El blog de Jose A. López Pastor

Clase 3ª del curso SQL Server 2012

2015-08-17T23:28:00.001+02:00

Os dejo la 3ª clase del curso de SQL Server 2012.
En breve tendremos la 4ª entrega!
Espero que os sirva y os ayude.

Curso sql server 2012 clase 3 from josealopezpastor

Saludos

Llamando a un AlertDialog fuera de una activity

2015-08-07T11:30:00.005+02:00

Esta mañana me he tenido que pelear con un AlertDialog que podía hacer dos opciones, por un lado mandar el documento adjunto por mail o por otro lado abrir el pdf. El problema era que llamaba al AlertDialog desde fuera de la Activity por lo que he tenido que usar

alertDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);

y añadir un permiso en el AndroidManifest.xml

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

El método completo que he usado es el siguiente:

AlertDialog alertDialog = new AlertDialog.Builder(context).create();
alertDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
alertDialog.setTitle("Documento correctamente generado");
alertDialog.setMessage("¿Que desea hacer con el documento?");
alertDialog.setButton(AlertDialog.BUTTON_NEUTRAL,"Mandar por email" ,
        new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                Log.i("Print.java", "Button email");
                Uri path = Uri.fromFile(pdfFile);
                Intent intent = new Intent(Intent.ACTION_SEND);
                intent.setType("message/rfc822");
                Uri uri = Uri.fromFile(pdfFile);
                intent.putExtra(Intent.EXTRA_SUBJECT, "Texto");
                intent.putExtra(Intent.EXTRA_STREAM, uri);
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                intent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
                context.startActivity(intent);
            }
        });
alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, "Imprimir",
        new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                Log.i("Print.java", "Button imprimir");
                Uri path = Uri.fromFile(pdfFile);
                Intent intent = new Intent(Intent.ACTION_VIEW);
                intent.setDataAndType(path, "application/pdf");
                intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                try {
                    context.startActivity(intent);
                } catch (ActivityNotFoundException e) {
                    Toast.makeText(context,"No Application Available to View PDF", Toast.LENGTH_SHORT).show();
                }
            }
        });
alertDialog.show();

Mi primera aplicación para Windows Phone y Windows 8

2015-06-25T14:01:00.001+02:00

Hace unos días me decidí a trastear con Windows Phone y gracias a AppStudio he podido crear mi primera aplicación. Además, gracias a la línea que ha adoptado Microsoft, es bastante sencillo generar el mismo desarrollo para Windows Phone y para Windows 8. Os dejo algunas capturas de pantalla y los enlaces:

Enlace para Windows Phone: aquí

Enlace para Windows 8: aquí

Copiar listas de reproducción de Youtube

2015-06-18T23:48:00.001+02:00

Para los que trabajamos con listas de reproducción de Youtube, hay una herramienta muy interesante que te permite copiar todos los vídeos de una lista de reproducción a una tuya. Os dejo el enlace porque a mi me ha sido muy útil: http://youtubeplaylist.net/

Curso SQL Server 2012. Clase 2

2015-06-12T16:44:00.000+02:00

Os dejo la segunda parte del curso SQL Server 2012.
Cualquier duda que tengáis sobre el mismo o cualquier pregunta no dudéis en en comentarmela.

Saludos

Permisos en Windows Phone 8.1

2015-06-11T00:06:00.002+02:00

De lo poco que he aprendido de mi primer día con Windows Phone es que los permisos han cambiado de Windows Phone a Windows Phone 8.1. Existe esta lista con los permisos anteriores y los permisos actuales.
https://msdn.microsoft.com/en-us/library/windows/apps/dn642081(v=vs.105).aspx

Windows Phone 8 capability WMAppManifest.xml	Windows Phone 8.1 capability Package.appxmanifest	More info
ID_CAP_APPOINTMENTS	Appointments
ID_CAP_CONTACTS	Contacts
ID_CAP_IDENTITY_DEVICE	None
ID_CAP_IDENTITY_USER	None
ID_CAP_ISV_CAMERA	Webcam
ID_CAP_LOCATION	Location	Requires user consent.
ID_CAP_MAP	None	In Windows Phone 8.1, this capability is provided automatically to all applications.
ID_CAP_MEDIALIB_AUDIO	MusicLibrary
ID_CAP_MEDIALIB_PHOTO	PicturesLibrary
ID_CAP_MEDIALIB_PLAYBACK	None	In Windows Phone 8.1, this capability is provided automatically to all applications.
ID_CAP_MICROPHONE	Microphone
ID_CAP_NETWORKING	Internet (Client & Server)
ID_CAP_PHONEDIALER	None
ID_CAP_PROXIMITY	Proximity
ID_CAP_PUSH_NOTIFICATION	None	Windows Phone 8.1 apps that use push notifications with the WNS service don't require a capability.
ID_CAP_REMOVABLE_STORAGE	Removable Storage
ID_CAP_RINGTONE_ADD	None
ID_CAP_SCREEN_RECORDER	None	In Windows Phone 8.1, this capability is provided automatically to all applications.
ID_CAP_SENSORS	None	In Windows Phone 8.1, this capability is provided automatically to all applications.
ID_CAP_SPEECH_RECOGNITION	Microphone
ID_CAP_VOIP	None
ID_CAP_WALLET	None	In Windows Phone 8.1, this capability is provided automatically to all applications.
ID_CAP_WALLET_PAYMENTINSTRUMENTS	None	This capability cannot be used by third-party app developers.
ID_CAP_WEBBROWSERCOMPONENT	None	In Windows Phone 8.1, this capability is provided automatically to all applications.
None	VideosLibrary
None	Shared User Certificates
None	Enterprise Authentication

Curso SQL Server 2012. Clase 1.

2015-05-27T14:45:00.001+02:00

Buenas amigos!!
Hace unas semanas que di un curso de SQL Server 2012 a una empresa. Estaban interesados sobre todo en la parte de administración por lo que el curso no está centrado en el lenguaje SQL propiamente sino en las posibilidades que tiene SQL Server 2012.
Os iré dejando las transparencias por aquí! Espero que os guste y aprendáis!!

Ver el logcat del terminal #Android

2015-05-20T22:01:00.003+02:00

Tras un día de frustración peleándome con Proguard he aprendido como leer el logcat directamente del terminal, sin tener que pasar por el de Eclipse. Y esto para qué, pues bien, cuando pasaba Proguard para generar el apk y lo ejecutaba en el terminal la aplicación se cerraba repentinamente sin dar pistas de porque lo hacía en el logcat de Eclipse.
Tras varias horas en Google en general y stackoverflow en particular encontré la solución con:

adb shell logcat -f sdcard/logoutput.txt

Y entonces puedes buscar en el log donde está el crash. Os dejo la página oficial del logcat aquí
Espero que os sirva!
Saludos

Canciones Educativas en Inglés

2015-02-17T22:32:00.001+01:00

