miércoles, 16 de abril de 2014

Como destruir sesion de Ubuntu congelado

Bien,esto es para los que aun pueden mover el puntero o entrar a una tty.

Digan lo que digan en Linux tenemos problemas,no tan populares como las pantallas azules de Windows pero en ocasiones se "rompe" algo y nuestro sistema se congela,en el caso de Ubuntu no se porque,me ha pasado a nivel de modulo con los gráficos de intel pero en esta ocasion dmesg no dijo nada,debió haber sido unity.

Para poder seguir usando la pc sin tener que reiniciarla a la brava podemos matar el proceso del servidor grafico,esto lo uso asi porque Linux me ha dado ese problema,sea Gentoo-KDE,Arch-GNOME-SHELL,Debian,etc siempre se ha congelado mi sistema(sera mi pc).

Para matar el proceso de Xorg solo hacemos esto:

Abrimos una tty:

Ctrl+Alt+F1

o

Ctrl+Alt+fn+F1
Nos logeamos.

Ahora matamos el proceso Xorg

sudo killall Xorg




O nos logeamos como root y tecleamos:

killall Xorg

Con eso eliminamos todo lo que tiene que ver con Xorg y en Ubuntu esto nos mostrara automáticamente la pantalla de login para entrar de nuevo,no es la mejor practica pero podemos entrar de nuevo a nuestro usuario.

Esto elimina los procesos,así que si tenemos por ejemplo un documento que aun no salvamos,no se guardara,a menos que tenga un servicio que guarde automaticamente cada cierto tiempo,y en teoria se debe seguir ejecutando ya que el sistema nos deja acceder a otras partes del mismo,el problema es solo que el entorno de escritorio no responde.

En el peor de los casos el sistema entero se cae y no nos deja ni siquiera mover el mouse o entrar a una tty o apagar la pc.

En el futuro hablaremos de como pausar procesos para salvarlos o migrarlos a otra shell,aunque sean los de terminal.



Leer más...

sábado, 12 de abril de 2014

Poder hacer debug con dispositivos Inco Eclipse Linux

Esto es para las tablets llamadas chinas,ya que el adb no las detecta.

Un poco de historia:

Me toco comprar varios dispositivos android para probar distintas apps que estoy programando,ya que aunque eclipse pueda emular android virtuales no hay como probar la app en la vida real(un dispositivo real),para no gastar mucho compre algunos dispositivos Inco ya que lo único que quiero ver es el posicionamiento de los layout en distintas pantallas,así que esa marca me sirve por lo menos para las tabletas.

Esta marca son de las llamadas tablets o smartphones chinos(como algunas otras marcas),no son muy buenos como los Samsung,LG,Motorola,Nexus pero lo que sea de cada quien sirven muy bien(para el precio que vale) y eso que lo comparo con un iPad o Galaxy tab bien basta de historia.


Tutorial

Linux no detecta estos dispositivos chinos,si los detecta pero no así el adb, o enteramente ya que solo se visualiza el BUS:



Si lo vemos que el adb tampoco lo muestra:

adb devices -l

Para que lo "agarre" el sistema, tenemos que añadir su  ID al servicio android:

Por ejemplo el mio es:

1f3a:1002

Tomamos el primero y usamos notación HEX:


cho '0x1f3a' >> ~/.android/adb_usb.ini
Tambien añadimos esto en las reglas de android:

Abrimos para editar:
sudo nano /etc/udev/rules.d/51-android.rules
Código es la notación HEX de 3 digitos quitando el primero del ID de tu tablet,por ejemplo:

1f3a

El código seria:

f3a

SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device",
SUBSYSTEM=="usb", ENV{PRODUCT}=="codigo/*", MODE="0666"
SUBSYSTEM=="usb", SYSFS{idVendor}=="codigo", MODE="0666"



Eso es todo,ahora solo reiniciamos la pc o si no pueden, reinician el servicio de adb:

adb kill-server &&  adb start-server 
Veamos:


En eclipse:


Eso es todo sirve para otros modelos Inco y creo que para mas tablets chinas(si no es que todas),el hecho es que lo reconozca Linux y este bien configurada la tablet para el modo debug dependiendo de la versión adroid que este ejecutando.
Leer más...

Convertidor de videos para Ubuntu 13.10 HandBrake

En Ubuntu o en los sistemas GNU/Linux tenemos algunos programas para convertir vídeos,este en especial me gusta:


Es Open Source y solo necesitamos instalar y ya,no necesitamos soporte extra como en el caso de ffmpeg , solo instalamos y listo :D

Este convertidor sirve muy bien para los ipod touch o iphone,en el caso de ipod touch,solo sirve de la version 4g para arriba,una version menor tenemos que convertirlos usando el codec ipod sin soporte para 5g:


Tiene opciones de Video,Audio,Subtitulos y Metadatos.


Bien para instalar lo podemos hacer por PPA:

Primero abrimos una terminal(Ctrl+Alt+T):

Escribimos:
sudo add-apt-repository ppa:stebbins/handbrake-releases &&  sudo apt-get update



Y instalamos:

sudo apt-get install handbrake-gtk
Para 64 bit podemos hacerlo desde el .deb:

mkdir ~/handbrake && cd ~/handbrake
wget -c https://launchpad.net/~stebbins/+archive/handbrake-releases/+files/handbrake-gtk_0.9.9ppa1~raring1_amd64.deb
sudo dpkg -i handbrake-gtk_0.9.9ppa1~raring1_amd64.deb && sudo apt-get install -f
Abrimos,buscamos en el Dash:


O en la terminal si aun esta abierta escriben:

ghb & exit

Ahora a disfrutar o usar :D.

Leer más...

viernes, 11 de abril de 2014

Tutorial Java en Linux Basico 8

Estructuras dinámicas

En esta ocasión vamos a ver como declarar estructuras dinámicas en java,las llamadas arrays.

En ocasiones anteriores hemos visto los arreglos de una dimensión llamados vectores y de dos llamados matrices,a diferencia de los arreglos comunes que acabo de mencionar los arrays deben o son dinámicos en tamaño no estáticos,por ejemplo al definir un vector de 10 elementos de tipo int tenemos que hacer esto:

Integer  elementos[] = new Integer[10];

Pero si quisiéramos o mejor dicho si no supiéramos cuantos elementos va a tener el arreglo como le haríamos?

Aquí es donde entra ArrayList lo que seria como una simple lista en lenguajes como python o ruby.

Listas

Para usar ArrayList tenemos que importarlo:

import java.util.ArrayList;

Su constructor es este:

ArrayList elementos = new ArrayList();

De esta manera seria idéntico a un lenguaje de alto nivel(fácil) crear una lista,a lo que me refiero es que podemos crear una lista de distintos tipos de datos,int,string,float,etc a diferencia de lo que seria un vector de un solo tipo de dato:


Para añadir un elemento usamos el método add pasándole como parámetro el dato a usar,por ejemplo:

elementos.add("Hola Mundo"); // String

elementos.add(10); // int

elementos.add('a'); // char

Bien,aun asi cuando los llamemos se convertiran a un tipo envuelto:

int a Interger

char a Character // etc


Aun así no es muy recomendable usar este tipo de listas(con datos de muchos tipos),lo recomendable es usar un dato de un solo tipo ya que incluso el compilador muestra un error.

Para definir el tipo de datos que vamos a usar lo añadimos al lado del constructor entre etiquetas:

ArrayList arreglo = new ArrayList();


En donde tipo usamos un tipo envuelto,por ejemplo:

ArrayList arreglo = new ArrayList();

Primero vamos a ver los métodos de agregar y de obtener:

arreglo.add(10);
arreglo.add(120);

