viernes, 3 de junio de 2016



Layout

Layout es un término de la lengua inglesa que no forma parte del diccionario de la Real Academia Española (RAE). El concepto puede traducirse como “disposición” o “plan” y tiene un uso extendido en el ámbito de la tecnología.

La noción de Layout suele utilizarse para nombrar al esquema de distribución de los elementos dentro un diseño. Es habitual que un diseñador que se dedica a la creación de páginas web desarrolle un Layout y se lo presente a su cliente para que éste lo apruebe y decida sobre la distribución de los contenidos.

El Layout, en este sentido, puede ser una especie de plantilla que presenta tablas o espacios en blanco. La idea es que, a partir del Layout, la página web comience a desarrollarse con sus contenidos específicos. El Layout puede estar compuesto, por ejemplo, por un rectángulo a modo de cabezal y por tres columnas. Dicho esquema es genérico y puede usarse para desarrollar múltiples sitios web.


Tipos de Layout para Aplicación Android en Eclipse

Vamos a ver distintos tipos de Layout que podemos utilizar en nuestro desarrollo para una plataforma Android. Los tipos de los que disponemos son:

  •            Layout Lineal
  •          Table Layout
  •         Absolute Layout
  •          Relative Layout
  •          Frame Layout



Layout Lineal

Es el Layout más simple que podemos utilizar. Como su nombre indica, los elementos se irán colocando uno detrás de otro, pero sí que podemos indicar si la colocación lineal se hará de forma vertical u horizontal.

Para ponerlo de forma vertical, en la propiedad “orientation” hay que indicarle el valor “vertical”.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
         android:orientation="vertical" android:layout_width="fill_parent"
         android:layout_height="fill_parent">

         <Button android:text="Button01" android:id="@+id/Button01"
                 android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

         <Button android:text="Button02" android:id="@+id/Button02"
                 android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
</LinearLayout>

Si lo que queremos es darle una orientación horizontal, el valor de la propiedad será “horizontal”.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
         android:orientation="horizontal" android:layout_width="fill_parent"
         android:layout_height="fill_parent">
 
         <Button android:text="Button01" android:id="@+id/Button01"
                 android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
 
         <Button android:text="Button02" android:id="@+id/Button02"
                 android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
 
</LinearLayout>


Table Layout

Es un modelo de organización basado en una organización con tablas. El diseño lo organizaremos en filas (elemento TableRow) y dentro de cada fila, pondremos los elementos.

<?xml version="1.0" encoding="utf-8"?>
<TableLayout android:id="@+id/TableLayout01"
         android:layout_width="fill_parent" android:layout_height="fill_parent"
         xmlns:android="http://schemas.android.com/apk/res/android">
         <TableRow android:id="@+id/TableRow01">
                 <TextView android:id="@+id/TextView01" android:text="First Name:"
                          android:width="100px" />
                 <EditText android:id="@+id/EditText01" android:width="220px" />
         </TableRow>
 
         <TableRow android:id="@+id/TableRow02">
                 <TextView android:id="@+id/TextView02" android:text="Second Name:" />
                 <EditText android:id="@+id/EditText02" />
         </TableRow>
 
         <TableRow android:id="@+id/TableRow03">
                 <Button android:id="@+id/Button01"
            android:layout_width="wrap_content"
                          android:layout_height="wrap_content" android:text="Submit" />
 
                 <Button android:id="@+id/Button02"
            android:layout_width="wrap_content"
                          android:layout_height="wrap_content" android:text="Reset"
                          android:width="100px" />
         </TableRow>
</TableLayout>

Layout Relativo

Este es el layout más flexibles de todos. Los elementos se colocan relativos a otro elemento o a otro Layout.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout android:id="@+id/RelativeLayout01"
         android:layout_width="fill_parent" android:layout_height="fill_parent"
         xmlns:android="http://schemas.android.com/apk/res/android">
 
         <TextView android:id="@+id/TextView01"
        android:layout_width="wrap_content"
                 android:layout_height="wrap_content" android:text="First Name:"
                 android:width="100px" />
 
         <EditText android:id="@+id/EditText01" android:layout_width="220px"
                 android:layout_height="wrap_content"
        android:layout_toRightOf="@+id/TextView01"
                 android:layout_below="@+id/RelativeLayout01" />
 
         <EditText android:id="@+id/EditText02" android:layout_width="220px"
                 android:layout_height="wrap_content"
        android:layout_below="@+id/EditText01"
                 android:layout_alignLeft="@+id/EditText01" />
 
         <TextView android:id="@+id/TextView02"
        android:layout_width="wrap_content"
                 android:layout_height="wrap_content" android:text="Second Name:"
                 android:width="100px" android:layout_below="@+id/EditText01"
                 android:layout_toLeftOf="@+id/EditText02" />
 
         <Button android:text="Submit" android:id="@+id/Button01"
                 android:layout_width="100px" android:layout_height="wrap_content"
                 android:layout_below="@id/EditText02"
        android:layout_alignLeft="@id/EditText02" />
 
         <Button android:text="Reset" android:id="@+id/Button02"
                 android:layout_width="100px" android:layout_height="wrap_content"
                 android:layout_below="@id/EditText02"
        android:layout_alignRight="@id/EditText02" />
 