Seguimos creando aplicaciones de calidad para que los reyes de la casa disfruten y a la misma vez aprendan. Esta vez hemos creado una aplicación que te permite ver, ordenadas por categorías, las mejores canciones en inglés que puedes encontrar por Internet. Esperemos que os guste tanto como le gustan a mi niño!
https://play.google.com/store/apps/details?id=com.litlelitodevelopment.cancioneseducativasingles

Como grabar la pantalla de los teléfono Android

2015-02-17T20:03:00.002+01:00

Si tienes Android 4.4 o superior no te hace falta ninguna aplicación para grabar lo que está pasando en tu teléfono. Basta con tener instalado el SDK de Android y el siguiente comando desde la carpeta platform-tools.
adb shell screenrecord /sdcard/archivo.mp4
Para bajarnos la grabación del teléfono a nuestro ordenador solamente tenemos que usar
adb pull /sdcard/archivo.mp4
Dejo aquí la fuente para profundizar y más información.

Como redondear esquinas de imágenes

2014-09-21T23:06:00.002+02:00

Os dejo aquí este vídeo de como redondear las esquinas de las imágenes. Lo he usado varias veces y nunca me acuerdo como se hace ;-)

Capítulo 3. Layout: LinearLayout, RelativeLayout, TableLayout y FrameLayout. (II)

2014-03-04T23:25:00.000+01:00

Accesos rápidos:

Vimos en el post anterior que la apariencia de nuestras pantallas se definía mediante archivos XML que situaremos en la carpeta res/layout.Si vamos al nuevo proyecto que creamos en capítulos anteriores y abrimos esta carpeta veremos un fichero activity_main.xml con un contenido como vemos a continuación:

Lo primero que podemos ver dentro de este fichero es que tenemos un componente RelativeLayout y dentro un componente TextView. En este tema vamos a centrarnos en explicar los elementos contenedores, es decir, elementos en los que introduciremos otros componentes. Estos elementos contenedores son LinearLayout, RelativeLayout, FrameLayout y TableLayout.

Estos elementos son llamados contenedores ya que en su interior se añaden el resto de elementos como botones, etiquetas de texto, imágenes, etc. Vamos a hacer una pequeña descripción de cada uno de estos elementos para posteriormente explicar con detalle sus principales características:

FrameLayout: es el contenedor primario y más básico de todos. Si empleamos este contenedor, cada uno de los componentes que añadamos se van solapando uno encima de otro. Por lo tanto, tendremos que pensarnos muy bien el usar este contenedor si deseamos introducir más de dos componentes en su interior
LinearLayout: los elementos que vamos situando en su interior se van colocando una a continuación del otro. Este elemento tiene una propiedad llamada orientation, que explicaremos en detalle más adelante, mediante la que seleccionamos si los elementos se van añadiendo uno a continuación de otro de forma vertical o de forma horizontal.
RelativeLayout: mediante el empleo de este contenedor podemos indicarle a los elementos que situemos en su interior la posición con respecto a los otros elementos o con respecto al contenedor donde los estamos situando. Este contenedor tiene una serie de variables que nos permiten especificar si queremos situar los elementos a la derecha, izquierda, encima o debajo del resto de elementos.
TableLayout: los componentes que se introducen dentro de este contenedor se distribuyen en filas y columnas. Se tienen propiedades que nos permiten definir el tamaño de las filas y de las columnas.

Vamos a ir cambiando ahora el archivo activity_main.xml para ir viendo como funcionan los contenedores que hemos explicado anteriormente más en detalle. Para este primer ejemplo vamos a usar un FrameLayout, añadiendo en su interior dos componentes del tipo TextView. Para ello vamos a sustituir el código que tiene el archivo por el siguiente:


<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />
    
     <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Otro texto"/>
    
</FrameLayout>

Como hemos dicho, tenemos un componente FrameLayout con dos componentes del tipo TextView en su interior. Al usar este componente, como hemos dicho anteriormente, vamos a ver un texto encima del otro tal y como mostramos en la imagen siguiente.

Ahora vamos a poner un ejemplo con el componente LinearLayout. Vamos a usar este contenedor y dentro vamos a insertar los mismos TextView que en el ejemplo anterior. El código que va a tener nuestro archivo activity_main.xml va a ser el siguiente:


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

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

</LinearLayout>

Como podemos ver estamos usando un componente LinearLayout con el atributo android:orientation="horizontal" por lo que los EditText se colocarán uno a continuación del otro tal y como vemos en la imagen siguiente:

Si cambiamos el atributo android:orientation="horizontal" por android:orientation="vertical", veremos como los EditText se colocan uno debajo de otro tal y como os mostramos en la imagen siguiente:

Ahora vamos a mostrar un ejemplo del componente RelativeLayout. En este caso vamos a usar los mismos EditText. Vamos a escribir el siguiente código que explicaremos a continuación:


<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"> 
    
    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />
    
     <TextView
        android:id="@+id/textView2" 
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/textView1"
        android:text="Otro texto"/>
    
</RelativeLayout>

Podemos ver que ahora le hemos añadido a cada elemento TextView un id para poder referirnos a ellos. Si nos fijamos en el textView2 podemos ver que estamos empleando el atributo android:layout_below="@id/textView1" para indicar que queremos situar este elemento debajo. Lo que veremos será entonces lo siguiente:

Además de below podemos usar toRightOf, toLeftOf or above, para situar un componente a la derecha, a la izquierda o encima de otro. En la imagen siguiente vemos el resultado de usar a android:layout_toRightOf="@id/textView1":

Y ahora por último vamos a explicar el contenedor TableLayout, explicando como se crean las filas y las columnas dentro de la tablas. Para ello vamos a usar este contenedor de la siguiente forma:


<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TableRow>
                  <TextView 
                      android:layout="@+id/textView1"
                      android:layout_width="wrap_content"
                      android:layout_height="wrap_content"
                      android:text="@string/hello_world" />
       </TableRow>
       <TableRow>
                 <TextView
                    android:id="@+id/textView2" 
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:text="Otro texto"/>
       </TableRow>
</TableLayout>

Podemos ver que dentro del contenedor TableLayout tenemos dos componentes TableRow. Cada uno de estos componentes nos va a describir el número de filas que va a tener nuestra tabla. El número de columnas que va a tener la misma va a venir determinada por los elementos que haya en su interior, de modo que si añadimos varios elementos dentro del TableRow tendremos varias columnas. Lo que podemos ver si volcamos el siguiente código en un terminal es lo siguiente:

Con esto damos por cerrado el post. Ya hemos hecho una primera introducción a los contenedores. En la siguiente entrada vamos a dar una explicación más detallada sobre el funcionamiento de los mismos, las alineaciones de componentes y la distribución de los mismos dentro de los contenedores. Hasta el siguiente post y si te es de utilidad, ya sabes, no dudes en compartir ;-)

Como decompilar un APK del market y ver su contenido

2014-02-11T13:43:00.000+01:00

