Mostrando entradas con la etiqueta móviles. Mostrar todas las entradas
Mostrando entradas con la etiqueta móviles. Mostrar todas las entradas

lunes, 9 de marzo de 2015

Notificaciones en Android (2da Parte)

image

En el artículo anterior comenzamos a abordar el tema de las notificaciones en Android. Hablamos de los Toast que son las notificaciones más simples que tiene Android. En este artículo vamos a hablar acerca de las notificaciones en la barra de estado. Este tipo de notificaciones son las que se muestran en el dispositivo cuando entra un SMS o cuando nos hacen una llamada perdida.

Estas notificaciones generalmente constan de un icono y un texto descriptivo del mensaje, al desplegar la barra de estado vamos a poder ver la notificación más descriptiva.

Pues bien vamos a hacer un ejemplo donde mostremos una notificación en la barra de estado.

Vamos a crear un botón que al presionarlo pondrá en la barra de estado la notificación. El diseño de nuestro ejemplo quedará de la siguiente manera:

image

Ahora vamos a entrar en el código. Lo primero que tenemos que hacer es capturar el evento clic de nuestro botón para esto en el método onCreate de nuestra Activity vamos a capturar el botón.
Button boton = (Button)findViewById(R.id.button);
Y luego vamos a definir el onclick del botón
boton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {

}
});
Y es en el método onClick donde vamos a poner todo el código para mostrar la notificación. 

Lo primero que vamos a hacer es obtener una referencia del servicio de notificaciones de Android. Para esto utilizaremos el método getSystemService como muestra el siguiente código.

//Obteniendo la referencia al servicio de notificaciones
String service = Context.NOTIFICATION_SERVICE;
NotificationManager notManager = (NotificationManager) getSystemService(service);

Luego vamos a configurar el aspecto de la notificación que vamos a mostrar para ello definimos el icono que vamos a mostrar, el texto y la hora y se lo pasamos al constructor de la notificación.

//Configuramos la notificación
int icono = android.R.drawable.stat_notify_error;
CharSequence texto = "Probando Notificacion";
long hora = System.currentTimeMillis();

Notification notificacion = new Notification(icono, texto, hora);


Y por último nos queda definir el texto y la descripción que se mostrará al desplegar la barra de notificaciones, así como la Activity que se mostrará cuando seleccionemos la notificación.

//Configuramos el Intent
CharSequence titulo = "Mensaje de Alerta";
CharSequence descripcion = "Ejemplo de notificación.";

Intent notIntent = new Intent(getApplicationContext(),
MainActivity.class);

PendingIntent contIntent = PendingIntent.getActivity(
getApplicationContext(), 0, notIntent, 0);

notificacion.setLatestEventInfo(
getApplicationContext(), titulo, descripcion, contIntent);


Como podemos ver en el código anterior lo primero que hacemos es preparar la información, es decir el título, la descripción y el intent que ejecutaremos cuando la notificación sea seleccionada. Luego creamos un PendingIntent y le atachamos el intent creado y luego con el método getApplicationContext de la notificación terminamos de preparar la misma.

Una vez configurados todos los parámetros necesarios de la notificación pues procedemos a mostrar la misma, esto lo hacemos de la siguiente forma:

//Mostrando notificación
notManager.notify(1, notificacion);

Con el objeto NotificationManager creado al inicio y mediante su método notify conseguimos lo que queremos, pasándole un id único de notificación y el objeto Notificación que preparamos con anterioridad.

{ Leer Más }


miércoles, 28 de enero de 2015

Menús en Android (1ra Parte)

image

En este artículo vamos a hablar sobre los menús en Android, un recurso importante para nuestras aplicaciones cuando queremos mostrar opciones secundarias o queremos simplificar espacio dentro de la vista. En Android existen tres tipos diferentes de menús:

· Menús principales: De estos decir que son los más habituales, aparece cuando se oprime el botón menú del dispositivo en la parte inferior del mismo.

· Submenús: Son usados para mostrar opciones secundarias y se pueden mostrar al pulsar una opción del menú principal.

· Menús Contextuales: Aparece cuando se hace una pulsación larga sobre algún elemento de la vista de la aplicación.

