[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.