Buenas amigos!! Después de un tiempo con mil lios vengo a contaros una cosa que he aprendido y que me está viniendo genial para mejorar como programador Android. Cuantas veces usando una aplicación en Android habéis dicho: ostras que bien que está esto hecho, como me molaría saber como han programado esta parte, joder que calidad que tiene esta aplicación.

Pues bien, os voy a enseñar a bajaros un .apk del market y ver su contenido ;-). Si, como lo oyes, puedes bajarte un .apk del market y decompilar una aplicación para explorar sus clases, sus layouts, etc. y os voy a enseñar como hacerlo.

Lo primero es bajarse en tu terminal la aplicación que quieres decompilar. Necesitas tenerla instalada para poder sacar el .apk. Bueno pues una vez que te bajas la aplicación que quieres decompilar tienes que instalarte el APK Extractor del siguiente enlace (aquí). Esta aplicación te permite extraer el .apk de cualquier aplicación que tengas instalado en tu terminal tal y como os muestro en la imagen siguiente:

Una vez que el APK Extractor te ha sacado el .apk de la aplicación que quieres estudiar a la SD de tu terminal tienes que mandártela a tu PC, bien por correo, pinchando el teléfono o como te apetezca.

Ahora entra en juego el programa dex2jar. Lo puedes bajar del siguiente enlace (aquí). Este programa va a generar un .jar que luego puedes descomprimir y explorar a partir del fichero .apk. Para ello llevamos el .apk a la carpeta donde tengamos el dex2jar y desde un cmd tecleamos:

dex2jar.bat <fichero .apk>

Veremos entonces que se nos ha creado un fichero con el mismo nombre que el apk anterior que tenemos pero al que se le añade *dex2jar.jar. Este fichero ya podemos descomprimirlo con winrar, winzip o similares. Una vez descomprimido, veremos que tenemos varias carpetas con un montón de clases compiladas de las que no podemos saber nada a no ser que usemos jd-gui que podéis descargar de este enlace (aquí). Este programa se va a encargar de decompilar las clases y nos va a hacer algo como lo que os muestro a continuación:

Ya podéis echar un vistazo a las clases que forman el programa en cuestión y ver como está implementado eso que tanto os fascina.

Espero que os sirva, y si es así, que no os tiemble la mano al compartir!!

PD: he conseguido hacer esto gracias a esta entrada de uno de los mejores blogs de la blogosfera: http://www.elladodelmal.com/

Capítulo 3. Distribución de archivos de los proyectos Android (I)

2014-01-31T08:37:00.000+01:00

Accesos rápidos:

Comenzamos un nuevo tema en el que vamos a explicar la distribución de carpetas de los proyectos Android y los principales componentes que tenemos disponibles como botones, campos de texto, label, etc. Primero recordar que en esta entrada del blog (aquí) nos creamos nuestro primero proyecto en Android. Vimos entonces que en Eclipse teníamos una apariencia como esta:

Vemos que en la parte izquierda de la pantalla tenemos una serie de carpetas y archivos que componen nuestro proyecto y que no explicamos entonces. Vamos a entrar en profundidad a explicar todas y cada una de las carpetas así como la distribución de los archivos en las mismas con el fin de comprender un poco mejor como se programan las aplicaciones en Android. Además nos servirá para introducir el concepto de activity y como se le da la funcionalidad a las pantallas. Los archivos que podemos ver en el proyecto son:

AndroidManifest.xml: es uno de los ficheros más importantes de nuestro proyecto Android. Algunas de las cosas que indicamos en este archivo son los permisos de nuestra aplicación, versiones de Android que son compatibles con la aplicación, las activity de las que consta, etc.
.classpath, .project: ficheros que necesita Eclipse para gestionar el proyecto.
ic_launcher-web.png: icono de nuestra aplicación a alta resolución.
proguard-project.txt: nos da información sobre cómo usar el componente de Android ProGuard. Se trata de una herramienta que modifica nuestra aplicación con el fin de hacerla más difícil de descifrar ante ataques de ingeniería inversa.
project.properties: aquí se indica la versión del SDK que estamos empleando para generar nuestra aplicación.

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Además podemos ver las siguientes carpetas:

assest: aquí guardaremos los ficheros que no queremos sean compilados, por lo tanto serán introducidos en el archivo apk que generamos cuando compilamos nuestra aplicación tal y como se encuentran aquí. Es usado por ejemplo para guardar datos y texturas para juegos.
bin: aquí se almacena nuestro proyecto compilado, es decir, será el directorio de salida de la compilación de nuestro proyecto. Encontraremos entonces ficheros con terminación .class que corresponden a los ficheros .java compilados.

bin/classes: contiene todas las clases compiladas
bin/res: contiene los archivos con imágenes que almacenábamos en res/drawable.

libs: contiene otras librerías externas que añadamos a nuestro proyecto.
res: dentro de esta carpeta almacenaremos los ficheros de imágenes (png, jpg, etc) de nuestra aplicación, los archivos de especificación de las activity, los ficheros de especificación de los menús y, por último los ficheros que definirán las etiquetas de texto y los estilos que usaremos en la aplicación. Las subcarpetas que encontramos dentro de res son:

res/drawable: almacenamos en esta carpeta todos los recursos gráficos que emplearemos en nuestra aplicación. Es decir, en esta carpeta introduciremos los iconos y ficheros png, jpg, bmp, etc. Además podemos observar que hay varias carpetas drawable distintas, con una terminación hdpi, ldpi, mdpi y xhdpi cada una de ellas. Lo ideal es generar tantas versiones de cada archivo como carpetas encontramos, cada una con una resolución distinta. En tiempo de ejecución Android cargará el recurso con la resolución correspondiente al tamaño de pantalla donde se está ejecutando. Así evitamos emplear imágenes con mucha resolución y que, por lo tanto, ocupan mucho espacio en teléfonos que no soportan imágenes con tanta calidad. En el caso contrario, si la imagen tiene poca resolución y la mostramos en una pantalla de tamaño grande, la imagen se pixelará y no se mostrará como deseamos.
res/layout: en esta carpeta se almacenan los archivos que formarán las pantallas de nuestra aplicación. Cada una de estas pantallas se llama activity y se definen mediante archivos XML. Además podemos definir distinta distribución de la activity para distintos tamaños de pantalla. Además también podemos tener carpetas que tengan el sufijo -land, como por ejemplo layout-xlarge-land o layout-land. Añadiendo el sufijo -land indicamos que se tiene que emplear este diseño cuando el teléfono se ponga en posición horizontal. Vemos entonces que tenemos muchas consideraciones de diseño a la hora de implementar nuestra aplicación si queremos que se muestre correctamente en todo tipo de teléfonos.

