Utilizzare la libreria di app di Android for Cars

La raccolta di app Android for Cars ti consente di visualizzare la navigazione, il punto d'interesse (PDI) e la connessione Internet delle cose (IOT) le app all'auto. Lo fa fornendo un insieme di modelli progettati per soddisfare gli standard di distrazione del conducente e prendendosi cura di dettagli come la varietà di fattori dello schermo dell'auto e le modalità di inserimento.

Questa guida fornisce una panoramica delle funzionalità e dei concetti principali della libreria. ti guida nella procedura di configurazione di un'app di base.

Codelab

Impara le nozioni di base della Raccolta di app per auto

arrow_forward

Prima di iniziare

1. Rivedi la progettazione per la guida pagine relative alla Raccolta di app per auto
   • App di navigazione e Altre app correlate alla guida panoramiche delle categorie
   • Panoramica sulla creazione di app con modelli
   • Componenti di base che illustra i modelli e i componenti dei modelli
   • Flussi di esempio dimostrazione di pattern UX comuni
   • Requisiti delle app basate su modelli
2. Esamina i termini e concetti chiave nel seguente articolo .
3. Acquisisci familiarità con il sistema Android Auto UI e Android Automotive OS la progettazione.
4. Consulta le Note di rilascio.
5. Esamina gli esempi.

Termini e concetti chiave

Modelli e modelli

L'interfaccia utente è rappresentata da un grafico di oggetti modello che possono essere disposti in modo diverso, come consentito dal modello a cui appartengono a. I modelli sono un sottoinsieme dei modelli che possono fungere da radice grafici. I modelli includono le informazioni da mostrare all'utente sotto forma di testo e immagini, nonché gli attributi per configurare aspetti dell'aspetto visivo di queste informazioni, ad esempio i colori del testo o le dimensioni delle immagini. L'host converte i modelli in visualizzazioni progettate per soddisfare gli standard di distrazione del conducente e si occupa di dettagli come la varietà di fattori dello schermo dell'auto e le modalità di input.

Moderatore

L'host è il componente di backend che implementa la funzionalità offerta dalle API della libreria in modo che l'app possa essere eseguita in auto. La le responsabilità dell'host variano, ad esempio scoprire l'app e gestire il suo ciclo di vita, fino alla conversione dei modelli in visualizzazioni e all'invio di notifiche all'app delle interazioni degli utenti. Sui dispositivi mobili, questo host è implementato da Android Automatico. Su Android Automotive OS, questo host è installato come app di sistema.

Limitazioni dei modelli

Modelli diversi applicano limitazioni ai contenuti dei modelli. Ad esempio, i modelli di elenco hanno limiti al numero di elementi che possono essere presentati all'utente. I modelli hanno anche limitazioni nel modo in cui possono essere collegati per formare il flusso di un'attività. Ad esempio, l'app può eseguire solo fino a cinque modelli. Per ulteriori dettagli, consulta la sezione Limitazioni dei modelli.

Screen

Screen è una classe fornita dalla biblioteca che le app implementano per gestire l'interfaccia utente presentata all'utente. Un Screen ha un ciclo di vita e fornisce il meccanismo per l'app per inviare il modello da visualizzare quando lo schermo è visibile. Le istanze Screen possono anche essere spostate in un stack Screen e viceversa, il che garantisce che rispettino le limitazioni del flusso dei modelli.

CarAppService

CarAppService è un classe Service astratta che la tua app devono implementare ed esportare per essere rilevati e gestiti dall'host. Il CarAppService della tua app è responsabile di verificare che una connessione all'host sia attendibile utilizzando createHostValidator e successivamente di fornire istanze Session per ogni connessione utilizzando onCreateSession.

Session

Session è una classe astratta l'app deve implementare e restituire utilizzando CarAppService.onCreateSession. Funge da punto di accesso per visualizzare le informazioni sullo schermo dell'auto. Ha un ciclo di vita che indica lo stato corrente dell'app sullo schermo dell'auto, ad esempio quando è visibile o nascosta.

Quando viene avviata una Session, ad esempio Quando l'app viene avviata per la prima volta, l'host richiede il Screen da visualizzare utilizzando onCreateScreen: .

Installare la libreria di app per auto

Visita la libreria Jetpack pagina di rilascio per istruzioni su come aggiungere la raccolta alla tua app.

Configura i file manifest dell'app

Per poter creare un'app per auto, devi prima configurare il file manifest come segue.

Dichiara il tuo servizio CarAppService

L'host si connette alla tua app tramite l'implementazione di CarAppService. Dichiari questo servizio nel file manifest per consentire all'host di scoprire e connettersi alla tua app.

Devi anche dichiarare la categoria della tua app nel L'elemento <category> dell'app filtro per intent. Consulta l'elenco di categorie di app supportate per i valori consentiti per questo elemento.

Il seguente snippet di codice mostra come dichiarare un servizio di app per auto per un punto di l'app di interesse nel manifest:

<application>
    ...
   <service
       ...
        android:name=".MyCarAppService"
        android:exported="true">
      <intent-filter>
        <action android:name="androidx.car.app.CarAppService"/>
        <category android:name="androidx.car.app.category.POI"/>
      </intent-filter>
    </service>

    ...
<application>

Categorie di app supportate

Dichiara la categoria della tua app aggiungendo uno o più dei seguenti valori di categoria nel filtro per intent quando dichiari CarAppService come descritto nella sezione precedente:

• androidx.car.app.category.NAVIGATION: un'app che fornisce indicazioni passo passo le indicazioni stradali di navigazione. Consulta Creare app di navigazione per le auto per ulteriori informazioni su questa categoria.
• androidx.car.app.category.POI: un'app che offre funzionalità pertinenti alla ricerca di punti d'interesse come parcheggi, stazioni di ricarica e distributori di benzina. Paga Creare app per punti d'interesse per le auto per documentazione aggiuntiva su questa categoria.
• androidx.car.app.category.IOT: un'app che consente agli utenti di passare contenuti pertinenti azioni sui dispositivi connessi dall'auto. Consulta Creare app per l'internet delle cose per le auto per documentazione aggiuntiva su questa categoria.

Consulta la pagina Qualità delle app per Android per le auto per descrizioni dettagliate di ogni categoria e criteri per l'appartenenza delle app.

Specifica il nome e l'icona dell'app

