从实体按键看 Android 车载的自定义事件机制

在汽车数字化、智能化革新的进程中，越来越多的车机规划或部分、或悉数地舍弃了实体按键，进而把车主操作的进口搬运到了车机 UI 以及语音帮手。

但统一、高效的零层级 UI 颇为困难，语音的准确率、覆盖率亦不行完善，那么在当下的阶段适当地保留部分实体按键是比较明智的选择。

开发者都了解 Android 平台能够监听按键、屏幕触控、耳机插拔等硬件的事情来历，来获取用户输入，进而封装成 KeyEvent、MotionEvent 等各种事情类型，并发送到 System 或 App 来进一步处理。

其原理都是运用 InputManagerService 体系服务读取 EventHub 所对应的事情类型，依照对应的 Mapper 转化、Dispatcher 分发以及 Channel 传送等步骤来完结的。

而本次讨论的 Android 变体即 Automotive OS（简称 AAOS）作用在车载场景下，其需求更多、丰厚的事情需求，比方来自方控、中控等。

可其和 Android 规范的 Event 来历不同，方控等设备并不处于同一个体系当中，归于体系以外的 ECU 单元。那么怎么高效、方便地添加对这些体系以外的按键支撑和处理，显得十分必要。

这就要谈到 AAOS 里特有的车载事情定制 CustomInputService。

自界说按键的实战

AAOS 默许支撑的自界说事情 Code 坐落文件 hardware/interfaces/automotive/vehicle/2.0/types.hal 中，App 能够运用这些预设的事情 Code 进行监听和自界说处理逻辑。

当然，Car OEM 厂商能够运用任意有符号的 32 位数值来扩展支撑自界说输入 HW_CUSTOM_INPUT 的 CustomInputType 枚举规模，以支撑更多的按键 Code，保证处理的规模符合实际的车辆按键需求。

// hardware/interfaces/automotive/vehicle/2.0/types.hal
/**
 * Input code values for HW_CUSTOM_INPUT.
 */
enum CustomInputType : int32_t {
  CUSTOM_EVENT_F1 = 1001,
  CUSTOM_EVENT_F2 = 1002,
  CUSTOM_EVENT_F3 = 1003,
  CUSTOM_EVENT_F4 = 1004,
  CUSTOM_EVENT_F5 = 1005,
  CUSTOM_EVENT_F6 = 1006,
  CUSTOM_EVENT_F7 = 1007,
  CUSTOM_EVENT_F8 = 1008,
  CUSTOM_EVENT_F9 = 1009,
  CUSTOM_EVENT_F10 = 1010,
};

咱们运用上述 Code 来自界说一个打开高频 app 的专用控件，比方：接电话、挂电话、音量、语音、微信按钮、地图按钮、音乐控制等等。

官方的 DEMO 源码如下：

cs.android.com/android/pla…

实战的详细步骤来说，首要得声明特定权限，才干监听 Car 的自界说输入：

android.car.permission.CAR_MONITOR_INPUT

当然，假如涉及到向 Android 体系注入回规范 KeyEvent，还需求申明对应的注入权限：

android.permission.INJECT_EVENTS

全体的 Manifest 界说如下：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.android.car.custominput.sample">
​
  <uses-permission android:name="android.permission.INJECT_EVENTS" />
  <uses-permission android:name="android.car.permission.CAR_MONITOR_INPUT"/>
   ...
​
  <application>
    <service android:name=".SampleCustomInputService"
         android:exported="true" android:enabled="true">
       ...
    </service>
  </application>
</manifest>

1. onBind() 时候调用 connectToCarService() 创立 Car 实例、获取 CarInputManager、CustomInputEventListener 实例，并向 CarInputManager 供给的 requestInputEventCapture() 进行注册，并传递 INPUT_TYPE_CUSTOM_INPUT_EVENT 作为输入类型参数
2. onDestroy() 里释放关于该事情的监听
3. 复写 CarInputCaptureCallback 的 onCustomInputEvents() 办法，作为各事情的处理进口和机遇，回调理将供给事情所属的屏幕类型和事情类型，CustomInputEventListener 承载了详细的处理逻辑

