RSS
Facebook
G+

Buscador de IntercambioSOS:


Retroceder   Foro de Ayuda IntercambiosvirtualeS > Soporte Sobre: Educación & Entretenimiento > Zona Académica > Programación

Respuesta
 
Herramientas Desplegado
Antiguo 17-dic-2011     #1
Predeterminado PROGRAMACIÓN EN ANDROID: Conceptos Generales "Parte 1"

• CURSO DE PROGRAMACIÓN EN ANDROID:
> CONCEPTOS GENERALES


ENTORNO DE DESARROLLO ANDROID

Para empezar, hay que describir los pasos básicos para disponer en la PC del entorno y las herramientas necesarias para comenzar a programar aplicaciones Android. Aquí encontraras los enumerados de los pasos necesarios de instalación y configuración.

1. Instalación y Descargar de Eclipse.
Es recomendado descargar por ejemplo la versión Eclipse IDE for Java Developers. La instalación consiste simplemente en descomprimir el Zip en la ubicación deseada.

2. Instalación de SDK de Android.
El SDK de la plataforma Android. De nuevo bastará con descomprimir el Zip en cualquier ubicación.

3. Instalación de plugin Android para Eclipse.
Google pone a disposición de los desarrolladores un plugin para Eclipse llamado Android Development Tools (ADT) que facilita en gran medida el desarrollo de aplicaciones para la plataforma. Podéis descargarlo mediante las opciones de actualización de Eclipse, accediendo al menú “Help / Install new software…”. Se debe seleccionar e instalar el paquete completo Developer Tools, formado por Android DDMS y Android Development Tools.

4. Configurar el plugin ADT.
En la ventana de configuración de Eclipse, se debe acceder a la sección de Android e indicar la ruta en la que se ha instalado el SDK.




5. Instalación de los targets necesarios.

Además del SDK de Android, también tendrás que instalar SDK Targets de Android, que no son más que las librerías necesarias para desarrollar en cada una de las versiones concretas de Android. Así, si queremos desarrollar por ejemplo para Android 1.6 tendremos que descargar su target correspondiente. Para ello, desde Eclipse debemos acceder al menú “Window / Android SDK and AVD Manager“, y en la sección Available Packages seleccionar e instalar todos los paquetes deseados.



6. Configurar un AVD.
A la hora de probar y depurar aplicaciones Android no tendrás que hacerlo necesariamente sobre un dispositivo físico, sino que podrás configurar un emulador o dispositivo virtual (Android Virtual Device, o AVD) donde puedes realizar fácilmente estas tareas. Para ello, accede nuevamente al AVD Manager, y en la sección Virtual Devices podrás añadir tantos AVD como se necesiten (ejemplo, configurados para distintas versiones de Android). Para configurar el AVD sólo tendrás que indicar un nombre descriptivo, el target de Android que utilizará, y las características de hardware del dispositivo virtual, como por ejemplo su resolución de pantalla, el tamaño de la tarjeta SD, o la disponibilidad de GPS.




Y con este paso estarás preparado para crear el primer proyecto para Android.

7. ¡Hola Mundo! en Android.
Crea un nuevo proyecto de tipo Android Project. Indica su nombre, el target deseado, el nombre de la aplicación, el paquete java por defecto para la clases y el nombre de la clase (Activity) principal.



Esta acción creará toda la estructura de carpetas necesaria para compilar un proyecto para Android. Para ejecutar el proyecto tal cual podrás hacerlo como cualquier otro proyecto java configurando una nueva entrada de tipo Android Applications en la ventana de Run Configurations. Al ejecutar el proyecto, se abrirá un nuevo emulador Android y se cargará automáticamente la aplicación.





__________________________________________________ __________________________________________________ ______________________________________



ESTRUCTURA DE UN PROYECTO ANDROID

Cuando se crea un nuevo proyecto Android en Eclipse se genera automáticamente la estructura de carpetas necesaria para poder generar posteriormente la aplicación. Esta estructura será común a cualquier aplicación, independientemente de su tamaño y complejidad.
En la siguiente imagen veras 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 generas un proyecto, la maquinaria de compilación de Android genera automáticamente 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 se puede acceder fácilmente a estos recursos desde el 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/. Como ejemplo la clase R creada por defecto para un proyecto nuevo:



package net.sgoliver;

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.

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.


__________________________________________________ __________________________________________________ ______________________________________


COMPONENTES DE UNA APLICACIÓN ANDROID


Aquí veras como centrarte más específicamente en los distintos tipos de componentes de software con los que podrás construir una aplicación Android. En Java o .NET te acostumbraras a manejar conceptos como ventana, control, eventos o servicios como los elementos básicos en la construcción de una aplicación.
En Android vas a disponer de esos mismos elementos básicos aunque con un pequeño cambio en la terminología y el enfoque. Revisa nuevamente los componentes principales que pueden formar parte de una aplicación Android (Por claridad, y para evitar confusiones al consultar documentación en inglés).

ACTIVITY
Las Actividades (Activities) representan el componente principal de la interfaz gráfica de una aplicación Android. Se puede pensar en una actividad como el elemento análogo a una ventana en cualquier otro lenguaje visual.

VIEW
Los objetos View son los componentes básicos con los que se construye la interfaz gráfica de la aplicación, análoga por ejemplo a los controles de Java o .NET. De inicio, Android pone a disposición una gran cantidad de controles básicos, como cuadros de texto, botones, listas desplegables o imágenes, aunque también existe la posibilidad de extender la funcionalidad de estos controles básicos o crear controles personalizados.

SERVICE
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.

CONTENT PROVIDER
Un Content Provider es el mecanismo que se ha definido en Android para compartir datos entre aplicaciones. Mediante estos componentes es posible compartir determinados datos de nuestra aplicación sin mostrar detalles sobre su almacenamiento interno, su estructura, o su implementación. De la misma forma, la aplicación podrá acceder a los datos de otra a través de los Content Provider que se hayan definido.

BROADCAST RECEIVER
Un Broadcast Receiver es un componente destinado a detectar y reaccionar ante determinados mensajes o eventos globales generados por el sistema (ejemplo: “Batería baja”, “SMS recibido”, “Tarjeta SD insertada”,…) o por otras aplicaciones (cualquier aplicación puede generar mensajes (intents, en terminología Android) broadcast, es decir, no dirigidos a una aplicación concreta sino a cualquiera que quiera escucharlo).

WIDGET
Los Widgets son elementos visuales, normalmente interactivos, que pueden mostrarse en la pantalla principal (home screen) del dispositivo Android y recibir actualizaciones periódicas. Permiten mostrar información de la aplicación al usuario directamente sobre la pantalla principal.

INTENT
Un Intent es el elemento básico de comunicación entre los distintos componentes Android que hemos descrito anteriormente. 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.
En el siguiente post empezaremos ya a ver algo de código, analizando al detalle una aplicación sencilla.



__________________________________________________ __________________________________________________ ______________________________________



DESARROLLANDO UNA APLICACIÓN ANDROID SENCILLA

Tradicionalmente es usado el clásico Hola Mundo, pero para este curso se han cambiado algunas cosas básicas. Así que ha cambiado el Hola Mundo, transformándolo en algo nuevo como un Hola Usuario, que es igual de sencillo pero añade un par de cosas interesantes de contar. La aplicación constará de dos pantallas, por un lado la pantalla principal que solicitará un nombre al usuario y una segunda pantalla en la que se mostrará un mensaje personalizado para el usuario. Sencillo, inútil, pero tienes la posibilidad de aprender muchos conceptos básicos, que para empezar no está mal.




Primero que todo hay que crear un nuevo proyecto Android. El proyecto será Llamado “HolaUsuario“, se indicara como target (Ejemplo: Android 1.6), abra que dar un nombre a la aplicación e indicar que se cree una actividad llamada “HolaUsuario”.