Devi specificare il nome e l'icona di un'app che l'host può utilizzare per rappresentare il tuo nell'interfaccia utente di sistema.

Puoi specificare il nome e l'icona dell'app utilizzati per rappresentare la tua app utilizzando label e Attributi icon di CarAppService:

...
<service
   android:name=".MyCarAppService"
   android:exported="true"
   android:label="@string/my_app_name"
   android:icon="@drawable/my_app_icon">
   ...
</service>
...

Se l'etichetta o l'icona non sono dichiarate nell'elemento <service>, l'host ricorre ai valori specificati per l'elemento <application>.

Impostare un tema personalizzato

Per impostare un tema personalizzato per l'app per auto, aggiungi un elemento <meta-data> nel file manifest, come segue:

<meta-data
    android:name="androidx.car.app.theme"
    android:resource="@style/MyCarAppTheme />

Quindi, dichiara la tua risorsa per lo stile in Imposta i seguenti attributi per il tuo tema app auto personalizzato:

<resources>
  <style name="MyCarAppTheme">
    <item name="carColorPrimary">@layout/my_primary_car_color</item>
    <item name="carColorPrimaryDark">@layout/my_primary_dark_car_color</item>
    <item name="carColorSecondary">@layout/my_secondary_car_color</item>
    <item name="carColorSecondaryDark">@layout/my_secondary_dark_car_color</item>
    <item name="carPermissionActivityLayout">@layout/my_custom_background</item>
  </style>
</resources>

Livello API Car App

La libreria di app per auto definisce i propri livelli API in modo che tu possa sapere quali funzionalità della libreria sono supportate dall'host del modello su un veicolo. Per recuperare il livello API dell'app per auto più elevato supportato da un host, utilizza il metodo getCarAppApiLevel().

Dichiara il livello API minimo dell'app Car App supportato dalla tua app nel tuo File AndroidManifest.xml:

<manifest ...>
    <application ...>
        <meta-data
            android:name="androidx.car.app.minCarApiLevel"
            android:value="1"/>
    </application>
</manifest>

Consulta la documentazione per RequiresCarApi per informazioni dettagliate su come mantenere la compatibilità con le versioni precedenti il livello API minimo richiesto per utilizzare una funzionalità. Per una definizione del livello di API richiesto per utilizzare una determinata funzionalità della libreria di app per auto, consulta la documentazione di riferimento di CarAppApiLevels.

Crea CarAppService e Session

L'app deve estendere la classe CarAppService e implementare il suo metodo onCreateSession, che restituisce un'istanza Session corrispondente alla connessione corrente all'host:

class HelloWorldService : CarAppService() {
    ...
    override fun onCreateSession(): Session {
        return HelloWorldSession()
    }
    ...
}

public final class HelloWorldService extends CarAppService {
    ...
    @Override
    @NonNull
    public Session onCreateSession() {
        return new HelloWorldSession();
    }
    ...
}

L'istanza Session è responsabile che restituisce l'istanza Screen per utilizzare al primo avvio dell'app:

class HelloWorldSession : Session() {
    ...
    override fun onCreateScreen(intent: Intent): Screen {
        return HelloWorldScreen(carContext)
    }
    ...
}

public final class HelloWorldSession extends Session {
    ...
    @Override
    @NonNull
    public Screen onCreateScreen(@NonNull Intent intent) {
        return new HelloWorldScreen(getCarContext());
    }
    ...
}

Per gestire scenari in cui l'app dell'auto deve essere avviata da uno schermo che non dalla schermata Home o di destinazione dell'app, ad esempio per gestire i link diretti, puoi pre-separare uno stack di schermi usando ScreenManager.push prima di tornare da onCreateScreen. Il pre-seeding consente agli utenti di tornare alle schermate precedenti dalla prima schermata mostrata nell'app.

Creare la schermata iniziale

Puoi creare le schermate visualizzate dalla tua app definendo classi che estendono Screen corso e ne viene implementata l'implementazione onGetTemplate , che restituisce Template che rappresenta l'istanza lo stato dell'interfaccia utente da visualizzare sullo schermo dell'auto.

Lo snippet seguente mostra come dichiarare un Screen che utilizza un modello PaneTemplate per visualizzare una semplice stringa "Hello world!":

class HelloWorldScreen(carContext: CarContext) : Screen(carContext) {
    override fun onGetTemplate(): Template {
        val row = Row.Builder().setTitle("Hello world!").build()
        val pane = Pane.Builder().addRow(row).build()
        return PaneTemplate.Builder(pane)
            .setHeaderAction(Action.APP_ICON)
            .build()
    }
}

public class HelloWorldScreen extends Screen {
    @NonNull
    @Override
    public Template onGetTemplate() {
        Row row = new Row.Builder().setTitle("Hello world!").build();
        Pane pane = new Pane.Builder().addRow(row).build();
        return new PaneTemplate.Builder(pane)
            .setHeaderAction(Action.APP_ICON)
            .build();
    }
}

La classe CarContext

Il corso CarContext è un Sottoclasse ContextWrapper accessibile ai tuoi dati Session e Screen di istanze. Fornisce accesso ai servizi per auto, come ScreenManager per la gestione della pila di schermate, AppManager per le funzionalità generali relative alle app, come l'accesso all'oggetto Surface per disegnare mappe e NavigationManager utilizzato dalle app di navigazione passo passo per comunicare metadati di navigazione e altri eventi correlati alla navigazione con l'host.

Vedi Accedere alla navigazione. modelli per un elenco completo delle funzionalità della libreria disponibili per le app di navigazione.

CarContext offre anche altre funzionalità, ad esempio consente di caricare risorse drawable utilizzando la configurazione sullo schermo dell'auto, avviare un'app nell'auto utilizzando gli intent e indicare se la tua app deve mostrare la mappa in tema scuro.

Implementare la navigazione tra le schermate

Le app spesso presentano una serie di schermate diverse, ognuna delle quali potrebbe utilizzare diversi modelli tra cui l'utente può navigare mentre interagisce con l'interfaccia visualizzata nella schermata.

La classe ScreenManager fornisce un insieme di schermate che puoi utilizzare per inviare schermate che possono essere visualizzate automaticamente quando l'utente seleziona un pulsante Indietro sullo schermo dell'auto o utilizza il pulsante Indietro hardware disponibile in alcune auto.