// SampleCustomInputService.java
public class SampleCustomInputService extends Service implements
    CarInputManager.CarInputCaptureCallback {
  private Car mCar;
  private CarInputManager mCarInputManager;
  private CustomInputEventListener mEventHandler;
​
  @Override
  public IBinder onBind(Intent intent) {
    if (intent != null) {
      connectToCarService();
     }
    return null;
   }
​
  private void connectToCarService() {
    if (mCar != null && mCar.isConnected()) {
      return;
     }
​
    mCar = Car.createCar(this, /* handler= */ null, Car.CAR_WAIT_TIMEOUT_WAIT_FOREVER,
         (car, ready) -> {
          mCar = car;
          if (ready) {
            mCarInputManager =
                 (CarInputManager) mCar.getCarManager(Car.CAR_INPUT_SERVICE);
            mCarInputManager.requestInputEventCapture(
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN,
                new int[]{CarInputManager.INPUT_TYPE_CUSTOM_INPUT_EVENT},
                CarInputManager.CAPTURE_REQ_FLAGS_ALLOW_DELAYED_GRANT,
                /* callback= */ this);
            mEventHandler = new CustomInputEventListener(getApplicationContext(),
                 (CarAudioManager) mCar.getCarManager(Car.AUDIO_SERVICE),
                 (CarOccupantZoneManager) mCar.getCarManager(
                    Car.CAR_OCCUPANT_ZONE_SERVICE),
                this);
           }
         });
   }
​
  @Override
  public void onDestroy() {
    if (mCarInputManager != null) {
      mCarInputManager.releaseInputEventCapture(CarOccupantZoneManager.DISPLAY_TYPE_MAIN);
     }
    if (mCar != null) {
      mCar.disconnect();
      mCar = null;
     }
   }
​
  @Override
  public void onCustomInputEvents(int targetDisplayType,
      @NonNull List<CustomInputEvent> events) {
    for (CustomInputEvent event : events) {
      mEventHandler.handle(targetDisplayType, event);
     }
   }
   ...
}

CustomInputEventListener 的核心逻辑在于 handle()：

1. 首要调用 isValidTargetDisplayType() 验证屏幕类型，决议是否处理

2. 经过 getInputCode() 从 CustomInputEvent 中提取 KEY CODE

3. 依照预设的 Event 类型进行对应的处理，比方：

   • LAUNCH_MAPS_ACTION 的话，封装发动 Map App 的办法 launchMap()，留意需求根据起先的 DisplayType 获取目标屏幕的 ID：targetDisplayId 并传入
   • INJECT_VOICE_ASSIST_ACTION_DOWN 的话，标明是发动语音帮手按键的按下事情，注入 语音帮手的规范 KeyEvent 即 KEYCODE_VOICE_ASSIST 的 DOWN 事情
   • INJECT_VOICE_ASSIST_ACTION_UP 则是注入 KEYCODE_VOICE_ASSIST 的 UP 事情
   • 等

// CustomInputEventListener.java
public final class CustomInputEventListener {
  private final SampleCustomInputService mService;
   ...
​
  public @interface EventAction {
    /** Launches Map action. */
    int LAUNCH_MAPS_ACTION = 1001;
     ...
    /** Injects KEYCODE_VOICE_ASSIST (action down) key event */
    int INJECT_VOICE_ASSIST_ACTION_DOWN = 1009;
​
    /** Injects KEYCODE_VOICE_ASSIST (action up) key event */
    int INJECT_VOICE_ASSIST_ACTION_UP = 1010;
   }
​
  public CustomInputEventListener( ... ) {
    mContext = context;
     ...
   }
​
  public void handle(int targetDisplayType, CustomInputEvent event) {
    if (!isValidTargetDisplayType(targetDisplayType)) {
      return;
     }
    int targetDisplayId = getDisplayIdForDisplayType(targetDisplayType);
    @EventAction int action = event.getInputCode();
​
    switch (action) {
      case EventAction.LAUNCH_MAPS_ACTION:
        launchMap(targetDisplayId);
        break;
       ...
      case EventAction.INJECT_VOICE_ASSIST_ACTION_DOWN:
        injectKeyEvent(targetDisplayType,
            newKeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOICE_ASSIST));
        break;
      case EventAction.INJECT_VOICE_ASSIST_ACTION_UP:
        injectKeyEvent(targetDisplayType,
            newKeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_VOICE_ASSIST));
        break;
      default: Log.e(TAG, "Ignoring event [" + action + "]");
     }
   }
