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 <densidade> /

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 <target-id> --name MyFirstApp \

5. --path <path-to-workspace> / MyFirstApp --activity MyActivity \

6. com.example.myfirstapp --package

Substitua <target-id> com um ID da lista de

alvos (da etapa anterior) e substitua <path-to-

workspace> 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


1. Executado em um dispositivo real

2. Execute no Emulator


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 na barra de

ferramentas.

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 na barra de ferramentas.

o 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 na barra de

ferramentas.

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


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


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 <TextView> elemento.

4. Alterar o <RelativeLayout> elemento a <LinearLayout> .

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 xmlns:android = "http://schemas.android.com/apk/res/android" xmlns:tools = "http://schemas.android.com/tools" android:layout_width = "match_parent" android:layout_height = "match_parent" android:orientation = "horizontal" > </LinearLayout>

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 <LinearLayout> elemento, definir

um <EditText> 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 <EditText> elemento deve ter a seguinte redacção:

res / layout / activity_my.xml

<EditText android:id = "@+id/edit_message" android:layout_width = "wrap_content" android:layout_height = "wrap_content" android:hint = "@string/edit_message" />

Aqui estão o <EditText> 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

<? xml version = "1.0" encoding = "utf-8" ?> <resources> <string nome = "app_name" > My First App </ string> <string nome = "edit_message" > Digite um message </string> <string name = "button_send" > Send </string> <string name = "action_settings" > Settings </string> <string name = "title_activity_main" > MainActivity </string> </resources>

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 <LinearLayout> elemento, definir um <Button> elemento

imediatamente a seguir ao <EditText>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 <LinearLayout> deve ser semelhante a este:


<LinearLayout xmlns:android = "http://schemas.android.com/apk/res/android" xmlns:tools = "http://schemas.android.com/tools" android:layout_width = "match_parent" android:layout_height = "match_parent" android:orientation = "horizontal" > <EditText android:id = "@+id/edit_message" android:layout_width = "wrap_content" android:layout_height = "wrap_content" android:hint = "@string/edit_message" /> <Button android:layout_width = "wrap_content" android:layout_height = "wrap_content" android:text = "@string/button_send" /> </LinearLayout>

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 <EditText> elemento layout_weight atribuir um valor de 1 .

2. Além disso, atribuir <EditText> elemento layout_width atribuir um

valor de 0DP .


<EditText android: layout_weight = "1" android: layout_width = "0DP" ... />

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:


<? xml version = "1.0" encoding = "utf-8" ?> <LinearLayout xmlns:android = "http://schemas.android.com/apk/res/android" xmlns:tools = "http://schemas.android.com/tools" android:layout_width = "match_parent" android:layout_height = "match_parent" android:orientation = "horizontal" > <EditText android:id = "@+id/edit_message" android:layout_weight = "1" android:layout_width = "0dp" android:layout_height = "wrap_content" android:hint = "@string/edit_message" /> <Button android:layout_width = "wrap_content"

android:layout_height = "wrap_content" android:text = "@string/button_send" /> </LinearLayout>

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


1. Responder ao botão Enviar

2. Construir uma Intent

3. Criar a segunda atividade

4. Receba o Intent

5. Mostrar a Mensagem


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 <Button> elemento, adicionar o android: onClickatributo.


<Button android:layout_width = "wrap_content" android:layout_height = "wrap_content" android:text = "@string/button_send" android:onClick = "sendMessage" />

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:


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

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:


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.


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.


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:


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:


/ ** 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:

<Resources> ... <string nome = "title_activity_display_message" > Minha Mensagem </ string> </ resources>

4. Em seu arquivo de manifesto, AndroidManifest.xml , dentro

do aplicativo elemento, adicione o <activity>elemento para o

seu DisplayMessageActivity classe, como segue:

<application ... > ... <activity android:name = "com.mycompany.myfirstapp.DisplayMessageActivity" android:label = "@string/title_activity_display_message" android:parentActivityName = "com.mycompany.myfirstapp.MyActivity" > <meta-data android:name = "android.support.PARENT_ACTIVITY" android:value = "com.mycompany.myfirstapp.MyActivity" /> </activity> </application>

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 <meta-dados>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.


à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.


à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 a exibição de texto TextView textView = nova TextView ( este ); textView . SetTextSize ( 40 ); textView . 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


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 drop-

down).

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


