Skip to content

Most visited

Recently visited

navigation

Adicione código C e C++ ao seu projeto

Usando o Android Studio 2.2 ou posterior com o Android Plugin para Gradle versão 2.2.0 ou superior, é possível adicionar código C e C++ ao seu aplicativo compilando-o em uma biblioteca nativa que o Gradle pode empacotar com o APK. O código Java pode chamar funções na biblioteca nativa por meio da Java Native Interface (JNI). Se você quiser saber mais sobre o uso do framework JNI, leia Dicas do JNI para Android.

A ferramenta de compilação padrão do Android Studio para bibliotecas nativas é o CMake. O Android Studio também é compatível com o ndk-build pelo grande número de projetos existentes que usa esse kit de ferramentas de compilação para compilar código nativo. Para importar uma biblioteca existente do ndk-build para um projeto Android Studio, consulte a seção sobre como configurar o Gradle para vincular à biblioteca nativa. No entanto, se você estiver criando uma nova biblioteca nativa, deverá usar o CMake.

Esta página fornece as informações necessárias para configurar o Android Studio com as ferramentas de compilação necessárias, criar ou configurar um projeto compatível com código nativo no Android e criar e executar um aplicativo.

Observação: se o projeto existente usar a ferramenta obsoleta ndkCompile, abra o arquivo build.properties e remova a seguinte linha de código antes de vincular o Gradle à sua biblioteca nativa:

// Remove this line
android.useDeprecatedNdk = true

Atenção, usuários experimentais do Gradle: considerem migrar para o plug-in versão 2.2.0 ou posterior e usar o CMake ou o ndk-build para criar bibliotecas nativas se alguma das condições a seguir se aplicar: o projeto nativo já usa CMake ou ndk-build; você prefere usar uma versão estável do sistema de compilação Gradle; ou você quer compatibilidade com ferramentas de complementos, como CCache. Caso contrário, você pode continuar a usar a versão experimental do Gradle e o plug-in do Android.

Baixe o NDK e o Build Tools

Para compilar e depurar código nativo para um aplicativo, serão necessários os seguintes componentes:

Para instalar esses componentes, use o SDK Manager:

  1. Em um projeto aberto, selecione Tools > Android > SDK Manager na barra de menus.
  2. Clique na guia SDK Tools.
  3. Marque as caixas ao lado de LLDB, CMake e NDK, como mostrado na figura 1.

    Figura 1. Instalação do LLDB, CMake e NDK a partir do SDK Manager.

  4. Clique em Apply e clique em OK na caixa de diálogo pop-up.
  5. Após a instalação, clique em Finish e em OK.

Criar um novo projeto compatível com C/C++

A criação de um novo projeto compatível com código nativo é semelhante à criação de qualquer outro projeto do Android Studio, mas com algumas etapas adicionais:

  1. Na seção Configure your new project do assistente, marque a caixa de seleção Include C++ Support.
  2. Clique em Next.
  3. Preencha todos os outros campos e as próximas seções do assistente da forma normal.
  4. Na seção Customize C++ Support do assistente, você pode personalizar o projeto com as seguintes opções:
    • C++ Standard: use a lista suspensa para selecionar a padronização desejada para o C++. A seleção de Toolchain Default usa a configuração padrão do CMake.
    • Exceptions Support: marque essa caixa se quiser ativar a compatibilidade para o processamento de exceções do C++. Se ativada, o Android Studio adiciona o sinalizador -fexceptions a cppFlags no arquivo build.gradle do módulo, que o Gradle passa ao CMake.
    • Runtime Type Information Support: marque essa caixa se quiser compatibilidade com RTTI. Se ativada, o Android Studio adiciona o sinalizador -frtti a cppFlags no arquivo build.gradle do módulo, que o Gradle passa ao CMake.
  5. Clique em Finish.

