[Mysql] Configurar acceso remoto a root

Mysql se ha convertido en uno de los servidores que regularmente tendemos a utilizar por primera vez en el ambito estudiantil y porque no en el ambito profesional tambien, por su flexibilidad, por su facilidad de implementación y por las diversas opciones que tenemos en el mercado para la parte web regularmente te ofrecen, en este caso muchas veces necesitamos acceder de forma remota o simplemente con un gestor que sea mas comodo en mi caso con Workbench que para mi uso es perfecto, muchas veces mi servidor no esta en la misma maquina que estoy utilizando por lo que requiero conectar remotamente, por configuración predeterminada Mysql no tiene un usuario para ingresar de modo remoto por lo que tenemos que nosotros darle el permiso.

1. Primero accedemos a nuestro servidor en mi caso de esta manera (en este caso se ejecutaran los comandos directamente en donde esta instalado el servidor) 
   
   
   
2. Nos pedira la contraseña y accederemos a la consola de Mysql
   
   
   
   
   
3. Una vez estando ahí daremos los siguientes comandos para dar permisos tomando en cuenta que el "%", es un wildcard de los nodos que permitira la conexión remota por lo que si ponemos 192.168.1.% significa que todos los nodos que pertenecen a la red 192.168.1.0 podran acceder.  
   

   
   mysql> GRANT ALL ON *.* to root@'%' IDENTIFIED BY ‘contraseña_de_acceso_remoto‘;
   mysql> FLUSH PRIVILEGES;
   
   

   
   

Con esto ya se podra acceder desde cualquier otra maquina utilizando el usuario root, si quieres proveer de dicho servicios a otros usuarios tendrías que repetir procedimiento en el workbench en la opción de usuarios

[MySQL] Recorrer el resultado de un select dentro de un procedmiento almacenado o función

Muchas veces hay tareas en las que necesitas hacer consultas cruzadas, que muchas veces complican demasiado el codigo y pueden generar problemas a la hora de la ejecución, ademas que la depuración es mas complicada dentro tus funciones o procedimientos, por lo que en lo particular me gusta que muchas de las tareas las haga el motor de base de datos, asi generando una sola transacción remota, les comento un ejemplo: 

1) Tengo un procedimiento almacenado que libera los productos de un proceso en tienda, y estoy generando, este procedimiento recibe un texto, el cual el procedimiento parte y realiza las actividades. Lo llamaremos: stp_devuelve_producto(idusuario, productos)

2) Ahora quiero devolver todos los productos en un dia particular, por lo que necesitaria hacer una consulta del día, luego posteriormente de los datos recibidos, ejecutar las sentencias para devolver el producto, por lo que lo hare en el mismo procedimiento almacenado que llamaremos stp_cancel_day(dia, idusuario), usaremos CURSOR de mysql 

CREATE DEFINER=`root`@`localhost` PROCEDURE `stp_cancel_day`(pday datetime, pidusuario int)
BEGIN  
   -- Declaramos las variables necesarias 
   -- La primera para saber cuando se detendra la consulta
   DECLARE done INT DEFAULT FALSE;
   -- Esta variable son las que recibiran los elementos necesarios 
   DECLARE piddetalle int DEFAULT 0;
   -- La variable que declararemos para concatenar los resultados
   DECLARE cad text; 
   
   -- Recorre se llma la variable CURSOR que recorre en base a la consulta
   DECLARE recorre CURSOR FOR 
      SELECT idproducto FROM detalle_pedido WHERE day=pday AND estado='ABIERTO';     
   -- Se declara un manejador para saber cuando se tiene que detener 
   DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
   -- Se abre el cursor
   OPEN recorre; 
   SET cad = "";
   loop_recorre: LOOP   
       FETCH recorre INTO piddetalle,pidproducto;        
       -- Fetch lo utilizamos para leer cada uno de los registros
       -- If que permite salir del ciclo
       IF done THEN 
   LEAVE loop_recorre;
    END IF;
       -- Concatemos los datos 
       SET cad = CONCAT(cad,CAST(pidproducto AS CHAR),',',CAST(piddetalle AS CHAR),',');       
   END LOOP;
   -- cerramos el cursor 
   CLOSE recorre;    
   -- Devuelve productos
   call stp_devuelve_producto(pidusuario,cad);
  