Lo snippet seguente mostra come aggiungere un'azione Indietro a un modello di messaggio come nonché un'azione che visualizzi una nuova schermata quando selezionata dall'utente:

val template = MessageTemplate.Builder("Hello world!")
    .setHeaderAction(Action.BACK)
    .addAction(
        Action.Builder()
            .setTitle("Next screen")
            .setOnClickListener { screenManager.push(NextScreen(carContext)) }
            .build())
    .build()

MessageTemplate template = new MessageTemplate.Builder("Hello world!")
    .setHeaderAction(Action.BACK)
    .addAction(
        new Action.Builder()
            .setTitle("Next screen")
            .setOnClickListener(
                () -> getScreenManager().push(new NextScreen(getCarContext())))
            .build())
    .build();

L'oggetto Action.BACK è un Action standard che richiama automaticamente ScreenManager.pop. Questo comportamento può essere ignorato utilizzando il comando OnBackPressedDispatcher disponibile dal CarContext.

Per garantire che l'app sia sicura da usare durante la guida, la pila di schermate può avere un valore massimo fino a cinque schermi. Per ulteriori dettagli, consulta la sezione Limitazioni dei modelli.

Aggiornare i contenuti di un modello

L'app può richiedere l'invalidazione dei contenuti di un Screen chiamando il metodo Screen.invalidate. L'organizzatore richiama successivamente nella console Screen.onGetTemplate per recuperare il modello con i nuovi contenuti.

Quando aggiorni un Screen, è importante comprendere i contenuti specifici del modello che possono essere aggiornati in modo che l'host non conti il nuovo modello rispetto alla quota del modello. Per ulteriori dettagli, consulta la sezione Limitazioni dei modelli.

Ti consigliamo di strutturare le schermate in modo che esista una mappatura uno a uno tra un Screen e il tipo di templata restituito tramite l'implementazione di onGetTemplate.

Disegnare mappe

Le app di navigazione e sui punti d'interesse (PDI) che utilizzano i seguenti modelli possono elaborare mappe accedendo a un Surface:

Dichiara l'autorizzazione di accesso alla piattaforma

Oltre all'autorizzazione richiesta per il modello utilizzato dall'app, l'app deve dichiarare l'autorizzazione androidx.car.app.ACCESS_SURFACE nel suo AndroidManifest.xml file per ottenere l'accesso alla piattaforma:

<manifest ...>
  ...
  <uses-permission android:name="androidx.car.app.ACCESS_SURFACE" />
  ...
</manifest>

Accedere alla superficie

Per accedere al Surface fornito dall'host, devi implementare un SurfaceCallback e fornire l'implementazione in AppManager dell'auto. L'attuale Surface viene passato al SurfaceCallback nel parametro SurfaceContainer dei callback onSurfaceAvailable() e onSurfaceDestroyed().

carContext.getCarService(AppManager::class.java).setSurfaceCallback(surfaceCallback)

carContext.getCarService(AppManager.class).setSurfaceCallback(surfaceCallback);

Informazioni sull'area visibile della superficie

L'organizzatore può disegnare gli elementi dell'interfaccia utente per i modelli sopra la mappa. L'host comunica l'area della superficie di cui viene garantito il non ostruita e completamente visibile all'utente chiamando il SurfaceCallback.onVisibleAreaChanged . Inoltre, per ridurre al minimo il numero di modifiche, l'organizzatore chiama la SurfaceCallback.onStableAreaChanged con il rettangolo più piccolo, che è sempre visibile in base modello corrente.

Ad esempio, quando un'app di navigazione utilizza il pulsante NavigationTemplate con una barra di azioni in alto, la barra di azioni può nascondersi quando l'utente non interagisce con lo schermo per un po' di tempo per fare spazio alla mappa. In questo caso, è presente un callback a onStableAreaChanged e onVisibleAreaChanged con lo stesso rettangolo. Quando la barra di azioni è nascosta, viene chiamata solo onVisibleAreaChanged con l'area più grande. Se l'utente interagisce con la schermata, viene richiamato di nuovo solo onVisibleAreaChanged con il primo rettangolo.

Supporto del tema scuro

Le app devono ridisegnare la mappa nell'istanza Surface con i colori scuri appropriati quando l'host stabilisce che le condizioni lo richiedono, come descritto nella sezione Qualità delle app per Android per le auto.

Per decidere se tracciare una mappa scura, puoi utilizzare CarContext.isDarkMode . Ogni volta che lo stato del tema scuro cambia, ricevi una chiamata al numero Session.onCarConfigurationChanged.

Consentire agli utenti di interagire con la mappa

Quando utilizzi i seguenti modelli, puoi aggiungere supporto per l'interazione degli utenti con le mappe che disegni, ad esempio consentendo loro di vedere diverse parti di una mappa lo zoom e la panoramica.

Implementa callback di interattività

Interfaccia di SurfaceCallback dispone di diversi metodi di callback che puoi implementare per aggiungere interattività alle mappe create con i modelli della sezione precedente:

Aggiungere una barra di azioni della mappa

Questi modelli possono avere una barra delle azioni sulla mappa per le azioni relative alla mappa, come aumentare e diminuire lo zoom, ricentrare, visualizzare una bussola e altre azioni scegliere di visualizzare. La barra delle azioni della mappa può avere fino a quattro pulsanti con solo icone che possono essere aggiornati senza influire sulla profondità delle attività. Si nasconde durante lo stato inattivo e viene visualizzato di nuovo nello stato attivo.

Per ricevere i callback per l'interattività della mappa: deve aggiungere un pulsante Action.PAN nella barra delle azioni della mappa. Quando l'utente il pulsante Panoramica, l'host attiva la modalità Panoramica, come descritto .

Se la tua app omette il pulsante Action.PAN nella barra delle azioni della mappa, non riceve input utente dai metodi SurfaceCallback e l'host esce da qualsiasi modalità di panoramica attivata in precedenza.

Su un touchscreen, il pulsante per la panoramica non viene visualizzato.

Informazioni sulla modalità Panoramica

In modalità panoramica, l'host del modello traduce l'input utente da dispositivi di input non touch, come controller rotatori e touchpad, nei metodi SurfaceCallback appropriati. Rispondere all'azione dell'utente per attivare o disattivare la modalità panoramica con il metodo setPanModeListener in NavigationTemplate.Builder. L'organizzatore può nascondere altre UI nel modello mentre l'utente è in modalità panoramica.

