AppFunctionCompatService

@MainThread
abstract suspend fun executeFunction(request: ExecuteAppFunctionRequest): ExecuteAppFunctionResponse

Called by the system to execute a specific app function.

This method is the entry point for handling all app function requests in an app. When the system needs your AppFunctionService to perform a function, it will invoke this method.

Each function you've registered is identified by a unique identifier. This identifier doesn't need to be globally unique, but it must be unique within your app. For example, a function to order food could be identified as "orderFood".

You can determine which function to execute by using ExecuteAppFunctionRequest.functionIdentifier. This allows your service to route the incoming request to the appropriate logic for handling the specific function.

This method is always triggered in the main thread. You should run heavy tasks on a worker thread.

Exception Handling

When an error occurs during execution, implementations have two options to report the failure:

1. Throw an appropriate androidx.appfunctions.AppFunctionException.

2. Return an ExecuteAppFunctionResponse.Error by wrapping an androidx.appfunctions.AppFunctionException.

This allows the agent to better understand the cause of the failure. For example, if an input argument is invalid, throw or wrap an androidx.appfunctions.AppFunctionInvalidArgumentException with a detailed message explaining why it is invalid.

Any unhandled exception other than androidx.appfunctions.AppFunctionException will be reported as androidx.appfunctions.AppFunctionAppUnknownException.

Cancellation

The agent app can cancel the execution of an app function at any time. When this happens, the coroutine executing this executeFunction will be cancelled. Implementations should handle the kotlinx.coroutines.CancellationException appropriately, for example, by ceasing any ongoing work and releasing resources.

@CallSuper
open fun onDestroy(): Unit

Implementing class can override this method to perform cleanup but should always call the superclass implementation.

final fun onExecuteFunction(
    request: ExecuteAppFunctionRequest,
    callingPackage: String,
    signingInfo: SigningInfo,
    cancellationSignal: CancellationSignal,
    callback: OutcomeReceiver<ExecuteAppFunctionResponse, AppFunctionException>
): Unit

Implements AppFunctionService.onExecuteFunction and delegates the execution to executeFunction when called by the system.