Activity 销毁后使用 startForeground 服务不保留

Question

Currently, I need a bound (Music)Service, because I need to interact with it. But I also want it to not be stopped, even when all components have unbound themselves.

My service code:

class ServicePlayer : LifecycleService() {
            
        var mediaPlayer: MediaPlayer? = null
        var notificationManager: NotificationManager? = null
        var notificationBuilder: NotificationCompat.Builder? = null
        private val mBinder: IBinder = PlayerBinder()
        private val NOTIFICATION_ID = 1111
  
    
        override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
            super.onStartCommand(intent, flags, startId)
            return START_REDELIVER_INTENT
        }
    
        inner class PlayerBinder : Binder() {
            val service: ServicePlayer
                get() = this@ServicePlayer
        }
    
        override fun onBind(intent: Intent): IBinder? {
            super.onBind(intent)
            return mBinder
        }
    
        override fun onCreate() {
            super.onCreate()
           
            mediaPlayer = MediaPlayer()
            mediaPlayer!!.setOnCompletionListener(this)
            mediaPlayer!!.setOnBufferingUpdateListener(this)
            mediaPlayer!!.setOnErrorListener(this)
            val filter = IntentFilter()
            filter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED)
            filter.addAction(Intent.ACTION_SCREEN_ON)
            registerReceiver(receiver, filter)
        }
    
    
        override fun onDestroy() {
    
            super.onDestroy()
            mediaPlayer!!.reset()
            mediaPlayer!!.release()
            Log.i("DESTROY SERVICE", "destroy")
            unregisterReceiver(receiver)
        }
    
    
    
        fun play(trackIndex: Int, tracks: ArrayList<Track>?) {
            
                    ...
                    
                    val intent = Intent(BUFFERING)
                    this@ServicePlayer.sendBroadcast(intent)
             
        }
    
        fun pause() {
                if (mediaPlayer!!.isPlaying) {
                    mediaPlayer!!.pause()
                    PlayerLiveData.isPlaying.value = false
                    val intent = Intent(UPDATE_UI)
                    this@ServicePlayer.sendBroadcast(intent)
                    
                    //Show notification
                    CoroutineScope(Dispatchers.Default).launch {
                        showNotification()
                    }
                }
        }
        
        
        private fun hideNotification() {
            notificationManager!!.cancel(NOTIFICATION_ID)
            stopForeground(true)
        }
        
        
        private fun showNotification() {
            notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

                ...
    
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                val CHANNEL_ID = "controls_channel_id"
                val CHANNEL_NAME = "Play tracks"
                val channel = NotificationChannel(CHANNEL_ID,CHANNEL_NAME, NotificationManager.IMPORTANCE_LOW)
                ...
                
                val mMediaSession = MediaSessionCompat(applicationContext, getString(R.string.app_name))
                mMediaSession.setFlags(
                        MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS or
                                MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS
                )
                notificationManager!!.createNotificationChannel(channel)
                notificationBuilder = NotificationCompat.Builder(applicationContext)
                        .setChannelId(CHANNEL_ID)
                        .setContentText(artistText)
                        .setContentTitle(track.title)
                       
                       ...
            } else {
                notificationBuilder = NotificationCompat.Builder(applicationContext)

                ...

                notificationBuilder!!
                        .setSmallIcon(R.drawable.ic_notification)
                        .setContentIntent(contentIntent)
                        .setCustomContentView(remoteSmallViews)
                        .setCustomBigContentView(remoteViews)
            }
    
    
            CoroutineScope(Dispatchers.Default).launch {
                val notification = notificationBuilder!!.build()
                startForeground(NOTIFICATION_ID, notification)
                val notificationTarget = NotificationTarget(
                        applicationContext
                        , R.id.imgThumb, remoteViews
                        , notification, NOTIFICATION_ID
                )
                ...
                    lifecycleScope.launch {
                        val request = ImageRequest.Builder(applicationContext)
                                .data(thumb)
                                .error(R.drawable.placeholder_song)
                                .placeholder(R.drawable.placeholder_song)
                                .build()
                        val drawable = imageLoader.execute(request).drawable
                        val bitmap = (drawable as BitmapDrawable).bitmap
    
    
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                        
                        
                            notificationBuilder!!.setLargeIcon(bitmap)
                            val notification = notificationBuilder!!.build()
                            notificationManager!!.notify(NOTIFICATION_ID,notification)
                            
                            
                            //Start Foreground service
                            startForeground(NOTIFICATION_ID, notification)
                            
                            
                        } 
                    }
            }
    
        }      
    }

Manifest file declaration:

<service android:name=".services.ServicePlayer" android:enabled="true" android:exported="true"/>

Using service in activity

class MainActivity : AppCompatActivity() {

    lateinit var binding: MainActivityBinding

    private lateinit var audioPlayerService: ServicePlayer
    
     override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val intent = Intent(this, ServicePlayer::class.java)
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)

        binding = DataBindingUtil.setContentView(this, R.layout.main_activity)
        binding.lifecycleOwner = this
        binding.viewmodel = mainViewModel
    }
    
    
       private val serviceConnection: ServiceConnection = object : ServiceConnection {
        override fun onServiceDisconnected(name: ComponentName) {
            // audioPlayerService = null;
        }

        override fun onServiceConnected(name: ComponentName, service: IBinder) {
            audioPlayerService = (service as ServicePlayer.PlayerBinder).service
            if (audioPlayerService.trackIndex !== -1) {
                //updatePlaybackUI()
            }
        }
    }
    
}

How can I keep my service running in background even after activity destroyed. I refer few threads of StackOverflow but they are not helpful.

Answer 1

1. Use Service instead LifecycleService as parent class.

2. Add partial wake lock start and stop calls to onCreate and onDestroy methods respectively.

    private val powerManager get() = (this.getSystemService(Context.POWER_SERVICE) as PowerManager) private var wakeLock: PowerManager.WakeLock? = null private fun startWakeLock() { if (wakeLock == null) { wakeLock = powerManager.newWakeLock( PowerManager.PARTIAL_WAKE_LOCK, "${packageName}:wakeLock" ) wakeLock?.acquire() } } private fun stopWakeLock() { if (wakeLock?.isHeld == true) { wakeLock?.release() wakeLock = null } }

3. Add the following tag to service at mainfest

android:foregroundServiceType="mediaPlayback"

4. You should start service as foreground from the activity

Answer 2

A bound service stops once every client unbinds from it, and that happens automatically when the client (your Activity ) is destroyed

If your client is still bound to a service when your app destroys the client, destruction causes the client to unbind. It is better practice to unbind the client as soon as it is done interacting with the service. Doing so allows the idle service to shut down.

If you want the service to just keep running, a Started Service will do that. You can still bind to it, but it won't stop until you explicitly tell it to stop and there are no clients bound.

---

Honestly though, if you're making some kind of media player, you'll probably want to use the MediaBrowserServiceCompat framework. It allows you to create a service that plays nice with MediaBrowser (which does the binding, among other things) and lets you use a MediaSession to get a media notification with controls and all that.

A few links about that stuff:

• MediaBrowserServiceCompat and the modern media playback app by Ian Lake from the Android team
• Background Audio in Android With MediaSessionCompat - Java but gets into a lot of the nonsense you'll have to wrangle
• Developer docs about building media apps - a few sections here and it's all kinda spread out, I feel like the other links give a better overview

If you don't care about any of that then startService / startForegroundService (or ContextCompat#startForegroundService ) will get you a service that just runs, but those links might give you some pointers about stuff