Archivo de la etiqueta: aplicación

Android como plataforma de desarrollo

Hola a todos,

Trayéndoles las siguientes notas del curso de Android, ahora vamos a conocer a Android como plataforma de desarrollo. Conoceremos las herramientas con las que podemos producir aplicaciones Android, cómo se administra la ejecución de las aplicaciones, cómo y qué se debe tomar en cuenta al desarrollar una aplicación.

Aquí las notas: http://www.nachintoch.mx/teaching/mobile_dev/android-framework.pdf

Estructuras de datos aplicadas – Ejemplo de árboles: sistemas de archivos

Saludos a todos,

después de casi medio año sin publicar nada; he vuelto de los rincones más fríos y oscuros de la vida y sus constantes altibajos; de pendiente prácticamente infinita pensada como derivada 😛 Y esta semana procuraré ponerme al corriente con el material que he trabajado en este tiempo.

En fin, en este post les dejo unas notas en las que se ejemplifica la estructura de datos árbol usando sistemas de archivos.

Muchos sistemas operativos, trabajan con sistemas de archivos que ocupan una jerarquía de directorios para organizar los archivos del sistema y sus usuarios.

Por ejemplo, Windows usa varios árboles enraizados en cada unidad. Así, el disco duro principal del sistema se identifica como C:\ y los directorios que contiene son hijos de este nodo raíz C:\; por ejemplo, users, windows, program files, etc. Y a su vez, estos directorios son raíces de más subárboles enraizados en ellos, y así sucesivamente.

Linux y Mac; en general los sistemas POSIX-compatibles, usan un sólo árbol que agrega dinámicamente los subárboles de los dispositivos que se le conecten o inserten al sistema; tales como memorias USB, CD, smartphones, etc…

Los archivos en todo caso, son siempre hojas en los árboles de los sistemas de archivos.

Y el enlace a las notas: http://www.nachintoch.mx/teaching/intro_data_structure/21_abr-EjemploarbolesSA.pdf

Y un ejemplo en Java: http://www.nachintoch.mx/teaching/intro_data_structure/ejemplo_arboles_archivo.zip

Saludos!

Python, Django & Javascript: Manipulación de imágenes con Pillow y API de Google Maps para Javasceipt

Hola a todos!

En esta ocasión quiero compartirles unas notas bastante interesantes. Estas hablan sobre:

  • Manipulación de imágenes con Python/Django usando la biblioteca Pillow.
  • Uso del API de Google Maps.

En las notas no lo incluyo, pero el servicio de Google Maps es gratuito cuando se tiene un tráfico pequeño. Es muy recomendable también siempre obtener una clave para nuestra aplicación para asegurar el servicio de Google Maps.

Y sin más, les dejo un enlace a las notas:

Haz clic para acceder a 6_abr%20-%20Manipulaci%C3%B3n%20de%20gr%C3%A1ficos.pdf

Espero les sea de utilidad.

Saludos!

Introducción a Python y Django

Hola a todos,

Les comparto unas notas sobre Python: qué es, cómo instalarlo en distintas plataformas y una muy breve introducción para empezar a programar en dicho lenguaje. Sin embargo, es importante mencionar que no es una guía para principiantes y se recomienda seguirla cuando se tienen conocimientos previos de programación.

Luego usamos los aprendido para empezar a desarrollar aplicaciones con Django, que es un framework que nos facilita el desarrollo de aplicaciones web con Python.

Link a las notas:

http://www.nachintoch.mx/teaching/tech_risk/IntroaPythonDjango.pdf

Espero les sean de utilidad.

 

Saludos!

Cómo hacer una aplicación web con Ruby on Rails

Hola a todos!

Sin mucho más que decir, les comparto un “tutorial” que elaboré para conocer Ruby y cómo empezar a desarrollar una aplicación hecha con Rails:

Haz clic para acceder a 2mar-IntroaRuby.pdf

Espero que les sea de utilidad!

Introducción a Java Enterprise Edition

Hola a todos!

Les comparto en esta ocasión unas notas-tutorial para empezar a hacer aplicaciones web con Java Enterprise Eidition (Java EE). En algunas ocasiones, configurar GlassFish para ejecutar una aplicación Java EE puede ser engorroso la primera vez.

En las notas comento una posible solución, que consiste en agregar el proyecto de los JavaBeans al proyecto web cómo biblioteca. Pero si esto no es suficiente, podemos intentar hacer lo siguiente:

Primero que nada, la generación de getters y setter de NetBeans parece no repsetar la convención de nombramientos de Java al pie de la letra. Como menciono en las notas, GlassFish espera que los atributos de clase a los que hagamos referencia desde la página XHTML tengan un getter y un setter nombrados bajo los estándares de Java. Es posible, que siguiendo las notas, NetBeans nos genere un getter getaManipular y un setter setaManipular, pero según la convención de Java, la primera letra de la siguiente palabra debería ser mayúscula, por lo que GlassFish puede no reconocer dichos métodos y debamos renombrarlos a getAManipular y setAManipular, lo que resuelve el problema para quien se le haya presentado.

Por otro lado; y volviendo al tema de la configuración por primera vez, si al correr el ejemplo como se indica en las notas obtenemos un mensaje similar a “No se ha encontrado la propiedad administrada fciencias.riesgotec.javaee.Anfitrion”, podemos hacer lo siguiente:

En la barra lateral izquierda de NetBeans hay una pestaña que dice services. Nos vamos a ella. Abrimos servers y damos click derecho en GlassFish. Nos aseguramos de que esté corriendo y de lo contrario lo iniciamos. Expandimos GlassFish.

Nos vamos a Applications y damos click derecho sobre el nombre de nuestro proyecto ejemplo que aparece. Seleccionamos “Disable” y luego “Undeploy”.

Volvemos a la pestaña “Projects” y seleccionamos el *-war proyecto de ejemplo que hicimos ayer (el del icono del globo). Damos click en run. Esperamos a que nos lleve al navegador y nos vamos a http://localhost:8080/Ejemplo-war/faces/index.xhtml y debería funcionar.

Espero que les sea de utilidad. A continuación los enlaces al texto:

Haz clic para acceder a 15feb-JavaEE.pdf

Y el proyecto de ejemplo:

http://www.nachintoch.mx/teaching/tech_risk/EjemploJavaEE.zip

Saludos!

Android: liberar memoria moviendo aplicaciones como Google Drive y WhatsApp al almacenamiento externo (¡Root no necesario!)

Saludos!

Les traigo un nuevo post para liberar memoria de un dispositivo Android; esta vez, moviendo apps al medio de almacenamiento externo.

Esto es muy fácil y se puede hacer por dos medios:

1 – Si tienes las herramientas de desarrollo de Google para Android instaladas en una computadora, ejecuta adb en una consola con el siguiene comando (si no las tienes o prefieres seguir pasos que no requieran del uso de una computadora ve al segundo método más abajo):

* Primero vamos a comprobar que tu dispositivo es visible. Para esto, ejecuta

adb devices

Si tu dispositivo aparece en la lista, ahora vamos a entrar a la consola del dispositivo, ejecuta

adb shell

Captura de pantalla de 2014-10-17 19:43:17

 

2 – Los siguientes pasos, son independientes de la opción que elijas. Esta otra, no requiere de las herramientas de desarrollo de Google, si no solamente que tengas instalado un emulador de terminal. Yo prefiero Terminal Emulator que pueden descargar desde Google Play en el siguiente enalce: https://play.google.com/store/apps/details?id=jackpal.androidterm Esta opción nos va a permitir mover aplicaciones usando únicamente el mismo dispositivo sin necesidad de utilizar una computadora.

Ya sea que hayamos entrado a la consola del sistema operativo (Android) por medio de “adb shell” o abriendo una aplicación como Terminal Emulator, ahora ejecuta en la terminal

pm set-install-location 2

Nota, en este caso; podrías obtener un error. Si eso pasa, sustituye “set-intall-location” por “setInstallLocation”.

Captura de pantalla de 2014-10-18 01:35:06

SC20141018-013613

Hecho esto, salimos del shell usado

exit

Ahora, vamos al gestor de aplicaciones nativo del sistema operativo. Seleccionamos la aplicación “no movible” que queremos pasar al almacenamiento externo. La opción para mover la aplicación al almacenamiento externo debería ahora estar habilitada. Damos un toque sobre él y Android moverá la aplicación al medio de almacenamiento externo. Así habremos liberado más memoria interna del dispositivo ¡Yey!

SC20141018-013332

Estos procedimientos son muy útiles; y más considerando que no se requiere root para efectuarlos, por lo que cualquier usuario puede repetirlos sin problema (en teoría).

Cuando hayamos terminado, es muy recomendable volver a entrar al shell de Android (por el método que prefieras) y volver a usar set-install-location, pero esta vez con el parámetro 0 en lugar de 2. Así, las aplicaciones serán instaladas en la memoria adecuada y podrá evitarnos comportamientos extraños que pueden afectar nuestra experiencia de usuario.

He realizado satisfactoriamente estos procedimientos, utilizando mi Samsung Galaxy Ace (GT-S5830M) con ambos métodos y moviendo WhatsApp a la memoria microSD; pero son bastante generales y deberían funcionar de igual manera con cualquier dispositivo Android: sea tablet, smatphone, etc… Sin embargo, no conozco las consecuencias que puede traer el mover ciertas aplicaciones a la memoria, y todo efecto será tu responsabilidad.

Dejemos fluir nuestra imaginación para hacer máximo provecho de los nuevos espacios en memoria que tendremos disponibles 😀

Android: cómo crear y manejar un mapa usando la Google Maps API v2; compartible con Android Froyo (2.2) y superiores

Hola de nuevo!!

Ahora vamos a ver cómo crear  manejar un mapa usando la Google Maps API for Android v2. Es my importante que antes de empezar con los pasos aquí listados, primero realicen los pasos en la guí para dar de alta un servicio de Google; usando Google Maps Android API v2 como el servicio a dar de alta.

Bien, una vez que tenemos el servicio registrado; es hora de poner manos (dedos) a la obra:

Primero que nada es necesario registrar permisos que va a usar la API de Google Maps; éstos los requiere para descargar los mapas de la red y usar los servicios de localización (como GPS) para usar un mapa dinámico con la ubicación del usuario: Vamos a incluir los siguientes permisos y características a nuestro manifiesto; todas éstas etiquetas son hijas de <manifest>:

<uses-feature
android:glEsVersion=”0x00020000″
android:required=”true” />
<uses-permission android:name=”android.permission.WRITE_CALENDAR” />
<uses-permission android:name=”android.permission.INTERNET” />
<uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE” />
<uses-permission android:name=”android.permission.ACCES_WIFI_STATE” />
<uses-permission android:name=”android.permission.WRITE_EXTERNAL_STORAGE” />
<uses-permission android:name=”com.google.android.providers.gsf.permission.READ_GSERVICES” />
<uses-permission android:name=”android.permission.ACCESS_COARSE_LOCATION” />
<uses-permission android:name=”android.permission.ACCESS_FINE_LOCATION” />
<uses-permission android:name=”com.nombredetuapp.MAPS_RECEIVE”/>
<permission
android:name=”com.nombredetuapp.permission.MAPS_RECEIVE”
android:protectionLevel=”signature” />

Recuerda cambiar <<nombredetuapp>> por el nombre completo de tu aplicación (recuerda que ésto es el paquete de Java; por ejemplo com.mx.nachintoch.example)

Ahora, debemos importar la biblioteca de los servicios de Google Play. En Eclipse procedemos de la siguiente manera: Archivo > Import > Existing Android code into workspace. Recordemos; que en la guía de activación de servicios, éstos quedan incorporados al Android SDK; y se encuentra en <directorio_de_tu_android_sdk>/extras/google/google_pay_services/libproject/google_play_services_lib

Éste es el archivo que debemos importar.

En Eclipse; aún necesitamos referencia éste código desde nuestro proyecto en el que lo vamos a utilizar. Para ello, nos vamos a las propiedades de nuestro proyecto > Preferencias > Resource y en la parte inferior; donde dice “Library“, seleccionamos “add” y  escogemos la recién importada en el paso previo.

