Google setzt sich dafür ein, die Rassengerechtigkeit für schwarze Gemeinschaften zu fördern. Siehe wie.
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Kombiinstrument

Verwenden Sie die Kombiinstrument-API (eine Android-API), um Navigations-Apps, einschließlich Google Maps, auf einer sekundären Anzeige in einem Auto anzuzeigen, z. B. hinter dem Lenkrad auf der Instrumententafel. In diesem Artikel wird beschrieben, wie Sie einen Dienst erstellen, um diese sekundäre Anzeige zu steuern und den Dienst dann in CarService zu integrieren, damit Navigations-Apps eine Benutzeroberfläche anzeigen können.

Terminologie

Die folgenden Begriffe werden in diesem Artikel verwendet:

Begriff Beschreibung
CarInstrumentClusterManager Ein CarManager, mit dem externe Apps eine Aktivität im Kombiinstrument starten und Rückrufe empfangen können, wenn das Kombiinstrument bereit ist, Aktivitäten anzuzeigen.
CarManager Basisklasse aller Manager, die von externen Apps zur Interaktion mit von CarService implementierten fahrzeugspezifischen Diensten verwendet werden.
Autowerkstatt Android Platform-Dienst, der die Kommunikation zwischen externen Apps (einschließlich Google Maps) und autospezifischen Funktionen wie dem Zugriff auf Kombiinstrumente ermöglicht.
Ziel Das endgültige Ziel, zu dem das Fahrzeug navigieren wird.
ETA Voraussichtliche Ankunftszeit am Zielort.
Head Unit (HU) Primäre Recheneinheit in ein Auto eingebettet. Die HU führt den gesamten Android-Code aus und ist mit dem zentralen Display im Auto verbunden.
Kombiinstrument Sekundäranzeige hinter dem Lenkrad und zwischen den Fahrzeuginstrumenten. Dies kann eine unabhängige Recheneinheit sein, die über das interne Netzwerk (CAN-Bus) des Fahrzeugs mit der HU verbunden ist, oder eine an die HU angeschlossene sekundäre Anzeige.
InstrumentClusterRenderingService Basisklasse für den Dienst, der für die Schnittstelle zur Anzeige des Kombiinstruments verwendet wird. OEMs müssen eine Erweiterung dieser Klasse bereitstellen, die mit der OEM-spezifischen Hardware interagiert.
KitchenSink App Testanwendung in Android Automotive enthalten.
Route Ein bestimmter Pfad, auf dem ein Fahrzeug navigiert, um ein Ziel zu erreichen.
Singleton-Service Ein Android-Dienst mit dem Attribut android:singleUser . Zu jedem Zeitpunkt wird höchstens eine Instanz des Dienstes auf dem Android-System ausgeführt.

Voraussetzungen

Stellen Sie zur Entwicklung der Integration folgende Elemente sicher:

  • Android-Entwicklungsumgebung. Informationen zum Einrichten der Android-Entwicklungsumgebung finden Sie unter Build-Anforderungen .
  • Laden Sie den Android-Quellcode herunter. Die neueste Version des Android-Quellcodes erhalten Sie im Zweig pi-car-release (oder höher) unter https://android.googlesource.com .
  • Haupteinheit (HU). Ein Android-Gerät, auf dem Android 9 (oder höher) ausgeführt werden kann. Dieses Gerät muss über ein eigenes Display verfügen und in der Lage sein, das Display mit neuen Android-Versionen zu blinken.
  • Das Kombiinstrument ist eines der folgenden:
    • An die HU angeschlossene physische Sekundäranzeige. Wenn die Gerätehardware und der Kernel die Verwaltung mehrerer Anzeigen unterstützen.
    • Unabhängige Einheit. Jede Recheneinheit, die über eine Netzwerkverbindung mit der HU verbunden ist und einen Videostream auf einem eigenen Display empfangen und anzeigen kann.
    • Emulierte Anzeige. Während der Entwicklung können Sie eine dieser emulierten Umgebungen verwenden:
      • Simulierte Sekundäranzeigen. Um eine simulierte sekundäre Anzeige auf einer beliebigen AOSP Android-Distribution zu aktivieren, gehen Sie zu den Einstellungen für Entwickleroptionen in der Systemanwendung Einstellungen und wählen Sie dann sekundäre Anzeigen simulieren aus. Diese Konfiguration entspricht dem Anschließen einer physischen sekundären Anzeige, mit der Einschränkung, dass diese Anzeige der primären Anzeige überlagert ist.
      • Emuliertes Kombiinstrument. Der in Android Automotive enthaltene Android-Emulator bietet die Möglichkeit, ein Kombiinstrument mit _qemu-pipes des Android-Emulators anzuzeigen . Verwenden Sie die Implementierung des DirectRenderingClusterSample- Referenzinstrumentenclusters, um eine Verbindung zu dieser emulierten externen Anzeige herzustellen .

