Adicionar compatibilidade com o Android Automotive OS ao seu app de mídia

O Android Automotive OS permite que os usuários instalem apps no carro. Para alcançar os usuários nessa plataforma, você precisa distribuir um app otimizado para motoristas que seja compatível com o Android Automotive OS. É possível reutilizar quase todo o código e os recursos do app Android Auto, mas é necessário criar uma versão separada que atenda aos requisitos desta página.

Visão geral do desenvolvimento

Adicionar compatibilidade com o Android Automotive OS é simples e requer apenas algumas etapas:

  1. Ativar recursos automotivos no Android Studio
  2. Criar um módulo automotivo
  3. Atualizar suas dependências do Gradle
  4. Adicionar configurações ou atividades de login (opcional)

Considerações sobre design

O Android Automotive OS cuida do layout do conteúdo de mídia que recebe do serviço de navegação de mídia do app. Isso significa que seu app não desenha a IU nem inicia nenhuma atividade quando um usuário aciona a reprodução de mídia.

Se você estiver implementando atividades de configurações ou login, elas precisarão ser otimizadas para veículos. Consulte as diretrizes de design do Android Automotive OS ao projetar essas áreas do seu app.

Configurar seu projeto

É necessário configurar várias partes diferentes do projeto do seu app para ativar a compatibilidade com o Android Automotive OS.

Ativar recursos automotivos no Android Studio

Use o Android Studio 4.0 ou posterior para garantir que todos os recursos do Automotive OS estejam ativados.

Criar um módulo automotivo

Alguns componentes do Android Automotive OS, como o manifesto, têm requisitos específicos da plataforma. Portanto, é necessário criar um módulo que possa manter o código desses componentes separado do restante do código do seu projeto, como o código usado no app para smartphones.

Siga as etapas abaixo para adicionar um módulo automotivo ao seu projeto:

  1. No Android Studio, selecione File > New > New Module.
  2. Selecione Automotive Module e clique em Next.
  3. Preencha o campo Application/Library name. Esse é o nome do seu app que os usuários veem no Android Automotive OS.
  4. Preencha o campo Module name.
  5. Ajuste o Package name para corresponder ao seu app.
  6. Selecione API 28:Android 9.0 (Pie) como Minimum SDK e clique em Next.

    Todos os carros compatíveis com o Android Automotive OS executam o Android 9 (API de nível 28) ou uma versão mais recente. Portanto, a seleção desse valor abrange todos os carros que usam o Android Automotive OS.

  7. Selecione Add No Activity e clique em Finish.

Depois de criar seu módulo no Android Studio, abra o AndroidManifest.xml no seu novo módulo automotivo:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.media">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" />

    <uses-feature
        android:name="android.hardware.type.automotive"
        android:required="true" />

</manifest>

Você perceberá algumas informações padrão do app no elemento application, mas há também um elemento uses-feature que declara a compatibilidade com o Android Automotive OS. Observe também que não há atividades declaradas no manifesto.

Se você implementar atividades de configurações ou login, adicione-as aqui. Essas atividades são acionadas pelo sistema usando intents explícitas e são as únicas atividades que precisam ser declaradas no manifesto para seu app Android Automotive OS.

Depois de adicionar qualquer atividade de configurações ou login, conclua o arquivo de manifesto definindo o atributo android:appCategory="audio" no elemento application e adicionando os seguintes elementos users-features:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.media">

    <application
        android:allowBackup="true"
        android:appCategory="audio"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" />

    <uses-feature
        android:name="android.hardware.type.automotive"
        android:required="true" />

    <uses-feature
        android:name="android.hardware.wifi"
        android:required="false" />
    <uses-feature
        android:name="android.hardware.screen.portrait"
        android:required="false" />
    <uses-feature
        android:name="android.hardware.screen.landscape"
        android:required="false" />

</manifest>