En este artículo hablaremos sobre el primer tipo de menú y dejaremos los otros tipos de menú para próximos artículos.

Los menús los podemos implementar de dos formas en nuestra aplicación, una mediante la definición en un fichero XML y la segunda mediante código. En este artículo abordaremos la primera por ser la que más utilizo por su rápida implementación.

Para entender el tema de los menús pues nada mejor que llevarlo a la práctica y para esto le pondremos unos menús a la app que comenzamos en los artículos anteriores.

Para diseñar un menú es necesario crear el fichero menú.xml en la carpeta res / menú. En nuestra app pondremos un menú con tres opciones, por lo que el diseño quedaría así:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/Menu1" android:title="Opción 1"
android:icon="@drawable/tag"></item>
<item android:id="@+id/Menu2" android:title="Opción 2"
android:icon="@drawable/filter"></item>
<item android:id="@+id/Menu3" android:title="Opción 3"
android:icon="@drawable/chart"></item>
</menu>

Este XML se compone de un elemento principal <menu> que contiene tantos elementos <item> como opciones queramos ponerle a nuestro menú. Destacar que los elementos <item> tiene propiedades como el id, el título y el icono. Podemos observar que nuestro XML tiene un detalle y es que los títulos están puestos directamente, algo que vimos que no era aconsejable, para esto creamos los Strings de las opciones y lo referenciamos en el XML por lo que quedaría así:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/MenuPrincipal"
android:title="@string/texto_opcion1_menu"
android:icon="@drawable/tag"></item>
<item android:id="@+id/Menu2"
android:title="@string/texto_opcion2_menu"
android:icon="@drawable/filter"></item>
<item android:id="@+id/Menu3"
android:title="@string/texto_opcion3_menu"
android:icon="@drawable/chart"></item>
</menu>

Ahora tenemos que implementar el evento onCreateOptionsMenu() del activity que queremos que muestre el menú. En este evento vamos a “inflar” el menú. Primero obtendremos una referencia al inflater mediante el método getMenuInflater() y posteriormente generamos la estructura del menú llamando a su método inflate() pasándole como parámetro el ID del menú definido en el XML que en nuestro caso será R.menu.menu. Por último devolveremos el valor true para confirmar que debe mostrarse el menú.

Ahora solos nos queda implementar cada una de las opciones del menú. Esto se hará incluyendo el evento onOptionsItemSelected() del activity que mostrará el menú. Este evento recibe como parámetro el ítem que fue pulsado, cuyo ID podemos recuperar con el método getItemId(). Con el ID podemos saber qué opción ha sido pulsada y ejecutar lo que queramos. Por ahora lo único que haremos es mostrar un mensaje.

@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.Menu1:
Toast.makeText(this, "Opcion 1 pulsada!",
Toast.LENGTH_LONG).show();
return true;
case R.id.Menu2:
Toast.makeText(this, "Opcion 2 pulsada!",
Toast.LENGTH_LONG).show();
return true;
case R.id.Menu3:
Toast.makeText(this, "Opcion 3 pulsada!",
Toast.LENGTH_LONG).show();
return true;
default:
return super.onOptionsItemSelected(item);
}
}

De este código solo comentar como se muestra el mensaje y es utilizando la clase Toast, el mismo tiene el método makeText para indicar el texto que se mostrará en el mensaje y luego usamos el método show() para que se muestre en nuestro activity. De las notificaciones hablaremos en próximos artículos.

{ Leer Más }


lunes, 12 de enero de 2015

Nuestra primera aplicación (1era Parte)

image

Ya viene siendo hora de ponernos a programar. Soy de los que piensa que en la práctica es donde mejor se aprende la teoría por lo que hoy vamos a hacer una pequeña aplicación donde aplicaremos lo visto en artículos anteriores y algunas cosas nuevas. Nuestra primera aplicación lo único que hará es tener un botón que al hacer clic cambie su texto.

