Nível da API: 19
O Android 4.4 (KITKAT) é uma nova versão da plataforma Android que oferece novos recursos para usuários e desenvolvedores de apps. Este documento apresenta uma introdução às novas APIs mais importantes.
Como desenvolvedor de apps, faça o download da imagem do sistema do Android 4.4 e da plataforma do SDK no SDK Manager assim que possível. Se você não tiver um dispositivo com o Android 4.4 para testar o app, use a imagem do sistema do Android 4.4 para testar o app no Android Emulator. Em seguida, crie seus apps na plataforma Android 4.4 para começar a usar as APIs mais recentes.
Atualizar o nível desejado da API
Para otimizar melhor seu app para dispositivos com o Android 4.4,
defina o targetSdkVersion como
"19", instale-o em uma imagem do sistema Android 4.4,
teste-o e publique uma atualização com essa mudança.
É possível usar APIs no Android 4.4 e, ao mesmo tempo, oferecer suporte a versões mais antigas adicionando
condições ao código que verificam o nível da API do sistema antes de executar
APIs não compatíveis com o minSdkVersion.
Para saber mais sobre como manter a compatibilidade com versões anteriores, leia Suporte a diferentes
versões da plataforma.
Para mais informações sobre como os níveis da API funcionam, leia O que é o nível da API?.
Mudanças importantes de comportamento
Se você já publicou um app para Android, saiba que ele pode ser afetado pelas mudanças no Android 4.4.
Se o app ler dados do armazenamento externo…
Seu app não pode ler arquivos compartilhados no armazenamento externo quando executado no Android 4.4, a menos que tenha a permissão READ_EXTERNAL_STORAGE. Ou seja, os arquivos no diretório retornado por getExternalStoragePublicDirectory() não podem mais ser acessados sem a permissão. No entanto, se você precisar acessar apenas os diretórios específicos do app, fornecidos por getExternalFilesDir(), não será necessário ter a permissão READ_EXTERNAL_STORAGE.
Se o app usa WebView…
Seu app pode se comportar de maneira diferente ao ser executado no Android 4.4, especialmente quando você atualiza o targetSdkVersion do app para "19" ou mais recente.
O código que serve de base para a classe WebView e as APIs relacionadas foi atualizado para se basear em um snapshot moderno do código-fonte do Chromium. Isso traz várias melhorias de desempenho, suporte para novos recursos de HTML5 e suporte para depuração remota do conteúdo do WebView. O escopo desse upgrade significa que, se o app usar WebView, o comportamento dele poderá ser afetado em alguns casos. Embora as mudanças de comportamento conhecidas estejam documentadas e afetem o app principalmente quando você atualiza o targetSdkVersion para "19" ou mais recente, o novo WebView opera no "modo quirks" para oferecer algumas funcionalidades legadas em apps que têm como nível desejado da API o 18 ou anterior. É possível que seu app dependa de comportamentos desconhecidos da versão anterior do WebView.
Portanto, se o app atual usa WebView, é importante testar no Android 4.4 assim que possível e consultar Migrar para o WebView no Android 4.4 para saber como o app pode ser afetado ao atualizar o targetSdkVersion para "19" ou mais recente.
Se o app usa o AlarmManager…
Quando você define o targetSdkVersion do app como "19" ou mais recente, os alarmes criados usando set() ou setRepeating() são inexatos.
Para melhorar a eficiência de energia, o Android agora agrupa os alarmes de todos os apps que ocorrem em horários razoavelmente semelhantes para que o sistema ative o dispositivo uma vez, em vez de várias vezes, para processar cada alarme.
Se o alarme não estiver associado a um horário exato, mas ainda for importante que ele seja invocado durante um período específico (como entre 14h e 16h), use o novo método setWindow(), que aceita um horário "mais cedo" para o alarme e uma "janela" de tempo após o horário mais cedo em que o sistema precisa invocar o alarme.
Se o alarme precisar ser fixado em um horário exato (como para um lembrete de evento da agenda), use o novo método setExact().
Esse comportamento de loteamento inexato se aplica apenas a apps atualizados. Se você definiu o targetSdkVersion como "18" ou anterior, os alarmes vão continuar se comportando como nas versões anteriores ao serem executados no Android 4.4.
Se o app sincroniza dados usando o ContentResolver…
Quando você define o targetSdkVersion do app como "19" ou mais recente, a criação de uma sincronização com addPeriodicSync() realiza as operações de sincronização em um intervalo flexível padrão de aproximadamente 4% do período especificado. Por exemplo, se a frequência de sondagem for de 24 horas, a operação de sincronização poderá ocorrer em uma janela de aproximadamente uma hora por dia, em vez de exatamente no mesmo horário todos os dias.
Para especificar seu próprio intervalo flexível para operações de sincronização, comece a usar o novo método requestSync(). Para mais detalhes, consulte a seção abaixo sobre adaptadores de sincronização.
Esse comportamento de intervalo flexível se aplica apenas a apps atualizados. Se você tiver definido o targetSdkVersion como "18" ou anterior, as solicitações de sincronização atuais vão continuar se comportando como nas versões anteriores ao serem executadas no Android 4.4.
Framework de impressão
O Android agora inclui um framework completo que permite aos usuários imprimir qualquer documento usando uma impressora conectada por Wi-Fi, Bluetooth ou outros serviços. O sistema processa a transação entre um app que quer imprimir um documento e os serviços que entregam os jobs de impressão para uma impressora. O framework android.print fornece todas as APIs necessárias para especificar um documento de impressão e enviá-lo ao sistema para impressão. As APIs necessárias para um determinado trabalho de impressão dependem do conteúdo.
Como imprimir conteúdo genérico
Se você quiser imprimir o conteúdo da interface como um documento, primeiro crie uma subclasse de PrintDocumentAdapter. Nessa classe, você precisa implementar alguns métodos de callback, incluindo onLayout() para estabelecer o layout com base nas propriedades de impressão fornecidas e onWrite() para serializar o conteúdo imprimível em um ParcelFileDescriptor.
Para gravar seu conteúdo no ParcelFileDescriptor, é necessário transmitir um PDF. As novas APIs PdfDocument oferecem uma maneira conveniente de fazer isso, fornecendo um Canvas de getCanvas(), em que é possível desenhar o conteúdo para impressão. Em seguida, grave o PdfDocument no ParcelFileDescriptor usando o método writeTo().
Depois de definir a implementação para PrintDocumentAdapter, você pode executar trabalhos de impressão mediante solicitação do usuário usando o método PrintManager, print(), que usa o PrintDocumentAdapter como um dos argumentos.
Como imprimir imagens
Se você quiser imprimir apenas uma foto ou outro bitmap, as APIs auxiliares na biblioteca de suporte farão todo o trabalho para você. Basta criar uma nova instância de PrintHelper, definir o modo de escala com setScaleMode() e transmitir o Bitmap para printBitmap(). É isso. A biblioteca processa todas as interações restantes com o sistema para entregar o bitmap à impressora.
Serviços de impressão de edifícios
Como OEM de impressora, você pode usar o framework android.printservice para oferecer interoperabilidade com suas impressoras em dispositivos Android. É possível criar e distribuir serviços de impressão como APKs, que os usuários podem instalar nos dispositivos . Um app de serviço de impressão funciona principalmente como um serviço headless, criando uma subclasse da classe PrintService, que recebe os trabalhos de impressão do sistema e os comunica às impressoras usando os protocolos adequados.
Para mais informações sobre como imprimir o conteúdo do app, leia Como imprimir conteúdo.
Provedor de SMS
O provedor de conteúdo Telephony (o "provedor de SMS") permite que os apps leiam e gravem mensagens SMS e MMS no dispositivo. Ele inclui tabelas para mensagens SMS e MMS recebidas, rascunhadas, enviadas, pendentes e muito mais.
A partir do Android 4.4, as configurações do sistema permitem que os usuários selecionem um "app de SMS padrão". Depois de selecionado, apenas o app de SMS padrão pode gravar no provedor de SMS e apenas o app de SMS padrão recebe a transmissão SMS_DELIVER_ACTION quando o usuário recebe um SMS ou a transmissão WAP_PUSH_DELIVER_ACTION quando o usuário recebe um MMS. O app de SMS padrão é responsável por gravar detalhes no provedor de SMS quando recebe ou envia uma nova mensagem.
Outros apps que não estão selecionados como o app de SMS padrão só podem ler o provedor de SMS, mas também podem ser notificados quando um novo SMS chega, detectando a transmissão SMS_RECEIVED_ACTION, que não pode ser cancelada e pode ser enviada para vários apps. Essa transmissão é destinada a apps que, embora não estejam selecionados como o App de SMS padrão, precisam ler mensagens recebidas especiais, como para realizar a verificação de número de telefone.
Para mais informações, leia a postagem do blog Getting Your SMS Apps Ready for KitKat (em inglês).
Redes sem fio e conectividade
Emulação de cartão host
Agora, os apps Android podem emular cartões NFC ISO14443-4 (ISO-DEP) que usam APDUs para troca de dados (conforme especificado na ISO7816-4). Isso permite que um dispositivo com NFC que executa o Android 4.4 emule vários cartões NFC ao mesmo tempo e que um terminal de pagamento por aproximação ou outro leitor de NFC inicie uma transação com o cartão NFC apropriado com base no identificador do aplicativo (AID).
Se você quiser emular um cartão NFC que usa esses protocolos no seu app, crie um componente de serviço com base na classe HostApduService. Por outro lado, se o app usar um elemento de segurança para emulação de cartão, será necessário criar um serviço com base na classe OffHostApduService, que não vai estar diretamente envolvido nas transações, mas é necessário para registrar os AIDs que devem ser processados pelo elemento de segurança.
Para mais informações, leia o guia Emulação de cartão NFC.
Modo de leitura NFC
Um novo modo de leitor de NFC permite que uma atividade restrinja todas as atividades de NFC à leitura apenas dos tipos de tags de interesse da atividade enquanto estiver em primeiro plano. É possível ativar o modo de leitura para sua atividade com enableReaderMode(), fornecendo uma implementação de NfcAdapter.ReaderCallback que recebe um callback quando novas tags são detectadas.
Esse novo recurso, em conjunto com a emulação de cartão host, permite que o Android opere nas duas extremidades de uma interface de pagamento com smartphone: um dispositivo opera como o terminal de pagamento (um dispositivo que executa uma atividade de modo de leitura) e outro opera como o cliente de pagamento (um dispositivo que emula um cartão NFC).
Transmissores infravermelhos
Ao executar em um dispositivo que inclui um transmissor infravermelho (IR), agora é possível transmitir sinais de IR usando as APIs ConsumerIrManager. Para receber uma instância de ConsumerIrManager, chame getSystemService() com CONSUMER_IR_SERVICE como argumento. Em seguida, você pode consultar as frequências de infravermelho compatíveis com o dispositivo usando getCarrierFrequencies() e transmitir sinais transmitindo a frequência desejada e o padrão de sinal com transmit().
Sempre verifique se um dispositivo inclui um transmissor de infravermelho chamando hasIrEmitter(). No entanto, se o app for compatível apenas com dispositivos que têm um, inclua um elemento <uses-feature> no manifesto para "android.hardware.consumerir" (FEATURE_CONSUMER_IR).
Multimídia
Reprodução adaptativa
O suporte à reprodução de vídeo adaptável agora está disponível com as APIs MediaCodec, permitindo uma mudança perfeita na resolução durante a reprodução em um Surface. É possível alimentar os frames de entrada do decodificador de uma nova resolução, e a resolução dos buffers de saída muda sem uma lacuna significativa.
Para ativar a reprodução adaptativa, adicione duas chaves a MediaFormat que especificam a resolução máxima que o app exige do codec: KEY_MAX_WIDTH e KEY_MAX_HEIGHT. Depois de adicionar esses itens ao MediaFormat, transmita o MediaFormat para a instância MediaCodec com configure().
O codec vai fazer a transição entre resoluções iguais ou menores que esses valores de maneira integrada. O codec também pode oferecer suporte a resoluções maiores que os máximos especificados (desde que estejam dentro dos limites dos perfis compatíveis), mas as transições para resoluções maiores podem não ser perfeitas.
Para mudar a resolução ao decodificar vídeos H.264, continue a colocar frames em fila usando MediaCodec.queueInputBuffer(), mas forneça os novos valores de Conjunto de Parâmetros de Sequência (SPS, na sigla em inglês) e Conjunto de Parâmetros de Imagem (PPS, na sigla em inglês) junto com o frame de Atualização Instantânea do Decodificador (IDR, na sigla em inglês) em um único buffer.
No entanto, antes de tentar configurar o codec para a reprodução adaptativa, verifique se o dispositivo é compatível com esse recurso chamando isFeatureSupported(String) com FEATURE_AdaptivePlayback.
Observação: o suporte à reprodução adaptativa é específico do fornecedor. Alguns codecs podem exigir mais memória para dicas de resolução maiores. Portanto, defina os máximos de resolução com base no material de origem que você está decodificando.
Marcações de tempo de áudio on demand
Para facilitar a sincronização de áudio e vídeo, a nova classe AudioTimestamp fornece detalhes da linha do tempo sobre um "frame" específico em um stream de áudio processado por AudioTrack. Para receber o carimbo de data/hora mais recente disponível, instancie um objeto AudioTimestamp e transmita-o para getTimestamp(). Se a solicitação do carimbo de data/hora for bem-sucedida, a instância AudioTrack será preenchida com uma posição em unidades de frame, junto com o tempo estimado em que esse frame foi apresentado ou está programado para ser apresentado.
É possível usar o valor de nanoTime em AudioTimestamp (que é monotônico) para encontrar o frame de vídeo associado mais próximo em comparação com framePosition. Assim, você pode descartar, duplicar ou interpolar frames de vídeo para corresponder ao áudio. Como alternativa, é possível determinar o tempo delta entre o valor de nanoTime e o tempo esperado de um frame de vídeo futuro (considerando a taxa de amostragem) para prever qual frame de áudio é esperado no mesmo momento que um frame de vídeo.
Leitor de imagens de superfície
A nova API ImageReader oferece acesso direto aos buffers de imagem conforme eles são renderizados em um Surface. É possível adquirir um ImageReader com o método estático newInstance(). Em seguida, chame getSurface() para criar um novo Surface e envie os dados de imagem com um produtor, como MediaPlayer ou MediaCodec. Para receber notificações quando novas imagens estiverem disponíveis na superfície, implemente a interface ImageReader.OnImageAvailableListener e registre-a com setOnImageAvailableListener().
Agora, ao desenhar conteúdo no Surface, o ImageReader.OnImageAvailableListener recebe uma chamada para onImageAvailable() à medida que cada novo frame de imagem é disponibilizado, fornecendo o ImageReader correspondente. Use o ImageReader para adquirir os dados de imagem do frame como um objeto Image chamando acquireLatestImage() ou acquireNextImage().
O objeto Image fornece acesso direto ao carimbo de data/hora, ao formato, às dimensões e aos dados de pixel da imagem em um ByteBuffer. No entanto, para que a classe Image interprete as imagens, elas precisam ser formatadas de acordo com um dos tipos definidos por constantes em ImageFormat ou PixelFormat.
Medição de pico e RMS
Agora é possível consultar o pico e o RMS do stream de áudio atual de Visualizer criando uma nova instância de Visualizer.MeasurementPeakRms e transmitindo-a para getMeasurementPeakRms(). Quando você chama esse método, os valores de pico e RMS do Visualizer.MeasurementPeakRms fornecido são definidos como os valores medidos mais recentes.
Otimizador de intensidade
O LoudnessEnhancer é uma nova subclasse de AudioEffect que permite aumentar o volume audível do MediaPlayer ou do AudioTrack. Isso pode ser especialmente útil em conjunto com o novo método getMeasurementPeakRms() mencionado anteriormente, para aumentar o volume das faixas de áudio falado enquanto outra mídia está sendo reproduzida.
Controles remotos
O Android 4.0 (nível 14 da API) introduziu as APIs RemoteControlClient, que permitem que apps de mídia consumam eventos do controlador de mídia de clientes remotos, como controles de mídia na tela de bloqueio. Agora, as novas APIs RemoteController permitem que você crie seu próprio controle remoto, possibilitando a criação de apps e periféricos inovadores que podem controlar a reprodução de qualquer app de mídia integrado ao RemoteControlClient.
Para criar um controle remoto, você pode implementar a interface do usuário como quiser, mas para enviar os eventos de botão de mídia ao app de mídia do usuário, é necessário criar um serviço que estenda a classe NotificationListenerService e implemente a interface RemoteController.OnClientUpdateListener. Usar o NotificationListenerService como base é importante porque ele fornece as restrições de privacidade adequadas, que exigem que os usuários ativem seu app como um listener de notificações nas configurações de segurança do sistema.
A classe NotificationListenerService inclui alguns métodos abstratos que você precisa implementar. No entanto, se você só se preocupa com os eventos do controlador de mídia para processar a reprodução de mídia, pode deixar a implementação deles vazia e se concentrar nos métodos RemoteController.OnClientUpdateListener.
Classificações de controles remotos
O Android 4.4 se baseia nos recursos atuais para clientes de controle remoto (apps que recebem eventos de controle de mídia com o RemoteControlClient) adicionando a capacidade de os usuários avaliarem a faixa atual no controle remoto.
A nova classe Rating encapsula informações sobre uma avaliação de usuário. Uma classificação é definida pelo estilo (RATING_HEART, RATING_THUMB_UP_DOWN, RATING_3_STARS, RATING_4_STARS, RATING_5_STARS ou RATING_PERCENTAGE) e pelo valor apropriado para esse estilo.
Para permitir que os usuários avaliem suas músicas usando um controle remoto:
- Sinalize que você quer expor a interface de classificação ao usuário (se aplicável) adicionando a flag
FLAG_KEY_MEDIA_RATINGemsetTransportControlFlags(). - Chame
editMetadata()para recuperar umRemoteControlClient.MetadataEditore transmitaRATING_KEY_BY_USERcomaddEditableKey(). - Em seguida, especifique o estilo de classificação chamando
putObject()e transmitindoRATING_KEY_BY_USERcomo a chave e um dos estilos de classificação anteriores como o valor.
Para receber um callback quando o usuário mudar a classificação no controle remoto, implemente a nova interface RemoteControlClient.OnMetadataUpdateListener e transmita uma instância para setMetadataUpdateListener(). Quando o usuário muda a classificação, o RemoteControlClient.OnMetadataUpdateListener recebe uma chamada para onMetadataUpdate(), transmitindo RATING_KEY_BY_USER como a chave e um objeto Rating como o valor.
Legendas ocultas
O VideoView agora é compatível com faixas de legenda WebVTT ao reproduzir vídeos de HTTP Live Streaming (HLS), mostrando a faixa de legenda de acordo com as preferências de legendas descritivas que o usuário definiu nas configurações do sistema.
Também é possível fornecer VideoView com as faixas de legenda WebVTT usando o método addSubtitleSource(). Esse método aceita um InputStream que carrega os dados da legenda e um objeto MediaFormat que especifica o formato dos dados da legenda, que pode ser especificado usando createSubtitleFormat(). Essas legendas também aparecem no vídeo de acordo com as preferências do usuário.
Se você não usar o VideoView para mostrar seu conteúdo de vídeo, faça com que a sobreposição de legendas corresponda o máximo possível à preferência de legendagem descritiva do usuário. Uma nova API CaptioningManager permite consultar as preferências de legendagem descritiva do usuário, incluindo estilos definidos por CaptioningManager.CaptionStyle, como família tipográfica e cor. Caso o usuário ajuste algumas preferências depois que o vídeo já tiver começado, registre uma instância de CaptioningManager.CaptioningChangeListener para receber um callback quando houver mudanças nas preferências e atualize as legendas conforme necessário.
Animação e gráficos
Cenas e transições
O novo framework android.transition oferece APIs que facilitam as animações entre diferentes estados da interface do usuário. Um recurso importante é a capacidade de definir estados distintos da interface, conhecidos como "cenas", criando um layout separado para cada um. Quando você quiser animar de uma cena para outra, execute uma "transição", que calcula a animação necessária para mudar o layout da cena atual para a próxima.
Para fazer a transição entre duas cenas, geralmente é necessário:
- Especifique o
ViewGroupque contém os componentes da interface que você quer mudar. - Especifique o layout que representa o resultado final da mudança (a próxima cena).
- Especifique o tipo de transição que deve animar a mudança de layout.
- Execute a transição.
É possível usar um objeto Scene para realizar as etapas 1 e 2. Um Scene contém metadados que descrevem as propriedades de um layout necessárias para realizar uma transição, incluindo a visualização da família e o layout da cena. É possível criar um Scene usando um construtor de classe ou o método estático getSceneForLayout().
Em seguida, use o TransitionManager para realizar as etapas 3 e 4. Uma maneira é transmitir o Scene para o método estático go(). Isso encontra a visualização da família da cena no layout atual e realiza uma transição nos modos infantis para alcançar o layout definido pelo Scene.
Como alternativa, não é necessário criar um objeto Scene. Em vez disso, você pode chamar beginDelayedTransition(), especificando um ViewGroup que contenha as visualizações que você quer mudar. Em seguida, adicione, remova ou reconfigure as visualizações de destino. Depois que o sistema define as mudanças conforme necessário, uma transição começa a animar todas as visualizações afetadas.
Para ter mais controle, você pode definir conjuntos de transições que devem ocorrer entre cenas predefinidas usando um arquivo XML no diretório res/transition/ do projeto. Dentro de um elemento <transitionManager>, especifique uma ou mais tags <transition> que definem uma cena (uma referência a um arquivo de layout) e a transição a ser aplicada ao entrar e/ou sair dessa cena. Em seguida, infle esse conjunto de transições usando inflateTransitionManager(). Use o TransitionManager retornado para executar cada transição com transitionTo(), transmitindo um Scene representado por uma das tags <transition>. Também é possível definir conjuntos de transições de forma programática com as APIs TransitionManager.
Ao especificar uma transição, é possível usar vários tipos predefinidos por subclasses de Transition, como Fade e ChangeBounds. Se você não especificar um tipo de transição, o sistema vai usar AutoTransition por padrão, que esmaece, move e redimensiona as visualizações automaticamente conforme necessário. Além disso, é possível criar transições personalizadas estendendo qualquer uma dessas classes para realizar as animações como quiser. Uma transição personalizada pode rastrear as mudanças de propriedade que você quiser e criar qualquer animação com base nelas. Por exemplo, você pode fornecer uma subclasse de Transition que detecta mudanças na propriedade "rotation" de uma visualização e, em seguida, anima as mudanças.
Para mais informações, consulte a documentação do TransitionManager.
Pausa do Animator
As APIs Animator agora permitem pausar e retomar uma animação em andamento com os métodos pause() e resume().
Para acompanhar o estado de uma animação, implemente a interface Animator.AnimatorPauseListener, que fornece callbacks quando uma animação é pausada e retomada: pause() e resume(). Em seguida, adicione o listener a um objeto Animator com addPauseListener().
Como alternativa, é possível criar uma subclasse da classe abstrata AnimatorListenerAdapter, que agora inclui implementações vazias para os callbacks de pausa e retomada definidos por Animator.AnimatorPauseListener.
Bitmaps reutilizáveis
Agora é possível reutilizar qualquer bitmap mutável em BitmapFactory para decodificar qualquer outro bitmap, mesmo quando o novo bitmap tem um tamanho diferente, desde que a contagem de bytes resultante do bitmap decodificado (disponível em getByteCount()) seja menor ou igual à contagem de bytes alocada do bitmap reutilizado (disponível em getAllocationByteCount()). Para mais informações, consulte inBitmap.
As novas APIs para Bitmap permitem uma reconfiguração semelhante para reutilização fora de BitmapFactory (para geração manual de bitmap ou lógica de decodificação personalizada). Agora é possível definir as dimensões de um bitmap com os métodos setHeight() e setWidth() e especificar um novo Bitmap.Config com setConfig() sem afetar a alocação de bitmap subjacente. O método reconfigure() também oferece uma maneira conveniente de combinar essas mudanças com uma chamada.
No entanto, não reconfigure um bitmap que esteja sendo usado pelo sistema de visualização, porque o buffer de pixel subjacente não será remapeado de maneira previsível.
Conteúdo do usuário
Framework de acesso ao armazenamento
Nas versões anteriores do Android, se você quiser que seu app recupere um tipo específico de arquivo de outro app, ele precisa invocar uma intent com a ação ACTION_GET_CONTENT. Essa ação ainda é a maneira adequada de solicitar um arquivo que você quer importar para o app. No entanto, o Android 4.4 introduz a ação ACTION_OPEN_DOCUMENT, que permite ao usuário selecionar um arquivo de um tipo específico e conceder ao app acesso de leitura de longo prazo a esse arquivo (possivelmente com acesso de gravação) sem importá-lo para o app.
Se você estiver desenvolvendo um app que oferece serviços de armazenamento de arquivos (como um serviço de salvamento na nuvem), poderá participar dessa interface unificada para escolher arquivos implementando um provedor de conteúdo como uma subclasse da nova classe DocumentsProvider. A subclasse de DocumentsProvider precisa incluir um filtro de intent que aceite a ação PROVIDER_INTERFACE ("android.content.action.DOCUMENTS_PROVIDER"). Em seguida, implemente os quatro métodos abstratos em DocumentsProvider:
queryRoots()- Isso precisa retornar um
Cursorque descreva todos os diretórios raiz do armazenamento de documentos, usando colunas definidas emDocumentsContract.Root. queryChildDocuments()- Isso precisa retornar um
Cursorque descreva todos os arquivos no diretório especificado, usando as colunas definidas emDocumentsContract.Document. queryDocument()- Isso precisa retornar um
Cursorque descreva o arquivo especificado, usando colunas definidas emDocumentsContract.Document. openDocument()- Isso precisa retornar um
ParcelFileDescriptorque represente o arquivo especificado. O sistema chama esse método quando o usuário seleciona um arquivo e o app cliente solicita acesso a ele chamandoopenFileDescriptor().
Para mais informações, consulte o guia do Storage Access Framework.
Acesso ao armazenamento externo
Agora é possível ler e gravar arquivos específicos do app em mídias de armazenamento externo secundárias, como quando um dispositivo oferece armazenamento emulado e um cartão SD. O novo método getExternalFilesDirs() funciona da mesma forma que o método getExternalFilesDir(), mas retorna uma matriz de objetos File. Antes de ler ou gravar em qualquer um dos caminhos retornados por esse método, transmita o objeto File para o novo método getStorageState() para verificar se o armazenamento está disponível no momento.
Outros métodos para acessar o diretório de cache específico do app e o diretório OBB agora também têm versões correspondentes que dão acesso a dispositivos de armazenamento secundários: getExternalCacheDirs() e getObbDirs(), respectivamente.
A primeira entrada na matriz File retornada é considerada o armazenamento externo principal do dispositivo, que é o mesmo que o File retornado por métodos como getExternalFilesDir().
Observação: a partir do Android 4.4, a plataforma não exige mais que o app adquira as permissões WRITE_EXTERNAL_STORAGE ou READ_EXTERNAL_STORAGE quando você precisa acessar apenas as regiões específicas do app no armazenamento externo usando os métodos acima. No entanto, as permissões são necessárias se você quiser acessar as regiões compartilháveis do armazenamento externo, fornecidas por getExternalStoragePublicDirectory().
Adaptadores de sincronização
O novo método requestSync() em ContentResolver simplifica parte do procedimento para definir uma solicitação de sincronização para seu ContentProvider, encapsulando solicitações no novo objeto SyncRequest, que pode ser criado com SyncRequest.Builder. As propriedades em SyncRequest oferecem a mesma funcionalidade que as chamadas de sincronização ContentProvider, mas adicionam a capacidade de especificar que uma sincronização precisa ser descartada se a rede for limitada, ativando setDisallowMetered().
Opinião dos usuários
Novos tipos de sensor
O novo sensor TYPE_GEOMAGNETIC_ROTATION_VECTOR
fornece dados de vetor de rotação com base em um magnetômetro, que é uma alternativa útil ao sensor TYPE_ROTATION_VECTOR quando um giroscópio não está disponível ou quando usado com eventos de sensor em lote para registrar a orientação do dispositivo enquanto o smartphone está em repouso. Esse sensor requer menos energia do que o TYPE_ROTATION_VECTOR, mas pode estar sujeito a dados de eventos ruidosos e é mais eficaz quando o usuário está ao ar livre.
O Android agora também oferece suporte a sensores de passos integrados no hardware:
TYPE_STEP_DETECTOR- Esse sensor aciona um evento sempre que o usuário dá um passo. A cada passo do usuário, esse sensor gera um evento com um valor de 1,0 e um carimbo de data/hora indicando quando o passo ocorreu.
TYPE_STEP_COUNTER- Esse sensor também aciona um evento a cada passo detectado, mas fornece o número total acumulado de passos desde que o sensor foi registrado pela primeira vez por um app.
Esses dois sensores de passos nem sempre fornecem os mesmos resultados. Os eventos TYPE_STEP_COUNTER ocorrem com uma latência maior do que os de TYPE_STEP_DETECTOR, mas isso ocorre porque o algoritmo TYPE_STEP_COUNTER faz mais processamento para eliminar falsos positivos. Portanto, o TYPE_STEP_COUNTER pode ser mais lento para entregar eventos, mas os resultados devem ser mais precisos.
Ambos os sensores de passos dependem do hardware (o Nexus 5 é o primeiro dispositivo compatível com eles). Portanto, verifique a disponibilidade com hasSystemFeature(), usando as constantes FEATURE_SENSOR_STEP_DETECTOR e FEATURE_SENSOR_STEP_COUNTER.
Eventos de sensor em lote
Para gerenciar melhor a energia do dispositivo, as APIs SensorManager agora permitem especificar a frequência com que você quer que o sistema envie lotes de eventos de sensor ao app. Isso não reduz o número de eventos de sensor reais disponíveis para o app em um determinado período, mas reduz a frequência com que o sistema chama o SensorEventListener com atualizações do sensor. Ou seja, em vez de enviar cada evento ao app no momento em que ele ocorre, o sistema salva todos os eventos que ocorrem durante um período e os envia ao app de uma só vez.
Para fornecer o lote, a classe SensorManager adiciona duas novas versões do método registerListener() que permitem especificar a "latência máxima do relatório". Esse novo parâmetro especifica o atraso máximo que o SensorEventListener vai tolerar para a entrega de novos eventos de sensor. Por exemplo, se você especificar uma latência de lote de um minuto, o sistema vai entregar o conjunto recente de eventos em lote em um intervalo de no máximo um minuto, fazendo chamadas consecutivas para o método onSensorChanged(), uma para cada evento que foi agrupado. Os eventos do sensor nunca vão atrasar mais do que o valor máximo de latência de relatório, mas podem chegar antes se outros apps tiverem solicitado uma latência menor para o mesmo sensor.
No entanto, o sensor vai enviar ao app os eventos em lote com base na latência do relatório somente enquanto a CPU estiver ativa. Embora um sensor de hardware que ofereça suporte ao processamento em lote continue a coletar eventos de sensor enquanto a CPU estiver em suspensão, ele não vai ativar a CPU para entregar os eventos em lote ao app. Quando o sensor ficar sem memória para eventos, ele vai começar a descartar os eventos mais antigos para salvar os mais recentes. Para evitar a perda de eventos, ative o dispositivo antes que o sensor preencha a memória e chame flush() para capturar o lote mais recente de eventos. Para estimar quando a memória estará cheia e precisará ser limpa, chame getFifoMaxEventCount() para ver o número máximo de eventos de sensor que ela pode salvar e divida esse número pela taxa em que o app deseja cada evento. Use esse cálculo para definir alarmes de ativação com AlarmManager que invoquem seu Service (que implementa o SensorEventListener) para limpar o sensor.
Observação: nem todos os dispositivos oferecem suporte ao envio de eventos de sensor em lote, porque isso requer suporte do sensor de hardware. No entanto, a partir do Android 4.4, use sempre os novos métodos registerListener(), porque, se o dispositivo não for compatível com o envio em lote, o sistema vai ignorar o argumento de latência do lote e entregar os eventos do sensor em tempo real.
Identidades do controlador
O Android agora identifica cada controle conectado com um número inteiro exclusivo que pode ser consultado com getControllerNumber(), facilitando a associação de cada controle a um jogador diferente em um jogo. O número de cada controle pode mudar devido à desconexão, conexão ou reconfiguração pelo usuário. Portanto, registre uma instância de InputManager.InputDeviceListener para acompanhar qual número de controle corresponde a cada dispositivo de entrada. Em seguida, chame getControllerNumber() para cada InputDevice quando ocorrer uma mudança.
Os dispositivos conectados agora também fornecem IDs de produto e de fornecedor que estão disponíveis em getProductId() e getVendorId(). Se você precisar modificar os mapeamentos de teclas com base no conjunto de teclas disponíveis em um dispositivo, consulte o dispositivo para verificar se determinadas teclas estão disponíveis com hasKeys(int...).
Interface do usuário
Modo imersivo de tela cheia
Para que o app tenha um layout que preencha toda a tela, a nova flag SYSTEM_UI_FLAG_IMMERSIVE para setSystemUiVisibility() (quando combinada com SYSTEM_UI_FLAG_HIDE_NAVIGATION) ativa um novo modo de tela cheia imersivo. Enquanto o modo imersivo de tela cheia estiver ativado, sua atividade vai continuar recebendo todos os eventos de toque. O usuário pode revelar as barras de sistema deslizando para dentro na região em que elas normalmente aparecem. Isso limpa a flag SYSTEM_UI_FLAG_HIDE_NAVIGATION (e a flag SYSTEM_UI_FLAG_FULLSCREEN, se aplicada) para que as barras de sistema permaneçam visíveis. No entanto, se você quiser que as barras do sistema sejam ocultadas novamente após alguns instantes, use a flag SYSTEM_UI_FLAG_IMMERSIVE_STICKY.
Barras de sistema translúcidas
Agora é possível deixar as barras de sistema parcialmente translúcidas com os novos temas, Theme.Holo.NoActionBar.TranslucentDecor e Theme.Holo.Light.NoActionBar.TranslucentDecor. Ao ativar as barras de sistema translúcidas, o layout vai preencher a área atrás delas. Portanto, você também precisa ativar fitsSystemWindows para a parte do layout que não deve ser coberta pelas barras de sistema.
Se você estiver criando um tema personalizado, defina um desses temas como o tema pai ou inclua as propriedades de estilo windowTranslucentNavigation e windowTranslucentStatus no seu tema.
Listener de notificações avançadas
O Android 4.3 adicionou as APIs NotificationListenerService, permitindo que os apps recebam informações sobre novas notificações conforme são postadas pelo sistema. No Android 4.4, os listeners de notificação podem recuperar metadados adicionais para a notificação e detalhes completos sobre as ações dela:
O novo campo Notification.extras inclui um Bundle para fornecer ao builder de notificações metadados adicionais, como EXTRA_TITLE e EXTRA_PICTURE.
A nova classe Notification.Action define as características de uma ação anexada à notificação, que pode ser recuperada do novo campo actions.
Espelhamento de drawables para layouts RTL
Nas versões anteriores do Android, se o app incluir imagens que precisam inverter a orientação horizontal para layouts da direita para a esquerda, inclua a imagem espelhada em um diretório de recursos drawables-ldrtl/. Agora, o sistema pode espelhar imagens automaticamente para você ao ativar o atributo autoMirrored em um recurso drawable ou ao chamar setAutoMirrored(). Quando ativado, o Drawable é espelhado automaticamente quando a direção do layout é da direita para a esquerda.
Acessibilidade
A classe View agora permite declarar "regiões ativas" para partes da interface que são atualizadas dinamicamente com novo conteúdo de texto. Para isso, adicione o novo atributo accessibilityLiveRegion ao layout XML ou chame setAccessibilityLiveRegion(). Por exemplo, uma tela de login com um campo de texto que mostra uma notificação de "senha incorreta" precisa ser marcada como uma região ativa para que o leitor de tela leia a mensagem quando ela mudar.
Os apps que oferecem um serviço de acessibilidade agora também podem melhorar os recursos com novas APIs que fornecem informações sobre coleções de visualizações, como visualizações de lista ou visualizações em grade, usando AccessibilityNodeInfo.CollectionInfo e AccessibilityNodeInfo.CollectionItemInfo.
Permissões do app
Confira a seguir as novas permissões que seu app precisa solicitar com a tag <uses-permission> para usar determinadas APIs novas:
INSTALL_SHORTCUT- Permite que um aplicativo instale um atalho no acesso rápido
UNINSTALL_SHORTCUT- Permite que um aplicativo desinstale um atalho no Launcher
TRANSMIT_IR- Permite que um aplicativo use o transmissor de infravermelho do dispositivo, se disponível
Observação: a partir do Android 4.4, a plataforma não exige mais que o app adquira WRITE_EXTERNAL_STORAGE ou READ_EXTERNAL_STORAGE quando você quer acessar as regiões específicas do app no armazenamento externo usando métodos como getExternalFilesDir(). No entanto, as permissões ainda são necessárias se você quiser acessar as regiões compartilháveis do armazenamento externo, fornecidas por getExternalStoragePublicDirectory().
Recursos do dispositivo
Confira a seguir os novos recursos de dispositivo que você pode declarar com a tag <uses-feature> para declarar os requisitos do app e ativar a filtragem no Google Play ou verificar no momento da execução:
FEATURE_CONSUMER_IR- O dispositivo é capaz de se comunicar com dispositivos de infravermelho do consumidor.
FEATURE_DEVICE_ADMIN- O dispositivo oferece suporte à aplicação de políticas do dispositivo usando administradores do dispositivo.
FEATURE_NFC_HOST_CARD_EMULATION- O dispositivo oferece suporte à emulação de cartão NFC baseada em host.
FEATURE_SENSOR_STEP_COUNTER- O dispositivo inclui um contador de passos de hardware.
FEATURE_SENSOR_STEP_DETECTOR- O dispositivo inclui um detector de passos de hardware.
Para uma visualização detalhada de todas as mudanças na API no Android 4.4, consulte o Relatório de diferenças da API.