END

Con esto podremos recorrer cualquier tabla y utilizar sus datos  espero sirva

[JAVA] Cuenta vocales utilizando Map

Un pequeño ejercicio para contar vocales a través de una cadena

import java.util.HashMap;
import java.util.Scanner;


public class Cadena {
    
    public static void main(String[] args) {
          Scanner sc = new Scanner(System.in); 
          String cad = sc.nextLine(); 
          char[] car = {'a','e','i','o','u'};
          cad = cad.toLowerCase(); 
          HashMap< Character, Integer> cuenta = new HashMap <>();
          for(char c: car)
             cuenta.put(c, 0);
          for(int i=0;i< cad.length();i++)         
              if(cuenta.containsKey(cad.charAt(i)))
              {
                  int ii = cuenta.get(cad.charAt(i));
                  ii++; 
                  cuenta.replace(cad.charAt(i), ii);
              }
          for(char c: car)
          {
              int cantdad = cuenta.get(c); 
              if(cantdad>0)
                  System.out.println(c+"->"+cantdad);
          }
          
    }  
}

[C#] Dando formato a las columnas de un DevExpress - > GridControl

DevExpress es una completa suite de componentes UI muy completa y que tiene componentes muy potentes para las herramientas .Net , aunque lo llevo poco utilizando permite generar proyectos mas rápido, por lo completo de sus componentes, y con aspecto visual muy interesantes y lo mejor para los que somos malos en el diseño en poco tiempo, aunque no todo es bueno en DevExpress he experimentando cierta latencia o retardo por lo que las aplicaciones no lo son de todo lo mejor. 

 

 

En este caso hablaremos de un componente llamado GridControl, que es una tabla de datos que sin problemas podemos relacionar con una fuente de datos para que pueda mostrar información, sin mayor complicación.

 gridControl1.DataSource = tabla; //DataTable

Una vez que se tiene una vista se forma un control interno llamada gridView el cual trabaja con la vista para que se pueda filtrar, ordenar o alguna operación sin afectar a los datos o la comunicación con el repositorio de la información.

Para poder trabajar con las columnas, gridview puede controlar las propiedades de las columnas a través de un arreglo, por lo que si una columna quieres ocultarla, en caso que necesites un índice pero no quieres que lo vea el usuario puedes usar lo siguiente: 

gridView1.Columns[0].Visible = false;

Si quieres cambiar el titulo de la cabecera utilizas 

gridView1.Columns[1].Caption = "CODIGO"; 

Si tu columna maneja una cantidad en dinero puedes usar 

gridView1.Columns[7].DisplayFormat.FormatType = DevExpress.Utils.FormatType.Numeric; 
gridView1.Columns[7].DisplayFormat.FormatString = "c2";

Si quieres cambiar su tamaño 

gridView1.Columns[0].Width = 30;

Si quieres traer un valor de alguna columna 

string cadenita = gridView1.GetRowCellValue(reng, gridView1.Columns[1]).ToString();

Espero les pueda servir. 

Referencias: 

https://documentation.devexpress.com/#WindowsForms/DevExpressXtraGridColumnsGridColumnClassPropTopic 

[Debian] Instalar Java (JDK y JRE) desde repositorios

La instalación de Java es sencilla utilizando repositorios, su instalación esta a solo unos comandos, en este caso fue probado en un debian 8 de 32 bits, entonces pasamos a ejecutar los siguientes comandos:

1) Entrar en modo super usuario

$ su 
 password: "nuestro password"

2) Agregar las siguientes entradas a nuestro source list que podemos hacerlo manual pero en este caso los pondremos de manera automática, aunque los repositorio no son de Debian originalmente porque no soporta esa opción

# echo "deb http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main" | tee /etc/apt/sources.list.d/webupd8team-java.list
# echo "deb-src http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main" | tee -a /etc/apt/sources.list.d/webupd8team-java.list

3) Agregamos las claves necesarias para la instalación

# apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys EEA14886

4) Instalamos el paquete, ya con esto permitiremos

# apt-get update
# apt-get install oracle-java8-installer