</RelativeLayout>

Absolute Layout

Es una capa donde se utilizan coordenadas X e Y para indicarle donde colocar los elementos dentro del diseño. En cada elemento del código se le indicará el valor de X y de Y.

<?xml version="1.0" encoding="utf-8"?>
<AbsoluteLayout android:id="@+id/AbsoluteLayout01"
         android:layout_width="fill_parent" android:layout_height="fill_parent"
         xmlns:android="http://schemas.android.com/apk/res/android">
         <EditText android:id="@+id/EditText01" android:layout_width="200px"
                 android:layout_height="wrap_content" android:layout_x="12px"
                 android:layout_y="12px" />
         <Button android:text="Search" android:id="@+id/Button01"
                 android:layout_width="100px" android:layout_height="wrap_content"
                 android:layout_x="220px" android:layout_y="12px" />
</AbsoluteLayout>

Frame Layout

Este Layout consiste en un marco que ocupa toda la pantalla, y donde los controles se dispondrán a partir de la esquina superior izquierda, por lo que es probable que haya elementos que se queden ocultos detrás de otros.

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout android:id="@+id/FrameLayout01"
         android:layout_width="fill_parent" android:layout_height="fill_parent"
         xmlns:android="http://schemas.android.com/apk/res/android">
 
         <ImageView android:id="@+id/ImageView01" android:src="@drawable/android"
                 android:layout_width="fill_parent"
        android:layout_height="fill_parent"
                 android:scaleType="center" />
 
         <TextView android:text="Android Partaker" android:id="@+id/TextView01"
                 android:layout_width="wrap_content"
        android:layout_height="wrap_content"
                 android:layout_marginBottom="20dip"
        android:layout_gravity="center_horizontal|bottom"
                 android:padding="10dip"
        android:textColor="#AA0000" android:textStyle="bold"
                 android:textSize="20px" android:background="#00000000" />
 
</FrameLayout>

jueves, 2 de junio de 2016



Estructura de un proyecto Android en Eclipse

Cuando creamos un proyecto Android en Eclipse se genera automáticamente la estructura de carpetas necesarias para poder generar posteriormente la aplicación. 
En la siguiente imagen se muestran los elementos creados inicialmente para un nuevo proyecto Android:



Elementos principales

Carpeta/src/
Contiene todo el código fuente de la aplicación, código de la interfaz gráfica, clases auxiliares, etc. Inicialmente, Eclipse creará 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/res
Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes, vídeos, cadenas de texto, etc. Los diferentes tipos de recursos de deberán distribuir entre las siguientes carpetas:


  • /res/drawable/. Contienen las imágenes de la aplicación. Se puede dividir en /drawable-ldpi,/drawable-mdpi y /drawable-hdpi para utilizar diferentes recursos dependiendo de la resolución del dispositivo.
  • /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/anim/. Contiene la definición de las animaciones utilizadas por la aplicación.
  • /res/menu/. Contiene la definición de los menús de la aplicación.
  • /res/values/. Contiene otros recursos de la aplicación como por ejemplo cadenas de texto (strings.xml), estilos (styles.xml), colores (colors.xml), etc.
  • /res/xml/. Contiene los ficheros XML utilizados por la aplicación.
  • /res/raw/. Contiene recursos adicionales, normalmente en formato distinto a XML, que no se incluyan en el resto de carpetas de recursos.
Como ejemplo, para un proyecto nuevo Android, se crean los siguientes recursos para la aplicación:


Carpeta/gen
Contiene una serie de elementos de código 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.

El más importante es el que se puede observar en la imagen, el fichero R.java, y la clase R.
Esta clase R contendrá en todo momento una serie de 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. Así, por ejemplo, la constante R.drawable.icon contendrá el ID de la imagen “icon.png”contenida en la carpeta /res/drawable/. Veamos como ejemplo la clase R creada por defecto para un proyecto nuevo:

public final class R {
public static final class attr {
}
public static final class drawable {
public static final int icon=0x7f020000;
}
public static final class layout {
public static final int main=0x7f030000;
}
public static final class string {
public static final int app_name=0x7f040001;
public static final int hello=0x7f040000;
}
}


Carpeta/assets
Contiene todos los demás ficheros auxiliares necesarios para la aplicación (y que se incluirán en su propio paquete), como por ejemplo ficheros de configuración, de datos, etc.
La diferencia entre los recursos incluidos en la carpeta /res/raw/ y los incluidos en la carpeta /assets/ es que para los primeros se generará un ID en la clase R y se deberá acceder a ellos con los diferentes métodos de acceso a recursos. Para los segundos sin embargo no se generarán ID y se podrá acceder a ellos por su ruta como a cualquier otro fichero del sistema. Usaremos uno u otro según las necesidades de nuestra aplicación.


Carpeta /libs/
Contendrá las librerías auxiliares, normalmente en formato “.jar” que utilicemos en nuestra aplicación Android.

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. Veremos más adelante más detalles de este fichero.
En el siguiente post veremos los componentes software principales con los que podemos construir una aplicación Android.

miércoles, 13 de abril de 2016


Primera aplicación de Android en Eclipse.

"Hola mundo" en Android con Eclipse.

Empezaremos con un programa de ejemplo, llamado “Hola mundo” este nombre se suele poner a la primera práctica que realizamos en cualquier lenguaje de programación.

Debemos tener instaladas las herramientas necesarias y que detallarán en 
android developers(en inglés).

Para ello abrimos el IDE y desde el menú superior accedemos a File ---> New -->AndroidAplicattionProject, se habilitará un cuadro de diálogo en el que nos pedirán la siguiente información:



Nombre de la aplicación(El que se mostrará al usuario una vez instalada, Hola Mundo).

Nombre del proyecto como hemos dicho Hola Mundo. Nombre del paquete que se usa como espacio de nombres y estructura de organización del código, “com.example.holamundo” Versión de Android mínima requerida, por ejemplo Android 2.2 (cuanto menor sea la versión, nuestra aplicación correrá en más dispositivos, aunque por otro lado nos penalizará el no poder usar las últimas características de Android).


A continuación marcamos la opción Crear Actividad para que Eclipse cree la clase que se lanzará al ejecutar la aplicación. Normalmente a esta clase se la llamará MainActivity, ya que será la clase principal de nuestra App. Al completar todo pulsamos finalizar para que se cree nuestro primer proyecto Android.


miércoles, 2 de marzo de 2016

Programación Android 2: configuración de PC para desarrollar como Android
A continuación te dejo el video que te ayudará con los pasos para realizar la configuración.