Para poder usar la Google Maps Android API v2 con dispositivos anteriores a Android 3.0 y iguales o superiores a 2.2; es necesario que nuestro espacio de trabajo cuente con la referencia a la biblioteca “android-support-v4.jar“. En Eclipse, podemos importarlo de la misma manera que lo hicimos para la biblioteca de lose servicios de Google Play; excepto que éste fichero jar lo encontraremos en <directorio_de_tu_android_sdk>/extras/android/support/v4/android-support-v4.jar

Bien con todo lo anterior hecho; a programar!

Creamos una nueva Layout donde mostraremos el mapa. Podemos usar como raíz una relative layout y agregar más monerias extras a la pantalla del mapa; como menús, animaciones, botones, imágenes, etc… Sin embargo; no recomiendo invadir el área del mapa con otras cosas. Para definir el área del mapa en pantalla; agregamos la siguiente etiqueta:

<fragment xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/map"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        class="com.google.android.gms.maps.SupportMapFragment"/>

Ahora, creamos una nueva clase de java; que será la actividad responsable de manejar nuestro mapa.

public class MainActivity extends android.support.v4.app.FragmentActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    }
}
En principio; ésto es todo lo que necesitamos para visualizar un mapa simple con unos botones de zoom. Hagámoslo más interesante.
Agreguemos los siguientes import a nuestra clase:

import com.google.android.gms.maps.CameraUpdate;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.CameraPosition;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
import android.location.Criteria;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;

Y definamos un atributo de clase del siguiente tipo de datos:

private GoogleMap map;

Ahora, en nuestro onCreate(Bundle); agreguemos el siguiente código, el cual nos permite obtener una referencia al mapa que se estará visualizando en pantalla:

map = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMap();

Podemos cambiar el aspecto del mapa usando los siguientes modificadores:

  • map.setMapType(GoogleMap.MAP_TYPE_NORMAL); //Muestra un mapa estándar <<tipo guía roji>>
  • map.setMapType(GoogleMap.MAP_TYPE_SATELLITE); //Muestra la vista de satélite (fotografías reales)
  • map.setMapType(GoogleMap.MAP_TYPE_TERRIAN); //Muestra el mapa con terreno
  • map.setMapType(GoogleMap.MAP_TYPE_HYBRID); //mezcla de normal y satélite

Podemos posicionar el mapa en una vista inicial sobre un lugar específico y con un zoom determinado usando:

CameraPosition position = new CameraPosition.Builder().target(new LatLong(0,0)).zoom(19).build();
CameraUpdate update = CameraUpdateFactory.newCameraPosition(position);
map.animateCamera(update);

target() recibe una coordenada donde se va a centrar la vista, zoom aleja o acerca la cámara del suelo de acuerdo al flotante dado. Las coordenadas podemos conocerlas fácilmente usando el Google Maps al que tenemos acceso desde cualquier PC. Ubicamos un lugar en el planeta y damos click derecho sobre él y seleccionamos “¿Qué hay aquí?” En la barra de búsqueda aparecerán las coordenadas de ese lugar.

Los CameraUpdate nos permiten modificar con una animación la vista del mapa.

Podemos agregar marcadores sobre el mapa usando:

map.addMarker(new MarkerOptions().position(new LatLng(0,0)).title(“This is a test marker”));

Podemos obtener la posición del usuario, rastreándola con el celular, el wi-fi ó GPS

map.setMyLocationEnabled(true);

Y rastreamos con:

LocationManager locationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
Criteria criteria = new Criteria();
String provider = locationManager.getBestProvider(criteria, true);
Location location = locationManager.getLastKnownLocation(provider);
if(location!=null){
onLocationChanged(location);
}//actualiza la localización
locationManager.requestLocationUpdates(provider, 20000, 0, this);

Lo más importante de éste fragmento de código es la última instrucción; que indica el intervalo de tiempo con el que se va a actualizar la posición del dispositivo sobre el globo. Note que es muy similar al uso de sensores; y como en los sensores, necesitamos un Listener; por lo que nuestra clase deberá implementar la interfaz LocationListener:

public class MapActivity extends android.support.v4.app.FragmentActivity implements LocationListener {

Los métodos a implementar son los siguientes:

@Override
public void onLocationChanged(Location location) {
}//onLocationChanged
@Override
public void onProviderDisabled(String provider) {
}//onProviderDisabled
@Override
public void onProviderEnabled(String provider) {
}//onProviderEnabled
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
}//onStatusChanged

Aún hay muchas cosas que podemos hacer con nuestro mapa; como poner un botón en la Layout raíz de la vista y hacer que el  mapa vuele automáticamente a ubicaciones predefinidas; o incluso a la posición de otros usuarios que estén compartiendo por P2P, SMS o algún otro medio.

Podemos crear todo tipo de aplicaciones con ésto: desde un clon de Google Maps, hasta un add-on para redes sociales donde podamos ver la posición de nuestros contactos.

El límite; como siempre lo he dicho, es tu imaginación ;¬)

Nueva app para Android

Hola a todos!

En ésta ocación les presento una app con la cual pueden convertir su dispositivo Android en una lámpara de mano. Para ello; aprovechará al máximo la luz de su pantalla y el flash de la cámara. La pantalla principal cuenta con un switch interactivo que activa o desactiva un contador automático que inicia la luz por sí mismo; aunque puede iniciarse en cualquier momento manualmente. Pueden escoger entre 3 diferentes tipos de switch e intervalos de tiempo para iniciar la luz automática de 3 a 5 segundos.

Resulta muy útil para escenarios de poca luz; cómo puede ocurrir en una emergencia y muy versátil

https://play.google.com/store/apps/details?id=com.mx.nachintoch.deviceaslantern&hl=es

¿Es posible anidar clases descendientes de BroadcastReceiver?

Saludos a todos!

Comenzando a desarrollar apps para Android, me encontré con un dilema que parece no estar claro entre la red: clases que extienden a android.content.BroadcastReceiver dentro de un archivo .java de otra clase (anidada).

La respuesta es simplemente: SÍ. Sí es posible anidar clases BroadcastReceiver. Mientras indagaba en la red; tratando de responder a la pregunta, me encontré con que muchos otros se la hacían y la primer respuesta a la mayoría es simplemente que no es posible. Pero si lo es. Hice una app que lo hace, corre en el emulador y en mi teléfono. La solución que descubrí fue la siguiente:

Android permite dar de alta receptores de dos maneras: declarándolos explícitamente en el archivo manifest xml; usando la etiqueta <receiver>; la cual es hija directa de <application>.

La otra es escribiendo en el código (preferentemente en el método onCreate(android.os.Bundle)) la instrucción registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter). Con ésto nuestro BroadcastReceiver queda dado de alta y durante ejecución estará listo para recibir llamadas de algún Intent. Es muy importante destacar que NO es posible mezclar estas formas de dar de alta BroadcastReceivers; de hacerlo, tirará una excepción en tiempo de ejecución cuando dispare un Intent al que debe responder. Dado que no se espera que dicha excepción sea disparada, no se espera que sea atrapada por nadie, por lo que usualmente el programa terminara de en forma de error. Recuerden también llamar al método unregisterReceiver(BroadcastReceiver) en onPause().

Teniendo en cuenta que debemos aplicar; siempre que usemos un receptor, uno y sólo uno de los registros anteriores, es como resolví mi problema para anidar receptores en otras clases.

Resulta muy útil el anidar receptores; pues así podemos responder en una clase que se dedidaca a ciertas tareas, ejecutarse directamente cuando recibe un intente. Por ejemplo en un servicio (una clase que extiende a Service; la clase que permite ejecución de tareas en segundo plano, incluso cuando la app no tiene foco en pantalla), que espera datos de Internet  que se presione el botón de la cámara; o cualquier otra señal Intent, sea nativa o personalizada y compartir recursos con la otra clase sin necesidad de sincronizar hilos o tener que mandar más señales Intent para compartir datos.