menu: en esta carpeta se almacenarán los ficheros XML que definen las pantallas de menú. Estas pantallas se emplean generalmente para configurar y establecer las preferencias de nuestra aplicación.
values: en esta carpeta estarán los archivos que nos definan los elementos de texto, colores, estilos y temas de nuestra aplicación. Si vemos nuestra carpeta values, tenemos un fichero llamado string.xml en donde hemos almacenado las etiquetas de texto que tenemos en nuestra aplicación. Si queremos que nuestra aplicación sea multilenguaje y que se muestre en el idioma que tenga predefinido el terminal donde se está ejecutando tenemos que crearnos una carpeta del tipo values-xx.
src: en esta carpeta estarán situados los archivos Java de nuestra aplicación destinados a dotar de funcionalidad nuestro desarrollo. Podemos observar que dentro de esta carpeta hay una serie de subdirectorios formados con el nombre del package y del namespace que empleamos en la creación del proyecto. En este caso src/com/josealopezpastor/holamundo.

Una vez que ya tenemos clara la distribución de carpetas de nuestro proyecto vamos a ir explicando los principales componentes de Android y como podemos emplearlos en nuestro proyecto.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Perspectiva Debug de Eclipse para Android (VIII)

2014-01-06T22:24:00.000+01:00

Accesos rápidos:

Una vez que hemos repasado la perspectiva DDMS en la entrada anterior, vamos a repasar otra perspectiva que puede ser muy interesante para depurar nuestros desarrollos, se trata de la perspectiva debug. Podemos abrirla desde Ventana - Abrir Perspectiva - Otras - Depurar. Se cambiará entonces nuestra pantalla de Eclipse y veremos una distribución como la que vemos a continuación.

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Esta perspectiva es muy interesante para poder consultar el estado de las variables que maneja nuestra aplicación y como se va desarrollando la ejecución de la misma ya que nos permite avanzar sentencia a sentencia. Para poner en marcha estas funcionalidades tenemos que indicar en nuestro código donde queremos establecer un breakpoint y la ejecución se detendrá en ese punto. Solamente se pueden establecer breakpoint en los ficheros Java y para ello tenemos que hacer doble click a la izquierda de la sentencia donde queremos establecerlo. En la imagen siguiente vemos un breakpoint en el establecido en nuestra clase MainActivity.java. Sabemos que tenemos un breakpoint por el punto azul que vemos a la izquierda de la sentencia.

Para lanzar nuestra aplicación en modo debug tenemos que lanzarlo desde el botón situado justa a la derecha de ejecutar . Cuando la ejecución llega a la sentencia donde hemos establecido el breakpoint el emulador se detiene y se habilitan los botones situados en la parte superior que nos permiten ejecutar las instrucciones paso a paso. Para ello tenemos el botón Si pulsamos dicho botón observaremos como la ejecución avanza a la siguiente instrucción.

Y con esto damos por terminado este capítulo. Comenzamos en el capítulo siguiente con los principales componentes Android.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Perspectiva DDMS de Eclipse para Android (VII)

2014-01-06T00:16:00.000+01:00

Accesos rápidos:

Una vez que hemos terminado de explicar como cargar nuestra primera aplicación al terminal Android o al emulador vamos a explicar un par de consejos sobre el uso de Eclipse que nos pueden ser muy útiles a la hora de implementar nuestros desarrollos en Android. Lo primero que vamos a explicar es la una perspectiva de Eclipse que nos puede ser muy interesante a la hora de testear nuestras aplicaciones Android. Se llama DDMS (Dalvik Debug Monitor Server) y aporta abundante información sobre nuestro terminal o el emulador en donde hemos cargado la aplicación. Podemos mostrar esta perspectiva de forma fácil desde Ventana - Abrir perspectiva - DDMS. Para poder obtener toda la información que nos aporta esta perspectiva tenemos que modificar la configuración por defecto de Eclipse y marcar dos check que vemos en la pantalla Ventana - Preferencias - DDMS. Éstos dos check son Thread updates enabled by default y Heap updates enabled by default tal y como se muestra en la imagen siguiente.

Entre las características que nos ofrece esta perspectiva se encuentran la posibilidad de escanear los puertos del emulador, realizar capturas de pantalla, mostrar información de los hilos y la pila de memoria del terminal, visualizar el LogCat, procesos activos e información de la radio, gestionar llamadas entrantes y mensajes de texto y algunas funcionalidades más.
Si tenemos nuestro emulador abierto, podemos abrir la perspectiva DDMS y nuestro Eclipse se mostrará como en la ilustración siguiente. En la parte izquierda y bajo el nombre de devices podemos ver los emuladores que tenemos activos o los terminales que tenemos conectados al PC. Si hacemos click en nuestro emulador se abrirá una lista con todos los procesos que tenemos abiertos. Podemos ver el último de todos el proceso correspondiente a nuestro proyecto.

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Con los botones que tenemos justo al lado de la palabra device actualizamos la información relativa tanto a la memoria consumida por nuestros threads como a la memoria que nos queda disponible de nuestro terminal. También podemos ver, con Network Statistics la gestión de la red que hace nuestro terminal con el fin de optimizar el proceso de carga y consulta de datos. Estas características no la usaremos a no ser que estemos creando grandes aplicaciones o queramos depurar de forma concienzuda el gasto de memoria de nuestra aplicación.
Otra funcionalidad importante de esta perspectiva es la posibilidad de cargar archivos desde el PC al emulador o terminal conectado o viceversa. Para ello tenemos que hacer click en File Explorer. Veremos entonces la estructura de ficheros y archivos que tiene nuestro terminal. Podemos bajar un fichero o subirlo mediante estos botones

Podemos además controlar como se gestionan las llamadas entrantes, sms, localización del dispositivo, etc. Para ello vamos a sacar en esta perspectiva la vista Emulator Control siguiendo la ruta Ventana - Mostrar Vista - Otras - Emulator Control. Veremos ahora una pantalla en la que podemos establecer nuestro terminal en modo ronaming, sin SIM, etc, la velocidad de la red a la que estamos conectando el emulador, simular una llamada entrante desde el número que deseemos, enviar un SMS con un texto que queramos o incluso seleccionar las coordenadas que queramos que tenga nuestro emulador para probar aplicaciones de geolocalización.

Como hemos dicho anteriormente, hemos sacado a esta perspectiva una vista que no venía en la versión por defecto. Es decir, la perspectiva DDMS no trae por defecto la vista Emulator Control sino que la hemos activado nosotros. Si queremos podemos guardar esta perspectiva tal y como la hemos dejado actualmente desde VentanaGuardar perspectiva como. Se nos abrirá un asistente para que establezcamos el nombre que queremos que tenga nuestra nueva perspectiva y la tendremos disponible a partir de ahora. En la siguiente entrada repasaremos la perspectiva Debug que emplearemos para depurar nuestras aplicaciones.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Gestionar los emuladores desde consola (VI)

2014-01-02T21:13:00.002+01:00

Accesos rápidos:

Ya hemos visto como volcar nuestros desarrollos tanto a un emulador como a un teléfono o terminal Android conectado a nuestro ordenador en los capítulos anteriores del curso Android. Ahora vamos a explicar como gestionar los emuladores pero desde consola, sin tener que acceder a la herramienta gráfica de gestión de emuladores de Eclipse. Para ello tenemos que irnos a la ruta donde tenemos instalado el SDK.