Ya hemos comentado el método add,para obtener un elemento del arreglo usamos el método get y le pasamos como parámetro el índice(comienza a contar desde 0) del elemento:

arreglo.get(10);

Si queremos ver el tamaño de un arreglo usamos el método size que nos devuelve un int,por ejemplo para recorrer los elementos de un array:

for (int i = 0;i < arreglo.size();i++)
    System.out.println(arreglo.get(i));


Antes de ver las otras funciones podemos ver que añadir tiene otra función,la cual es diferente,mientras el add normal "apila" los datos uno sobre otro,este otro add puede añadir un dato en cierta posición:

arreglo.add(posición,elemento);

Eso seria como un remplazar.

Bien ahora vamos a ver las formas de iterar los elementos de un array,forma uno:

Esta ya la vimos:

for (int i = 0;i < arreglo.size();i++)
    System.out.println(arreglo.get(i));


Forma dos:

Con un bucle foreach,donde Integer es el tipo de Objeto.

for (Integer x: arreglo) {
    System.out.println(x);
}


Forma tres con un Iterator,donde Integer no es el tipo de objeto.

import java.util.Iterator;

Iterator i = arreglo.iterator();

while(i.hasNext()) {
    System.out.println(i.next());
}


Bien que mas podemos hacer?

Tenemos mas funciones:

arreglo.clear(); // Limpia el array(lo resetea)

arreglo.contains(elemento); // Devuelve true si existe el elemento en el array


arreglo.remove(indice); // elimina un elemento basado en el índice

arreglo.remove(elemento); // elimina un elemento basado en el elemento

arreglo.toArray(); // Devuelve un array (Object[])

arreglo.indexOf(elemento); // Devuelve el índice del elemento contando desde la izquierda

arreglo.lastIndexOf(elemento); // Devuelve el índice del elemento contando desde la derecha



Hashes

Ahora vamos a ver como usar los arreglos asociativos o has tables,los cuales se usan igual que las listas solo que se usan con clave valor en vez de índice valor:

Para definir un Hashtable,primero lo importamos:

import java.util.Hashtable;

Ahora usamos este constructor:

Hashtable hash;

Los dos objetos son los que usaremos para clave y valor,se recomienda usar String para clave,por ejemplo:

Hashtable hash = new Hashtable();

Ahora vamos a ver como añadir elementos:

Usamos:

hash.put(clave,valor);

Por ejemplo usando el hash de arriba:

hash.put("uno",1);
hash.put("diez",10);

Ahora tenemos dos elementos en el hash,como los recuperamos?

hash.get(clave);

Por ejemplo:

hash.get("uno"); // devuelve 1

Tenemos funciones similares al de ArrayList:

hash.clear(); // Resetea el hash

hash.containsKey(clave); // Devuelve true si contiene la clave

hash.containsValue(valor); // Devuelve true si contiene el valor

hash.isEmpty(); // Devuelve true si esta vacio

hash.remove(clave); // Quita el objeto basado en clave


Como iteramos?

Aquí es un poco mas complicado ya que no podemos usar índices,pero aun así tenemos algunas opciones:

La primera opciones es usando Collection ,primero importamos:

import java.util.Collection;

Ahora creamos un objeto Collection,esta nos devolverá los valores:

Collection  col = hash.values(); // En donde Integer es el tipo de objeto de los valores
Luego creamos un Iterator,como con ArrayList y iteramos:

Iterator i = col.iterator();
while(i.hasNext()) {
  System.out.println(i.next());
}


Forma 2:

Esta otra forma es mas sutil ya que podremos usar las llaves y los valores,es usando Enumeration:

import java.util.Enumeration;

Enumeration en = hash.keys(); // En donde String es el tipo de Objeto de las claves

Bien ahora solo iteramos:

while(en.hasMoreElements()) {
      String key = en.nextElement();
      System.out.printf("Clave : %s Valor : %s\n",key,hash.get(key));
}






Eso es todo :D

Leer más...