Como ya se vio esto crea la estructura de carpetas del proyecto y todos los ficheros necesarios de un Hola Mundo básico, es decir, una sola pantalla donde se muestra únicamente un mensaje fijo. Lo primero que se hará será diseñar una pantalla principal modificando la que Eclipse ha creado por defecto. ¿Pero dónde y cómo se define cada pantalla de la aplicación? En Android, el diseño y la lógica de una pantalla estarán separados en dos ficheros distintos. Por un lado, en el fichero /res/layout/main.xml se tendrá el diseño puramente visual de la pantalla definido como fichero XML y por otro lado, en el fichero /src/paquetejava/HolaUsuario.java, habrá que hallar el código java que determina la lógica de la pantalla.
Aquí abra que modificar en primer lugar el aspecto de la ventana principal de la aplicación añadiendo los controles (views) que se vera en la primera captura de pantalla. Para ello, hay que sustituir el contenido del fichero main.xml por el siguiente:



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

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

<EditText android:id="@+id/TxtNombre"
android:layout_height="wrap_content"
android:layout_width="fill_parent" />

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

</LinearLayout>
En este XML se definen los elementos visuales que componen la interfaz de la pantalla principal y se especifican todas sus propiedades. No abra que detenerse mucho en cada detalle porque ése será tema de otro artículo, ¿Pero que vemos en el fichero? Lo primero que se encuentra 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, conocen 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 tendrán que haber incluidos tres controles: una etiqueta (TextView), un cuadro de texto (EditText), y un botón (Button). En todos ellos ya habrá que establecer las siguientes propiedades:

android:id. ID del control, con el que se podrá identificar más tarde en código. Se vera que el identificador habrá que escribirlo precedido a este: “@+id/”. Esto tendrá como efecto que al compilarse el proyecto se genere automáticamente una nueva constante en la clase R para dicho control.

android:text. Texto del control. El texto de un control se puede especificar directamente o bien utilizar alguna de las cadenas de texto definidas en los recursos del proyecto (fichero strings.xml), en cuyo caso se indicara su identificador precedido del prefijo “@string/”.

android:layout_height y android:layout_width. Dimensiones del control con respecto al layout que lo contiene. Esta propiedad tomará normalmente los valores “wrap_content” para indicar que las dimensiones del control se ajustarán al contenido del mismo, o bien “fill_parent” para indicar que el ancho o el alto del control se ajustará al ancho o alto del layout contenedor respectivamente.

Con esto ya estará definida la presentación visual de nuestra ventana principal de la aplicación. De igual forma habrá que definir la interfaz de la segunda pantalla, creando un nuevo fichero llamado frmmensaje.xml, y añadirlo esta vez solo a una etiqueta (TextView) para mostrar el mensaje personalizado al usuario. A continuación veremos cómo quedaría la segunda pantalla:



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

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

</LinearLayout>
Una vez definida la interfaz de las pantallas de la aplicación se tendrá que implementar la lógica de la misma. Como ya se ha comentado, la lógica de la aplicación se definirá en ficheros Java independientes. Para la pantalla principal ya estará creado un fichero por defecto llamado HolaUsuario.java. Se empezara comentando su código por defecto:



public class HolaUsuario extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Como ya se ha visto, las diferentes pantallas de una aplicación Android se definen mediante objetos de tipo Activity. Por tanto, lo primero que se encontrara será el fichero java es la definición de una nueva clase HolaUsuario que extiende a Activity. El único método que será sobrescribido de esta clase será el método OnCreate, llamado cuando se crea por primera vez la actividad. En este método lo único que se encontrara 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 se estara 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 se ha especificado en el fichero /res/layout/main.xml. Una vez más s puede observar la utilidad de las diferentes constantes de recursos creadas automáticamente en la clase R al compilar el proyecto.
En principio habrá que crear una nueva actividad para la segunda pantalla de la aplicación análoga a ésta primera, para lo que se creara una nueva clase FrmMensaje que se extiende de Activity y que implemente el método onCreate indicando que utilice la interfaz definida en R.layout.frmmensaje.




