Criando Projeto Android

Criando um projeto Android ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Criar um projeto com Android Estúdio 2. Criar um projeto com ferramentas de linha de comando

VOCÊ TAMBÉM DEVE LER  Gerenciamento de Projetos

Um projeto Android contém todos os arquivos que compõem o código-fonte para o seu app Android. Esta lição mostra como criar um novo projeto ou usando Android Studio ou usando as ferramentas do SDK a partir de uma linha de comando. Nota: Você já deve ter o SDK Android instalado, e se você estiver usando o Android Studio, você também deve terAndroid estúdio instalado. Se você não tiver esses, siga o guia de instalação do SDK Android antes de começar esta lição.

Criar um projeto com Android Estúdio 1. Em Android Studio, crie um novo projeto: o

Se você não tiver um projeto aberto, no Bem-vindo tela, clique em New Project .

o

Se você tiver um projeto aberto, a partir do arquivo de menu, selecione New Project .

Figura 1. Configurando um novo projeto no Android Studio.

2. Sob Configure seu novo projeto , preencha os campos conforme mostrado na figura 1 e clique emAvançar . Provavelmente será mais fácil seguir essas lições se você usar os mesmos valores como mostrado. o

Nome do aplicativo é o nome do aplicativo que aparece para os usuários. Para este projeto, use "My First App."

o

Domínio da empresa fornece um qualificador que será anexado ao nome do pacote; Android Estúdio vai se lembrar deste qualificador para cada novo projeto criado.

o

Nome do pacote é o nome totalmente qualificado para o projeto (seguindo as mesmas regras para a nomeação de pacotes na linguagem de programação Java). Seu nome embalagem deve ser exclusivo em todos os pacotes instalados no sistema Android. Você pode editar esse valor independentemente do nome do aplicativo ou o domínio da empresa.

o

Local do Projeto é o diretório em seu sistema que contém os arquivos do projeto.

3. Sob Selecionar a forma Fatores seu aplicativo será executado em , marque a caixa de telefone e tablet . 4. Para SDK mínimo , selecione API 8: Android 2.2 (Froyo) . O mínimo exigido SDK é a versão mais antiga do Android que seus suportes de aplicativos, indicadas com onível API . Para suportar tantos dispositivos quanto possível, você deve definir isso para o menor versão disponível que permite que o seu app para fornecer seu conjunto de recursos do núcleo. Se alguma característica do seu aplicativo é possível apenas em versões mais recentes do Android e não é crítico para o núcleo conjunto de recursos do app, você pode ativar o recurso somente quando rodando em versões que o suportam (como discutido no apoio às diferentes versões de plataforma ). 5. Deixe todas as outras opções (TV, desgaste e Glass) desmarcada e clique em Avançar.

Atividades Uma atividade é uma das características distintivas do quadro Android. Atividades fornecer ao usuário o acesso a sua aplicação, e pode haver muitas atividades. Um pedido geralmente têm uma atividade principal para quando o usuário inicia a aplicação, uma outra atividade para quando ela seleciona algum conteúdo para ver, por exemplo, e outras atividades para quando ela executa outras tarefas dentro do app. VejaAtividades para mais informações.

6. Sob Adicionar uma atividade para < template > , selecioneAtividade em branco e clique em Avançar . 7. Sob Escolha opções para o seu novo arquivo , altere o nome da atividade para MyActivity . O Nome do layout muda paraactivity_my , eo título de MyActivity . O nome do recurso de menu é menu_my . 8. Clique no Finish botão para criar o projeto. Seu projeto Android é agora um app básico "Olá Mundo", que contém alguns arquivos padrão. Tome um momento para rever a mais importante delas: app / src / main / res / layout / activity_my.xml

Este é o arquivo de layout XML para a atividade que você adicionou quando criou o projeto com Android Studio.Seguindo o fluxo de trabalho New Project, Android Estúdio apresenta este arquivo com uma exibição de texto e uma pré-visualização da tela de interface do usuário. O arquivo inclui algumas configurações padrão e um TextView elemento que exibe a mensagem: "Olá, mundo!" app / src / main / java / com.mycompany.myfirstapp / MyActivity.java

Um guia para este arquivo aparece em Android Studio quando o fluxo de trabalho New Project termina.Quando você seleciona o arquivo que você veja a definição de classe para a atividade que você criou.Quando você criar e executar o aplicativo, o Activity aula começa a atividade e carrega o arquivo de layout que diz "Olá mundo!" app / src / main / AndroidManifest.xml

O arquivo de manifesto descreve as características fundamentais do app e define cada um dos seus componentes. Você vai revisitar este arquivo que você siga estas lições e adicionar mais componentes para o seu app. app / build.gradle

Android Studio usa Gradle para compilar e construir o seu app. Há um build.gradle arquivo para cada módulo do seu projeto, bem como a build.gradle arquivo para o projeto inteiro. Normalmente, você só está interessado no build.gradle arquivo para o módulo, neste caso, o app ou módulo de aplicação. Este é o lugar onde dependências de construção de seu aplicativo são definidas, incluindo as DefaultConfigconfigurações: 

compiledSdkVersion é a versão da plataforma com a qual você irá compilar o seu app. Por padrão, isso é definido como a última versão do Android disponível no seu SDK. (Deve ser Android 4.1 ou superior, se você não tem essa versão disponível, você deve instalar um usando o Gerenciador de SDK ). Você ainda pode construir seu aplicativo para suportar as versões mais antigas, mas definindo-o para a versão mais recente permite- para permitir novos recursos e otimizar o seu app para uma grande experiência do usuário em dispositivos mais recentes.



ApplicationID é o nome do pacote completo para seu aplicativo que você especificou durante o fluxo de trabalho New Project.



minSdkVersion é a versão SDK mínimo especificado durante o fluxo de

trabalho New Project. Esta é a versão mais antiga do Android SDK que o seu aplicativo suporta. 

targetSdkVersion indica a maior versão do Android com o qual você tenha testado sua aplicação. À medida que novas versões do Android se tornam disponíveis, você deve testar seu aplicativo na nova versão e atualizar este valor para corresponder ao nível API mais recente e, assim, tirar proveito dos novos recursos da plataforma. Para mais informações, leia o apoio às diferentes versões da plataforma .

Veja Construindo seu projeto com Gradle para mais informações sobre Gradle. Note-se também os / RES subdiretórios que contêm os recursos para a sua aplicação: drawable

/

Diretórios para objetos drawable (como bitmaps) que são projetados para várias densidades, como de média densidade (MDPI) e (hdpi) telas de alta densidade. Outros diretórios drawable conter ativos projetadas para outras densidades de tela. Aqui você vai encontrar o ic_launcher.png que aparece quando você executar o aplicativo padrão. layout /

Diretório para arquivos que definem a interface de seu aplicativo do usuário, como activity_my.xml, discutido acima, que descreve um layout básico para a classe MyActivity. Menu /

Diretório para arquivos que definem os itens de menu de seu aplicativo.

valores /

Diretório para outros arquivos XML que contêm um conjunto de recursos, tais como definições de cordas e de cor. O arquivo strings.xml define o "Olá, mundo!" seqüência que mostra quando você executar o aplicativo padrão. Para executar o aplicativo, passe para a próxima lição .

Criar um projeto com ferramentas de linha de comando Se você não está usando o IDE Android Studio, você pode, em vez criar seu projeto usando as ferramentas do SDK a partir de uma linha de comando: 1. Altere os diretórios para o SDK do Android SDK / caminho. 2. Executar: ferramentas / alvos lista android

Imprime uma lista de plataformas disponíveis para Android que você tenha baixado para o seu SDK. Encontre a plataforma com a qual você quer compilar seu app. Anote o ID de destino. Recomendamos que você selecione a versão mais alto possível. Você ainda pode construir o seu app para apoiar as versões mais antigas, mas definir o destino de compilação para a versão mais recente permite otimizar seu aplicativo para os dispositivos mais recentes. Se você não vê quaisquer metas listadas, você precisa instalar alguns usando a ferramenta SDK Android Manager. Veja Adicionando pacotes SDK . 3. Executar: 4. android criar projeto --target --name MyFirstApp \ 5. --path / MyFirstApp --activity MyActivity \ 6. com.example.myfirstapp --package

Substitua com um ID da lista de alvos (da etapa anterior) e substitua com o local em que você deseja salvar seus projetos Android. Dica: Adicione as plataformas-tools / , bem como a / ferramentas de diretório para a PATH variável de ambiente. Seu projeto Android é agora um app básico "Olá Mundo", que contém alguns arquivos padrão. Para executar o aplicativo, passe para a próxima lição .

Executando o seu App ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Executado em um dispositivo real 2. Execute no Emulator

VOCÊ TAMBÉM DEVE LER  Utilizar dispositivos de hardware  Gerenciando AVDs com AVD Manager  Gerenciamento de Projetos

Se você seguiu a lição anterior para criar um projeto Android, que inclui um conjunto padrão de arquivos de origem "Olá Mundo" que permitem que você execute imediatamente o app. Como você executar seu aplicativo depende de duas coisas: se você tem um dispositivo real rodando Android e se você estiver usando o Android Studio. Esta lição mostra como instalar e executar o seu aplicativo em um dispositivo real e no emulador Android, e em ambos os casos com ou Estúdio Android ou as ferramentas de linha de comando.

Executado em um dispositivo real Se você tiver um dispositivo rodando Android, aqui está como instalar e executar o seu app.

Configurar o dispositivo 1. Conecte o dispositivo ao computador de desenvolvimento com um cabo USB. Se você está desenvolvendo no Windows, pode ser necessário instalar o driver USB apropriado para o seu dispositivo. Para os motoristas de ajuda para instalar, consulte o drivers USB OEM documento. 2. Ativar a depuração USB no seu dispositivo. o

Na maioria dos dispositivos que executam o Android 3.2 ou mais, você pode encontrar a opção emConfigurações> Aplicativos> Desenvolvimento .

o

No Android 4.0 e mais recentes, está em Configurações> Opções do desenvolvedor . Nota: No Android 4.2 e mais recentes, Opções do desenvolvedor está oculta por padrão. Para torná-lo disponível, vá para Configurações> Sobre o telefone e toque em número Construir sete vezes. Retorne à tela anterior de encontrar opções de Desenvolvedor .

Execute o aplicativo do Android Estúdio 1. Selecione um dos arquivos do seu projeto e clique em Executar ferramentas.

na barra de

2. Na Escolha Aparelho janela que aparece, selecione a um dispositivo executando Escolha botão de opção, selecione o dispositivo e clique em OK . Android Estúdio instala o aplicativo em seu dispositivo conectado e começa-lo.

Execute o aplicativo a partir de uma linha de comando Abra uma linha de comando e navegue até o diretório raiz do seu projeto. Use Gradle para construir seu projeto no modo de depuração, invocar o assembleDebug tarefa de compilação usando o script wrapper Gradle (assembleRelease gradlew ). Isso cria a sua depuração .apk arquivo dentro do módulo build / diretório, chamado MyFirstApp-debug.apk . Em plataformas Windows, digite o seguinte comando:

> gradlew . bat assembleDebug

Em plataformas Mac OS e Linux, digite os seguintes comandos:

$ Chmod + x gradlew $ ./ gradlew assembleDebug

Depois de criar o projeto, a saída APK para o módulo app está localizado em app / construir / saídas / apk /

Nota: O primeiro comando ( chmod ) acrescenta a permissão de execução ao script wrapper Gradle e só é necessária na primeira vez que construir esse projeto a partir da linha de comando. Verifique se o SDK Android platform-tools / diretório está incluído no seu PATH variável de ambiente, em seguida, execute:

adb instalar app / build / saídas / MyFirstApp-debug.apk

No dispositivo, localize MyFirstApp e abri-lo. Isso é como você construir e executar seu aplicativo Android em um dispositivo! Para iniciar o desenvolvimento, passe para a próxima lição .

Execute no Emulator

Se você está usando o Android Studio ou a linha de comando, para executar seu aplicativo no emulador, você precisa primeiro criar um dispositivo virtual Android (AVD). Um AVD é uma configuração do dispositivo para o emulador Android que permite modelar um dispositivo específico.

Criar uma AVD 1. Lançar o Android Virtual Device Manager: o

Em Android Studio, selecione Ferramentas> Android> Gerenciador de AVD , ou clique no ícone AVD Gerente

o

na barra de ferramentas.

Ou, a partir da linha de comando, altere os diretórios para sdk / e execute: ferramentas / android avd

Nota: O Gestor de AVD que aparece quando iniciado a partir da linha de comando é diferente da versão em Android Studio, de modo que as instruções a seguir podem não se aplicar.

2. 3. Figura 1. A tela principal AVD Manager mostra seus dispositivos virtuais atuais.

4. Na tela principal do AVD Manager (figura 1), clique em Criar Dispositivo Virtual . 5. Na janela Selecionar Hardware, selecione a configuração do dispositivo, tais como Nexus 6, em seguida, clique em Avançar . 6. Selecione a versão do sistema desejado para o AVD e clique em Avançar .

7. Verifique as definições de configuração, clique em Finish . Para obter mais informações sobre o uso de AVDs, consulte Gerenciando AVDs com AVD Manager .

Execute o aplicativo do Android Estúdio 1. Em Android Estúdio , selecione seu projeto e clique em Executar ferramentas.

na barra de

2. Na Escolha Aparelho janela, clique no emulador Lançamento botão de rádio. 3. A partir do dispositivo virtual Android menu pull-down, selecione o emulador que você criou e clique em OK . Pode demorar alguns minutos para que o emulador para carregar em si. Você pode ter que desbloquear o ecrã.Quando fizer isso, meu primeiro aplicativo aparece na tela do emulador.

Execute o aplicativo a partir da linha de comando 1. Criar o projeto a partir da linha de comando. A saída APK para o módulo app está localizado em app / construir / saídas / apk / . 2. Verifique se o SDK Android platform-tools / diretório está incluído no seu PATH variável de ambiente. 3. Execute este comando: adb instalar app / build / saídas / MyFirstApp-debug.apk

