desenvolvendo seu primeiro aplicativo Android

desenvolvendo seu primeiro aplicativo Android

Por Que Nos preocupamos com o Android? Nós Nos preocupamos com a plataforma Android porque é a plataforma móvel mais amplamente distribuída do planeta e é acessível aos consumidores em todo o mundo. Em economias onde a propriedade de um computador pessoal é um luxo, o uso de dispositivos móveis é a norma–e o Android está desempenhando um papel importante na conexão das pessoas umas com as outras. Como você aprenderá neste tutorial, o Android adota uma abordagem distinta para os aplicativos. A arquitetura do Android permite um ambiente de software altamente personalizável, graças à sua ligação em tempo de execução das ações solicitadas e ao código para satisfazer essas solicitações. Quer se trate de considerações orientadas para o mercado ou os aspectos técnicos do Android, é uma plataforma que vale a pena ser examinada. Além disso, se você está considerando seriamente ter uma experiência móvel para sua plataforma, não pode ignorar o Android.

pré-requisitos

este tutorial requer várias tecnologias que funcionam juntas. Você precisa de todos eles para este tutorial.

• Android Studio – Android Studio é o principal ponto de partida para a construção de Aplicativos Android
• Android dispositivo ou Emulador – Você vai querer um físico dispositivo Android, ou o Emulador Android. De qualquer forma, ler este tutorial irá ajudá-lo a entender os pontos de conexão básicos de um aplicativo Android.

• código – fonte-trechos de código-fonte neste tutorial incluem:

  • AndroidManifest.XML snippet-este arquivo é o descritor de implantação de aplicativos para aplicativos Android.
  • MainActivity.java-isso implementa uma atividade do Android, o principal ponto de entrada para o aplicativo de exemplo deste tutorial.
  • Activity_main.xml-este contém definições para os elementos visuais, ou recursos, para uso por atividades Android.
  • AndroidManifest.xml completo-isso Lista um AndroidManfest completo.arquivo xml, juntamente com uma descrição de cada um dos elementos importantes.

Introdução o Android arquitetura

Antes de mergulhar para a direita para o ins-e-saídas do Android Estúdio e desenvolvimento de aplicações Android, vamos ter um olhar para a arquitetura do Android e alguns dos termos-chave que serão úteis no tutorial e para além dela, como você começar a criar aplicativos para Android para si mesmo.

terminologia do Android

uma compreensão dos termos abaixo é útil no desenvolvimento de aplicativos Android com o Android Studio.

• o Android é um ambiente operacional de código aberto voltado para dispositivos móveis. Cada vez mais, o Android é encontrado em aplicativos além dos “smartphones”. Isso inclui tecnologia vestível, aparelhos como projetores, alto-falantes e televisores e até automóveis.
• Emulator é uma ferramenta de software representativa de outro sistema. Muitas vezes, um emulador é um ambiente que é executado em um computador pessoal (PC, Mac, máquina Linux) que emula outro ambiente, como um dispositivo de computação móvel.O Linux é um kernel de sistema operacional de código aberto no coração de muitas plataformas de computação, incluindo servidores, computadores desktop, dispositivos de rede e dispositivos de computação móvel. O Android é executado em cima de um kernel Linux.
• o Android Run Time (ART) é um ambiente operacional encontrado na pilha do Android, que executa o código do aplicativo em tempo de execução. O tempo de execução do Android substitui a máquina virtual Dalvik (VM) “herdada” de versões anteriores do Android que operavam de maneira semelhante a uma VM Java compatível.

a intenção

desde a sua criação, o Android tornou-se uma força dominante no espaço do telefone móvel. Seu modelo de aplicação é único, pois os aplicativos não são aplicativos monolíticos e carregados de menus que exigem muito Clique e toque para operar. Claro, existem menus e botões a serem tocados, mas o Android tem um elemento de design inovador para sua arquitetura conhecida como intenção.

uma intenção é uma construção que permite que um aplicativo emita uma solicitação, que é um pouco como um sinal de Ajuda desejada. Pode parecer assim:

• “queria: Um aplicativo para me ajudar a procurar um contato”
• “queria: um aplicativo para me ajudar a exibir esta imagem”
• ” queria: um aplicativo para realizar esta pesquisa geográfica.”

de forma semelhante e complementar, os aplicativos podem se registrar como capazes e interessados em satisfazer várias solicitações ou intenções. Para seguir o paradigma da publicidade classificada, estes podem ser assim:

• “Disponível: aplicativo pronto e disposto a apresentar registros de contato de maneira clara e concisa”
• ” disponível: Aplicativo pronto e disposto a realizar uma pesquisa geográfica.”

estes são exemplos de IntentFilters, que são discutidos a seguir.

os aplicativos IntentFilter

anunciam sua disponibilidade para executar esses tipos de operações por meio de uma construção conhecida como IntentFilter. O IntentFilter está registrado em tempo de execução ou é enumerado no AndroidManifest.arquivo xml. O trecho a seguir vem de um aplicativo Android que responde a mensagens SMS (Texto) Recebidas:

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

IntentFilter, a próxima seção apresenta os quatro principais tipos de aplicativos do Android.

Tipos de aplicativos do Android

Vamos ter um momento para examinar os quatro principais tipos de aplicativos do Android:

• Atividade
• Serviço
• Receptor
• ContentProvider

Vamos também ter um olhar para os modos de exibição para exibir a interface de usuário (UI) elementos.

Activity apps

a atividade é a forma mais visível e proeminente de um aplicativo Android. Uma atividade apresenta a interface do Usuário para um aplicativo, juntamente com a assistência de uma classe conhecida como view. A classe view é implementada como vários elementos da interface do usuário, como caixas de texto, rótulos, botões e outras UIs típicas em plataformas de computação, dispositivos móveis ou otherwise.An o aplicativo pode conter uma ou mais atividades. Uma atividade é normalmente definida em um relacionamento um-para-um com as telas encontradas em um aplicativo.

Uma aplicação se desloca de uma atividade para outra chamando um método conhecido como startActivity() ou startSubActivity(). O método anterior é usado quando o aplicativo deseja simplesmente “mudar” para a nova atividade. Este último é usado quando um paradigma de chamada/resposta síncrona é desejado. Em ambos os casos, uma intenção é passada como um argumento para o método chamado.

é responsabilidade do sistema operacional determinar a atividade mais qualificada para satisfazer a intenção especificada.

aplicativos de serviço e receptor

como outros ambientes de computação com várias tarefas, existem aplicativos em execução “em segundo plano” que executam várias tarefas. O Android chama esses tipos de serviços de aplicativos. O serviço é um aplicativo Android que não tem interface do Usuário.

o receptor é um componente de aplicativo que recebe solicitações para processar intenções. Como o serviço, um receptor não, na prática normal, tem um elemento UI. Os receptores são normalmente registrados no AndroidManifest.arquivo xml.

o seguinte trecho (que é o mesmo que o mostrado para IntentFilter) é um exemplo de um aplicativo receptor sendo definido. Observe que o atributo name do receptor é a classe Java responsável pela implementação do receptor.

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

O ContentProvider é o Android mecanismo para armazenamento de dados de abstração. Vejamos um tipo específico de dados encontrado em um dispositivo móvel: o catálogo de endereços ou o banco de dados de contatos. O catálogo de endereços contém todos os contatos e números de telefone que uma pessoa pode precisar ao usar um telefone celular.

o ContentProvider é um mecanismo para abstrair o acesso a um armazenamento de dados específico. De muitas maneiras, o ContentProvider atua na função de um servidor de banco de dados. As operações para ler e gravar conteúdo em um armazenamento de dados específico devem ser passadas por um ContentProvider apropriado , em vez de acessar um arquivo ou banco de dados diretamente. Pode haver “clientes” e “implementações” do ContentProvider.

visualizações do Android