Depois que o Android Studio concluir a criação do novo projeto, abra o painel Project no lado esquerdo do IDE e selecione a visualização Android. Como mostrado na figura 2, o Android Studio adiciona os grupos cpp e External Build Files:

    Figura 2. Grupos de visualização do Android para origens nativas e scripts de compilação externos.

    Observação: Essa visualização não reflete a hierarquia de arquivos real no disco, mas agrupa arquivos similares para simplificar a navegação no projeto.

  1. O grupo cpp é onde você pode encontrar todos os arquivos de origem, cabeçalhos e bibliotecas pré-compiladas que fazem parte do projeto. Para novos projetos, o Android Studio cria um arquivo de origem C++ de exemplo, native-lib.cpp, e coloca-o no diretório src/main/cpp/ do módulo do aplicativo. Esse exemplo de código oferece uma função C++ simples, stringFromJNI(), que retorna a string "Hello from C++". Para aprender a adicionar mais arquivos de origem ao projeto, veja a seção Criar novos arquivos de origem nativos.
  2. O grupo External Build Files é onde você pode encontrar scripts de compilação para o CMake ou o ndk-build. Da mesma forma que os arquivos build.gradle informam ao Gradle como criar um aplicativo, o CMake e o ndk-build precisam de um script de compilação para saber como compilar a biblioteca nativa. Para novos projetos, o Android Studio cria um script de compilação do CMake, CMakeLists.txt, e coloca-o no diretório raiz do módulo. Para saber mais sobre o conteúdo desse script de compilação, veja a seção Criar um script de compilação do CMake.

Criar e executar o aplicativo de amostra

Ao clicar em Run executar e depois executar aplicativo da barra de menus, o Android Studio compila e inicia um aplicativo que exibe o texto "Hello from C++" no dispositivo ou emulador Android. A visão geral a seguir descreve os eventos que podem ocorrer na compilação e execução do aplicativo de amostra:

  1. O Gradle chama o script de compilação externa CMakeLists.txt.
  2. O CMake segue os comandos no script de compilação para compilar um arquivo de origem C++, native-lib.cpp, para uma biblioteca de objetos compartilhada de nome libnative-lib.so, que o Gradle empacota no APK.
  3. Durante o tempo de execução, o MainActivity do aplicativo carrega a biblioteca nativa usando System.loadLibrary(). A função nativa da biblioteca stringFromJNI() está agora disponível para o aplicativo.
  4. MainActivity.onCreate() chama stringFromJNI(), que retorna "Hello from C++", que é usado para atualizar a TextView.

Observação: Instant Run não é compatível com projetos que usam código nativo. O Android Studio desativa automaticamente esse recurso.

Se você quiser verificar se o Gradle empacota a biblioteca nativa no APK, você pode usar o APK Analyzer:

  1. Selecione Build > Analyze APK.
  2. Selecione o APK no diretório app/build/outputs/apk/ e clique em OK.
  3. Como mostrado na figura 3, você pode ver libnative-lib.so na janela do APK Analyzer em lib/<ABI>/.

    Figura 3. Localização de uma biblioteca nativa usando o APK Analyzer.

Dica: se você quiser experimentar com outros aplicativos Android que usam código nativo, clique em File > New > Import Sample e selecione um projeto de amostra na mesma lista Ndk.

Adicionar código C/C++ a um projeto existente

Se você quiser adicionar código nativo a um projeto existente, execute estas etapas:

  1. Crie novos arquivos de origem nativos e adicione-os ao projeto do Android Studio.
    • Você pode ignorar esta etapa se já tiver código nativo ou quiser importar uma biblioteca nativa pré-compilada.
  2. Crie um script de compilação do CMake para compilar o código-fonte nativo em uma biblioteca. Esse script de compilação também será necessário se você importar e compilar usando bibliotecas pré-compiladas ou da plataforma.
    • Se você tiver uma biblioteca nativa que já tem um script de compilação CMakeLists.txt ou usar o ndk-build e incluir um script de compilação Android.mk, poderá ignorar esta etapa.
  3. Forneça um caminho para o arquivo de script do CMake ou do ndk-build para vincular o Gradle à sua biblioteca nativa. O Gradle usa o script de compilação para importar código-fonte ao projeto do Android Studio e incorporar a biblioteca nativa (o arquivo SO) ao APK.

Após configurar o projeto, você pode acessar as funções nativas no código Java usando o framework JNI. Para compilar e executar seu aplicativo, basta clicar em Run executar e depois executar aplicativo da barra de menus. O Gradle adiciona o processo externo de compilação nativa como uma dependência para compilar, criar e empacotar a biblioteca nativa com o APK.

