AlexaAutoSDK供汽车原始设备制造商将Alexa直接集成.zip

# Alexa Auto Client Service (AACS) ## Overview Alexa Auto Client Service (AACS) is an Alexa Auto SDK feature packaged in an Android archive library (AAR). By providing a common service framework, AACS simplifies the integration of the Auto SDK with your Android device and supports all the Auto SDK extensions. Your application communicates with AACS through an intent, which is a messaging object on an Android device. AACS provides the platform implementation for certain interfaces, which speeds up Alexa integration for in-vehicle infotainment (IVI). Without AACS, typical integration of the Auto SDK in the IVI involves the implementation of abstract interfaces provided by each Auto SDK module to handle platform-specific functionality. To implement all required platform interfaces, the Auto SDK is integrated to an event-based system that converts from direct method APIs to an event-based architecture. This document assumes that you understand how the Auto SDK works, as described in the [Auto SDK concepts documentation](https://alexa.github.io/alexa-auto-sdk/docs/explore/concepts). When this document uses the term "application," it refers to the application you develop on the Android platform. Information for your application in this document also applies to your Android service. ## AACS Architecture The following diagram shows the high-level architecture of AACS on the Android platform. The shaded boxes in the diagram represent components developed by Amazon that are packaged in AACS.  The following list describes the components in the AACS service layer, as illustrated in the diagram, and how they interact with one another and with the Auto SDK: 1. **AlexaAutoClientService** is a persistent service that can start automatically after device boot-up or be manually started by an application through a `startService()` call. The service performs the following functions: * Instantiating the Auto SDK Engine. * Creating and registering the AASB message handler with the AASB MessageBroker. * Setting the required Engine configuration. * Managing the notifications displayed in the system notification area. 2. **PhoneControlMessagingImpl** and **NavigationMessagingImpl** are messaging implementations that serialize direct API calls into a standardized message format. The `PhoneControlMessagingImpl` or `NavigationMessagingImpl` converts platform interface method parameters into the message payload of the respective messaging implementation. The message is then sent to the service layer by using the AASB `MessageBroker` with a specific message topic and action. The messaging implementation also subscribes to message topics that are sent from the human-machine interface (HMI) application to the Auto SDK. 3. **AudioInputImpl**, **AudioOutputImpl**, **ExternalMediaPlayerImpl**, and **AdditionalPlatformImpl** are the direct implementations of Auto SDK platform interfaces. You can enable or disable the implementations in the AACS AAR through the configuration file. If an implementation is disabled, the platform message handler must be provided by a client application. 4. **AASB MessageBroker** is an abstraction built on top of the Auto SDK core. `MessageBroker` routes messages between the application and the Auto SDK core. When the application responds to `MessageBroker` with an event, the event is routed back through the platform interface implementation. 5. **AASB MessageHandler** implements the platform-specific logic to send and receive AASB messages. 6. **Mediaplayer** handles the default AudioOutput actions, such as prepare, play, and pause for a TTS channel. 7. **IPCLibrary** defines the protocol for the communication between the HMI application and AACS. It provides the APIs for sending and receiving AASB Messages over the Android Intent/Binder interface and supports streaming audio data to and from an external application. It builds into an Android archive (AAR) file, which you can include in other apps that need to communicate with AACS. For more information about the IPC, see this [README](common/ipc/README.md). 8. **LVCInteractionProvider** implements APIs defined by the `ILVCClient` Android Interface Definition Language (AIDL) file to connect with `ILVCService`, which is implemented by the Local Voice Control (LVC) application. This connection also enables the LVC APK to provide the configuration for LVC. 9. The core of the **HMI application** that holds the business logic need not change with `AlexaAutoClientService`. However, you must modify the application so that it can interface with the APIs defined by AACS. ### AACS as Foreground Service or System Service AACS runs as a started service on Android. The [Initialization](#initialization) section describes how it is started; this section describes what you do to run AACS as a foreground service or a system service. #### As Foreground Service Typically, AACS is started as a foreground service, which has higher priority and continues running unless it is under memory constraints. In addition, the service displays notifications to alert the user that it is running. AACS is run as a foreground service if your application containg AACS AAR is not a system application. Then your application can use the `startForegroundService()` function to initialize AACS. If AACS is started properly, a notification is displayed. Since Android 8.0 (API level 26), foreground services have had some changes in how they are initialized. The following code checks the Android version and calls the correct API: ~~~ Intent intentStartService = new Intent(); intentStartService.setComponent(new ComponentName(AACSConstants.getAACSPackageName(new WeakReference<Context>(context)), "com.amazon.alexaautoclientservice.AlexaAutoClientService")); intentStartService.setAction(Action.LAUNCH_SERVICE); if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) { startForegroundService(intent); } else { startService(intent); } ~~~ #### As Persistent System Service If you have root access on the device and your application containing AACS AAR is a system application, then AACS is run as a system service. Your application no longer needs to start AACS in the foreground, and no notifications appear to show that the service is running. The following example shows an application starting AACS as a system service: ~~~ Intent intentStartService = new Intent(); intentStartService.setComponent(new ComponentName(AACSConstants.getAACSPackageName(new WeakReference<Context>(context)), "com.amazon.alexaautoclientservice.AlexaAutoClientService")); intentStartService.setAction(Action.LAUNCH_SERVICE); startService(intent); ~~~ Note: persistentSystemService configuration is deprecated. You no longer need to specify this field to run AACS as a persistent system service. ### AACS Initialization and Configuration Initializing AACS means getting AACS ready to communicate with other applications. However, Alexa functionality is not available until AACS receives the configuration. #### Initialization There are two ways to initialize AACS: * Start AACS from an application: AACS includes a permission that determines whether an application can start or stop the service. For an application to start or stop AACS, specify the permission name in the application's `AndroidManifest.xml` file as follows: `<uses-permission android:name="com.amazon.alexaautoclientservice"/>` For an example of starting AACS from an application, see [example for starting AACS as a system service](#as-persistent-system-service). * Start AACS upon device boot: If you want AACS to start every time the user turns on the device, set `startOnDeviceBootEnabled` in `aacs.general` of your configuration to `true`. Due to this setting, AACS initiates a `startService()` call on itself when it receives the `BOOT_COMPLETED` intent, which the device broadcasts when it is finished