domingo, 27 de setembro de 2015

Chamando Outros aplicativos de dentro de seu app

   Hoje resolvi escrever sobre como usarmos as Intents para chamar o browser de seu celular e como chamar o aplicativo de email.
   Primeiro criamos uma tela com duas caixas de texto e dois botões. O primeiro para a digitação da URL que será mostrada no browser e o segundo para abrir a tela de enviar email com o destinatário já preenchido.
   O objetivo com este post é aprender um pouco mais da utilidade da Intent e mostrar que o Android permite que a chamada de serviços do celular.
 


   Xml da Tela: 
   Do xml destaco a propriedade hint onde você coloca o texto que ficará no EditText antes do usuário digitar. destaco também a propriedade inputType onde setei o campo do email para este tipo para que o teclado ficasse com o @ já presente.
  
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    
        android:layout_width="match_parent"    
        android:layout_height="match_parent"    
        android:orientation="vertical"   >
  <EditText android:layout_width="match_parent"        
            android:layout_height="wrap_content"        
            android:hint="Digite a URL"        
            android:textSize="30sp"        
            android:id="@+id/edtUrl"        />
  <Button android:layout_width="match_parent"        
          android:layout_height="wrap_content"        
          android:text="Browser"        
          android:layout_gravity="center_vertical"        
          android:id="@+id/btnBrowser"
        />
  <EditText  android:layout_width="match_parent"        
             android:layout_height="wrap_content"        
             android:inputType="textEmailAddress"        
             android:hint="Digite o Destinatário"        
             android:textSize="30sp"        
             android:ems="10"        
             android:id="@+id/edtEmail" />
    <Button  android:layout_width="match_parent"        
             android:layout_height="wrap_content"        
             android:text="E-mail"        
             android:layout_gravity="center_vertical"        
             android:id="@+id/btnEmail"
        />

</LinearLayout>


   Código Java:

package br.com.nav.blog;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private EditText edtUrl;
    private EditText edtEmail;

    @Override    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //Tratando os botões da tela:        
        Button btnBrowser = (Button) findViewById(R.id.btnBrowser);
        btnBrowser.setOnClickListener(this);
        Button btnEmail = (Button) findViewById(R.id.btnEmail);
        btnEmail.setOnClickListener(this);
        //Tratando as caixas de texto da tela        
        edtUrl = (EditText) findViewById(R.id.edtUrl);
        edtEmail = (EditText) findViewById(R.id.edtEmail);
    }

    @Override    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btnBrowser:
                Uri uri = Uri.parse(edtUrl.getText().toString());
                Intent intent = new Intent(Intent.ACTION_VIEW, uri);
                try {
                    startActivity(intent);
                } catch (Exception erro) {
                    Toast.makeText(this,"Browser Não disponível/Endereço incorreto",Toast.LENGTH_SHORT).show();
                }
                break;
            case R.id.btnEmail:
                Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts(
                        "mailto",edtEmail.getText().toString(), null));
                startActivity(Intent.createChooser(emailIntent, "Send email..."));
                break;
        }
    }
}
   Chamando o browser:
   Primeiro é preciso gerar uma Uri. No caso pego o endereço web do edtUrl, digitado pelo usuário. Para isto utilizo a classe Uri e passo a mesma no construtor da Intent. A constante ACTION_VIEW é necessária para indicar que uma ação será executada.
   Agora basta chamar o método StartActivity.
   Para evitar mensagem de erro do celular, caso se digite um endereço errado, coloquei o trecho num try catch e capturei o erro utilizando para mostrar uma mensagem a classe Toast.   Detalhe: Se você digitar, neste exemplo, uma página válida mas sem o http ele falhará.
   
   Criando um email:
   Para o email o código muda um pouco. Aqui coloquei a constante ACTION_SENDTO e crio uma uri contendo o destinatário, digitado na tela, "mail to". Para iniciar o email lançamos a opção de escolha dos aplicativos de email que houver.
   Bom, espero ter ajudado.
   Até a próxima!
   

domingo, 20 de setembro de 2015

Android Básico: Transição entre telas


   No post de hoje mostraremos como capturar o evento de um botão, como chamar uma Activity a partir de outra, o uso do xml de strings e criação de novas telas além da padrão.
   Primeiro criamos uma tela com um botão centralizado na mesma. Não me preocupei com o layout mas apenas com a funcionalidade:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="horizontal"   >

    <Button        android:layout_width="match_parent"        android:layout_height="wrap_content"        android:text="@string/strNovatela"        android:layout_gravity="center_vertical"        android:id="@+id/btnNovaTela"
        />