Definir explicitamente esses recursos como não obrigatórios garante que o app não entre em conflito com os recursos de hardware disponíveis nos dispositivos Automotive OS.

Declarar compatibilidade de mídia com o Android Automotive OS

Use a seguinte entrada de manifesto para declarar que o app é compatível com o Android Automotive OS:

<application>
    ...
    <meta-data android:name="com.android.automotive"
        android:resource="@xml/automotive_app_desc"/>
    ...
</application>

Essa entrada de manifesto se refere a um arquivo XML que declara com quais recursos automotivos seu app é compatível. Para indicar que você tem um app de música, adicione um arquivo XML chamado automotive_app_desc.xml ao diretório res/xml/ no projeto. Esse arquivo precisa incluir o seguinte conteúdo:

<automotiveApp>
    <uses name="media"/>
</automotiveApp>

Filtros de intent

O Android Automotive OS usa intents explícitas para acionar atividades no seu app de música. O arquivo de manifesto não pode conter nenhuma atividade que tenha filtros de intent CATEGORY_LAUNCHER ou ACTION_MAIN.

Atividades como a do exemplo a seguir geralmente são destinadas a um smartphone ou outro dispositivo móvel. Essas atividades precisam ser declaradas no módulo que cria o app para smartphones, não no módulo que cria o app Android Automotive OS.

<activity android:name=".MyActivity">
    <intent-filter>
        <!-- You can't use either of these intents for Android Automotive OS -->
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
        <!--
        In their place, you can include other intent filters for any activities
        that your app needs for Android Automotive OS, such as settings or
        sign-in activities.
        -->
    </intent-filter>
</activity>

Atualizar suas dependências do Gradle

Recomendamos manter o serviço de navegação de mídia em um módulo separado que você compartilhe entre o app para smartphones e o módulo automotivo. Se você estiver usando essa abordagem, será necessário atualizar o módulo automotivo para incluir o módulo compartilhado, conforme mostrado no seguinte snippet:

my-auto-module/build.gradle

Groovy

buildscript {
    ...
    dependencies {
        ...
        implementation project(':shared_module_name')
    }
}

Kotlin

buildscript {
    ...
    dependencies {
        ...
        implementation(project(":shared_module_name"))
    }
}

Implementar atividades de configurações e login

Além do serviço de navegação de mídia, você também pode fornecer atividades de configurações e login otimizadas para veículos ao app Android Automotive OS. Essas atividades permitem que você forneça funcionalidades de apps que não estão incluídas nas APIs Android Media.

Implemente essas atividades somente se seu app Android Automotive OS precisar permitir que os usuários façam login ou especifiquem as configurações do app. Essas atividades não são usadas pelo Android Auto.

Fluxos de trabalho de atividades

O diagrama a seguir mostra como um usuário interage com suas atividades de configurações e login usando o Android Automotive OS:

Fluxos de trabalho para atividades de configurações e login

Figura 1. Fluxos de trabalho de atividades de configurações e login

Adicionar uma atividade de configurações

Adicione uma atividade de configurações otimizada para veículos para que os usuários possam definir as configurações do seu app no carro. Sua atividade de configurações também pode fornecer outros fluxos de trabalho, como fazer login ou sair da conta de um usuário ou alternar entre contas. Lembre-se de que essa atividade só é acionada por um app em execução no Android Automotive OS. Os apps para smartphones conectados ao Android Auto não usam esse recurso.

Declarar uma atividade de configurações

Declare sua atividade de configurações no arquivo de manifesto do seu app, conforme mostrado no seguinte snippet de código:

<application>
    ...
    <activity android:name=".AppSettingsActivity"
              android:exported="true"
              android:theme="@style/SettingsActivity"
              android:label="@string/app_settings_activity_title">
        <intent-filter>
            <action android:name="android.intent.action.APPLICATION_PREFERENCES"/>
        </intent-filter>
    </activity>
    ...
</application>

Implementar sua atividade de configurações

