lunes, 28 de mayo de 2012

Proyecto de Dispositivos Móviles



Presentación



Funcionamiento
Diagrama Arquitectonico:


Consumo de energía y paralelismo:

La aplicación no cuenta con paralelismo y el consumo de energía es el siguiente:





Imágenes de la interfaz:


Sensor de flujo de agua:




Sensor conectado al arduino

Lo que nos marca en el Serial  Monitor, para ver el cambio en el flujo se puede sopplar en este =)





 


Código de Processing en donde se realizo la interfaz, este código muestra los dispositivos bluetooth que se encuentran alrededor y seleccionamo con el q trabajaremos:
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import java.util.ArrayList;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
 
private static final int REQUEST_ENABLE_BT = 3;
ArrayList dispositivos;
BluetoothAdapter adaptador;
BluetoothDevice dispositivo;
BluetoothSocket socket;
InputStream ins;
OutputStream ons;
boolean registrado = false;
PFont f1;
PFont f2;
int estado;
String error;
byte valor;
PImage logo;
PImage imagen1;
PImage imagen2;
PImage imagen3;
PImage imagen4;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BroadcastReceiver receptor = new BroadcastReceiver()
{
    public void onReceive(Context context, Intent intent)
    {
        println("onReceive");
        String accion = intent.getAction();
 
        if (BluetoothDevice.ACTION_FOUND.equals(accion))
        {
            BluetoothDevice dispositivo = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            println(dispositivo.getName() + " " + dispositivo.getAddress());
            dispositivos.add(dispositivo);
        }
        else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(accion))
        {
          estado = 0;
          println("Empieza búsqueda");
        }
        else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(accion))
        {
          estado = 1;
          println("Termina búsqueda");
        }
 
    }
};
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  //size(320,480);
  frameRate(25);
  f1 = createFont("Arial",20,true);
  f2 = createFont("Arial",15,true);
  stroke(255);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void draw() {
  switch(estado)
  {
    case 0:
      listaDispositivos("BUSCANDO DISPOSITIVOS", color(255, 0, 0));
      break;
    case 1:
      listaDispositivos("ELIJA DISPOSITIVO", color(0, 255, 0));
      break;
    case 2:
      conectaDispositivo();
      break;
    case 3:
      muestraDatos();
      break;
    case 4:
      muestraError();
      break;
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onStart()
{
  super.onStart();
  println("onStart");
  adaptador = BluetoothAdapter.getDefaultAdapter();
  if (adaptador != null)
  {
    if (!adaptador.isEnabled())
    {
        Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
    }
    else
    {
      empieza();
    }
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onStop()
{
  println("onStop");
  /*
  if(registrado)
  {
    unregisterReceiver(receptor);
  }
  */
 
  if(socket != null)
  {
    try
    {
      socket.close();
    }
    catch(IOException ex)
    {
      println(ex);
    }
  }
  super.onStop();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onActivityResult (int requestCode, int resultCode, Intent data)
{
  println("onActivityResult");
  if(resultCode == RESULT_OK)
  {
    println("RESULT_OK");
    empieza();
  }
  else
  {
    println("RESULT_CANCELED");
    estado = 4;
    error = "No se ha activado el bluetooth";
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mouseReleased()
{
  switch(estado)
  {
    case 0:
      /*
      if(registrado)
      {
        adaptador.cancelDiscovery();
      }
      */
      break;
    case 1:
      compruebaEleccion();
      break;
    case 3:
      muestraDatos();
      break;
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void empieza()
{
    dispositivos = new ArrayList();
    /*
    registerReceiver(receptor, new IntentFilter(BluetoothDevice.ACTION_FOUND));
    registerReceiver(receptor, new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_STARTED));
    registerReceiver(receptor, new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED));
    registrado = true;
    adaptador.startDiscovery();
    */
    for (BluetoothDevice dispositivo : adaptador.getBondedDevices())
    {
        dispositivos.add(dispositivo);
    }
    estado = 1;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void listaDispositivos(String texto, color c)
{
  background(0);
  textFont(f1);
  fill(c);
  text(texto,0, 20);
  if(dispositivos != null)
  {
    for(int indice = 0; indice < dispositivos.size(); indice++)
    {
      BluetoothDevice dispositivo = (BluetoothDevice) dispositivos.get(indice);
      fill(255,255,0);
      int posicion = 50 + (indice * 55);
      if(dispositivo.getName() != null)
      {
        text(dispositivo.getName(),0, posicion);
      }
      fill(180,180,255);
      text(dispositivo.getAddress(),0, posicion + 20);
      fill(255);
      line(0, posicion + 30, 319, posicion + 30);
    }
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void compruebaEleccion()
{
  int elegido = (mouseY - 50) / 55;
  if(elegido < dispositivos.size())   
  {     
    dispositivo = (BluetoothDevice) dispositivos.get(elegido);     
    println(dispositivo.getName());     
    estado = 2;   
  } 
} 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
void conectaDispositivo() 
{   
  try   
  {     
    socket = dispositivo.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
    /*|     
      Method m = dispositivo.getClass().getMethod("createRfcommSocket", new Class[] { int.class });     
      socket = (BluetoothSocket) m.invoke(dispositivo, 1);             
    */     
    socket.connect();     
    ins = socket.getInputStream();     
    ons = socket.getOutputStream();     
    estado = 3;   
  }   
  catch(Exception ex)   
  {     
    estado = 4;     
    error = ex.toString();     
    println(error);   
  } 
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
void muestraDatos() 
{   
  try
  {     
    while(ins.available() > 0)
    {
      valor = (byte)ins.read();
    }
  }
  catch(Exception ex)
  {
    estado = 4;
    error = ex.toString();
    println(error);
  }
  background(0);
  fill(255);
  text("Flujo Actual: ",(width / 2)-150,height / 2);
  text(valor, width / 2, height / 2);
  text(" Litros/Hora", (width / 2)+20, height / 2);
  
  //stroke(255, 255, 0);
  //fill(255, 0, 0);
  //rect(120, 400, 80, 40);
  //fill(255, 255, 0);
  //text("Botón", 135, 425);
  logo= loadImage ("riego1.png");
   image(logo,10,10); 
  imagen1= loadImage ("riego2.png");
   image(imagen1,10,10);
  imagen2= loadImage ("riego3.png");
   image(imagen2,10,10);  
  imagen3= loadImage ("riego4.png");
   image(imagen3,10,10);  
   imagen4= loadImage ("riego5.png");
   image(imagen4,10,10); 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//void compruebaBoton()
//{
  //if(mouseX > 120 && mouseX < 200 && mouseY > 400 && mouseY < 440)
  //{
    //try
    //{
      //  ons.write(0);
    //}
    //catch(Exception ex)
    //{
      //estado = 4;
      //error = ex.toString();
      //println(error);
    //}
  //}
//}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void muestraError()
{
  background(255, 0, 0);
  fill(255, 255, 0);
  textFont(f2);
  textAlign(CENTER);
  translate(width / 2, height / 2);
  rotate(3 * PI / 2);
  text(error, 0, 0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Código que cargamos al arduino en donde nos muestra el flujo de agua y hace posible la conexión al bluetooth

int val = 0;     // variable
#include 
#define RxD 6
#define TxD 7
 
#define DEBUG_ENABLED  1
 
SoftwareSerial blueToothSerial(RxD,TxD);
volatile int NbTopsFan; //measuring the rising edges of the signal
int Calc;                               
int hallsensor = 2;    //The pin location of the sensor
 
void rpm ()     //This is the function that the interupt calls 
{ 
  NbTopsFan++;  //This function measures the rising and falling edge of the 
 
//hall effect sensors signal
} 
 
void setup() 
{ 
  Serial.begin(9600);
  pinMode(RxD, INPUT);
  pinMode(TxD, OUTPUT);
  pinMode(13, OUTPUT);
  setupBlueToothConnection(); 
  pinMode(hallsensor, INPUT); //initializes digital pin 2 as an input
  attachInterrupt(0, rpm, RISING);
} 
 
void loop() 
{ 
  NbTopsFan = 0;   //Set NbTops to 0 ready for calculations
  sei();      //Enables interrupts
  delay (1000);   //Wait 1 second
  cli();      //Disable interrupts
  Calc = (NbTopsFan * 60 / 7.5); //(Pulse frequency x 60) / 7.5Q, = flow rate 
  
Serial.print(Calc);
Serial.print("\n");
  char recvChar;
  
    if(blueToothSerial.available() > 0){
      blueToothSerial.write(Calc) ;
      {int val = blueToothSerial.read(); }//check if there's any data sent from the remote bluetooth shield
      recvChar = blueToothSerial.read();
      Serial.print(recvChar);
      {recvChar = Serial.read();}
      {val = blueToothSerial.read();}
       // read value coming in from phone
       if(isDigit(val));{   // 
         digitalWrite(13, HIGH);
         delay(100);
         digitalWrite(13, LOW);}         
  
}
}
void setupBlueToothConnection()
{
  blueToothSerial.begin(38400); //Set BluetoothBee BaudRate to default baud rate 38400
  blueToothSerial.print("\r\n+STWMOD=0\r\n"); //set the bluetooth work in slave mode
  blueToothSerial.print("\r\n+STNA=Blanka\r\n"); //set the bluetooth name as "Bluebot"
  blueToothSerial.print("\r\n+STOAUT=1\r\n"); // Permit Paired device to connect me
  blueToothSerial.print("\r\n+STAUTO=0\r\n"); // Auto-connection should be forbidden here
  delay(2000); // This delay is required.
  blueToothSerial.print("\r\n+INQ=1\r\n"); //make the slave bluetooth inquirable 
  Serial.println("Bluebot is ready for your command!");
  delay(2000); // This delay is required.
  blueToothSerial.flush();
}
 Código del sensor de flujo de agua:
volatile int NbTopsFan; //measuring the rising edges of the signal
int Calc;                               
int hallsensor = 2;    //The pin location of the sensor
 
void rpm ()     //This is the function that the interupt calls 
{ 
  NbTopsFan++;  //This function measures the rising and falling edge of the 
 
//hall effect sensors signal
} 
// The setup() method runs once, when the sketch starts
void setup() //
{ 
  pinMode(hallsensor, INPUT); //initializes digital pin 2 as an input
  Serial.begin(9600); //This is the setup function where the serial port is initialised,
  attachInterrupt(0, rpm, RISING); //and the interrupt is attached
} 
// the loop() method runs over and over again,
// as long as the Arduino has power
void loop ()    
{
  NbTopsFan = 0;   //Set NbTops to 0 ready for calculations
  sei();      //Enables interrupts
  delay (1000);   //Wait 1 second
  cli();      //Disable interrupts
  Calc = (NbTopsFan * 60 / 7.5); //(Pulse frequency x 60) / 7.5Q, = flow rate 
 
//in L/hour 
  
}


Sensor de humedad:



 Probado el en Serial Monitor de arduino:

Sensor en tierra con agua:



Sensor fuera de la planta:


 Código del sensor de humedad:


void setup()
{
  Serial.begin(9600);
}
void loop()
{
  Serial.print(analogRead(0));
  Serial.print("\n");
}

domingo, 20 de mayo de 2012

Tercer programa en Android:

En esta entrada realizaremos una entrada en la cual el usuario podra ingresar dos números y seleccionar el botón de sumar para que nos despliegue el resultado:

  • Mostraremos un mensaje que pida los valores en 2 TextView
  • Realizaremos la carga de los numeros en controles de tipo EditText
  • Un Button para sumar los valores 
  •  Otro TextView pra mostrar el resutado
Paso 1: Crear nuevo projecto

Creamos un nuevo Proyecto Android en eclipse (este paso ya fue mencionado en la entrada pasada).

Paso 2: Comenzar con la interfaz

Para crear la interfaz nos vamos al main.xml y borramos elTextView que nos aparece.

Seleccionamos los componentes que nos queden de esta manera (recuerden que la manera en la que se ponen es arrastrandolos a la pantalla, esto también se menciono en la entrada anterior):

2.1 Seleccionamos el primer TextView desde la ventana "Palette" seleccionamos de la pestaña "Form Widgets" el control "TextView" y lo arrastramos a la ventana de diseño de nuestra interfaz y le cambiamos el mensaje dando clic de lado derecho y seleccionando Edit Text...

Como ven esta es la pantalla que nos muestra abajo es donde cambiaremos el nombre yo en mi caso le pondre "Ingrese el primer valor" y le damos OK:





Vemos que cambia el Texto y ahora se nos muestra de esta manera:


También especificaremos el ID  seleccionando el TextView y dandole clic derecho escogiendo el Edit ID, nos saldra una pantalla donde pondremos el nombre del ID en este caso "texto1" y después seleccionamos OK:



 2.2 Ahora de la paleta de componentes seleccionamos la pestaña "Text Fields" seleccionamos el primero:




Y lo arrastramos a la pantalla y queda de la siguiente manera:


Ahora al igual que el anterior configuramos el ID de la misma manera pero en este caso el ID sera "numero1".

2.3 Reaizamos los mismos pasos para el otro TextView(ID="texto2") y el EditVIew(ID=numero2).


2.4  Arrastramos un "Button" de la pestaña "Form Widgets:





 Editamos su propiedad texto y lo cambiamos por "Sumar":

2.5 Para finalizar arrastramos el ultimo TextView y le ponemos con la propiedad Text "Resultado" y asi no queda nuestrainterfaz completa:

o


 3 Capturar eventos Ahora vamos a trabajar con la parte lógica del programa, nos vamos al programa en java en mi caso Sumar_NumeroActivity.java y el código que tenemos al iniciar es el siguiente:

package com.Numeros;

import android.app.Activity;
import android.os.Bundle;


public class Sumar_NumeroActivity extends Activity {
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);  
    }
  
    
}
3.1 Definimos las dos variables de tipo EditText y TextView importando el paquete android.widget para poder definirlas:
package com.Numeros;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.EditText;

public class Sumar_NumeroActivity extends Activity {
 private EditText numero1, numero2;
 private TextView texto3; 
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
     
    }
   
}
3.2 Enlazamos las variables anteriormente declaradas con los objetos definidos en el archivo XML, con el método findViewById:
package com.Numeros;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.EditText;

public class Sumar_NumeroActivity extends Activity {
 private EditText numero1, numero2;
 private TextView texto3; 
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        numero1=(EditText)findViewById(R.id.numero1);
        numero2=(EditText)findViewById(R.id.numero2);
        texto3= (TextView)findViewById(R.id.texto3);
        
    }
    
}
Recordemos que debemos pasar las constantes creadas ala clase R. 3.3 Ahora el método que se ejecutará cuando se presione el botón (el método debe recibir como parámetro un objeto de la clase View) En nuestro ejemplo lo llamé sumar y hay que agregarle el paquete android.view.View para que funcione:
package com.Numeros;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.EditText;
import android.view.View;


public class Sumar_NumeroActivity extends Activity {
 private EditText numero1, numero2;
 private TextView texto3; 
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        numero1=(EditText)findViewById(R.id.numero1);
        numero2=(EditText)findViewById(R.id.numero2);
        texto3= (TextView)findViewById(R.id.texto3);
        
    }
    //método que se ejecutara cuando se precione el botón view sumar
   public void sumar(View view) {
  
    }
    
}
3.4 Nos dirigimos al archivo main.xml y le cambiamos la propiedad onClick albotón "sumar":


Asignamos "sumar":



3.5 Ahora sumamos los dos valores ingresados en los controles EditText:
package com.Numeros;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.EditText;
import android.view.View;


public class Sumar_NumeroActivity extends Activity {
 private EditText numero1, numero2;
 private TextView texto3; 
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        numero1=(EditText)findViewById(R.id.numero1);
        numero2=(EditText)findViewById(R.id.numero2);
        texto3= (TextView)findViewById(R.id.texto3);
        
    }
    //método que se ejecutara cuando se precione el botón view sumar
   public void sumar(View view) {
    String valor1=numero1.getText().toString();
    String valor2=numero2.getText().toString();
    int nro1=Integer.parseInt(valor1);
    int nro2=Integer.parseInt(valor2);
    int suma=nro1+nro2;
    String resu=String.valueOf(suma);
    texto3.setText(resu);
    }
    
}


Hemos términado al fin  =) ahora probamos la aplicación :


Segundo programa en Android

Realizaremos una aplicación en donde te va a decir Hola y tu tecleras tu nombre y te saldra Hola [nombre].

Abrimos eclipse y lo que haremos es modificar el proyecto que realizamos en la entrada anterior, por el momento solo le quitamos el nombre que le pusimos y la carita feliz en el string primero, el código era el siguiente:

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="hello">Escribe tu nombre</string>
    <string name="app_name">Hola </string>

</resources>


Lo primero que haremos sera modificar la pantalla principal en donde modificaremos la que nos creo eclipse al momento de crear el proyecto, recuerden que en el primer programa que realizamos solo le cambiamos el saludo o mensaje que nos desplegaba.

 En Android, el diseño y la lógica de una pantalla estan separados en dos ficheros distintos. Por un lado, en el fichero /res/layout/main.xml tendremos el diseño puramente visual de la pantalla definido como fichero XML y por otro lado, en el fichero /src/paquetejava/PrimeraAplicación.java, encontraremos el código java que determina la lógica de la pantalla.


Primer pantalla

Primero que nada entraremos al main pero en lapestaña de Graphical Layout para poner algunos botones, sera una interfaz grafica pequeña:



Ahora seleccionaremos los componentes que utilizaremos del siguiente menú:


Y de lado derecho nos aparece como se veria la interfaz y como se ve hasta el momento:




 Ocupamos un TextView del submenu Text Fields en este caso el primero:





 Para poder ponerlo en nuestro proyecto lo unico que tenemos que hacer es arrastrarlo de lado derecho a la pantalla del celular que mostramos anteriormente.

Ya arrastrado se nos muestra de la siguiente manera:



Ahora seleccionamos un button del siguiente menu:


Y realizamos lo mismo arrastramos el Button y queda asi:



Ahora nos checamos en pestaña main.xml y vemos el código y ahi se inserto lo que pusimo:




En este XML se definen los elementos visuales que componen la interfaz de nuestra pantalla principal y se especifican todas sus propiedades.

Código XML realizando los cambios necesarios para después realizar la lógica:

<?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" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" /> 

    <EditText
        android:id="@+id/TxtNombre"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10" >

        <requestFocus />
    </EditText>

    <Button
        android:id="@+id/buttonHola"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/Enviar" />

</LinearLayout>


Quedara asi:



Como vemos primero que nos encontramos es un elemento LinearLayout. Los layout son elementos no visibles que determinan cómo se van a distribuir en el espacio los controles que incluyamos en su interior. Los programadores java, y más concretamente de Swing, conocerán este concepto perfectamente. En este caso, un LinearLayout distribuirá los controles uno tras otro y en la orientación que indique su propiedad android:orientation.

Dentro del layout hemos incluido 3 controles: una etiqueta (TextView), un cuadro de texto (EditText), y un botón (Button). En todos ellos hemos establecido las siguientes propiedades:
  • android:id. ID del control, con el que podremos identificarlo más tarde en nuestro código.
  • android:text. Texto del control.
  • android:layout_height y android:layout_width. Dimensiones del control con respecto al layout que lo contiene.

Ahora ya tenemos definida la presentación visual de nuestra ventana principal de la aplicación.

Segunda pantalla

Después crearemos la interfaz de la segunda pantalla para poder hacer esto nos vamos al menu File--> New-->Other y nos saldra una ventana en la cual seleccionaremos  Android XML Layout File




 Nos aparecerá una pantalla en la que debemos indicar el tipo de archivo que crearemos y el nombre del mismo, en mi caso le di el nombre de msj y le damos finalizar:





Ahora vemos que ya nos sale en layout:



También ya vemos que nos sale de lado derecho para crear la interfaz.



En esta pestaña solo agregamos un TexView








Ynos genero este código xml dode ya lo arreglamos para la lógica:




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

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="$mensaje" />

</LinearLayout>



Ya que tenemos la interfaz definida de las dos pantallas de nuestra aplicación, ahora nos toca implementar lalógica de esta misma, se definira en ficheros java independientes, para la pantalla principal ya tenemos creado un fichero por defecto llamado PrimeraAplicacion.java. la cual el código es el siguiente:


package com.Hola;

import android.app.Activity;
import android.os.Bundle;

public class PrimeraAplicacion extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
    
}
Las diferentes pantallas de una aplicación Android se definen mediante objetos de tipo Activity. Lo primero que encontramos en nuestro fichero java es la definición de una nueva clase PrimeraAplicacion que extiende a Activity. El único método que sobreescribiremos de esta clase será el método OnCreate, llamado cuando se crea por primera vez la actividad. En este método lo único que encontramos en principio, además de la llamada a su implementación en la clase padre, es la llamada al método setContentView(R.layout.main). Con esta llamada estaremos indicando a Android que debe establecer como interfaz gráfica de esta actividad la definida en el recurso R.layout.main, que no es más que la que hemos especificado en el fichero /res/layout/main.xml. vamos a crear una nueva actividad para la segunda pantalla de la aplicación análoga a ésta primera, para lo que crearemos una nueva clase Mensaje que exienda de Activity y que implemente el método onCreate indicando que utilice la interfaz definida en R.layout.frmmensaje. Para crear la clase nos vamos al menu Fule-->New-->Class y se nos abrira la siguiente ventan en donde ponemos el nombre de nuestra clase Mensaje y le damos finalizar:



Nos crea la clase y genera este código


package com.Hola;

import android.app.Activity;

public class Mensaje extends Activity {

}

Ahora lo modificaremos a lo siguiente:
package com.Hola;

import android.app.Activity;
import android.os.Bundle;

public class Mensaje extends Activity {
 /** Called when the activity is first created. */
 @Override
 public void onCreate(Bundle savedInstanceState){
  super.onCreate(savedInstanceState);
  setContentView(R.layout.msj);
}
}



El código incluido por defecto en estas clases lo único que hace es generar la interfaz de la actividad. Ahora nosotros tendremos que incluir el resto de la lógica de la aplicación. Comenzamos con la actividad principal PrimeraAplición obteniendo una referencia a los diferentes controles de la interfaz que necesitemos manipular, en nuestro caso sólo el cuadro de texto y el botón. Para ello utilizaremos el método findViewById() indicando el ID de cada control, definidos como siempre en la clase R:

sábado, 19 de mayo de 2012

Componentes de una aplicación Android



Cualquier aplicación en Adroid se compone de 4 componentes  cada uno de los cuales existe como una entidad propia y desempeña un papel específico; cada elemento es una pieza única que ayuda a definir el comportamiento general de la aplicación.

 Algunos de estos elementos son el punto de entrada para que los usuarios interactúen con la aplicación y algunos elementos dependen de otros.

Cada componente  tiene un propósito y un ciclo de vida distinto que define cómo se crea y se destruye el componente.

Los componentes son:

  • Activities (actividades)
  • Intents (intenciones)
  • Content providers (proveedores de contenido) 
  • Services (servicios) 
  
Activities (actividades)

Las actividades (activities) representan el componente principal de la interfaz gráfica de una aplicación Android.

La mayoría del codigo ejecutable que se escribe para Android sera ejecutado en el contexto de Actividad. Las Actividades usualmente corresponde a pantallas en el display: cada Actividad mostrara una pantalla a el usuario.

Las aplicaciones constan de una o más actividad y cada una de ellas es responsable de guardar su estado.

Se encarga de:
  • Crea una ventana donde se coloca una interfaz
  • Gestiona la interfaz
  • Responde a los eventos
Estados de una actividad:
  • Activa: la actividad esta en primer plano y tiene el focus (enfoque de usuario). Esta se encuentra en lo alto de la pila.
  • En pausa: la actividad es visible pero no tiene el focus.
  • Detenida: la actividad esta tapada por otra aplicación.
  • Destruida: una actividad detenida ha sido destruida  para liberar memoria y ha perdido sus datos. Se tiene que recrear completamente
Ciclo de una actividad

Toda actividad pasa por los estados anteriores, los cuales se pueden ver,  junto con los métodos que se ejecutarán entre cada cambio de estado, en la siguiente imagen:



Los métodos más importantes de la clase Activity son los siguientes:
  1. onCreate(): Es llamado cuando se crea la actividad, aquí generalmente se inicializan las variables de la clase, enlazando los componentes de la interfaz.
  2. onStart(): Para que la actividad se visualice.
  3. onResume(): Se llama cuando la actividad empieza a interactuar con el usuario, la actividad se encuentra en la pila de actividades del sistema.
  4. onPause(): Este método se llama cuando el sistema está a punto de iniciar una actividad anterior, se suele guardar datos importantes para la aplicación y parar tareas que consuman CPU, este debe ser sencillo puesto que la siguiente aplicación no comenzará hasta que este no acabe.
  5. onStop(): Cuando otra actividad se invoca y la actual debe permanecer en segundo plano un tiempo determinado y luego volver a utilizarse.
  6. onRestart(): Cuando la actividad, que se encontraba en segundo plano, vuelve a utilizarse.
  7. onDestroy():  Se utiliza para matar a la actividad, debido a que la misma ya no es necesaria.
  8. onSaveInstanceState (Bundle): la actividad puede guardar su estado. 
  9. onRestoreInstanceState (Bundle): recupera el estado guardado por el anterior metodo. 

Toda actividad se inicia como respuesta a un Intent.



Intents (intenciones)

Son los mensajes del sistema que se encuentran corriendo en el interior del dispositivo. Un intent es el elemento básico de comunicación entre los distintos componentes Android. Se pueden entender como los mensajes o peticiones que son enviados entre los distintos componentes de una aplicación o entre distintas aplicaciones.

Mediante un intent se puede mostrar una actividad desde cualquier otra, iniciar un servicio, enviar un mensaje broadcast, iniciar otra aplicación, etc.

Ejemplos de Intent:
  • ANSWER_ACTION
  • CALL_ACTION
  • DELETE_ACTION
  • DIAL_ACTION
  • EDIT_ACTION
  • FACTORY_TEST_ACTION
  • GET_CONTENT_ACTION
  • INSERT_ACTION
  • MAIN_ACTION: inicio de la aplicación.
  • PICK_ACTION: permite a otras apps elegir contenido de la tuya.
  • VIEW_CONTENT: para ver contenido.
  • EDIT_CONTENT: para editar contenido.
 
Content providers (proveedores de contenido)
 
Son los componentes creados para compartir datos con otras actividades o servicios. Un proveedor de contenido usa una interface standard en la forma de una URI para llenar las solicitudes para los datos de otras aplicaciones que pueden no conocer aun, que proveedor de contenidos están ellas usando.


Services (servicios)

Los servicios son componentes sin interfaz gráfica que se ejecutan en segundo plano. En concepto, son exactamente iguales a los servicios presentes en cualquier otro sistema operativo. Los servicios pueden realizar cualquier tipo de acciones, por ejemplo actualizar datos, lanzar notificaciones, o incluso mostrar elementos visuales (activities) si se necesita en algún momento la interacción con del usuario.


No son mas que piezas de código ejecutable que correrán en segundo plano desde el momento en que estas se carguen hasta que el mobil es apagado.



 Bibliografía:
Referencia1
Referencia2 
Referencia3 
Referencia4
Referencia5
Referencia6
Estructura de un proyecto Android y nuestro primer proyecto

Cuando creamos un proyecto en Android  en el IDE eclipse se nos crea automáticamente una estructura de carpetas que son  necesarias para crear una aplicación. La estructura es la misma no importa cual sea el tamaño del programa, o lo dificl o facil que sea.

Para poder explicar esta estructura crearemos un proyecto, nos vamos a la ventanadel IDE eclipse.

Nos vamos al menu file-->New project




 Nos saldrá una ventana en donde seleccionaremosel tipo de proyecto en este caso Android Project dentro de Android y le damos Next.


Le daremos un nombre a nuestro proyecto, yo le di el nombre de Hola, en Project location indicamos el directorio que contendrá los archivos del proyecto, podemos dejar el valor por defecto yo asile hice en mi caso y le damos Next.


 A continuación seleccionaremos el SDK en  el Android cual desarrollaremos,en este caso pondremos el instalado en la entrada anterior el Android 2.2 y pulsamos Next.


Ahora tecleamos lo siguiente:

- Application Name: nombre de la aplicación.
- Package Name: nombre del paquete Javase recomienda que sea un paquete nombrado con el estándar de Java, es decir, un dominio invertido.
- Create Activity: nombre de la primera actividad de la aplicación.
- Minimum SDK: API mínima requería para el funcionamiento de la aplicación.

En mi caso yo puse lo siguiente y le dmos Finalizar:



Eclipse nos habrá creado un proyecto con la siguiente estructura:




Descripción de elementos

Carpeta /src/

Contiene:

  • todo el código fuente de la aplicación
  •  código de la interfaz gráfica
  • clases auxiliares, etc.

Al principio Eclipse crea por nosotros el código básico de la pantalla (Activity) principal de la aplicación, siempre bajo la estructura del paquete java definido.




Carpeta /gen/

Contiene  elementos de código que son generados automáticamente al compilar el proyecto.

Cada vez que generamos nuestro proyecto, la maquinaria de compilación de Android genera por nosotros una serie de ficheros fuente en java dirigidos al control de los recursos de la aplicación.




Como vemos se encuentran el fichero R.java y la clase R.

La clase R contiene una serie constantes con los ID de todos los recursos de la aplicación incluidos en la carpeta /res/, de forma que podamos acceder fácilmente a estos recursos desde nuestro código a través de este dato.

Carpeta /assets/

Contiene ficheros auxiliares para la aplicación (por ejemplo, archivos de configuración)



Carpeta /res/

Aquése encuentran los recursos complementarios para el proyecto como son imagenes entre otras cosas,sus directorios son:

  • /res/drawable/: Tiene las mágenes de la aplicación (a su vez dividido en otros subdirectorios, según la calidad de las mismas: drawable-hdpidrawable-mdpidrawable-ldpi).
  • /res/layout/. Contienen los ficheros de definición de las diferentes pantallas de la interfaz gráfica. Se puede dividir en /layout y /layout-land para definir distintos layouts dependiendo de la orientación del dispositivo.
  • /res/values/: donde se encuentra el archivo strings.xml, en el cual declaramos las cadenas de texto que usará la aplicación.
  •  /res/anim/: Defininiciones de las animaciones utilizadas.
  • /res/menu/: Definiciones de los menus.
  • /res/xml/: Ficheros xml utilizados.
  •  /res/raw/: Recursos adicionales que no clasifican en otros subdirectorios.




Fichero AndroidManifest.xml

Contiene la definición en XML de los aspectos principales de la aplicación, como por ejemplo su identificación (nombre, versión, icono, …), sus componentes (pantallas, mensajes, …), o los permisos necesarios para su ejecución.



Ahora continuando con el proyecto lo que haremos es ir al archivo strings.xml que se encuentra en la carpeta res y le damos doble clic:



 Nos aparecerá de lado derecho el siguiente código asegurensen de tener seleccionadas las pestañas que yo selecciones:



Ahora personalizaremos el saludo:

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="hello">Hola ALicia =)! </string>
    <string name="app_name">Hola </string>

</resources>

Para finalizar nos vamos a la opción Run y después Run  y vemos como se abre nuestra maquina virtual y se despliega nuestra aplicación. Tenemos que desbloquearlo:



Ya desbloqueado nos aparece el proyecto =)


También podemos acceder esta aplicación a través del icono de aplicaciones de Android y ahi veremos nuestra aplicación, solo le damos clic y entramos:




Bibliografía:

Referencia1
Referencia2