Criar novos arquivos de origem nativos

Para criar um diretório cpp/ com os novos arquivos de origem nativos no conjunto de origem do módulo do aplicativo, faça o seguinte:

  1. Abra o painel Project no lado esquerdo do IDE e selecione a visualização Project no menu suspenso.
  2. Navegue até seu-módulo > src, clique com o botão direito no diretório main e selecione New > Directory.
  3. Insira um nome para o diretório (como cpp) e clique em OK.
  4. Clique com o botão direito no diretório recém-criado e selecione New > C/C++ Source File.
  5. Insira um nome para o arquivo de origem, como native-lib.
  6. No menu suspenso Type, selecione a extensão de arquivo do arquivo de origem, como .cpp.
    • Para adicionar outros tipos de arquivo ao menu suspenso, como .cxx ou .hxx, clique em Edit File Types . Na caixa de diálogo C/C++ do pop-up, selecione outra extensão de arquivo dos menus suspensos Source Extension e Header Extension e clique em OK.
  7. Se você também quiser criar um arquivo de cabeçalho, marque a caixa de seleção Create an associated header.
  8. Clique em OK.

Criar um script de compilação do CMake

Se as origens nativas ainda não têm um script de compilação do CMake, será necessário criar e incluir um desses scripts nos comandos apropriados do CMake. Um script de compilação do CMake é um arquivo de texto simples que deve ter o nome CMakeLists.txt. Esta seção cobre alguns comandos básicos que devem ser incluídos no script de compilação para informar ao CMake quais origens devem ser usadas na criação da biblioteca nativa.

Observação: se o projeto incluir o ndk-build, não será necessário criar um script de compilação do CMake. Para vincular o Gradle à biblioteca nativa, informe um caminho para o arquivo Android.mk.

Para criar um arquivo de texto simples que possa ser usado como script de compilação do CMake, faça o seguinte:

  1. Abra o painel Project no lado esquerdo do IDE e selecione a visualização Project no menu suspenso.
  2. Clique com o botão direito no diretório raiz do seu-módulo e selecione New > File.

    Observação: você pode criar o script de compilação no local que quiser. No entanto, ao configurá-lo, os caminhos para os arquivos de origem e bibliotecas nativos são relativos ao local do script de compilação.

  3. Insira "CMakeLists.txt" como nome do arquivo e clique em OK.

Agora é possível configurar o script de compilação adicionando comandos do CMake. Para instruir o CMake a criar uma biblioteca nativa com o código-fonte nativo, adicione os comandos cmake_minimum_required() e add_library() ao script de compilação:

# Sets the minimum version of CMake required to build your native library.
# This ensures that a certain set of CMake features is available to
# your build.

cmake_minimum_required(VERSION 3.4.1)

# Specifies a library name, specifies whether the library is STATIC or
# SHARED, and provides relative paths to the source code. You can
# define multiple libraries by adding multiple add.library() commands,
# and CMake builds them for you. When you build your app, Gradle
# automatically packages shared libraries with your APK.

add_library( # Specifies the name of the library.
             native-lib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             src/main/cpp/native-lib.cpp )

Quando você adiciona um arquivo ou biblioteca de origem ao script de compilação do CMake usando add_library(), o Android Studio também mostra os arquivos de cabeçalho associados na visualização Project após a sincronização do projeto. No entanto, para que o CMake localize os arquivos de cabeçalho durante a compilação, será necessário adicionar o comando include_directories() ao script de compilação do CMake e especificar o caminho até os cabeçalhos:

add_library(...)

# Specifies a path to native header files.
include_directories(src/main/cpp/include/)

A convenção de nomenclatura usada pelo CMake para os arquivos da biblioteca é a seguinte:

liblibrary-name.so

Por exemplo, se você especificar "native-lib" como o nome da biblioteca compartilhada no script de compilação, o CMake criará um arquivo denominado libnative-lib.so. No entanto, para carregar essa biblioteca no código Java, use o nome especificado no script de compilação do CMake:

static {
    System.loadLibrary(“native-lib”);
}