4. No emulador, localize MyFirstApp e abri-lo. Isso é como você construir e executar seu aplicativo Android no emulador! Para iniciar o desenvolvimento, passe para a próxima lição .

Construir uma interface de usuário simples ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Criar um layout Linear 2. Adicionar um campo de texto 3. Adicionar recursos de seqüência 4. Adicionar um botão de 5. Faça a Caixa de Entrada Preencha a largura da tela

VOCÊ TAMBÉM DEVE LER  Layouts

Nesta lição, você cria um layout em XML que inclui um campo de texto e um botão. Na próxima lição, o aplicativo responde quando o botão é pressionado, enviando o conteúdo do campo de texto para outra atividade. A interface gráfica do usuário para um aplicativo Android é construído usando uma hierarquia de Visualização e ViewGroupobjetos. Visualização de objetos são geralmente widgets UI, tais como botões ou campos de texto . ViewGroup objetos são vista recipientes invisíveis que definem como os pontos de vista de crianças são colocadas para fora, como em uma grade ou uma lista vertical. Android fornece um vocabulário XML que corresponde às subclasses de Ver e ViewGroup para que você possa definir o seu UI em XML usando uma hierarquia de elementos de interface do usuário. Layouts são subclasses da ViewGroup . Neste exercício, você vai trabalhar com um LinearLayout .

Layouts alternativos Declarando seu layout UI em XML em vez de código de tempo de execução é útil por várias razões, mas é especialmente importante para que você possa criar layouts diferentes para diferentes tamanhos de tela. Por exemplo, você pode criar duas versões de um layout e dizer ao sistema para usar um sobre "pequenas" telas e outra nas telas "grandes". Para obter mais informações, consulte a classe sobre apoio às diferentes dispositivos.

Figura 1. Ilustração de como ViewGroup objetos ramos de formulário no layout e conter outros Veja objetos.

Criar um layout Linear 1. Em Android Studio, da res / layout diretório, abra o activity_my.xml arquivo. O modelo BlankActivity que você escolheu quando criou este projeto inclui a activity_my.xml arquivo com um RelativeLayout exibição de raiz e um TextView vista criança. 2. Na prévia painel, clique no ícone Ocultar

para fechar o painel de visualização.

Em Android Studio, quando você abre um arquivo de layout, você é mostrado primeiro painel de visualização.Clicando elementos neste painel abre as ferramentas WYSIWYG no painel de estrutura. Para esta lição, você vai trabalhar diretamente com o XML. 3. Excluir o elemento. 4. Alterar o elemento a . 5. Adicione o android: orientação atributo e defini-la como "horizontal" . 6. Retire o android: preenchimento atributos e ferramentas: contexto atributo. O resultado se parece com isso: res / layout / activity_my.xml



LinearLayout é um grupo view (uma subclasse de ViewGroup ) que estabelece pontos

de vista da criança em uma orientação vertical ou horizontal, conforme especificado pelo android: orientação atributo. O filho de umLinearLayout aparece na tela na ordem em que aparece no XML.

Dois outros atributos, android: layout_width e android: layout_height , são necessários para todos os pontos de vista, a fim de especificar o seu tamanho. Porque o LinearLayout é a exibição de raiz no layout, deve preencher a área da tela inteira que está disponível para o aplicativo, definindo a largura e altura para "match_parent" . Este valor declara que a visão deve expandir sua largura ou altura para corresponder a largura ou altura da vista principal. Para mais informações sobre propriedades de layout, veja o layout guia.

Adicionar um campo de texto Tal como acontece com todas as Vista objeto, você deve definir os atributos certos XML para especificar oEditText propriedades do objeto. 1. No activity_my.xml arquivo, dentro do elemento, definir um elemento com o idatributo definido como @ + id / edit_message . 2. Definir o layout_width e layout_height atributos como wrap_content . 3. Definir uma dica atributo como uma string objeto chamado edit_message . O elemento deve ter a seguinte redacção: res / layout / activity_my.xml



Aqui estão o atributos que você adicionou: android: id

Isso fornece um identificador exclusivo para a vista, que você pode usar para fazer referência ao objeto do seu código app, como ler e manipular o objeto (você vai ver isso na próxima aula). O sinal de arroba ( @ ) é necessária quando você está se referindo a qualquer objeto de recurso do XML. Ele é seguido pelo tipo de recurso ( id , neste caso), uma barra, em seguida, o nome do recurso ( edit_message).

Objetos de recurso Um objeto de recurso é um nome inteiro exclusivo que está associado a um recurso app, como um bitmap, arquivo layout, ou string. Todo recurso tem um objeto de recurso correspondente definida no do seu projeto gen / R.java arquivo.Você pode usar os nomes de objeto noR classe para se referir a seus recursos, tais como quando você precisa especificar um valor de cadeia para o android: dica atributo. Você também pode criar IDs

de recursos arbitrários que você associa com vista usando o android: id atributo, que permite fazer referência a esse ponto de vista de outro código. As ferramentas do SDK gerar o R.javaarquivo cada vez que você compilar o seu app. Você nunca deve modificar este arquivo manualmente. Para mais informações, leia o guia para Fornecendo recursos .

O sinal de mais ( + ) antes do tipo de recurso só é necessária quando você está definindo um ID de recurso pela primeira vez. Quando você compilar o aplicativo, as ferramentas do SDK usar o nome de ID para criar um novo ID de recursos em seu projeto de gen / R.java arquivo que se refere aoEditText elemento. Com a identificação do recurso, uma vez declarado desta forma, outras referências para a identificação não é necessário o sinal de mais. Usando o sinal de mais é necessário somente quando a especificação de um novo ID de recursos e não é necessário para recursos concretos, tais como cordas ou layouts. Veja o Sidebox para obter mais informações sobre objetos de recurso. android: layout_width e android: layout_height

Em vez de usar tamanhos específicos para a largura e altura, o"wrap_content" valor especifica que a visão deve ser apenas tão grande quanto necessário para ajustar o conteúdo do ponto de vista. Se você tivesse que passar a usar"match_parent" , então o EditText elemento iria preencher a tela, porque iria coincidir com o tamanho do pai LinearLayout. Para obter mais informações, consulte o Layouts guia. android: dica

Esta é uma seqüência de caracteres padrão para exibir quando o campo de texto está vazio. Em vez de usar uma string codificada como o valor, o "@ string / edit_message"valor refere-se a um recurso de cadeia definido em um arquivo separado. Porque esta refere-se a um recurso concreto (e não apenas um identificador), ele não precisa de o sinal de mais. No entanto, porque você não tiver definido o recurso de cadeia no entanto, você verá um erro do compilador em primeiro lugar. Você vai corrigir isso na próxima seção, definindo a seqüência. Nota: Este recurso de cadeia tem o mesmo nome que o ID elemento: edit_message . No entanto, as referências aos recursos são sempre com escopo pelo tipo de recurso (como ID ou corda ), portanto, usando o mesmo nome não causa colisões.

Adicionar recursos de seqüência Por padrão, o projeto Android inclui um arquivo de recurso de cadeia em res / valores / strings.xml . Aqui, você vai adicionar uma nova seqüência de caracteres chamado "edit_message" e defina o valor como "Digite uma mensagem." 1. Em Android Studio, a partir das res / valoriza diretório, aberto strings.xml .

2. Adicionar uma linha para uma seqüência de caracteres chamado "edit_message" com o valor, "Digite uma mensagem". 3. Adicionar uma linha para uma seqüência de caracteres chamado "button_send" com o valor, em "Enviar". Você vai criar o botão que utiliza esta cadeia na próxima seção. 4. Remova a linha para o "Olá mundo" string. O resultado para strings.xml parece com isso: res / valores / strings.xml

My First App Digite um message Send Settings MainActivity

Para o texto na interface do usuário, sempre especificar cada corda como um recurso. Recursos de cadeia permitem que você gerencie todo o texto da interface do usuário em um único local, o que torna o texto mais fácil de encontrar e atualização. Externalisação as cordas também permite localizar o seu app para diferentes idiomas, fornecendo definições alternativas para cada recurso de cadeia. Para obter mais informações sobre o uso de recursos de cadeia para localizar o seu aplicativo para outros idiomas, consulte o apoio aos diversos dispositivos de classe.

Adicionar um botão de 1. Em Android Studio, da res / layout diretório, edite o activity_my.xml arquivo. 2. Dentro do elemento, definir um elemento imediatamente a seguir ao elemento. 3. Ajuste da largura do botão e atributos altura para "wrap_content" assim que o botão é somente tão grande quanto necessário para caber rótulo de texto do botão. 4. Definir rótulo de texto do botão com o android: texto atributo; definir o valor para o button_send recurso de cadeia definido na seção anterior. Seu deve ser semelhante a este: res / layout / activity_my.xml



Nota: Este botão não precisa do android: id atributo, porque não vai ser referenciada a partir do código de atividade. A disposição está concebida de modo que tanto o EditarTexto e Botões estes elementos são somente tão grande quanto necessário, para ajustar o seu conteúdo, como mostrado na figura 2.

Figura 2. O EditText e botão Widgets têm suas larguras definida como "wrap_content" .

Isso funciona bem para o botão, mas não tão bem para o campo de texto, porque o usuário pode digitar algo mais. Seria bom para preencher a largura da tela não utilizada com o campo de texto. Você pode fazer isso dentro de um LinearLayout com o peso da propriedade, o que você pode especificar usando o android: layout_weight atributo. O valor do peso é um número que especifica a quantidade de espaço restante cada exibição deve consumir, em relação à quantidade consumida pelos irmãos visualizações. Isso funciona mais ou menos como a quantidade de ingredientes em uma receita da bebida: "2 partes de soda, xarope de 1 parte" significa dois terços da bebida é refrigerante. Por exemplo, se você der uma vista de um peso de 2 e outro um peso de 1, a soma é de 3, então a primeira vista enche 2/3 do espaço restante ea segunda vista preenche o resto. Se você adicionar um terceiro ponto de vista e dar-lhe um peso de 1, então a primeira vista (com peso de 2) agora recebe 1/2 o espaço restante, enquanto os restantes dois cada obter 1/4. O peso padrão para todos os pontos de vista é 0, por isso, se você especificar qualquer valor de peso maior que 0 a apenas um ponto de vista, em seguida, que a visão preenche o espaço que permanece após todas as vistas são dados o espaço de que necessitam.

Faça a Caixa de Entrada Preencha a largura da tela Para preencher o espaço restante em seu layout com o EditText elemento, faça o seguinte: 1. No activity_my.xml arquivo, atribua o elemento layout_weight atribuir um valor de 1 . 2. Além disso, atribuir elemento layout_width atribuir um valor de 0DP . res / layout / activity_my.xml



Para melhorar a eficiência do layout quando você especificar o peso, você deve alterar a largura do EditTextser zero (0DP). Definir a largura para zero porque melhora o desempenho do esquema usando"wrap_content" como a largura requer o sistema para calcular uma largura que é irrelevante porque em última análise, o valor do peso requer um outro cálculo de largura para preencher o espaço restante. A Figura 3 mostra o resultado quando você atribui todo o peso ao EditText elemento.

Figura 3. O EditText widget é dado todo o peso layout, de forma a preencher o espaço restante no LinearLayout .

Veja como sua completa activity_my.xml arquivo de layout agora deve ser: res / layout / activity_my.xml



Executar o seu App Este layout é aplicado pelo padrão Atividade classe que as ferramentas do SDK gerado quando você criou o projeto. Execute o aplicativo para ver os resultados: 

Em Android Studio, a partir da barra de ferramentas, clique em Executar



.

Ou a partir de uma linha de comando, altere os diretórios para a raiz do seu projeto Android e executar: ant debug adb instalar bin / MyFirstApp - debug . apk

Continue para a próxima lição para aprender a responder ao pressionamento de botões, ler o conteúdo do campo de texto, iniciar outra atividade, e muito mais.

A partir de uma outra atividade ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Responder ao botão Enviar 2. Construir uma Intent 3. Criar a segunda atividade 4. Receba o Intent 5. Mostrar a Mensagem

VOCÊ TAMBÉM DEVE LER  Instalando o SDK

Depois de completar a lição anterior , você tem um aplicativo que mostra uma atividade (uma única tela) com um campo de texto e um botão. Nesta lição, você vai adicionar algum código para MyActivity que inicia uma nova atividade quando o usuário clica no botão Enviar.

Responder ao botão Enviar 1. Em Android Studio, da res / layout diretório, edite oactivity_my.xml arquivo. 2. Para o elemento, adicionar o android: onClickatributo. res / layout / activity_my.xml



O android: onClick valor do atributo, "sendMessage" , é o nome de um método em sua atividade que o sistema chama quando o usuário clica no botão. 3. No java / com.mycompany.myfirstapp diretório, abra o MyActivity.java arquivo. 4. Dentro do MyActivity classe, adicione o sendMessage () método stub mostrado abaixo. java / com.mycompany.myfirstapp / MyActivity.java