Lo primero que haremos es abrir el eclipse. Yo usaré la versión Indigo. Una vez abierto el eclipse crearemos una nueva aplicación para esto vamos a File > New > Android Project nos saldrá un cuadro donde pondremos el nombre de nuestra aplicación. Yo le llamaré Primera App. Luego deberemos seleccionar para qué versión de Android haremos nuestra aplicación. Esta selección es importante pues la versión que seleccionemos significará que será la versión mínima de Android que debe tener la aplicación que crearemos. En estos artículos usaremos la versión 2.2 por ser una de las más usadas.

Después de haber seleccionado la versión, entonces nos tocará seleccionar el nombre del paquete. En nuestro caso pondremos el siguiente: softpei.app. También debemos seleccionar el nombre de nuestra Activity. No hemos explicado qué es un Activity, pues llegó el momento: un Activity no es más que el componente principal de la interfaz gráfica. Viene siendo como la ventana en cualquier lenguaje visual. En nuestro caso seleccionaremos como nombre de nuestro Activity el de PrimeraActivity.

Con esto ya hemos creado los parámetros iniciales de nuestra aplicación. Ahora nos dedicaremos a la parte visual de la aplicación. Como vimos en el artículo Conociendo la estructura de un Proyecto Android, para ver el XML que representará la interfaz visual de nuestra Activity vamos a la carpeta res > layout. Ahí tendremos el fichero main.xml que por defecto tendrá el siguiente código:

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

</LinearLayout>

Aquí podemos ver que por defecto el Layout es linear con una orientación vertical y dentro hay un texto que tiene como valor lo que está en la variable hello.

Nosotros le haremos a esto unos pequeños ajustes, y es que quitaremos ese texto y pondremos un botón; entonces el código quedará así:

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

Aquí vemos que el texto del botón tiene un valor escrito en el fichero por lo que, como vimos en Los textos en Android es importante poner todos nuestros textos en el fichero strings.xml por lo que vamos a crear una variable en este fichero de nuestra aplicación para asignárselo al texto del botón creado. Nuestro fichero de textos quedaría así:

<resources>

<string name="hello">Hello World, PrimeraActivity!</string>
<string name="app_name">Primera App</string>
<string name="texto_boton">Aceptar</string>

</resources>

Ahora procedemos a modificar el valor del botón por la variable creada, por lo que el main.xml quedará así:

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

Bueno ya tenemos la parte visual casi lista. Solo nos quedaría crear también un texto para cuando hagamos clic sobre el botón, para esto creamos otra variable en el fichero strings.xml:

<string name="texto_boton_clickeado">Botón Clickeado</string>
Con esto ya hemos terminado la parte visual, ahora nos quedará la lógica pero esto lo veremos en un próximo articulo.
{ Leer Más }


martes, 9 de diciembre de 2014

Entorno de desarrollo en android.

clip_image001

En este tutorial aprenderemos cómo preparar el entorno de trabajo para comenzar a hacer aplicaciones para el sistema operativo Android.

Lo primero que debemos hacer es descargar los archivos y programas necesarios:

· IDE Eclipse que se puede descargar desde este link.

· SDK de Android que se puede descargar en la página de Android developers. Este paquete incluye muchas herramientas que nos van a hacer de mucha utilidad a la hora de programar para Android.

· Plugin ADT, que es un plugin para hacer de eclipse un ide ideal para hacer aplicaciones Android.

Primero debemos comprobar que nuestra computadora tienes los requerimientos mínimos que son necesarios para que todo se instale bien. Esto se puede hacer leyéndolo en la página de Android developers.

Si el eclipse que tenemos está en un compactado, lo extraemos y lo ponemos en cualquier carpeta de nuestra PC. Cuando ejecutamos el eclipse lo primero que nos pide es una dirección que es donde el eclipse guardará todos los proyectos que vayamos creando. Si queremos que esto no nos lo pida más pues elegimos la opción de no preguntar de nuevo.

Ahora vamos a encargarnos del SDK. Este puede estar en un compactado o en un ejecutable. Si fuera un compactado pues lo extraemos en lo ponemos en cualquier carpeta de nuestra PC, si es un ejecutable pues en uno de los pasos nos pedirá la dirección de la carpeta hacia donde queremos instalar el SDK.

Es importante señalar que para que todo esto que estamos montando funcione es necesario el entorno Java por lo que busca los instaladores necesarios para que esto esté correctamente instalado en tu PC.