Pero además de cómo hemos explicado anteriormente, los emuladores también se pueden crear desde una consola. Estas opciones son válidas tanto para Ubuntu como para Windows. Para ello nos situamos en la carpeta platform-tools del SDK de android ver la carpeta en donde tenemos que hacerlo y tenemos los siguientes comandos:

android create avd -n <name> -target <targetID>

Mediante este comando se crea un emulador con el nombre que especifiquemos en name y con la versión de Android que especifiquemos en -target. Para conocer cuáles son las posibles versiones que tenemos disponibles de Android tenemos el comando siguiente (este comando no se encuentra en el directorio platform-tools sino en tools):

android list targets

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Veremos un listado como muestra en la imagen siguiente con un listado de los posibles niveles del API. El campo id es el que tenemos que indicar en el comando de creación del emulador para especificar el sistema operativo que deseamos.

Otra de las características del emulador que podemos manejar mediante el terminal es el tipo de la pantalla que queremos que tenga.

android create avd -n <name> -t <targetID> --skin WVGA800

Los tipo de pantallas que podemos emplear en función del tamaño y la resolución se muestra en la tabla siguiente. Estos tipos de pantallas son los mismos que vemos en la pantalla de configuración del emulador en la lista de device.

En esta entrada del blog (aquí) ya nos hemos creado un emulador desde Eclipse. Ahora nos crearemos un emulador desde consola. Pare ello usaremos el siguiente comando:

android create avd -n 2-hdpi -t 18 --skin WVGA800

Vemos en la siguiente imagen como hemos creado el emulador

Una vez que tenemos creado el emulador podemos arrancarlos con:

emulator -avd <name>

En este caso

emulator -avd 2-hdpi

Y veremos como se abre nuestro emulador:

Otra cosa que podemos hacer es borrar un emulador. Para ello tenemos el siguiente comando:

android delete avd -n <name>

La documentación oficial sobre la gestión del emulador Android desde consola la podéis encontrar aquí. En los siguientes post de este tema explicaremos un par de consejos que debemos seguir a la hora de emplear Eclipse.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Conectar nuestro terminal Android al ordenador con Ubuntu (V)

2013-12-26T23:37:00.000+01:00

Accesos rápidos:

En la entrada anterior vimos como conectar nuestros teléfonos para volcar nuestros desarrollos desde un entorno en Windows(tienes el enlace justo arriba). Ahora vamos a mostrar lo mismo pero desde Ubuntu. Tenemos que usar los comandos que lleva el SDK para la gestión del emulador. Podéis consultar la documentación oficial aquí. Para ello tenemos que ir a la carpeta platform-tools donde se encuentra instalado el SDK y usaremos el comando

xxx@xxx:~/xxx/android-sdk-linux/platform-tools $ ./adb devices

Veremos entonces que nuestra consola muestra algo como:

List of devices attached ????????? no permissions

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Esto quiere decir que no tenemos nuestro dispositivo correctamente conectado. Tenemos que irnos a cd /etc/udev/rules.d/ y añadir en el fichero 51-android.rules el renglón:

SUBSYSTEM=="usb", SYSFS{idVendor}=="xxxx",MODE="0666"

El idVendor cambia para cada uno de los distintos fabricantes, por lo que tendremos que buscar el que nos interese. Por ejemplo para Samsung tenemos que emplear como idVendor 04e8 y para HTC 0bb4. Podemos encontrar un listado de los idVendor a emplear en la página oficial de Android http://developer.android.com/tools/device.html.

Una vez hecho esto, volvemos /platform-tools/ y reiniciamos el servicio con:

sudo ./adb kill-server
sudo ./adb start-server

Con esto, si ejecutamos de nuevo ./adb devices vermos algo como lo siguiente. Esto nos indica que ya tenemos acceso a nuestro terminal

List of devices attached
S583058235733 device

Ya veremos entonces desde Eclipse tanto el emulador como nuestro dispositivo físico.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Conectar nuestro terminal Android al ordenador en Windows (IV).

2013-12-26T12:24:00.000+01:00

Accesos rápidos:

Si pudiste seguir con éxito el post anterior (aquí), ya habrás sido capaz de volcar tu primero proyecto en el emulador, viendo en la pantalla el mensaje Hello World!. Ahora vamos a volcar el desarrollo a un terminal conectado al ordenador desde un sistema Windows. Lo primero que tenemos que hacer es habilitar nuestro teléfono que permita instalar aplicaciones que no son del Market. Para ello tenemos que ir a Ajustes-Aplicaciones y seleccionamos Orígenes desconocidos. Además tenemos que permitir la depuración por USB desde Ajuste-Aplicaciones-Desarrollo y seleccionamos Depuración de USB.

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Una vez que hemos realizado estos pasos desde el Administrador de dispositivos veremos que nuestro teléfono ha sido correctamente reconocido. Normalmente los drivers de los teléfonos al ser por USB vienen preinstalados en Windows y no hay que hacer ningún otro paso que conectar el terminal.

Si intentamos cargar nuesta aplicación en un terminal veremos entonces que tenemos dos dispositivos disponible, el emulador que nos hemos creado anteriormente y el terminal que hemos insertado por USB.

Como podéis ver se trata de un terminal Android de Sony bastante barato. Ahora si cargamos la aplicación en el terminal podemos ver que se muestra el mismo mensaje. En la siguiente entrada veremos como realizar esta misma operación pero desde Ubuntu

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Usando el emulador de Android en Eclipse (III)

2013-12-23T12:03:00.001+01:00

Accesos rápidos:

Vamos a realizar un pequeño repaso para no perder el hilo del capítulo. Lo comenzamos creándonos nuestro primer proyecto Android llamado Hola Mundo! (aquí), después explicamos los detalles fundamentales de la aplicación que vamos a usar para programar(aquí), es decir Eclipse, y ahora vamos a ver funcionando este primer proyecto en un Emulador de un terminal Android. El paso que tendremos que dar para cargar nuestra aplicación en el emulador sería pulsar el botón con flecha blanca y verde que mostramos en la imagen siguiente. Mediante este botón podemos cargar nuestro desarrollo en un terminal conectado a nuestro ordenador o a un emulador.

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Pero antes de cargar nuestro proyecto de ejemplo vamos a describir en profundidad el emulador de Android. El SDK de Android permite crear tantos emuladores como deseemos, con distintas versiones del sistema operativo y distinta configuración hardware. Podemos tenerlos además activos de manera simultánea de forma que podemos probar el comportamiento de nuestra aplicación en distintos hardware emulados de manera simultánea. Es recomendable además crearnos varios emuladores, cada uno con un tamaño de pantalla distinto. Esto nos permitirá testear el comportamiento de nuestras aplicaciones antes de su instalación en distintos hardware. Los ejemplos y códigos que desarrollemos en este curso serán volcados y probados en el emulador para comprobar su funcionamiento.

Los emuladores se pueden crear y gestionar desde el propio Eclipse. Para ello nos vamos al proyecto que hemos creado y hacemos click en Window-Android Virtual Device Manager y desde el botón New podemos comenzar a crearnos los emuladores necesarios para probar nuestros desarrollos. Veremos entonces una imagen como la que mostramos a continuación.