public class FrmMensaje extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.frmmensaje);
}
}
Como se puede observar, el código incluido por defecto en estas clases lo único que hace es generar la interfaz de la actividad. A partir de aquí habrá que incluir el resto de la lógica de la aplicación. Y habrá que empezar con la actividad principal HolaUsuario, obteniendo una referencia a los diferentes controles de la interfaz que necesitan manipular, para el caso sólo el cuadro de texto y el botón. Para ello se utilizaran el método findViewById() indicando el ID de cada control, definidos como siempre en la clase R:



final EditText txtNombre = (EditText)findViewById(R.id.TxtNombre);
final Button btnHola = (Button)findViewById(R.id.BtnHola);
Una vez obtenido el acceso a los diferentes controles, ya sólo queda implementar las acciones a tomar cuando sea pulsado el botón de la pantalla. Para ello será implementado el evento onClick de dicho botón, aquí se puede observar:



btnHola.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
Intent intent = new Intent(HolaUsuario.this, FrmMensaje.class);

Bundle bundle = new Bundle();
bundle.putString("NOMBRE", txtNombre.getText().toString());
intent.putExtras(bundle);

startActivity(intent);
}
});
Como se ha indicado, la comunicación entre los distintos componentes y aplicaciones en Android se realiza mediante intents, por lo que el primer paso será crear un objeto de este tipo. Existen varias variantes del constructor de la clase Intent, cada una de ellas dirigida a unas determinadas acciones, pero en nuestro caso particular se utilizara el intent para llamar a una actividad desde otra de la misma aplicación, para lo que habrá que pasar al constructor una referencia a la propia actividad llamada (HolaUsuario.this), y la clase de la actividad llamada (FrmMensaje.class).
Si se quisiera sólo mostrar una nueva actividad ya tan sólo quedaría llamar a startActivity() pasándole como parámetro el intent creado. Pero en el ejemplo usado también se quiere pasar cierta información a la actividad, concretamente el nombre que introduzca el usuario en el cuadro de texto. Para hacer esto habrá que crear un objeto Bundle, que puede contener una lista de pares clave-valor con toda la información a pasar entre las actividades. En este caso sólo habrá que añadir un dato de tipo String mediante el método putString (clave,valor). Tras esto se añadirá la información al intent mediante el método putExtras(bundle).
Finalizada la actividad principal de la aplicación se pasara a la secundaria. Se comenzara de forma análoga a la anterior, ampliando el método onCreate obteniendo las referencias a los objetos que se manipularan, esta vez sólo la etiqueta de texto. Luego de esto viene lo más interesante, habrá que recuperar la información pasada desde la actividad principal y asignarla como texto de la etiqueta. Para ello hay que acceder en primer lugar al intent que ha originado la actividad actual mediante el método getIntent() y se podrá recuperar la información asociada (objeto Bundle) mediante el método getExtras().
Hecho esto tan sólo habrá que construir el texto de la etiqueta mediante su método setText (texto) y recuperando el valor de nuestra clave almacenada en el objeto Bundle mediante getString (clave).



public class FrmMensaje extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.frmmensaje);

TextView txtMensaje = (TextView)findViewById(R.id.TxtMensaje);

Bundle bundle = getIntent().getExtras();

txtMensaje.setText("Hola " + bundle.getString("NOMBRE"));
}
}
Con esto se ha concluido la lógica de las dos pantallas de la aplicación y tan sólo queda un paso importante para finalizar el desarrollo. Como se ha indicado anteriormente, cualquier aplicación Android utiliza un fichero especial en formato XML (AndroidManifest.xml) para definir, entre otras cosas, los diferentes elementos que la componen. Por tanto, todas las actividades de la aplicación deben quedar convenientemente recogidas en este fichero. La actividad principal ya debe aparecer puesto que se creó de forma automática al crear el nuevo proyecto Android, por lo que hay que añadir tan sólo la segunda. Para este ejemplo limitaremos a incluir la actividad en el XML, más adelante se encuentran las opciones adicionales que se pueden especificar.



<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="net.sgoliver"
android:versionCode="1"
android:versionName="1.0">

<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".HolaUsuario"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