Para instalar el ADT podemos hacerlo de dos formas, la primera es en nuestro Eclipse vamos a la opción Help -> Install New Software… Damos un click sobre el botón Add, en el cuadro de Add Repository escribimos “ADT Plugin” en el campo Name y en Location escribimos la URL https://dl-ssl.google.com/android/eclipse/. Otra forma de hacer esto es descargarndo el plugin de internet y obteniéndolo de alguna otra vía y copiando en la carpeta plugins que está en el directorio donde esta intalado nuestro Eclipse.

Ahora vamos a decirle al Eclipse dónde es que está el SDK de Android. Para esto vamos a la opción Window -> Preferences… ahí seleccionamos la opción Android del panel de la izquierda y seleccionamos Browse… donde elegiremos la carpeta donde pusimos o instalamos nuestro SDK.

Ya casi tenemos listo nuestro entorno de desarrollo, ahora vamos a descargar los componentes esenciales de SDK. El SDK separa los elementos principales en componentes que se pueden instalar por separado. Para poder desarrollar en Android necesitamos al menos descargar una plataforma Android con sus herramientas asociadas por lo que vamos a Windows -> Android SDK and AVD Manager y elegimos Avaible packages en el panel de la izquierda. En el panel de la derecha vamos a poder ver todas las opciones disponibles para descargar.

clip_image002

De este listado podrás seleccionar todas aquellas que quieras. Las plataformas se adaptan a la versión de Android por lo que si su teléfono tiene instalado Android 2.2 pues deberá descargar esta plataforma o una de las inferiores para poder probar las aplicaciones en él. Dependiendo del número de plataformas y componentes que hayas decidido descargarte, esta parte puede tardarte un poco.

Con estos pasos hemos configurado nuestro entorno para comenzar a desarrollar para Android. Ya estamos listo para hacer nuestra primera aplicación. Espero que les haya sido de ayuda.

{ Leer Más }


jueves, 4 de diciembre de 2014

¿Qué es Android?

image

Imagino que en la actualidad hablar de Android debe ser un tema bastante conocido para todos, pero en este artículo trataré de contar en pocas palabras la historia del que se ha convertido en el sistema operativo más usado en los celulares del mundo.

La historia de Android comienza cuando el empresario y desarrollador Andy Rubin se le ocurrió la idea de desarrollar un sistema operativo para celulares basado en la filosofía Open Source, de forma de que fuera de código abierto, adaptable a cualquier hardware y que tuviera un entorno de desarrollo único que permitiera crear aplicaciones que corrieran en el sistema operativo y que cualquier hardware lo soportara.

El sistema operativo Android se compone de aplicaciones que se ejecutan en un framework Java de aplicaciones orientadas a objetos sobre el núcleo de las bibliotecas de Java en una máquina virtual Dalvik con compilación en tiempo de ejecución. Las bibliotecas escritas en lenguaje C incluyen un administrador de interfaz gráfica (surface manager), un framework OpenCore, una base de datos relacional SQLite, una Interfaz de programación de API gráfica OpenGL ES 2.0 3D, un motor de renderizado WebKit, un motor gráfico SGL, SSL y una biblioteca estándar de C Bionic. El sistema operativo está compuesto por 12 millones de líneas de código, incluyendo 3 millones de líneas de XML, 2,8 millones de líneas de lenguaje C, 2,1 millones de líneas de Java y 1,75 millones de líneas de C++.

clip_image002

Android tiene una gran cantidad de desarrolladores que escriben aplicaciones para extender la funcionalidad de los dispositivos. En la actualidad existen más de 1 millón de aplicaciones, de las cuales dos tercios son gratis.

El sistema operativo ha tenido numerosas actualizaciones desde su liberación inicial. Estas actualizaciones básicamente arreglan bugs y agregan nuevas funcionalidades. Es interesante el hecho de que estas actualizaciones se han desarrollado bajo un nombre relacionado con postres en orden alfabético.