Nota: en la parte de la instalación nos pregunta si aceptamos la licencia solo escribimos la palabra "yes"

5) Aceptamos las licencias de forma automatica para las actualizaciones

# echo oracle-java8-installer shared/accepted-oracle-license-v1-1 select true | sudo /usr/bin/debconf-set-selections

6) Configuramos las variables de entorno

# sudo apt-get install oracle-java8-set-default

7) Ya puedes hacer tus pruebas con los siguientes comandos para su utilización

# javac -version 
# java -version 

Fuente: http://www.webupd8.org/2014/03/how-to-install-oracle-java-8-in-debian.html

[Ubuntu] Bajar videos de youtube

 

Muchas veces necesitamos un video y no tenemos una buena conexión de internet, y en linux o ubuntu es muy sencillo poder descargarlo, solo necesitamos instalar clive 

 $ sudo apt-get install clive

Ya una vez que se tiene instalado solo se tiene que poner en la consola el comando clive y la url del video y empezara a descargar. 

$ clive https://www.youtube.com/watch?v=LXqEfkUUlEU

Espero les ayude.

[Android] Conectando Genymotion para probar nuestras aplicaciones

Genymotion es un software que sin problema puede sustituir al emulador que viene por default en los desarrollos de android como ya explicamos en el post anterior, en este caso genymotion es muy noble para la conexion ya que solo tenemos que irnos al menu Settings,  en la pestaña de ABD y poner la ruta del SDK que utiliza nuestro Android Studio. 

Una vez configurado solo lanzamos nuestros emulador y en este caso al abrir Android Studio detectaremos el dispositivo.

 

[Java] Compartir archivos por socket

Continuando con el post anterior, ya antes ya habia escrito algo con sockets pero creo que este esta mas elaborado se trata de una aplicación que permite mediante un servidor de socket generar una carpeta compartida, mediante un cliente se pueden descargar y subir archivos a dicha carpeta, aunque todavía falta seguridad es un buen ejercicio para quien lo pueda utilizar, les dejo un video de su uso y el enlace en gitHub para que descarguen el codigo. 

[Java] JTree como explorador de archivos

 

En Java existe un componente llamado JTree que permite enlistar una serie de elementos en una estructura esquematica o por jerarquia, por lo el poder explorar archivos no es una tarea tan sencilla como se quisiera pero les dejo una libreria. 

En mi caso vamos a crear un proyecto Java y le agregaremos un componente JTree para las pantallas para esto yo tengo el ejemplo en Netbeans por lo que tendría algo así. 

En este caso vamos a entrar al codigo en el constructor pondremos lo siguiente suponiendo que mi componente lo llamaremos jTree1. 

        public ContructorClass{
        initComponents();
        JTreeFile jTreeFiles = new JTreeFile(); 
        jTreeFiles.setJTree(jTree1);
        jTreeFiles.init(); 
        }

Ya lo unico que tendremos que hacer es crear una clase con sl siguiente codigo que permita actualizar el listado de los archivos.

package ui.jTreeLib;

import java.io.File;
import javax.swing.JTree;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

/**
 *
 * @author coby
 */
public class JTreeFile implements TreeExpansionListener{

    
    private JTree jTree1;
    private DefaultTreeModel modelo;

    public DefaultTreeModel getModelo() {
        return modelo;
    }

    public JTreeFile() {
    }

    public JTreeFile(JTree jTree1) {
        this.jTree1 = jTree1;
    }

    public void setJTree(JTree jTree1) {
        this.jTree1 = jTree1;
    }

    /**
     * Metodo que permite enlazar los escuchas de eventos 
     * y permite actualizar 
     */
    public void init() {
        //creamos el nodo principal
        DefaultMutableTreeNode top = new DefaultMutableTreeNode("Directorio");
        //creamos un modelo con el nodo que creamos principal
        modelo = new DefaultTreeModel(top);
        // seteamos el modelo y el escucha al componente 
        jTree1.setModel(modelo);
        jTree1.addTreeExpansionListener(this);
        //extraemos todas las unidades disponibles en caso que tengamos C, D o otra
        for (File f : File.listRoots()) {
            DefaultMutableTreeNode raiz = new DefaultMutableTreeNode(f);
            //añadimos el nodo a la raiz
            top.add(raiz);
            //hacemos un recorrido de dos niveles a partir de cada una unidad
            actualizaNodo(raiz, f);     
        }
    }