Para configurar nuestro emulador tenemos que indicar los siguientes parámetros:

AVD Name (Android Virtual Device): nombre que emplearemos para el emulador. No se pueden emplear para el nombre espacios en blanco ni caracteres especiales.

Device: especifica el tamaño de pantalla que emplearemos en el emulador. Podemos elegir entre algunos de los terminales fabricados por Google como Nexus 7 o Nexus One o elegir directamente el tamaño y la densidad de pantalla que queremos emplear. En el tema 6 explicaremos las diferencias entre ldpi, mldpi, hdpi y xhdpi. Ahora simplemente nos fijaremos en que podemos crear múltiples emuladores con distintos tamaños de pantalla distintos, desde 2.7” hasta 10.1”

Target: seleccionaremos la versión de Android que queremos emplear en nuestro emulador. Podemos elegir tantas como SDK hayamos instalado previamente.

Keyword: si queremos emular teclado físico en nuestros dispositivos.

Skin: podemos hacer que nuestro emulador tenga la apariencia del teléfono que hemos seleccionado.

Front Camera – Back Camera: podemos emular la cámara de nuestro terminal mediante la webcam de nuestro equipo de desarrollo

RAM: la memoria RAM que queremos que tenga nuestro emulador.

Internal Storage: cantidad de memoria interna que queremos tenga nuestro emulador

SD-Card: tamaño que queremos especificar como memoria SD de nuestro emulador.

Use Host GPU: nos permite usar el hardware del equipo donde estamos programando para aceleración gráfica. Se necesita Android 4.0.3 (API 15) o superior.

Vamos a crearnos un primer emulador y vamos a volcar en el nuestro proyecto de ejemplo. Este primer proyecto solamente tiene un label que muestra el mensaje Hola Mundo! Para crearnos este primer emulador vamos a usar los siguientes parámetros:

Pulsando el botón OK ya tenemos creado nuestro primer emulador. Ahora solo nos falta una pequeña configuración en Eclipse para poder ejecutar nuestra primera aplicación. Tenemos hacer click en la flecha verde de ejecutar e ir a Run Configurations. Veremos una pantalla como la siguiente:

Tenemos entonces que crearnos una nueva configuración para la ejecución de nuestras aplicaciones Android haciendo click en el botón New Launch Configuration

Seleccionaremos entonces nuestro proyecto y en la pantalla de Target indicaremos que pregunte siempre que emulador elegir antes de lanzar nuestra aplicación:

Ya podemos hacer click en el botón de Run para pasar una nueva pantalla desde la que seleccionamos en que emulador queremos cargar nuestra aplicación.

Y listo, ya veremos el primer proyecto que hemos comenzado con el texto Hola mundo! en la pantalla del Emulador.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Principales componentes de Eclipse para Android (II)

2013-12-15T23:19:00.000+01:00

Accesos rápidos:

En el capítulo anterior (enlace arriba) comenzamos el primer proyecto Android empleando Eclipse. Si todo ha ido con éxito, verás una pantalla con un montón de secciones como la que mostramos a continuación y que iremos explicando con detalle:

Esta es la distribución de componentes de Eclipse para un proyecto Android por defecto, pero podemos configurarcomo deseemos. Vamos a ir explicando los componentes que podemos ver ahora y algunos que nos serán de interés. Si recordamos, en la entrada anterior comenzamos un proyecto llamado Hola Mundo. Por defecto, y por regla general, los proyectos que tenemos almacenados en nuestro workspace se muestran en la izquierda de la pantalla en una sección llamada Package Explorer.

Dentro de esta sección vemos los componentes de nuestro proyecto que explicaremos más adelante. Se puede configurar como se muestra el contenido de nuestros proyectos mediante Windows-Show View y seleccionando Proyecto Explorer o Navigator tal y como mostramos en la imagen siguiente:

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Yo prefiero la vista Navigator por lo que la emplearé a lo largo de los ejemplos. Podemos ver el resultado del cambio de vista en la view de la izquierda como hemos comentado. Explicaremos posteriormente el contenido del proyecto y para que sirve cada archivo.

En la parte central Eclipse se encuentra el editor de archivos. Este editor nos muestra en una pestaña distinta cada archivo que estamos modificando. Para la programación de Android existen fundamentalmente dos tipos de archivos: archivos Java y archivos XML. Mediante los archivos Java se definen los objetos que emplearemos y se dota de funcionalidad a la aplicación mientras que los archivos XML se emplean para la definición de las pantallas (activitys). Cuando hemos abierto Eclipse hemos observado que Eclipse nos muestra que está editando el archivo activity_main.xml. Al tratarse de un archivo de tipo .xml lo estamos empleando para definir la apariencia de una pantalla llamada activity_main.Eclipse permite modificar las activitys mediante un editor gráfico, sin tener que modificar el código de la misma. Podemos insertar nuevos componentes en nuestra pantalla arrastrando componentes a su interior, pero generalmente trabajaremos definiendo y modificando los componentes mediante texto. Para cambiar de este modo gráfico a modo edición de texto tenemos que hacer click en el nombre del fichero en la parte inferior de este editor. Veremos ahora el código que define nuestra activity.

En la vista inferior vemos que hay varias pestañas con otros componentes de Eclipse abiertos. Dos de los componentes que se suelen emplear en esta vista son la Consola y el LogCat, ambos empleados para programar en Android. La consola se encuentra habilitada por defecto pero tenemos que habilitar el LogCat. Para ello Windows-Show View-Other-LogCat y veremos en la parte inferior lo siguiente:

Posteriormente, en siguientes capítulos os mostraremos como utilizar estas ventanas y como depurar nuestras aplicaciones mediante la consola y el LogCat. Ahora pasamos a las vistas que se muestran a la derecha, con el nombre Outline y TaskList no las emplearemos por ahora. Podemos por lo tanto cerrarlas y emplear toda esta parte de la pantalla para el editor de ficheros. Un pequeño truco, si hacemos doble click sobre la pestaña del editor de ficheros veremos que este ocupa toda la pantalla y nos facilita así la edición de archivos. Veremos así como se esconden el resto de vistas a derecha e izquierda. Si volvemos a hacer doble click en la pestaña volveremos a ver Eclipse tal y como estaba anteriormente.

Otro componente importante de Eclipse es la Toolbar. Esta se divide en dos filas, una con los comandos de configuración y modificación de Eclipse y otra fila que nos proveerá de acciones como compilar o ejecutar nuestra aplicación.

Algunas de las cosas más importantes que usaremos de la toolbar son las siguientes:

Archivo: Nos permite entre otras cosas abrir un nuevo proyecto como hicimos en el tema anterior; cerrar proyectos; es recomendable cerrar los proyectos con los que no estemos trabajando; cambiar el espacio de trabajo de donde Eclipse carga nuestros proyectos; importar y exportar proyectos.