Interagire con l'utente

La tua app può interagire con l'utente utilizzando schemi simili a quelli di un'app mobile.

Gestire l'input utente

L'app può rispondere all'input utente trasmettendo gli ascoltatori appropriati alla e modelli che le supportano. Il seguente snippet mostra come creare un Action modello che imposta un OnClickListener che richiama un metodo definito dal codice della tua app:

val action = Action.Builder()
    .setTitle("Navigate")
    .setOnClickListener(::onClickNavigate)
    .build()

Action action = new Action.Builder()
    .setTitle("Navigate")
    .setOnClickListener(this::onClickNavigate)
    .build();

Il metodo onClickNavigate può quindi avviare l'app di navigazione predefinita per l'auto utilizzando il metodo CarContext.startCarApp:

private fun onClickNavigate() {
    val intent = Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address))
    carContext.startCarApp(intent)
}

private void onClickNavigate() {
    Intent intent = new Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address));
    getCarContext().startCarApp(intent);
}

Per maggiori dettagli su come avviare le app, incluso il formato dell'intentACTION_NAVIGATE, consulta la sezione Avvia un'app per auto con un intent.

Alcune azioni, ad esempio quelle che richiedono all'utente di continuare sui dispositivi mobili sono consentite solo quando l'auto è parcheggiata. Puoi utilizzare lo ParkedOnlyOnClickListener per implementare queste azioni. Se l'auto non è parcheggiata, l'host visualizza un che indica all'utente che l'azione non è consentita in questo caso. Se l'auto è parcheggiato, il codice viene eseguito normalmente. Lo snippet seguente mostra come usare ParkedOnlyOnClickListener per aprire una schermata delle impostazioni sul dispositivo mobile:

val row = Row.Builder()
    .setTitle("Open Settings")
    .setOnClickListener(ParkedOnlyOnClickListener.create(::openSettingsOnPhone))
    .build()

Row row = new Row.Builder()
    .setTitle("Open Settings")
    .setOnClickListener(ParkedOnlyOnClickListener.create(this::openSettingsOnPhone))
    .build();

Mostra notifiche

Le notifiche inviate al dispositivo mobile vengono visualizzate sullo schermo dell'auto soltanto se vengono estese con CarAppExtender Alcuni attributi delle notifiche, come titolo dei contenuti, testo, icona e azioni, può essere impostato in CarAppExtender, sostituendo gli attributi della notifica quando vengono visualizzati sullo schermo dell'auto.

Il seguente snippet mostra come inviare una notifica allo schermo dell'auto che visualizza un titolo diverso da quello mostrato sul dispositivo mobile:

val notification = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    .setContentTitle(titleOnThePhone)
    .extend(
        CarAppExtender.Builder()
            .setContentTitle(titleOnTheCar)
            ...
            .build())
    .build()

Notification notification = new NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    .setContentTitle(titleOnThePhone)
    .extend(
        new CarAppExtender.Builder()
            .setContentTitle(titleOnTheCar)
            ...
            .build())
    .build();

Le notifiche possono influire sulle seguenti parti dell'interfaccia utente:

• All'utente potrebbe essere visualizzata una notifica di avviso (HUN).
• È possibile aggiungere una voce nel centro notifiche, facoltativamente con un badge visibile sul binario.
• Per le app di navigazione, la notifica può essere visualizzata nel widget ferroviario come descritti in Notifiche passo passo.

Puoi scegliere come configurare le notifiche dell'app in modo che influiscano su ciascuno di questi elementi dell'interfaccia utente utilizzando la priorità della notifica, come descritto nella documentazione di CarAppExtender.

Se NotificationCompat.Builder.setOnlyAlertOnce viene richiamata con il valore true, una notifica ad alta priorità viene visualizzata HUN solo una volta.

Per ulteriori informazioni su come progettare le notifiche dell'app per auto, consulta la guida di Google Design for Driving sulle notifiche.

Mostrare avvisi popup

La tua app può mostrare un messaggio popup utilizzando CarToast come mostrato in questo snippet:

CarToast.makeText(carContext, "Hello!", CarToast.LENGTH_SHORT).show()

CarToast.makeText(getCarContext(), "Hello!", CarToast.LENGTH_SHORT).show();

Richiedi autorizzazioni

Se la tua app ha bisogno di accedere a dati o azioni con restrizioni, ad esempio posizione: le regole standard di Android autorizzazioni . Per richiedere un'autorizzazione, puoi utilizzare il metodo CarContext.requestPermissions().

Il vantaggio dell'utilizzo di CarContext.requestPermissions(), rispetto all'utilizzo delle API Android standard, è che non devi avviare il tuo Activity per creare la finestra di dialogo delle autorizzazioni. Inoltre, puoi utilizzare lo stesso codice Android Auto e Android Automotive OS, invece di dover creare che dipendono dalla piattaforma.

Personalizzare la finestra di dialogo delle autorizzazioni su Android Auto

Su Android Auto, sullo smartphone viene visualizzata la finestra di dialogo delle autorizzazioni per l'utente. Per impostazione predefinita, non è presente alcun sfondo dietro la finestra di dialogo. Per impostare un sfondo personalizzato, dichiara un tema dell'app per auto nel file AndroidManifest.xml e imposta l'attributo carPermissionActivityLayout per il tema dell'app per auto.

<meta-data
    android:name="androidx.car.app.theme"
    android:resource="@style/MyCarAppTheme />

Dopodiché, imposta l'attributo carPermissionActivityLayout per il tema dell'app per auto:

<resources>
  <style name="MyCarAppTheme">
    <item name="carPermissionActivityLayout">@layout/my_custom_background</item>
  </style>
</resources>

Avviare un'app per auto con un'intent

Puoi chiamare il metodo CarContext.startCarApp per eseguire una delle seguenti azioni:

• Apri la tastiera per telefonare.
• Avvia la navigazione passo passo verso una località con l'app di navigazione predefinita per auto.
• Avvia la tua app con un intent.

L'esempio seguente mostra come creare una notifica con un'azione che apre la tua app con una schermata che mostra i dettagli di una prenotazione del parcheggio. Estendi l'istanza di notifica con un'intenzione di contenuto che contiene un PendingIntent che racchiude un'intenzione esplicita per l'azione della tua app:

val notification = notificationBuilder
    ...
    .extend(
        CarAppExtender.Builder()
            .setContentIntent(
                PendingIntent.getBroadcast(
                    context,
                    ACTION_VIEW_PARKING_RESERVATION.hashCode(),
                    Intent(ACTION_VIEW_PARKING_RESERVATION)
                        .setComponent(ComponentName(context, MyNotificationReceiver::class.java)),
                    0))
            .build())

Notification notification = notificationBuilder
    ...
    .extend(
        new CarAppExtender.Builder()
            .setContentIntent(
                PendingIntent.getBroadcast(
                    context,
                    ACTION_VIEW_PARKING_RESERVATION.hashCode(),
                    new Intent(ACTION_VIEW_PARKING_RESERVATION)
                        .setComponent(new ComponentName(context, MyNotificationReceiver.class)),
                    0))
            .build());

L'app deve inoltre dichiarare BroadcastReceiver, ovvero richiamati per elaborare l'intent quando l'utente seleziona l'azione nella dell'interfaccia di notifica CarContext.startCarApp con un intent che includa l'URI dei dati:

class MyNotificationReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val intentAction = intent.action
        if (ACTION_VIEW_PARKING_RESERVATION == intentAction) {
            CarContext.startCarApp(
                intent,
                Intent(Intent.ACTION_VIEW)
                    .setComponent(ComponentName(context, MyCarAppService::class.java))
                    .setData(Uri.fromParts(MY_URI_SCHEME, MY_URI_HOST, intentAction)))
        }
    }
}

public class MyNotificationReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        String intentAction = intent.getAction();
        if (ACTION_VIEW_PARKING_RESERVATION.equals(intentAction)) {
            CarContext.startCarApp(
                intent,
                new Intent(Intent.ACTION_VIEW)
                    .setComponent(new ComponentName(context, MyCarAppService.class))
                    .setData(Uri.fromParts(MY_URI_SCHEME, MY_URI_HOST, intentAction)));
        }
    }
}

Infine, il metodo Session.onNewIntent nella tua app gestisce questo intent inviando la schermata di prenotazione del parcheggio nella pila, se non è già in primo piano:

override fun onNewIntent(intent: Intent) {
    val screenManager = carContext.getCarService(ScreenManager::class.java)
    val uri = intent.data
    if (uri != null
        && MY_URI_SCHEME == uri.scheme
        && MY_URI_HOST == uri.schemeSpecificPart
        && ACTION_VIEW_PARKING_RESERVATION == uri.fragment
    ) {
        val top = screenManager.top
        if (top !is ParkingReservationScreen) {
            screenManager.push(ParkingReservationScreen(carContext))
        }
    }
}

@Override
public void onNewIntent(@NonNull Intent intent) {
    ScreenManager screenManager = getCarContext().getCarService(ScreenManager.class);
    Uri uri = intent.getData();
    if (uri != null
        && MY_URI_SCHEME.equals(uri.getScheme())
        && MY_URI_HOST.equals(uri.getSchemeSpecificPart())
        && ACTION_VIEW_PARKING_RESERVATION.equals(uri.getFragment())
    ) {
        Screen top = screenManager.getTop();
        if (!(top instanceof ParkingReservationScreen)) {
            screenManager.push(new ParkingReservationScreen(getCarContext()));
        }
    }
}

Per ulteriori informazioni, consulta la sezione Mostra notifiche informazioni su come gestire le notifiche per l'app dell'auto.

Limitazioni relative al modello

L'host limita a un massimo il numero di modelli da visualizzare per una determinata attività su cinque, di cui l'ultimo modello deve essere di uno dei seguenti tipi:

• NavigationTemplate
• PaneTemplate
• MessageTemplate

Tieni presente che questo limite si applica al numero di modelli, non al numero di modelli, Screen istanze nello stack. Ad esempio, se un'app invia due modelli nella schermata A e poi passa alla schermata B, ora può inviare altri tre modelli. In alternativa, se ogni schermata è strutturata per inviare un singolo modello, l'app può eseguire il push di cinque istanze di schermata Pila ScreenManager.

Esistono casi speciali per queste limitazioni: aggiornamenti dei modelli e operazioni di annullamento e reimpostazione.

Aggiornamenti del modello

Alcuni aggiornamenti dei contenuti non concorrono al raggiungimento del limite di modelli. In generale, se un'app esegue il push di un nuovo modello dello stesso tipo e contenente gli stessi contenuti principali del modello precedente, il nuovo modello non conteggiato nella quota. Ad esempio, aggiornare lo stato di attivazione/disattivazione di una riga in una ListTemplate non conta rispetto alla quota. Consulta la documentazione dei singoli modelli per scoprire di più sui tipi di aggiornamenti dei contenuti che possono essere considerati un aggiornamento.

Operazioni di arretramento

Per attivare i flussi secondari all'interno di un'attività, l'host rileva quando un'app sta aprendo una Screen dallo stack ScreenManager e aggiornamenti la quota rimanente in base al numero di modelli usati dall'app al contrario.

Ad esempio, se l'app invia due modelli nella schermata A, poi spinge la schermata B e invia altri due modelli, l'app ha una quota rimanente. Se l'app torna alla schermata A, l'host reimposta la quota su tre, perché l'app è tornata indietro di due modelli.

Tieni presente che, quando apri di nuovo una schermata, un'app deve inviare un modello che dello stesso tipo dell'ultimo inviato dalla schermata. Invio di qualsiasi altro utente il tipo di modello causa un errore. Tuttavia, a condizione che il tipo rimanga invariato durante un'operazione di ritorno, un'app può modificare liberamente i contenuti del modello senza influire sulla quota.

Operazioni di reimpostazione

Alcuni modelli hanno una semantica speciale che indica la fine di un'attività. Ad esempio, NavigationTemplate è una visualizzazione che dovrebbe rimanere sullo schermo e essere aggiornata con nuove istruzioni passo passo per l'utente. Quando raggiunge uno di questi modelli, l'host reimposta la quota del modello, trattandolo come se fosse il primo passaggio di una nuova attività. In questo modo l'app può iniziare una nuova attività. Consulta la documentazione dei singoli modelli per scoprire quali attivano un ripristino sull'host.