    private boolean actualizaNodo(DefaultMutableTreeNode nodo, File f) {
        //quitamos lo que tenga el nodo 
        nodo.removeAllChildren();
        //recursivamente mandamos actualizar
        return actualizaNodo(nodo,f,2); 
    }
    
    /**
     * A partir de un nodo enlista los archivos y los agrega como nodo 
     * @param nodo Es el nodo que tenemos parcialmente como raiz
     * @param f es el archivo que se enlaza con la raiz 
     * @param profundidad el numero de subdirectorios que se quiere que escarbe
     * @return 
     */

    private boolean actualizaNodo(DefaultMutableTreeNode nodo, File f, int profundidad) {
       File[] files = f.listFiles(); // de el nodo que llega listamos todos sus archivos
       if(files!=null && profundidad>0) //permite detener la recursividad si ya llego al limite 
       {   
           for(File file: files)  // recorre todos los archivos 
           {
               DefaultMutableTreeNode nuevo = new DefaultMutableTreeNode(file);
               //vuelve a mandar en caso que sea directorio 
               actualizaNodo(nuevo, file,profundidad-1); 
               nodo.add(nuevo); //crea el nodo
           }
       }
       return true; 
    }
    /**
     * Metodo que se ejecuta al expandir alguno de los nodos
     * @param event 
     */
    @Override
    public void treeExpanded(TreeExpansionEvent event) {
        TreePath path = event.getPath(); // Se obtiene el path del nodo
        DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
        // verifica que sea nodo valido
        if(node==null || !(node.getUserObject() instanceof File) ) return; 
        File f = (File) node.getUserObject();
        actualizaNodo(node, f);  //actualiza la estructura
        JTree tree = ( JTree) event.getSource(); 
        DefaultTreeModel model = (DefaultTreeModel)tree.getModel(); 
        model.nodeStructureChanged(node);
    }

    @Override
    public void treeCollapsed(TreeExpansionEvent event) { }

}

La clase la pueden encontrar en un pequeño ejemplo que dejo a continuación

 

 

[LeapMotion] Hola Mundo, linux SDK + Java

Para los que nos gusta un poco la programación estos dispositivos son muy interesantes, por lo que vamos a hacer un pequeño programa que nos permita leer datos de un leapMotion, vamos a empezar con un pequeño Hola Mundo.

Imagen de leapmotion.com

LeadMotion es un gadget muy interesante para trabajar con realidad aumentada, prácticamente consiste en detectar los movimientos de las manos, bueno un video vale mas que mil palabras por lo que lo dejo.

Interesante la verdad con lo que se puede hacer, pero vamos a entrar en materia, lo primero que haremos es configurar el entorno de desarrollo en mi caso utilizaremos una distribución de ubuntu, java 1.8 y el SDK de leapmotion en su versión 2.2.2 que la puedes descargar en  la pagina de desarrolladores oficial. 

Descomprimiremos la carpeta en una ubicación cualquiera, y posteriormente instalaremos el software que viene en ella, que como es una extensión de deb con el mismo centro de software lo puedes instalar. 

En mi caso instalamos el x64 por la arquitectura y la distribución que se tiene instalado, una vez veras que los sensores del leapmotion se encienden.

Abriremos nuestro proyecto de netbeans en este caso usaremos un tipo de movimiento o gesto que detecta el leadmotion que sera movimientos circulares, y la intensión es hacer un contador que al dar movimientos circulares un contador aumente si es que va en sentido a las manecillas del reloj, de lo contrario disminuiría.

Imagen de la pagina de desarrolladores de leapmotion

Lo primero vamos a hacer es crear un proyecto nuevo de Netbeans, y agregar a las librerias el sdk, a ir a la carpeta del LeapSDK -> Lib, buscaremos el archivo LeapJava.Jar y lo agregamos al proyecto. 

Crearemos un listener que nos ayudara a estar escuchando los eventos 

package example;

import com.leapmotion.leap.*;
/**
 * Clase de escucha para los movimientos
 * @author luis
 */

public class ListenerLeapMotion extends Listener {