Quando um usuário inicia seu app, o Android Automotive OS detecta a atividade de configurações que você declarou e exibe uma funcionalidade, como um ícone. O usuário pode selecionar essa funcionalidade ou tocar nela usando o tela do carro para navegar para a atividade. O Android Automotive OS envia a intent ACTION_APPLICATION_PREFERENCES, que solicita que seu app inicie a atividade de configurações.

O restante desta seção mostra como você pode adaptar o código do app de amostra Universal Android Music Player (UAMP) para implementar uma atividade de configuração para o app.

Para começar, faça o download do exemplo de código:

# Clone the UAMP repository
git clone https://github.com/android/uamp.git

# Fetch the appropriate pull request to your local repository
git fetch origin pull/323/head:NEW_LOCAL_BRANCH_NAME

# Switch to the new branch
git checkout NEW_LOCAL_BRANCH_NAME

Para implementar sua atividade, siga estas etapas:

  1. Copie a pasta automotive/automotive-lib para seu módulo automotivo.
  2. Defina uma árvore de preferências como em automotive/src/main/res/xml/preferences.xml.
  3. Implemente um PreferenceFragmentCompat (consulte SettingsFragment.kt no UAMP) que sua atividade de configurações (consulte SettingsActivity.kt) exibirá. Consulte o Guia de configurações do Android para saber mais.

Ao implementar a atividade de configurações, consulte estas práticas recomendadas para usar alguns dos componentes na biblioteca Preference:

  • Seu app não precisa ter mais de dois níveis de profundidade abaixo da visualização principal na atividade de configurações.
  • Não use uma DropDownPreference. Use uma ListPreference.
  • Componentes organizacionais:
  • Todos os componentes a seguir precisam ter uma key e um title e podem ter um summary e/ou icon:
    • Preference
      • Personalize a lógica no callback onPreferenceTreeClick() da sua implementação PreferenceFragmentCompat.
    • CheckBoxPreference
      • Pode ter summaryOn ou summaryOff em vez de summary para texto condicional.
    • SwitchPreference
      • Pode ter summaryOn ou summaryOff em vez de summary para texto condicional.
      • Pode ter switchTextOn ou switchTextOff.
    • SeekBarPreference
      • Precisa ter min, max e defaultValue.
    • EditTextPreference
      • Precisa ter dialogTitle, positiveButtonText e negativeButtonText.
      • Pode ter dialogMessage e/ou dialogLayoutResource.
    • com.example.android.uamp.automotive.lib.ListPreference
      • É derivado principalmente de ListPreference.
      • Usado para exibir uma lista de escolha única de objetos Preference.
      • Precisa ter uma matriz de entries e entryValues correspondentes.
    • com.example.android.uamp.automotive.lib.MultiSelectListPreference
      • É derivado principalmente de MultiSelectListPreference.
      • Usado para exibir uma lista de múltipla escolha de objetos Preference.
      • Precisa ter uma matriz de entries e entryValues correspondentes.

Adicionar uma atividade de login

Se o app exigir que um usuário faça login antes de usá-lo, adicione uma atividade de login otimizada para veículos que processe o login e o logout do app. Você também pode adicionar fluxos de trabalho de login e logout a uma atividade de configurações, mas precisará usar uma atividade de login dedicada se o app não puder ser usado até que o usuário faça login. Lembre-se de que essa atividade só é acionada por um app em execução no Android Automotive OS. Os apps para smartphones conectados ao Android Auto não usam esse recurso.

Login obrigatório na inicialização do app