Se l'attività ospitante riceve un'intenzione di avviare l'app da un'azione di notifica o dal programma di avvio, la quota viene reimpostata. Questo meccanismo consente a un'app iniziare un nuovo flusso di attività dalle notifiche e questo vale anche se un'app già associate e in primo piano.

Per ulteriori dettagli, consulta la sezione Mostrare notifiche su come visualizzare le notifiche dell'app nello schermo dell'auto. Consulta la sezione Avvia un'app per auto con un'intent per informazioni su come avviare l'app da un'azione di notifica.

API Connection

Puoi stabilire se la tua app è installata su Android Auto o su Android Automotive OS utilizzando API CarConnection in per recuperare le informazioni di connessione in fase di esecuzione.

Ad esempio, nel file Session dell'app dell'auto, inizializza CarConnection e iscriviti agli aggiornamenti di LiveData:

CarConnection(carContext).type.observe(this, ::onConnectionStateUpdated)

new CarConnection(getCarContext()).getType().observe(this, this::onConnectionStateUpdated);

Nell'osservatore, puoi quindi reagire ai cambiamenti nello stato di connessione:

fun onConnectionStateUpdated(connectionState: Int) {
  val message = when(connectionState) {
    CarConnection.CONNECTION_TYPE_NOT_CONNECTED -> "Not connected to a head unit"
    CarConnection.CONNECTION_TYPE_NATIVE -> "Connected to Android Automotive OS"
    CarConnection.CONNECTION_TYPE_PROJECTION -> "Connected to Android Auto"
    else -> "Unknown car connection type"
  }
  CarToast.makeText(carContext, message, CarToast.LENGTH_SHORT).show()
}

private void onConnectionStateUpdated(int connectionState) {
  String message;
  switch(connectionState) {
    case CarConnection.CONNECTION_TYPE_NOT_CONNECTED:
      message = "Not connected to a head unit";
      break;
    case CarConnection.CONNECTION_TYPE_NATIVE:
      message = "Connected to Android Automotive OS";
      break;
    case CarConnection.CONNECTION_TYPE_PROJECTION:
      message = "Connected to Android Auto";
      break;
    default:
      message = "Unknown car connection type";
      break;
  }
  CarToast.makeText(getCarContext(), message, CarToast.LENGTH_SHORT).show();
}

API Constraints

Automobili diverse possono consentire di mostrare all'utente un numero diverso di istanze di Item alla volta. Utilizza la ConstraintManager per controllare il limite per i contenuti in fase di runtime e impostare il numero appropriato di elementi nei tuoi modelli.

Per iniziare, richiedi un ConstraintManager dal CarContext:

val manager = carContext.getCarService(ConstraintManager::class.java)

ConstraintManager manager = getCarContext().getCarService(ConstraintManager.class);

Puoi quindi eseguire una query sull'oggetto ConstraintManager recuperato per trovare la query limiti dei contenuti. Ad esempio, per ottenere il numero di elementi che possono essere visualizzati una griglia, richiama getContentLimit con CONTENT_LIMIT_TYPE_GRID:

val gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID)

int gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID);

Aggiungere un flusso di accesso

Se la tua app offre un'esperienza di accesso per gli utenti, puoi utilizzare modelli come SignInTemplate e LongMessageTemplate con l'API Car App 2.0 e versioni successive per gestire l'accesso alla tua app sull'unità principale dell'auto.

Per creare un SignInTemplate, definisci un SignInMethod. La raccolta di app per auto supporta attualmente i seguenti metodi di accesso:

• InputSignInMethod per l'accesso con nome utente/password.
• PinSignInMethod per l'accesso con PIN, in cui l'utente collega il proprio account dallo smartphone utilizzando un PIN visualizzato sull'unità principale.
• ProviderSignInMethod per l'accesso del fornitore, ad esempio Accedi con Google e Un tocco.
• QRCodeSignInMethod per l'accesso con codice QR, dove l'utente scansiona un codice QR per completare l'accesso sul loro telefono. Questa funzionalità è disponibile con API Car di livello 4 e successivi.

Ad esempio, per implementare un modello che raccoglie la password dell'utente, inizia creando un InputCallback per elaborare e convalidare l'input dell'utente:

val callback = object : InputCallback {
    override fun onInputSubmitted(text: String) {
        // You will receive this callback when the user presses Enter on the keyboard.
    }

    override fun onInputTextChanged(text: String) {
        // You will receive this callback as the user is typing. The update
        // frequency is determined by the host.
    }
}

InputCallback callback = new InputCallback() {
    @Override
    public void onInputSubmitted(@NonNull String text) {
        // You will receive this callback when the user presses Enter on the keyboard.
    }

    @Override
    public void onInputTextChanged(@NonNull String text) {
        // You will receive this callback as the user is typing. The update
        // frequency is determined by the host.
    }
};

È obbligatorio un InputCallback per il InputSignInMethod Builder.

val passwordInput = InputSignInMethod.Builder(callback)
    .setHint("Password")
    .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD)
    ...
    .build()

InputSignInMethod passwordInput = new InputSignInMethod.Builder(callback)
    .setHint("Password")
    .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD)
    ...
    .build();

Infine, utilizza il nuovo InputSignInMethod per creare un SignInTemplate.

SignInTemplate.Builder(passwordInput)
    .setTitle("Sign in with username and password")
    .setInstructions("Enter your password")
    .setHeaderAction(Action.BACK)
    ...
    .build()

new SignInTemplate.Builder(passwordInput)
    .setTitle("Sign in with username and password")
    .setInstructions("Enter your password")
    .setHeaderAction(Action.BACK)
    ...
    .build();

Utilizzare AccountManager

Le app per Android Automotive OS con autenticazione devono utilizzare AccountManager per i seguenti motivi:

• Esperienza utente migliore e facilità di gestione dell'account. Gli utenti possono gestire facilmente tutti i loro account dal menu degli account nelle impostazioni di sistema, compreso e uscire.
• "Ospite" : poiché le auto sono dispositivi condivisi, gli OEM possono esperienze degli ospiti all'interno del veicolo, per le quali non è possibile aggiungere account.

Aggiungi varianti della stringa di testo

Dimensioni dello schermo dell'auto diverse possono mostrare quantità diverse di testo. Con l'API Car App di livello 2 e versioni successive, puoi specificare più varianti di una stringa di testo per adattarla al meglio allo schermo. Per sapere dove sono accettate le varianti di testo, cerca i modelli e i componenti che accettano un CarText.