Para nosotros los programadores existen muchas oportunidades de poder hacer nuestro aporte a esta gran cantidad de aplicaciones existentes. Las aplicaciones de desarrollan habitualmente en el lenguaje java con Android Software Development Kit (Android SDK) pero existen otras herramientas de desarrollo incluyendo un Kit de Desarrollo Nativo para aplicaciones o extensiones en C, C++, Google App Inventor, un entorno visual para programadores novatos e incluso el Mono for Android, una aplicación para convertir aplicaciones de Windows pone en aplicaciones Android. También es posible usar bibliotecas Qt gracias al proyecto Necesitas SDK.

El desarrollo de aplicaciones para Android no requiere aprender lenguajes complejos de programación, todo lo que hace falta es un conocimiento básico en Java y tener el kit de desarrollo de software (SDK) el cual se puede adquirir gratuitamente.

Con este breve recuento del sistema operativo Android espero que los que todavía no lo conocen se documenten más sobre el mismo y que los desarrolladores de software comiencen a adentrarse en el fascinante mundo del desarrollo de aplicaciones Android.

{ Leer Más }


jueves, 27 de junio de 2013

Sugerencias para usar ZK 6.5.x en dispositivos móviles.

clip_image002

A partir de la versión 6.5 del Framework ZK, los desarrolladores pueden aprovechar el poder de ZK para crear una aplicación web, que funcione correctamente en dispositivos móviles como una tableta (Tablet, en inglés).

Como ya sabemos, existen diferencias entre el hardware de una tableta y un PC, debemos pensar diferente en la fase de diseño, teniendo en cuenta cada detalle que necesita ser ajustado para que se vea como esperamos en todos los dispositivos, y por lo tanto consigamos proveer de una buena experiencia al usuario en ambos. A continuación mostraremos como puedes controlar y usar ZK 6.5 para hacer el mejor uso de él.

Diferentes estilos

En una tableta, los usuarios operan con sus dedos, mediante interacciones de tipo táctiles, por lo tanto el tamaño de los componentes en los que tiene que hacer clic (por ejemplo botones) no puede ser muy pequeño, 24px x 24px es el límite.

Por otra parte, si el tamaño del componente es pequeño, el espacio entre componentes debe ser grande, para evitar que el usuario pulse los botones cercanos por error.

ZK ha ajustado los componentes de acuerdo a este principio, por ejemplo Combobox,Timebox y Colorbox, los desarrolladores ahora pueden usarlos en un dispositivo móvil directamente. Para más detalles, te recomendamos que leas: UI Enhancements.

Diferentes eventos:
Eventos de Ratón

Como no hay ratón o cursor en las tabletas, los eventos relacionados con el ratón son diferentes que en el escritorio tradicional.

Primero de todo, onMouseOver no está soportado, tooltip y autodrop tampoco funcionan en una tablet. Segundo, onRightClick no está soportado directamente por el browser nativo como evento, pero ZK simula este evento del siguiente modo "pulsar y aguantar pulsado un momento", por lo tanto la propiedad context (que muestra el menú contextual) y onRightClick pueden ser usados en una tablet.

Por otra parte, si a Image o Div se les añade la propiedad onClick, los desarrolladores deben añadir el CSS cursor: pointer; en el atributo sclass o style, para que el navegador del tablet pueda gestionar la propiedad onClick correctamente.

ClientInfoEvent

Los usuarios pueden cambiar fácilmente la orientación de la tablet, por lo tanto los desarrolladores tienen que poder identificar cual es la orientación que los usuarios están usando y aplicar los cambios necesarios al tamaño y diseño. ZK 6.5 añade esta información sobre la orientación en el objeto ClientInfoEvent, simplemente añadimos atributo de evento onClientInfo para obtener el objeto ClientInfoEvent y accedemos a su método getOrientation(), isPortrait() o isLandscape().

Por ejemplo:

<tabbox id="tbx" height="400px" width="600px">
<attribute name="onClientInfo"><![CDATA[
ClientInfoEvent oe = (ClientInfoEvent) event;
lbl.setValue(oe.getOrientation());
if (oe.isPortrait()) {
tbx.setHeight("600px");
tbx.setWidth("400px");
} else {
tbx.setHeight("400px");
tbx.setWidth("600px");
}
]]></attribute>
<tabs>
<tab label="tab 1" />
</tabs>
<tabpanels>
<tabpanel>
Current Orientation:
<label id="lbl" />
</tabpanel>
</tabpanels>
</tabbox>