​
  private int getDisplayIdForDisplayType(int targetDisplayType) {
    int displayId = mCarOccupantZoneManager.getDisplayIdForDriver(targetDisplayType);
    return displayId;
   }
​
  private static boolean isValidTargetDisplayType(int displayType) {
    if (displayType == CarOccupantZoneManager.DISPLAY_TYPE_MAIN) {
      return true;
     }
    return false;
   }
​
  private void launchMap(int targetDisplayId) {
    ActivityOptions options = ActivityOptions.makeBasic();
    options.setLaunchDisplayId(targetDisplayId);
    Intent mapsIntent = new Intent(Intent.ACTION_VIEW);
    mapsIntent.setClassName(mContext.getString(R.string.maps_app_package),
        mContext.getString(R.string.maps_activity_class));
    mapsIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
    mService.startActivity(mapsIntent, options.toBundle());
   }
   ...
​
  private KeyEvent newKeyEvent(int action, int keyCode) {
    long currentTime = SystemClock.uptimeMillis();
    return new KeyEvent(/* downTime= */ currentTime, /* eventTime= */ currentTime,
        action, keyCode, /* repeat= */ 0);
   }
​
  private void injectKeyEvent(int targetDisplayType, KeyEvent event) {
    mService.injectKeyEvent(event, targetDisplayType);
   }
}

KeyEvent 的注入还需求回到自界说 CustomInputService 中，之后是调用 CarInputManager 将 Event 进一步注入。

将在下个章节论述 CarInputManager 的进一步处理。

// SampleCustomInputService.java
public class SampleCustomInputService extends Service implements
    CarInputManager.CarInputCaptureCallback {
   ...
  public void injectKeyEvent(KeyEvent event, int targetDisplayType) {
    if (mCarInputManager == null) {
      throw new IllegalStateException(
          "Service was properly initialized, reference to CarInputManager is null");
     }
    mCarInputManager.injectKeyEvent(event, targetDisplayType);
   }
}

需求该 Service 收效的话，需求运用如下指令发动 Service，依照逻辑向体系注册事情监听。

adb shell am start-foreground-service com.android.car.custominput.sample/.SampleCustomInputService

接下来按压硬件的按键，或者像下面相同模仿按键的输入，比方下面模仿 1001 发动 Map 的按键按下：

adb shell cmd car_service inject-custom-input -d 0 f1

其他几个和上述逻辑相应的事情模仿指令：

adb shell cmd car_service inject-custom-input f2 // accept incoming calls
adb shell cmd car_service inject-custom-input f3 // reject incoming calls
adb shell cmd car_service inject-custom-input f4 // To increase media volume
adb shell cmd car_service inject-custom-input f5 // To decrease media volume
adb shell cmd car_service inject-custom-input f6 // To increase alarm volume
adb shell cmd car_service inject-custom-input f7 // To decrease alarm volume
adb shell cmd car_service inject-custom-input f8 // To simulate pressing BACK HOME button

体系的默许处理

以上述的 KEYCODE_VOICE_ASSIST 为例，看一下 CarInputManager 的进一步处理怎么。

对应的在 CarInputService 中：

1. 首要，injectKeyEvent() 将先查看注入方的相关权限：INJECT_EVENTS
2. 接着，调用 onKeyEvent() 执行事情的后续处理

// packages/services/Car/service/src/com/android/car/CarInputService.java
public class CarInputService ... {
   ...
  @Override
  public void injectKeyEvent(KeyEvent event, @DisplayTypeEnum int targetDisplayType) {
    // Permission check
    if (PackageManager.PERMISSION_GRANTED != mContext.checkCallingOrSelfPermission(
        android.Manifest.permission.INJECT_EVENTS)) {
      throw new SecurityException("Injecting KeyEvent requires INJECT_EVENTS permission");
     }
​
    long token = Binder.clearCallingIdentity();
    try {
      // Redirect event to onKeyEvent
      onKeyEvent(event, targetDisplayType);
     } finally {
      Binder.restoreCallingIdentity(token);
     }
   }
}

注入的事情类型为 KEYCODE_VOICE_ASSIST 的话，交给 handleVoiceAssistKey() 处理。

