Nível da API: 17
O Android 4.2 (JELLY_BEAN_MR1)
é uma atualização da versão Jelly Bean que oferece novos recursos para usuários e desenvolvedores
de apps. Este documento apresenta uma introdução às APIs novas mais importantes e
úteis para desenvolvedores.
Como desenvolvedor de apps, faça o download da imagem do sistema do Android 4.2 e da plataforma do SDK no SDK Manager assim que possível. Se você não tiver um dispositivo com o Android 4.2 para testar o app, use a imagem do sistema do Android 4.2 para testar o app no Android Emulator. Em seguida, crie seus apps com base na plataforma Android 4.2 para começar a usar as APIs mais recentes.
Para otimizar melhor seu app para dispositivos com o Android 4.2,
defina o targetSdkVersion como
"17", instale-o em uma imagem do sistema Android 4.2,
teste-o e publique uma atualização com essa mudança.
É possível
usar APIs no Android 4.2 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 Como criar interfaces
compatíveis com versões anteriores.
Para mais informações sobre como os níveis da API funcionam, consulte O que é o nível da API?.
Mudanças importantes de comportamento
Se você já publicou um app para Android, fique ciente das seguintes mudanças que podem afetar o comportamento dele:
- Os provedores de conteúdo não são mais exportados por padrão. Ou seja, o valor padrão
para o atributo
android:exportedagora é"false". Se for importante que outros apps possam acessar seu provedor de conteúdo, defina explicitamenteandroid:exported="true".Essa mudança só vai entrar em vigor se você definir
android:targetSdkVersionouandroid:minSdkVersioncomo 17 ou mais. Caso contrário, o valor padrão ainda será"true", mesmo ao executar no Android 4.2 e versões mais recentes. - Em comparação com as versões anteriores do Android, os resultados de localização do usuário podem ser menos precisos
se o app solicitar a permissão
ACCESS_COARSE_LOCATION, mas não a permissãoACCESS_FINE_LOCATION.Para atender às expectativas de privacidade dos usuários quando o app solicita permissão para localização aproximada (e não exata), o sistema não fornece uma estimativa de localização do usuário mais precisa do que um quarteirão.
- Algumas configurações do dispositivo definidas por
Settings.Systemagora são somente leitura. Se o app tentar gravar mudanças nas configurações definidas emSettings.Systemque foram movidas paraSettings.Global, a operação de gravação vai falhar silenciosamente ao ser executada no Android 4.2 e versões mais recentes.Mesmo que o valor de
android:targetSdkVersioneandroid:minSdkVersionseja menor que 17, o app não poderá modificar as configurações que foram movidas paraSettings.Globalao ser executado no Android 4.2 e versões mais recentes. - Se o app usa
WebView, o Android 4.2 adiciona uma camada extra de segurança para que você possa vincular o JavaScript ao seu código Android com mais segurança. Se você definir otargetSdkVersioncomo 17 ou mais, será necessário adicionar a anotação@JavascriptInterfacea qualquer método que você queira disponibilizar para o JavaScript. O método também precisa ser público. Se você não fornecer a anotação, o método não poderá ser acessado por uma página da Web no seuWebViewao ser executado no Android 4.2 ou versões mais recentes. Se você definir otargetSdkVersioncomo 16 ou menos, a anotação não será necessária, mas recomendamos que você atualize a versão de destino e adicione a anotação para aumentar a segurança.Leia mais sobre como vincular o código JavaScript ao código Android.
Sonhos
O Daydream é um novo modo de proteção de tela interativo para dispositivos Android. Ele é ativado automaticamente quando o dispositivo é inserido em uma base ou quando fica inativo enquanto está conectado a um carregador (em vez de desligar a tela). O Daydream mostra um sonho por vez, que pode ser uma exibição puramente visual e passiva que é dispensada ao toque ou pode ser interativa e responsiva ao conjunto completo de eventos de entrada. Os sonhos são executados no processo do app e têm acesso total ao kit de ferramentas de interface do Android, incluindo visualizações, layouts e animações. Por isso, eles são mais flexíveis e poderosos do que os planos de fundo interativos ou os widgets de apps.
É possível criar um sonho para o Daydream implementando uma subclasse de DreamService. As APIs DreamService foram
projetadas para serem semelhantes às de Activity. Para especificar a interface do seu
dream, transmita um ID de recurso de layout ou View para setContentView() a qualquer momento depois de ter
uma janela, como no callback
onAttachedToWindow().
A classe DreamService fornece outros métodos de callback do ciclo de vida
importantes além das APIs Service de base, como onDreamingStarted(), onDreamingStopped() e onDetachedFromWindow().
Não é possível iniciar uma DreamService no seu
app. Ela é iniciada automaticamente pelo sistema.
Se o sonho for interativo, você poderá iniciar uma atividade para enviar o usuário à
interface completa do app para mais detalhes ou controle. Use finish() para encerrar o sonho e permitir que o usuário veja a
nova atividade.
Para disponibilizar o daydream para o sistema, declare o DreamService com um elemento <service>
no arquivo de manifesto. Em seguida, inclua um filtro de intent com a ação "android.service.dreams.DreamService". Exemplo:
<service android:name=".MyDream" android:exported="true" android:icon="@drawable/dream_icon" android:label="@string/dream_label" > <intent-filter> <action android:name="android.service.dreams.DreamService" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </service>
Há outros métodos úteis em DreamService
que você precisa conhecer:
setInteractive(boolean)controla se o protetor de tela recebe eventos de entrada ou é encerrado imediatamente após a entrada do usuário. Se o sonho for interativo, o usuário poderá usar os botões Voltar ou Início para sair do sonho ou você poderá chamarfinish()para interromper o sonho.- Se você quiser uma tela totalmente imersiva, chame
setFullscreen()para ocultar a barra de status. - Antes de o Daydream ser iniciado, a tela escurece para sinalizar ao usuário que o tempo limite de inatividade
está se aproximando. Chamar
setScreenBright(true)permite definir a tela com o brilho normal.
Para mais informações, consulte a documentação do DreamService.
Telas secundárias
Agora, o Android permite que seu app mostre conteúdo exclusivo em outras telas conectadas
ao dispositivo do usuário por uma conexão com fio ou Wi-Fi.
Para criar conteúdo exclusivo para uma tela secundária, estenda a classe Presentation
e implemente o callback onCreate(). Em
onCreate(), especifique a interface para a tela secundária
chamando setContentView().
Como uma extensão da classe Dialog, a classe Presentation fornece a região em que o app pode mostrar uma interface exclusiva na
tela secundária.
Para detectar telas secundárias em que é possível mostrar o Presentation,
use as APIs DisplayManager ou MediaRouter. Embora as APIs DisplayManager permitam enumerar
várias telas que podem estar conectadas ao mesmo tempo, geralmente é melhor usar MediaRouter para acessar rapidamente a tela padrão do sistema para
apresentações.
Para acessar a exibição padrão da sua apresentação, chame MediaRouter.getSelectedRoute() e transmita
ROUTE_TYPE_LIVE_VIDEO. Isso retorna um objeto MediaRouter.RouteInfo que descreve a rota selecionada no momento pelo sistema
para apresentações de vídeo. Se o MediaRouter.RouteInfo não for nulo, chame
getPresentationDisplay() para receber o Display que representa a tela conectada.
Em seguida, você pode exibir sua apresentação transmitindo o objeto Display
para um construtor da classe Presentation. Sua apresentação vai aparecer
na tela secundária.
Para detectar no ambiente de execução quando uma nova tela é conectada, crie uma instância de MediaRouter.SimpleCallback em que você implementa o método de callback onRoutePresentationDisplayChanged(), que o sistema chama quando uma nova tela de apresentação é conectada. Em seguida, registre o MediaRouter.SimpleCallback transmitindo-o para MediaRouter.addCallback() com o tipo de rota ROUTE_TYPE_LIVE_VIDEO. Quando você receber uma chamada para
onRoutePresentationDisplayChanged(), basta chamar MediaRouter.getSelectedRoute(), conforme mencionado acima.
Para otimizar ainda mais a interface do Presentation para
telas secundárias, aplique
um tema diferente especificando o atributo android:presentationTheme no <style> que você
aplicou ao aplicativo ou à atividade.
As telas conectadas ao dispositivo do usuário geralmente têm um tamanho maior e,
provavelmente, uma densidade diferente. Como as características da tela podem ser diferentes, forneça
recursos otimizados especificamente para essas telas maiores. Se você precisar
solicitar mais recursos do Presentation, chame getContext().getResources() para receber o objeto Resources correspondente à tela. Isso fornece
os recursos adequados do app que são mais adequados para o
tamanho e a densidade da tela secundária.
Para mais informações e alguns exemplos de código, consulte a documentação da classe Presentation.
Widgets da tela de bloqueio
Agora o Android permite que os usuários adicionem widgets de apps à tela de bloqueio. Para disponibilizar o widget do app para uso na
tela de bloqueio, adicione o atributo android:widgetCategory ao arquivo XML que especifica o AppWidgetProviderInfo. Esse atributo aceita dois valores: home_screen
e keyguard. Por padrão, o atributo é definido como home_screen para que os usuários possam adicionar o
widget do app à tela inicial. Se você quiser que o widget do app também esteja disponível na tela de bloqueio, adicione o valor keyguard:
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
...
android:widgetCategory="keyguard|home_screen">
</appwidget-provider>Você também precisa especificar um layout inicial para o widget do app quando ele estiver na tela de bloqueio com
o atributo android:initialKeyguardLayout. Isso funciona da mesma forma que o android:initialLayout, fornecendo
um layout que pode aparecer imediatamente até que o widget do app seja inicializado e possa atualizar o
layout.
Para mais informações sobre como criar widgets de app para a tela de bloqueio, incluindo como dimensionar corretamente o widget do app na tela de bloqueio, consulte o guia Widgets de app.
Dispositivo compartilhado
O Android agora permite vários espaços de usuário em dispositivos compartilháveis, como tablets. Cada usuário em um dispositivo tem o próprio conjunto de contas, apps, configurações do sistema, arquivos e outros dados associados.
Como desenvolvedor de apps, você não precisa fazer nada diferente para que seu app funcione corretamente com vários usuários em um único dispositivo. Independentemente de quantos usuários existirem em um dispositivo, os dados que o app salva para um determinado usuário são mantidos separados dos dados salvos para outros usuários. O sistema monitora quais dados pertencem ao processo do usuário em que o app está sendo executado e fornece acesso apenas aos dados desse usuário, não permitindo o acesso aos dados de outros usuários.
Como salvar dados em um ambiente multiusuário
Sempre que o app salva as preferências do usuário, cria um banco de dados ou grava um arquivo no espaço de armazenamento interno ou externo do usuário, esses dados só podem ser acessados enquanto o app é executado como esse usuário.
Para garantir que o app se comporte corretamente em um ambiente multiusuário, não use caminhos codificados para se referir ao diretório interno do app ou ao local de armazenamento externo. Em vez disso, use sempre as APIs adequadas:
- Para acessar o armazenamento interno, use
getFilesDir(),getCacheDir()ouopenFileOutput(). - Para acessar o armazenamento externo, use
getExternalFilesDir()ougetExternalStoragePublicDirectory().
Não importa qual dessas APIs você use para salvar dados de um determinado usuário, eles não vão ficar acessíveis quando o app estiver sendo executado como um usuário diferente. Do ponto de vista do app, cada usuário está executando em um dispositivo completamente separado.
Como identificar usuários em um ambiente multiusuário
Se o app quiser identificar usuários únicos, como para coletar análises ou criar outras associações
de conta, siga as práticas recomendadas para identificar
instalações únicas. Ao criar um novo UUID quando o app é iniciado pela
primeira vez, você garante um ID exclusivo para rastrear cada usuário, independentemente de quantos
usuários instalarem o app em um único dispositivo. Como alternativa, é possível salvar um token local buscado no
servidor ou usar o ID de registro fornecido pelo Google Cloud Messaging.
Se o app solicitar um dos identificadores de dispositivo de hardware (como o endereço MAC do Wi-Fi
ou o número SERIAL), eles vão fornecer o mesmo valor para cada
usuário, porque esses identificadores estão vinculados ao hardware, e não ao usuário. Sem mencionar os outros
problemas que esses identificadores introduzem, conforme discutido na postagem do blog
Como identificar instalações de apps.
Novas configurações globais
As configurações do sistema foram atualizadas para oferecer suporte a Dispositivo compartilhado com a adição de Settings.Global. Essa coleção de configurações é semelhante às configurações de Settings.Secure porque são somente leitura, mas se aplica globalmente a
todos os espaços do usuário no dispositivo.
Várias configurações foram transferidas de Settings.System ou Settings.Secure para cá. Se o app
estiver fazendo mudanças nas configurações definidas anteriormente em Settings.System
(como AIRPLANE_MODE_ON), isso não vai mais funcionar em um dispositivo com o Android 4.2 ou versões mais recentes se essas configurações tiverem sido
movidas para Settings.Global. Você pode continuar lendo as configurações que estão em
Settings.Global, mas, como elas não são mais consideradas seguras
para serem alteradas por apps, as tentativas de fazer isso vão falhar silenciosamente, e o sistema vai gravar um aviso no
registro do sistema ao executar o app no Android 4.2 ou mais recente.
Suporte a layout RTL
O Android agora oferece várias APIs que permitem criar interfaces do usuário que transformam a orientação do layout para oferecer suporte a idiomas que usam interfaces e direção de leitura da direita para a esquerda (RTL), como árabe e hebraico.
Para começar a oferecer suporte a layouts RTL no seu app, defina o atributo android:supportsRtl como o elemento <application> no arquivo de manifesto
e defina-o como "true". Depois que você ativar essa opção, o sistema vai ativar várias APIs RTL para
exibir o app com layouts RTL. Por exemplo, a barra de ações vai mostrar o ícone e o título
no lado direito e os botões de ação no esquerdo, e todos os layouts criados com as
classes View fornecidas pelo framework também serão invertidos.
Se você precisar otimizar ainda mais a aparência do seu app quando ele for exibido com um layout RTL, há dois níveis básicos de otimização:
- Converter propriedades de layout orientadas para a esquerda e para a direita em propriedades de layout orientadas para o início e para o fim.
Por exemplo, use
android:layout_marginStartem vez deandroid:layout_marginLefteandroid:layout_marginEndem vez deandroid:layout_marginRight.A classe
RelativeLayouttambém fornece os atributos de layout correspondentes para substituir as posições esquerda/direita, comoandroid:layout_alignParentStartpara substituirandroid:layout_alignParentLefteandroid:layout_toStartOfem vez deandroid:layout_toLeftOf. - Ou, para oferecer uma otimização completa para layouts RTL, você pode fornecer arquivos de layout
totalmente separados usando o qualificador de recurso
ldrtl(ldrtlsignifica layout-direction-right-to-left). Por exemplo, é possível salvar os arquivos de layout padrão emres/layout/e os layouts otimizados para RTL emres/layout-ldrtl/.O qualificador
ldrtlé ótimo para recursos drawable, porque permite fornecer gráficos orientados na direção correspondente à direção de leitura.
Várias outras APIs estão disponíveis no framework para oferecer suporte a layouts RTL, como na
classe View, para que você possa implementar os comportamentos adequados para visualizações
personalizadas, e em Configuration, para consultar a direção atual do layout.
Observação: se você estiver usando o SQLite e tiver tabelas ou nomes de colunas que sejam
"somente números", tome
cuidado: o uso de String.format(String, Object...) pode levar a erros em que os números
são convertidos para os equivalentes em árabe se o dispositivo estiver definido para essa localidade.
Use String.format(Locale,String,Object...) para garantir que os números sejam
preservados como ASCII. Além disso, use String.format("%d", int) em vez de
String.valueOf(int) para
formatar números.
Fragments aninhados
Agora é possível incorporar fragmentos dentro de fragmentos. Isso é útil para várias situações em
que você quer colocar componentes de IU dinâmicos e reutilizáveis em um componente de IU que também é
dinâmico e reutilizável. Por exemplo, se você usar ViewPager para
criar fragmentos que deslizam para a esquerda e para a direita e consomem a maior parte do espaço da tela, agora é possível
inserir fragmentos em cada página de fragmento.
Para aninhar um fragmento, basta chamar getChildFragmentManager() no
Fragment em que você quer adicionar um fragmento. Isso retorna um FragmentManager que pode ser usado como você normalmente faz na atividade de nível superior
para criar transações de fragmento. Por exemplo, veja um código que adiciona um fragmento de dentro
de uma classe Fragment:
Kotlin
val videoFragment = VideoPlayerFragment() childFragmentManager.beginTransaction().apply { add(R.id.video_fragment, videoFragment) commit() }
Java
Fragment videoFragment = new VideoPlayerFragment(); FragmentTransaction transaction = getChildFragmentManager().beginTransaction(); transaction.add(R.id.video_fragment, videoFragment).commit();
Em um fragmento aninhado, é possível receber uma referência ao fragmento pai chamando
getParentFragment().
A Biblioteca de Suporte do Android agora também oferece suporte a fragmentos aninhados, para que você possa implementar designs de fragmentos aninhados no Android 1.6 e versões mais recentes.
Observação: não é possível inflar um layout em um fragmento quando esse layout
inclui um <fragment>. Os fragmentos aninhados só são compatíveis quando adicionados a um
fragmento de forma dinâmica.
RenderScript
A funcionalidade de computação do Renderscript foi aprimorada com os seguintes recursos:
- Intrínsecos de script
É possível usar as funções intrínsecas de script integradas do Renderscript que implementam operações comuns para você, como:
BlendsBlurColor matrix3x3 convolve5x5 convolvePer-channel lookup tableConverting an Android YUV buffer to RGB
Para usar um script intrínseco, chame o método estático
create()de cada intrínseco para criar uma instância do script. Em seguida, chame os métodosset()disponíveis de cada script intrínseco para definir as entradas e opções necessárias. Por fim, chame o métodoforEach()para executar o script.- Grupos de scripts
-
Os
ScriptGroups permitem encadear scripts relacionados do Renderscript e executá-los com uma chamada.Use um
ScriptGroup.Builderpara adicionar todos os scripts ao grupo chamandoaddKernel(). Depois de adicionar todos os scripts, crie as conexões entre eles chamandoaddConnection(). Quando terminar de adicionar as conexões, chamecreate()para criar o grupo de scripts. Antes de executar o grupo de scripts, especifique a entradaAllocatione o script inicial a ser executado com o métodosetInput(Script.KernelID, Allocation)e forneça a saídaAllocationem que o resultado será gravado e o script final a ser executado comsetOutput(). Por fim, chameexecute()para executar o grupo de scripts. - Filterscript
-
O Filterscript define restrições nas APIs do Renderscript que permitem que o código resultante seja executado em uma variedade maior de processadores (CPUs, GPUs e DSPs). Para criar arquivos Filterscript, crie arquivos
.fsem vez de arquivos.rse especifique#pragma rs_fp_relaxedpara informar ao ambiente de execução do Renderscript que seus scripts não exigem precisão estrita de ponto flutuante IEEE 754-2008. Essa precisão permite o flush-to-zero para denorms e o arredondamento para zero. Além disso, os scripts do Filterscript não podem usar tipos integrados de 32 bits e precisam especificar uma função raiz personalizada usando o atributo__attribute__((kernel)), porque o Filterscript não oferece suporte a ponteiros, que são definidos pela assinatura padrão da funçãoroot().
Observação: embora o suporte ao Filterscript esteja na plataforma, o suporte ao desenvolvedor estará disponível na versão 21.0.1 das Ferramentas do SDK.
Para uma visualização detalhada de todas as mudanças na API no Android 4.2, consulte o Relatório de diferenças da API.