Massami welington kamigashima


PROGRAmação JAVA para android



Baixar 5.43 Mb.
Página3/25
Encontro07.10.2019
Tamanho5.43 Mb.
1   2   3   4   5   6   7   8   9   ...   25

PROGRAmação JAVA para android


Como anteriormente citado, as aplicações desenvolvidas para a plataforma Android são escritas na linguagem Java. Entretanto, para se desenvolver estes aplicativos, é necessária a utilização do Android SDK, responsável por compilar o código e arquivos do projeto e armazená-los em um único “pacote”, um arquivo com extensão .apk que será responsável pela instalação da aplicação no dispositivo (ANDROID DEVELOPERS, 2011).

Pela preocupação na utilização de recursos nos dispositivos móveis, ao se tratar de desempenho nas aplicações para o Android, no qual pode implicar diretamente no consumo de bateria que a aplicação utilizará, segundo os desenvolvedores do Android, duas regras básicas devem ser seguidas: “Não faça trabalho desnecessário” e “Evite alocar memória se possível” (ANDROID DEVELOPERS, 2011).

Com base nas regras citadas acima, os desenvolvedores do Android consideram algumas formas de reduzir a utilização de recursos do aplicativo (ANDROID DEVELOPERS, 2011), sendo elas:


  1. evitar criar objetos desnecessários: variáveis temporárias de curta utilização devem ser evitadas, pois uma menor quantidade de objetos significa chamadas menos frequentes do Garbage Collector, reduzindo assim consideravelmente o consumo de memória;

  2. preferir o uso de métodos estáticos a virtuais: o uso de métodos estáticos tornam-nos de 15% a 20% mais rápidos;

  3. evitar o uso de getters e setters: a utilização destas funções são bastante difundidas na programação orientada a objetos, porém as chamadas destas funções são de um alto custo, muito maiores que as chamadas diretas de suas respectivas variáveis. É aceitável o uso das funções ao utilizar chamadas entre classes. Porém dentro de uma mesma classe, a variável deve ser sempre acessada diretamente, pois além do consumo de memória, o acesso a variáveis diretamente é três vezes mais rápida, ou até 7 vezes em sistemas com Just-In-Time4 (JIT);

  4. utilizar static final para constantes: a utilização do parâmetro final facilita o acesso ao valor da constante, pois ao invés de consultar uma tabela de constantes, o valor é diretamente acessado. Esta regra aplica-se somente para tipos primitivos como int e String;

  5. utilizar o loop For otimizado: aconselha-se o uso de for-each na interação de vetores, pois ele pode tornar o loop até três vezes mais rápido;

  6. conhecer e usar as bibliotecas: métodos da biblioteca do sistema podem ser melhores que o melhor método produzido pelo JIT para um equivalente escrito manualmente em Java.

Os aplicativos desenvolvidos para o Android contêm quatro principais componentes (ANDROID DEVELOPERS, 2011):

  1. atividades (activities): representa uma tela única de interface com o usuário. Cada atividade é independente das outras e outra aplicação pode chamá-la se a atividade permitir;

  2. serviços (services): representa um componente sem interface com o usuário que roda ocultamente para executar processos de longa duração ou remotos;

  3. provedores de conteúdo (content providers): gerenciador de dados da aplicação, controlando seu acesso ao banco de dados e se necessário, alterar dados do usuário;

  4. receptores de transmissão (broadcast receivers): este componente gerencia as notificações e alertas da aplicação, sendo utilizado para comunicar-se com outros aplicativos quando uma requisição for concluída.

Dos quatro componentes citados acima, o mais utilizado é a atividade pelo fato desta ser o componente responsável por exibir uma interface que permita ao usuário interagir. Uma aplicação pode conter apenas uma tela ou múltiplas, contidas em suas respectivas atividades. Cada atividade permite que seja chamada uma nova atividade que é colocada à frente da atual, sendo armazenado numa pilha de atividades, também conhecido como back-stack, conforme ilustra a Figura 3.


Fonte: Android Developers (2011).

Figura 3 - Representação da pilha de atividades

Cada atividade chamada antes da atual é armazenada na pilha guardando as variáveis disponíveis no momento e quando pressionado o botão back, a atividade atual é destruída e o conteúdo da atividade anterior é recuperado. Ao chamar uma nova atividade, a anterior é parada, eventos de mudança de estado são disparados, como o onPause(), e recomenda-se que ao mudar o estado da atividade os dados utilizados nesta atividade sejam gravados pois não há garantias que o usuário retorne a esta atividade. Sugere-se também que ao parar uma atividade, objetos grandes como conexões de rede ou bancos de dados, devem ser liberados e recuperados no momento que a atividade for restituída (ANDROID DEVELOPERS, 2011).

Um conjunto de atividades pode ser agrupado em tarefas, permitindo que esse conjunto possa ser movido para o plano de fundo quando pressionado o botão home sem que as atividades sejam destruídas. Ao mover a tarefa para o plano de fundo, os dados das atividades são armazenados e serão recuperados assim que o usuário retornar à aplicação. Porém, caso o desenvolvedor desejar que as informações da atividade atual sejam preservadas quando o usuário pressionar o botão back, será necessário armazená-las de alguma forma, nas quais os meios mais utilizados são armazenando na classe SharedPreferences, que permite armazenar dados de tipos primitivos como int, String, long entre outros, salvando no banco de dados sqllite, nativo do Android ou armazenando-os em um arquivo (ANDROID DEVELOPERS, 2011).