• 当 action 尚为 DOWN 机遇，交给 VoiceKeyTimer 的 keyDown() 开端计时

• 当 action 为 UP 机遇：经过 Timer 的 keyUp() 获取是否达到长按（长按时长默许是 400ms，能够在 SettingsProvider 中改写）条件，并调用 dispatchProjectionKeyEvent() 发送相应的事情：

  • 短按处理 KEY_EVENT_VOICE_SEARCH_SHORT_PRESS_KEY_UP
  • 反之，发送 KEY_EVENT_VOICE_SEARCH_LONG_PRESS_KEY_UP
  • 假如 dispatchProjectionKeyEvent() 没没有拦截处理，执行默许逻辑： launchDefaultVoiceAssistantHandler()

// packages/services/Car/service/src/com/android/car/CarInputService.java
public class CarInputService ... {
   ...
  @Override
  public void onKeyEvent(KeyEvent event, @DisplayTypeEnum int targetDisplayType) {
    switch (event.getKeyCode()) {
      case KeyEvent.KEYCODE_VOICE_ASSIST:
        handleVoiceAssistKey(event);
        return;
       ...
      default:
        break;
     }
     ...
   }
​
  private void handleVoiceAssistKey(KeyEvent event) {
    int action = event.getAction();
    if (action == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
      mVoiceKeyTimer.keyDown();
      dispatchProjectionKeyEvent(CarProjectionManager.KEY_EVENT_VOICE_SEARCH_KEY_DOWN);
     } else if (action == KeyEvent.ACTION_UP) {
      if (mVoiceKeyTimer.keyUp()) {
        dispatchProjectionKeyEvent(
            CarProjectionManager.KEY_EVENT_VOICE_SEARCH_LONG_PRESS_KEY_UP);
        return;
       }
​
      if (dispatchProjectionKeyEvent(
          CarProjectionManager.KEY_EVENT_VOICE_SEARCH_SHORT_PRESS_KEY_UP)) {
        return;
       }
​
      launchDefaultVoiceAssistantHandler();
     }
   }
​
  private void launchDefaultVoiceAssistantHandler() {
    if (!AssistUtilsHelper.showPushToTalkSessionForActiveService(mContext, mShowCallback)) {
      Slogf.w(TAG, "Unable to retrieve assist component for current user");
     }
   }
}

CarProjectionManager 是允许 App 向体系注册/注销某些事情处理的机制。

CarProjectionManager allows applications implementing projection to register/unregister itself with projection manager, listen for voice notification.

dispatchProjectionKeyEvent() 则将上述的短按、长按事情发送给 App 经过 CarProjectionManager 向其注册的 ProjectionKeyEventHandler 处理。

// packages/services/Car/service/src/com/android/car/CarInputService.java
public class CarInputService ... {
   ...
  private boolean dispatchProjectionKeyEvent(@CarProjectionManager.KeyEventNum int event) {
    CarProjectionManager.ProjectionKeyEventHandler projectionKeyEventHandler;
    synchronized (mLock) {
      projectionKeyEventHandler = mProjectionKeyEventHandler;
      if (projectionKeyEventHandler == null || !mProjectionKeyEventsSubscribed.get(event)) {
        return false;
       }
     }
​
    projectionKeyEventHandler.onKeyEvent(event);
    return true;
   }
}
​
// packages/services/Car/service/src/com/android/car/CarProjectionService.java
class CarProjectionService ... {
  @Override
  public void onKeyEvent(@CarProjectionManager.KeyEventNum int keyEvent) {
    Slogf.d(TAG, "Dispatching key event: " + keyEvent);
    synchronized (mLock) {
      for (BinderInterfaceContainer.BinderInterface<ICarProjectionKeyEventHandler>
          eventHandlerInterface : mKeyEventHandlers.getInterfaces()) {
        ProjectionKeyEventHandler eventHandler =
             (ProjectionKeyEventHandler) eventHandlerInterface;
​
        if (eventHandler.canHandleEvent(keyEvent)) {
          try {
            // oneway
            eventHandler.binderInterface.onKeyEvent(keyEvent);
           } catch (RemoteException e) {
            Slogf.e(TAG, "Cannot dispatch event to client", e);
           }
         }
       }
     }
   }
   ...
}