Editar: nos permite cortar, copiar y pegar código del editor, deshacer y rehacer acciones y varias tareas más. Habitualmente estas acciones son realizadas empleando atajos de teclado tan extendidos como Ctrl+C (copiar), Ctrl+V (pegar), etc.

Search: lo utilizaremos para buscar expresiones de texto por nuestro código. Lo habitual será emplear Search-Buscar y seleccionar Búsqueda de archivos.

Proyecto: sobre todo emplearemos la opción Propiedades. Desde esta opción se configuran múltiples opciones de nuestro proyecto pero la más importante es poder cambiar la versión del sistema operativo que estamos empleando en nuestro desarrollo. Para ello tenemos que seleccionar Android y a continuación veremos como tenemos seleccionada la opción 4.2 ya que iniciamos el proyecto con ella pero podemos cambiar a otra versión, aunque tenemos que tener cuidado con estos cambios ya que pueden producir errores.

Ejecutar: empleado para compilar nuestra aplicación y cargarla en un emulador o en un dispositivo físico. Estas opciones las usaremos frecuentemente por lo que hablaremos de estas opciones en posteriores capítulos de este tema.

Ventana: desde aquí se cambia la apariencia de Eclipse e indicamos que view y componentes queremos mostrar. Recordad que la empleamos anteriormente para cambiar el menú de navegación del proyecto y para mostrar la vista consola y LogCat. Otra de las cosas que emplearemos a menudo es el cambio de perspectiva. Se trata de una configuración predefinida de Eclipse con varias vistas que nos permite una mayor facilidad a la hora de realizar tareas de depuración del código. Para mostrar la perspectiva de depuración hacemos Ventana-Abrir perspectiva-Depurar. Si queremos cambiar de forma rápida a la perspectiva anterior, podemos hacer click en el recuadro marcado en rojo en la esquina superior derecha en la imagen anterior. Además también podemos personalizar nuestra perspectiva y posteriormente guardarla desde Ventana-Guardar perspectiva. Así la tendremos disponible posteriormente de forma rápida.

Ayuda: lo más relevante de este menú es poder instalar nuevo software para Eclipse en forma de plug-in. Recordad que también lo hemos empleado para instalar el plug-in ADT de Eclipse en el capítulo anterior.

Ya hemos repasado toda la parte superior de la toolbar. En la parte inferior se encuentran accesos rápidos a muchos de los elementos que hemos comentado anteriormente. Sin duda, dos de los que más emplearemos son los botones de depurar y ejecutar. Como su nombre indica, con ellos pondremos a funcionar nuestra aplicación a medida que vamos avanzando en el desarrollo para comprobar su funcionamiento. Para poder depurar y ejecutar nuestras aplicaciones necesitamos un emulador o un dispositivo físico con el que hacerlos. Esto es lo que explicamos en los siguientes capítulos.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 2. Nuestro primer proyecto Android en Eclipse (I)

2013-12-12T18:05:00.000+01:00

Accesos rápidos:

En las dos entradas anteriores instalamos todo lo necesario para comenzar a programar en Android, tanto en Windows (aquí) como en Ubuntu (aquí). En este tema vamos a comentar los aspectos fundamentales de nuestra herramienta de programación, en este caso Eclipse, comenzando por nuestro primer proyecto.

Para comenzar un proyecto tenemos que abrir Eclipse e irnos a File-New-Other y seleccionaremos Android Application Project

Veremos entonces una pantalla como la siguiente:

Esta es la pantalla donde comenzarán nuestro proyectos Android. Lo primero que tenemos que indicar es el nombre de la aplicación, el nombre del proyecto y el nombre del package. En el campo Application Name pondremos el nombre que queremos que tenga nuestra aplicación, por ejemplo en este caso usaremos Hola Mundo. El campo Project Name será el directorio que usaremos para almacenar nuestro proyecto dentro del workspace y el nombre que veremos en Eclipse, en nuestro caso lo llamaremos HolaMundo y por último el Package Name para indicar el nombre de nuestro paquete. Este termino se suele completar con el dominio de la empresa, el nombre de la misma y por último el nombre del paquete. A modo de ejemplo, si nos fijamos en Adobe, una nomenclatura para sus proyectos sería:

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

com.adobe.reader (Adobe Reader)
com.adobe.photoshop (Adobe Photoshop)
com.adobe.ideas (Adobe Ideas)

En la documentación oficial se puede consultar más información sobre como crear el nombre de los paquetes (aquí). En mi caso vamos a elegir com.josealopezpastor.holamundo.

Ahora tenemos que elegir la versión de Android más antigua para la que queremos que funcione nuestro desarrollo en el campo Minimun required SDK, tenemos que indicar la versión de Android más alta donde hemos probado nuestra aplicación en el campo Target SDK y sobre que versión queremos compilar nuestro desarrollo en Compile With. Son muchas las versiones de Android, pero si especificamos como el Minimun Required SDK Android 2.2 y como Target SDK Android 4.3 estaremos cubriendo el 97.7% de los terminales Android tal y como vemos en la página de información de Android (aquí).

Además nos da la opción de seleccionar uno de los themes que Android trae por defecto como son Holo Dark y Holo Light. Holo Dark se caracteriza por tener un fondo negro con el texto en blanco mientras que Holo Light se caracteriza por emplear colores claros con fuentes en negro. Se puede consultar más información sobre los themes de Android en el siguiente enlace (aquí).

Una vez que hemos seleccionado estos parámetros en la pantalla siguiente podemos elegir si queremos que nos cree los iconos necesarios para las distintas densidades de pantalla y si queremos crear una activity por defecto.

En el caso de seleccionar que queremos crear un icono por defecto veremos una pantalla como la que mostraremos a continuación en la que podemos seleccionar una imagen y varios efectos para crear los iconos de nuestra aplicación para cada densidad de pantalla. Posteriormente explicaremos el concepto de densidad de pantalla.

Si hemos dicho que queremos crear una activity pasaremos a la pantalla que mostramos a continuación en la que podemos crear la activity por defecto según varios formatos como son Fullscreen Activity o Master/Detail Flow. Tenemos que indicarle entonces el nombre que queremos ponerle a dicha activity y ya tendremos neustro proyecto inicializado.

Por si se desconoce, Activity es el nombre que tienen en Android las pantallas, cada una de las pantallas se llama Activity. Si una vez hecho esto ves una pantalla como la que mostramos a continuación, ENHORABUENA, ya has creado tu primer proyecto en Android!!

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Como instalar IIS Server en Windows 2003 Server sin el CD

2013-12-10T23:08:00.001+01:00

Esta mañana me he topado con un problema, he tenido que instalar IIS en un Servidor con Windows 2003 Server 64 bits y no tenía el CD.
Tras Googlear un rato he encontrado esto y por ahora me está funcionando:
http://www.microsoft.com/web/downloads/platform.aspx
Te bajas el instalador y te pregunta por todo aquello que quieres instalar: Visual Studio Express, SQL Server Express, PHP, IIS Express, etc.