</LinearLayout>
   
   O que mudei na tela que o android cria de padrão:
   Mudei o formato de RelativeLayout para LinearLayout.
  O LinearLayout trabalha com os componentes visuais seguindo uma determinada orientação: Horizontal ou vertical. Mudei para ele para mostrar que há outros tipos de layout além do RelativeLayout.
   Depois criei um botão e coloquei a largura para completar a tela toda. Coloquei um texto "Nova Tela" no campo text, depois explico pq está mostrando @string, e coloquei um identificador: btnNovaTela esse identificador será importante mais tarde. Perceba que para criar um identificador de um campo você atribui a propriedade id um valor que comece com "@+id".
 Ao final a tela ficou assim:
   


   Segundo Passo: Criar o código para capturar o botão e seu clique:
   Modifiquei a classe MainActivity que foi criada automaticamente pelo Android e a fiz implementar a interface View.OnClickListener, esta interface estabelece o método onClick de um objeto visual (View). Fazendo desta forma ficamos com um código menos poluído, pois uma outra forma seria criar uma classe inline do java.
   Feito isto capturamos o botão:
   Button btnNovaTela = (Button) findViewById(R.id.btnNovaTela);
   O método findViewById é responsável por recuperar o objeto do xml com o identificador passado no parametro. A classe R, guarda todos os ids criados e a usamos para recuperar o botão com o id btnNovaTela.
   Temos que fazer o cast para um objeto Button e agora podemos ter acesso aos métodos do botão.
   Próximo passo é indicar para o botão quem vai ser responsável por capturar seu click:
   btnNovaTela.setOnClickListener(this);
   No caso usamos nossa própria classe (this).
   Agora falta colocar o método para chamar nossa futura tela:
   Para chamar outra tela é muito simples:
   Utilizamos o objeto Intent para dizer ao Android que temos a intenção de chamar uma nova tela:
   Colocamos nossa classe como contexto e a tela a ser chamada no outro parâmetro e em  seguida executamos o startActivity. 
     Intent intent = new Intent(MainActivity.this,NovaTela.class);
   startActivity(intent);

   public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    @Override    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //Tratando o botão da tela:        
        Button btnNovaTela = (Button) findViewById(R.id.btnNovaTela);
        btnNovaTela.setOnClickListener(this);

    }


    @Override    public void onClick(View v) {
        //Se houvesse mais de um botão seria necessário colocar um switch  
      Intent intent = new Intent(MainActivity.this,NovaTela.class);
      startActivity(intent);
    }

   Criamos o código mas ainda falta criar a nova Activiy ou o código não compilará:
   Para criar a classe e o xml ao mesmo tempo o modo mais fácil é clicar em new, xml e após LayoutXml:
   


   


   Escolhi o mesmo nome que coloquei na classe anterior: NovaTela.
   Automaticamente o Android cria o xml da Activity e sua classe.
   Inclusive ele coloca a referência da mesma  no AndroidManifest:

    <activity  android:name=".NovaTela" android:label="@string/title_activity_nova_tela" >
    </activity>
    </application>
  
  Vamos a criação do xml da tela que aparecerá após o clique do botão:
   Modificamos o xml criado pelo Android para:
   <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="horizontal"    >


    <TextView        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:textAppearance="?android:attr/textAppearanceLarge"        android:text="CONSEGUIMOS!!"        android:id="@+id/textView"        />
</LinearLayout>
   
   A tela ficou assim:
   


   Agora o código está pronto, basta executar e quando você clicar o botão ele chamará a segunda tela. Não foi preciso modificar uma linha de código sequer da classe NovaTela.
   Antes que eu me esqueça segue como colocar os textos no xml de Strings:
   

   
   Quando você clica Alt + Enter em cima de um texto aparece a opção de extrair o mesmo para o xml de Strings. Depois basta dar um nome para o texto e ele grava automaticamente lá:
   


   Bom, por hoje é só.
   Até a próxima!


quarta-feira, 16 de setembro de 2015

Android: Telas adaptáveis à orientação do celular

   Quando você faz um aplicativo Android e rotaciona seu celular para a horizontal ele rotaciona a tela mas nem sempre ela fica ok.
   O mais indicado é fazer uma tela horizontal e outra vertical.
   Mas como fazer isto de forma que o sistema entenda qual tela chamar?
   Primeiro faça seu xml da tela nornalmente e depois:
   Clique com o botão direito na pasta layout e escolha new e layout resouce file:



   Em seguida se abrirá a seguinte tela:
   


   Existem diversas opções, mas a que nos interessa é a Orientation. Marque ela e clique nas setas para direita.
   Na próxima tela escolha o tipo de tela que você quer replicar. Exemplo, se você fez sua tela se baseado na orientação portrait (retrato), o que é mais comum, escolha landscape(paisagem) . Neste exemplo vou criar uma cópia da activity_main na horizontal.
   

   Escolhemos o mesmo nome e damos OK. O resultado é uma tela em modo paisagem. Agora teremos que replicar o código da tela original na nova. Utilize a poderosa ferramenta copiar e colar e depois adapte :)
   

   Uma coisa que percebi é um bug da ferramenta, quando você cria o novo layout você não enxerga os dois arquivos, portrait e landscape, e para você enxergar só fechando e abrindo o projeto novamente.
   Os arquivos ficam assim:
   

   É isto, nada complicado, mas teria que fazer o mesmo para cada tela que você queira personalizar o formato na horizontal.