假使没有 App 注册或者消费了 VOICE_SEARCH 的短按/长按事情，则调用默许的 launchDefaultVoiceAssistantHandler() 经过 Assist 相关的协助类 AssistUtilsHelper 持续。

public final class AssistUtilsHelper {
   ...
  public static boolean showPushToTalkSessionForActiveService( ... ) {
    AssistUtils assistUtils = getAssistUtils(context);
     ...
    Bundle args = new Bundle();
    args.putBoolean(EXTRA_CAR_PUSH_TO_TALK, true);
​
    IVoiceInteractionSessionShowCallback callbackWrapper =
        new InternalVoiceInteractionSessionShowCallback(callback);
​
    return assistUtils.showSessionForActiveService(args, SHOW_SOURCE_PUSH_TO_TALK,
        callbackWrapper, /* activityToken= */ null);
   }
   ...
}

默许的语音帮手的发动是经过 Android 规范的 VoiceInteraction 链路完结，所以后续的处理是经过 showSessionForActiveService() 交由专门管理 VoiceInteraction 的 VoiceInteractionManagerService 体系服务来完结。

public class AssistUtils {
   ...
  public boolean showSessionForActiveService(Bundle args, int sourceFlags,
      IVoiceInteractionSessionShowCallback showCallback, IBinder activityToken) {
    try {
      if (mVoiceInteractionManagerService != null) {
        return mVoiceInteractionManagerService.showSessionForActiveService(args,
            sourceFlags, showCallback, activityToken);
       }
     } catch (RemoteException e) {
      Log.w(TAG, "Failed to call showSessionForActiveService", e);
     }
    return false;
   }
   ...
}

详细的是找到默许的数字帮手 DigitalAssitant app 的 VoiceInteractionService 进行绑定和发动对应的 Session。

public class VoiceInteractionManagerService extends SystemService {
  class VoiceInteractionManagerServiceStub extends IVoiceInteractionManagerService.Stub {
    public boolean showSessionForActiveService( ... ) {
         ...
        final long caller = Binder.clearCallingIdentity();
        try {
           ...
          return mImpl.showSessionLocked(args,
              sourceFlags
                  | VoiceInteractionSession.SHOW_WITH_ASSIST
                  | VoiceInteractionSession.SHOW_WITH_SCREENSHOT,
              showCallback, activityToken);
         } finally {
          Binder.restoreCallingIdentity(caller);
         }
       }
     }
     ...
   }
   ...
}  

对 VoiceInteraction 细节感兴趣的能够参考其他文章：

• 怎么打造车载语音交互：Google Voice Interaction 给你答案

自界说按键的来历

按键的信号输入来自于 ECU，其与 AAOS 的 Hal 依照界说监听 HW_CUSTOM_INPUT 输入事情的 property 改变，来自于上述提及的 types.hal 中界说的支撑自界说输入事情 Code 发送到 Car Service 层。

Car Service App 的 VehicleHal 将在 onPropertyEvent() 中接收到 HAL service 的 property 发生改变。接着，订阅了 HW_CUSTOM_INPUT property 改变的 InputHalService 的 onHalEvents() 将被调用。

之后交由 CarInputService 处理，因其在 init() 时将自己作为 InputListener 的实现传递给了 InputHalService 持有。

处理自界说输入的 App 在调用 requestInputEventCapture() 时的 Callback 将被管理在 InputCaptureClientController 中的 SparseArray 里。

天然的 CarInputService 的 onCustomInputEvent() 需求将事情交给 InputCaptureClientController 来进一步分发。

public class CarInputService ... {
   ...
  @Override
  public void onCustomInputEvent(CustomInputEvent event) {
    if (!mCaptureController.onCustomInputEvent(event)) {
      return;
     }
   }
}

InputCaptureClientController 将从 SparseArray 中获取对应的 Callback 并回调 onCustomInputEvents()。

