Na primeira parte desse tutorial, configuramos nosso ambiente de desenvolvimento. Hoje vamos ver um exemplo de uma aplicação desenvolvida para Android e ver a estrutura que deve ser implementada.

Você já deve estar com o Eclipse aberto eu imagino (não leu a parte 1?). Vamos criar um exemplo padrão do Android, então vá em File > New > Project. Na janela que abrir, selecione Android Sample Project e clique em Next.

Na segunda janela do assistente ele pede o Build Target do aplicativo. É recomendado utilizar a versão mais recente do Android, pois isso garante que seu aplicativo possa ser compilado com suporte a maioria das versões. Para esse exemplo, estou escolhendo a versão 4.0.3. Ao clicar em Next, é hora de escolher qual exemplo vamos utilizar. Selecione SkeletonApp e clique em Finish.

Package Explorer

Já temos nosso exemplo criado. O exemplo escolhido possui o código básico para um aplicativo (por isso seu nome). No lado esquerdo da janela do Eclipse, temos o painel Package Explorer e nele vemos a estrutura de arquivos do nosso exemplo:

  • src/: é o diretório que contém todo o código-fonte da aplicação, escrito em Java
  • src/com/android/skeletonapp/SkeletonActivity.java: implementação da Activity (lembre-se bem desse nome) principal do app.
  • res/: diretório onde estão os resources do aplicativo, ou seja, tudo aquilo que não é código-fonte mas que vai ser usado no aplicativo. Dentro desse diretório temos:
    • drawable*: diretórios que contém imagens, divididos por densidade de pixels das telas.
    • layout: nesse diretório vão todos os arquivos de layout em formato XML usados no app.
    • values: diretório com arquivos também em formato XML que contém valores que podem ser referenciados no código-fonte (ex.: strings, etc.).
  • AndroidManifest.xml: arquivo de especificação do aplicativo, que define informações como quais dispositivos são compatíveis, como iniciar o app, os dados que ele pode receber de outro aplicativo, etc. Todos os aplicativos para Android devem ter um arquivo exatamente com esse mesmo nome.

Mas não adianta ficar aqui falando pra que serve cada arquivo. Hora de começar a ver o código, começando pelo AndroidManifest.xml. Ao abri-lo, provavelmente você verá o plugin do Android em ação. O editor possui 5 abas inferiores: “Manifest”, “Application”, “Permissions”, “Instrumentation” e “AndroidManifest.xml”. Abra a última aba, que contém o código. As outras quatro abas facilitam o trabalho de editar o arquivo, fornecendo várias opções em forma gráfica (GUI). Nós queremos aprender o código, então não vamos ver essas abas agora.

<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2007 The Android Open Source Project

http://www.apache.org/licenses/LICENSE-2.0

-->

<!-- Declara o conteúdo desse aplicativo Android. O atributo package
     é um identificador único do aplicativo. No seu aplicativo, use um
     domínio que você controle no lugar de "com.example.*". -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.android.skeletonapp">
    
    <uses-sdk android:targetSdkVersion="11"/>
    <!-- Esse pacote é um aplicativo. O label é o nome a ser exibido ao
         usuário. Deve ser uma referência para um resource string. -->
    <application android:label="@string/skeleton_app">

        <!-- Uma Activity no aplicativo - isso é alguma coisa que o
             usuário pode executar e interagir. O atributo name é o
             nome de uma classe do seu package que extenda a classe
             Activity do Android. -->
        <activity android:name="SkeletonActivity">

            <!-- Um IntentFilter informa ao sistema quando usar essa
                 Activity. Isso permite que outros aplicativos acessem
                 a sua Activity apenas sabendo o que ela faz, permitindo
                 "integrar" os aplicativos. -->
            <intent-filter>
                <!-- A ação MAIN descreve um ponto de entrada comum,
                     sem receber dados de outros aplicativos. -->
                <action android:name="android.intent.action.MAIN" />

                <!-- Isso coloca o ícone dessa Activity na lista de aplicativos. -->
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

        </activity>

    </application>

</manifest>

Essa é a sintaxe geral do arquivo AndroidManifest.xml. Quanto mais complexo for um aplicativo, mais complexo fica o arquivo, mas a sintaxe sempre será a mesma.