domingo, 13 de setembro de 2015

Hello World Android: Parte 2

   Continuando o post anterior agora vamos observar o código gerado pelo Android Studio e aprender um pouco mais sobre o Android.
   Existem 3 pastas principais na estrutura da app:
   manifests - Onde se encontra o arquivo AndroidManifest.xml;
   java         - Onde ficam as classes java e
   res          -  pasta ondem ficam os recursos do app. Imagens, xmls, áudios, etc.




  Vamos analisar o app Hello World:


   Arquivo AndroidManifest.xml:

   Cuida das configurações do app:
   Pacote da aplicação, Activitys, permissões, etc.
   Como o aplicativo só tem uma activity, que nós escolhemos o nome na hora da criação do projeto, o preenchimento do arquivo foi autómatico.
   Vamos comentar alguns trechos:
   Dentro da cláusula application:
      android:icon="@mipmap/ic_launcher"  
-> Indica que o ícone do app está na pasta mipmap dentro da pasta res.

   android:label="@string/app_name"  
->indica que o nome do aplicativo consta no xml de strings que fica na past values:
   
Uma boa prática é centralizar todos os textos neste arquivo.
    android:theme="@style/AppTheme  
-> Indica qual estilo o app vai utilizar. O estilo também é guardado em um xml na pasta values.
  
A cláusula activity é reservada para as classes que tratarão das telas. No nosso caso a HelloWordActivity.
        android:name=".HelloWordActivity"   
-> Indica a classe que vai lidar com a tela.
      <action android:name="android.intent.action.MAIN" /> 
->Indica que esta activity    será o ponto de entrada da aplicação
      <category android:name="android.intent.category.LAUNCHER" /> 
-> indica que a activity vai aparecer na lista de aplicações do aparelho.

A tela:

O desenho da tela é feito através de arquivos xmls que devem ser gravados na subpasta de layouts da past res. No nosso caso foi criado o activity_helloo_word.xml:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:paddingLeft="@dimen/activity_horizontal_margin"    android:paddingRight="@dimen/activity_horizontal_margin"    android:paddingTop="@dimen/activity_vertical_margin"    android:paddingBottom="@dimen/activity_vertical_margin"    tools:context=".HelloWordActivity">

    <TextView 
        android:text="@string/hello_world"         android:layout_width="wrap_content"        android:layout_height="wrap_content" />
</RelativeLayout>

   Relative Layout - Tipo de Layout do Android que permite o posicionamento relativo entre os objetos.
   match_parent -    Indica o preenchimento do espaço total da tela na dimensão setada. No caso ele é utilizado para dizer que o Relative Layout vai ocupar a tela completana largura e na altura.
   TextView  -  Objeto que se comporta como um label. Apenas exibe um texto e não permite a entrada de dados pelo usuário.
   Percebam que o texto Hello World também está contido no xml de Strings.
   O resultado é visto na tela:
   

Código Java

E o código java?
Até agora só configuramos xmls.
Muito de nosso trabalho em android é assim mesmo, mas ainda é preciso codificar.
Vamos ao código:
A classe gerada foi a HelloWorldActivity. Peguei o trecho de código que importa no momento:
public class HelloWordActivity extends AppCompatActivity {

    @Override    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_hello_word);
    }
   
   Esta é uma classe comum do java que herda de uma classe do Android chamada AppCompatActivity para manter a commpatibilidade com as versões mais antigas do Android.
   O método que interessa é o onCreate, como o próprio nome indica, ele é chamado na criação do objeto.
   Ele chama o onCreate de sua classe mãe e logo depois o método:
   setContentView - Este método é responsável por receber um xml e exibi-lo para o usuário. Como entrada ele está recebendo nosso xml a partir da classe R.
   A classe R é A classe do Android. E através dela que você pode ter acesso ao conteúdo das subpastas da pasta res, ou seja, strings, xmls de telas, etc.
   Nossa activity, constante da pasta de layouts é acessada com o um recurso da classe R.
   R.layout.activity_hello_word - > Procure na pasta layout o arquivo activiy_hello_world.

   É isto, não vou fazer um curso de Android, até porque não me sinto preparado para isto, ainda, mas vou postar algumas descobertas neste blog.
   

sábado, 12 de setembro de 2015

Hello World Android