/ ** Chamado quando o usuário clica no botão Enviar * / público vazio sendMessage ( Ver vista ) { // faz alguma coisa em resposta ao botão }

Para que o sistema para combinar com esse método para o nome do método dado a android: onClick , a assinatura deve ser exatamente como mostrado. Especificamente, o método deve: o

Seja pública

o

Ter um valor de retorno void

o

Tenha um Ver como único parâmetro (este será o Vista que foi clicado)

Em seguida, você vai preencher esse método para ler o conteúdo do campo de texto e entregar esse texto para outra atividade.

Construir uma Intent 1. Em MyActivity.java , dentro do sendMessage () método, crie um Intenção para iniciar uma atividade chamada DisplayMessageActivity com o seguinte código: java / com.mycompany.myfirstapp / MyActivity.java

público vazio sendMessage ( Ver vista ) { Intenção intenção = nova Intent ( este , . classe ); }

DisplayMessageActivity

Intenções Uma Intenção é um objeto que fornece a ligação entre os componentes separados (tais como duas atividades) runtime. A Intençãorepresenta "a intenção de fazer alguma coisa." de um app Você pode usar as intenções para uma ampla variedade de tarefas, mas na maioria das vezes eles são usados para iniciar outra atividade. Para obter mais informações, consulte as intenções e Filtros Intent .

Nota: A referência a DisplayMessageActivity irá gerar um erro se você estiver usando uma IDE como o Android Estúdio porque a classe não existe ainda. Ignore o erro, por enquanto;você vai criar a classe em breve. O construtor utilizado aqui tem dois parâmetros: o

A Contexto como seu primeiro parâmetro ( este é usado porque o Activity classe é uma subclasse de Contexto )

o

A classe do componente app para o qual o sistema deve entregar a Intenção (neste caso, a actividade que deve ser iniciado)

Android Estúdio indica que você deve importar o Intenção de classe. 2. Na parte superior do arquivo, importe o Intenção de classe: java / com.mycompany.myfirstapp / MyActivity.java

importação android . conteúdo . Intenção ;

Dica: No Android Studio, pressione Alt + Enter (opção + retorno do Mac) para importar faltar às aulas.

3. Dentro do sendMessage () método, use findViewById () para obter o EditText elemento. java / com.mycompany.myfirstapp / MyActivity.java

public void sendMessage ( View view ) { Intent intent = new Intent ( this , DisplayMessageActivity . class ); EditText editText = ( EditText ) findViewById ( R . id . edit_message ); }

4. Na parte superior do arquivo, importe o EditText classe. Em Android Studio, pressione Alt + Enter (opção + retorno do Mac) para importar faltar às aulas. 5. Atribuir o texto para um local de mensagem variável, e usar o putExtra () método para adicionar seu valor de texto para a intenção. java / com.mycompany.myfirstapp / MyActivity.java

public void sendMessage ( View view ) { Intent intent = new Intent ( this , DisplayMessageActivity . class ); EditText editText = ( EditText ) findViewById ( R . id . edit_message ); String message = editText . getText (). toString (); intent . putExtra ( EXTRA_MESSAGE , message ); }

Uma Intenção pode transportar tipos de dados como pares de valores-chave chamados extras . O putExtra () método leva o nome da chave no primeiro parâmetro e o valor no segundo parâmetro. 6. Na parte superior do MyActivity classe, adicionar o EXTRA_MESSAGE definição como se segue: java / com.mycompany.myfirstapp / MyActivity.java

public class MyActivity extends ActionBarActivity public final static String EXTRA_MESSAGE = "com.mycompany.myfirstapp.MESSAGE" ; ... }

