| /* |
| * Copyright (C) 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.systemui.controls.controller |
| |
| import android.content.ComponentName |
| import android.content.Context |
| import android.content.Intent |
| import android.content.ServiceConnection |
| import android.os.Binder |
| import android.os.Bundle |
| import android.os.IBinder |
| import android.os.RemoteException |
| import android.os.UserHandle |
| import android.service.controls.ControlsProviderService |
| import android.service.controls.ControlsProviderService.CALLBACK_BUNDLE |
| import android.service.controls.ControlsProviderService.CALLBACK_TOKEN |
| import android.service.controls.IControlsActionCallback |
| import android.service.controls.IControlsLoadCallback |
| import android.service.controls.IControlsProvider |
| import android.service.controls.IControlsSubscriber |
| import android.service.controls.IControlsSubscription |
| import android.service.controls.actions.ControlAction |
| import android.util.ArraySet |
| import android.util.Log |
| import com.android.internal.annotations.GuardedBy |
| import com.android.systemui.util.concurrency.DelayableExecutor |
| import java.util.concurrent.TimeUnit |
| |
| /** |
| * Manager for the lifecycle of the connection to a given [ControlsProviderService]. |
| * |
| * This class handles binding and unbinding and requests to the service. The class will queue |
| * requests until the service is connected and dispatch them then. |
| * |
| * @property context A SystemUI context for binding to the services |
| * @property executor A delayable executor for posting timeouts |
| * @property loadCallbackService a callback interface to hand the remote service for loading |
| * controls |
| * @property actionCallbackService a callback interface to hand the remote service for sending |
| * action responses |
| * @property subscriberService an "subscriber" interface for requesting and accepting updates for |
| * controls from the service. |
| * @property user the user for whose this service should be bound. |
| * @property componentName the name of the component for the service. |
| */ |
| class ControlsProviderLifecycleManager( |
| private val context: Context, |
| private val executor: DelayableExecutor, |
| private val loadCallbackService: IControlsLoadCallback.Stub, |
| private val actionCallbackService: IControlsActionCallback.Stub, |
| private val subscriberService: IControlsSubscriber.Stub, |
| val user: UserHandle, |
| val componentName: ComponentName |
| ) : IBinder.DeathRecipient { |
| |
| var lastLoadCallback: ControlsBindingController.LoadCallback? = null |
| private set |
| val token: IBinder = Binder() |
| @GuardedBy("subscriptions") |
| private val subscriptions = mutableListOf<IControlsSubscription>() |
| private var requiresBound = false |
| @GuardedBy("queuedMessages") |
| private val queuedMessages: MutableSet<Message> = ArraySet() |
| private var wrapper: ServiceWrapper? = null |
| private var bindTryCount = 0 |
| private val TAG = javaClass.simpleName |
| private var onLoadCanceller: Runnable? = null |
| |
| companion object { |
| private const val MSG_LOAD = 0 |
| private const val MSG_SUBSCRIBE = 1 |
| private const val MSG_ACTION = 2 |
| private const val MSG_UNBIND = 3 |
| private const val BIND_RETRY_DELAY = 1000L // ms |
| private const val LOAD_TIMEOUT = 5000L // ms |
| private const val MAX_BIND_RETRIES = 5 |
| private const val MAX_CONTROLS_REQUEST = 100000L |
| private const val DEBUG = true |
| private val BIND_FLAGS = Context.BIND_AUTO_CREATE or Context.BIND_FOREGROUND_SERVICE or |
| Context.BIND_WAIVE_PRIORITY |
| } |
| |
| private val intent = Intent().apply { |
| component = componentName |
| putExtra(CALLBACK_BUNDLE, Bundle().apply { |
| putBinder(CALLBACK_TOKEN, token) |
| }) |
| } |
| |
| private fun bindService(bind: Boolean) { |
| requiresBound = bind |
| if (bind) { |
| if (bindTryCount == MAX_BIND_RETRIES) { |
| return |
| } |
| if (DEBUG) { |
| Log.d(TAG, "Binding service $intent") |
| } |
| bindTryCount++ |
| try { |
| context.bindServiceAsUser(intent, serviceConnection, BIND_FLAGS, user) |
| } catch (e: SecurityException) { |
| Log.e(TAG, "Failed to bind to service", e) |
| } |
| } else { |
| if (DEBUG) { |
| Log.d(TAG, "Unbinding service $intent") |
| } |
| bindTryCount = 0 |
| wrapper?.run { |
| context.unbindService(serviceConnection) |
| } |
| wrapper = null |
| } |
| } |
| |
| private val serviceConnection = object : ServiceConnection { |
| override fun onServiceConnected(name: ComponentName, service: IBinder) { |
| if (DEBUG) Log.d(TAG, "onServiceConnected $name") |
| bindTryCount = 0 |
| wrapper = ServiceWrapper(IControlsProvider.Stub.asInterface(service)) |
| try { |
| service.linkToDeath(this@ControlsProviderLifecycleManager, 0) |
| } catch (_: RemoteException) {} |
| handlePendingMessages() |
| } |
| |
| override fun onServiceDisconnected(name: ComponentName?) { |
| if (DEBUG) Log.d(TAG, "onServiceDisconnected $name") |
| wrapper = null |
| bindService(false) |
| } |
| } |
| |
| private fun handlePendingMessages() { |
| val queue = synchronized(queuedMessages) { |
| ArraySet(queuedMessages).also { |
| queuedMessages.clear() |
| } |
| } |
| if (Message.Unbind in queue) { |
| bindService(false) |
| return |
| } |
| if (Message.Load in queue) { |
| load() |
| } |
| queue.filter { it is Message.Subscribe }.flatMap { (it as Message.Subscribe).list }.run { |
| if (this.isNotEmpty()) { |
| subscribe(this) |
| } |
| } |
| queue.filter { it is Message.Action }.forEach { |
| val msg = it as Message.Action |
| action(msg.id, msg.action) |
| } |
| } |
| |
| override fun binderDied() { |
| if (wrapper == null) return |
| wrapper = null |
| if (requiresBound) { |
| if (DEBUG) { |
| Log.d(TAG, "binderDied") |
| } |
| // Try rebinding some time later |
| } |
| } |
| |
| private fun queueMessage(message: Message) { |
| synchronized(queuedMessages) { |
| queuedMessages.add(message) |
| } |
| } |
| |
| private fun unqueueMessage(message: Message) { |
| synchronized(queuedMessages) { |
| queuedMessages.removeIf { it.type == message.type } |
| } |
| } |
| |
| private fun load() { |
| if (DEBUG) { |
| Log.d(TAG, "load $componentName") |
| } |
| if (!(wrapper?.load(loadCallbackService) ?: false)) { |
| queueMessage(Message.Load) |
| binderDied() |
| } |
| } |
| |
| private inline fun invokeOrQueue(f: () -> Unit, msg: Message) { |
| wrapper?.run { |
| f() |
| } ?: run { |
| queueMessage(msg) |
| bindService(true) |
| } |
| } |
| |
| /** |
| * Request a call to [ControlsProviderService.loadAvailableControls]. |
| * |
| * If the service is not bound, the call will be queued and the service will be bound first. |
| * The service will be bound after the controls are returned or the call times out. |
| * |
| * @param callback a callback in which to return the result back. If the call times out |
| * [ControlsBindingController.LoadCallback.error] will be called instead. |
| */ |
| fun maybeBindAndLoad(callback: ControlsBindingController.LoadCallback) { |
| unqueueMessage(Message.Unbind) |
| lastLoadCallback = callback |
| onLoadCanceller = executor.executeDelayed({ |
| // Didn't receive a response in time, log and send back error |
| Log.d(TAG, "Timeout waiting onLoad for $componentName") |
| callback.error("Timeout waiting onLoad") |
| // Don't accept load callbacks after this |
| lastLoadCallback = null |
| unbindService() |
| }, LOAD_TIMEOUT, TimeUnit.MILLISECONDS) |
| |
| invokeOrQueue(::load, Message.Load) |
| } |
| |
| /** |
| * Request a subscription to the [Publisher] returned by [ControlsProviderService.publisherFor] |
| * |
| * If the service is not bound, the call will be queued and the service will be bound first. |
| * |
| * @param controlIds a list of the ids of controls to send status back. |
| */ |
| fun maybeBindAndSubscribe(controlIds: List<String>) { |
| invokeOrQueue({ subscribe(controlIds) }, Message.Subscribe(controlIds)) |
| } |
| |
| private fun subscribe(controlIds: List<String>) { |
| if (DEBUG) { |
| Log.d(TAG, "subscribe $componentName - $controlIds") |
| } |
| if (!(wrapper?.subscribe(controlIds, subscriberService) ?: false)) { |
| queueMessage(Message.Subscribe(controlIds)) |
| binderDied() |
| } |
| } |
| |
| /** |
| * Request a call to [ControlsProviderService.performControlAction]. |
| * |
| * If the service is not bound, the call will be queued and the service will be bound first. |
| * |
| * @param controlId the id of the [Control] the action is performed on |
| * @param action the action performed |
| */ |
| fun maybeBindAndSendAction(controlId: String, action: ControlAction) { |
| invokeOrQueue({ action(controlId, action) }, Message.Action(controlId, action)) |
| } |
| |
| private fun action(controlId: String, action: ControlAction) { |
| if (DEBUG) { |
| Log.d(TAG, "onAction $componentName - $controlId") |
| } |
| if (!(wrapper?.action(controlId, action, actionCallbackService) ?: false)) { |
| queueMessage(Message.Action(controlId, action)) |
| binderDied() |
| } |
| } |
| |
| /** |
| * Starts the subscription to the [ControlsProviderService] and requests status of controls. |
| * |
| * @param subscription the subscriber to use to request controls |
| * @see maybeBindAndLoad |
| */ |
| fun startSubscription(subscription: IControlsSubscription) { |
| synchronized(subscriptions) { |
| subscriptions.add(subscription) |
| } |
| wrapper?.request(subscription, MAX_CONTROLS_REQUEST) |
| } |
| |
| /** |
| * Unsubscribe from this service, cancelling all status requests. |
| */ |
| fun unsubscribe() { |
| if (DEBUG) { |
| Log.d(TAG, "unsubscribe $componentName") |
| } |
| unqueueMessage(Message.Subscribe(emptyList())) // Removes all subscribe messages |
| |
| val subs = synchronized(subscriptions) { |
| ArrayList(subscriptions).also { |
| subscriptions.clear() |
| } |
| } |
| |
| subs.forEach { |
| wrapper?.cancel(it) |
| } |
| } |
| |
| /** |
| * Request bind to the service. |
| */ |
| fun bindService() { |
| unqueueMessage(Message.Unbind) |
| bindService(true) |
| } |
| |
| /** |
| * Request unbind from the service. |
| */ |
| fun unbindService() { |
| lastLoadCallback = null |
| onLoadCanceller?.run() |
| onLoadCanceller = null |
| |
| bindService(false) |
| } |
| |
| override fun toString(): String { |
| return StringBuilder("ControlsProviderLifecycleManager(").apply { |
| append("component=$componentName") |
| append(", user=$user") |
| append(")") |
| }.toString() |
| } |
| |
| /** |
| * Messages for the internal queue. |
| */ |
| sealed class Message { |
| abstract val type: Int |
| object Load : Message() { |
| override val type = MSG_LOAD |
| } |
| object Unbind : Message() { |
| override val type = MSG_UNBIND |
| } |
| class Subscribe(val list: List<String>) : Message() { |
| override val type = MSG_SUBSCRIBE |
| } |
| class Action(val id: String, val action: ControlAction) : Message() { |
| override val type = MSG_ACTION |
| } |
| } |
| } |