Espero que os sirva y si os funciona compartir sin miedo!

Capítulo 1. Instalación del entorno de desarrollo de Android en Ubuntu (IV)

2013-12-06T21:32:00.001+01:00

Accesos rápidos:

Una vez que hemos realizado la instalación de todo el entorno de desarrollo en Windows, vamos a realizar la instalación en Ubuntu. La instalación es similar a la de Windows, tenemos que instalar los mismos componentes. Estos son:

SDK de Java
SDK de Android
Entorno gráfico de programación: Eclipse
Plugin para Eclipse.

Los pasos para la instalación son casi los mismos pero de forma un poco distinta :-), lo vimos en el post anterior (aquí). Lo primero que vamos a instalar es Java, concretamente el OpenJDK. Para ello sudo apt-get install openjdk-7-jdk desde una consola. Si todo va de forma correcta podemos y veremos que se nos ha instalado la versión 1.7.09 tal y como muestra la imagen siguiente:

Vamos entonces a bajarnos la versión del SDK de Android que nos corresponda de http://developer.android.com/sdk/index.html para descomprimirlo donde nos interese. En mi caso en la carpeta de mi usuario. Una vez que lo hemos descomprimido tenemos que ir a la ruta adt-bundle-linux-x86/sdk/tools y ejecutar el comando ./android. Se abrirá entonces la ventana del SDK Manager desde el que instalaremos todos los componentes sino tenemos problemas de espacio.

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Una vez que lo hemos instalado todo vamos a instalar el Eclipse. En el mismo caso que para Windows, tenemos que ir a http://www.eclipse.org/downloads/, seleccionamos la versión 32 o 64 bits y una vez que lo descargamos solamente tenemos que moverlo a la carpeta que deseamos y ya podemos ejecutarlo dado que no es necesario instalarlo. Para ello, mediante un terminal solamente tenemos que ejecutar ./android desde la ruta donde lo hemos dejado.

Ahora tenemos que instalar el Plugin para Android. Para ello tenemos que ir a Help-Install new software y en add añadir la URL https://dl-ssl.google.com/android/eclipse/. Tenemos que instalarlo todo, tanto el Developer Tools como el NDK Plugin.

Vamos entonces a vincular Eclipse con el SKD de Android. Para ello tenemos que ir a Open Preferences y especificar donde hemos instalado el SDK tal y como mostramos en la siguiente imagen.

Para comprobar que no tenemos ningún problema, vamos a File-New-Other y ya podemos comenzar nuestro proyecto Android.

Con esto damos por terminado el tema 1, comenzaremos el nuevo tema con nuestro primer proyecto Android, haremos una explicación de como funciona Eclipse para programar Android, conectaremos un terminal físico y os explicaré como instalarse git como repositorio de nuestros proyectos en Android.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier

Capítulo 1. Instalación del entorno de desarrollo de Android en Windows (III)

2013-11-30T11:53:00.000+01:00

Accesos rápidos:

Como hemos comentado en el post anterior de este capítulo (aquí) vamos a comenzar a explicar como se instala el entorno de desarrollo para Android, tanto en Windows como en Linux, comenzando con Windows.

Para poder programar Android con Windown necesitamos instalar los siguientes componentes:

SDK de Java
SDK de Android
Entorno gráfico de programación: Eclipse
Plugin de Eclipse para programar Android

Como hemos dicho, lo primero que tenemos que instalar es el SDK de Java. Se puede descargar de este enlace y la versión a fecha de redacción de este post es la 7u45. Probablemente mientras que lees este post la versión habrá cambiado pero seguramente no habrá ningún problema (más bien es lo más recomdable) si usas la última versión disponible. Ojo tenemos que bajarnos el JDK y no solo el JRE. Con el JRE puedes correr aplicaciones Java pero necesitas el JDK para poder programar. Una vez que te instalas la versión correspondiente a tu sistema operativo y aceptas las condiciones de uso, etc., etc., puede comprobar que está correctamente instalado haciendo java -version desde la consola de comandos. Si tu resultado es como el que vemos en la imagen siguiente, ya tienes el SDK instalado.

PORQUE TE LO MERECES!! VISITA LOS MÁS VENDIDOS DE AMAZON EN MÓVILES

Ahora vamos a por el SDK de Android.Podemos descarlo desde este enlace y una vez en nuestro poder descomprimimos el .zip y ejecutamos el fichero SDK manager.exe. Podemos ver que se trata de un gestor de descargas desde el que se manejan los paquetes que necesitamos para programar en Android. Podemos ver los siguientes componentes:

Android SDK Tools
Android SDK Platform Tools
Android Platform
Extras

En mi caso voy a instalar todos los paquetes y componentes para no tener problemas a la hora de programar en varias versiones de Android.

Una vez que lo tenemos todo instalado, ya podemos comenzar con la instalación del entorno gráfico de desarrollo, el IDE que vamos a emplear para desarrollar nuestras aplicaciones. En el siguiente enlace podemos encontrar la última versión disponible de Eclipse que en el momento de la redacción de este tema es la Eclipse Kepler 4.3.1. Eclipse no necesita instalación por lo que podemos dejarlo en la carpeta que deseemos y ejecutarlo directamente. La primera vez que lo ejecutamos tenemos que indicarle el workspace que vamos a emplear para depositar nuestros proyectos y entonces ya veremos una imagen como la siguiente:

Mirarla con cariño porque este va a ser nuestro espacio de trabajo para programar nuestras aplicaciones en Android a lo largo del curso. Ahora que tenemos el IDE necesitamos el plugin para programar Eclipse. Para ello hacemos Help-Install new software y en add para especificar la url desde la que descargar el plugin. Tenemos que añadir entonces el repositorio https://dl-ssl.google.com/android/eclipse/.

Cuando pulsemos OK veremos que hay dos paquetes disponibles, instalaremos los dos. Durante la instalación nos pedirá que arranquemos Eclipse. En mi caso, me ha mostrado un error al arrancar. Esto es debido a que nos falta un último paso. Una vez instalado el plugin tenemos que especificarle a Eclipse donde tenemos el SKD de Android instalado. Para ello desde Windows-Preferences-Android le especificamos la ruta del SDK de Android que nos hemos descargado. Tenemos que seleccionar la carpeta sdk. Ahora ya podemos comenzar con nuestro primer proyecto en Android desde File-New-Other e indicamos que deseamos realizar un proyecto Android. Solamente le pondremos el título MiPrimerProyecto y daremos a continuar hasta que volvamos de nuevo a nuestra pantalla principal de Eclipse con nuestro proyecto creado.

Si ves una pantalla como la anterior ya puedes comenzar a programar en Android dado que ya tienes todos los componentes instalados correctamente. En el siguiente capítulo explicaremos como instalar todo este entorno pero para Ubuntu.

LIBRO RECOMENDADO PARA APRENDER ANDROID

Uno de los libros fundamientales y que recomiendo para aprender Android y llegar a hacer aplicaciones profesionales es: Android 2 Application Developement de Reto Meier