1. Suporte Android 3.0 e acima só

2. Suporte Android 2.1 e acima


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:

<Manifest ... > <usa-sdk android: minSdkVersion = "11" ... /> ... </ manifest>

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 <application> elemento ou

individuais <Actividade> elementos para usar um dos Theme.AppCompat temas. Por

exemplo:

<Atividade 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:

<Manifest ... > <usa-sdk android: minSdkVersion = "7" android: targetSdkVersion = "18" />

... </ manifest>

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


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


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 <item> elemento para cada item que deseja incluir na barra de ação. Por

exemplo:

res / menu / main_activity_actions.xml

<Menu xmlns: android = "http://schemas.android.com/apk/res/android" > <! - Search, deve aparecer como botão de ação

Configurações, deve estar sempre no estouro

Ícones da barra de ação download

Para melhor corresponder às Androidiconografia orientações, você deve usar símbolos

fornecidos na Barra de ação Icon Pack .

Esta declara que a ação de busca deve aparecer como um botão de ação quando a sala

está disponível na barra de ação, mas a ação Configurações deve sempre aparecer no

estouro. (Por padrão, todas as ações aparecem no estouro, mas é uma boa prática para

declarar explicitamente suas intenções de design para cada ação.)

O ícone atributo requer um ID de recurso para uma imagem. O nome que segue @

drawable / deve ser o nome de uma imagem bitmap que você salvou no seu projeto

de res / drawable / diretório. Por exemplo, "@ estirável /

ic_action_search" refere-se a ic_action_search.png . Da mesma forma,

o título atributo usa um recurso de cadeia que é definido por um arquivo XML em seu

projeto deres / valores / diretório, como discutido em Construindo uma interface de

usuário simples .

Nota: Ao criar ícones e outras imagens bitmap para o seu app, é importante que você

forneça várias versões que são otimizados para cada uma densidade de tela

diferente. Isso é discutido mais na lição sobre Apoiar diferentes telas .

Se seu aplicativo está usando a biblioteca de suporte para compatibilidade em versões

tão baixas como Android 2.1, o showAsAction atributo não está disponível

no Android: namespace. Em vez disso, esse atributo é fornecido pela Biblioteca de

suporte e você deve definir o seu próprio namespace XML e usar esse espaço de nomes

como o prefixo de atributo. (A namespace XML personalizado deve ser baseada em seu

nome do aplicativo, mas pode ser qualquer nome que você quer e só é acessível no

âmbito do arquivo no qual você declará-lo.) Por exemplo:

res / menu / main_activity_actions.xml

<menu xmlns:android = "http://schemas.android.com/apk/res/android" xmlns:yourapp = "http://schemas.android.com/apk/res-auto" >  <item android:id = "@+id/action_search" android:icon = "@drawable/ic_action_search" android:title = "@string/action_search" yourapp:showAsAction = "ifRoom" /> ... </menu>

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 <item> 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:

<Application ... > ... <! - A principal atividade / home (não tem atividade pai) -> <atividade android: name = "com.example.myfirstapp.MainActivity" ... > ... </ activity> <! - Uma criança da atividade principal Atividade do meta-dados pai para apoiar 4.0 e inferior

Em seguida, habilite o ícone do aplicativo como o Up botão

chamando setDisplayHomeAsUpEnabled () :

