Tutorial Android Parte 3 - Lanzar actividades de forma explicita

La segunda forma de lanzar actividades, es hacerlo de forma explicita, para esto se tiene que modificar el archivo manifest.xml agregando para la actividad "Dos" un "intent filter" el cual es como un "alias" que las actividades van a poder referencia para identificar la actividad.

Una vez modificado el archivo manifest.xml, solo debemos de cambiar la forma en la que llamamos la actividad utilizando el método setAction como se muestra a continuación.

Si todo sale bien podran visualizar nuevamente la actividad dos.

El código fuente de este ejemplo se puede encontrar en la siguiente dirección.

https://github.com/alfespa17/tutorialmobile/tree/master/Ejemplo3LanzarActividadesExplicitas

Tutorial Android Parte 2 - Lanzar Actividades de forma Implicita

Una de las cosas mas comunes en Android es lanzar diferentes aplicaciones para que el usuario pueda realizar diferentes acciones, por ejemplo estar en la aplicación de Facebook y lanzar la aplicación de la cámara para tomar un Selfie o estar en la actividad de Google+ y luego lanzar la aplicación de Youtube para ver un vídeo.

Existen dos métodos para cargar actividades, la primera es la forma implícita que es la que describiré a continuación y la forma explicita que la detallare en otro entrada del blog.

Lo primero que necesitaremos será crear un proyecto y agregar una segunda actividad a la aplicación ademas de la actividad que se crea por defecto y le llamaremos actividad "dos".

Click derecho en java->new->activity-EmptyActivity, colocamos el nombre "dos" y luego podremos observar nuestra nueva actividad en Android Studio.

Buscamos el layout de la actividad principal, agregamos un pequeño boton y le asignamos un id "lanzarDos" para poder obtener una referencia al objeto luego.

Ahora modificamos el código java de la actividad principal para poder agregar la acción al botón y lanzar la actividad dos.

Al ejecutar el código si todo salio bien luego de presionar el botón inicial deberían de poder visualizar el resultado de la siguiente forma.

El código fuente de este ejemplo lo pueden encontrar en la siguiente dirección

https://github.com/alfespa17/tutorialmobile/tree/master/Ejemplo2LanzarActividadImplicita

Tutorial Android Parte 1 Ciclo de Vida de Actividades.

Todos los formularios en android se denominan actividades, cada actividad tiene un ciclo de vida predefinido que debe de tomarse en cuenta para comprender el funcionamiento de las diferentes aplicaciones y poder conocer como responden estas a diferentes tipos de estímulos como por ejemplo el cambio de orientación.

Para comprender mejor como funciona el ciclo de vida podemos ejecutar el codigo de ejemplo "Ejemplo1CicloVida" en mi respositorio de git y revisar el log de la aplicación para poder observar como se ejecuta cada uno de los metodos cuando giramos el dispositivo, cuando cambiamos de actividad o cuando cerramos las actividades.

https://github.com/alfespa17/tutorialmobile/tree/master/Ejemplo1CicloDeVida

Si lograron ejecutarlo de forma correcta luego de girar varias veces el dispositivo mobil deberian de poder visualizar un log similar al siguiente.

Tutorial Android Parte 0 Estructura de Proyectos

A continuación se describe de forma básica la estructura de los proyectos en Android. 

El archivo básico de configuración de cada aplicación Android se encuentra en el archivo manifest.xml, en este archivo se pueden definir cada unos de los formularios con los que contara la aplicación, se pueden definir los diferentes permisos a los cuales tendrá acceso, así como también la versión mínima necesaria para ejecutar la aplicación y la versión máxima de la mismas manera.

Las aplicaciones Android se desarrollan en capas, cada uno de las pantallas de los formularios se definen en la carpeta de layouts mediante archivos XML, estas se pueden crear considerando las diferentes resoluciones de los dispositivos.

Debido a que Android es una plataforma multi-lenguaje todas las cadenas de texto de nuestras aplicaciones deben de crearse en la carpeta de values/strings como se puede visualizar a continuación.

Cambiar Wallpaper en Gnome con Ruby