Puoi aggiungere varianti della stringa di testo a un CarText con il CarText.Builder.addVariant() :

val itemTitle = CarText.Builder("This is a very long string")
    .addVariant("Shorter string")
    ...
    .build()

CarText itemTitle = new CarText.Builder("This is a very long string")
    .addVariant("Shorter string")
    ...
    .build();

Puoi quindi utilizzare CarText, ad esempio, come testo principale di un GridItem

GridItem.Builder()
    .addTitle(itemTitle)
    ...
    .build()

new GridItem.Builder()
    .addTitle(itemTitle)
    ...
    build();

Aggiungi le stringhe in ordine dalla più alla meno preferita, ad esempio dalla più lunga alla più breve. L'host sceglie la stringa di lunghezza appropriata in base allo spazio disponibile sullo schermo dell'auto.

Aggiungere CarIcons in linea per le righe

Puoi aggiungere icone incorporate nel testo per arricchire l'aspetto visivo della tua app utilizzando CarIconSpan Consulta la documentazione per CarIconSpan.create per ulteriori informazioni sulla creazione di questi intervalli. Consulta Spantastico applicazione degli stili del testo con Intervalli per una panoramica del funzionamento dello stile del testo con le sezioni.

  
val rating = SpannableString("Rating: 4.5 stars")
rating.setSpan(
    CarIconSpan.create(
        // Create a CarIcon with an image of four and a half stars
        CarIcon.Builder(...).build(),
        // Align the CarIcon to the baseline of the text
        CarIconSpan.ALIGN_BASELINE
    ),
    // The start index of the span (index of the character '4')
    8,
    // The end index of the span (index of the last 's' in "stars")
    16,
    Spanned.SPAN_INCLUSIVE_INCLUSIVE
)

val row = Row.Builder()
    ...
    .addText(rating)
    .build()
  
  

  
SpannableString rating = new SpannableString("Rating: 4.5 stars");
rating.setSpan(
        CarIconSpan.create(
                // Create a CarIcon with an image of four and a half stars
                new CarIcon.Builder(...).build(),
                // Align the CarIcon to the baseline of the text
                CarIconSpan.ALIGN_BASELINE
        ),
        // The start index of the span (index of the character '4')
        8,
        // The end index of the span (index of the last 's' in "stars")
        16,
        Spanned.SPAN_INCLUSIVE_INCLUSIVE
);
Row row = new Row.Builder()
        ...
        .addText(rating)
        .build();
  
  

API per hardware per auto

A partire dal livello 3 dell'API Car App, la libreria Car App include API che puoi utilizzare per accedere alle proprietà e ai sensori del veicolo.

Requisiti

Per utilizzare le API con Android Auto, inizia aggiungendo una dipendenza da androidx.car.app:app-projected al file build.gradle per il tuo modulo Android Auto. Per Android Automotive OS, aggiungi una dipendenza da androidx.car.app:app-automotive al file build.gradle per il modulo Android Automotive OS.

Inoltre, nel file AndroidManifest.xml devi: dichiarare le autorizzazioni pertinenti necessarie per richiedere i dati dell'auto che vuoi usare. Tieni presente che anche queste autorizzazioni devono essere concesso dall'utente. Puoi utilizzare lo lo stesso codice su Android Auto e Android Automotive OS, anziché che dover creare flussi dipendenti dalla piattaforma. Tuttavia, le autorizzazioni necessarie sono diverse.

Info auto

In questa tabella vengono descritte le proprietà visualizzate API di CarInfo e autorizzazioni che devi richiedere per utilizzarle:

Ad esempio, per ottenere l'intervallo rimanente, crea un oggetto CarInfo, quindi crea e registra un OnCarDataAvailableListener:

val carInfo = carContext.getCarService(CarHardwareManager::class.java).carInfo

val listener = OnCarDataAvailableListener<EnergyLevel> { data ->
    if (data.rangeRemainingMeters.status == CarValue.STATUS_SUCCESS) {
      val rangeRemaining = data.rangeRemainingMeters.value
    } else {
      // Handle error
    }
  }

carInfo.addEnergyLevelListener(carContext.mainExecutor, listener)
…
// Unregister the listener when you no longer need updates
carInfo.removeEnergyLevelListener(listener)

CarInfo carInfo = getCarContext().getCarService(CarHardwareManager.class).getCarInfo();

OnCarDataAvailableListener<EnergyLevel> listener = (data) -> {
  if(data.getRangeRemainingMeters().getStatus() == CarValue.STATUS_SUCCESS) {
    float rangeRemaining = data.getRangeRemainingMeters().getValue();
  } else {
    // Handle error
  }
};

carInfo.addEnergyLevelListener(getCarContext().getMainExecutor(), listener);
…
// Unregister the listener when you no longer need updates
carInfo.removeEnergyLevelListener(listener);

Non dare per scontato che i dati dell'auto siano disponibili in ogni momento. Se ricevi un errore, controlla lo stato del valore richiesto per capire meglio perché i dati richiesti non sono stati recuperati. Fai riferimento alla documentazione di riferimento per la definizione completa della classe CarInfo.

Sensori auto

La classe CarSensors consente di accedere ai dati di accelerometro, giroscopio, bussola e posizione del veicolo. La disponibilità di questi valori potrebbe dipendere dall'OEM. Il formato dei dati dell'accelerometro, del giroscopio e della bussola è lo stesso che otterresti dall'API SensorManager. Ad esempio: per controllare la direzione del veicolo:

val carSensors = carContext.getCarService(CarHardwareManager::class.java).carSensors

val listener = OnCarDataAvailableListener<Compass> { data ->
    if (data.orientations.status == CarValue.STATUS_SUCCESS) {
      val orientation = data.orientations.value
    } else {
      // Data not available, handle error
    }
  }

carSensors.addCompassListener(CarSensors.UPDATE_RATE_NORMAL, carContext.mainExecutor, listener)
…
// Unregister the listener when you no longer need updates
carSensors.removeCompassListener(listener)

CarSensors carSensors = getCarContext().getCarService(CarHardwareManager.class).getCarSensors();