{

Para a próxima atividade para consultar os dados extras, você deve definir a chave para o adicional de sua intenção através de um constante público. Em geral, é uma boa prática para definir as chaves para extras intenção usando o nome do pacote do seu aplicativo como um prefixo. Isso garante que as chaves são únicas, no caso do seu app interage com outros apps. 7. No sendMessage () método, para terminar a intenção, ligue para o startActivity () método, passando oIntenção objeto criado na etapa 1. Com esse novo código, a completa sendMessage () método que é chamado pelo botão Enviar agora se parece com isso: java / com.mycompany.myfirstapp / MyActivity.java

/ ** Chamado quando o usuário clica no botão Enviar */ public void sendMessage ( View view ) { Intent intent = new Intent ( this , DisplayMessageActivity . class ); EditText editText = ( EditText ) findViewById ( R . id . edit_message ); String message = editText . getText (). toString (); intent . putExtra ( EXTRA_MESSAGE , message ); startActivity ( intent ); }

O sistema recebe esta chamada e inicia uma instância da Atividade especificado pelo Intent . Agora você precisa criar o DisplayMessageActivity classe para que isso funcione.

Criar a segunda atividade Todas as subclasses de Atividade deve implementar a onCreate () método. Este método é o lugar onde a atividade recebe a intenção com a mensagem, em seguida, processa a mensagem. Além disso, o onCreate ()método deve definir o layout atividade com o setContentView () método. Este é o lugar onde a atividade executa a configuração inicial dos componentes de atividade.

Criar uma nova atividade usando Android Estúdio

Figura 1. O novo assistente de atividade no Android Studio.

Android Studio inclui um esboço para oonCreate () método quando você cria uma nova atividade. 1. Em Android Studio, no java diretório, selecione o pacote,com.mycompany.myfirstapp , clique com o botão direito e selecione Novo> Atividade> Atividade em branco . 2. Na escolha Opções de janela, preencha os detalhes da atividade: o

Nome da atividade : DisplayMessageActivity

o

Nome do layout : activity_display_message

o

Título : Minha mensagem

o

Pai hierárquica : com.mycompany.myfirstapp.MyActivity

o

Nome do pacote : com.mycompany.myfirstapp

Clique em Concluir . 3. Abra o DisplayMessageActivity.java arquivo. A classe já inclui uma implementação da necessária onCreate () método. Você vai atualizar a implementação deste método mais tarde. Ele também inclui uma implementação de onOptionsItemSelected () , que trata da barra de ação Up comportamento. Mantenha estes dois métodos como são para agora.

4. Remover o onCreateOptionsMenu () método. Você não vai precisar dele para este app. Se você está desenvolvendo com Android Studio, você pode executar o aplicativo agora, mas não acontece muita coisa. Clicando no botão Enviar começa a segunda atividade, mas ele usa um padrão "Olá, mundo" Layout fornecidos pelo modelo. Em breve, você atualizar a atividade a vez exibir uma visão texto personalizado.

Criar a atividade sem Android Estúdio Se você estiver usando uma IDE ou as ferramentas de linha de comando diferente, faça o seguinte: 1. Crie um novo arquivo chamado DisplayMessageActivity.java no projeto src / diretório, ao lado do originalMyActivity.java arquivo. 2. Adicione o seguinte código para o arquivo:

Handle item da barra de acção clica aqui. A barra de ação vai // tratar automaticamente os cliques no botão Home / Up, desde // como você especificar uma atividade pai em

Um fragmento de espaço reservado contendo uma simples

Nota: Se você estiver usando uma IDE diferente Android Studio, seu projeto não contém oactivity_display_message layout que é solicitado pelo setContentView () . Isso é OK, porque você vai atualizar este método mais tarde e não vai estar usando esse layout. 3. Para sua strings.xml arquivo, adicione o título do novo atividade da seguinte forma: ... Minha Mensagem

4. Em seu arquivo de manifesto, AndroidManifest.xml , dentro do aplicativo elemento, adicione o elemento para o seu DisplayMessageActivity classe, como segue: ...

O android: parentActivityName atributo declara o nome da atividade pai desta atividade dentro hierarquia lógica do aplicativo. O sistema utiliza este valor para implementar comportamentos de navegação padrão, comonavegação Up on Android 4.1 (nível API 16) e superior. Você pode fornecer os mesmos comportamentos de navegação para versões mais antigas do Android usando a biblioteca de suporte e adicionando o elemento imediata. Nota: O seu SDK Android já deverá incluir o suporte mais recente Biblioteca Android, que você instalou durante a adição de pacotes SDK etapa. Ao usar os modelos no Android Studio, a biblioteca de suporte é automaticamente adicionado ao seu projeto app (você pode ver arquivo JAR da biblioteca listada emDependências Android ). Se você não está usando o Android Studio, você precisa adicionar manualmente a biblioteca para o seu projeto de seguir o guia para configurar a biblioteca de suporte , em seguida, voltar aqui. Se você estiver usando uma IDE diferente do Android Studio, não se preocupe que o app ainda não irá compilar.Em breve, você atualizar a atividade para exibir uma visão texto personalizado.

Receba o Intent Cada atividade é invocado por um Intent , independentemente de como o usuário navegou lá. Você pode obter a Intenção que começou sua atividade chamando getIntent () e recuperar os dados contidos na intenção. 1. No java / com.mycompany.myfirstapp diretório, edite o DisplayMessageActivity.java arquivo. 2. No onCreate () método, remova a seguinte linha: setContentView ( R . disposição . activity_display_message );

3. Obter a intenção e atribuí-lo a uma variável local. Intenção intenção = getIntent ();

4. Na parte superior do arquivo, importe o Intenção de classe. Em Android Studio, pressione Alt + Enter (opção + retorno do Mac) para importar faltar às aulas. 5. Extrai-se a mensagem entregue por MyActivity com o getStringExtra () método. Cadeia mensagem = intenção . getStringExtra ( MyActivity . EXTRA_MESSAGE );

Mostrar a Mensagem 1. No onCreate () método, crie um TextView objeto. TextView textView =

nova

TextView ( este );

2. Defina o tamanho do texto e mensagem com setText () . textView . SetTextSize ( 40 ); textView . setText ( mensagem );

3. Em seguida, adicione o TextView como a vista raiz do layout da atividade, passando-a para setContentView () . setContentView ( textView );

4. Na parte superior do arquivo, importe o TextView classe. Em Android Studio, pressione Alt + Enter (opção + retorno do Mac) para importar faltar às aulas.

A completa onCreate () método para DisplayMessageActivity agora se parece com isso:

Override pública vazio onCreate ( Bundle savedInstanceState ) super . onCreate ( savedInstanceState );

{

// Obter a mensagem da intenção Intenção intenção = getIntent (); Cordas mensagem = intenção . getStringExtra ( MyActivity . EXTRA_MESSAGE ); // Criar TextView textView textView

a exibição de texto textView = nova TextView ( este ); . SetTextSize ( 40 ); . setText ( mensagem );

// definir a exibição de texto como o layout atividade setContentView ( textView ); }

Agora você pode executar o aplicativo. Quando se abre, digite uma mensagem no campo de texto, clique em Enviar, e a mensagem aparece na segunda atividade.

Figura 2. Ambas as atividades no app final, funcionando com o Android 4.4.

É isso aí, você construiu o seu primeiro aplicativo Android! Para saber mais, siga o link abaixo para a próxima aula

Adicionando o Bar Ação COMEÇAR

DEPENDÊNCIAS E PRÉ-REQUISITOS  Android 2.1 ou superior

VOCÊ TAMBÉM DEVE LER  Barra de ação  A implementação da navegação eficaz

GUIA DE DESIGN

Barra de ação A barra de ação é um dos elementos de design mais importantes que você pode implementar para as atividades de seu aplicativo. Ele oferece vários recursos de interface de usuário que fazem seu app imediatamente familiar aos usuários, oferecendo consistência entre outros aplicativos do Android. As principais funções incluem: 

Um espaço dedicado para dar o seu app de uma identidade e indicando a localização do usuário no aplicativo.



O acesso a importantes ações de uma forma previsível (como Search).



Suporte para a navegação e visualização de comutação (com abas ou listas dropdown).

Esta classe de treinamento oferece um guia rápido para o básico da barra de ação. Para obter mais informações sobre os vários recursos de barra de ação, consulte a Ação Bar guia.

Lições Configurando o Bar Ação Saiba como adicionar uma barra de ação básica para sua atividade, se o seu aplicativo suporta apenas Android 3.0 e superior ou também suporta versões tão baixas como Android 2.1 (usando a biblioteca de suporte Android). Adicionando botões de ação Saiba como adicionar e responder às ações do usuário na barra de ação.

Denominando a Barra de Ação Aprenda a personalizar a aparência de sua barra de ação. Sobrepondo o Bar Ação Aprenda a sobrepor a barra de ação na frente de seu layout, permitindo transições contínuas ao esconder a barra de ação.

Configurando o Bar Ação ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Suporte Android 3.0 e acima só 2. Suporte Android 2.1 e acima

VOCÊ TAMBÉM DEVE LER  Configurando a biblioteca de suporte

Em sua forma mais básica, a barra de ação exibe o título para a atividade e o ícone do aplicativo na esquerda. Mesmo nessa forma simples, a barra de ação é útil para todas as atividades para informar os usuários sobre onde estão e para manter uma identidade constante para o seu app.

Figura 1. Uma barra de ação com o ícone do app e título da atividade. Configurando um bar ação básica exige que o seu aplicativo usa um tema atividade que permite a barra de ação. Como pedir um tal tema depende de qual versão do Android é a mais baixa suportado pelo seu app. Então, essa lição é dividido em duas seções, dependendo de qual versão do Android é a sua menor suporte.

Suporte Android 3.0 e acima só Começando com o Android 3.0 (nível API 11), a barra de ação está incluído em todas as atividades que utilizam o Theme.Holo tema (ou um de seus descendentes), que é o tema padrão quando quer o targetSdkVersion ouminSdkVersion atributo é definido como "11 " ou superior. Então, para adicionar a barra de ação para suas atividades, basta definir ou atribuir a 11 ou superior. Por exemplo:

...

Nota: Se você criou um tema personalizado, não se esqueça que ele usa um dos Theme.Holo temas como seu pai. Para mais detalhes, consulte o Bar Styling Ação . Agora o Theme.Holo tema é aplicado ao seu app e todas as atividades mostrar a barra de ação. É isso aí.

Suporte Android 2.1 e acima Adicionando a barra de ação quando executado em versões mais antigas do que o Android 3.0 (para baixo para Android 2.1) exige que você incluir a biblioteca de suporte Android em sua aplicação. Para começar, leia o Setup Biblioteca de suporte de documentos e configurar o v7 AppCompat biblioteca (uma vez que você tenha baixado o pacote de biblioteca, siga as instruções para a adição de bibliotecas com recursos). Uma vez que você tem a biblioteca de suporte integrado com o seu projeto de aplicativo: 1. Atualize a sua atividade, de modo que ela se estende ActionBarActivity . Por exemplo: público

classe

MainActivity

estende

ActionBarActivity

{

...

}

2. Em seu arquivo de manifesto, atualizar ou o elemento ou individuais elementos para usar um dos Theme.AppCompat temas. Por exemplo:

android: theme = "@ estilo / Theme.AppCompat.Light" ...

Nota: Se você criou um tema personalizado, não se esqueça que ele usa um dos Theme.AppCompat temas como seu pai. Para mais detalhes, consulte o Bar Styling Ação . Agora, a sua actividade inclui a barra de ação quando em execução no Android 2.1 (nível API 7) ou superior. Lembre-se de definir adequadamente suporte de nível API do aplicativo no manifesto:



android: targetSdkVersion

...

Adicionando botões de ação ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Especifique as ações em XML 2. Adicione as ações para a Barra de Ação 3. Responda aos botões de ação 4. Adicionar Up Botão para atividades de baixo nível

VOCÊ TAMBÉM DEVE LER  Fornecendo Up Navigation

A barra de ação permite que você adicione botões para os itens de ação mais importantes relacionadas com o contexto atual do app. Aqueles que aparecem diretamente na barra de ação com um ícone e / ou texto são conhecidos como botões de ação .Ações que não cabem na barra de ação ou não são suficientemente importantes estão escondidos no estouro ação.

Figura 1. Uma barra de ação com um botão de ação para a busca e o transbordamento de ação, o que revela ações adicionais.

Especifique as ações em XML Todos os botões de ação e outros itens disponíveis no estouro de ação são definidos em um XML recurso de menu . Para adicionar ações a barra de ação, criar um novo arquivo XML em seu projeto de res / menu /diretório. Adicionar um elemento para cada item que deseja incluir na barra de ação. Por exemplo: res / menu / main_activity_actions.xml

...

Adicione as ações para a Barra de Ação

Para colocar os itens de menu na barra de ação, implementar o onCreateOptionsMenu () método de retorno em sua atividade para inflar o recurso de menu no dado menu objeto. Por exemplo:

Override público boolean onCreateOptionsMenu ( menu do menu ) { // Encha os itens de menu para uso na ação bar MenuInflater inflater = getMenuInflater (); inflater . inflate ( R . menu . main_activity_actions , menu ); return super . onCreateOptionsMenu ( menu ); }

Responda aos botões de ação Quando o usuário pressiona um dos botões de ação ou outro item no estouro de ação, o sistema chama de sua atividade onOptionsItemSelected () método de retorno. Em sua implementação deste método, chamargetItemId () sobre o dado MenuItem para determinar qual item foi pressionado-o ID devolvido corresponde ao valor que você declarou na correspondente do elemento android: id atributo.

Override público boolean onOptionsItemSelected ( MenuItem produto ) // prensas alça na barra de ação items switch ( item . getItemId ()) { case R . id . action_search : openSearch (); return true ; case R . id . action_settings : openSettings (); return true ; default : return super . onOptionsItemSelected ( item ); } }

{

Adicionar Up Botão para atividades de baixo nível

Figura 4. O Up botão no Gmail.

Todas as telas em seu aplicativo que não são a entrada principal para o seu aplicativo (atividades que não são a tela "home") deve oferecer ao usuário uma maneira de navegar para a tela pai lógico na hierarquia do aplicativo pressionando o Up botão na ação bar. Quando rodando em Android 4.1 (nível API 16) ou superior, ou quando usar ActionBarActivity da Biblioteca de suporte, realizando Upnavegação simplesmente requer que você declarar a atividade pai no arquivo de manifesto e permitir que o Up botão para a barra de ação. Por exemplo, aqui está como você pode declarar o pai de uma atividade no manifesto:

... ... elemento ou indivíduo elementos. Por exemplo:



android: theme = "android: estilo / Theme.Holo.Light" ...

Você também pode usar a barra de ação escuro, enquanto o resto da atividade usa o esquema de cor clara, declarando a Theme.Holo.Light.DarkActionBartema. Ao usar a biblioteca de suporte, você deverá usar osTheme.AppCompat temas: 

Theme.AppCompat para o tema "dark".



Theme.AppCompat.Light para o tema "light".



Theme.AppCompat.Light.DarkActionBar para o tema luz com uma barra de ação

escuro. Certifique-se que você use ícones da barra de ação que contrastam adequadamente com a cor de sua barra de ação. Para ajudá-lo, a Barra de ação Icon Pack inclui ícones de ação padrão para uso tanto com a luz Holo Holo e bar ação escuro.

Personalize o fundo

Para alterar a barra de fundo ação, criar um tema personalizado para a sua atividade que substitui oactionBarStyle propriedade. Esta propriedade aponta para um outro estilo em que você pode substituir ofundo propriedade para especificar um recurso drawable para o fundo barra de ação. Se o seu aplicativo usa guias de navegação ou a barra de ação de divisão , então você também pode especificar o fundo para estas barras usando os backgroundStacked e backgroundSplit propriedades, respectivamente.

Atenção: É importante que você declarar um tema pai adequado a partir do qual o tema personalizado e estilo herdar seus estilos. Sem um estilo pai, sua barra de ação será sem muitas propriedades de estilo, a menos que declará-los explicitamente si mesmo.

Para Android 3.0 e superior apenas Ao apoiar Android 3.0 e superior apenas, você pode definir o fundo da barra de ações como esta: RES / valores / themes.xml

< item name = "android: actionBarStyle" > @ estilo / MyActionBar < item name = "android: background" > @ drawable / actionbar_background

Em seguida, aplique o seu tema para todo o seu app ou atividades individuais:



Para Android 2.1 e superior Ao usar a biblioteca de suporte, o mesmo tema, como acima devem vez parecido com este: RES / valores / themes.xml

< item name = "android: actionBarStyle" > @ estilo / MyActionBar < item de nome = "actionBarStyle" > @ estilo / MyActionBar

< item name = "android: background" > @ drawable / actionbar_background < item de nome = "background" > @ drawable / actionbar_background

Em seguida, aplique o seu tema para todo o seu app ou atividades individuais:



Personalize a cor do texto Para modificar a cor do texto na barra de ação, você precisa substituir as propriedades separadas para cada elemento do texto: 

Título de ação bar: Criar um estilo personalizado que especifica o textColor propriedade e especificar que estilo para o titleTextStyle propriedade em seu costume actionBarStyle . Nota: O estilo personalizado aplicado a titleTextStyle deve usarTextAppearance.Holo.Widget.ActionBar.Title como o estilo pai.



Separadores de bar Ação: Substituir actionBarTabTextStyle em seu tema de atividade.



Os botões de ação: Substituir actionMenuTextColor em seu tema de atividade.

Para Android 3.0 e superior apenas Ao apoiar Android 3.0 e superior apenas, o seu arquivo XML estilo pode ter esta aparência: RES / valores / themes.xml

< item name = "android: actionBarStyle" > @ estilo / MyActionBar < item name = "android: actionBarTabTextStyle" > @ estilo / MyActionBarTabText < item name = "android: actionMenuTextColor" > @ cor /

actionbar_text < item name = "android: titleTextStyle" > @ estilo / MyActionBarTitleText < item name = "android: textColor" > @ cor / actionbar_text < item name = "android: textColor" > @ cor / actionbar_text

Para Android 2.1 e superior Ao usar a biblioteca de suporte, o seu arquivo XML estilo pode ter esta aparência: RES / valores / themes.xml

< item name = "android: actionBarStyle" > @ estilo / MyActionBar < item name = "android: actionBarTabTextStyle" > @ estilo / MyActionBarTabText < item name = "android: actionMenuTextColor" > @ cor / actionbar_text < item name = "actionBarStyle" > @ estilo / MyActionBar < item name = "actionBarTabTextStyle" > @ estilo / MyActionBarTabText < nome do item = "actionMenuTextColor" > @ cor / actionbar_text < item de nome = "android: titleTextStyle" > @ estilo / MyActionBarTitleText

< item name = "titleTextStyle" > @ estilo / MyActionBarTitleText @ cor / actionbar_text < item name = "android: textColor" > @ cor / actionbar_text

Personalize o Indicador Tab

Para alterar o indicador utilizado para as guias de navegação , criar um tema atividade que substitui oactionBarTabStyle propriedade. Esta propriedade aponta para outro recurso de estilo em que você substituir o fundo propriedade que deve especificar uma lista de estado drawable. Nota: A drawable-list estado é importante para que a guia selecionada no momento indica seu estado com um fundo diferente do que as outras abas. Para obter mais informações sobre como criar um recurso drawable que lida com vários estados de botão, leia a lista do estado documentação. Por exemplo, aqui está um drawable-list estado que declara uma imagem específica de fundo para vários estados diferentes de um guia barra de ação: res / drawable / actionbar_tab_indicator.xml

< item name = "android: actionBarTabStyle" > @ estilo / MyActionBarTabs < item name = "android: background" > @ drawable / actionbar_tab_indicator



Para Android 2.1 e superior Ao usar a biblioteca de suporte, o seu arquivo XML estilo pode ter esta aparência: RES / valores / themes.xml

< item name = "android: actionBarTabStyle" > @ estilo / MyActionBarTabs < item name = "actionBarTabStyle" > @ estilo / MyActionBarTabs < item name = "android: Fundo " > @ drawable / actionbar_tab_indicator < item de nome = "background" > @ drawable / actionbar_tab_indicator

Mais recursos 

Veja mais imóveis de estilo para a barra de ação estão listados na Ação Bar guia.



Saiba mais sobre como os temas funcionam na estilos e temas guia.



Para styling ainda mais completo para a barra de ação, tente a ação Generator Bar Estilo Android .

Sobrepondo o Bar Ação ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Ativar o modo de sobreposição 1. Para Android 3.0 e superior apenas 2. Para Android 2.1 e superior 2. Especifique layout Top-margin

VOCÊ TAMBÉM DEVE LER  Estilos e temas

Por padrão, a barra de ação aparece na parte superior da janela do seu atividade, ligeiramente reduzindo a quantidade de espaço disponível para o resto do layout do seu atividade. Se, durante o curso de interação com o usuário, que deseja ocultar e mostrar a barra de ação, você pode fazê-lo chamando hide ()e show () no ActionBar . No entanto, isso faz com que sua atividade para recalcular e redesenhar o layout baseado em seu novo tamanho.

Figura 1. barra de ação da galeria no modo de sobreposição.

Para evitar o redimensionamento seu layout quando a barra de ação esconde e mostra, você pode ativar o modo de sobreposição para a barra de ação. Quando em modo de sobreposição, o seu layout atividade usa todo o espaço disponível, como se a barra de ação não está lá e o sistema chama a barra de ação na frente de seu layout. Isso obscurece algum do layout, na parte superior, mas agora, quando a barra de ação oculta ou é apresentado, o sistema não precisa redimensionar o seu layout e a transição é perfeita. Dica: Se você quiser que o seu layout a ser parcialmente visível por trás da barra de ação, criar um estilo personalizado para a barra de ação com um fundo parcialmente transparente, como o mostrado na figura 1. Para obter informações sobre como definir o plano de fundo barra de ação, leia Styling na barra de ação .

Ativar o modo de sobreposição Para ativar o modo de sobreposição para a barra de ação, você precisa criar um tema personalizado que estende um tema barra de ação existente e definir o android: windowActionBarOverlay propriedade de verdade .

Para Android 3.0 e superior apenas

Se o seu minSdkVersion está definido para 11 ou superior, o tema personalizado deve usar Theme.Holo tema (ou um de seus descendentes) como seu tema principal. Por exemplo:

< item de nome = "android: windowActionBarOverlay" > verdadeiro < / produto >

Para Android 2.1 e superior Se seu aplicativo está usando a biblioteca de suporte para compatibilidade com versões em dispositivos menores que executam o Android 3.0, o tema personalizado deve usar Theme.AppCompat tema (ou um de seus descendentes) como seu tema principal. Por exemplo:

< item name = "android: windowActionBarOverlay" > verdadeiro < / produto > < item name = "windowActionBarOverlay" > verdadeiro

Note também que este tema inclui duas definições para o windowActionBarOverlay estilo: um com o android:prefixo e um sem. Aquele com o android: prefixo é para versões do Android, que incluem o estilo na plataforma e um sem o prefixo é para versões mais antigas que lêem o estilo da Biblioteca Suporte.

Especifique layout Top-margin Quando a barra de ação está em modo de sobreposição, pode obscurecer um pouco do seu layout que deve permanecer visível. Para garantir que tais itens permanecer abaixo da barra de ação em todos os momentos, adicionar ou margin ou padding para o topo da view (s) usando a altura especificada por actionBarSize . Por exemplo:

...

Se você estiver usando a biblioteca de suporte para a barra de ação, você precisa remover o android: prefixo.Por exemplo:

...

Neste caso, o attr / actionBarSize? valor sem o prefixo funciona em todas as versões, incluindo Android 3.0 e superior.

Apoiando Diferentes Devices COMEÇAR

DEPENDÊNCIAS E PRÉ-REQUISITOS  Android 1.6 ou superior

VOCÊ TAMBÉM DEVE LER  Recursos de Aplicativo  Projetando para Múltiplas Telas

Dispositivos Android vêm em muitas formas e tamanhos em todo o mundo. Com uma vasta gama de tipos de dispositivos, você tem a oportunidade de atingir um público enorme, com seu app. A fim de ser tão bem sucedido quanto possível no Android, o aplicativo precisa se adaptar a várias configurações de dispositivo. Algumas das variações importantes que você deve considerar incluem línguas diferentes tamanhos de tela e versões da plataforma Android. Esta classe ensina como usar a plataforma básica características que recursos alavancagem alternativos e outros recursos para que o seu app pode fornecer uma experiência de usuário otimizada em uma variedade de dispositivos compatíveis com o Android, usando um único pacote de aplicativos (APK).

Lições

Apoiando diferentes idiomas Aprenda a suportar vários idiomas com recursos de cadeia alternativas. Apoiando diferentes telas Saiba como otimizar a experiência do usuário para diferentes tamanhos de tela e densidades. Apoiando Diferentes versões da plataforma Saiba como usar APIs disponíveis em novas versões do Android enquanto continua a apoiar as versões mais antigas do Android.

Apoiando diferentes idiomas ANTERIORPRÓXIMA

ESTA CLASSE ENSINA VOCÊ A 1. Criar Local diretórios e arquivos de Cordas 2. Use os recursos de seqüência

VOCÊ TAMBÉM DEVE LER  Checklist Localization  Localização com Recursos

É sempre uma boa prática para extrair cordas UI do seu código app e mantê-los em um arquivo externo. Android torna isso fácil com um diretório de recursos em cada projeto Android. Se você criou seu projeto usando as ferramentas do SDK do Android (leia Criando um projeto Android ), as ferramentas de criação de um res / diretório no nível superior do projeto.Dentro deste RES / diretório são subdiretórios para vários tipos de recursos. Há também alguns arquivos padrão, como res / valores / strings.xml , que detém os seus valores de cadeia.

Criar Local diretórios e arquivos de Cordas Para adicionar suporte para mais idiomas, criar adicionaisvalores diretórios dentro RES / que incluem um hífen e o código de linguagem ISO no final do nome do diretório. Por exemplo, os valores-es / é o diretório que contém resourcess simples para as localidades com o código de linguagem "es". Android carrega os recursos apropriados de acordo com as definições de região do dispositivo em tempo de execução. Para obter mais informações, consulte Fornecendo recursos alternativos . Uma vez que você tenha decidido sobre os idiomas que você irá apoiar, criar os subdiretórios de recursos e arquivos de recursos string. Por exemplo: Meu projeto /

res / valores / strings.xml valores-es / strings.xml valores-fr / strings.xml

Adicione os valores de cadeia para cada localidade para o arquivo adequado. Em tempo de execução, o sistema Android utiliza o conjunto apropriado de recursos de cadeia com base na localidade actualmente definido para o dispositivo do usuário. Por exemplo, a seguir estão alguns arquivos de recursos seqüência diferentes para diferentes idiomas. Inglês (locale padrão), /values/strings.xml :

My Application Olá mundo! < / recursos>

Espanhol, /values-es/strings.xml :

Mi Aplicación Hola Mundo! < / recursos>

Francês, /values-fr/strings.xml :

Aplicação Mon Bonjour le monde!

Nota: Você pode usar o qualifier localidade (ou qualquer qualificador de configuração) em qualquer tipo de recurso, como se você quer fornecer versões localizadas do seu drawable bitmap. Para obter mais informações, consulte Localização .

Use os recursos de seqüência Você pode fazer referência a seus recursos de cadeia em seu código-fonte e outros arquivos XML usando o nome do recurso definido pelo do elemento nome atributo. Em seu código-fonte, você pode se referir a um recurso de cadeia com a sintaxe R.string. . Há uma variedade de métodos que aceitam um recurso de cadeia desta forma. Por exemplo:

// Obter um recurso de cadeia a partir do seu aplicativo de Recursos Cadeia Olá = getResources () . getString ( R . corda . hello_world ); // Ou fornecer um recurso de cadeia para um método que requer uma seqüência de TextView textView = nova TextView ( este ); textView . setText ( R . corda . hello_world );

Em outros arquivos XML, você pode se referir a um recurso de cadeia com a sintaxe cadeia @ / sempre que o atributo XML aceita um valor de cadeia. Por exemplo:



Apoiando diferentes telas ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Criar diferentes layouts 2. Criar bitmaps diferentes

VOCÊ TAMBÉM DEVE LER  Projetando para Múltiplas Telas  Fornecendo recursos  Guia de design de Iconografia

Android categoriza telas de dispositivos usando duas propriedades gerais: tamanho e densidade. Você deve esperar que seu aplicativo será instalado em dispositivos com telas que variam em tamanho e densidade. Como tal, você deve incluir alguns recursos alternativos que otimizem a aparência do seu app para diferentes tamanhos de tela e densidades. 

Há quatro tamanhos generalizadas: pequeno, normal, grande, extra grande



E quatro densidades generalizadas: baixo (LDPI), médio (MDPI), alta (HDPI), extra alta (xhdpi)

Para declarar diferentes layouts e bitmaps que você gostaria de usar para diferentes telas, você deve colocar esses recursos alternativos em diretórios separados, semelhante à forma como você faz para diferentes cadeias de idioma. Também estar ciente de que a orientação telas (paisagem ou retrato) é considerado uma variação do tamanho da tela, de modo que muitos aplicativos devem rever o layout para otimizar a experiência do usuário em cada orientação.

Criar diferentes layouts Para otimizar a experiência do usuário em diferentes tamanhos de tela, você deve criar um arquivo XML layout exclusivo para cada tamanho de tela que deseja apoiar. Cada layout deve ser salvo no diretório de recursos adequados, nomeado com um sufixo. Por exemplo, um layout exclusivo para as grandes telas devem ser guardados sob res / layout-large / . Nota: Android dimensiona automaticamente o seu layout a fim de encaixar corretamente na tela. Assim, os seus layouts para diferentes tamanhos de tela não precisa se preocupar com o tamanho absoluto de elementos de interface do usuário, mas sim concentrar-se na estrutura de layout que afeta a experiência do usuário (como o tamanho ou a posição de pontos de vista importantes em relação ao irmão visitas). Por exemplo, este projecto inclui um layout padrão e uma disposição alternativa para grandes telas: Meu projeto / res / layout / main.xml layout grande / main.xml

Os nomes dos arquivos devem ser exatamente o mesmo, mas o seu conteúdo é diferente, a fim de fornecer uma interface otimizada para o tamanho da tela correspondente.

Basta referenciar o arquivo de layout em seu aplicativo, como de costume:

@Override protected void onCreate ( Bundle savedInstanceState ) super . onCreate ( savedInstanceState ); setContentView ( R . layout . main ); }

{

O sistema carrega o arquivo de layout do diretório de layout adequado com base no tamanho da tela do dispositivo no qual o aplicativo está sendo executado. Mais informações sobre como Android seleciona o recurso apropriado está disponível no Recursos Fornecer guia. Como outro exemplo, aqui está um projecto com uma disposição alternativa para orientação paisagem: Meu projeto / res / layout / main.xml disposição do solo / main.xml

Por padrão, o / main.xml layout de arquivo é usado para orientação retrato. Se você quiser fornecer um layout especial para a paisagem, incluindo, enquanto em telas grandes, então você precisa usar tanto o grande e terra qualifier: Meu projeto / res / layout / # default (portrait) main.xml disposição do solo / paisagem # main.xml layout grande / # grande (portrait) main.xml leiaute-large-terra / # grande paisagem main.xml

Nota: Android 3.2 e acima suporta um método avançado de definir os tamanhos de tela que permite que você especifique os recursos para os tamanhos de tela com base na

largura e altura mínimas em termos de pixels independente de densidade. Esta lição não cobre esta nova técnica. Para mais informações, leia Projetando para Múltiplas Telas .

Criar bitmaps diferentes Você deve sempre fornecer recursos de bitmap que estão devidamente dimensionadas para cada um dos baldes densidade generalizadas: baixa, média, alta e extra-alta densidade. Isso ajuda você a alcançar uma boa qualidade e desempenho gráfico em todas as densidades de tela. Para gerar estas imagens, você deve começar com o seu recurso cru em formato vetorial e gerar as imagens para cada densidade utilizando a seguinte escala de tamanho: 

xhdpi: 2,0



HDPI: 1,5



MDPI: 1,0 (linha de base)



LDPI: 0,75

Isso significa que se você gerar uma imagem de 200x200 para dispositivos xhdpi, você deve gerar o mesmo recurso em 150x150 para HDPI, 100x100 para MDPI e 75x75 para dispositivos LDPI. Em seguida, coloque os arquivos no diretório drawable recurso apropriado: Meu projeto / res / drawable-xhdpi / awesomeimage.png drawable-HDPI / awesomeimage.png drawable-MDPI / awesomeimage.png drawable-LDPI / awesomeimage.png

Toda vez que você faz referência @ drawable / awesomeimage , o sistema seleciona o bitmap apropriado com base na densidade da tela. Nota: de baixa densidade (LDPI recursos) nem sempre são necessárias. Quando você fornece ativos hdpi, o sistema os reduz à metade telas LDPI para encaixar corretamente.

Para mais dicas e orientações sobre como criar ativos ícone para sua aplicação, consulte o Guia de design de Iconografia .

Apoiando Diferentes versões da plataforma ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Especifique mínimos e níveis alvo de API 2. Verifique versão do sistema em tempo de execução 3. Use estilos e temas de Plataforma

VOCÊ TAMBÉM DEVE LER  Níveis API Android  Biblioteca de suporte Android

Enquanto as versões mais recentes do Android costumam oferecer grandes APIs para o seu aplicativo, você deve continuar a apoiar as versões mais antigas do Android até mais dispositivos são atualizados. Esta lição mostra como tirar proveito dos mais recentes APIs enquanto continua a apoiar as versões mais antigas também. O painel de instrumentos para versões de plataforma é atualizado regularmente para mostrar a distribuição de dispositivos ativos em execução cada versão do Android, com base no número de dispositivos que visitam o Google Play Store. Geralmente, é uma boa prática para apoiar cerca de 90% dos dispositivos ativos, ao alvejar seu aplicativo para a versão mais recente. Dica: A fim de fornecer os melhores recursos e funcionalidades através de várias versões do Android, você deve usar a biblioteca de suporte Android em seu aplicativo, que permite a utilização de várias APIs da plataforma recentes em versões mais antigas.

Especifique mínimos e níveis alvo de API O AndroidManifest.xml arquivo descreve detalhes sobre seu app e identifica quais versões do Android que suporta. Especificamente, o minSdkVersion e targetSdkVersion atributos para o = Build . VERSION_CODES . HONEYCOMB ) { ActionBar actionBar = getActionBar (); actionBar . setDisplayHomeAsUpEnabled ( true ); } }

Nota: Ao analisar os recursos XML, Android ignora atributos XML que não são suportadas pelo dispositivo atual. Assim, você pode usar com segurança atributos XML que são apenas suportados por versões mais novas sem se preocupar com versões mais antigas que quebram quando se deparam com esse código. Por exemplo, se você definir o targetSdkVersion = "11" , o aplicativo inclui o ActionBar por padrão no Android 3.0 e superior. Para, em seguida, adicionar itens de menu para a barra de ação, você precisa definir android: showAsAction = "ifRoom" em seu XML recurso menu. É seguro fazer isso em um arquivo XML cross-versão, porque as versões mais antigas do Android simplesmente ignorar o showAsAction atributo (ou seja, você nãoprecisa de uma versão separada em res / menu v11 / ).

Use estilos e temas de Plataforma Android fornece temas de experiência do usuário que dão aplicativos a aparência do sistema operacional subjacente. Estes temas podem ser aplicadas ao seu app dentro do

arquivo de manifesto. Ao utilizar essas construído em estilos e temas, seu aplicativo irá naturalmente acompanhar as últimas aparência do Android a cada novo lançamento. Para tornar a sua atividade parece com uma caixa de diálogo:



Para tornar a sua actividade tem um fundo transparente:



Para aplicar o seu próprio tema personalizado definido em /res/values/styles.xml :



Para aplicar um tema para todo o seu app (todas as atividades), adicione o android: tema atribuem ao elemento:



Para saber mais sobre a criação e utilização de temas, leia a estilos e temas guia.

Interagindo com outros apps COMEÇAR

DEPENDÊNCIAS E PRÉ-REQUISITOS  Conhecimento básico do ciclo de vida de atividades (consulte Gerenciando o Ciclo de Vida de Atividade )

VOCÊ TAMBÉM DEVE LER  Compartilhamento de Dados Simples  Compartilhamento de Arquivos  A integração do aplicativo com Intenções (post)  Intenções e filtros Intent

Um app Android normalmente tem várias atividades . Cada atividade apresenta uma interface de usuário que permite ao usuário executar uma tarefa específica (como visualizar um mapa ou tirar uma foto). Para levar o usuário a partir de uma atividade para outra, seu aplicativo deve usar um Intenção para definir a "intenção" de seu aplicativo para fazer algo. Quando você passar um Intenção para o sistema com um método como startActivity () , o sistema utiliza a Intenção de identificar e iniciar o

componente app apropriado. Usando intenções ainda permite que o seu aplicativo para iniciar uma atividade que está contido em um aplicativo separado. Uma Intenção pode ser explícita , a fim de iniciar um componente específico (a específica Atividade exemplo) ouimplícita , a fim de iniciar qualquer componente que pode lidar com a ação pretendida (como "tirar uma foto"). Esta classe mostra como usar um Intenção para executar algumas interações básicas com outros aplicativos, tais como iniciar outro aplicativo, recebe um resultado de que o app, e fazer o seu app capaz de responder às intenções de outros apps.

Lições Enviando o usuário para outra App Mostra como você pode criar intenções implícitas para lançar outros aplicativos que podem executar uma ação. Conseguir um resultado de uma Atividade Mostra como iniciar outra atividade e receber um resultado da atividade. Permitindo que outros Apps para começar seu Atividade Mostra como fazer atividades em sua app aberto para uso por outros aplicativos, definindo filtros intenção que declaram as intenções implícitas seu app aceita.

Enviando o usuário para outra App ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Construir uma Intenção Implícita 2. Verifique Há um App para Receber o Intent 3. Iniciar uma atividade com a intenção 4. Mostrar um App Chooser

VOCÊ TAMBÉM DEVE LER  Compartilhamento de Dados Simples

Uma das características mais importantes do Android é a capacidade de um app para enviar o usuário para outro app baseado em uma "ação" que gostaria de realizar. Por exemplo, se seu aplicativo tem o endereço de um negócio que você gostaria de mostrar em um mapa, você não tem que construir uma atividade em seu aplicativo que mostra um mapa. Em vez disso, você pode criar um pedido para ver o endereço usando um Intent . O sistema Android em seguida, inicia um aplicativo que é capaz de mostrar o endereço em um mapa. Como explicado na primeira classe, Construindo seu primeiro App , você deve usar as intenções para navegar entre as atividades em seu próprio aplicativo. Você geralmente o

fazem com uma intenção explícita , que define o nome da classe exacto da parte que você deseja iniciar. No entanto, quando você quer ter um app separado executar uma ação, como "ver um mapa", você deve usar uma intenção implícita . Esta lição mostra como criar uma intenção implícita para uma determinada ação, e como usá-lo para começar uma atividade que executa a ação em outro app.

Construir uma Intenção Implícita Intenções implícitas não declarar o nome da classe do componente para começar, mas em vez declarar uma ação a ser executada. A ação especifica a coisa que você quer fazer, tais como visão , editar , enviar , ou obteralguma coisa. Intenções muitas vezes também incluem dados associados com a ação, tais como o endereço que você deseja visualizar, ou a mensagem de e-mail que você quer enviar. Dependendo da intenção que você quer criar, os dados podem ser um Uri , um dos vários outros tipos de dados, ou a intenção pode não precisar de dados em tudo. Se os seus dados é um Uri , há uma simples Intent () construtor você pode usar definir a ação e dados. Por exemplo, aqui está como criar uma intenção de iniciar uma chamada telefônica utilizando as Uri dados para especificar o número de telefone:

Uri número = Uri . analisar ( "tel: 5551234" ); Intenção callIntent = nova Intent ( Intenção . ACTION_DIAL , número );

Quando seu aplicativo invoca esta intenção chamando startActivity () , o aplicativo de telefone inicia uma chamada para o número de telefone indicado. Aqui estão algumas outras intenções e sua ação e Uri pares de dados: 

Ver um mapa: // Ponto do mapa com base no endereço Uri localização = Uri . analisar ( "geo: 0,0 q = 1,600 + Amphitheatre Parkway +, + montanha + View, California +" ); // Ou mapa ponto baseado em latitude / longitude / / localização Uri = URI.parse ("geo: 37,422219, -122,08364 z = 14"); // Z param é o nível de zoom Intenção mapIntent = nova Intent ( Intenção . ACTION_VIEW , localização );



Ver uma página web: Uri webpage = Uri . parse ( "http://www.android.com" ); Intent webIntent = new Intent ( Intent . ACTION_VIEW , webpage );

Outros tipos de intenções implícitas exigem dados "extra" que oferecem diferentes tipos de dados, como uma string. Você pode adicionar um ou mais peças de dados extras, utilizando as várias putExtra () métodos. Por padrão, o sistema determina o tipo MIME adequado exigido por uma intenção com base nos Uri dados que estão incluídos. Se você não incluir um Uri na intenção, você deverá usar setType () para especificar o tipo de dados associados com a intenção. Definir o tipo de MIME especifica ainda que os tipos de atividades devem receber a intenção. Aqui estão mais algumas intenções que agregam dados extras para especificar a ação desejada: 

Enviar um e-mail com um anexo: Intenção emailIntent = nova Intent ( Intenção . ACTION_SEND ); // A intenção não tem um URI, então declarar a "text / plain" MIME destinatários emailIntent . putExtra ( Intent . ); emailIntent . putExtra ( Intent . de texto" ); emailIntent . putExtra ( Intent . "content: // path / to / e-mail / // Você também pode anexar vários Uris



EXTRA_SUBJECT , EXTRA_TEXT ,

"Email assunto"

"mensagem de e-mail

EXTRA_STREAM , Uri . analisar ( attachment " )); itens por meio de um ArrayList de

Criar um evento de calendário: Intent calendarIntent = new Intent ( Intent . ACTION_INSERT , Events . CONTENT_URI ); Calendar beginTime = Calendar . getInstance (). set ( 2012 , 0 , 19 , 7 , 30 ); Calendar endTime = Calendar . getInstance (). set ( 2012 , 0 , 19 , 10 , 30 ); calendarIntent . putExtra ( CalendarContract . EXTRA_EVENT_BEGIN_TIME , beginTime . getTimeInMillis ()); calendarIntent . putExtra ( CalendarContract . EXTRA_EVENT_END_TIME , endTime . getTimeInMillis ()); calendarIntent . putExtra ( Events . TITLE , "Ninja classe " ); calendarIntent . putExtra ( Eventos . EVENT_LOCATION , "dojo Segredo" );

Nota: Esta intenção para um evento de calendário é suportado apenas com nível API 14 e superior. Nota: É importante que você defina sua intenção de ser o mais específico possível. Por exemplo, se você quiser exibir uma imagem usando a ACTION_VIEW intenção, você deve especificar um tipo de MIME de imagem / * . Isso evita que aplicativos que podem "ver" outros tipos de dados (como um app mapa) de ser desencadeada pela intenção.

Verifique Há um App para Receber o Intent

Embora a plataforma Android garante que certas intenções será resolvido para um dos aplicativos embutidos (como o telefone, email, ou app de calendário), você deve sempre incluir uma etapa de verificação antes de invocar uma intenção. Cuidado: Se você chamar uma intenção e não há nenhum app disponível no dispositivo que pode lidar com a intenção, o seu aplicativo irá falhar. Para verificar há uma atividade disponível que pode responder à intenção, chamar queryIntentActivities ()para obter uma lista de atividades capazes de lidar com a sua Intenção . Se o retornou lista não estiver vazia, você pode usar com segurança a intenção. Por exemplo:

Packagemanager packagemanager = getPackageManager () ; Listaactivities = packageManager . queryIntentActivities ( intent , PackageManager . MATCH_DEFAULT_ONLY ); boolean isIntentSafe = activities . size () > 0 ;

Se isIntentSafe é verdadeiro , então pelo menos um aplicativo irá responder à intenção. Se for falsa , então não há quaisquer aplicativos para lidar com a intenção. Nota: Você deve executar essa verificação quando sua atividade se inicia pela primeira vez em caso de necessidade de desativar o recurso que usa a intenção antes que o usuário tenta usá-lo. Se você souber de um aplicativo específico que pode lidar com a intenção, você também pode fornecer um link para o usuário baixar o aplicativo (veja como para ligar para o seu produto no Google Play ).

Iniciar uma atividade com a intenção

Figura 1. Exemplo de diálogo de seleção que aparece quando mais de um app pode lidar com uma intenção.

Depois de ter criado a sua Intenção e definir a informação extra, chamarstartActivity () para enviá-lo para o sistema. Se o sistema identifica mais de uma atividade que pode lidar com a intenção, ele exibe uma caixa de diálogo para o usuário selecionar qual app para usar, como mostra a figura 1. Se houver apenas uma atividade que lida com a intenção, o sistema começa imediatamente a ele .

startActivity ( intenção );

Aqui está um exemplo completo que mostra como criar uma intenção de ver um mapa, verifique se existe um aplicativo para lidar com a intenção, então inicie-o:

// Construir o

Verifique se ele

Iniciar uma atividade se é seguro se ( isIntentSafe ) { startActivity ( mapIntent ); }

Mostrar um App Chooser

Figura 2. A janela de seleção.

Observe que quando você iniciar uma atividade, passando a sua Intençãopara startActivity () e há mais de um aplicativo que responde à intenção, o usuário pode selecionar qual app para usar por padrão (selecionando a caixa de seleção na parte inferior da caixa de diálogo; ver figura 1). Isso é bom quando se realiza uma ação para que o usuário geralmente quer usar o mesmo aplicativo de cada vez, como ao abrir uma página web (usuários provavelmente usar apenas um navegador da Web) ou tirar uma foto (usuários provavelmente preferir uma câmera).

No entanto, se a ação a ser executada poderia ser tratado por vários aplicativos eo usuário pode preferir um app diferente de cada vez, como uma ação de "share", para o qual os usuários podem ter várias aplicações, através do qual eles podem compartilhar um item, você deve mostrar explicitamente uma janela de selecção, como mostrado na figura 2. A janela de seleção de força o usuário a selecionar qual app para usar para a ação de cada vez (o usuário não pode selecionar um aplicativo padrão para a ação). Para mostrar o seletor, criar uma Intent usando createChooser () e passá-lo para startActivity () . Por exemplo:

Intenção intenção = ...

nova

Intent ( Intenção . ACTION_SEND );

. // Sempre utilize recursos de cadeia para o texto UI // Isso diz algo como "Compartilhe essa foto com" Cordas título = getResources (). getString ( R . corda . chooser_title ); // Criar a intenção de mostrar seletor de Intenção chooser = Intenção . createChooser ( intenção , título ); // Verifique a intenção será resolvido para pelo menos uma atividade se ( intenção . resolveActivity ( getPackageManager ()) ! = NULL ) { startActivity ( chooser ); }

Isto mostra uma janela com uma lista de aplicativos que respondem à intenção passado para o createChooser () método e usa o texto fornecido como o título de diálogo.

Conseguir um resultado de uma Atividade ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Iniciar a Atividade 2. Receber o resultado

VOCÊ TAMBÉM DEVE LER 

Compartilhamento de Dados Simples



Compartilhamento de Arquivos

A partir de uma outra atividade não tem de ser só de ida. Você também pode iniciar outra atividade e receber um resultado de volta. Para receber um resultado, chamastartActivityForResult () (em vez de startActivity () ).

Por exemplo, o aplicativo pode iniciar um aplicativo de câmera e receber a foto capturada como resultado. Ou, você pode começar a Pessoas app para que o usuário selecione um contato e você receberá os dados de contato, como resultado. Naturalmente, a actividade que responde deve ser concebida para retornar um resultado. Quando isso acontecer, ele envia o resultado como outro Intenção objeto. Sua atividade recebe-lo no onActivityResult () callback. Nota: Você pode usar as intenções explícitas ou implícitas quando você chamar startActivityForResult () . Ao iniciar uma de suas próprias atividades para receber um resultado, você deve usar uma intenção explícita de assegurar que você receba o resultado esperado.

Iniciar a Atividade Não há nada de especial sobre a Intenção objeto que você usa quando se inicia uma atividade para um resultado, mas você precisa para passar um argumento inteiro adicional ao startActivityForResult ()método. O argumento inteiro é um "código de pedido" que identifica o seu pedido. Quando você recebe o resultadoIntenção , o callback fornece o mesmo código de pedido para que o seu app pode identificar corretamente o resultado e determinar como lidar com isso. Por exemplo, aqui está como começar uma atividade que permite ao usuário escolher um contato:

static

final,

int PICK_CONTACT_REQUEST =

1 ;

// O pedido

Mostrar apenas os contatos do usuário w / números de telefone startActivityForResult ( pickContactIntent , PICK_CONTACT_REQUEST ); }

Receber o resultado Quando o usuário é feito com a atividade e retorna posterior, o sistema chama de sua atividadeonActivityResult () método. Este método inclui três argumentos: 

O código de pedido é passado para startActivityForResult () .



Um código de resultado especificado pela segunda atividade. Isto é, quer RESULT_OK se a operação foi bem sucedida ou RESULT_CANCELED se o usuário desistiu ou a operação falhou por algum motivo.



Uma Intenção que carrega os dados do resultado.

Por exemplo, aqui está como você pode manipular o resultado para a "pegar um contato" intenção:

Override protegido vazio onActivityResult ( int requestCode , int resultCode , Intenção de dados ) { // Verificar que solicitar estamos respondendo a se ( requestCode == PICK_CONTACT_REQUEST ) { // Verifique se o pedido foi bem-sucedida se ( resultCode == RESULT_OK ) { // O usuário escolheu um contato. // Os dados da Intenção Uri identifica que o contato foi selecionado. // Faça algo com o contato aqui (exemplo maior abaixo) } } }

Neste exemplo, o resultado Intenção retornado por do Android Contatos ou Pessoas app fornece um conteúdoUri que identifica o contato do usuário selecionado. A fim de lidar com sucesso o resultado, você deve entender o que o formato do resultado Intenção será. Fazer isso é fácil quando a atividade retornando um resultado é uma de suas próprias atividades. Apps incluídos com a plataforma Android oferecem suas próprias APIs que você pode contar para os dados de resultados específicos. Por exemplo, o aplicativo de pessoas (Contatos app em algumas versões mais antigas) sempre retorna um resultado com o conteúdo URI que identifica o contato selecionado, eo app Camera retorna umBitmap nos "dados" extra (consulte a classe sobre a captura de fotos ).

Bônus: Leia os dados de contato O código acima mostra como obter um resultado a partir da aplicação Pessoas não entrar em detalhes sobre como realmente ler os dados a partir do resultado, porque requer discussões mais avançadas sobre os provedores de conteúdo . No entanto, se você estiver curioso, aqui está um código mais que mostra como consultar os dados do resultado para obter o número de telefone do contato selecionado:

Override protegido vazio onActivityResult ( int requestCode , int resultCode , Intenção de dados ) { // Verificar que solicitá-lo é que estamos respondendo a se ( requestCode == PICK_CONTACT_REQUEST ) { // Verifique se o pedido foi bem-sucedida se ( resultCode == RESULT_OK ) { // Pega o URI que aponta para o contato selecionado Uri contactUri = dados . getData (); // Precisamos apenas a coluna de número, porque haverá apenas uma linha no resultado de Cordas [] projeção = { telefone . NÚMERO }; // Realizar a consulta sobre o contato para obter a coluna

NÚMERO // Nós não precisamos de uma seleção ou ordem de classificação (só há um resultado para o dado URI) // CUIDADO: O query () método deve ser chamado de um segmento separado para evitar o bloqueio // segmento interface do usuário do aplicativo. (Por simplicidade da amostra, este código não faz isso.) // Considere o uso de CursorLoader para realizar a

Recuperar o número de telefone a partir da coluna NÚMERO int coluna = cursor . getColumnIndex ( Telefone . NÚMERO ); Cordas número = cursor . getString ( coluna ); // Faça algo com o número de telefone ... } } }

Nota: Antes de Android 2.3 (nível API 9), realizando uma consulta sobre o Provedor de Contatos (como a mostrada acima) requer que o app declarar a READ_CONTACTS permissão (ver Segurança e permissões ). No entanto, começando com o Android 2.3, os contatos / Pessoas app concede seu app uma permissão temporária para ler a partir do provedor de Contatos quando ele retorna um resultado. A permissão temporária aplica-se apenas para o contato específico solicitado, para que você não pode consultar um contato que não seja o especificado pela intenção de Uri , a menos que você faz declarar a READ_CONTACTSpermissão.

Permitindo que outros Apps para começar seu Atividade ANTERIORPRÓXIMA

ESTA LIÇÃO ENSINA A 1. Adicionar um filtro de Intenção 2. Lidar com o Intenção em sua atividade 3. Retornar um resultado

VOCÊ TAMBÉM DEVE LER  Compartilhamento de Dados Simples  Compartilhamento de Arquivos

As duas lições anteriores focada em um lado da história: a partir de uma outra atividade app do seu app. Mas se o seu aplicativo pode executar uma ação que pode ser útil para outro aplicativo, o aplicativo deve estar preparado para responder aos pedidos de ação de outros apps. Por exemplo, se você criar um aplicativo social que pode compartilhar

mensagens ou fotos com amigos do usuário, é no seu melhor interesse para apoiar aACTION_SEND intenção para que os usuários podem iniciar uma ação de "share" de outro aplicativo e iniciar o seu aplicativo para executar a ação . Para permitir que outros aplicativos para iniciar a sua atividade, você precisa adicionar um elemento no seu arquivo de manifesto para o correspondente elemento. Quando o aplicativo é instalado em um dispositivo, o sistema identifica os filtros intenção e adiciona as informações para um catálogo interno de intenções suportados por todos os aplicativos instalados. Quando um aplicativo chama startActivity () ou startActivityForResult () , com a intenção implícita, o sistema encontra que a atividade (ou atividades) pode responder à intenção.

Adicionar um filtro de Intenção A fim de definir corretamente que objetiva sua atividade pode segurar, cada filtro intenção de adicionar deve ser o mais específico possível em termos do tipo de acção e dados da atividade aceita. O sistema pode enviar uma determinada Intenção de uma atividade se que a atividade tem um filtro de intenção de preencher os seguintes critérios da Intenção objeto: Ação A string com o nome da ação a ser executada. Geralmente um dos valores definidos pelo plataforma, comoACTION_SEND ou ACTION_VIEW . Especifique isso em seu filtro intenções com o elemento. O valor especificado neste elemento deve ser o nome da seqüência completa para a ação, em vez da constante API (veja os exemplos abaixo). Dados Uma descrição dos dados associados com a intenção. Especifique isso em seu filtro intenções com o elemento. Usando um ou mais atributos neste elemento, você pode especificar apenas o tipo MIME, apenas um prefixo URI, apenas um esquema URI, ou uma combinação destes e de outros que indicam o tipo de dados aceito. Nota: Se você não precisa declarar detalhes sobre os dados de Uri (como quando sua atividade alças para outro tipo de dados "extra", em vez de um URI), você deve especificar apenas o android: mimeTypeatribuir a declarar o tipo dos dados de sua atividade manipula, como text / plain ou image / jpeg . Categoria Fornece uma forma adicional de caracterizar a atividade manusear a intenção, normalmente relacionada com a ação do usuário ou local de onde ela começou. Existem várias categorias diferentes suportados pelo sistema, mas a

maioria são raramente utilizados. No entanto, todas as intenções implícitas são definidos com CATEGORY_DEFAULT por padrão. Especifique isso em seu filtro intenções com o elemento. Em seu filtro de intenção, você pode declarar quais os critérios que sua atividade aceita declarando cada um deles com elementos XML correspondentes aninhados no elemento. Por exemplo, aqui está uma atividade com um filtro de intenção que manipula o ACTION_SEND intenção quando o tipo de dados é texto ou uma imagem:



Cada intenção de entrada especifica apenas uma ação e um tipo de dados, mas não há problema em declarar várias instâncias do , e elementos em cada . Se quaisquer dois pares de ação e dados são mutuamente exclusivas em seus comportamentos, você deve criar filtros intenção separados para especificar quais ações são aceitáveis quando combinado com os tipos de dados que. Por exemplo, suponha que sua atividade lida com texto e imagens, tanto para o ACTION_SEND e ACTION_SENDTOintenções. Neste caso, você deve definir dois filtros intenção separados para as duas ações, porque aACTION_SENDTO intenção deve usar os dados Uri para especificar o endereço do destinatário usando o envio ousendto esquema URI. Por exemplo:

apenas para C ++ 11.

o

Modificado os seguintes cabeçalhos para uso autônomo: sys / user.h e gl2ext.h , dlext.h , fts.h ,sgidefs.h para o nível de 21 API.

o

Modificado sys / user.h renomear mxcsr_mask como mxcr_mask , e para alterar o tipo de dados para u_ar0

o 

de unsigned long para struct user_regs_struct *. Changed sysconf () Tipo de valor de retorno de int para longo .

Manipulação de fixo ndk-build do polegar para LOCAL_ARM_MODE : Em r10d, ndk-build acrescenta LOCAL_LDFLAGS + = - mthumb por padrão, a menos que uma das seguintes condições: o

Você definiu LOCAL_ARM_MODE igual a armar .

o

Você está fazendo uma compilação de depuração (com configurações como APP_OPTIM = debug eAndroidManifest.xml contendo android: debuggable = "true" ), onde o modo ARM é o padrão, a fim de manter a compatibilidade com toolchains anteriores. (Problema 74040 )



Fixo LOCAL_SRC_FILES em ndk-build usar caminhos absolutos Windows. (Problema 74333 )



Removido código específico do bash ndk-gdb. (Problema 73338 )



Removido código específico do bash make-standalonetoolchain.sh . (Problema 74145)



Documentação Revista sobre uma correção para System.loadLibrary () dependências transitivos. (Problema41790 )



Corrigido um problema que impedia pacotes de 64 bits a partir de extração no Ubuntu 14.04 e OS X 10,10 (Yosemite). (Problema 78148 )



Corrigido um problema com LOCAL_PCH para melhorar o suporte Clang. (Problema 77575 )



Esclarecido "requer executável pilha" aviso de ld.gold. (Problema 79115 ) Android NDK, 10c Revisão (Outubro de 2014) Android NDK, 10b Revisão (setembro de 2014) Android NDK, Revisão 10 (julho de 2014)

Android NDK, 9d Revisão (Março de 2014) Android NDK, 9c Revisão (Dezembro de 2013) Android NDK, 9b Revisão (Outubro de 2013) Android NDK, Revisão 9 (Julho de 2013) Android NDK, 8e Revisão (Março de 2013) Android NDK, 8d Revisão (Dezembro de 2012) Android NDK, 8c Revisão (Novembro de 2012) Android NDK, 8b Revisão (julho de 2012) Android NDK, Revisão 8 (maio de 2012) Android NDK, 7c Revisão (Abril de 2012) Android NDK, 7b Revisão (fevereiro de 2012) Android NDK, Revisão 7 (novembro de 2011) Android NDK, 6b Revisão (agosto de 2011) Android NDK, Revisão 6 (Julho de 2011) Android NDK, 5c Revisão (Junho de 2011) Android NDK, 5b Revisão (janeiro de 2011) Android NDK, Revisão 5 (dezembro de 2010) Android NDK, 4b Revisão (Junho de 2010) Android NDK, Revisão 3 (Março de 2010) Android NDK, Revisão 2 (setembro de 2009) Android NDK, Revisão 1 (Junho de 2009)

Requisitos de Sistema e Software As seções abaixo descrevem o sistema e requisitos de software para usar o Android NDK, bem como considerações de compatibilidade de plataforma que afetam appplications usando bibliotecas produzidos com o NDK.

O SDK Android 

A instalação do SDK Android completo (incluindo todas as dependências) é necessária.



É necessária Android 1.5 SDK ou versão posterior.

Os sistemas operacionais suportados 

Windows XP (32 bits) ou Vista (32 ou 64 bits)



Mac OS X 10.4.8 ou posterior (x86 apenas)



Linux (32 ou 64 bits; Ubuntu 8.04, ou outras distribuições Linux usando glibc 2.7 ou posterior)

Ferramentas de desenvolvimento obrigatórios 

Para todas as plataformas de desenvolvimento, o GNU Make 3.81 ou posterior é necessário. As versões anteriores do GNU make pode funcionar, mas não foram testadas.



Também é necessária uma versão recente do awk (ou GNU Awk ou nawk).



Para o Windows, Cygwin 1.7 ou superior é necessário. O NDK vai não trabalhar com Cygwin instalações 1.5.

Compatibilidade com a plataforma Android 



As bibliotecas nativas criadas pelo Android NDK só pode ser usado em dispositivos que executam versões da plataforma Android mínimos especificados. A versão mínima exigida plataforma depende da arquitetura de CPU dos dispositivos que são alvo. A tabela seguinte detalha quais versões da plataforma Android são compatíveis com o código nativo desenvolvido para arquiteturas de CPU específicos.

Native Código CPU arquitetura usada

Plataforma Android compatíve

ARM, ARM-NEON

Android 1.5 (Nível 3 API) e sup

x86

Android 2.3 (Nível API 9) e sup

MIPS

Android 2.3 (Nível API 9) e sup

Estas exigências significa que você pode usar bibliotecas nativas produzidas com o NDK em aplicações que são destacáveis para dispositivos rodando Android 1.5 ou posterior ARM baseado no. Se você estiver implantando bibliotecas nativas para x86 e dispositivos baseados em MIPS, a sua aplicação deve ter como alvo Android 2.3 ou posterior.



Para garantir a compatibilidade, um aplicativo usando uma biblioteca nativa produzido com o NDK deve declarar um elemento no seu arquivo de manifesto, com um android: minSdkVersion valor de "3" ou maior atributo. Por exemplo:



Se você usar esta NDK para criar uma biblioteca nativa que utiliza as APIs OpenGL ES, o aplicativo que contém a biblioteca pode ser implantado apenas para dispositivos que executam as versões de plataforma mínimos descritos na tabela abaixo. Para garantir a compatibilidade, certifique-se de que seu aplicativo declara o bom android: minSdkVersion valor do atributo, como mostra a tabela a seguir.



OpenGL ES versão utilizada

Plataforma Android compatível (s)

Uses-sdk obriga

OpenGL ES 1.1

Android 1.6 (Nível API 4) e superior

android: min

OpenGL ES 2.0

Android 2.0 (API Nível 5) e superior

android: min



Para mais informações sobre o nível da API e sua relação com as versões da plataforma Android, consulte Níveis de API do Android .



Além disso, um aplicativo usando as APIs OpenGL ES deve declarar um elemento no seu manifesto, com um android: glEsVersion atributo que especifica a versão mínima OpenGL ES exigido pelo aplicativo. Isso garante que Google Play irá mostrar a sua aplicação apenas para usuários cujos dispositivos são capazes de suportar a sua aplicação. Por exemplo:

...

Para obter mais informações, consulte o documentação.



Se você usar esta NDK para criar uma biblioteca nativa que usa a API para acessar Android Bitmap buffers de pixel ou utiliza atividades nativas, o aplicativo que contém a biblioteca pode ser implantado apenas para dispositivos que executam o Android 2.2 (nível API 8) ou superior. Para garantir a compatibilidade, certifique-se de que seu aplicativo declara valor de atributo no seu manifesto.

Instalando o NDK Instalando o NDK no computador de desenvolvimento é simples e envolve a extração do NDK de seu pacote de download. Antes de começar certifique-se de que você tenha baixado o mais recente Android SDK e atualizado suas aplicações e ambiente, conforme necessário. O NDK é compatível com versões de plataforma mais velhas, mas não versões mais antigas das ferramentas do SDK. Além disso, ter um momento para rever os requisitos de software e do sistema para o NDK, se você não tiver já. Para instalar o NDK, primeiro baixe o pacote apropriado da tabela no topo desta página. Então, siga o procedimento para a sua plataforma de desenvolvimento: 

No Linux e Mac OS X (Darwin): 1. Faça o download do pacote apropriado desta página. 2. Abra uma janela de terminal. 3. Vá para o diretório no qual você baixou o pacote. 4. Execute chmod a + x no pacote baixado. 5. Execute o pacote. Por exemplo: ndk $ chmod a + x android - ndk - R10C - darwin x86_64 . bin ndk $ ./ android - ndk - R10C - darwin - x86_64 . bin

A pasta que contém o NDK extrai-se. Note que você também pode usar um programa como o 7z para extrair o pacote. 

No Windows: 1. Faça o download do pacote apropriado desta página. 2. Navegue até a pasta onde você baixou o pacote. 3. Dê um duplo clique no arquivo baixado. A pasta que contém o NDK extrai-se.

Quando não comprimido, os arquivos NDK estão contidos em um diretório chamado android-ndk- . Você pode renomear o diretório NDK se necessário e você pode movê-lo para qualquer lugar no seu computador. Esta documentação se refere ao diretório NDK como . Agora você está pronto para começar a trabalhar com o NDK.

Primeiros passos com o NDK Uma vez que você tenha instalado o NDK com sucesso, dedique alguns minutos para ler a documentação incluída no NDK. Você pode encontrar a documentação no / docs / diretório. Em particular, por favor leia o documento overview.html completamente, para que você entenda a intenção do NDK e como usá-lo. Se você usou uma versão anterior do NDK, tome um momento para rever a lista de mudanças NDK no documento CHANGES.HTML. Aqui está o esboço geral de como você trabalhar com as ferramentas NDK: 1. Coloque suas fontes nativas sob / jni / ... 2. Criar /jni/Android.mk para descrever as suas fontes nativas da NDK sistema de construção 3. Opcional: Criar /jni/Application.mk . 4. Construa o seu código nativo, executando o script 'ndk-build "do diretório do seu projeto. Ele está localizado no diretório NDK de nível superior: 5. cd 6. / NDK-build

As ferramentas de compilação copiar os despojados, bibliotecas compartilhadas necessárias para a sua aplicação para o local adequado no diretório do projeto do aplicativo. 7. Finalmente, compilar o aplicativo usando as ferramentas do SDK da maneira usual. As ferramentas de compilação SDK irá embalar as bibliotecas compartilhadas no destacável do aplicativo .apk arquivo. Para obter informações completas sobre todas as etapas listadas acima, por favor, consulte a documentação incluída com o pacote NDK.

Usando o NDK O quadro Android fornece duas maneiras de usar o código nativo: 

Faça seu aplicativo usando o framework Android e usar JNI para acessar as APIs fornecidas pelo Android NDK. Esta técnica permite que você tire vantagem da conveniência do quadro Android, mas ainda permite que você escreva código nativo quando necessário. Se você usar essa

abordagem, sua aplicação deve ter como alvo níveis de plataformas específicas, mínimos Android, consulte compatibilidade com a plataforma Android para mais informações. 

Faça uma atividade nativa, o que permite implementar os retornos de chamada do ciclo de vida em código nativo. O Android SDK fornece a NativeActivity classe, que é uma classe de conveniência que notifica o código nativo de qualquer retornos de chamada de ciclo de vida de atividade ( onCreate () , onPause () , onResume () , etc). Você pode implementar as chamadas de retorno em seu código nativo para lidar com esses eventos quando eles ocorrem. As aplicações que utilizam atividades nativas deve ser executado no Android 2.3 (Nível API 9) ou mais tarde. Você não pode acessar recursos como serviços e provedores de conteúdo nativamente, então se você quiser usá-los ou qualquer outra API quadro, você ainda pode escrever código JNI para fazê-lo.

Conteúdo do NDK O NDK contém as aplicações de APIs, documentação e amostras que ajudam você a escrever o seu código nativo.Especificamente: 

Um conjunto de ferramentas e construir arquivos usados para gerar bibliotecas de código nativo a partir de fontes em C e C ++



A maneira de incorporar as bibliotecas nativas correspondentes em um arquivo de pacote de aplicativo ( .apk ) que pode ser implantado em dispositivos Android



Um conjunto de cabeçalhos do sistema nativo e bibliotecas que serão suportados em todas as versões futuras da plataforma Android, a partir Android 1.5. As aplicações que utilizam atividades nativas deve ser executado no Android 2.3 ou posterior.



Documentação, exemplos e tutoriais A versão mais recente do NDK suporta os seguintes conjuntos de instruções:



ARMv5TE, incluindo instruções Thumb-1 (ver docs / CPU-ARCHABIS.html para mais informações)



ARMv7-A, incluindo instruções Thumb-2 e VFPv3-D16, com suporte opcional para instruções NEON / VFPv3-D32 (verdocs / CPU-ARMNEON.html para mais informações)



instruções x86 (ver docs / CPU-X86.html para mais informações)



Instruções MIPS (ver docs / CPU-MIPS.html para mais informações) Código de máquina ARMv5TE será executado em todos os dispositivos Android baseados em ARM. ARMv7-A será executado apenas em dispositivos como a Verizon Droid ou o Google Nexus One que têm uma

CPU compatível. A principal diferença entre os dois conjuntos de instruções é que ARMv7-A suporta FPU hardware, Thumb-2, e as instruções de néon. Você pode direcionar um ou ambos os conjuntos de instruções ARMv5TE é o padrão, mas a mudança para ARMv7-A é tão fácil quanto adicionar uma única linha para o aplicativo do Application.mk arquivo, sem a necessidade de mudar alguma coisa no arquivo. Você também pode construir para as arquiteturas ao mesmo tempo e ter tudo armazenado na final .apk . Informação completa é fornecida no CPU-ARCH-ABIS.HTML no pacote NDK. O NDK fornece cabeçalhos estáveis para libc (a biblioteca C), libm (a biblioteca de matemática), OpenGL ES (biblioteca de gráficos 3D), a interface JNI, e outras bibliotecas, conforme listado na ferramentas de desenvolvimento seção.

As ferramentas de desenvolvimento O NDK inclui um conjunto de cross-toolchains (compiladores, ligantes, etc.) que podem gerar binários ARM nativas em Linux, OS X e Windows (com o Cygwin) plataformas. Ele fornece um conjunto de cabeçalhos de sistema para APIs nativas estáveis que são garantidos para ser suportada em todas as versões posteriores da plataforma: 

libc (biblioteca C) cabeçalhos



libm (biblioteca de matemática) cabeçalhos



Cabeçalhos de interface JNI



libz (compressão Zlib) cabeçalhos



liblog (logging Android) cabeçalho



OpenGL ES 1.1 e OpenGL ES 2.0 (bibliotecas gráficas 3D) cabeçalhos



libjnigraphics (acesso tampão Pixel) cabeçalho (para Android 2.2 e acima).



Um conjunto mínimo de cabeçalhos de apoio C ++



Bibliotecas de áudio nativo OpenSL ES



Android APIS aplicativo nativo O NDK também fornece um sistema de construção que permite trabalhar de forma eficiente com as suas fontes, sem ter que lidar com o conjunto de ferramentas / platform / CPU / detalhes ABI. Você cria arquivos de construção muito curtos para descrever quais as fontes para compilar e qual aplicativo Android irá utilizá-los - o sistema de compilação reúne as fontes e coloca as bibliotecas compartilhadas diretamente em seu projeto de aplicativo. Importante: Com exceção das bibliotecas listadas acima, as bibliotecas do sistema nativo na plataforma Android é nãoestável e pode sofrer alterações

em versões futuras da plataforma. Seus aplicativos devem apenas fazer uso das bibliotecas do sistema nativas estáveis fornecidas neste NDK.

Documentação O pacote NDK inclui um conjunto de documentação que descreve as capacidades do NDK e como usá-lo para criar bibliotecas compartilhadas para seus aplicativos Android. Nesta versão, a documentação é fornecida somente no pacote NDK para download. Você pode encontrar a documentação no / docs / diretório. Incluem-se esses arquivos (lista parcial): 

INSTALL.html - descreve como instalar o NDK e configurá-lo para o seu sistema host



Overview.html - fornece uma visão geral dos recursos e uso NDK



ANDROID-MK.HTML - descreve o uso do arquivo Android.mk, que define as fontes nativas que deseja compilar



APLICAÇÃO-MK.HTML - descreve o uso do arquivo Application.mk, que descreve as fontes nativas exigidas pelo seu aplicativo Android



CPLUSPLUS-support.html - descreve o suporte a C ++ fornecido no Android NDK



CPU-ARCH-ABIS.HTML - uma descrição de arquiteturas de CPU suportados e sobre como orientá-las.



CPU-features.html - uma descrição do cpufeatures biblioteca estática que permite que o código do aplicativo detectar família CPU do dispositivo de destino e os recursos opcionais em tempo de execução.



CHANGES.HTML - uma lista completa de mudanças no NDK em todas as versões.



DEVELOPMENT.HTML - descreve como modificar o NDK e gerar pacotes de libertação para ele



HOWTO.html - informações sobre tarefas comuns associados com o desenvolvimento NDK



IMPORT-MODULE.HTML - descreve como partilhar e módulos de reutilização



LICENSES.HTML - informações sobre as várias licenças de código aberto que governam o NDK Android



NATIVO-ACTIVITY.HTML - descreve como implementar atividades nativas



NDK-BUILD.HTML - descreve o uso do script ndk-build



NDK-GDB.HTML - descreve como usar o depurador de código nativo



PREBUILTS.HTML - informações sobre como bibliotecas pré-construídos e compartilhados estáticos funcionam



INDEPENDENTE-TOOLCHAIN.HTML - descreve como usar Android NDK toolchain como um compilador standalone (ainda em beta).



SYSTEM-ISSUES.HTML - problemas conhecidos nas imagens do sistema Android que você deve estar ciente de, se você estiver desenvolvendo usando o NDK.



ESTÁVEL-APIS.HTML - uma lista completa das APIs estáveis expostos por cabeçalhos no NDK. Além disso, o pacote inclui informações detalhadas sobre o "biônico" biblioteca C equipado com a plataforma Android que você deve estar ciente de, se você estiver desenvolvendo usando o NDK. Você pode encontrar a documentação no / docs / system / libc / diretório:



Overview.html - fornece uma visão geral do "biônico" biblioteca C e os recursos que ele oferece.

Aplicativos de exemplo O NDK inclui aplicativos de amostra que ilustram como usar o código nativo em seus aplicativos Android: 

Olá-jni - uma aplicação simples que carrega uma seqüência de caracteres a partir de um método nativo implementado em uma biblioteca compartilhada e, em seguida, exibe na interface do aplicativo.



e dois libs - uma aplicação simples que carrega uma biblioteca compartilhada de forma dinâmica e chama um método nativo fornecido pela biblioteca. Neste caso, o método é implementado de uma biblioteca estática importado pela biblioteca partilhada.



san-angeles - uma aplicação simples que renderiza gráficos 3D através

das APIs nativas OpenGL ES, enquanto a gestão do ciclo de vida atividade com um GLSurfaceView objeto. 

Olá-gl2 - uma aplicação simples que torna um triângulo usando

OpenGL ES 2.0 vértice e fragmento shaders. 

Olá-neon - um aplicativo simples que mostra como usar o cpufeatures biblioteca para buscar recursos de CPU em tempo de execução, em seguida, usar intrínsecos NEON se suportado pela CPU. Especificamente, a aplicação implementa duas versões de um minúsculo ponto de referência para um circuito de filtro FIR, uma versão C e uma versão otimizada para NEON para dispositivos que suportam.



bitmap-plasma - uma aplicação simples que demonstra como acessar os buffers de pixel do Android Bitmap objetos de código nativo, e usa isso para gerar um old-school efeito "plasma".



nativo-atividade - uma aplicação simples que demonstra como usar a biblioteca estática nativo-app-cola para criar uma atividade nativa



nativo-plasma - uma versão de bitmap-plasma implementada com uma

atividade nativa. Para cada amostra, o NDK inclui o código fonte C correspondente e os arquivos Android.mk e Application.mk necessárias.Lá estão localizados

sob / samples / / e seu código fonte pode ser encontrado em / samples / / jni / . Você pode construir as bibliotecas compartilhadas para os aplicativos de amostra, entrando / samples / / , em seguida, chamar o NDK-build comando. As bibliotecas compartilhadas gerados serão localizados sob / samples / / libs / armeabi / para (código ARMv5TE máquina) e / ou / samples / / libs / armeabi-v7a / for (ARMv7 código de máquina). Em seguida, construir os aplicativos de amostra do Android que use as bibliotecas compartilhadas: 

Se você estiver desenvolvendo em Eclipse com ADT, use o assistente Novo projeto para criar um novo projeto Android para cada amostra, usando o "Importar de código-fonte existentes" opção e importar a fonte de / samples / / . Em seguida, criar um AVD, se necessário, e construir / executar o aplicativo no emulador.



Se você está desenvolvendo com Ant, utilize o android ferramenta para criar o arquivo de construção para cada um dos projetos de amostra em / samples / / . Em seguida, criar um AVD, se necessário, construir o seu projeto da forma habitual, e executá-lo no emulador. Para obter mais informações sobre o desenvolvimento com as ferramentas do SDK do Android e o que você precisa fazer para criar, construir e executar seus aplicativos, consulte a Visão geral seção para o desenvolvimento em Android.

Explorando o Sample Olá-jni A amostra Olá-jni é uma simples demonstração de como usar JNI de um aplicativo Android. A atividade HelloJni recebe uma string de uma função C simples e exibe em um TextView. Os principais componentes da amostra incluem: 

A estrutura básica de um conhecido aplicativo Android (um AndroidManifest.xml arquivo, um src / e res diretórios, e uma atividade principal)



A jni / diretório que inclui o arquivo de origem implementado para o código nativo, bem como o arquivo Android.mk



A testes / diretório que contém o código de teste de unidade.

1. Crie um novo projeto no Eclipse a partir da fonte de amostra existente ou usar o android ferramenta para atualizar o projeto para que ele gera um arquivo build.xml que você pode usar para criar o exemplo. o

Em Eclipse: a. Clique em Arquivo> Novo Projeto Android ...

b. Selecione o projeto de criar a partir de fonte existente botão de rádio. c. Escolha qualquer nível API acima Android 1.5. d. Na localidade de campo, clique em Browse ... e selecione o / samples / Olá-jni diretório. e. Clique em Concluir . o

Na linha de comando: a. Mude para o / samples / Olá-jni diretório. b. Execute o seguinte comando para gerar um arquivo build.xml: android -p projeto de atualização. -s

2. Compilar o código nativo usando o NDK-build comando. 3. cd / samples / Hello-JNI 4. / NDK-build

5. Construir e instalar o aplicativo como se fosse uma aplicação Android normal. Se você estiver usando Eclipse, execute o aplicativo para construir e instalá-lo em um dispositivo. Se você estiver usando Ant, execute os seguintes comandos a partir do diretório do projeto: 6. debug formiga 7. adb instalar bin / HelloJni-debug.apk

Quando você executar o aplicativo no dispositivo, a seqüência Olá JNI deve aparecer em seu dispositivo. Você pode explorar o resto das amostras que estão localizados no / samples diretório para mais exemplos sobre como usar o JNI.

Explorando o aplicativo de exemplo nativo-atividade A amostra nativo-atividade fornecida com o Android NDK demonstra como usar a biblioteca estática android_native_app_glue. Esta biblioteca estático torna a criação de uma atividade nativa mais fácil, fornecendo-lhe com uma implementação que lida com as suas chamadas de retorno em outro segmento, assim você não tem que se preocupar com eles bloqueando o seu principal segmento. As principais partes da amostra são descritos abaixo: 

A estrutura básica de um conhecido aplicativo Android (um AndroidManifest.xml arquivo, um src / e res diretórios).O AndroidManifest.xml declara que a aplicação é nativa e especifica o arquivo .so da atividade nativa. VejaNativeActivity para a fonte ou ver o /platforms/samples/nativeactivity/AndroidManifest.xmlarquivo.



A jni / diretório contém a atividade nativa, main.c, que usa o android_native_app_glue.h interface para implementar a atividade. O Android.mk que descreve o módulo nativo para o sistema de construção também existe aqui. Para construir este aplicativo:

1. Crie um novo projeto no Eclipse a partir da fonte de amostra existente ou usar o android ferramenta para atualizar o projeto para que ele gera um arquivo build.xml que você pode usar para criar o exemplo. o

Em Eclipse: a. Clique em Arquivo> Novo Projeto Android ... b. Selecione o projeto de criar a partir de fonte existente botão de rádio. c. Escolha qualquer nível API acima Android 2.3. d. Na localidade de campo, clique em Browse ... e selecione o / samples / native-atividadediretório. e. Clique em Concluir .

o

Na linha de comando: a. Mude para o / samples / nativeatividade diretório. b. Execute o seguinte comando para gerar um arquivo build.xml: c. android -p projeto de atualização. -s

2. Compilar o código nativo usando o NDK-build comando. 3. cd / plataformas / samples / android-9 / samples / native-atividade 4. / NDK-build

5. Construir e instalar o aplicativo como se fosse uma aplicação Android normal. Se você estiver usando Eclipse, execute o aplicativo para construir e instalá-lo em um dispositivo. Se você estiver usando Ant, execute os seguintes comandos no diretório do projeto, em seguida, executar o aplicativo no dispositivo: 6. debug formiga

adb instalar bin / NativeActivity-debug.apk