Talvez você já tenha percebido que eu falei bastante de uma tal de Activity e que eu disse pra você não esquecer desse nome. Bom, vamos ver porque: abra o arquivo src/com/example/android/skeletonapp/SkeletonActivity.java. Dessa vez sem abas, direto no código. Talvez você queira abrir também o layout do exemplo no arquivo res/layout/skeleton_activity.xml para acompanhar melhor a explicação.

/**
 * Copyright (C) 2007 The Android Open Source Project
 * http://www.apache.org/licenses/LICENSE-2.0
 */

package com.example.android.skeletonapp;

import android.app.Activity;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

/**
 * Essa classe mostra o básico de uma Activity do Android.
 */
public class SkeletonActivity extends Activity {

    static final private int BACK_ID = Menu.FIRST;
    static final private int CLEAR_ID = Menu.FIRST + 1;

    private EditText mEditor;

    public SkeletonActivity() {
    }

    /**
     * Método executado ao criar a Activity pela primeira vez.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Carrega o layout criado em XML (veremos mais sobre isso no próximo post)
        setContentView(R.layout.skeleton_activity);

        // Pega a referência para um editor de texto criado no layout
        mEditor = (EditText) findViewById(R.id.editor);

        // Define ações para os botões da tela
        ((Button) findViewById(R.id.back)).setOnClickListener(mBackListener);
        ((Button) findViewById(R.id.clear)).setOnClickListener(mClearListener);

        // Define o texto exibido inicialmente
        mEditor.setText(getText(R.string.main_label));
    }

    /**
     * Método executado quando a Activity está pronta para interagir com o usuário
     */
    @Override
    protected void onResume() {
        super.onResume();
    }

    /**
     * Método executado quando o menu de opções precisa ser criado.
     */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);

        // Cria dois menus.
        // O primeiro parâmetro é o grupo (no caso, nenhum)
        // O segundo é uma ID única para cada menu
        // O terceiro é a ordem de exibição dos itens (no caso, sem ordem)
        // O quarto é o texto exibido (definido em um resource de strings)
        // Define ainda um atalho para os itens (em dispositivos com Qwerty)
        menu.add(0, BACK_ID, 0, R.string.back).setShortcut('0', 'b');
        menu.add(0, CLEAR_ID, 0, R.string.clear).setShortcut('1', 'c');

        return true;
    }

    /**
     * Método chamando antes do menu de opções ser exibido.
     */
    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        super.onPrepareOptionsMenu(menu);

        // Exibe o item Limpar apenas se houver texto no editor.
        menu.findItem(CLEAR_ID).setVisible(mEditor.getText().length() > 0);

        return true;
    }

    /**
     * Método executado quando um item do menu de opções é selecionado.
     * Aqui é verificado qual item foi selecionado e a ação correspondente é executada.
     */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
        case BACK_ID:
            finish();
            return true;
        case CLEAR_ID:
            mEditor.setText("");
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

    /**
     * Quando o usuário pressionar o botão Voltar (Back)
     */
    OnClickListener mBackListener = new OnClickListener() {
        public void onClick(View v) {
            finish();
        }
    };

    /**
     * Quando o usuário pressionar o botão Limpar (Clear)
     */
    OnClickListener mClearListener = new OnClickListener() {
        public void onClick(View v) {
            mEditor.setText("");
        }
    };
}

Você pode executar esse exemplo clicando em Run > Run e, ao executar pela primeira vez, selecionando Android Application na janel Run As.

Skeleton App

Bom, espero que eu tenha conseguido explicar bem como é a estrutura básica de um app para Android usando esse exemplo simples. Principalmente, espero que vocês tenham entendido bem o que é e para que serve a Activity (se eu não fui muito claro, por favor deixe um comentário!). No próximo post vou mostrar um outro exemplo, dessa vez começando do zero. :D

Com as tags → 
Plataforma Wordpress Latest (GPLv2)
Tema PageLines Lite Improved (GPLv3)
Hospedado por OpenShift by RedHat
Domínio registrado pela Neep Host
Creative Commons Attribution-ShareAlike License
Copyleft © 2016 Eduardo Weiland
Utilize um leitor de QR Code para acessar o blog no seu celular:
21
%d blogueiros gostam disto: