Herramientas SDK – Capturar fotos – Instalar apps

He visto magníficos manuales en toda la red respecto al mundo android, pero nos solemos olvidar de cosas y trucos que nos hacen mucho mas cómodo el trabajo, en estos días desarrollando las apps y visitando infinidad de webs he recopilado algunas cosas que nos serán útiles, no solo es capturar lo que esta pasando en nuestro android, sino hacerlo de una forma distinta y como se trabaja en modo consola con el sdk,

Partimos de la base de que tenemos instalado el Android SDK en nuestro PC, un “bicho” android sea un móvil o una tablet y su cable de conexión usb entre ambos.

Yo tengo una tablet ACER asi que instale el driver de la pagina de Acer para conectar con la tablet, creo que en ese sentido no es preciso comentar nada mas, me consta que el sdk lleva una serie de driver para estos menesteres.

El aspecto importante en el equipo android es permitir la depuración USB (lo podian haber llamado conexión USB_PC), lo vemos en esta imagen, imagen por cierto que después de leer estos consejos podréis hacer, me preguntareis porque no una captura de cuando no esta seleccionado, pero en ese caso, la conexión con el pc aun no es posible, y la foto se toma desde el propio pc donde esta el SDK, y sin estar habilitada la depuración pues ninguna conexión tendremos.

Las herramientas que vamos a usar están dentro del Android-SDK , y se supone que esta instalado en cierta ruta, no creo necesario explicar como saber esa ruta, en mi caso por ejemplo:

Como vamos a tener que trabajar muchas veces con comando MS-DOS, lo que viene a ser la pantalla negra, o la shell que conocemos de linux, o lo que esta de moda denominar como símbolo del sistema, pues para no tener que escribiendo rutas, vamos a fijar dentro de variables de entorno, las rutas de las carpetas donde tenemos ciertas herramientas del android-sdk, esta carpetas seran /tools y platform-tools/, pero su ruta directa, en este caso:

C:\Users\condor\AppData\Local\Android\android-sdk\tools

C:\Users\condor\AppData\Local\Android\android-sdk\platform-tools

Es fácil añadir al sistema estas ruta, donde encontrar los ejecutables directos, nos vamos a Panel de control, después en Sistema y Seguridad y dentro de aquí en Sistema, que es lo mismo que en el escritorio en el icono  Equipo, clicar con el botón secundario del ratón y fijando Propiedades, y en esa pantalla, seleccionamos:

Configuración avanzada del sistema donde nos saldrá una nueva venta.

Nos encontramos en este punto:

Clicamos  en variables de entorno;

después en el listado inferior sobre Path.

donde nos permite editar la variable Path, que suelen ser donde se ponen las rutas donde el sistema busca los ejecutables. Pues al final de todo añadimos esas dos rutas, ojo, siempre separadas (;) por punto y coma.

De esta forma, siempre que después lancemos el comando cmd o lo que se suele llamar símbolo del sistema, estemos en la ruta que estemos, tendremos acceso a los ejecutables del android-sdk, sin tener que teclear las rutas, es muy comodo perder un poco de tiempo en añadir las rutas. Mas tarde veréis un ejemplo de una ruta completa o directa.

Se supone que ya tenemos activado la casilla de depuración dentro del android, y que nuestro pc nos ha reconocido el dispositivo, se ve enseguida, en mi caso:

Un comando muy bueno que permite saber que dispositivos tenemos conectado, ojo, puede ser un android real o uno emulado , por ejemplo si estamos haciendo correr el AVD Manager, pero la emulación es lenta, así que siempre mejor usar un android directo, es mucho mejor, al menos para las cosas que aun hacemos a este nivel.

adb devices

Saldrán los identificadores de los dispositivos android conectados al Pc, incluso el emulado si exisitiese.

Haremos un inciso en este punto, otro comando muy importate, que te permite instalar una app es el comando adb install.

Si, cierto, es mas facil desde el  google play store (siempre que tengamos conexión a la red) o un enlace de un servidor externo, pero este metodo es muy util, para probar apps que nosotros hemos generado, en mi caso concreto tambien suelo subirla fia ftp al server, y bajarla con el navegador, porque ya tengo las pantallas abiertas y preparadas con el navegador, pero para los que no tengas un servidor o cuenta del market de android como desarroyador, pues este sistema es el mejor, bueno tambien podemos meter la apk, como almacenamiento directo dentro de la sdcard y luego ejecutarla, pero esta vía es la mas rápida (en mi humilde opinión), y ademas, no hace falta ni que tengas un dispositivo, sino que en el android emulado también lo permite

Vemos un ejemplo:

Y ahora otro ejemplo, en el caso que no hubiéramos fijado las rutas dentro de las variables del sistema, vemos que según el caso, hay que teclear pero que mucho, y a los de windows, me consta que eso los estresa mucho.

CommandPrompt.png

Bien, seguimos con la captura de pantalla nuestro android que era el tema principal. Solo para efectuar una captura no es necesario tener las variables de entorno fijadas como he dicho, ni iniciar en modo consola, fue solo un inciso que creí interesante añadir. No es necesario porque la herramienta a usar no es mas que un comando de proceso de lotes, de extensión bat que internamente ya hace la llamada al símbolo de sistema o shell, incluso permanece abierta durante efectuamos las capturas.

Bien, estamos en el punto que hemos seleccionado la depuración usb y conectado el android al pc, y están conectados y reconocidos, ambos dos.

La herramienta es ddms.bat y pinchamos sobre ella, si fijaste las rutas de variables del sistema, si quieres puedes escribir ese comando desde cualquier punto, incluso sin la extensión y veras que también se inicia la herramientas, pero con el doble click típico es suficiente.

Su ruta es dentro de /tools donde tengamos instalado el sdk de android

Vemos que parece el Dalvilk Debug Monitor, y nuestro dispositivo, insisto si fuera emulado con el AVD Manager, pues también aparecería.

En mi caso, en este ejemplo solo esta la tablet, pero podemos tener mas dispositivos. Así que seleccionamos el que deseemos. Y dentro del menú Device seleccionamos Screen Capture.

Lo siguiente que ya podemos ver, es una nueva ventana con la captura de lo que justo esta en el android, incrustada dentro de otra ventana con una serie de botones.

Esta imagen esta retocada uniendo mas los botones para que sea mejor lo que quiero decir, basta con mirar la aspa de color rojo, para notar que en el color algo no cuadra, asi que realmente veréis esos botones mas separados.

Bien, podemos hacer un refresco (Refresh) de la captura por si cambiamos lo que estamos haciendo en android, podemos girar la captura (Rotate), y si queremos guardar la imagen dentro del pc pues en Save, donde nos pedira el nombre, lo típico en estos casos.

La captura grabada sera lo integro del android, sin los botones de la herramienta.

Entenderme ahora porque no pede poner una captura de la depuración USB deshabilitada (sin aspa), porque en ese caso no hay conexión todavía con el Pc, recordar que cuando la habilitemos siempre nos saldrá una aviso de advertencia de lo que se esta haciendo, y añadir que en algunas formas de trabajo con android, hay que configurarlo de forma que permita las aplicaciones de otros sitios que no sea google play store, pero a este nivel eso ya lo sabemos todos.

Recordar que hemos comentado que hay otras formas de instalar apps (aplicaciones android), y que la mas común es via google play, pero si eres desarrollador, y si es tu primera app, o incluso las nuevas que vayas haciendo, para poder publicarla en el google market, se necesitan mínimo 2 capturas de ciertas formas, pues esa sera la mejor forma de poder tomar captura de tus apps antes de subirlas, de hecho, por eso se ha llegado a este manual, o bien pedirlas a un compañero que te las haga, siempre que le hayas pasado la aplicación, o tener un dispositivo que permita la captura de pantalla mediante ciertas apps que las hay y muy buenas, o con cierta combinación de teclas, sin embargo saber que siempre tendréis esta posibilidad, la cual te permitirá hacer capturas rapidísimas y ponerlas en tu pc, y posteriormente subirlas aun server para hacer un manual de este estilo, el cual ademas lleva capturas del propio pc, pero no creo que a estas alturas tengamos que explicar como se captura la pantalla de un pc y como se retoca con el paint.

Así que por favor os pido obviar los comentarios al respecto, del estilo, pues yo uso x app para eso.

La idea es mostrar como se trabaja en base con las herramientas del android sdk, en este caso la toma de capturas, y preparar el pc respecto a las ruta de las herramientas, porque hay muchísimo mas dentro del sdk de android, que digamos es un entorno de trabajo y desarrollo para tratar aplicaciones android nativas. Ojo, es la base para trabajar co ellas, pero no para programarlas, para eso es necesario ademas del sdk, un entorno como eclipse, y no olvidemos el emulador AVD Manager, pero hay cientos de manuales en ese sentido de esos puntos, incluido este mismo portal, y sino, los habrá en un futuro, pero todos son meras copias unos de otros.

Un saludo a www.seguridadwireless.net

 

Desarrollando una aplicación Android

Fuente original, creo que es el mejor tuto para iniciarse, asi pues, lo añado al portal, pero en ese sitio encontrareis muchisimas mas cosas interesantes.

www.sgoliver.net

Dentro del manual también encontrareis multitud de links internos hacia su web.

Después de instalar nuestro entorno de desarrollo para Android y comentar la estructura básica de un proyecto y los diferentes componentes software que podemos utilizar ya es hora de empezar a escribir algo de código. Y como siempre lo mejor es empezar por escribir una aplicación sencilla.

En un principio me planteé analizar en este post el clásico Hola Mundo pero más tarde me pareció que se iban a quedar algunas cosas básicas en el tintero. Así que he versionado a mi manera el Hola Mundo transformándolo en algo así como un Hola Usuario, que es igual de sencilla 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 aprenderemos muchos conceptos básicos, que para empezar no está mal.

Hola Usuario Pantalla 1Hola Usuario Pantalla 2

En primer lugar vamos a crear un nuevo proyecto Android tal como vimos al final del primer post de la serie. Llamaremos al proyecto “HolaUsuario”, indicaremos como target por ejemplo “Android 1.6″, daremos un nombre a la aplicación e indicaremos que se cree una actividad llamada “HolaUsuario”.

Nuevo Proyecto Hola Usuario

Como ya vimos esto nos 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 vamos a hacer es diseñar nuestra pantalla principal modificando la que Eclipse nos 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 estan separados en dos ficheros distintos. Por un lado, en el fichero  /res/layout/main.xml tendremos el diseño puramente visual de la pantalla definido como fichero XML y por otro lado, en el fichero /src/paquetejava/HolaUsuario.java, encontraremos el código java que determina la lógica de la pantalla.

Vamos a modificar en primer lugar el aspecto de la ventana principal de la aplicación añadiendo los controles (views) que vemos en la primera captura de pantalla. Para ello, vamos a sustituir el contenido del fichero main.xml por el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    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 nuestra pantalla principal y se especifican todas sus propiedades. No nos detendremos mucho en cada detalle porque ése será tema de otro artículo, pero expliquemos un poco lo que vemos en el fichero.

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

Dentro del layout hemos incluido 3 controles: una etiqueta (TextView), un cuadro de texto (EditText), y un botón (Button). En todos ellos hemos establecido las siguientes propiedades:

  • android:id. ID del control, con el que podremos identificarlo más tarde en nuestro código.Vemos que el identificador lo escribimos precedido de “@+id/”. Esto tendrá como efecto que al compilarse el proyecto se genere automáticamente una nueva constante en la clase R para dicho control [Aprende más sobre la clase R en el post anterior].
  • 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 (ficherostrings.xml), en cuyo caso indicaremos 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 tenemos definida la presentación visual de nuestra ventana principal de la aplicación. De igual forma definiremos la interfaz de la segunda pantalla, creando un nuevo fichero llamado frmmensaje.xml, y añadiendo esta vez tan solo una etiqueta (TextView) para mostrar el mensaje personalizado al usuario. Veamos cómo quedaría nuestra segunda pantalla:

1
2
3
4
5
6
7
8
9
10
11
12
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  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 deberemos implementar la lógica de la misma. Como ya hemos comentado, la lógica de la aplicación se definirá en ficheros java independientes. Para la pantalla principal ya tenemos creado un fichero por defecto llamadoHolaUsuario.java. Empecemos por comentar su código por defecto:

1
2
3
4
5
6
7
8
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 vimos en un post anterior, las diferentes pantallas de una aplicación Android se definen mediante objetos de tipo Activity. Por tanto, lo primero que encontramos en nuestro fichero java es la definición de una nueva clase HolaUsuario que extiende a Activity. El único método que sobreescribiremos de esta clase será el método OnCreate, llamado cuando se crea por primera vez la actividad. En este método lo único que encontramos en principio, además de la llamada a su implementación en la clase padre, es la llamada al métodosetContentView(R.layout.main). Con esta llamada estaremos indicando a Android que debe establecer como interfaz gráfica de esta actividad la definida en el recursoR.layout.main, que no es más que la que hemos especificado en el fichero/res/layout/main.xml. Una vez más vemos la utilidad de las diferentes constantes de recursos creadas automáticamente en la clase R al compilar el proyecto.

En principio vamos a crear una nueva actividad para la segunda pantalla de la aplicación análoga a ésta primera, para lo que crearemos una nueva clase FrmMensaje que exienda deActivity y que implemente el método onCreate indicando que utilice la interfaz definida enR.layout.frmmensaje.

1
2
3
4
5
6
7
public class FrmMensaje extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.frmmensaje);
    }
}

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

1
2
final EditText txtNombre = (EditText)findViewById(R.id.TxtNombre);
final Button btnHola = (Button)findViewById(R.id.BtnHola);

Una vez tenemos acceso a los diferentes controles, ya sólo nos queda implementar las acciones a tomar cuando pulsemos el botón de la pantalla. Para ello implementaremos el evento onClick de dicho botón, veamos cómo:

1
2
3
4
5
6
7
8
9
10
11
12
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 ya indicamos en el artículo anterior, 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 vamos a utilizar elintent para llamar a una actividad desde otra de la misma aplicación, para lo que pasaremos al constructor una referencia a la propia actividad llamadora (HolaUsuario.this), y la clase de la actividad llamada (FrmMensaje.class).

Si quisiéramos tan sólo mostrar una nueva actividad ya tan sólo nos quedaría llamar astartActivity() pasándole como parámetro el intent creado. Pero en nuestro ejemplo queremos también pasarle cierta información a la actividad, concretamente el nombre que introduzca el usuario en el cuadro de texto. Para hacer esto vamos a crear un objeto Bundle, que puede contener una lista de pares clave-valor con toda la información a pasar entre las actividades. En nuestro caso sólo añadiremos un dato de tipo String mediante el métodoputString(clavevalor). Tras esto añadiremos la información al intent mediante el métodoputExtras(bundle).

Finalizada la actividad principal de la aplicación pasamos ya a la secundaria. Comenzaremos de forma análoga a la anterior, ampliando el método onCreate obteniendo las referencias a los objetos que manipularemos, esta vez sólo la etiqueta de texto. Tras esto viene lo más interesante, debemos recuperar la información pasada desde la actividad principal y asignarla como texto de la etiqueta. Para ello accederemos en primer lugar al intent que ha originado la actividad actual mediante el método getIntent() y recuperaremos su información asociada (objeto Bundle) mediante el método getExtras().

Hecho esto tan sólo nos queda construir el texto de la etiqueta mediante su métodosetText(texto) y recuperando el valor de nuestra clave almacenada en el objeto Bundlemediante getString(clave).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 hemos concluido la lógica de las dos pantallas de nuestra aplicación y tan sólo nos queda un paso importante para finalizar nuestro desarrollo. Como indicamos en uno de los artículos anteriores, 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 nuestra 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 debemos añadir tan sólo la segunda. Para este ejemplo nos limitaremos a incluir la actividad en el XML, más adelante veremos que opciones adicionales podemos especificar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="utf-8"?>
      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, deberíamos poder ejecutar el proyecto sin errores y probar nuestra aplicación en el emulador.