Observação: se você renomear ou remover uma biblioteca no script de compilação do CMake, será necessário limpar o projeto antes que o Gradle aplique as alterações ou remova a versão antiga da biblioteca do APK. Para limpar o projeto, selecione Build > Clean Project na barra de menus.

O Android Studio adiciona automaticamente os arquivos de origem e cabeçalhos ao grupo cpp no painel Project. O uso de vários comandos add_library() permite definir bibliotecas adicionais para o CMake use outros arquivos de origem para a compilação.

Adicionar APIs do NDK

O Android NDK oferece um conjunto de APIs e bibliotecas nativas que podem ser úteis. Você pode usar qualquer uma dessas APIs incluindo as bibliotecas do NDK no arquivo de script CMakeLists.txt no seu projeto.

A plataforma Android já tem bibliotecas do NDK pré-compiladas. Portanto, não será necessário compilar ou empacotar essas bibliotecas no APK. Como as bibliotecas do NDK já fazem parte do caminho de pesquisa do CMake, não é necessário especificar o local da biblioteca na instalação local do NDK: basta informar o nome da biblioteca que você quer usar ao CMake e vinculá-la com a sua biblioteca nativa.

Adicione o comando find_library() ao script de compilação do CMake para localizar uma biblioteca do NDK e armazenar seu caminho como variável. Use essa variável como referência à biblioteca do NDK em outras partes do script de compilação. O exemplo a seguir localiza a biblioteca de suporte de registro específica do Android e armazena seu caminho em log-lib:

find_library( # Defines the name of the path variable that stores the
              # location of the NDK library.
              log-lib

              # Specifies the name of the NDK library that
              # CMake needs to locate.
              log )

Para que a biblioteca nativa chame funções na biblioteca log, é necessário vincular as bibliotecas usando o comando target_link_libraries() no script de compilação do CMake:

find_library(...)

# Links your native library against one or more other native libraries.
target_link_libraries( # Specifies the target library.
                       native-lib

                       # Links the log library to the target library.
                       ${log-lib} )

O NDK também contém algumas bibliotecas como código-fonte que é preciso compilar e vincular à biblioteca nativa. Para compilar o código-fonte para uma biblioteca nativa, use o comando add_library() no script de compilação do CMake. Para informar um caminho à biblioteca do NDK local, você pode usar a variável de caminho ANDROID_NDK, definida automaticamente pelo Android Studio.

O comando a seguir instrui o CMake a compilar android_native_app_glue.c, que gerencia eventos de ciclo de vida e entradas por toque de NativeActivity, para uma biblioteca estática e vinculá-la à native-lib:

add_library( app-glue
             STATIC
             ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c )

# You need to link static libraries against your shared native library.
target_link_libraries( native-lib app-glue ${log-lib} )

Adicionar outras bibliotecas pré-compiladas

A adição de uma biblioteca pré-compilada é semelhante à especificação de outra biblioteca nativa para compilação pelo CMake. No entanto, como a biblioteca já está compilada, é necessário usar o sinalizador IMPORTED para informar ao CMake que importe somente a biblioteca no projeto:

add_library( imported-lib
             SHARED
             IMPORTED )

Em seguida, é preciso especificar o caminho para a biblioteca usando o comando set_target_properties(), como mostrado abaixo.

Algumas bibliotecas fornecem pacotes separados para arquiteturas específicas de CPU, ou Application Binary Interfaces (ABIs), e as organizam em diretórios separados. Essa abordagem ajuda as bibliotecas a aproveitar determinadas arquiteturas de CPU, sem impedir que você use apenas as versões da biblioteca que quiser. Para adicionar várias versões de ABI de uma biblioteca ao script de compilação do CMake, sem ter de codificar vários comandos para cada versão da biblioteca, use a variável de caminho ANDROID_ABI. Essa variável usa uma lista das ABIs padrão compatíveis com o NDK ou uma lista filtrada de ABIs configurada manualmente no Gradle para sua utilização. Por exemplo:

add_library(...)
set_target_properties( # Specifies the target library.
                       imported-lib

                       # Specifies the parameter you want to define.
                       PROPERTIES IMPORTED_LOCATION

                       # Provides the path to the library you want to import.
                       imported-lib/src/${ANDROID_ABI}/libimported-lib.so )