Para exigir que um usuário faça login para usar seu app, o serviço de navegação de mídia precisa fazer o seguinte:

  1. No método onLoadChildren() do serviço, enviar um resultado nulo usando o método sendResult().
  2. Definir o PlaybackState da sessão de mídia como STATE_ERROR usando o método setState(). Isso informa ao Android Automotive OS que nenhuma outra operação pode ser executada até que o erro seja resolvido.
  3. Definir o código de erro PlaybackState da sessão de mídia para ERROR_CODE_AUTHENTICATION_EXPIRED. Isso informa ao Android Automotive OS que o usuário precisa de autenticação.
  4. Definir a mensagem de erro PlaybackState da sessão de mídia usando o método setErrorMessage(). Como essa mensagem de erro é voltada para o usuário, a mensagem precisa ser traduzida para a localidade dele.
  5. Definir os extras PlaybackState da sessão de mídia usando o método setExtras(). Inclua as duas chaves a seguir:

O snippet de código a seguir mostra como seu app pode exigir que o usuário faça login antes de usá-lo:

Kotlin

import androidx.media.utils.MediaConstants

val signInIntent = Intent(this, SignInActivity::class.java)
val signInActivityPendingIntent = PendingIntent.getActivity(this, 0,
    signInIntent, 0)
val extras = Bundle().apply {
    putString(
        MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL,
        "Sign in"
    )
    putParcelable(
        MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT,
        signInActivityPendingIntent
    )
}

val playbackState = PlaybackStateCompat.Builder()
        .setState(PlaybackStateCompat.STATE_ERROR, 0, 0f)
        .setErrorMessage(
            PlaybackStateCompat.ERROR_CODE_AUTHENTICATION_EXPIRED,
            "Authentication required"
        )
        .setExtras(extras)
        .build()
mediaSession.setPlaybackState(playbackState)

Java

import androidx.media.utils.MediaConstants;

Intent signInIntent = new Intent(this, SignInActivity.class);
PendingIntent signInActivityPendingIntent = PendingIntent.getActivity(this, 0,
    signInIntent, 0);
Bundle extras = new Bundle();
extras.putString(
    MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL,
    "Sign in");
extras.putParcelable(
    MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT,
    signInActivityPendingIntent);

PlaybackStateCompat playbackState = new PlaybackStateCompat.Builder()
    .setState(PlaybackStateCompat.STATE_ERROR, 0, 0f)
    .setErrorMessage(
            PlaybackStateCompat.ERROR_CODE_AUTHENTICATION_EXPIRED,
            "Authentication required"
    )
    .setExtras(extras)
    .build();
mediaSession.setPlaybackState(playbackState);

Depois que o usuário tiver sido autenticado, seu app precisará definir o PlaybackState novamente para um estado diferente de STATE_ERROR e, em seguida, levará o usuário de volta ao Android Automotive OS chamando o método finish() da atividade.

Implementar sua atividade de login

O Google oferece uma variedade de ferramentas de identidade que podem ser usadas para ajudar os usuários a fazer login no seu app no carro. Algumas ferramentas, como o Firebase Authentication, oferecem kits de ferramentas de pilha completa que podem ajudar a criar experiências de autenticação personalizadas. Outras ferramentas aproveitam as credenciais existentes de um usuário ou outras tecnologias para ajudar a criar experiências de login facilitadas para os usuários.

Recomendamos as seguintes ferramentas para ajudar a criar uma experiência de login mais fácil para usuários já conectados a outro dispositivo:

  • Login do Google: se você já tiver implementado o Login do Google em outros dispositivos (como o app para smartphones), também precisará implementá-lo no seu app Android Automotive OS para oferecer compatibilidade com os usuários do Login do Google.
  • Preenchimento automático do Google: se os usuários tiverem ativado o preenchimento automático do Google em outros dispositivos Android, as credenciais deles serão salvas no Gerenciador de senhas do Google. Assim, quando o usuário fizer login no seu app Android Automotive OS, o preenchimento automático do Google sugerirá as credenciais salvas relevantes. O uso do preenchimento automático do Google não requer esforço de desenvolvimento de apps. No entanto, os desenvolvedores precisam otimizar os apps para ter resultados de melhor qualidade. O preenchimento automático do Google é compatível com todos os dispositivos que executam o Android Oreo 8.0 (API de nível 26) ou mais recente (incluindo o Android Automotive OS).