Bueno he aquí un pequeño script de ruby para cambiar el fondo de pantalla de un escritorio de Gnome, para ejecutarlo solo es necesario escribir en una terminal el siguiente comando:

ruby wallpaperDaemon.rb parametro1 parametro2 parametro3..N&

donde
parametro1     = Ruta en la cual se encuentran las imágenes para el fondo de pantalla
parametro2     = Tiempo en segundos para realizar el cambio de pantalla
parametro3..N = Extensión de archivos a ser tomadas en cuenta para cambiar el fondo de pantalla
&                   = Escribir al final para que se ejecute en segundo plano

Por ejemplo el comando completo para ejecutar el script seria:

ruby wallpaperDaemon.rb /home/alfredo/Imágenes/Wallpaper/ 10 png jpg bmp jpeg&

#!/usr/bin/env ruby

require 'rubygems'
require 'gconf2'

class WallpaperChanger
   def initialize(w_ruta)
      @w_directorio = w_ruta
      @w_tipos = []
      @w_imagenes = []
   end

   def buscarWallpaper
      buscarDirTipo(@w_directorio)
   end

   def wallpaperAleatorio()
      w_cliente = GConf::Client.default
      w_min = 0
      w_max = @w_imagenes.size-1
      w_cliente['/desktop/gnome/background/picture_filename'] = @w_imagenes[rand(w_min+rand(w_max))]
   end

   def agregarTipo(w_tipo)
      if @w_tipos.include?(w_tipo)
         puts "#{w_tipo} ya se ha ingresado"
      else
         @w_tipos.push(w_tipo)
      end
   end

   private
   def buscarDirTipo(w_directorio)
      Dir.new(w_directorio).each do |w_archivo|
         w_ruta = w_directorio + '/' + w_archivo
         unless (w_archivo =~ /^\.+/)
            File.directory?(w_ruta) ? buscarDirTipo(w_ruta) : verificarTipo(w_ruta)
         end
      end
   end

   def verificarTipo(w_archivo)
      @w_tipos.each do |extension|
         if w_archivo.end_with?(extension)
            agregarImagen(w_archivo)
         end    
      end
   end

   def agregarImagen(w_archivo)
      @w_imagenes.push(w_archivo)
   end
end

#REVISO LA EXISTENCIA DEL DIRECTORIO
if File.directory? ARGV[0]
   w_directorio = ARGV[0]
else
   raise 'Directorio no valido'
end

#VALIDO EL TIEMPO PARA CAMBIAR EL FONDO DE PANTALLA
if /[1-9][0-9]*/ =~ ARGV[1]
   w_tiempo = ARGV[1].to_i
else
   raise 'Tiempo no valido'
end

#CREANDO EL CAMBIADOR DE WALLPAPER
w_wallpaper = WallpaperChanger.new(w_directorio)

#AGREGANDO LOS TIPO DE EXTENSIONES DISPONIBLES
2.upto(ARGV.size-1) {|parametro| w_wallpaper.agregarTipo(ARGV[parametro])}

#BUSCO ARCHIVOS QUE COINCIDAN CON LOS TIPOS INGRESADOS
w_wallpaper.buscarWallpaper

loop do
   w_wallpaper.wallpaperAleatorio
   sleep(w_tiempo)
end


Megaupload: http://www.megaupload.com/?d=BB3700PD

Buscar Archivos en Carpetas

Bueno el día de ahora no tenia nada que hacer así que se me ocurrió realizar un pequeño script para mostrar todos los archivos que existen en un directorio especifico y aquí esta el resultado.




#!/usr/bin/env ruby