Para que o CMake localize os arquivos de cabeçalho durante a compilação, é preciso usar o comando include_directories() e incluir o caminho para os arquivos de cabeçalho:

include_directories( imported-lib/include/ )

Observação: se você quiser empacotar uma biblioteca pré-compilada que não seja uma dependência em tempo de compilação (por exemplo, ao adicionar uma biblioteca pré-compilada que seja uma dependência de imported-lib), não será necessário seguir as instruções abaixo para vincular a biblioteca.

Para vincular a biblioteca pré-compilada à biblioteca nativa, adicione-a ao comando target_link_libraries() no script de compilação do CMake:

target_link_libraries( native-lib imported-lib app-glue ${log-lib} )

Quando você compila o aplicativo, o Gradle empacota automaticamente a biblioteca importada no APK. É possível verificar quais bibliotecas foram empacotadas pelo Gradle no APK usando o APK Analyzer. Para obter mais informações sobre os comandos do CMake, consulte a documentação do CMake.

Para vincular o Gradle à sua biblioteca nativa, é preciso fornecer um caminho para o arquivo de script do CMake ou do ndk-build. Quando você compila um aplicativo, o Gradle executa o CMake ou o ndk-build como uma dependência e empacota as bibliotecas compartilhadas no APK. Além disso, o Gradle usa o script de compilação para saber quais arquivos devem ser incorporados ao projeto do Android Studio para que possam ser acessados na janela Project. Se você não tiver um script de compilação para as origens nativas, precisa criar um script de compilação do CMake antes de prosseguir.

Após vincular o Gradle a um projeto nativo, o Android Studio atualiza o painel Project para mostrar os arquivos de origem e as bibliotecas nativas no grupo cpp e os scripts de compilação externos no grupo External Build Files.

Observação: ao alterar a configuração do Gradle, assegure a aplicação das alterações clicando em Sync Project na barra de ferramentas. Além disso, ao alterar o arquivo de script do CMake ou do ndk-build após vinculá-lo ao Gradle, selecione Build > Refresh Linked C++ Projects na barra de menus para sincronizar o Android Studio com as alterações.

Você pode usar a IU do Android Studio para vincular o Gradle a um projeto externo do CMake ou do ndk-build:

  1. Abra o painel Project no lado esquerdo do IDE e selecione a visualização Android.
  2. Clique com o botão direito no módulo que quer vincular à biblioteca nativa, como o módulo app e selecione Link C++ Project with Gradle no menu. Você deve ver uma caixa de diálogo semelhante à mostrada na figura 4.
  3. No menu suspenso, selecione CMake ou ndk-build.
    1. Se você selecionar CMake, use o campo próximo a Project Path para especificar o arquivo de script CMakeLists.txt para o projeto externo do CMake.
    2. Se você selecionar ndk-build, use o campo próximo a Project Path para especificar o arquivo de script Android.mk para o projeto externo do ndk-build. O Android Studio também inclui o arquivo Application.mk se estiver localizado no mesmo diretório do arquivo Android.mk.

    Figura 4. Vinculação a um projeto C++ externo usando a caixa de diálogo do Android Studio.

  4. Clique em OK.

Configurar manualmente o Gradle

Para configurar manualmente o Gradle para vincular à biblioteca nativa, é preciso adicionar o bloco externalNativeBuild {} ao arquivo build.gradle do módulo e configurá-lo com cmake {} ou ndkBuild {}:

android {
  ...
  defaultConfig {...}
  buildTypes {...}

  // Encapsulates your external native build configurations.
  externalNativeBuild {

    // Encapsulates your CMake build configurations.
    cmake {

      // Provides a relative path to your CMake build script.
      path "CMakeLists.txt"
    }
  }
}

Observação: para vincular o Gradle a um projeto existente do ndk-build, use o bloco ndkBuild {} em vez de cmake {} e informe um caminho relativo para o arquivo Android.mk. O Gradle também incluirá o arquivo Application.mk se ele se localizar no mesmo diretório do arquivo Android.mk.

Especificar configurações opcionais