Integrationsarchitektur

Integrationskomponenten

Eine Integration der Kombiinstrument-API besteht aus diesen drei Komponenten:

  • Autowerkstatt
  • Navigations-Apps.
  • OEM-Kombiinstrument-Service

Integrationskomponenten

Autowerkstatt

CarService vermittelt zwischen Navigations-Apps und dem Auto und stellt sicher, dass jeweils nur eine Navigations-App aktiv ist und nur Apps mit der Berechtigung android.car.permission.CAR_INSTRUMENT_CLUSTER_CONTROL Daten an das Auto senden können.

CarService bootet alle fahrzeugspezifischen Dienste und bietet über eine Reihe von Managern Zugriff auf diese Dienste. Um mit den Diensten zu interagieren, können im Auto ausgeführte Anwendungen auf diese Manager zugreifen.

Für die Implementierung von Kombiinstrumenten müssen Automobilhersteller eine benutzerdefinierte Implementierung von InstrumentClusterRendererService erstellen und die Datei config.xml aktualisieren, um auf diese angepasste Implementierung zu verweisen.

Beim Rendern eines Kombiinstruments liest der CarService während des Startvorgangs den InstrumentClusterRendererService-Schlüssel der Datei config.xml , um eine Implementierung von InstrumentClusterService zu finden. In AOSP verweist dieser Eintrag auf den Renderdienst der Beispielclusterimplementierung für die Navigationsstatus-API:

<string name="instrumentClusterRendererService">
android.car.cluster/.ClusterRenderingService
</string>

Der in diesem Eintrag genannte Dienst wird initialisiert und an CarService gebunden. Wenn Navigations-Apps wie Google Maps einen CarInstrumentClusterManager anfordern, stellt CarService einen Manager zur Verfügung, der den Status des Kombiinstruments über den gebundenen InstrumentClusterRenderingService aktualisiert. (In diesem Fall bezieht sich gebunden auf Android-Dienste .)

Kombiinstrument-Service

OEMs müssen ein Android PacKage (APK) erstellen, das eine Unterklasse von InstrumentClusterRendererService enthält . Ein Beispiel finden Sie unter ClusterRenderingService .

Diese Klasse dient zwei Zwecken:

  • Bietet eine Schnittstelle zwischen Android und dem Kombiinstrument-Rendering-Gerät (der Zweck dieses Dokuments).
  • Empfängt und rendert Navigationsstatusaktualisierungen, z. B. Navigationsanleitungen für Turn-by-Turn.

Zum ersten Zweck müssen OEM-Implementierungen von InstrumentClusterRendererService die sekundäre Anzeige initialisieren, die zum Rendern von Informationen auf Bildschirmen in der Fahrzeugkabine verwendet wird, und diese Informationen an CarService übermitteln, indem sie die Methoden InstrumentClusterRendererService.setClusterActivityOptions() und InstrumentClusterRendererService.setClusterActivityState() aufrufen.

Für die zweite Funktion muss das Instrument Clusterdienst eine Implementierung der liefern NavigationRenderer Schnittstelle , die Navigationsstatusaktualisierungsereignisse empfängt, die als ein eventtype und Ereignisdaten codiert in einem Bündel codiert werden.

Integrationssequenz

Das folgende Diagramm zeigt die Implementierung eines Navigationsstatus, der Aktualisierungen darstellt:

Integrationssequenz

Legende:

  • Gelb. CarService und CarNavigationStatusManager werden von der Android-Plattform bereitgestellt.
  • Cyan. InstrumentClusterRendererService vom OEM implementiert.
  • Lila. Die Navigations-App, die von Google und Drittentwicklern implementiert wurde.
  • Grün. CarAppFocusManager.