Otras consideraciones acerca del scrolling

En el artículo Scrolling on Tablet se realizó un análisis sobre el principio básico de scroll en tablets.

A continuación, discutiremos a cerca de algunos componentes muy comunes que puede que uses en tu implementación.

· Para crear un nuevo text area, puedes usar <textbox multiline="true" />cuando el contexto es grande, puedes hacer scroll en el componente Textbox. Este comportamiento lo maneja directamente el navegador, nada que ver con ZK, por lo tanto, su comportamiento será diferente de otros componentes en los que es ZK quien controla el scroll.

· Si el sistema contiene un Image, el desarrollador debe especificar el tamaño para o activar la precarga mediante el atributo a tal efecto, de cualquier otro modo, el scroll no funcionará como se espera. Veamos un ejemplo a continuación.

<zk>
<window contentStyle="overflow:auto" height="300px" border="normal">
<image src="http://www.zkoss.org/resource/img/index/src/top_bannerimage3.png" />
<div>bottom</div>
</window>
</zk>

En este caso, Window no producirá una barra de scroll, el usuario final de la aplicación no podrá ver la imágen entera, puesto que no podrá hacer scroll de la misma.

Esto se soluciona de 2 formas, 1. Activando el atributo de preload como en el siguiente ejemplo.

<zk>
<window contentStyle="overflow:auto" height="300px" border="normal">
<custom-attributes org.zkoss.zul.image.preload="true"/>
<image src="http://www.zkoss.org/resource/img/index/src/top_bannerimage3.png" />
<div>bottom</div>
</window>
</zk>

2. O indicando el tamaño de la imagen, como en el siguiente ejemplo:

<zk>
<window contentStyle="overflow:auto" height="300px" border="normal">
<image height="500px"
src="http://www.zkoss.org/resource/img/index/src/top_bannerimage3.png" />
<div>bottom</div>
</window>
</zk>

Nuestra recomendación es activar el atributo de precarga en el fichero de configuración zk.xml para evitar tener que hacerlo en todas las imágenes, una a una.

· No te recomendamos que asignes el número de filas en el componente Listbox, es decir que no establezcas ningún valor en el atributo rows, como en el siguiente ejemplo.

<zk>
<zscript> String[] s = new String[100]; </zscript>
<listbox id="lbx1" height="300px">
<zk forEach="${s}">
<listitem label="${forEachStatus.index + 1}" />
</zk>
</listbox>
<listbox id="lbx2" rows="8">
<zk forEach="${s}">
<listitem label="${forEachStatus.index + 1}" />
</zk>
</listbox>
</zk>

En el iPad, solo una pequeña parte de los 10 elementos del componente lbx1 es visible, el usuario final verá que es incompleto y hará scroll de forma natual. Este efecto no es el mismo en el componente lbx2, puesto que hemos establecido el número de filas "rows" a un valor. Esto sucede de igual modo en los componentes Grid y Tree.

Tan simple como sea posible

Como hemos mencionado antes, el tamaño de la pantalla en tablets o teléfonos móviles es mucho más pequeño y los componentes crecen respectivamente para facilitar al usuario final la interacción con ellos. Por lo tanto, no es prudente crear un diseño complejo para que los usuarios interactuen con él meticulosamente.

La potencia de procesar es mucho menor en un tablet que en un PC tradicional. El tiempo de renderizado en un ordenador de escritorio, puede ser lo suficientemente breve como para ignorarlo, pero puede ser un problema en una tablet. Por lo tanto el diseño de websites para tableta siguiendo el concepto "Tan simple como sea posible" es muy importante.

Otra forma de mejorar la velocidad de rendimiento es activar el atributo ROD de los componentes de tipo Listbox, Grid y Tree.

Conclusión

ZK 6.5 provee de la habilidad de crear aplicaciones web para el escritorio y la tableta desde el mismo código de base. Pero teniendo en cuenta a la hora de desarrollar algunas de las diferencias a las que hemos apuntando.

Envíenos sus comentarios.

{ Leer Más }


IconIconIcon