class Busqueda


   def initialize(w_ruta)
      @w_directorio = w_ruta
      @w_tipos = []
   end


   def mostrarArchivos
      buscarDirectorio(@w_directorio)
   end


   def buscarArchivos
      buscarTipos(@w_directorio)
   end


   def buscarTipo
      buscarDirTipo(@w_directorio)
   end


   def agregarTipo(w_tipo)
      if @w_tipos.include?(w_tipo)
         puts "#{w_tipo} ya se ha ingresado"
      else
         @w_tipos.push(w_tipo)
      end 
   end


   def buscarDirectorio(w_directorio)
      Dir.new(w_directorio).each do |w_archivo|
         w_ruta = w_directorio + '/' + w_archivo
         unless (w_archivo =~ /^\.+/)
            File.directory?(w_ruta) ? buscarDirectorio(w_ruta) : mostrarArchivo(w_ruta)
         end
      end
   end


   def buscarDirTipo(w_directorio)
      Dir.new(w_directorio).each do |w_archivo|
         w_ruta = w_directorio + '/' + w_archivo
         unless (w_archivo =~ /^\.+/)
            File.directory?(w_ruta) ? buscarDirTipo(w_ruta) : verificarTipo(w_ruta)
         end
      end
   end 


   def verificarTipo(w_archivo)
      @w_tipos.each do |extension|
         if w_archivo.end_with?(extension)
            puts w_archivo
         end      
      end
   end
end


w_buscar = Busqueda.new(ARGV[0])
w_buscar.buscarTipo
w_buscar.agregarTipo('mp3')
w_buscar.agregarTipo('doc')
w_buscar.buscarTipo



La ejecución del script se realiza de la siguiente forma:

ruby buscar.rb "directorio"

Bueno el script se ejecuta bastante rápido(2 o 3 segundos) para mostrar todos los archivos en la carpeta home de mi computadora.

Instalación Ruby-Gnome2 desde RubyGems

Buen tenia bastante tiempo de no escribir en este Blog pero el trabajo me tiene un poco ocupado, pero ahora que tengo un poco de tiempo libre me gustaría compartir la forma de instalar Ruby-Gnome2 desde RubyGems simplemente ejecutando los siguientes comando desde una terminal:

sudo apt-get install libgtk2.0-dev

sudo gem install gtk2

Ahora para ejecutar algún programa que utilice Ruby-Gnome2 es solamente necesario poner las siguientes lineas al inicio del programa


#!/usr/env/bin ruby


require 'rubygems'
require 'gtk2'

Parte 2 - Creación de Menú

Al crear aplicaciones utilizando ruby-gnome2 es posible la utilización de menú, los cuales se pueden desarrollar de una forma muy sencialla como se muestra en el siguiente ejemplo:

#!/usr/bin/env ruby


require 'gtk2'


ventana=Gtk::Window.new
ventana.set_title("Titulo Ventana")
ventana.set_default_size(300,50)


#CREACION DE LA BARRA DE MENU
barraMenu=Gtk::MenuBar.new


#CREANDO EL MENU DE ARCHIVO
menuArchivo=Gtk::Menu.new


#CREANDO EL MENU DE AYUDA
menuAyuda=Gtk::Menu.new


#CREANDO ELEMENTOS DEL MENU ARCHIVO
elementoArchivoAbrir=Gtk::MenuItem.new("Abrir")
elementoArchivoCerrar=Gtk::MenuItem.new("Cerrar")


#CREANO ELEMENTO DEL MENU DE AYUDA
elementoAyudaAcerca=Gtk::MenuItem.new("Ayuda")


#AGREGANDO ELEMENTOS AL MENU DE ARCHIVO
menuArchivo.append(elementoArchivoAbrir)
menuArchivo.append(elementoArchivoCerrar)


#AGREGANDO ELEMENTOS AL MENU DE AYUDA
menuAyuda.append(elementoAyudaAcerca)


#ELEMENTO DE LA BARRA DE MENU QUE TENDRAN LOS MENU DE ARCHIVO Y AYUDA
archivo=Gtk::MenuItem.new("Abrir")
ayuda=Gtk::MenuItem.new("Acerca")


#AL HACER CLICK SOBRE LOS ELEMENTOS DE LA BARRA
#DE MENU SE LLAMA A UN DETERMINADO SUBMENU
#EN ESTE CASO SERIA LOS MENU DE ARCHIVO Y AYUDA
archivo.submenu=menuArchivo
ayuda.submenu=menuAyuda


#AGREGANDO ELEMENTOS DEL MENU A LA BARRA DE MENU
barraMenu.append(archivo)
barraMenu.append(ayuda)


#AGREGANDO MENU A LA VENTANA
ventana.add(barraMenu)