    /**
     * Metodo que detecta cuando el leapmotion esta conectado
     * @param controller 
     */
    @Override
    public void onConnect(Controller controller) {
        System.out.println("Connected");
    }

    /**
     * Metodo que detecta los eventos en el leapmotion 
     * @param controller 
     */
    @Override
    public void onFrame(Controller controller) {
        ///Obtenemos el fram que captura
        Frame frame = controller.frame();
        //habilitamos el gesto de los movimientos circulares
        controller.enableGesture(Gesture.Type.TYPE_CIRCLE);
        //configuracion para mejor deteccion 
        controller.config().setFloat("Gesture.Circle.MinRadius", 10.0f);
        controller.config().setFloat("Gesture.Circle.MinArc", .5f);
        controller.config().save();
        
        //sacamos una lista de los eventos que se presenten 
        GestureList lista = frame.gestures();
        //verificamos que haya pasado algo
        if (!lista.isEmpty()) {
            //recorremos entre los eventos que ocurrieron 
            for (Gesture gesture : lista) {                
                switch (gesture.type()) {
                    //Si el evento fue movimientos circulares
                    case TYPE_CIRCLE:                       
                        //instancia de un objeto para el movimiento
                        CircleGesture circle = new CircleGesture(gesture);
                        //a partir de un posicionamiento verificamos a que sentido esta el movimiento
                        if(circle.pointable().direction().angleTo(circle.normal())<= Math.PI/2)                            
                        {  //si se da en sentido del reloj (limite 255)
                            if(LeapMotion.intensidad<255)
                                    LeapMotion.intensidad++; //aumenta el contador
                        }
                        else {
                                if(LeapMotion.intensidad>0)
                                    LeapMotion.intensidad--; //disminuye el contador
                                }
                        System.out.println(LeapMotion.intensidad); //imprimo el contador
                        break;

                }
            }
        }
    }

}

Despues vamos a crear un archivo Main agregando el listener 

package example;

import com.leapmotion.leap.*;
import java.io.IOException;

/**
 *
 * @author luis
 */
public class LeapMotion {

    //variable estatica que almacena el valor segun los movimientos
    public static int intensidad = 0;

    public static void main(String... a) {
        //instanciamos de nuestra clase de escucha 
        ListenerLeapMotion listener = new ListenerLeapMotion();
        //instanciamos la clase para control de los datos 
        Controller controller = new Controller();
        //añadimos el escucha para que tome los eventos 
        controller.addListener(listener);        
        System.out.println("Presiona algo para salir");
        try {
            //detemos el programa hasta que presionemos algo
            System.in.read();
        } catch (IOException e) {
            System.out.println("Ocurrio un error");
        }

        //Se remueve el listener
        controller.removeListener(listener);

    }

}

Para que pueda ser ejecutado hay que ir a la carpeta de LeapMotionSDK/lib/x64(en mi caso) y copiar la ruta para agregarla como argumento en la ejecución como se ve en la pantalla siguiente: 

Despues veras en la consola los valores que van aumentando según tu movimiento de la mano. 

[Galileo] Hacer una caminata o serie de luces con 4 led

Regresando un poco al trabajo con galileo, vamos a hacer un recorrido o caminata con leds programado con la tarjeta de galileo de arduino.

Para esto pondremos cuatro led a los cuales siguiendo el siguiente diagrama del led conectaremos las salidas del 4 al 7 a la conexión de anodo de cada uno de los led. Para las conexiones de cátodo solo conectariamos a una resistencia de 220 o 330 ohms la cual el otro extremo a una salida a tierra de galileo.

Foto de www.zazzle.es

 

Una vez que hicimos las conexiones podemos crear nuestro código en este caso tendríamos que abrir el IDE para galileo o teclear el siguiente código

//salida en la que vamos a empezar el encendido
int cont=4; 
//bandera para poder regresar 
boolean ban=true; 
void setup() {
  //empezamos con el cuatro  
  int led=cont; 
  //activamos todas como salida desde el 4
  for(;led<=7;led++)
    pinMode(led,OUTPUT); 

}