@Override public void onCreate ( Bundle savedInstanceState ) { super . onCreate ( savedInstanceState ); setContentView ( R . layout . activity_displaymessage ); getSupportActionBar (). setDisplayHomeAsUpEnabled ( true ); // Se o seu minSdkVersion é de 11 ou superior, utilizar: //. getActionBar () setDisplayHomeAsUpEnabled (true); }

Porque o sistema agora sabe MainActivity é a atividade principal

para DisplayMessageActivity , quando o usuário pressiona o Up botão, o sistema

navega para a atividade pai conforme o caso, você não precisa lidar com o Up evento do

botão.

Para mais informações sobre a navegação, consulte fornecendo até Navigation .

Denominando a Barra de Ação

ANTERIORPRÓXIMA


1. Use um tema Android

2. Personalize o fundo

3. Personalize a cor do texto

4. Personalize o Indicador Tab


Estilos e temas

Android Ação Generator Estilo Bar

A barra de ação fornece a seus usuários uma maneira familiar e previsível para executar

ações e navegar no seu app, mas isso não significa que ele precisa ser exatamente igual

como faz em outros aplicativos. Se você quer denominar a barra de ação para melhor

atender a sua marca do produto, você pode facilmente fazê-lo utilizando do Android estilo

e tema recursos.

Android inclui alguns temas de atividades integradas que incluem estilos "escuros" ou

"light" da barra de ação. Você também pode estender estes temas para personalizar ainda

mais o olhar para a sua barra de ação.

Nota: Se você estiver usando a biblioteca de suporte APIs para a barra de ação, então

você deve usar (ou substituir) oTheme.AppCompat família de estilos (em vez

do Theme.Holofamília, disponível no nível de API 11 e superior). Ao fazê-lo, cada

propriedade de estilo que você declarar deve ser declarado duas vezes: uma usando

propriedades de estilo da plataforma (o android: propriedades) e uma vez usando as

propriedades de estilo incluído na Biblioteca Support (o appcompat.R.attr propriedades

de contexto para essas propriedades é realmente seu app ). Veja os exemplos abaixo para

mais detalhes.

Use um tema Android

Android inclui dois temas atividade básica que ditam a cor da barra de ação:

http://www.actionbarstylegenerator.com/

Theme.Holo para um tema "dark".

Theme.Holo.Light para um tema "light".

Você pode aplicar esses temas com toda a sua app ou para atividades individuais,

declarando-los em seu arquivo de manifesto com o android: tema atributo para

o <application> elemento ou indivíduo<activity> elementos.

Por exemplo:

<Aplicação 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

<? xml version = "1.0" encoding = "UTF-8" ?> <resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "android: estilo / Theme.Holo.Light.DarkActionBar " > < item name = "android: actionBarStyle" > @ estilo / MyActionBar </ produto > </ style> <! - ActionBar estilos -> <style nome = "" MyActionBar pai = " android: estilo / Widget.Holo.Light.ActionBar.Solid.Inverse " > < item name = "android: background" > @ drawable / actionbar_background </ produto > </ style> </ resources>

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

<Aplicação android: theme = "@ estilo / CustomActionBarTheme" ... />

Para Android 2.1 e superior

Ao usar a biblioteca de suporte, o mesmo tema, como acima devem vez parecido com

este:


<? xml version = "1.0" encoding = "UTF-8" ?> <resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "@ estilo / temáticos. AppCompat .Light.DarkActionBar " > < item name = "android: actionBarStyle" > @ estilo / MyActionBar </ produto > <! - compatibilidade biblioteca Apoio -> < item de nome = "actionBarStyle" > @ estilo / MyActionBar </ item de > </ style>

<! - ActionBar estilos -> <style nome = "MyActionBar" pai = ". @ estilo / Widget AppCompat .Light.ActionBar.Solid.Inverse " > < item name = "android: background" > @ drawable / actionbar_background </ produto > <! - compatibilidade biblioteca Apoio -> < item de nome = "background" > @ drawable / actionbar_background </ produto > </ style> </ resources>

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

<Aplicação android: theme = "@ estilo / CustomActionBarTheme" ... />

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.


Ao apoiar Android 3.0 e superior apenas, o seu arquivo XML estilo pode ter esta

aparência:


<? xml version = "1.0" encoding = "UTF-8" ?> <resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "@ estilo / temáticos. Holo " > < item name = "android: actionBarStyle" > @ estilo / MyActionBar </ produto > < item name = "android: actionBarTabTextStyle" > @ estilo / MyActionBarTabText </ produto > < item name = "android: actionMenuTextColor" > @ cor /

actionbar_text </ produto > </ style> <! - ActionBar estilos -> <style nome = "MyActionBar" pai = "@ estilo / Widget.Holo.ActionBar" > < item name = "android: titleTextStyle" > @ estilo / MyActionBarTitleText </ produto > </ style> <! - ActionBar texto do título -> <style nome = "MyActionBarTitleText" pai = "/ TextAppearance.Holo.Widget.ActionBar.Title @ estilo" > < item name = "android: textColor" > @ cor / actionbar_text </ produto > </ style> <! - estilos de texto guias ActionBar -> <style nome = "MyActionBarTabText" pai = "@ estilo / Widget.Holo.ActionBar.TabText" > < item name = "android: textColor" > @ cor / actionbar_text </ produto > </ style> </ resources>


Ao usar a biblioteca de suporte, o seu arquivo XML estilo pode ter esta aparência:


<? xml version = "1.0" encoding = "UTF-8" ?> <resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "@ estilo / temáticos. AppCompat " > < item name = "android: actionBarStyle" > @ estilo / MyActionBar </ produto > < item name = "android: actionBarTabTextStyle" > @ estilo / MyActionBarTabText </ produto > < item name = "android: actionMenuTextColor" > @ cor / actionbar_text </ produto > <! - compatibilidade biblioteca Apoio -> < item name = "actionBarStyle" > @ estilo / MyActionBar </ produto > < item name = "actionBarTabTextStyle" > @ estilo / MyActionBarTabText </ produto > < nome do item = "actionMenuTextColor" > @ cor / actionbar_text </ produto > </ style> <! - ActionBar estilos -> <style nome = "MyActionBar" pai = ". @ estilo / Widget AppCompat .ActionBar " > < item de nome = "android: titleTextStyle" > @ estilo / MyActionBarTitleText </ produto >

<! - compatibilidade biblioteca Apoio -> < item name = "titleTextStyle" > @ estilo / MyActionBarTitleText </ produto > </ style> <! - texto do título ActionBar nome = "android: textColor" > @ cor / actionbar_text </ produto > <! - A propriedade textColor é compatível com a biblioteca de suporte -> </ style> <! - texto guias ActionBar -> <style nome = "MyActionBarTabText" pai = ". @ estilo / Widget AppCompat .ActionBar.TabText " > < item name = "android: textColor" > @ cor / actionbar_text </ produto > <! - A propriedade textColor é compatível com o Suporte Biblioteca -> </ style> </ recursos>

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

<? xml ESTADOS QUANDO botão não for pressionado -> <! - Estados não focalizados

Membros centradas (como quando focada com um d-pad ou o mouse) ESTADOS quando o botão é pressionado -> <! - Estados não focalizados Membros centradas (como quando focada com um d-pad ou o mouse)


Ao apoiar Android 3.0 e superior apenas, o seu arquivo XML estilo pode ter esta

aparência:


<? xml version = "1.0" encoding = "UTF-8" ?> <resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "@ estilo / temáticos. Holo " > < item name = "android: actionBarTabStyle" > @ estilo / MyActionBarTabs </ produto > </ style> <! - guias ActionBar estilos -> <style nome = "MyActionBarTabs" pai = "@ estilo / Widget. Holo.ActionBar.TabView " > <! - indicador guia -> < item name = "android: background" > @ drawable / actionbar_tab_indicator </ produto >

</ style> </ resources>


Ao usar a biblioteca de suporte, o seu arquivo XML estilo pode ter esta aparência:


<? xml version = "1.0" encoding = "UTF-8" ?> <resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "@ estilo / temáticos. AppCompat " > < item name = "android: actionBarTabStyle" > @ estilo / MyActionBarTabs </ produto > <! - compatibilidade biblioteca Apoio -> < item name = "actionBarTabStyle" > @ estilo / MyActionBarTabs </ produto > </ style > <! - guias ActionBar estilos -> <style nome = "MyActionBarTabs" pai = ". / Widget @ estilo AppCompat .ActionBar.TabView " > <! - indicador guia -> < item name = "android: Fundo " > @ drawable / actionbar_tab_indicator </ produto > <! - compatibilidade biblioteca Apoio -> < item de nome = "background" > @ drawable / actionbar_tab_indicator </ produto > </ style> </ resources>

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


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




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 .


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:

<Resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "android: estilo / Theme.Holo" > < item de nome = "android: windowActionBarOverlay" > verdadeiro < / produto > </ style> </ recursos>


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:

<Resources> <! - o tema aplicado ao aplicativo ou atividade -> <style nome = "CustomActionBarTheme" pai = "android:. estilo / Tema AppCompat " > < item name = "android: windowActionBarOverlay" > verdadeiro < / produto > <! - compatibilidade biblioteca Apoio -> < item name = "windowActionBarOverlay" > verdadeiro </ produto > </ style> </ resources>

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:

<RelativeLayout xmlns:android = "http://schemas.android.com/apk/res/android"

android:layout_width = "match_parent" android:layout_height = "match_parent" android:paddingTop = "?android:attr/actionBarSize" > ... </RelativeLayout>

Se você estiver usando a biblioteca de suporte para a barra de ação, você precisa remover

o android: prefixo.Por exemplo:

<! - Compatibilidade biblioteca Suporte --> <RelativeLayout xmlns:android = "http://schemas.android.com/apk/res/android" android:layout_width = "match_parent" android:layout_height = "match_parent" android:paddingTop = "?attr/actionBarSize" > ... </RelativeLayout>

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


Android 1.6 ou superior


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


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 :

<? xml version = "1.0" encoding = "utf-8" ?> <resources> <string nome = "title" > My Application </ string> <string nome = "hello_world" > Olá mundo! </ string> < / recursos>

Espanhol, /values-es/strings.xml :

<? xml version = "1.0" encoding = "utf-8" ?> <resources> <string nome = "title" > Mi Aplicación </ string> <string nome = "hello_world" > Hola Mundo! </ string> < / recursos>

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

<? xml version = "1.0" encoding = "utf-8" ?> <resources> <string nome = "title" > Aplicação Mon </ string> <string nome = "hello_world" > Bonjour le monde! </ string> </ recursos>

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 <string> do

elemento nome atributo.

Em seu código-fonte, você pode se referir a um recurso de cadeia com a

sintaxe R.string. <string_name> . 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 @ / <string_name>sempre que o atributo XML aceita um valor de

cadeia.

Por exemplo:

<TextView android:layout_width = "wrap_content" android:layout_height = "wrap_content" android:text = "@string/hello_world" />

Apoiando diferentes telas ANTERIORPRÓXIMA


1. Criar diferentes layouts

2. Criar bitmaps diferentes


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 -

<screen_size> 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


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


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 <uses-sdk elemento identificar

o nível mais baixo API com que seu aplicativo é compatível e o nível mais alto contra a API

que você projetou e testou seu app.

Por exemplo:

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

http://developer.android.com/about/dashboards/index.html

<uses-sdk android:minSdkVersion = "4" android:targetSdkVersion = "15" /> ... </manifest>

À medida que novas versões do Android são liberados, alguns estilo e comportamentos

podem mudar. Para permitir que o seu app para aproveitar essas mudanças e garantir que

o seu app se encaixa no estilo de dispositivo de cada usuário, você deve definir

o targetSdkVersion valor para coincidir com a versão mais recente Android disponível.

Verifique versão do sistema em tempo de execução

Android fornece um código único para cada versão de plataforma na Construir classe

constantes. Use estes códigos dentro do seu app para construir condições que garantam o

código que depende dos níveis mais altos da API é executado somente quando essas

APIs estão disponíveis no sistema.

privado vazio setUpActionBar () { // Certifique-se de que estamos rodando em Honeycomb ou superior para utilizar ActionBar APIs if ( Build . VERSION . SDK_INT >= 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:

<Atividade android: theme = "android: estilo / Theme.Dialog" >

Para tornar a sua actividade tem um fundo transparente:

<Atividade android: theme = "android: estilo / Theme.Translucent" >

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

<Atividade android: theme = "@ estilo / CustomTheme" >

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

tema atribuem ao<application> elemento:

<Aplicação android: theme = "@ estilo / CustomTheme" >

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

Interagindo com outros apps COMEÇAR


Conhecimento básico do ciclo de vida de atividades (consulte Gerenciando o Ciclo

de Vida de Atividade )


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

http://android-developers.blogspot.com/2009/11/integrating-application-with-intents.html

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


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



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 . EXTRA_SUBJECT , "Email assunto" ); emailIntent . putExtra ( Intent . EXTRA_TEXT , "mensagem de e-mail de texto" ); emailIntent . putExtra ( Intent . EXTRA_STREAM , Uri . analisar ( "content: // path / to / e-mail / attachment " )); // Você também pode anexar vários itens por meio de um ArrayList de Uris

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


1. Iniciar a Atividade

2. Receber o resultado




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


1. Adicionar um filtro de Intenção

2. Lidar com o Intenção em sua atividade

3. Retornar um resultado




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 <intent-filter> elemento no seu arquivo de manifesto para o

correspondente <activity>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 <action> 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 <dados> 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 <category> 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 <intent-filter> 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:

<activity android:name = "ShareActivity" > <intent-filter> <action android:name = "android.intent.action.SEND" /> <category android:name = "android.intent.category.DEFAULT" /> <data android:mimeType = "text/plain" /> <data android:mimeType = "image/*" /> </intent-filter> </activity>

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 <action> , <categoria> e <Data> elementos em cada <intent-

filter> .

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:

<Atividade android: name = "ShareActivity" > <! - filtro para enviar mensagens de texto; aceita ação SENDTO com sms esquemas URI filtrar para o envio de texto ou imagens; ENVIAR aceita ação e dados de texto ou imagem

Nota: Para receber intenções implícitas, você deve incluir

o CATEGORY_DEFAULT categoria no filtro de intenção.A

métodos startActivity () e startActivityForResult () tratar todas

as intenções, como se declarou aCATEGORY_DEFAULT categoria. Se você

não declará-lo em seu filtro de intenção, não há intenções implícitas irá

resolver a sua atividade.

Para mais informações sobre o envio e

recebimento ACTION_SEND intenções que realizam comportamentos de

compartilhamento social, consulte a lição sobre Recebendo dados simples

de Outros Apps .

Lidar com o Intenção em sua atividade

A fim de decidir que ação tomar em sua atividade, você pode ler

a Intenção que foi usado para iniciá-lo.

À medida que sua atividade se inicia, ligue getIntent () para recuperar

o Intenção que iniciou a atividade. Você pode fazê-lo a qualquer momento

durante o ciclo de vida da atividade, mas geralmente você deve fazê-lo

durante callbacks precoces, como onCreate () ou onStart () .

Por exemplo:

@Override protected void onCreate ( Bundle savedInstanceState ) { super . onCreate ( savedInstanceState ); setContentView ( R . layout . main ); // Obter a intenção de que começou essa atividade Intenção intenção = getIntent (); Uri dados = intenção . getData (); // Descobrir o que fazer com base no tipo intenção se ( intenção . getType . () indexOf ( "image /" ) ! = - 1 ) { // intenções Handle com dados de imagem ... } outra pessoa se ( intenção . GetType (). equals ( "text / plain" )) { // intenções Handle com texto ... } }

Retornar um resultado

Se você quiser retornar um resultado para a atividade que invocou o seu,

basta ligar para setResult () para especificar o código de resultado e

resultar Intent . Quando a sua operação é feita e que o usuário deve

retornar à atividade original, chamar acabamento () para fechar (e

destruir) sua atividade. Por exemplo:

// Cria a intenção de entregar algum tipo de resultado data Intent result = new Intent ( "com.example.RESULT_ACTION" , Uri . parse ( "content://result_uri" ); setResult ( Activity . RESULT_OK , result ); finish ();

Você sempre deve especificar um código de resultado com o

resultado. Geralmente, é ou RESULT_OK ouRESULT_CANCELED . Você pode,

então, fornecer dados adicionais com um Intent , conforme necessário.

Nota: O resultado está definido para RESULT_CANCELED por padrão. Assim,

se o usuário pressiona a Voltarbotão antes de completar a ação e antes de

definir o resultado, a atividade original recebe o resultado "cancelado".

Se você simplesmente precisa retornar um inteiro que indica uma das várias

opções de resultado, você pode definir o código de resultado para qualquer

valor superior a 0. Se você usar o código de resultado para entregar um

inteiro e você não tem necessidade de incluir a Intenção , você pode

chamar setResult () e passar apenas um código de resultado. Por

exemplo:

setResult ( RESULT_COLOR_RED ); acabamento ();

Neste caso, pode haver apenas um pequeno número de possíveis

resultados, de modo que o código de resultado é um número inteiro definido

localmente (superior a 0). Isso funciona bem quando você está retornando

um resultado de uma atividade em seu próprio aplicativo, porque a atividade

que recebe o resultado pode fazer referência a constante pública para

determinar o valor do código de resultado.

Nota: Não há necessidade de verificar se a atividade foi iniciada

com startActivity () oustartActivityForResult () . Basta ligar

para setResult () se a intenção que começou sua atividade poderia

esperar um resultado. Se a atividade de origem tinha

chamado startActivityForResult () , então o sistema de entrega-lo o

resultado que você fornecer para setResult () ; caso contrário, o

resultado é ignorado.

Android NDK

NESTE DOCUMENTO

1. Transferências

2. Revisões

3. Requisitos de Sistema e Software

4. Instalando o NDK

5. Primeiros passos com o NDK

1. Usando o NDK

6. Conteúdo do NDK

1. As ferramentas de desenvolvimento

2. Documentação

3. Aplicativos de exemplo

O NDK é um conjunto de ferramentas que permite implementar partes do seu aplicativo

usando linguagens de código nativo, como C e C ++. Para certos tipos de aplicativos, isso

pode ser útil para que você possa reutilizar bibliotecas de código existentes escritas em

línguas, mas a maioria dos aplicativos não precisa do Android NDK.

Antes de baixar o NDK, você deve entender que o NDK não vai beneficiar a maioria dos

aplicativos . Como um desenvolvedor, você precisa equilibrar seus benefícios contra os

seus inconvenientes. Notavelmente, usando o código nativo no Android geralmente não

resulta em uma melhoria de desempenho perceptível, mas ele sempre aumenta sua

complexidade app. Em geral, você só deve usar o NDK se é essencial para o seu app-

nunca, porque você simplesmente preferem programar em C / C ++.

Típicas bons candidatos para o NDK são cargas de trabalho intensivo da CPU, como

motores de jogo, processamento de sinal, simulação de física, e assim por diante. Ao

analisar se você deve ou não se desenvolver em código nativo, pensar sobre suas

necessidades e ver se as APIs quadro Android fornecer a funcionalidade que você precisa.

Transferências

Plataforma Pacote Tamanho (Bytes) MD5 checksum

Windows de 32

bits

android-NDK-r10d-windows-

x86.exe

455427281 c0930abfae0c990c4d191cc4ebd46b68

Windows de 64

bits

android-NDK-r10d-windows-

x86_64.exe

472613732 9a33f96da58a7e0b70e47d27b4a880b4

http://dl.google.com/android/ndk/android-ndk-r10d-windows-x86.exe

http://dl.google.com/android/ndk/android-ndk-r10d-windows-x86.exe

http://dl.google.com/android/ndk/android-ndk-r10d-windows-x86_64.exe

http://dl.google.com/android/ndk/android-ndk-r10d-windows-x86_64.exe

Mac OS X 32-bit android-ndk-r10d-darwin-x86.bin

441545213 0aeb3dc062dc457a4cd01e72eadb2379

Mac OS X 64-bit android-ndk-r10d-darwin-

x86_64.bin

442691567 cb101e1e62d56ea75b215f6bc6c27fae

Linux de 32 bits

(x86)

android-ndk-r10d-linux-x86.bin

449997190 70ed6d8c34e7e620c145b791e8eeef89

Linux de 64 bits

(x86)

android-ndk-r10d-linux-x86_64.bin

459151600 263b83071e6bca15f67898548d8d236e

Revisões

As seções a seguir fornecem informações sobre lançamentos do NDK.

Android NDK, 10d Revisão (Dezembro de 2014)

Mudanças importantes:

Feito GCC 4.8 padrão para todos os ABIs de 32 bits. Reprovado GCC 4.6, e irá

removê-lo próximo lançamento.Para restaurar o comportamento anterior,

adicione NDK_TOOLCHAIN_VERSION = 4,6 para NDK-build, ou adicionar--

toolchain = braço-linux-androideabi-4.6 ao executar make-

standalone-toolchain.sh na linha de comando. GCC 4.9 continua a ser o

padrão para ABIs de 64 bits.

Parado todos x86 [_64] toolchains de adicionar -mstackrealign por padrão. O

conjunto de ferramentas NDK assume um alinhamento pilha de 16 bytes. As

ferramentas e opções usadas por padrão aplicar esta regra. Um usuário

escrever código de montagem deve certificar-se de preservar o alinhamento

stack, e garantir que outros compiladores também cumprir esta regra. (GCC

bug 38496 )

Funcionalidade Sanitizer Endereço Adicionado a Clang 3.5 apoio à ARM e x86

ABIs. Para obter mais informações sobre essa alteração, consulte o Sanitizer

Endereço projeto.

Introduziu a exigência, a partir do nível API 21, para usar -fpie -pie ao

construir. Em níveis de API 16 e superiores, ndk-build usa PIE ao

construir. Esta mudança tem uma série de implicações, que são discutidas

noDeveloper Preview Issue 888 . Essas implicações não se aplicam às

bibliotecas compartilhadas.

Importantes correções de bugs:

Feitos mais correções relacionadas à A53 Errata # 835769 no-aarch64-linux-

android 4.9 vinculador. Como parte deste, GCC passa uma nova opção, --fix-

cortex-a53-835769 , quando -mfix-cortex-a53-835769 (ativado por

http://dl.google.com/android/ndk/android-ndk-r10d-darwin-x86.bin

http://dl.google.com/android/ndk/android-ndk-r10d-darwin-x86_64.bin

http://dl.google.com/android/ndk/android-ndk-r10d-darwin-x86_64.bin

http://dl.google.com/android/ndk/android-ndk-r10d-linux-x86.bin

http://dl.google.com/android/ndk/android-ndk-r10d-linux-x86_64.bin

padrão) é especificado. Para obter mais informações, consulte esta mensagem

binutils e esta mensagem binutils .

Documentado uma correção para um libc ++ sscanf / vsscanf jeito que

ocorreu no nível API 21. A correção em si havia sido executado de

R10C. (Problema 77988 )

Corrigido um AutoFDO ( -fauto-profile ) acidente que ocorreu com o GCC

4.9 quando -Os foi especificado.(Problema 77571 )

Outras correções de bugs:

Feitas as seguintes correções de cabeçalho e biblioteca:

o Adicionado posix_memalign a nível API 16. Além disso, acrescentou um

protótipo em stdlib.h aos níveis API de 16 a 19. (Problema 77861 )

o Corrigido stdatomic.h para que ele inclui <atômica> 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

de unsigned long para struct user_regs_struct *.

o 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-standalone-

toolchain.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)

http://b.android.com/77988











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ível (s)

ARM, ARM-NEON Android 1.5 (Nível 3 API) e superior

x86 Android 2.3 (Nível API 9) e superior

MIPS Android 2.3 (Nível API 9) e superior

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.

http://www.cygwin.com/

Para garantir a compatibilidade, um aplicativo usando uma biblioteca

nativa produzido com o NDK deve declarar um<usa-sdk> elemento no

seu arquivo de manifesto, com um android: minSdkVersion valor de

"3" ou maior atributo. Por exemplo:

<Manifest> <usa-sdk android: minSdkVersion = "3" /> ... </ manifest>

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 obrigatórios Atributo

OpenGL ES 1.1 Android 1.6 (Nível API 4) e superior android: minSdkVersion = "4"

OpenGL ES 2.0 Android 2.0 (API Nível 5) e superior android: minSdkVersion = "5"

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 <usa-feature> 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:

<Manifest> <usa-metragem android: glEsVersion = "0x00020000" /> ... </ manifest>

Para obter mais informações, consulte o <uses-

feature> 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 <usa-SDK do Android: minSdkVersion = "8"

/> 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- <versão> . 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 <ndk> .

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 <ndk> / 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 <project> / jni / ...

2. Criar <project> /jni/Android.mk para descrever as suas fontes

nativas da NDK sistema de construção

3. Opcional: Criar <project> /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 <projeto>

6. <Ndk> / 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-ARCH-

ABIS.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-ARM-

NEON.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 <ndk> / 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 <ndk> / 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 <ndk> / samples / <nome> / e seu código fonte pode ser

encontrado em <ndk> / samples / <nome> / jni / .

Você pode construir as bibliotecas compartilhadas para os aplicativos de

amostra, entrando <ndk> / samples / <nome> / , em seguida, chamar

o NDK-build comando. As bibliotecas compartilhadas gerados serão

localizados sob <ndk> / samples / <nome> / libs / armeabi / para

(código ARMv5TE máquina) e / ou <ndk> / samples / <nome> / 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 <ndk> / samples / <nome> / . 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 <ndk> / samples / <nome> / . 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 <ndk-root> / samples / Olá-jni diretório.

e. Clique em Concluir .

o Na linha de comando:

a. Mude para o <ndk-root> / 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 <ndk-root> / samples / Hello-JNI

4. <Ndk_root> / 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 <ndk-root> / 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 <ndk_root> /platforms/samples/native-

activity/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 <ndk-root> / samples / native-atividadediretório.

e. Clique em Concluir .

o Na linha de comando:

a. Mude para o <ndk-root> / samples / native-

atividade 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 <ndk-root> / plataformas / samples / android-9 / samples / native-atividade

4. <Ndk_root> / 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

Criando Projeto Android

Documents

Transcript of Criando Projeto Android