Android Core Aula 6 -  Desenvolvimento de aplicações Android
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share

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

  • 649 views
Uploaded on

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

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

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
649
On Slideshare
649
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
64
Comments
0
Likes
3

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Android Core Felipe Silveira felipesilveira.com.br Aula 6
  • 2. Aplicações I
  • 3. Desenvolvimento de Aplicações
  • 4. Android SDK SDK https://developer.android.com/sdk
  • 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. Android SDK Instalação: descompacte o arquivo e execute o executável eclipse, localizado no diretório eclipse:
  • 7. Hello World
  • 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. Criando o projeto
  • 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. 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. 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. 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. 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. Criando o projeto Após isso, será criado o projeto android já com a activity principal:
  • 16. Criando o projeto E com seu respectivo layout, escrito em XML:
  • 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. Emulador
  • 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. Emulador
  • 21. Emulador Depois de criado o AVD, basta selecioná-lo na lista e clicar em "Start..."
  • 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. Emulador
  • 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. Quick Notes
  • 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. 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. 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. Layout
  • 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. 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. 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. 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. Activity Lifecycle
  • 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. 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. 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. Content Providers Com a construção do content provider, a arquitetura do quick notes ficará assim:
  • 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. Adapters
  • 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. 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. Integração com content providers Integrando a Activity com o content provider, passamos a ter uma aplicação totalmente funcional.
  • 54. Bibliografia Android 4 Application Development Reto Meier