Resumen:
·         Paso uno: Instalar UDK (conjunto de herramientas para Java).
·         Paso dos: Descargar e instalar SDK (conjunto de herramientas para Android).
·         Paso tres: Descargar Eclipse, para esto debes ingresar al sitio oficial de Eclipse (https://eclipse.org/), después vas a la sección de descargas y elijes la primera opción. Ya descargado lo comprimes.
·         Paso cuatro: Instalar Plugin, lo cual va a permitir integrar las herramientas de desarrollo  para Android con Eclipse, así van a ser reconocidos los pasos.
·         Paso cinco: Configurar las preferencias de Eclipse.
·         Paso seis: Configurar la máquina virtual a través del controlador virtual de Android.
Programación Android tutorial 1: Introducción
A continuación se muestra un video que ayudará a comprender mas sobre Android y las características de su sistema operativo.

Resumen:
Android es un sistema operativo que desde 2005 es propiedad de Google  y está basado en Linux. Está diseñado principalmente para dispositivos que tienen pantalla táctil.
Características del sistema operativo:
·         Es multitarea, es decir, la capacidad de desarrollar muchas tareas al mismo tiempo.
·         Permite desarrollar aplicaciones como Java.
·         Es multitáctil, es decir, la capacidad de percibir mediante pequeños toques en la pantalla e interpretarlos como touch, arrastrar o mover elementos.

·         También brinda un soporte para bases de datos y lo hace a través del sistema llamado SQLite.







Entornos de trabajo para aplicaciones moviles

En
tor
no
Características
Ventajas
Desventajas
E
C
L
I
P
S
E

·         Dispone de un editor de texto con resaltado de sintaxis donde puedes ver el contenido del fichero en el que estás trabajando.
·         Contiene una lista de tareas y otros módulos similares.
·         La compilación es en tiempo real.
·         Tiene pruebas unitarias con Junit.
·         Integración con Ant, asistentes (wizards) para creación de proyectos, clases, tests, etc. y refactorización.
·         El entorno de desarrollo integrado de Eclipse emplea módulos para proporcionar toda su funcionalidad al frente de la plataforma de cliente rico a diferencia de otros entornos monolíticos donde las funcionalidades están todas incluidas, las necesite el usuario o no.
·         Este mecanismo de módulos es una plataforma ligera de componentes de software. Adicionalmente permite a Eclipse extenderse usando otros lenguajes de programación como son C/C++ y Python, permite a Eclipse trabajar con lenguajes para procesado de texto como LaTex, aplicaciones en red como Telnet y sistema de gestión en bases de datos.
·         La arquitectura Plug-in permite escribir cualquier extensión deseada en el ambiente, como seria gestión de la configuración.
·         La definición que da el proyecto Eclipse acerca de su Software es: “Una especie de herramienta universal-un IDE abierto y extensible para todo y nada en particular.
·         Su principal inconveniente es el consumo de recursos del sistema.
·         Carece de muchos recursos para webapps tal y como lo hace netbeans.
X
C
O
D
E

·         Es el entorno de desarrollo integrado de Apple Inc. Y se suministra gratuitamente junto con Mac OS X.
·         Xcode trabaja conjuntamente con Interface Builder, una herencia de NeXT, una herramienta básica para la creación de interfaces de usuario.
·         Incluye la colección de compiladores del proyecto GNU (GCC), y puede compilar código C, C++, Objetive-C, Objetive-C++, Java y Apple Script.
·         Compilación de múltiples lenguajes.
·         Tiene simulación virtual IOS.
·         Insepección de código (“en tiempo real”).
·         Es gratuito.
·         Está diseñado solo para Mac.
·         No hay mucha información sobre su uso.
·         Es un poco extenso en herramientas y eso es bueno solo cuando se sabe usar bien.
N
E
T
B
E
A
N
S

·         La plataforma NetBeans es una base modular y extensible usada como una estructura de integración para crear aplicaciones de escritorio grandes. 
·         La plataforma ofrece servicios comunes a las aplicaciones de escritorio, permitiéndole al desarrollador enfocarse en la lógica específica de su aplicación. 
·         Entre las características de la plataforma están: 
  ü  Administración de las interfaces de usuario (ej. menús y barras de herramientas). 
  ü  Administración de las configuraciones del usuario. 
  ü  Administración del almacenamiento (guardando y cargando cualquier tipo de dato). 
  ü  Administración de ventanas. 
  ü  Framework basado en asistentes (diálogos paso a paso). 
·         Paquetes que componen a NetBeans (algunos pueden ser descargados individualmente). 
·         NetBeans Enterprise Pack provee Soporte para la creación de aplicaciones orientadas a servicios (SOA), incluyendo herramientas de esquemas XML, un editor WSDL, y un editor BPEL para web services.
·         La plataforma Netbeans puede ser usada para desarrollar cualquier tipo de aplicación.
·         Reutilización del Módulos.
·         Permite el uso de la herramienta Update Center Module.
·         Instalación y actualización simple.
·         Incluye Templates y Wizards.
·         Posee soporte para Php.

·         Poca existencia de pluguins para esta plataforma.
·         hace falta documentación del Rich Client Plataform (RCP).
·         No posee un editor de código HTML.

J
A
V
A

·         Lenguaje totalmente orientado a Objetos. 
·         Disponibilidad de un amplio conjunto de bibliotecas. 
·         Lenguaje simple. 
·         Distribuido. 
·         Interpretado y compilado a la vez. 
·         Robusto. 
·         Seguro. 
·         Indiferente a la arquitectura. 
·         Portable. 
·         Alto rendimiento. 
·         Multihebra. 
·         Dinámico. 
·         Produce applets. 
§  Manejo automático de la memoria. (para los que vienen de C/C++) " Si, no hay punteros! WOW!". El manejo de la memoria se hace automáticamente y utilizando el garbage collector. Esto ahorra SIGNIFICANTE tiempo de programación.
§  Lenguaje Multi-plataforma: El código que escrito en java es leído por un intérprete, por lo que su programa andará en cualquier plataforma.
§  Programación Orientada a Objetos: Paradigma muy utilizado hoy en dia que facilita y organiza mucho la programación.
§  Puede correr en el explorador y en dispositivos móviles.
§  Sintaxis similar a C/C++, pero más simple.

§  Menos Eficiente, comparado a C/C++.
§  Requiere un intérprete.
§  Algunas implementaciones y librerías pueden tener código rebuscado.
§  Una mala implementación de un programa en java, puede resultar en algo muy lento.