Hello World Android

   Primeiro Abra o Android Studio e escolha a opção "start a new Android Project":

   Na próxima tela Escolha o nome do aplicativo, no caso Hello_World e o domínio de sua empresa, no caso escolhi exemplo.com.br ele, automaticamente, transforma o nome do pacote para br.com.exemplo.hello_world:


   Na próxima tela você deve escolher para sdk mínimo seu aplicativo vai funcionar, se o aplicativo vai funcionar para TV, android auto ou apenas para celular. Como vamos tratar de um Hello World deixe tudo padrão e aperte o next:

   Escolha a opção "Blank Activity" na próxima tela:
   


   E finalmente você deve escolher o nome da sua Activity, escolhi HelloActivity e apertei o "Finish"



   Pronto, projeto criado o resultado é um projeto com uma Activity Contendo um texto "Hello World":
   

   Clique no botão Run e aparecerá a tela para escolher onde o aplicativo irá rodar. Se houver algum emulador  ou aparelho rodando ele aparecerá na opção "Choose a running device". No meu caso escolhi a opção "Launch emulator" que abrirá o emulador do android. Como meu computador tem um bom processador eu consigo utilizar o emulador nativo com muita rapidez. Caso vocês queiram utilizar o Genymotion sigam o tutorial da Techmundo: http://www.techtudo.com.br/dicas-e-tutoriais/noticia/2013/12/veja-como-emular-o-android-no-computador-com-o-genymotion.html
    
  
   
   O Android compila o código e instala o aplicativo no emulador. O emulador funciona como um celular com um determinada versão do android instalada. Você consegue simular muitas coisas nele.:
   


   Desbloqueie o emulador e nosso app e aparecerá nosso primeiro app:
   

   Foi o Hello World mais fácil de sua vida :).
   Como o post ficou muito grande vou parar aqui e no próximo explico a estrutura do código gerado automaticamente e algumas teorias básicas de como criar as telas (Activitys), onde ficam as classes java, etc.
   Até lá!

quarta-feira, 9 de setembro de 2015

Android: Como começar?

   Android: Como começar?

   Primeiro é bom deixar claro que saber java é muito importante para poder programar para Android, se você não sabe é necessário estudar a linguagem.
   Dito isto vamos ao próximo passo: Ambiente de desenvolvimento:
   É possível desenvolver para Android utilizando o Eclipse, mas o Google disponibilizou o Android Studio que está se mostrando um ambiente muito produtivo de desenvolvimento e a o ambiente em que eles dão suporte e atualizam com frequência.
   Para baixar o Android Studio vá ao site: Baixar Android Studio.
   Existem versões para Windows, Mac, Linux.
   A instalação é simples e existem diversos sites que ensinam como fazer.
   
   Além  do Android Studio é importante ter um emulador para testar seus aplicativos, o Android Studio já vem com um nativo, mas se sua máquina não for muito boa ele ficará lento. Com isto muitos usam emuladores alternativos, como por exemplo o Genymotion. Ele é um emulador gratis para uso pessoal e muito leve e rápido. Baixe aqui.
  Pronto, tudo instalado é por em prática.
  No próximo post farei um Hello World de exemplo!
  

terça-feira, 8 de setembro de 2015

Android

   Vou começar falando um pouco de Android.
   Android é um sistema operacional desenvolvido inicialmente para dispositivos móveis. Mas está se espalhando para eletrodomésticos como Televisão, relógios inteligentes e até automóveis.
   Ele é baseado no kernel do Linux.
   Mantido como projeto open source pela Open Hanset Alliance, composta por 84 empresas:  Dentre elas: Motorola, LG, Toshiba, Telefônica, Intel e até a Google .  :)
   A proposta é que o Android seja o mais livre e adaptável possível
   Cada empresa pode utilizar o Android puro ou adaptá-lo conforme sua necessidade.
   A linguagem para desenvolvimento Android é o java mas já há rumores de que o Google estaria pensando em utilizar a linguagem GO como substituta.
   Para rodar os aplicativos nos dispositivos existe uma máquina virtual Dalvik ou DVM que transforma o bytecode de seu aplicativo no formato .dex.
   Também há boatos de que o Google quer substituir a DVM pela ART, Andorid Runtime. Em algumas versões do Android já é possível escolher qual das duas maquinas utilizar.
 

segunda-feira, 7 de setembro de 2015

Apresentação

Apresentação


   Sou formado em Ciências da Computação pela Universidade Federal de Alagoas e saindo do curso gostei da área de desenvolvimento de sistemas e me dediquei a mesma. 
   Programo desde 1994, ano que comecei meu curso e de lá para cá já programei em:
   Pascal, C, C++, java, Visual Basic, Delphi, Natural/Adabas que eu me lembre :).
   Procurarei utilizar este blog para assuntos de programação e tecnologia.
   Bem vindos e até a próxima!