as visualizações do Android são o mecanismo de interface do Usuário para colocar as coisas na tela de um dispositivo Android. A atividade do Android emprega visualizações para exibir elementos da interface do Usuário. Alguns dos designs de layout mais populares incluem:

• LinearVertical – cada elemento subsequente segue seu antecessor fluindo abaixo dele em uma única coluna.
• LinearHorizontal – cada elemento subsequente segue seu antecessor fluindo para a direita em uma única linha.
• Table-uma série de linhas e Colunas, semelhante a uma tabela HTML. Cada célula pode conter um elemento de visualização.
• restrição-cada elemento é “restrito” a um aspecto da tela, como a parte superior ou lateral da tela ou outro elemento. Este layout ajuda na construção de aplicativos “responsivos” e é o herdeiro aparente do layout relativo legado introduzido em versões anteriores da plataforma Android.

depois que um layout específico (ou combinação de layouts) foi selecionado, visualizações individuais são usadas para definir a IU.

Ver elementos familiarizado elementos da INTERFACE do usuário, incluindo:

• Botão
• Imagemver
• EditText para coletar a entrada com vários filtros, como Data ou Numérico
• TextView (semelhante a um rótulo, exibe texto estático)
• caixa de Verificação
• Botão de Rádio
• Giratório (semelhante a um “drop-down” caixa de combinação)
• Autocompletar (EditText com o auto de texto completo de recurso)

pontos de Vista são definidos em um arquivo XML. Por exemplo, isso mostra uma visualização linear vertical simples, com botões e textviews definidos:

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent" ><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1!" /><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1, second text view!" /><Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Switch To Activity 2" /></LinearLayout>

https://developer.android.com/, e role para baixo para baixar o Android Studio. O Android Studio está disponível para Windows, Mac e Linux.O Android Studio é baseado na plataforma IntelliJ IDE. Se você é o tipo de desenvolvedor que é interessante em alavancar atalhos de teclado, você pode considerar aprender mais sobre IntelliJ a partir do site jetbrains.

começando com o Android SDK

agora que temos o Android Studio instalado, é hora de obter o Software Developer Kit (SDK) para Android.

mas, antes de ir mais longe, precisamos ter uma discussão sobre as versões do Android.

versões do Android

desde o seu início, o Android foi lançado sob um caminho um tanto paralelo de revisões de versão numérica, níveis de API e também nomes “doces”, incluindo Jelly Bean, KitKat, Oreo e outros Favoritos de confeitaria.

é fácil ser oprimido pelas escolhas disponíveis. Por enquanto, você precisa apenas de um pouco de compreensão deste “cenário de versão” para começar como um desenvolvedor Android.

existem muitas versões, ou revisões, do Android na natureza. Se você for escrever um aplicativo para lançamento comercial, precisará saber quais dispositivos você está segmentando. Wikipedia tem um bom resumo das versões do Android, os nomes, as datas de lançamento, bem como um gráfico que descreve o número aproximado de cada dispositivo no mercado.

os dispositivos mais recentes executam o código mais recente e os dispositivos mais antigos podem ser um pouco limitados em sua capacidade de atualizar para uma versão mais recente do Android. Às vezes, as versões mais recentes suportam recursos que os aparelhos mais antigos não são capazes de suportar (pense em segunda câmera, comunicações de campo próximo e assim por diante). Outra razão não trivial de que aparelhos mais antigos podem não ser capazes de executar a versão mais recente do Android é que o fabricante e a operadora de telecomunicações (Verizon, em&T, e assim por diante) precisam suportar o software em execução em seu ecossistema. O suporte a um novo sistema operacional requer recursos por parte do fabricante do dispositivo e da operadora. As forças do mercado sugerem que esses participantes do mercado estão mais preocupados com as vendas futuras do que com o apoio às vendas anteriores e investem seu capital humano de acordo.

como desenvolvedor de software, o que importa que existam novas versões do sistema operacional? Isso se divide em duas grandes categorias quando se trata de aplicativos de programação:

• uma nova versão do sistema operacional geralmente introduz novos recursos que podemos aproveitar e / ou nossa base de usuários espera que nossos aplicativos suportem.
• os recursos mais antigos (ou legados) do ambiente podem estar realmente dificultando os recursos mais recentes e / ou representar uma abordagem inferior ao fornecimento de um conjunto específico de funcionalidades. Às vezes, o código precisa realmente ser removido das definições da API. Existe um termo especial para essa “remoção” de código que funcionava anteriormente – chamamos de “depreciação de código”. Quando uma API foi marcada para remoção, dizemos que esta é uma API obsoleta. Esta é essencialmente uma mensagem para o desenvolvedor que é algo como isto: “Aviso” este código será removido no futuro, por favor, planeje de acordo.”

a plataforma Android tem sido bastante liberal (isto é, favorável ao Desenvolvedor) com sua abordagem ao código obsoleto, permitindo que os aplicativos continuem usando APIs mais antigas por um bom tempo depois de serem marcados como obsoletos. (Essa abordagem contrasta com a abordagem da Apple com o código obsoleto no iOS, onde o código mais antigo pode simplesmente parar de funcionar na próxima versão do sistema operacional. Com o iOS, até a linguagem de programação parece mudar enquanto não estamos olhando!)

embora o Android possa ser um pouco mais indulgente com seu longo sofrimento de código obsoleto, precisamos ficar de olho na tag de documentação que diz que uma API específica está obsoleta. Se algum código que estamos usando estiver marcado como obsoleto, precisaremos eventualmente alterar nossa abordagem em uma versão futura de nosso aplicativo porque qualquer API marcada como obsoleta pode ser removida em uma versão futura. Os marcadores de depreciação no SDK são nosso roteiro para futuras oportunidades de melhoria e possíveis dores de cabeça. Às vezes, a “nova” maneira de fazer as coisas é simples e direta, mas não em todos os casos!

ser um desenvolvedor de aplicativos móveis de sucesso requer um investimento contínuo ao longo da vida de um aplicativo onde o tempo tende a passar como anos de cachorro…muito rapidamente!

com esta introdução básica para as versões do Android, é hora de obter o Android SDK.

obtendo e instalando o Android SDK

Inicie o Android Studio. No menu Ferramentas, selecione SDK Manager. Esta opção de menu carrega a caixa de diálogo Preferências do Android Studio e pré-seleciona o submenu do Android SDK. Este menu é o nosso principal meio de interagir com os vários SDKs disponíveis para as muitas versões do Android.

com cada versão do sistema operacional, os incrementos de nível de API. Observe que a revisão aumenta mais lentamente do que o nível da API. Você pode pensar na revisão como uma” geração “da plataforma ou como um número de versão” principal”. Ao navegar na documentação do Android, certifique-se de observar qual nível de API foi introduzido em um determinado recurso. Cada API está disponível no nível da API indicado e maior, a menos que a API tenha sido descontinuada e posteriormente removida. Por exemplo, a API ContactsContract foi introduzida no nível 5, que é bastante “antiga” neste momento.

selecione um ou dois níveis do SDK para trabalhar por enquanto. O SDK Manager irá posteriormente baixar os arquivos relacionados e torná-los disponíveis para uso no Android Studio.

também no menu Ferramentas é uma opção para o Gerenciador de AVD. AVD significa dispositivo virtual Android. Este é o emulador. O emulador é útil porque nos permite testar aplicativos em vários tipos, tamanhos e versões de dispositivos. As capturas de tela neste tutorial são tiradas do emulador. Mais sobre isso mais tarde.

construindo seu primeiro aplicativo Android

este tutorial o conduz através da criação de um aplicativo Android básico, chamado SaySomething , usando o Android Studio e demonstrando-o no emulador Android.

obter o código

Passo 1: Crie um novo projeto

1. selecione o arquivo > novo projeto.

2. preencha a caixa de diálogo Criar projeto Android e clique em Avançar.

   

   Os requisitos para o novo projeto incluir:

   • nome do Aplicativo
   • domínio da Empresa (isso é revertido em com.domínio) para manter os aplicativos particionados, mesmo que tenham o mesmo nome de aplicativo.
   • local do projeto – onde armazenar os arquivos
   • o nome do pacote é sugerido a partir do nome do aplicativo e do domínio da empresa
   • por padrão, os aplicativos Android são escritos em Java. Se você quiser oferecer suporte a linguagens alternativas, como C++ (para código nativo) ou Kotlin, marque as caixas de seleção apropriadas.

3. na caixa de diálogo dispositivos Android de destino, especifique o nível da API e as plataformas de destino. Como mencionado anteriormente, o Android é para mais do que apenas telefones, embora, para nossos propósitos, simplesmente selecionemos o Fator de forma de telefone e Tablet para este tutorial. Em seguida, clique em Avançar.

   

4. na caixa de diálogo Adicionar uma atividade ao celular, selecione o tipo de atividade vazio. Em seguida, clique em Avançar.

   

   isso criará um aplicativo padrão pronto para ser construído e executado diretamente do Android Studio.

5. na caixa de diálogo Configurar atividade, nomeie os arquivos do aplicativo.

   

Passo 2: Revisar o código

A figura seguinte mostra os componentes de nosso novo projeto:

Existem duas pastas: aplicação e Gradle Scripts.

• a pasta app contém todo o código do nosso aplicativo.
• a pasta manifesta na pasta app contém AndroidManifest.xml que é o descritor de implantação para esta aplicação. Este arquivo informa ao dispositivo Android sobre como interagir com o aplicativo, Qual atividade mostrar quando o aplicativo é iniciado, o que intenta os serviços do aplicativo, quais ícones exibir e muito mais.
• a pasta java contém o código – fonte do aplicativo. Nesse caso, o arquivo que implementa nossa atividade mais alguns arquivos de classe para realizar testes automatizados (que ignoraremos para este tutorial).
• a pasta res contém os recursos do aplicativo, incluindo ícones, arquivos de layout, strings, menus e assim por diante.
• a pasta Gradle Scripts contém todos os elementos scriptáveis para a construção do aplicativo. O sistema de construção Gradle é um tópico em si mesmo. Por enquanto, entenda que esses scripts governam o processo de construção do aplicativo – e, mais importante, para projetos e equipes mais maduros, cada uma dessas etapas pode ser executada a partir da linha de comando. Isso é importante porque essa abordagem suporta automação e se enquadra na categoria de Integração Contínua.

agora, vamos examinar o código – fonte com mais detalhes.

atividade primária para o aplicativo

nosso aplicativo de amostra consiste em uma única atividade, chamada MainActivity.

package com.navitend.saysomething;import android.content.Intent;import android.net.Uri;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.view.View;import android.util.Log;import android.widget.Button;import android.widget.TextView;import android.widget.EditText;public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.i("IBM","Hello there logcat!"); setContentView(R.layout.activity_main); final Button btnHitMe = (Button) findViewById(R.id.hitme); final Button btnMapMe = (Button) findViewById(R.id.mapme); final TextView tvLabel = (TextView) findViewById(R.id.thelabel); final EditText etLatitude = (EditText) findViewById(R.id.etLatitude); final EditText etLongitude = (EditText) findViewById(R.id.etLongitude); btnHitMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { tvLabel.setText("Ouch!"); } } ); btnMapMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { String coords = etLatitude.getText()+","+etLongitude.getText(); Log.i("IBM",coords); Uri mapsIntentUri = Uri.parse("geo:" + coords); Intent mapIntent = new Intent(Intent.ACTION_VIEW, mapsIntentUri); startActivity(mapIntent); } } ); }}

MainActivity é uma classe Java normal, com um pacote e as importações, como esperado.

os recursos para o aplicativo

os recursos no Android são organizados em um subdiretório do projeto denominado res, conforme descrito anteriormente. Os recursos se enquadram em várias categorias. Essas três categorias são:

• Drawables – Esta pasta contém arquivos de elementos gráficos, como ícones e bitmaps
• Layouts – Esta pasta contém arquivos XML que representam os layouts e views da aplicação. Estes serão examinados em detalhes abaixo.
• valores – esta pasta contém um arquivo chamado strings.xml. Este é o principal meio de localização de string para o aplicativo. As cores do arquivo.xml é útil para definir códigos de cores usados pelo aplicativo. Este arquivo é análogo a uma folha de estilo css para aqueles familiarizados com técnicas de programação web.

recursos primários da interface do usuário no main_activity.arquivo xml

o aplicativo de amostra contém uma única atividade e uma única visualização. O aplicativo contém um arquivo chamado main_activity.xml que representa os aspectos visuais da IU primária da atividade. Observe que não há referência no main_activity.xml onde o layout é usado. Isso significa que pode ser usado em mais de uma atividade, se desejado. Veja a seguinte lista de códigos

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" android:gravity="center_vertical"> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" android:orientation="horizontal" android:gravity="center" tools:layout_editor_absoluteX="8dp" tools:layout_editor_absoluteY="301dp"> <Button android:id="@+id/hitme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hit Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="383dp" /> <Button android:id="@+id/mapme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Map Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="460dp" /> </LinearLayout> <TextView android:id="@+id/thelabel" android:layout_width="match_parent" android:layout_height="wrap_content" android:gravity="center" android:text="Hello World, Say Something!!!!!" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" /> <EditText android:id="@+id/etLatitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Latitude" android:inputType="numberDecimal" android:text="40.9241164" /> <EditText android:id="@+id/etLongitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Longitude" android:inputType="numberDecimal" android:text="-74.7213913" /></LinearLayout>

LinearLayout, há um segundo LinearLayout organizado como um layout horizontal. Este layout interno contém um par de widgets de botão. Abaixo da horizontal LinearLayout há um único elemento TextView, que pode ser comparado a um rótulo em outros ambientes de desenvolvimento. Uma TextView representa um texto estático que não é editável. Abaixo do TextView , existem dois widgets EditText , configurados para receber entradas numéricas. Esses elementos de entrada são usados para capturar um valor de Latitude e Longitude que será posteriormente passado para um aplicativo de mapeamento, conforme demonstrado abaixo.

observe que cada elemento de visualização tem atributos no espaço de nome do android. Alguns atributos são comuns a todas as visualizações-os atributos android:layout_width e android:layout_height , por exemplo. Os valores disponíveis para esses atributos são:

• Match Parent-isso estende o elemento view para ocupar o espaço máximo disponível. Isso também pode ser pensado como significando ” esticar.”
• Wrap Content – esta opção resulta na expansão do elemento apenas o suficiente para conter suas visualizações ou atributos filho, como texto ou imagem.

descritor de implantação para um aplicativo Android (AndroidManifest.xml)

o AndroidManifest.o arquivo xml representa o descritor de implantação de um aplicativo Android. O arquivo Lista qualquer atividade, Serviço, provedor de conteúdo ou receptor contido no aplicativo, junto com os IntentFilters apropriados suportados pelo aplicativo. Aqui está o AndroidManifest completo.arquivo xml para o aplicativo de amostra:

<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.navitend.saysomething"> <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/AppTheme"> <activity android:name=".MainActivity" android:label="@string/app_name" android:theme="@style/AppTheme.NoActionBar"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application></manifest>

<manifest > está essencialmente importando classes deste pacote. Todas as classes não totalmente qualificadas neste arquivo são encontradas no Pacote identificado no atributo package.

Etapa 3: Construa o aplicativo

para construir o aplicativo, selecione o ícone da chave inglesa (parece mais um martelo para mim) no menu do Android Studio.

o processo de compilação, conforme introduzido anteriormente, é um processo de várias etapas que pode ser personalizado para qualquer aplicativo específico. Para este tutorial, Não modificamos o processo de construção. A saída do processo de compilação deve ser algo como isto:

Para demonstrar o processo de construção, nós introduzimos um erro no código-fonte; nós adicionamos um espaço extra no nome do método findViewById, mostrado na figura a seguir:

Isso cria uma sintaxe ou erro de análise que é captado pelo processo de compilação e exibidos na janela resultados da compilação no Android Estúdio. Ao corrigir o erro no código – fonte, o aplicativo é compilado corretamente e os erros são removidos da lista de problemas.

Passo 4: Execute o aplicativo

agora que o aplicativo foi compilado com sucesso, é hora de executar o aplicativo de amostra.

no início deste tutorial, o AVD Manager foi introduzido como o meio para configurar o emulador para testar aplicativos sem a necessidade de um dispositivo real. Executar um aplicativo usando o emulador é particularmente útil porque permite testes sem a necessidade de comprar vários dispositivos caros.

para configurar um emulador ou, mais corretamente, um dispositivo virtual Android (AVD), selecione Ferramentas > AVD Manager. Ou simplesmente clique no ícone Reproduzir (executar).

Isto abre uma janela que permite que você selecione qualquer um verdadeiro dispositivo que é conectado por um cabo USB ou com uma AVD instância, como mostrado na figura a seguir:

Se há dispositivos conectados, cada um mostra até no drop-down abaixo Dispositivos Conectados. Como alternativa, selecione um dos dispositivos virtuais disponíveis. Na figura anterior, há um único AVD definido intitulado Nexus One API P . Para criar um novo AVD, selecione o botão Criar Novo Dispositivo Virtual.Finalmente, clique em OK para iniciar o aplicativo no destino de implantação selecionado. O AVD ou emulador é iniciado com nosso aplicativo de amostra em execução nele.

Passo 5: Testar a aplicação no emulador

Agora que a aplicação está em execução no emulador, vamos dar uma olhada no que está acontecendo por trás das cenas. No Android Studio, selecione Exibir > janelas de ferramentas. Vamos destacar apenas algumas dessas opções de ferramentas, embora cada uma delas seja um tópico em si.

Android Studio Tools

primeiro, olhe para o perfilador Android que retrata um gráfico em execução de CPU, memória e tráfego de rede. O Android Profiler nos permite alternar entre diferentes dispositivos / instâncias do emulador e respectivos processos em execução. A figura a seguir exibe as métricas para nosso aplicativo de exemplo em execução em uma instância do emulador.

o registro é uma ferramenta útil para qualquer desenvolvedor em qualquer plataforma. Para Desenvolvedores Android, o nome da ferramenta é LogCat.

o LogCat é um arquivo de log em execução da atividade que ocorre na VM. Os aplicativos podem fazer suas próprias entradas para esta lista com uma linha simples de código da seguinte forma: Log.eu(tag, mensagem); 1, onde tag e message são ambas as strings Java. A classe Log faz parte do android .util.Log pacote.

outra ferramenta útil é o file explorer, que permite o acesso do sistema de arquivos do emulador. A figura a seguir mostra onde o aplicativo de exemplo do tutorial é implantado no emulador.

Usuário aplicativos são implantados em /data/app enquanto o Android aplicativos internos são encontrados em /system/app diretório.

a depuração em grande escala de um aplicativo Android está além do escopo deste tutorial, embora tenha certeza de que o Android Studio suporta todas as ferramentas modernas de depuração de aplicativos que podemos esperar com coisas como entrar e passar por chamadas de função.

testando o aplicativo de amostra

Toque no Hit Me! botão, e o conteúdo do rótulo muda para ” AI!”

Toque no mapa Me! e um aplicativo de mapeamento é iniciado com a latitude e longitude especificadas contidas nos widgets EditText.

A fiação dos botões está na MainActivity.código xml. Em particular, observe como os valores de latitude e longitude são extraídos e empacotados em um Intent, que é posteriormente usado para iniciar o aplicativo de mapeamento.

este tutorial introduziu a plataforma Android, o Android Studio e os principais elementos do desenvolvimento do Android. Agora você deve estar pronto para criar seus próprios aplicativos Android.

você está pronto para algo mais? Experimente este tutorial onde você usa APIs Bluetooth Low Energy (BLE) para criar dispositivos conectados à IoT.