@siteed/expo-audio-studio 2.1.1

package/android/src/main/java/net/siteed/audiostream/AudioRecordingService.kt

@@ -0,0 +1,166 @@
+package net.siteed.audiostream
+
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import android.os.Handler
+import android.os.Looper
+import expo.modules.kotlin.Promise
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import androidx.core.app.NotificationCompat
+
+class AudioRecordingService : Service() {
+    private val notificationManager by lazy {
+        AudioNotificationManager.getInstance(applicationContext)
+    }
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var isRunning = false
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        Log.d(Constants.TAG, "AudioRecordingService onCreate")
+        isRunning = true
+        setServiceRunning(true)
+        
+        // Start foreground immediately in onCreate to prevent timing issues
+        startForegroundWithNotification()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        Log.d(Constants.TAG, "AudioRecordingService onStartCommand")
+        return START_STICKY
+    }
+
+    private fun startForegroundWithNotification() {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                // Create a minimal notification channel if needed
+                val channel = NotificationChannel(
+                    "recording_service",
+                    "Recording Service",
+                    NotificationManager.IMPORTANCE_LOW
+                ).apply {
+                    setSound(null, null)
+                    enableLights(false)
+                    enableVibration(false)
+                }
+                val notificationManager = getSystemService(NotificationManager::class.java)
+                notificationManager.createNotificationChannel(channel)
+                
+                // Create minimal silent notification with minimal text
+                val notification = NotificationCompat.Builder(this, "recording_service")
+                    .setContentTitle(" ")  // Space character instead of empty string
+                    .setContentText(" ")   // Space character instead of empty string
+                    .setSmallIcon(R.drawable.ic_microphone)
+                    .setOngoing(true)
+                    .setSound(null)
+                    .setVibrate(null)
+                    .setDefaults(0)
+                    .setPriority(NotificationCompat.PRIORITY_LOW)
+                    .build()
+                
+                startForeground(1, notification)
+                Log.d(Constants.TAG, "Started foreground service with minimal notification")
+            }
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Failed to start foreground service: ${e.message}", e)
+        }
+    }
+
+    override fun onDestroy() {
+        Log.d(Constants.TAG, "AudioRecordingService onDestroy")
+
+        try {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Error stopping foreground service: ${e.message}", e)
+        }
+
+        isRunning = false
+        setServiceRunning(false)
+        super.onDestroy()
+    }
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        super.onTaskRemoved(rootIntent)
+        Log.d(Constants.TAG, "AudioRecordingService onTaskRemoved")
+        
+        // Stop recording when app is killed
+        AudioRecorderManager.getInstance()?.let { manager ->
+            mainHandler.post {
+                // Create a simple promise object for internal use
+                val promise = object : Promise {
+                    override fun resolve(value: Any?) {
+                        Log.d(Constants.TAG, "Successfully stopped recording on task removed")
+                        cleanup()
+                    }
+                    override fun reject(code: String, message: String?, cause: Throwable?) {
+                        Log.e(Constants.TAG, "Failed to stop recording on task removed: $message")
+                        cleanup()
+                    }
+                }
+
+                try {
+                    manager.stopRecording(promise)
+                } catch (e: Exception) {
+                    promise.reject("ERROR", e.message, e)
+                }
+            }
+        }
+    }
+
+    
+    private fun cleanup() {
+        try {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Error stopping foreground in cleanup: ${e.message}", e)
+        }
+        stopSelf()
+    }
+
+    companion object {
+        // Static flag to track if service is running
+        private var isServiceRunningStatic = false
+
+        fun isServiceRunning(): Boolean {
+            return isServiceRunningStatic
+        }
+
+        fun setServiceRunning(running: Boolean) {
+            isServiceRunningStatic = running
+        }
+
+        fun startService(context: Context) {
+            try {
+                val serviceIntent = Intent(context, AudioRecordingService::class.java)
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    context.startForegroundService(serviceIntent)
+                    Log.d(Constants.TAG, "Started foreground service")
+                } else {
+                    context.startService(serviceIntent)
+                    Log.d(Constants.TAG, "Started regular service")
+                }
+                setServiceRunning(true)
+            } catch (e: Exception) {
+                Log.e(Constants.TAG, "Failed to start service: ${e.message}", e)
+            }
+        }
+
+        fun stopService(context: Context) {
+            try {
+                context.stopService(Intent(context, AudioRecordingService::class.java))
+                setServiceRunning(false)
+                Log.d(Constants.TAG, "Stopped service")
+            } catch (e: Exception) {
+                Log.e(Constants.TAG, "Failed to stop service: ${e.message}", e)
+            }
+        }
+    }
+}