<activity android:name=".FrmMensaje"></activity>
</application>

<uses-sdk android:minSdkVersion="4" />

</manifest>
Una vez llegado aquí, si todo ha ido bien, se puede ejecutar el proyecto sin errores y probar la aplicación en el emulador.



Última edición por GenuiWorld; 05-ago-2012 a las 19:34
Responder Citando
Los siguientes 10 usuarios agradecen a GenuiWorld por este mensaje:
cramercaba (17-dic-2011), dreamfox (23-feb-2012), Duck1245 (17-dic-2011), Eloy58 (18-dic-2011), humo3 (04-ene-2015), Hunted (17-dic-2011), maik007 (10-ene-2014), marcos.RV (26-ago-2015), tamarindoloco (01-ene-2012), xdkizaru (31-dic-2011)
Antiguo 17-dic-2011     #2
Predeterminado Muchas gracias!!!



Conocimiento: Máximo Poder
Enviar un mensaje por Yahoo  a Hunted Responder Citando
Los siguientes 6 usuarios agradecen a Hunted por este mensaje:
baduser (19-dic-2011), cramercaba (17-dic-2011), davece (15-may-2013), dreamfox (23-feb-2012), Eloy58 (18-dic-2011), GenuiWorld (05-ago-2012)
Antiguo 17-dic-2011     #3
Predeterminado



La vida es lo que pasa mientras se instalan las actualizaciones de Windows
Responder Citando
Los siguientes 3 usuarios agradecen a cramercaba por este mensaje:
dreamfox (23-feb-2012), Eloy58 (18-dic-2011), GenuiWorld (05-ago-2012)
Antiguo 18-dic-2011     #4
Caluroso






Aprende lo que puedas y enseña lo que sepas, el conocimiento es patrimonio de TODOS
Responder Citando
Los siguientes 4 usuarios agradecen a Eloy58 por este mensaje:
baduser (19-dic-2011), cramercaba (21-dic-2011), dreamfox (23-feb-2012), GenuiWorld (05-ago-2012)
Antiguo 19-dic-2011     #5
Predeterminado


"Hay una fuerza motriz mas poderosa que el vapor, la electricidad y la energía atómica, LA VOLUNTAD."
Responder Citando
Los siguientes 3 usuarios agradecen a baduser por este mensaje:
cramercaba (21-dic-2011), dreamfox (23-feb-2012), GenuiWorld (05-ago-2012)
Antiguo 31-dic-2011     #6
Predeterminado

WOW esta muy bien realizado gracias¡¡ por la información amigo justo bucaba esta info Felizz año nuevo¡¡
Responder Citando
Los siguientes 4 usuarios agradecen a xdkizaru por este mensaje:
cramercaba (01-ene-2012), dreamfox (23-feb-2012), GenuiWorld (02-feb-2012), Hunted (31-dic-2011)
Respuesta


(0 miembros y 1 visitantes)
 
Herramientas
Desplegado

Normas de Publicación
No puedes crear nuevos temas
No puedes responder mensajes
No puedes subir archivos adjuntos
No puedes editar tus mensajes

Los Códigos BB están Activado
Las Caritas están Activado
[IMG] está Activado
El Código HTML está Desactivado

Ir al Foro

Temas Similares
Tema Autor Foro Respuestas Último mensaje
Que es Android ..?? Eloy58 Android, WebOS, IOS, ChromeOS 17 10-dic-2015 19:59
Rootear Celulares Android Eloy58 Android, WebOS, IOS, ChromeOS 28 16-nov-2014 13:38
Android OS - Toda la información en este hilo ltnd2k9 Android, WebOS, IOS, ChromeOS 11 15-abr-2014 15:49
ANDROID Glosario Eloy58 Android, WebOS, IOS, ChromeOS 15 01-oct-2013 12:54
Programación en Android GenuiWorld Programación 9 23-feb-2012 02:57


Desarrollado por: vBulletin® Versión 3.8.1
Derechos de Autor ©2000 - 2017, Jelsoft Enterprises Ltd.
Ad Management by RedTyger