Usar o AccountManager

Os apps Android Automotive OS que têm autenticação precisam usar o AccountManager pelos seguintes motivos:

  • Melhor UX e gerenciamento de contas facilitado: os usuários podem gerenciar facilmente todas as suas contas do menu de contas nas configurações do sistema, incluindo o login e a saída.
  • Experiências de "convidado": como os carros são dispositivos compartilhados, os OEMs podem ativar experiências de "convidado" no veículo. Nesses casos, não é possível adicionar contas. Essa restrição é alcançada usando DISALLOW_MODIFY_ACCOUNT para AccountManager.

Permissões

Se você precisar solicitar permissões do usuário, use o mesmo fluxo da atividade de autenticação ou de configurações no diagrama de fluxos de trabalho de atividades.

Tratamento de erros

Os erros em apps de música no Android Automotive OS são comunicados por meio do PlaybackState da sessão de mídia. Para todos os erros, defina um código e uma mensagem de erro adequados no PlaybackState. Isso faz com que um Toast apareça na IU.

Quando ocorre um erro, mas a reprodução pode continuar, é necessário emitir um erro não fatal. Por exemplo, um usuário pode tocar música em um app antes de fazer login, mas precisa estar logado para poder pular uma música. Ao usar um erro não fatal, o sistema pode sugerir que o usuário precisa fazer login sem interromper a reprodução do item de mídia atual. Nesse caso, é preciso preservar o restante do PlaybackState no estado em que se encontra, além do código e da mensagem de erro. Essa abordagem permite que a reprodução do item de mídia atual continue enquanto o usuário decide se fará login ou não.

Quando a reprodução não for possível, por exemplo, se não houver conexão de Internet e conteúdo off-line, defina o estado PlaybackState como STATE_ERROR.

Nas atualizações subsequentes do PlaybackState, apague o código e a mensagem de erro para evitar a exibição de vários avisos para o mesmo erro.

Se em algum momento não for possível carregar uma árvore de navegação (por exemplo, se você exigir autenticação e o usuário não tiver feito login), envie uma árvore de navegação vazia. Para representar isso, onLoadChildren() para o nó de mídia raiz retorna um resultado nulo. Quando isso acontece, o sistema exibe um erro em tela cheia com a mensagem de erro definida no PlaybackState.

Erros acionáveis

Se um erro for acionável, defina também os dois extras a seguir no PlaybackState:

Os erros acionáveis aparecem como uma Dialog e podem ser resolvidos pelos usuários somente quando o carro está parado.

Testar casos de erro

Verifique se o app é executado normalmente em todos os cenários, incluindo:

  • Níveis diferentes do produto: por exemplo, sem custos financeiros ou premium, com ou sem login.
  • Estados de direção diferentes: por exemplo, estacionado ou em movimento.
  • Estados de conectividade diferentes: por exemplo, on-line ou off-line.

Outras considerações

Lembre-se destas considerações quando estiver desenvolvendo seu app Android Automotive OS:

Conteúdo off-line

Se for o caso, implemente compatibilidade com a reprodução off-line. Os carros com Android Automotive OS precisam ter conectividade de dados própria, ou seja, um plano de dados incluído no custo do veículo ou pago pelo usuário. No entanto, espera-se que os carros tenham mais conectividade variável do que os dispositivos móveis. Por isso, recomendamos que você pense na melhor estratégia de suporte off-line para seu conteúdo. O espaço em disco nos carros pode variar. Por isso, os usuários precisam conseguir excluir conteúdo off-line, por exemplo, usando uma opção na sua atividade de configurações.

Veja alguns pontos importantes ao considerar sua estratégia de suporte off-line:

  • O melhor momento para fazer o download de conteúdo é quando seu aplicativo está em uso.
  • Não suponha que o Wi-Fi esteja disponível. Um carro pode nunca entrar no alcance do Wi-Fi, ou o OEM pode ter desativado o Wi-Fi em favor de uma rede celular.
  • Não há problema em armazenar em cache o conteúdo que você acredita que os usuários provavelmente usarão, mas é altamente recomendável permitir que esse comportamento seja alterado pelo usuário na atividade de configurações.