Der Informationsfluss zum Navigationsstatus folgt dieser Reihenfolge:

  1. CarService initialisiert den InstrumentClusterRenderingService.
  2. Während der Initialisierung aktualisiert der InstrumentClusterRenderingService CarService mit:
    1. Anzeigeeigenschaften des Kombiinstruments, z. B. nicht sichtbare Grenzen (weitere Details zu nicht sichtbaren Grenzen finden Sie später).
    2. Aktivitätsoptionen, die zum Starten von Aktivitäten in der Kombiinstrument-Anzeige erforderlich sind (weitere Informationen finden Sie unter ActivityOptions .
  3. Eine Navigations-App (z. B. Google Maps für Android Automotive oder eine Karten-App mit den erforderlichen Berechtigungen):
    1. Ruft einen CarAppFocusManager mit der Car-Klasse von car-lib ab.
    2. Rufen CarAppFocusManager.requestFocus() Beginn der Turn-by-Turn-Anweisungen CarAppFocusManager.requestFocus() auf, um CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION als appType Parameter zu übergeben.
  4. CarAppFocusManager übermittelt diese Anforderung an CarService. Wenn dies gewährt wird, überprüft CarService das Navigations-App-Paket und sucht eine Aktivität, die mit der Kategorie android.car.cluster.NAVIGATION .
  5. Wenn gefunden, verwendet die Navigations-App die vom InstrumentClusterRenderingService gemeldeten ActivityOptions, um die Aktivität zu starten, und nimmt die Anzeigeeigenschaften des Kombiinstruments als Extras in die Absicht auf.

API integrieren

Die Implementierung von InstrumentClusterRenderingService muss:

  • Sie können als Singleton-Dienst festgelegt werden, indem Sie der AndroidManifest.xml den folgenden Wert hinzufügen. Dies ist erforderlich, um sicherzustellen, dass eine einzelne Kopie des Kombiinstrument-Dienstes auch während der Initialisierung und des Benutzerwechsels ausgeführt wird:
    android:singleUser="true"
  • Halten Sie die BIND_INSTRUMENT_CLUSTER_RENDERER_SERVICE . Dies garantiert, dass nur der als Teil des Android-Systemabbilds enthaltene Kombiinstrument-Rendering-Service jemals an den CarService gebunden ist.
    <uses-permission android:name="android.car.permission.BIND_INSTRUMENT_CLUSTER_RENDERER_SERVICE"/>

Implementieren von InstrumentClusterRenderingService

So erstellen Sie den Dienst:

  1. Schreiben Sie eine Klasse, die sich von InstrumentClusterRenderingService aus erstreckt, und fügen Sie Ihrer AndroidManifest.xml-Datei einen entsprechenden Eintrag hinzu. Diese Klasse steuert die Anzeige des Kombiinstruments und kann ( optional ) Navigationsstatus-API-Daten rendern.
  2. Verwenden Sie diesen Dienst während onCreate (), um die Kommunikation mit der Rendering-Hardware zu initialisieren. Zu den Optionen gehören:
    • Bestimmen Sie die sekundäre Anzeige, die für das Kombiinstrument verwendet werden soll.
    • Erstellen Sie eine virtuelle Anzeige, damit die Kombiinstrument-App das gerenderte Bild rendert und an eine externe Einheit überträgt (unter Verwendung eines Video-Streaming-Formats wie H.264).
  3. Wenn die oben angegebene Anzeige bereit ist, muss dieser Dienst InstrumentClusterRenderingService # setClusterActivityLaunchOptions () aufrufen, um die genauen ActivityOptions zu definieren, die zum Anzeigen einer Aktivität im Kombiinstrument verwendet werden müssen. Verwenden Sie diese Parameter:
    • Kategorie. CarInstrumentClusterManager # CATEGORY_NAVIGATION
    • ActivityOptions. Eine ActivityOptions-Instanz, mit der eine Aktivität im Kombiinstrument gestartet werden kann. Beispiel aus der Beispielimplementierung des Kombiinstruments auf AOSP:
      getService().setClusterActivityLaunchOptions(
         CATEGORY_NAVIGATION,
         ActivityOptions.makeBasic()
            .setLaunchDisplayId(displayId));
      
    • Wenn das Kombiinstrument bereit ist, Aktivitäten anzuzeigen, muss dieser Dienst Folgendes aufrufen:
      InstrumentClusterRenderingService#setClusterActivityState() .

      Verwenden Sie diese Parameter:
      • Kategorie. CarInstrumentClusterManager # CATEGORY_NAVIGATION
      • Zustand. Mit ClusterActivityState generiertes Bundle . Sie müssen folgende Daten angeben:
        • sichtbar. Gibt das Kombiinstrument als sichtbar und zur Anzeige von Inhalten bereit an.
        • ungehinderte Grenzen. Ein Rechteck, das den Bereich innerhalb der Kombiinstrument-Anzeige definiert, in dem Inhalte sicher angezeigt werden können. Zum Beispiel Bereiche, die von Zifferblättern und Messgeräten abgedeckt werden.
    • Überschreiben Sie die Service#dump() -Methode und melden Sie Statusinformationen, die für das Debuggen nützlich sind (weitere Informationen finden Sie unter dumpsys ).

Beispiel für eine Implementierung von InstrumentClusterRenderingService

Das folgende Beispiel beschreibt eine InstrumentClusterRenderingService-Implementierung, die ein VirtualDisplay erstellt, um den Inhalt des Kombiinstruments auf einer physischen Remote-Anzeige darzustellen.

Alternativ könnte dieser Code, wie oben erwähnt, alternativ die displayId einer physischen sekundären Anzeige übergeben, die mit der HU verbunden ist, wenn bekannt ist, dass eine verfügbar ist.

/**
* Sample {@link InstrumentClusterRenderingService} implementation
*/
public class SampleClusterServiceImpl extends InstrumentClusterRenderingService {
   // Used to retrieve or create displays
   private final DisplayManager mDisplayManager;
   // Unique identifier for the display that will be used for instrument
   // cluster
   private final String mUniqueId = UUID.randomUUID().toString();
   // Format of the instrument cluster display
   private static final int DISPLAY_WIDTH = 1280;
   private static final int DISPLAY_HEIGHT = 720;
   private static final int DISPLAY_DPI = 320;
   // Area not covered by instruments
   private static final int DISPLAY_UNOBSCURED_LEFT = 40;
   private static final int DISPLAY_UNOBSCURED_TOP = 0;
   private static final int DISPLAY_UNOBSCURED_RIGHT = 1200;
   private static final int DISPLAY_UNOBSCURED_BOTTOM = 680;
   @Override
   public void onCreate() {
      super.onCreate();
      // Create a virtual display to render instrument cluster activities on
      mDisplayManager = getSystemService(DisplayManager.class);
      VirtualDisplay display = mDisplayManager.createVirtualDisplay(
          mUniqueId, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_DPI, null,
          0 /* flags */, null, null);
      // Do any additional initialization (e.g.: start a video stream
      // based on this virtual display to present activities on a remote
      // display).
      onDisplayReady(display.getDisplay());
}
private void onDisplayReady(Display display) {
    // Report activity options that should be used to launch activities on
    // the instrument cluster.
    String category = CarInstrumentClusterManager.CATEGORY_NAVIGATION;
    ActionOptions options = ActivityOptions.makeBasic()
        .setLaunchDisplayId(display.getDisplayId());
    setClusterActivityOptions(category, options);
    // Report instrument cluster state.
    Rect unobscuredBounds = new Rect(DISPLAY_UNOBSCURED_LEFT,
        DISPLAY_UNOBSCURED_TOP, DISPLAY_UNOBSCURED_RIGHT,
        DISPLAY_UNOBSCURED_BOTTOM);
    boolean visible = true;
    ClusterActivityState state = ClusterActivityState.create(visible,
       unobscuredBounds);
    setClusterActivityState(category, options);
  }
}

Anhang: Verwenden der Beispielanwendung

AOSP bietet eine Beispielanwendung, die die Navigationsstatus-API implementiert.

So führen Sie diese Beispielanwendung aus:

  1. Erstellen und flashen Sie Android Auto auf einer unterstützten HU. Verwenden Sie die für Ihr Gerät spezifischen Anweisungen zum Erstellen und Flashen von Android. Anweisungen finden Sie unter Verwenden von Referenzkarten .
  2. Schließen Sie eine physische sekundäre Anzeige an die HU an (falls unterstützt) oder schalten Sie die virtuelle sekundäre HU ein:
    1. Wählen Sie in der App Einstellungen den Entwicklermodus .
    2. Gehen Sie zu Einstellungen> System> Erweitert> Entwickleroptionen> Sekundäre Anzeigen simulieren .
  3. Starten Sie die HU neu. Der ClusterRenderingService- Dienst ist mit der sekundären Anzeige verbunden.
  4. So starten Sie die KitchenSink-App:
    1. Öffnen Sie die Schublade.
    2. Gehe zu Inst. Cluster .
    3. Klicken Sie auf METADATEN STARTEN .

KitchenSink fordert den NAVIGATION-Fokus an, der den DirectRenderingCluster-Dienst anweist, eine nachgebildete Benutzeroberfläche im Kombiinstrument anzuzeigen.