ventana.show_all
Gtk.main

El resultado del código anterior da como resultado una barra con 2 menús uno de archivo y el otro de ayuda. El menú archivo tiene dos elementos y el menú de ayuda uno.

Ruby Gnome 2 - Parte 1 - Contenedores de Pestañas

Los elementos en una aplicación que utiliza Ruby Gnome 2 puede hacer uso de pestañas para la organización de sus elementos y esto se puede lograr de una forma muy fácil como se muestra a continuación en el ejemplo:


#!/usr/bin/env ruby


require 'gtk2'


ventana=Gtk::Window.new
ventana.set_title("Titulo Ventana")
ventana.border_width=10
ventana.set_default_size(500,500)
ventana.set_window_position(Gtk::Window::POS_MOUSE)


#CREANDO EL CONTENEDOR PESTAÑA
pestana=Gtk::Notebook.new


#CREANDO LA ETIQUETA PARA LA PRIMERA PESTAÑA
etiPestana1=Gtk::Label.new("Pestaña 1")


#AHORA AGREGUEMOS ALGUNAS PESTAÑAS CADA UNA
#DE ELLAS CON UTILIZANDO UN CONTENEDOR EXPLICADO 
#CON ANTERIORIDAD PARA HACERLO UN POCO MAS INTERESANTE


#AGREDANDO UNA TABLA COMO PESTAÑA
tabla=Gtk::Table.new(2,2,true)


#CREACION DE ELEMENTOS DE LA TABLA
etiqueta1=Gtk::Label.new("Etiqueta 1")
etiqueta2=Gtk::Label.new("Etiquera 2")
boton1=Gtk::Button.new("Boton 1")
boton2=Gtk::Button.new("Boton 2")


#OPCIONES PARA QUE LOS ELEMENTOS SE LLENEN TODA LA VENTANA
opciones = Gtk::EXPAND|Gtk::FILL


#ESQUINA SUPERIOR IZQUIERDA CUADRICULA 2X2
tabla.attach(etiqueta1,0,1,0,1,opciones,opciones,0,0)
#ESQUINA SUPERIOR DERECHA CUADRICULA 2X2
tabla.attach(etiqueta2,0,1,1,2,opciones,opciones,0,0)
#ESQUINA INFERIOR IZQUIERDA CUADRICULA 2X2
tabla.attach(boton1,1,2,0,1,opciones,opciones,0,0)
#ESQUINA INFERIOR DERECHA CUADRICULA 2X2
tabla.attach(boton2,1,2,1,2,opciones,opciones,0,0)


#AGREGANDO ETIQUETA DE PESTAÑA Y ELEMENTOS
pestana=pestana.append_page(tabla,etiPestana1)


#AGREGANDO EL CONTENEDOR DE PESTAÑA A LA VENTANA
ventana.add(pestana)
ventana.show_all


Gtk.main


El resultado del código anterior da como resultado lo siguiente:

Ruby Gnome 2 - Parte 1 - Contenedores Fijos

Otra diferente forma de organizar los elementos en pantalla utilizando Ruby Gnome 2 son los contenedores fijos, estos permiten el posicionamiento de los elementos en una posicion "x,y" especifica, como se muestra en el siguiente ejemplo:


#!/usr/bin/env ruby


require 'gtk2'


ventana=Gtk::Window.new
ventana.border_width=10
ventana.set_title("Titulo Ventana")
ventana.set_default_size(300,300)
ventana.set_window_position(Gtk::Window::POS_MOUSE)


#CREACION DE VENTANA CON ELEMENTOS FIJOS
contenedorFijo=Gtk::Fixed.new


#CREACION DE ELEMENTOS PARA LA VENTANA


boton1=Gtk::Button.new("Boton 1")
boton2=Gtk::Button.new("Boton 2")
etiqueta1=Gtk::Label.new("Etiqueta 1")


#AGREGANDO ELEMENTOS AL CONTENEDOR
#parametros=nombreElemento,posicionX,posicionY
contenedorFijo.put(boton1,0,50)
contenedorFijo.put(boton2,100,223)
contenedorFijo.put(etiqueta1,125,75)