void loop() {
  //inicia encendiendo el led 4 y en cada vuelta va aumentando
  digitalWrite(cont,HIGH);
  //esperamos un tiempo
  delay(500); 
  // apagamos el led que encendimos despues del tiempo
  digitalWrite(cont,LOW);
  //si la bandera esta activida va aumentando si esta falsa va disminuyendo
  if(ban) 
    cont++;  
  else
    cont--; 
  // si el contador llego al final entonces empieza a regresar
  if(cont==8 && ban)
    ban=false;
  else if(cont==3 && !ban) 
    ban=true;
}

Puedes ver los ejercicios en: 

Todo el contenido de los post de arduino son basados en la información que recibí en el curso de Galileo patrocinado por Intel en el Cinvestav de Guadalajara en Noviembre 2014. 

Comunidad de galileo: 

https://engage.intel.com/community/es/galileo

[Android] Instalar Genymotion teniendo ya virtualbox

Dándole seguimiento al post anterior de programación en Android, se comentaba es un poco tedioso el tema del emulador buscando opciones para poder solventar ese problema creo que podemos categorizar de la siguiente de opciones para probar tus aplicaciones

1. Probar directamente en un dispositivo real (Si tienes dispositivos "genéricos" muy difícil encontrar los drivers adecuados para el debuggin)
2. Probar con el emulador que viene directamente en el IDE (realmente lento si la maquina no es compatible con el acelerador de intel)
3. Instalar un sistema de virtualización que sea independiente y que pueda emular en este caso podemos optar por el método anterior  o en este caso usar Genymotion. 

Genymotion lo venden como el emulador más rápido para poder probar tus aplicaciones, no es totalmente gratuito pero tiene una versión gratis,  tiene varias opciones interesantes como lo son trabajar con el GPS, poder cambiar la orientación o inclusive trabajar con el IMEI que tiene en la versión de paga. Además que tiene soporte para Mac, Linux y Windows.

Se puede considerar como un emulador profesional para el desarrollo de Android aunque tiene algunos puntos malos que son que debajo de Genymotion sigue teniendo un virtual box por lo que es algo mas como Andy con algunas opciones, además que consume algo de recursos pero por las opciones que maneja pero vale la pena probar y lo mas importante es que es caro para desactivar las opciones.

En este caso utilizaremos la versión gratuita, en este caso como yo ya tengo virtual box en mi equipo no es necesario que baje la versión completa si no la versión de 26 MB y seguir el asistente que es muy sencillo y compacto.

Una vez que instalamos nos abrirá Genymotion y tendremos que poner nuestro credenciales por la parte de licenciamiento a considerar.

Una vez que te autentifiques tendrás una serie de dispositivos que pudes usar, en este caso probaremos con un nexus 7 con kitkat 4.4.4, por lo cual empezará a descargar lo necesario para su funcionamiento.

Mientras se da la descarga nos ira explicando algunas partes importantes de funcionamiento, desgraciadamente muchas de ellas son de paga pero la mensualidad en lo personal es un poco elevada que te pone a pensar o pago la mensualidad o mejor me compro un dispositivo.

Una vez instalado ya podrás tener un equipo virtualizado en tu PC con Android, en este caso le daremos start para que pueda empezar el emulador. 

Igual el emulador lo puedes utilizar para instalar aplicaciones desgraciadamente la versión gratis no tiene instalado los paquetes de los servicios de google por lo que no podrás descargar aplicaciones de google play y tampoco viene desbloqueado por lo que tendrás que instalarlas a mano, para hacer debug de nuestra aplicaciones puede funcionar bien

[Android] Introduccion a la programacion en android: Instalar android en una maquina Virtual

Instalar android en una maquina virtual no se oye o se lee muy tentativo porque la potencialidad de android se ve reflejada en la capacidad que pueda tener el dispositivo, pero en este caso nos podemos preguntar ¿Para que puedo necesitar una rom de android corriendo directamente en una PC?.

Bueno en este caso empezaremos descargando primero el programa para la maquina virtual que en este caso usare Virtual Box  y segundo usaremos una Rom de Kitkat de android para instalar. Mientras se descargan estos archivos que el rom no esta tan liviano les contare algunos detalles.