Compatibilidade comercial

No momento, o Android Automotive OS não é compatível com nenhuma funcionalidade comercial. Isso significa que não é possível ter um app pago nem permitir compras no seu app. Os usuários podem fazer compras em apps fora do seu aplicativo Android Automotive OS, mas não precisarão realizar outras etapas comerciais no carro para usar novos conteúdos ou recursos pagos.

Compatibilidade com WebView

As WebViews são compatíveis com o Android Automotive OS, mas são permitidas apenas nas atividades de configurações e login. As atividades que usam uma WebView precisam ter uma funcionalidade de fechamento e/ou retorno fora da WebView.

Veja alguns exemplos de casos de uso aceitáveis para WebViews:

  • Exibição da Política de Privacidade, dos Termos de Serviço ou de outros links relacionados à lei no serviço de configurações
  • Um fluxo de login baseado na Web na sua atividade de login

Ao usar uma WebView, você tem permissão para ativar o JavaScript.

Proteger a WebView

Tome todas as precauções para garantir que a WebView não atue como ponto de entrada para a Internet. Veja no snippet de código abaixo um exemplo de como bloquear a WebView para o URL usado na chamada loadUrl() e evitar redirecionamentos. É altamente recomendado implementar proteções como essa quando o caso de uso faz sentido, por exemplo, ao exibir links relacionados à lei.

Kotlin

override fun shouldOverrideUrlLoading(webView: WebView,
                             webResourceRequest: WebResourceRequest): Boolean {
  val originalUri: Uri = Uri.parse(webView.originalUrl)
  // Check for allowed URLs
  if (originalUri.equals(Uri.parse(BLANK_URL))
      || originalUri.equals(webResourceRequest.url)) {
    return false
  }
  if (webResourceRequest.isRedirect) {
    logger.w("Redirect detected, not following")
    return true
  }
  setupWizardWebViewClientListener.onUriBlocked(webResourceRequest.url)
  logger.w(
    String.format(
      "Navigation prevented to %s original is %s", webResourceRequest.url, originalUri))
  return true
}

Java

@Override
public boolean shouldOverrideUrlLoading(WebView webView, WebResourceRequest webResourceRequest) {
  Uri originalUri = Uri.parse(webView.getOriginalUrl());
  // Check for allowed URLs
  if (originalUri.equals(Uri.parse(BLANK_URL))
      || originalUri.equals(webResourceRequest.getUrl())) {
    return false;
  }
  if (webResourceRequest.isRedirect()) {
    logger.w("Redirect detected, not following");
    return true;
  }
  setupWizardWebViewClientListener.onUriBlocked(webResourceRequest.getUrl());
  logger.w(
      String.format(
          "Navigation prevented to %s original is %s", webResourceRequest.getUrl(), originalUri));
  return true;
}

Nomes de pacote

Como você distribui um APK separado para o Android Automotive OS, é possível reutilizar o nome do pacote do seu app para dispositivos móveis ou criar um novo nome de pacote. A principal diferença é que, com outro nome de pacote, o app tem duas páginas "Detalhes do app" completamente separadas na Play Store. Se você reutilizar o nome do pacote atual, terá uma única página "Detalhes do app" nas duas plataformas.

Isso é predominantemente uma decisão comercial. Por exemplo, se você tem uma equipe trabalhando no app para dispositivos móveis e outra completamente separada trabalhando no app Android Automotive OS, pode fazer sentido ter nomes de pacotes diferentes e permitir que cada equipe gerencie as próprias páginas "Detalhes do app". Não há uma grande diferença no esforço técnico necessário para usar qualquer uma das abordagens.