ventana.add(contenedorFijo)
ventana.show_all


Gtk.main


El resultado del codigo anterior es:

Ruby Gnome 2 - Parte 1 - Contenedores Tablas

Otro elemento que se puede utilizar ademas de los contenedores verticales y horizontales en las ventanas es el contenedor de tabla, el cual es capaz de organizar los elementos en una cuadricula, como se muestra en el siguiente ejemplo:

#!/usr/bin/env ruby


require 'gtk2'


#CREACION DE LA VENTANA PRINCIPAL
ventana=Gtk::Window.new
ventana.set_title("Titulo Ventana")
ventana.border_width=10
ventana.set_default_size(300,300)
ventana.set_window_position(Gtk::Window::POS_MOUSE)


#CREACION DE LA TABLA DE 2X2 PARA ORDENAR LOS ELEMENTOS
#LOS PARAMETROS SON EL ANCHO,ALTO Y SI SON HOMOGENEOS
tabla=Gtk::Table.new(2,2,true)


#CREACION DE ELEMENTOS DE LA TABLA
etiqueta1=Gtk::Label.new("Etiqueta 1")
etiqueta2=Gtk::Label.new("Etiquera 2")
boton1=Gtk::Button.new("Boton 1")
boton2=Gtk::Button.new("Boton 2")


#LOS ELEMENTOS SE AGREGAN A LA TABLA ESTABLECIENDO
#EL PUNTO DE LA ESQUINA SUPERIOR IZQUIERDA
#Y EL PUNTO DE LA ESQUINA INFERIOR DERECHA


#OPCIONES PARA QUE LOS ELEMENTOS SE LLENEN TODA LA VENTANA
opciones = Gtk::EXPAND|Gtk::FILL


#AGREGANDO BOTONES Y ETIQUETAS
# parametros=nombreElemento,x1,x2,y1,y2,opciones,opciones,xpad,ypad


#ESQUINA SUPERIOR IZQUIERDA CUADRICULA 2X2
tabla.attach(etiqueta1,0,1,0,1,opciones,opciones,0,0)
#ESQUINA SUPERIOR DERECHA CUADRICULA 2X2
tabla.attach(etiqueta2,0,1,1,2,opciones,opciones,0,0)
#ESQUINA INFERIOR IZQUIERDA CUADRICULA 2X2
tabla.attach(boton1,1,2,0,1,opciones,opciones,0,0)
#ESQUINA INFERIOR DERECHA CUADRICULA 2X2
tabla.attach(boton2,1,2,1,2,opciones,opciones,0,0)


#AGREGANDO TABLA EN LA VENTANA PRINCIPAL
ventana.add(tabla)


#MOSTRANDO ELEMENTOS
ventana.show_all


Gtk.main


El resultado del codigo anterior será el siguiente:

Ruby Gnome 2 - Parte 1 - Contenedores Horizontales y Verticales

Para poder organizar elementos en las ventanas ruby-gnome2 hace uso de los que se conoce como "contenedores". Existen varios tipos de contenedores pero por el momento solo explicare como utilizar los contenedores horizontales y verticales. También utilizare el ejemplo para mostrar como se crean botones y etiquetas.

Contenedores Horizontales

Como su nombre lo indica estos sirven para poder ordenar los elementos de una forma horizontal como se muestra en el siguiente ejemplo:

#!/usr/bin/env ruby

require 'gtk2'

ventana=Gtk::Window.new

ventana.set_title("Titulo Ventana")

ventana.set_default_size(300,300)

ventana.set_window_position(Gtk::Window::POS_MOUSE)

#Creacion de elementos para la ventana

#Creacion de boton 1

boton1=Gtk::Button.new("Boton 1")

#Creacion de boton 2

boton2=Gtk::Button.new("Boton 2")

#Creacion de etiqueta 1

etiqueta1=Gtk::Label.new("Etiqueta 1")

#Creacion de etiqueta 2

etiqueta2=Gtk::Label.new("Etiqueta 2")

#Creacion del contenedor horizontal

contenedorH=Gtk::HBox.new

#Funcion para agregar un elemento al contenedor

