从通知启动子Activity：音乐播放器Activity与Service绑定场景技术咨询

针对你描述的音乐播放器架构，要实现从通知启动Activity B并保持绑定逻辑的一致性，核心要处理任务栈管理、Service绑定状态切换和返回逻辑对齐这几个关键点，下面是具体的实现步骤：

1. 配置通知的PendingIntent，确保正确的任务栈 #

首先，Service创建通知时，要给PendingIntent设置正确的启动参数，保证启动B时能关联到A的任务栈，并且返回时能回到A（即使A之前被销毁）。这里用TaskStackBuilder来构建包含父Activity的任务栈：

// 在Service中创建通知的PendingIntent
val intent = Intent(this, ActivityB::class.java)
val stackBuilder = TaskStackBuilder.create(this)
// 添加父Activity到任务栈
stackBuilder.addParentStack(ActivityB::class.java)
stackBuilder.addNextIntent(intent)
// 获取包含任务栈的PendingIntent
val pendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)

// 构建通知
val notification = NotificationCompat.Builder(this, CHANNEL_ID)
    .setContentTitle("当前播放")
    .setContentText("歌曲名称")
    .setSmallIcon(R.drawable.ic_notification)
    .setContentIntent(pendingIntent)
    .build()

startForeground(NOTIFICATION_ID, notification)

同时要在AndroidManifest.xml中声明Activity B的父Activity：

<activity
    android:name=".ActivityB"
    android:parentActivityName=".ActivityA">
    <meta-data
        android:name="android.support.PARENT_ACTIVITY"
        android:value=".ActivityA" />
</activity>

2. 处理Activity B启动时的Service绑定逻辑 #

当从通知启动B时，需要先检查Activity A是否处于活跃状态，如果存在则让A解绑Service，再让B绑定。这里推荐两种实现方式：

方式一：通过Application维护全局弱引用 #

在自定义Application类中用弱引用保存Activity A的实例（避免内存泄漏）：

class MyApp : Application() {
    var activityA: WeakReference<ActivityA>? = null

    override fun onCreate() {
        super.onCreate()
    }
}

然后在Activity A的生命周期中更新引用：

class ActivityA : AppCompatActivity() {
    var isBound = false
    private lateinit var serviceConnection: ServiceConnection

    override fun onResume() {
        super.onResume()
        (application as MyApp).activityA = WeakReference(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        (application as MyApp).activityA = null
    }

    // 对外暴露解绑Service的方法
    fun unbindMusicService() {
        if (isBound) {
            unbindService(serviceConnection)
            isBound = false
        }
    }
}

在Activity B的onCreate()中处理绑定逻辑：

class ActivityB : AppCompatActivity() {
    private var isBound = false
    private lateinit var serviceConnection: ServiceConnection

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_b)

        // 先检查Activity A是否存在，存在则让其解绑
        val app = application as MyApp
        app.activityA?.get()?.let {
            it.unbindMusicService()
        }

        // 绑定Service
        serviceConnection = object : ServiceConnection {
            override fun onServiceConnected(name: ComponentName, service: IBinder) {
                // 处理Service绑定成功逻辑
                isBound = true
            }

            override fun onServiceDisconnected(name: ComponentName) {
                isBound = false
            }
        }
        Intent(this, MusicService::class.java).also { intent ->
            bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
        }
    }
}

方式二：使用广播实现无引用通信 #

如果不想维护全局实例，可以用广播来通知A解绑：
在Activity B启动时发送解绑广播：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_b)

    // 发送广播通知A解绑
    sendBroadcast(Intent("ACTION_UNBIND_MUSIC_SERVICE"))

    // 绑定Service逻辑...
}

Activity A中注册广播接收解绑指令：

private val unbindReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        unbindMusicService()
    }
}

override fun onResume() {
    super.onResume()
    registerReceiver(unbindReceiver, IntentFilter("ACTION_UNBIND_MUSIC_SERVICE"))
}

override fun onPause() {
    super.onPause()
    unregisterReceiver(unbindReceiver)
}

3. 处理返回键的反向绑定逻辑 #

当从B按返回键回到A时，需要B解绑Service，同时A重新绑定。可以在Activity B的onBackPressed()中处理：

override fun onBackPressed() {
    // 先解绑Service
    if (isBound) {
        unbindService(serviceConnection)
        isBound = false
    }
    // 发送广播通知A重新绑定
    sendBroadcast(Intent("ACTION_BIND_MUSIC_SERVICE"))
    super.onBackPressed()
}

然后在Activity A中注册广播接收绑定指令：

private val bindReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        // 重新绑定Service
        Intent(this@ActivityA, MusicService::class.java).also { intent ->
            bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
            isBound = true
        }
    }
}

override fun onResume() {
    super.onResume()
    registerReceiver(bindReceiver, IntentFilter("ACTION_BIND_MUSIC_SERVICE"))
}

override fun onPause() {
    super.onPause()
    unregisterReceiver(bindReceiver)
}

4. 确保Service的前台稳定性 #

因为你的Service负责创建通知，一定要用startForegroundService()启动Service，并在onCreate()中调用startForeground()，这样即使所有Activity解绑，Service也会因为前台状态保持运行，不会被系统杀死：

class MusicService : Service() {
    override fun onCreate() {
        super.onCreate()
        // 创建通知并启动前台服务
        createNotification()
        startForeground(NOTIFICATION_ID, notification)
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        return START_STICKY
    }

    // ...其他Service逻辑
}

关键注意事项 #

• 避免内存泄漏：优先用弱引用或广播这种无强引用的通信方式，不要直接持有Activity实例。
• PendingIntent的flags：Android 12+必须添加FLAG_IMMUTABLE，FLAG_UPDATE_CURRENT确保更新Intent内容。
• 任务栈一致性：通过TaskStackBuilder和Manifest父Activity声明，保证从通知启动B后，返回键能正确回到A，不会创建多个实例。

内容的提问来源于stack exchange，提问作者Emilian Cebuc