A tabela a seguir resume algumas das principais diferenças entre cada abordagem:

Recurso Mesmo nome de pacote Novo nome do pacote
Página "Detalhes do app" Uma Várias
Instalação espelhada Sim. "Reinstalação rápida de aplicativo" durante o assistente de configuração Não
Processo de análise da Play Store Bloqueio de análises. Atualmente, se a análise falhar para um APK, outros APKs enviados na mesma versão serão bloqueados. Análises individuais
Estatísticas, métricas e vitals Combinados. Observação: você pode filtrar por nome de dispositivo para dados específicos de automóveis (por exemplo, dois carros no ano 2020) Separados
Indexação e classificação na pesquisa Com base na posição atual Não transmite
Integração a outros apps Provavelmente nenhuma alteração será necessária, supondo que o código de mídia seja compartilhado entre os dois APKs. Talvez seja necessário atualizar o app correspondente (por exemplo, para a reprodução de URIs com o Google Assistente).

Perguntas frequentes

Consulte as seções a seguir para ver respostas de algumas perguntas frequentes sobre o Android Automotive OS.

Hardware

Meu app tem acesso ao microfone?

Para apps voltados ao Android 10 (API de nível 29) ou versões mais recentes, consulte a documentação sobre compartilhamento de entrada de áudio. Isso não é viável antes da API de nível 29.

A quais APIs de carro podemos ter acesso e como?

Você está limitado às APIs expostas pelo OEM. Estamos padronizando a forma como você acessa essas APIs.

Os apps podem acessar APIs de carro usando SetProperty() e GetProperty() em CarPropertyManager. Consulte o código-fonte ou a documentação de referência para ver uma lista de todas as propriedades disponíveis. Se a propriedade estiver anotada com @SystemApi, ela será limitada a apps do sistema (pré-carregados).

Quais tipos de codecs de áudio são compatíveis?

Consulte os detalhes de codecs de áudio no CDD do Android.

O DRM da Widevine é compatível?

Sim. O DRM da Widevine (link em inglês) é compatível.

Desenvolvimento e teste

Há restrições ou recomendações quanto ao uso de SDKs e bibliotecas de terceiros?

Não temos diretrizes específicas sobre o uso de SDKs e bibliotecas de terceiros. Se você optar por usar SDKs e bibliotecas de terceiros, ainda será responsável por obedecer a todos os requisitos de qualidade de apps para carros.

Posso usar um serviço em primeiro plano?

O único caso de uso permitido para um serviço em primeiro plano é o download de conteúdo para uso off-line. Se você quiser a compatibilidade com outro caso de uso para um serviço em primeiro plano, entre em contato com nossa equipe usando o grupo de discussão do Android Automotive OS.

Publicar apps Android Automotive OS

Como faço para publicar meu app Android Automotive OS usando o Google Play Console?

O processo de publicação é semelhante à publicação do seu app para smartphones, mas você usa um tipo de versão diferente. Para que seu app use o tipo de versão do Android Automotive OS, siga estas etapas:

  1. Abra o Play Console.
  2. Selecione seu app.
  3. No menu à esquerda, selecione Versão > Configuração > Configurações avançadas > Tipos de versão.
  4. Selecione Adicionar tipo de versão > Android Automotive OS e siga as instruções no Play Console.

Outros recursos

Para saber mais sobre o Android Automotive OS, consulte os seguintes recursos adicionais.

Amostras

Guias

Blogs

Vídeos

Informar um problema de mídia no SO Android Automotive

Se você encontrar um problema ao desenvolver seu app de mídia para o SO Android Automotive, poderá informá-lo usando o Google Issue Tracker. Preencha todas as informações solicitadas no modelo de problema.

Criar novo problema

Antes de informar um novo problema, verifique se ele já foi informado na lista de problemas. Inscreva-se e vote nos problemas clicando na estrela de um deles na lista de problemas. Para ver mais informações, consulte Como se inscrever em um problema.