contenedorH.pack_start(boton1)

contenedorH.pack_start(etiqueta1)

contenedorH.pack_start(boton2)

contenedorH.pack_start(etiqueta2)

#AHORA QUE SE TIENE EL CONTENEDOR HORIZONTAL CON LOS ELEMENTOS

#ES NECESARIO AGREGAR EL CONTENEDOR A LA VENTANA

ventana.add(contenedorH)

#Se muestra la ventana

ventana.show_all

Gtk.main

El resultado del código anterior sera el siguiente:

Contenedores Verticales.

Ahora un ejemplo para la creación de contenedores verticales
#!/usr/bin/env ruby

require 'gtk2'


ventana=Gtk::Window.new
ventana.set_title("Titulo Ventana")
ventana.set_default_size(300,300)
ventana.set_window_position(Gtk::Window::POS_MOUSE)


#Creacion de elementos para la ventana


#Creacion de boton 1
boton1=Gtk::Button.new("Boton 1")


#Creacion de boton 2
boton2=Gtk::Button.new("Boton 2")


#Creacion de etiqueta 1
etiqueta1=Gtk::Label.new("Etiqueta 1")


#Creacion de etiqueta 2
etiqueta2=Gtk::Label.new("Etiqueta 2")


#Creacion del contenedor vertical
contenedorH=Gtk::VBox.new


#Funcion para agregar un elemento al contenedor
contenedorH.pack_start(boton1)
contenedorH.pack_start(etiqueta1)
contenedorH.pack_start(boton2)
contenedorH.pack_start(etiqueta2)


#AHORA QUE SE TIENE EL CONTENEDOR HORIZONTAL CON LOS ELEMENTOS
#ES NECESARIO AGREGAR EL CONTENEDOR A LA VENTANA
ventana.add(contenedorH)




#Se muestra la ventana
ventana.show_all


Gtk.main


El resultado del codigo anterior es:

Ruby Gnome 2 - Parte 1 - Creación de Ventanas

Bueno para comenzar a aprender como utilizar Ruby-Gnome2 lo primero que se necesita conocer es como poder crear una ventana y los metodos basicos de las ventanas:

Ejemplo 1:
#!/usr/bin/env ruby
#Libreria Ruby-Gnome2
require 'gtk2'


#Creacion de la ventana principal
ventana=Gtk::Window.new


#Establecer titulo de la ventana
ventana.set_title("Titulo Ventana")


#Establecer el tamaño de la ventana
ventana.set_default_size(300,300)


#Establecer la posicion de la ventana
#posibles opciones
#Gtk::Window::POS_NONE 
#Gtk::Window::POS_CENTER 
#Gtk::Window::POS_MOUSE
#Gtk::Window::POS_CENTER_ALWAYS
#Gtk::Window::POS_CENTER_ON_PARENT


#Establecer la posicion de la ventana en el mismo lugar
#donde se encuentra el mouse
ventana.set_window_position(Gtk::Window::POS_MOUSE)


#Se muestra la ventana
ventana.show_all


Gtk.main


El resultado del codigo anterior sera es siguiente:

Aprendiendo Ruby Gnome 2

Hace algunas semanas estaba pensando en aprender un nuevo lenguaje de programación y empece a buscar en Internet, luego de ver en Google encontré dos lenguajes de programación que me parecieron muy interesantes Python y Ruby, luego de leer un poco acerca de los dos lenguajes me decidí por Ruby cuya sintaxis es bastante clara.

Pero el motivo mas importante por el cual escogí este lenguaje es una frase que leí hace mucho tiempo

"A language that doesn't affect the way you think about programming, is not worth knowing"

"Un lenguaje que no afecte la forma en la cual pienses acerca de programación, no vale la pena conocerlo"

Ruby es muy diferente a los lenguajes que conozco Java, C#, Php y C++(aprendidos en la Universidad) por lo que durante las ultimas semanas me di a la tarea de aprender este lenguaje. El principal problema que encontré es la poca documentación en español así que decidí  crear un blog para compartir lo que he logrado aprender en especial lo relacionado a la creación de interfaces gráficas con Ruby-Gnome2.