OnCarDataAvailableListener<Compass> listener = (data) -> {
  if (data.getOrientations().getStatus() == CarValue.STATUS_SUCCESS) {
    List<Float> orientations = data.getOrientations().getValue();
  } else {
    // Data not available, handle error
  }
};

carSensors.addCompassListener(CarSensors.UPDATE_RATE_NORMAL, getCarContext().getMainExecutor(),
    listener);
…
// Unregister the listener when you no longer need updates
carSensors.removeCompassListener(listener);

Per accedere ai dati sulla posizione dall'auto, devi anche dichiarare e richiedere l'autorizzazione android.permission.ACCESS_FINE_LOCATION.

Test

Per simulare i dati dei sensori durante i test su Android Auto, consulta le sezioni Sensori e Configurazione dei sensori della guida sull'unità principale per computer. Per simulare i dati dei sensori durante i test su Android Automotive OS, consulta la sezione Emulare stato hardware della guida dell'emulatore Android Automotive OS.

Ciclo di vita di CarAppService, della sessione e dello schermo

Le Session e Le classi Screen implementano LifecycleOwner. Quando l'utente interagisce con l'app, vengono richiamati i callback del ciclo di vita degli oggetti Session e Screen, come descritto nei seguenti diagrammi.

I cicli di vita di un servizio CarAppService e di una sessione

.

Per i dettagli completi, consulta la documentazione Session.getLifecycle .

Il ciclo di vita di una schermata

Per informazioni dettagliate, consulta la documentazione relativa Screen.getLifecycle.

Registrare dal microfono dell'auto

Utilizzando CarAppService e l'API CarAudioRecord della tua app, puoi dare all'app l'accesso al microfono dell'auto dell'utente. Gli utenti devono concedere alla tua app l'autorizzazione per accedere al microfono dell'auto. La tua app può registrare e elaborare l'input dell'utente al suo interno.

Autorizzazione alla registrazione

Prima di registrare qualsiasi audio, devi dichiarare l'autorizzazione di registrazione nel tuo AndroidManifest.xml e chiedere all'utente di concederla.

<manifest ...>
   ...
   <uses-permission android:name="android.permission.RECORD_AUDIO" />
   ...
</manifest>

Devi richiedere l'autorizzazione per registrare in fase di runtime. Consulta la richiesta autorizzazioni per maggiori dettagli su come richiedere autorizzazione nell'app dell'auto.

Registra l'audio

Dopo che l'utente concede l'autorizzazione alla registrazione, puoi registrare l'audio ed elaborare l'audio. la registrazione.

val carAudioRecord = CarAudioRecord.create(carContext)
        carAudioRecord.startRecording()

        val data = ByteArray(CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE)
        while(carAudioRecord.read(data, 0, CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE) >= 0) {
            // Use data array
            // Potentially call carAudioRecord.stopRecording() if your processing finds end of speech
        }
        carAudioRecord.stopRecording()
 

CarAudioRecord carAudioRecord = CarAudioRecord.create(getCarContext());
        carAudioRecord.startRecording();

        byte[] data = new byte[CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE];
        while (carAudioRecord.read(data, 0, CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE) >= 0) {
            // Use data array
            // Potentially call carAudioRecord.stopRecording() if your processing finds end of speech
        }
        carAudioRecord.stopRecording();
 

Focus audio

Quando registri dal microfono dell'auto, acquisisci prima l'attenzione audio per assicurarti che i contenuti multimediali in riproduzione vengano interrotti. Se perdi il focus audio, interrompi la registrazione.

Ecco un esempio di come acquisire il focus audio:

 
val carAudioRecord = CarAudioRecord.create(carContext)
        
        // Take audio focus so that user's media is not recorded
        val audioAttributes = AudioAttributes.Builder()
            .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
            // Use the most appropriate usage type for your use case
            .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE)
            .build()
        
        val audioFocusRequest =
            AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
                .setAudioAttributes(audioAttributes)
                .setOnAudioFocusChangeListener { state: Int ->
                    if (state == AudioManager.AUDIOFOCUS_LOSS) {
                        // Stop recording if audio focus is lost
                        carAudioRecord.stopRecording()
                    }
                }
                .build()
        
        if (carContext.getSystemService(AudioManager::class.java)
                .requestAudioFocus(audioFocusRequest)
            != AudioManager.AUDIOFOCUS_REQUEST_GRANTED
        ) {
            // Don't record if the focus isn't granted
            return
        }
        
        carAudioRecord.startRecording()
        // Process the audio and abandon the AudioFocusRequest when done

CarAudioRecord carAudioRecord = CarAudioRecord.create(getCarContext());
        // Take audio focus so that user's media is not recorded
        AudioAttributes audioAttributes =
                new AudioAttributes.Builder()
                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                        // Use the most appropriate usage type for your use case
                        .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE)
                        .build();

        AudioFocusRequest audioFocusRequest =
                new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
                        .setAudioAttributes(audioAttributes)
                        .setOnAudioFocusChangeListener(state -> {
                            if (state == AudioManager.AUDIOFOCUS_LOSS) {
                                // Stop recording if audio focus is lost
                                carAudioRecord.stopRecording();
                            }
                        })
                        .build();

        if (getCarContext().getSystemService(AudioManager.class).requestAudioFocus(audioFocusRequest)
                != AUDIOFOCUS_REQUEST_GRANTED) {
            // Don't record if the focus isn't granted
            return;
        }

        carAudioRecord.startRecording();
        // Process the audio and abandon the AudioFocusRequest when done
 

Libreria di test

Il test di Android for Cars La libreria fornisce informazioni ausiliarie che puoi utilizzare per convalidare il comportamento della tua app in un ambiente di test. Ad esempio, il messaggio SessionController ti consente di simulare una connessione all'host e verificare che i valori Screen e Template corretti vengano creati e restituito.

Consulta le Campioni per esempi di utilizzo.

Segnalare un problema relativo alla libreria di app Android for Cars

Se rilevi un problema con la libreria, segnalalo utilizzando il Google Issue Tracker. Assicurati di compilare tutte le informazioni richieste nel modello di problema.

Creare un nuovo problema

Prima di inviare un nuovo numero, controlla se è elencato nell'uscita della raccolta note o segnalati nell'elenco dei problemi. Puoi iscriverti e votare i problemi facendo clic sulla stella accanto a un problema nel tracker. Per ulteriori informazioni, vedi Abbonarsi a un problema.