Algunos de los motivos que podemos tener es porque muchas aplicaciones que tenemos disponibles en los dispositivos moviles no estan disponibles para PC como es el caso del Whatsapp y esta puede ser una buena opción para tenerlo simulado en nuestro equipo (¿Realmente vale la pena abrir una maquina virtual para chatear? .. asi es la vida de loca). En este caso cuando nos acercamos al mundo de la programación para dispositivos moviles descubriremos que los emuladores y los editores que se utilizan no son nuestros mejores amigos(realmente muchos llegan a odiar la programación en android por este motivo), pero para solucionar el primer problema podemos trabajar con un emulador independiente al IDE que vayamos a utilizar para programar por lo que aquí la maquina virtual puede tomar un poco mas de valor. 

Si alguna vez te haz preguntado como podemos acelerar el emulador de Android esta es una de las mejores opciones que podemos tener. 

¿Porque los emuladores generan muchos problemas?, la mayoria de los dispositivos que hay en el mercado son procesadores ARM por lo que el tamaño, la forma de interpretar las instrucciones es diferente a procesadores x86 o x86_64 que son los que usamos en los equipos de computo por lo que el cambio entre una forma y otra provoca que el emulador simule trabajar de una manera a la cual no esta acostumbrado, y esto hace que en el tiempo real sea dificil interactuar. Actualmente hay dispositivos compatibles con arquitectura x86 y tambien emuladores, pero desgraciadamente dependemos mucho de la posibilidad de virtualización y compatibilidad de los procesadores ( Olvidemos esto los que tenemos AMD ), por lo que por el momento no todos los equipos son beneficiados. Los problemas los vemos reflejados cuando corremos nuestra aplicación y nuestro emulador dura horas (literalmente hablando) para abrir una interfaz y esto si no te dio el clasico error (Ocurrio un error y el proceso se cerrara).

Empezaremos a instalar VirtualBox para generar una maquina virtual en este caso la vamos a crear una maquina virtual con los siguientes datos: 

• Nombre: Android (El que quieran) 
• Tipo: Linux
• Version: Otro Linux 32bits
• Tamaño de memoria: 512 (preferente 1024) 
• Crear un disco Virtual ahora
• Tipo: VDI 
• Reservado Dinamicamente 
• Tamaño de disco >=4GB

 

 

 

Les recomiendo que cambien el adaptor de red, como adaptador puente ya que conectaremos nuestro IDE de desarrollo por medio de una Ip independiente por lo que pueden cambiarlo. Una vez creada la maquina virtual le daremos en iniciar para que pueda empezar el proceso de instalación, la cual nos pedira que le digamos donde esta nuestra imagen para la instalación, la cual es el Rom que bajamos con el android por lo que lo seleccionamos. 

 Dejamos que haga su proceso, hasta que posteriormente de las opciones de inicio del dispositivo, por lo que escogemos la opción de instalar 

 

Dejamos que la maquina virtual siga con el proceso. Como es una instalación inicial, debemos de crear las particiones, por lo que vamos a darle a la opción de modificar las particiones, para este caso a diferencia de los linux solo necesitaremos una sola partición de tipo ext3. Por lo que damos clic en new, escogemos el tamaño completo, escogemos la opcion para que sea booteable y por ultimo escribimos los datos al disco

 

Una vez que escogemos el tipo de particion y salimos de la pantalla anterior, nos mostrara en la pantalla donde escogimos modificar el sda1 ya disponible por lo que le damos enter, escogemos la opcion de ext3 y dejamos que le aplique formato a la partición. Una vez terminado nos preguntara si queremos instalar GRUB por lo que le decimos que si, y autorizamos los cambios, despues de esto empezara hacer la instalación la cual no llevara mucho tiempo. Por ultimo reiniciamos, quitamos la unidad de CD con la imagen para ya tener una maquina virtual con android instalada. 

Empezara a correr y su primera configuración sera como la de cualquier dispositivo android. 

Como nota no te preocupes por la red porque por lo pronto aparecera desconectada pero puedes checar haciendo una busqueda para que tome la red que tienes en tu equipo.

 

Algunas cosas que te pueden presentar problemas son la integración con el mouse por lo que puedes deshabilitarlo para que veas un eco en la pantalla y la segunda con la red si es que no tienes internet puedes dejarlo en nat para que ya tengas un dispositivo.