Para especificar argumentos e sinalizadores opcionais para o CMake ou o ndk-build, configure outro bloco externalNativeBuild {} dentro do bloco defaultConfig {} do arquivo build.gradle do módulo. Da mesma forma que em outras propriedades no bloco defaultConfig {}, é possível modificar essas propriedades para cada variação de produto na configuração da compilação.

Por exemplo: se o projeto do CMake ou do ndk-build definir várias bibliotecas nativas, você poderá usar a propriedade targets para compilar e empacotar apenas um subconjunto dessas bibliotecas para uma determinada variação de produto. A amostra de código a seguir descreve algumas propriedades que podem ser configuradas:

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {

      // For ndk-build, instead use ndkBuild {}
      cmake {

        // Passes optional arguments to CMake.
        arguments "-DANDROID_ARM_NEON=TRUE", "-DANDROID_TOOLCHAIN=clang"

        // Sets optional flags for the C compiler.
        cFlags "-D_EXAMPLE_C_FLAG1", "-D_EXAMPLE_C_FLAG2"

        // Sets a flag to enable format macro constants for the C++ compiler.
        cppFlags "-D__STDC_FORMAT_MACROS"
      }
    }
  }

  buildTypes {...}

  productFlavors {
    ...
    demo {
      ...
      externalNativeBuild {
        cmake {
          ...
          // Specifies which native libraries to build and package for this
          // product flavor. If you don't configure this property, Gradle
          // builds and packages all shared object libraries that you define
          // in your CMake or ndk-build project.
          targets "native-lib-demo"
        }
      }
    }

    paid {
      ...
      externalNativeBuild {
        cmake {
          ...
          targets "native-lib-paid"
        }
      }
    }
  }

  // Use this block to link Gradle to your CMake or ndk-build script.
  externalNativeBuild {
    cmake {...}
    // or ndkBuild {...}
  }
}

Para saber mais sobre a configuração de variações de produtos e compilação, consulte Configurar variantes de compilação. Para obter uma lista de variáveis que podem ser configuradas para o CMake com a propriedade arguments, consulte Usar variáveis do CMake.

Especificar ABIs

Por padrão, o Gradle compila a biblioteca nativa em arquivos .so separados para as ABIs compatíveis com o NDK e empacota elas todas no APK. Se quiser que o Gradle compile e empacote apenas determinadas configurações de ABI das bibliotecas nativas, você poderá especificá-las com o sinalizador ndk.abiFilters no arquivo build.gradle do módulo, como mostrado abaixo:

android {
  ...
  defaultConfig {
    ...
    externalNativeBuild {
      cmake {...}
      // or ndkBuild {...}
    }

    ndk {
      // Specifies the ABI configurations of your native
      // libraries Gradle should build and package with your APK.
      abiFilters 'x86', 'x86_64', 'armeabi', 'armeabi-v7a',
                   'arm64-v8a'
    }
  }
  buildTypes {...}
  externalNativeBuild {...}
}

Na maioria dos casos, basta especificar abiFilters no bloco ndk {}, como mostrado acima, pois isso instrui o Gradle a compilar e compactar essas versões das bibliotecas nativas. No entanto, se você quiser controlar o que o Gradle deve compilar, independentemente do que você quer que ele empacote no APK, configure outro sinalizador abiFilters no bloco defaultConfig.externalNativeBuild.cmake {} (ou no bloco defaultConfig.externalNativeBuild.ndkBuild {}). O Gradle compila essas configurações de ABI, mas empacota apenas as especificadas no bloco defaultConfig.ndk{}.

Para reduzir ainda mais o tamanho do APK, considere a configuração de divisões de APKs de ABI. Em vez de criar um único APK grande, com todas as versões das bibliotecas nativas, o Gradle cria um APK separado para cada ABI compatível e empacota apenas os arquivos necessários para cada ABI. Se você configurar uma divisão de ABIs sem especificar o sinalizador abiFilters como mostrado na amostra de código acima, o Gradle compilará todas as versões compatíveis de ABI das bibliotecas nativas, mas empacotará apenas as versões especificadas na configuração de divisão de ABIs. Para evitar a compilação das bibliotecas nativas indesejadas, informe a mesma lista de ABIs para o sinalizador abiFilters e a sua configuração de divisão de ABIs.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience.
(Sep 2017 survey)