Os serviços são componentes que não necessitam de uma interface com usuário e podem rodar operações de longo prazo em plano de fundo. Um serviço iniciado pela aplicação continuará rodando mesmo após a aplicação perder o foco. Este componente costuma ser utilizado para gerenciar conexões, tocar músicas e comunicar com bancos e dados. Cada serviço, como os outros componentes, deve ser declarado no manifest e caso ele necessite utilizar um grande consumo de recursos, ele deverá ser criado em um thread separada para reduzir o risco de travar a aplicação (ANDROID DEVELOPERS, 2011).

Os provedores de conteúdo são os componentes responsáveis por efetuar a comunicação entre aplicações, permitindo integrar vários tipos de dados comuns, tais quais arquivos de áudio, vídeo, imagens, dados pessoais entre outros. Há duas formas de utilizar os provedores: criando um nova instância da classe ContentResolver, ou utilizando um provedor já existente desde que este seja de mesmo tipo e haja permissão de escrita (ANDROID DEVELOPERS, 2011).

Para se implementar uma Graphic User Interface (GUI) para a aplicação, utiliza-se derivados da classe View e ViewGroup. Cada View é responsável por uma região retangular na atividade e permite que o usuário interaja nesta região. A classe View contém subgrupos chamados widgets, objetos de interface como botões e campos de texto, enquanto o ViewGroup contém as subclasses de layouts, responsáveis por estruturar os componentes na tela (ANDROID DEVELOPERS, 2011).



quatro tipos principais de layouts: FrameLayout, LinearLayout, TableLayout e RelativeLayout.
      1. FrameLayout


O tipo mais simples de layout. É composto por um elemento que ocupa todo o espaço da tela e pode ser ocupado total ou parcialmente por somente um elemento, como uma imagem por exemplo. O objeto inserido neste layout sempre será fixo no canto superior esquerdo da tela, e novos objetos inseridos neste layout irão sobrepor os objetos anteriores.
      1. LinearLayout


Este layout alinha os componentes associados a ele na direção horizontal ou vertical dependendo de qual for o parâmetro definido na propriedade orientation. Cada elemento filho do layout é empilhado abaixo do elemento anterior. Este layout permite também que seus elementos tenham pesos diferenciados, permitindo assim que elementos com maior peso preencham um espaço maior na tela, como pode ser visto na Figura 4. A imagem da esquerda ilustra elementos sem peso definido, que por padrão o valor é zero, enquanto na imagem da direita, o campo de comentários tem um peso igual a 1 dando maior prioridade a ele. Caso o campo de nome também tivesse peso 1, os dois campos teriam o mesmo tamanho.

Fonte: Android Developers (2011).

Figura 4 - LinearLayout

      1. TableLayout


Este layout utiliza uma estrutura de tabela, dividido em linhas e colunas. Cada tabela irá possuir a quantidade de colunas igual à linha com o maior número de células dentro dela.

Cada linha deste layout é definido pelo objeto TableRow, que pode conter zero ou mais células e cada célula é definida por qualquer componente da classe View. O Quadro 1 demonstra o eXtensible Model Language (XML) que estrutura uma tabela simples contendo duas linhas e duas colunas, como pode ser visualizado na Figura 5.



xml version="1.0" encoding="utf-8"?>
xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:stretchColumns="1">
   
       
            android:text="@string/table_layout_4_open"
            android:padding="3dip" />
       
            android:text="@string/table_layout_4_open_shortcut"
            android:gravity="right"
            android:padding="3dip" />
   

   
       
            android:text="@string/table_layout_4_save"
            android:padding="3dip" />
       
            android:text="@string/table_layout_4_save_shortcut"
            android:gravity="right"
            android:padding="3dip" />
   

Fonte: Android Developers (2011).



Quadro 1 - Estrutura XML de um TableLayout

Fonte: Android Developers (2011).



Figura 5 - TableLayout
      1. RelativeLayout


O RelativeLayout permite que os componentes dispostos nele sejam posicionados em relação ao container ou a algum outro elemento pelo seu id. Caso seja utilizado um arquivo XML para determinar os elementos do layout, deve-se criar o elemento base antes do elemento que irá referenciá-lo. O Quadro 2 exemplifica uma estrutura simples de um layout relativo com quatro componentes básicos, como pode ser visto na Figura 6.

xml version="1.0" encoding="utf-8"?>
xmlns:android="http://schemas.android.com/apk/res/android
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:background="@drawable/blue"
                android:padding="10px" >

    android:id="@+id/label"
              android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:text="Type here:" />
    android:id="@+id/entry"
              android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:background="@android:drawable/editbox_background"
              android:layout_below="@id/label" />
    android:id="@+id/ok"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_below="@id/entry"
            android:layout_alignParentRight="true"
            android:layout_marginLeft="10px"
            android:text="OK" />
    android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_toLeftOf="@id/ok"
            android:layout_alignTop="@id/ok"
            android:text="Cancel" />

Fonte: Android Developers (2011).



Quadro 2 – Estrutura XML de um RelativeLayout

Fonte: Android Developers (2011).

Figura 6 – RelativeLayout





1   2   3   4   5   6   7   8   9   ...   25


©aneste.org 2017
enviar mensagem

    Página principal