Android Core Aula 6 - Desenvolvimento de aplicações Android

1,337 views
1,286 views

Published on

Nesta aula iniciaremos o estudo de aplicações Android. Serão tratados conceitos como Activities, Layouts XML, Content Providers, etc.

Published in: Technology
0 Comments
4 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
1,337
On SlideShare
0
From Embeds
0
Number of Embeds
5
Actions
Shares
0
Downloads
132
Comments
0
Likes
4
Embeds 0
No embeds

No notes for slide

Android Core Aula 6 - Desenvolvimento de aplicações Android

  1. 1. Android Core Felipe Silveira felipesilveira.com.br Aula 6
  2. 2. Aplicações I
  3. 3. Desenvolvimento de Aplicações
  4. 4. Android SDK SDK https://developer.android.com/sdk
  5. 5. Android SDK Android SDK: ● Eclipse + ● ADT plugin + ● Android platform-tools + ● A última versão das interfaces do application framework + ● A última imagem para o emulador
  6. 6. Android SDK Instalação: descompacte o arquivo e execute o executável eclipse, localizado no diretório eclipse:
  7. 7. Hello World
  8. 8. Criando o projeto Passo 1 – Criando o projeto no Eclipse Abra o Eclipse, vá até File > New > Project Na tela que aparecer, escolha “Android Project” e clique em “Next”.
  9. 9. Criando o projeto
  10. 10. Criando o projeto Após isso, irá aparecer a tela com as configurações de seu projeto android. Nesta tela, você irá inserir o nome da sua aplicação, o package e as versões de android que ela irá suportar. Após preencher os campos, clique em Next
  11. 11. Criando o projeto A próxima tela contém opções para criação do ícone da aplicação e a localização do projeto. Após preencher os campos, clique em Next
  12. 12. Criando o projeto Na próxima tela, é possível configurar o ícone padrão da aplicação. Após preencher os campos, clique em Next
  13. 13. Criando o projeto A próxima tela contém as opções da Activity a ser criada. Após preencher os campos, clique em Next
  14. 14. Criando o projeto Por fim, a última tela do assistente de criação permite que seja alterado o nome da Activity principal da aplicação a ser criada. Após preencher os campos, clique em Finish
  15. 15. Criando o projeto Após isso, será criado o projeto android já com a activity principal:
  16. 16. Criando o projeto E com seu respectivo layout, escrito em XML:
  17. 17. Emulador Uma ferramenta muito útil para teste das aplicações é o emulador, que é parte do SDK Android. Para usarmos o emulador, é preciso antes entender o conceito de AVD - Android Virtual Device. O AVD serve para "representar" um dispositivo real, ou seja, ele vai ter as suas características, como tamanho de tela, quantidade de memória, etc. Dessa forma, o primeiro passo para a execução do emulador é a criação de um AVD, sobre o qual o emulador funcionará. Para isso, vamos usar o Android Virtual Devices Manager.
  18. 18. Emulador
  19. 19. Emulador Na tela para a criação do AVD, é necessário escolher um nome, que representará o AVD, e o "target", que é versão de android que rodará nele. Só são mostradas as versões de android instaladas na máquina local pelo SDK Manager. Também é necessário escolher o tamanho para o SD Card e o tamanho de tela. essas opções podem ficar como no screenshot a seguir.
  20. 20. Emulador
  21. 21. Emulador Depois de criado o AVD, basta selecioná-lo na lista e clicar em "Start..."
  22. 22. Emulador Na próxima tela, existem opções para mudar a escala da tela do emulador e para apagar os dados do usuário, gravados em uma execução anterior (Wipe user data)
  23. 23. Emulador
  24. 24. Compilando/Executando Para compilar e executar o projeto, clique com o botao direito no nome do projeto, e clique em Run As > Android Application
  25. 25. Quick Notes
  26. 26. Quick Notes Para estudarmos os principais componentes de uma aplicação Android, faremos a partir de agora uma aplicação completa. A aplicação será chamada de Quick Notes, e irá prover ao usuário uma interface simples para entrada de textos que serão armazenados para posterior visualização. Em outras palavras, uma ferramenta de anotações rápidas.
  27. 27. Quick Notes A interface da tela principal do QuickNotes será a seguinte: Insira um texto... SALVAR Texto 1 Texto 2 Texto 3 Texto 4 Texto 5 Texto 6 Texto 7
  28. 28. Layout Em android, existem duas formas de se definir o layout de uma tela: ● Através do próprio código java da aplicação ● Através de arquivos XML que "descrevem" a tela Seguir a segunda forma é uma boa prática, pois ajuda o desenvolvedor a separar o código da UI da lógica do aplicativo. Para armazenar os arquivos XML citados, já existe um folder dedicado no projeto android, em res/layout. Desse diretório já contém um XML criado por padrão, com o conteúdo a seguir
  29. 29. Layout
  30. 30. Layout No arquivo activity_main.xml, temos contato com os primeiros elementos de um arquivo de layout XML: ● LinearLayout, que é apenas um container. ● TextView, que é um elemento de texto. Nesse caso está imprimindo a string cujo id é @string/hello. Para criar um layout parecido com o que queremos, iremos inserir outros dois elementos: ● EditText – uma caixa de texto onde o usuário irá entrar com as anotações; ● ListView – uma lista de anotações previamente submetidas.
  31. 31. Layout <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" > <EditText android:id="@+id/edit_box" android:layout_width="330px" android:layout_height="wrap_content" android:text="" > </EditText> <Button android:id="@+id/insert_button" android:layout_width="150px" android:layout_height="wrap_content" android:text="Inserir" > </Button> </LinearLayout> <ListView android:id="@android:id/list" android:layout_width="fill_parent" android:layout_height="fill_parent" > </ListView> </LinearLayout>
  32. 32. Layout - carregando o XML Para que a nossa aplicação tenha o layout definido pelo arquivo XML, é preciso carregá-lo. Isso é feito através da função setContentView(), como no código abaixo: 1. public void onCreate(Bundle savedInstanceState) { 2. super.onCreate(savedInstanceState); 3. setContentView(R.layout.main); 4. } O parâmetro R.layout.main indica que o arquivo de layout a ser carregado é o main.xml. (Se o se arquivo se chamar abobrinha.xml, o parâmetro deverá ser R.layout.abobrinha)
  33. 33. Activity Agora é a hora de conhecer uma das mais importantes classes de uma aplicação Android: A classe Activity. Uma Activity é basicamente uma classe gerenciadora de UI (Interface com o usuário). Todo aplicativo android começa por uma Activity. Ou seja, quando uma aplicação android é executada, na verdade é a sua Activity principal que é lançada. A primeira coisa que deve-se conhecer sobre a Activity é o seu ciclo de vida, ilustrado no diagrama a seguir:
  34. 34. Activity Lifecycle
  35. 35. Content Providers Os Content Providers são parte importantíssima da arquitetura de um sistema android. É responsabilidade deles prover às aplicações o conteúdo que elas precisam para funcionar, ou seja, os dados. Mas por que são realmente necessários? As aplicações poderiam muito bem acessar diretamente um banco de dados, por exemplo. Porém, é uma boa prática tornar o modo como os dados são gravados transparente à aplicação. Dessa forma, a aplicação pode manter o foco nas interações com o usuário. Além disso, essa técnica permite a criação de Shared Content Providers, que são providers “públicos” que podem ser acessados por várias aplicações. Por exemplo, existe o content provider de SMS/MMS que permite a qualquer aplicação ler as mensagens recebidas por um telefone celular.
  36. 36. Content Providers E como é feita a comunicação entre Content Providers e Aplicações? Através de uma Uri Toda a comunicação entre aplicações e providers é feita através dos métodos da interface ContentProvider, que sempre recebem um objeto Uri como parâmetro. O formato da Uri é definido pelo content provider. Por exemplo, a Uri content://sms/inbox acessa as mensagens de inbox no Content Provider de SMS. Falaremos um pouco mais sobre as Uris a seguir, mas primeiro, vamos conhecer os métodos que usaremos para enviá-las para o provider:
  37. 37. Content Providers ● query(Uri, String[], String, String[], String)- usado para recuperar dados. ● insert(Uri, ContentValues) – usado para inserir dados. ● update(Uri, ContentValues, String, String[]) – usado para atualizar dados. ● delete(Uri, String, String[]) – usado para deletar dados. ● getType(Uri) – usado para obter o MIME type de certo dado.
  38. 38. Content Providers Com a construção do content provider, a arquitetura do quick notes ficará assim:
  39. 39. Estrutura das Uris Uma Uri usada para acessar Content Provider segue o formato: content://<authority>/<parametros> Onde authority é o “nome” do provider, e os parâmetros são aqueles definidos pelo provider. Por exemplo, a seguinte Uri: content://sms/conversations/10 Acessa o Content Provider de SMS, e seleciona a conversation de Id número 10.
  40. 40. Criando um Content Provider Para criar seu próprio content provider, é preciso fazer 2 coisas: 1. Criar uma sub-classe da ContentProvider, implementando os métodos públicos que eu citei no começo do artigo; 2. Registrar o provider no AndroidManifest.xml Vamos começar criando a classe QuickNotesProvider.
  41. 41. Criando um Content Provider Agora, vamos registrar o nosso provider no AndroidManifest, adicionando a seguinte linha dentro da tag application: <provider android:authorities="android.helloworld. quicknotesprovider" android:name="android.helloworld. QuickNotesProvider"/>
  42. 42. Acessando o banco de dados Com o Content Provider criado, vamos implementar os métodos de acesso e gravação de dados usando o SQLite. Para isso, usaremos a classe SQLiteOpenHelper para gerenciar a conexão com o banco de dados. Para usá-la, é preciso criar uma subclasse implementando os métodos abaixo: ■ onCreate() – Este método é chamado quando a conexão com o banco de dados for aberta pela primeira vez. É aqui que criaremos o banco de dados, com o comando sql CREATE. ■ onUpdate() – Este método é chamado quando a versão do banco de dados muda. Por exemplo, digamos que você criou uma nova versão de seu aplicativo que usa uma tabela a mais no banco de dados. Quando esta nova versão for instalada (em um telefone que já possuir a primeira versão) este método será chamado, então você poderá criar apenas a nova tabela, mantendo os dados do usuário.
  43. 43. Acessando o banco de dados Após implementar os métodos onCreate e onUpdate, deve-se implementar os métodos query, insert e delete, responsáveis por gerenciar os dados do DB.
  44. 44. Acessando o content provider Com o Provider pronto, vamos começar a interagir com ele a partir de nossa UI. Vamos começar inserindo uma anotação do usuário no banco de dados. Para fazer isso, o primeiro passo é adicionar um Listener ao botão ‘Inserir’, da seguinte forma: Button insertButton = (Button)findViewById(R.id.insert_button); insertButton.setOnClickListener(mInsertListener); Este código deve ser colocado dentro do método onCreate.
  45. 45. Acessando o content provider E agora, criando o objeto mInsertListener. Ele precisa ser um objeto que implementa a interface OnClickListener,. Assim, precisamos implementar o método onClick(), que será chamado assim que o usuário pressionar o botão. 1. // Definindo um OnClickListener para o botão "Inserir" 2. private OnClickListener mInsertListener = new OnClickListener() { 3. public void onClick(View v) { 4. EditText editBox = (EditText)findViewById(R.id.edit_box); 5. addNote(editBox.getText().toString()); 6. editBox.setText(""); 7. } 8. };
  46. 46. Acessando o content provider No código anterior, fizemos uma chamada a um método que ainda não está implementado – o método addNote(), que recebe um String que será inserida no banco de dados. Ele será o método responsável por acessar o content provider. Vamos implementá-lo: 1. /* 2. * Método responsável por inserir um registro no content provider 3. */ 4. protected void addNote(String text) { 5. ContentValues values = new ContentValues(); 6. values.put(QuickNotesProvider.Notes.TEXT, text); 7. 8. getContentResolver().insert( 9. QuickNotesProvider.Notes.CONTENT_URI, values); 10. }
  47. 47. ListActivity Agora, aprenderemos a usar uma ListActivity para mostrar ao usuario uma lista com as anotações que ele inseriu em nossa aplicação QuickNotes. A ListActivity é uma classe filha da Activity cujo objetivo é mostrar ao usuário uma Lista (uma ListView). Em suma, é uma Activity com alguns métodos para gerenciamento de listas, criada com o intuito de facilitar a criação de telas com essa configuração, muito comuns nas aplicações android. O primeiro passo para criar uma Activity desse tipo é assegurar que o layout XML a ser usado por ela possui um elemento ListView (afinal, estamos criando uma ListActivity!). Além disso, é preciso que seu id seja “@android: id/list”.
  48. 48. ListActivity Depois disso, o próximo é fazer a nossa classe MainActivity ser uma classe filha da ListActivity: public class MainActivity extends ListActivity E então, inicializar a ListView no método onCreate. Mas para isso precisaremos de um Adapter.
  49. 49. Adapters Adapters são classes responsáveis por fazer o que é chamado de “bind“: Receber os dados de um Cursor (ou de alguma outra fonte de dados) e colocá-los nos seus respectivos lugares no layout da Activity. Para Activity’s complexas, tipicamente são criadas subclasses da classe CursorAdapter (Adapter dedicado a tratar cursores). No nosso caso, em que temos um layout bastante simples, é suficiente o uso do SimpleCursorAdapter.
  50. 50. Adapters
  51. 51. SimpleAdapter 1. ListAdapter adapter = new SimpleCursorAdapter( 2. // O primeiro parametro eh o context. 3. this, 4. // O segundo, o layout de cada item. 5. R.layout.list_item, 6. // O terceiro parametro eh o cursor que contem os dados 7. // a serem mostrados 8. mCursor, 9. // o quarto parametro eh um array com as colunas do 10. // cursor que serao mostradas 11. new String[] {QuickNotesProvider.Notes.TEXT}, 12. // o quinto parametro eh um array (com o mesmo 13. // tamanho do anterior) com os elementos que 14. // receberao os dados. 15. new int[] {R.id.text}); 16. 17. setListAdapter(adapter);
  52. 52. SimpleAdapter Um dos parâmetros recebidos pelo contrutor da SimpleCursorAdapter é o layout dos itens da lista, que definimos da seguinte forma: <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android: layout_width="fill_parent" android:layout_height="wrap_content" android:orientation="vertical" > <TextView android:id="@+id/text" android:textSize="16sp" android:textStyle="bold" android:textColor="#FFFFFF" android:layout_width="fill_parent" android:layout_height="wrap_content" /> </LinearLayout>
  53. 53. Integração com content providers Integrando a Activity com o content provider, passamos a ter uma aplicação totalmente funcional.
  54. 54. Bibliografia Android 4 Application Development Reto Meier

×