基于Android推荐架构的WearOS后台服务实现问题咨询

1. 服务初始化与Composable启停实现 #

不要通过Activity传递Service实例，而是将服务的启停逻辑封装在TimerViewModel中，让UI（Composable）只与ViewModel交互：

• ViewModel中管理服务绑定与状态：利用AndroidViewModel的Application Context，实现ServiceConnection处理服务绑定回调，通过StateFlow向Composable暴露服务的运行状态（断开/已连接/正在采集）。
• Composable仅触发命令：在Composable中调用ViewModel提供的startMonitoring()/stopMonitoring()方法，通过collectAsState()监听状态变化，更新按钮文本与行为。
• 自动恢复连接：ViewModel初始化时检查服务是否正在运行，若已运行则自动绑定，避免应用重启后手动触发连接。

核心代码示例：

TimerViewModel 改造 #

class TimerViewModel(application: Application) : AndroidViewModel(application) {
    private val _serviceState = MutableStateFlow<ServiceState>(ServiceState.Disconnected)
    val serviceState = _serviceState.asStateFlow()

    private val serviceConnection = object : ServiceConnection {
        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            val binder = service as MonitoringService.MonitoringBinder
            val monitoringService = binder.getService()
            // 同步服务的采集状态
            viewModelScope.launch {
                monitoringService.isCollectingFlow.collect { isCollecting ->
                    _serviceState.value = if (isCollecting) ServiceState.Running else ServiceState.Connected
                }
            }
            _serviceState.value = ServiceState.Connected
        }

        override fun onServiceDisconnected(className: ComponentName) {
            _serviceState.value = ServiceState.Disconnected
        }
    }

    init {
        // 启动时检查服务状态，自动绑定
        if (isServiceRunning()) bindService()
    }

    fun startMonitoring() {
        val intent = Intent(getApplication(), MonitoringService::class.java)
        // 启动前台服务（WearOS后台限制要求）
        getApplication().startForegroundService(intent)
        bindService()
    }

    fun stopMonitoring() {
        val intent = Intent(getApplication(), MonitoringService::class.java)
        getApplication().stopService(intent)
        _serviceState.value = ServiceState.Disconnected
    }

    private fun bindService() {
        val intent = Intent(getApplication(), MonitoringService::class.java)
        getApplication().bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
    }

    // 检查服务是否在运行
    private fun isServiceRunning(): Boolean {
        val manager = getApplication().getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        return manager.getRunningServices(Int.MAX_VALUE).any {
            it.service.className == MonitoringService::class.java.name
        }
    }

    override fun onCleared() {
        super.onCleared()
        getApplication().unbindService(serviceConnection)
    }

    sealed class ServiceState {
        object Disconnected : ServiceState()
        object Connected : ServiceState()
        object Running : ServiceState()
    }
}

MonitoringService 改造 #

class MonitoringService : Service() {
    private val binder = MonitoringBinder()
    private val _isCollecting = MutableStateFlow(false)
    val isCollectingFlow = _isCollecting.asStateFlow()

    inner class MonitoringBinder : Binder() {
        fun getService(): MonitoringService = this@MonitoringService
    }

    override fun onBind(intent: Intent): IBinder = binder

    override fun onCreate() {
        super.onCreate()
        // 必须启动前台服务，否则WearOS会快速回收后台服务
        val notification = NotificationCompat.Builder(this, "health_monitoring_channel")
            .setContentTitle("健康数据采集")
            .setContentText("正在采集心率、体温等数据")
            .setSmallIcon(R.drawable.ic_notification)
            .build()
        startForeground(1, notification)
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        _isCollecting.value = true
        startSensorCollection() // 启动传感器采集逻辑
        return START_STICKY // 服务被系统杀死后尝试自动重启
    }

    override fun onDestroy() {
        super.onDestroy()
        _isCollecting.value = false
        stopSensorCollection() // 释放传感器资源
    }

    private fun startSensorCollection() {
        // 初始化心率、体温、加速度传感器的采集逻辑
    }

    private fun stopSensorCollection() {
        // 停止采集并释放传感器资源
    }
}

Composable 调用 #

@Composable
fun TimerScreen(viewModel: TimerViewModel = viewModel()) {
    val serviceState by viewModel.serviceState.collectAsState()

    Column(
        modifier = Modifier.fillMaxSize(),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Button(
            onClick = {
                when (serviceState) {
                    TimerViewModel.ServiceState.Disconnected,
                    TimerViewModel.ServiceState.Connected -> viewModel.startMonitoring()
                    TimerViewModel.ServiceState.Running -> viewModel.stopMonitoring()
                }
            }
        ) {
            Text(
                text = when (serviceState) {
                    TimerViewModel.ServiceState.Disconnected -> "启动采集"
                    TimerViewModel.ServiceState.Connected -> "开始采集"
                    TimerViewModel.ServiceState.Running -> "停止采集"
                }
            )
        }
    }
}

2. MVVM架构下使用Service的最佳实践 #

• UI与服务完全解耦：Composable只关注状态展示和命令触发，所有服务操作通过ViewModel中转，禁止UI直接持有Service实例。
• 前台服务强制化：WearOS对后台服务限制极严，涉及健康传感器的服务必须调用startForeground()显示通知，同时申请FOREGROUND_SERVICE_HEALTH权限。
• 状态驱动而非实例传递：用StateFlow/LiveData传递服务的运行状态，而非直接传递Service对象，避免内存泄漏、实例失效等问题。
• ViewModel管理连接生命周期：将ServiceConnection放在ViewModel中，利用AndroidViewModel的生命周期（与Application绑定），避免Activity重建时重复绑定或丢失连接。
• 服务重启策略：设置onStartCommand返回START_STICKY，让服务被系统杀死后尝试自动重启，保证采集连续性。
• 异常处理：在onServiceDisconnected中更新状态为断开，必要时触发重新绑定逻辑。

解决偶尔无法连接的问题 #

当前问题根源是Activity传递Service实例的方式不可靠：应用重启时Activity重建，之前的实例已失效，且绑定过程异步导致实例未及时传递。通过上述ViewModel管理绑定的方式，结合以下两点可彻底解决：

1. 启动时检查服务运行状态，自动绑定；
2. 服务返回稳定的Binder实例（如示例中使用内部类Binder，每次绑定返回同一个实例）。

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