public class InputCaptureClientController {
   ...
  public boolean onCustomInputEvent(CustomInputEvent event) {
    int displayType = event.getTargetDisplayType();
    if (!SUPPORTED_DISPLAY_TYPES.contains(displayType)) {
      return false;
     }
    ICarInputCallback callback;
    synchronized (mLock) {
      callback = getClientForInputTypeLocked(displayType,
          CarInputManager.INPUT_TYPE_CUSTOM_INPUT_EVENT);
      if (callback == null) {
        return false;
       }
     }
    dispatchCustomInputEvent(displayType, event, callback);
    return true;
   }
​
  private void dispatchCustomInputEvent(@DisplayTypeEnum int targetDisplayType,
      CustomInputEvent event,
      ICarInputCallback callback) {
    CarServiceUtils.runOnCommon(() -> {
      mCustomInputEventDispatchScratchList.clear();
      mCustomInputEventDispatchScratchList.add(event);
      try {
        callback.onCustomInputEvents(targetDisplayType,
            mCustomInputEventDispatchScratchList);
       } ...
     });
   }
}

尔后便抵达了 上个实战章节实现的 SampleCustomInputService 中的 onCustomInputEvents()。

模仿调试

在漫长的 HMI 实验台架、实车准备就绪之前，往往需求开发者提早验证链路的可行性，这时候就怎么模仿这些自界说事情的注入就显得十分需求。

咱们知道自界说实体按键的输入并不归于 EventHub 领域，那么传统的 getevent、dumpsys input 也就无法监听到该事情的输入，天然也就无法运用 adb 的 input 和 sendevent 指令来反向注入，正如实战章节说到的那样，咱们能够运用 Car 专用的 adb 指令来达到意图。

adb shell cmd car_service inject-custom-input <custom key code>
# or
adb shell cmd car_service inject-key <key code>

前者模仿的是自界说事情的注入，后者则是针对 Android 规范事情。

当然假如需求区别按键的短按和长按事情，需求像上面的案例相同供给针对 DOWN 和 UP 的两种 Code，那么模仿的时候也要模仿按键之间的时长。

adb shell cmd car_service inject-custom-input <custom key code for down>; sleep 0.2; adb shell cmd car_service inject-custom-input <custome key code for up>

别的要留意，虽然都归归于 Android platform，但有些规范 KeyEvent 的模仿能够被 AAOS 所处理，而有些却不支撑呢？

比方运用如下的指令模仿宣布音量 mute Keycode，体系能完结静音，但运用同样指令形式的音量的 +/-，体系则无反应。

adb shell input keyevent <key code number or name>
adb shell sendevent [device] [type] [code] [value]

这是因为部分 AAOS 的 OEM 实现里可能删除了部分规范 KeyEvent 的处理，而改部分的规范 Event 处理挪到了 Car Input 中统一处理了，所以需求运用上述的 car_service 对应的 inject-custom-input 才行。

结语

让咱们再从全体上看下自界说按键事情的分发和处理过程：

假如自界说的按键数量不多，能够运用 AAOS 预置的 F1～F10。反之，能够采用任意有符号的 32 位数值来扩展自界说输入的规模。

当不用区别某种事情的短按、长按逻辑，运用一种 Code 映射即可，由 CustomInputService 直接执行。比方监控方控上的“通话”和“完毕通话”实体按键：

• 当没有来电时，按下方向盘上的“通话”按钮会发送 DIAL intent 并显示拨号器的拨号键盘页面
• 当有来电时，按下方向盘上的“通话”按钮会使 TelecomManager 接听来电
• 当有来电时，按下方向盘上的“完毕通话”按钮会使 TelecomManager 挂断电话

而当需求区别长、短按的时候，需求配置两种 Code 和 DOWN 及 UP 进行对应，由 CustomInputService 或 转发送给 CarInputService 依照 DOWN 和 UP 的时间距离决议触发短按仍是长按逻辑。

从悠远的未来来讲，实体按键的交互方式肯定会消亡，取而代之的是手势、语音、眼睛等更直接、丰厚的方式。

但正如前言讲的，在现阶段适当地保留高频的实体按键，和车机的数字化、智能化之间并不冲突，车机的智能化不等于粗犷地扔掉实体按键等传统规划。

并且需求留神的一点是：假如车机交互做得不行好，还执意取消了实体键，那真是本末倒置了。

引荐阅读

• 怎么打造车载语音交互：Google Voice Interaction 给你答案
• Android 车机初体验：Auto，Automotive 傻傻分不清楚？

参考文档

• developer.android.google.cn/training/ca…
• source.android.google.cn/docs/device…
• cs.android.com/android/pla…