Está realizado a partir de los archivos de la página web original y oficial: " "

Transcripción

1 mail: Parche 3.3 (Patch 3.3) Parche que inicialmente era para crear un archivo de configuración del teclado físico en español de España para Android x RC2, para que al instalarse en un pc portátil o si se conecta un teclado físico en un puerto USB, el teclado español funcione correctamente. La nueva versión permite cambiar fácilmente el archivo de configuración de teclado físico de cualquier idioma. El archivo es un archivo normal de texto plano pero de Linux, que se puede sacar fuera de Android y compartir este archivo por Internet con otras personas, para completar el tener todos los teclados físicos de todos los idiomas. Está realizado a partir de los archivos de la página web original y oficial: " " Y grupo de noticias: " Este parche 3 (Patch3) se considera acabado. Muchas gracias a Chih-Wei Huang miembro de por su ayuda. Esto es sólo un parche para tener el teclado en español, que espero que se incorpore a la siguiente versión que se saque en la web original y oficial Muchas gracias a ALoGeNo por su corrección, con fecha 01/10/2012 he modificado todos los archivos.kcm con este detalle aportado por ALoGeno que no estába contemplado en el archivo original "Generic.kcm" El error que había es: Si se pulsa [Bloq Mayús] entonces al pulsar las letras aparecen en mayúsculas Es decir si por ejemplo se pulsa 'o' como el bloqueo de mayúsculas está activo aparece 'O' en mayúsculas. Pero si se pulsa por ejemplo shift+'o' entonces debe aparecer 'o' en minúscula lugar de 'O' en mayúscula. (Es como si mayúsculas+mayúsculas=minúsculas) Muchas gracias a Stefan Seidel que es el autor de un conjunto de modificaciones en la APP "Settings.apk" del sistema de elección de teclado físico, que ya viene incluido en la versión original, y gracias a el se puede cambiar "on fly" (sin necesidad de reiniciar el ordenador). Me ha enviado una explicación de como cambiarlo. Incluso se puede cambiar en modo LiveCD, porque cuando se arranca en modo LiveCD siempre usa el teclado inglés de Estados Unidos y si fuera necesario reinicializarlo para aplicar el cambio, como esta todo en memoria se perdería el cambio. Cuento estas explicaciones en el archivo: "Como_cambiar_el_teclado_en_modo_LiveCD.txt" "How_to_change_keyboard_in_LiveCD_mode.txt". Hay una explicación fácil y rápida en este archivo. En el parche 3 (Patch3) también se incluye el emulador de ARM de Intel que permite ejecutar algunas aplicaciones APP con código nativo ARM gracias al desarrollo de la página " Y gracias a la página " que cuenta en español que simplemente hay que incluir unas bibliotecas y ese es el único añadido.

2 Como Intel publica su versión libremente y proporciona los fuentes y con licencia libre Apache entiendo que se puede utilizar legalmente. Es añadir: "libhoudini.so" dentro de "/system/lib" "libdvm_houdini.so" dentro de "/system/lib" y el conjunto de bibiliotecas que hay en "houdini_armlibs.tgz" lógicamente descomprimidas dentro de "/system/lib/arm" y ese el único añadido. Lógicamente hay que crear una nueva imagen "system.sfs" más grande y esto se cuenta también en "Como_Cambiar_(Generic.kcm).pdf" mail: luis393luis393@gmail.com En la antigua versión había que hacer lo siguiente, luego explico como está para la nueva versión: El archivo que define que caracteres le llegan a una aplicación al pulsar una tecla o combinación de teclas está en el directorio "/system/usr/keychars" y el archivo que se usa por defecto se llama "Generic.kcm" y tiene la definición del teclado de Estados Unidos. Dentro de dicho directorio vienen otros archivos como "Generic_de.kcm" que define el teclado alemán o "Generic_it.kcm" que define el teclado italiano y "Generic_fr.kcm" que define el teclado francés. Por lo que, por lógica, cabe esperar que el teclado español de España se debería de llamar "Generic_es.kcm" y efectivamente funciona. A partir del archivo "Generic.kcm" se ha creado el archivo "Generic_es.kcm" cambiando la definición de las teclas que eran distintas en el teclado físico en español de España y esto es todo lo que realmente supone el proyecto. Sólo se ha añadido este archivo "Generic_es.kcm" todo lo demás es idéntico a la versión original de " El añadir este archivo no es tan sencillo como parece ya que este directorio es de solo lectura. Hay muchos apartados a lo largo de este archivo. Al final se cuentas curiosidades genéricas de Android-x86. Una explicación rápida que luego se vuelve a repetir con más detalle: El directorio "/system/usr/keychars" y su contenido, está en la imagen "system.sfs" en la raiz del CD de instalación, y cuando se instala al disco duro está en el directorio "/android-4.0-rc2/system.sfs" Se empieza usando Linux. Como cualquier otra imagen de Linux se puede montar usando el comando de Linux "mount" aunque hay que estar como superusuario, administrador ó root $ sudo bash # cd /root # mkdir /root/tmp1 # cp /cdrom/system.sfs /root/tmp1 # mkdir /root/img1

3 # mount -t squashfs /root/tmp1/system.sfs /root/img1 -o loop (realmente con "mount /root/tmp1/system.sfs /root/img1" suele funcionar). pero el tipo squashfs es de solo lectura. Dentro de esta imagen hay otra imagen ya de tipo normal "system.img" por lo que: # cp /root/img1/system.img /root/tmp1 # umount /root/img1 # mount /root/tmp1/system.img /root/img1 -o loop (si vuestro Linux es un poco quisquilloso habrá que decir el tipo de imagen "mount -t ext3 /root/tmp1/system.img /root/img1 -o loop" pero curiosamente si no se pone tipo lo monta como ext4, cuando realmente es se tipo ext3, por lo que mejor si se puede no poner tipo) Y suponiendo que el archivo "Generic_es.kcm" está en el CD en /2-keychars/"Generic_es.kcm" : # cp /cdrom/2-keychars/generic_es.kcm /root/tmp1 # cp /root/tmp1/generic_es.kcm /root/img1/usr/keychars # sync # sync # umount /root/img1 # mkdir /root/tmp2 # cd /root/tmp1 # mksquashfs system.img /root/tmp2/system.sfs Y ya tenemos el archivo "Generic_es.kcm" dentro de la imagen "system.sfs" que está en el directorio "/root/tmp2" Luego hay que usar algún programa de modificación de imágenes iso para cambiar el archivo "system.sfs" y otro programa para crear el CD a partir de la nueva imagen.iso... como por ejemplo "brasero" y ya está. Lógicamente si nos queremos hacer nuestro propio archivo "Generic_es.kcm" no vamos a quemar un CD con cada prueba, se puede copiar el archivo "system.sfs" a la partición del disco duro donde tengamos instalado Android-x86 y arrancar el ordenador con Android-x86 y si vemos que de repente hacemos alguna modificación en el archivo "Generic_es.kcm" y el teclado está con el de Estados Unidos es porque hemos puesto algún carácter por encima del ascii 127 o hemos cometido algún error sintáctico. Cuando el archivo "Generic_es.kcm" esta mal lo que hace Android-x86 es usar el archivo "Generic.kcm". Esto tiene el inconveniente que hay que tener instalado Linux, realmente Android-x86 es un Linux y si se pudiese añadir el comando mksquashfs todo esto se podría hacer desde "Terminal Emulator" con Android-x86. La solución provisional de la nueva versión es en lugar de poner el archivo "Generic_es.kcm" se pone un enlace software ó symbolic link (como un acceso directo de Windows) a un lugar donde se pueda escribir, la SDCARD. Por tanto los comandos, empezando desde cero son, en Linux: $ sudo bash # cd /root # mkdir /root/tmp1 # cp /cdrom/system.sfs /root/tmp1 # mkdir /root/img1 # mount -t squashfs /root/tmp1/system.sfs /root/img1 -o loop Y igual que antes: # cp /root/img1/system.img /root/tmp1

4 # umount /root/img1 # mount /root/tmp1/system.img /root/img1 -o loop Pero ahora en lugar de copiar el archivo "Generic_es.kcm" copiamos los archivos de teclados que para España es "Generic_es_ES.kcm" # cp /cdrom/2-keychars/generic.kcm /root/tmp1/usr/keychars # cp /cdrom/2-keychars/keyboards/* /root/tmp1/usr/keychars # chmod 0664 /root/tmp1/usr/keychars/generic.kcm # chmod 0664 /root/tmp1/usr/keychars/generic_??_*.kcm Y hay que darle permisos adecuados de tipo "media_rw" para que se puedan leer en la scdard que luego el sistema lo convierte a tipo "sdcard_rw" pero como estamos en Linux ponemos su id es decir: (1023 = media_rw) (1015 = sdcard_rw) # chown 1023 /root/tmp1/usr/keychars/generic_??_*.kcm # chgrp 1023 /root/tmp1/usr/keychars/generic_??_*.kcm Luego estos archivo se copiaran por el sistema de instalación automático en la sdcard (realmente dentro de /data/media/keychars esto lo hace el script "5-keymaps") Y hay que crear los enlaces para que se acceda a estos archivos que luego están accesibles desde la sdcard # cd /root/tmp1/usr/keychars # ln -s /data/media/keychars/generic_es.kcm Generic_es.kcm ( y el mismo "ln" para cada 1 de los 44 idiomas, lógicamente cambiando el nombre, por ejemplo por ejemplo para portugues es "Generic_pt.kcm" ) ( lo de la ruta "/data/media" es porque para que se haga automáticamente se hace antes de que la SDCARD esté montada del todo y como realmente la SDCARD esta en este subdirectorio, así funciona. ) Y igual que antes: # sync # sync # umount /root/img1 # mkdir /root/tmp2 # cd /root/tmp1 # mksquashfs system.img /root/tmp2/system.sfs Lógicamente falta poner el archivo "Generic_es.kcm" dentro de la SDCARD, esto se hace automáticamente mediante "5-keymaps" en la instalación, pero para entenderlo supongamos que no esta hecho y que después de instalar el programa en el disco duro desde la terminal de Android "Terminal Emulator" tendríamos que hacer lo siguiente: $ su # cd /data/media # mkdir keychars # chmod 0775 keychars # chown media_rw keychars # chgrp media_rw keychars Y para tener el teclado Español # cp /system/usr/keychars/generic_es_es.kcm /data/media/keychars/generic_es.kcm # chmod 0664 /data/media/keychars/* # chown media_rw /data/media/keychars/keychars/* # chgrp media_rw /data/media/keychars/keychars/* Y para que un usuario lo pueda modificar más facilmente con el editor desde android usando "DroEdit_Free.app" existe el subdirectorio "keyboards" y "tmp"

5 # mkdir /data/media/keychars/keyboards # chmod 0775 /data/media/keychars/keyboards # chown media_rw /data/media/keychars/keyboards # chgrp media_rw /data/media/keychars/keyboards # mkdir /data/media/keychars/tmp # chmod 0775 /data/media/keychars/tmp # chown media_rw /data/media/keychars/tmp # chgrp media_rw /data/media/keychars/tmp (Y como los teclados los tenemos ya en "/system/usr/keychars") # cp /system/usr/keychars/generic_??_*.kcm keychars/keyboards # chmod 0664 keychars/keyboards/* # chown media_rw keychars/keyboards/* # chgrp media_rw keychars/keyboards/* Para tener nuestro teclado en español de España (ya lo hemos hecho antes): # cp keychars/keyboards/generic_es_es.kcm /data/media/keychars/generic_es.kcm O si queremos tener el teclado en español de hispanoamerica: # cp keychars/keyboards/generic_es_us.kcm /data/media/keychars/keychars/generic_es.kcm Y lo mismo para el resto de teclados. Y hay que moner los permisos adecuados parece raro que haya que poner "media_rw" en lugar de "sdcard_rw" pero he verificado que tiene que ser así, para que luego desde el directorio "/sdcard" ó "/mnt/sdcard" se puedan sobrescribir. # chmod 0664 /data/media/keychars/* # chown media_rw /data/media/keychars/keychars/* # chgrp media_rw /data/media/keychars/keychars/* Y ya está... Una explicación rápida de como acceder a la imagen "initrd.img" que es la que hay que modificar para conseguir que la SDCARD se modifique automáticamente es: Hay 3 tipos de imágenes: 1) Tipo squashfs - son de este tipo: system.sfs (esto ya está explicado) 2) Tipo imagen normal: ext3 (linux) / ext4 (Linux) / vfat (FAT Windows) / ntfs (Windows NT) son de este tipo: "data.img" que es de tipo ext3 (se monta de forma normal como con "system.img" que también es de tipo ext3 ya explicado) 3) Tipo digamos de archivo comprimido de imagen en memoria - son de este tipo: "initrd.img", "ramdisk.img", "install.img" Para acceder al interior de esta imagen, por ejemplo "initrd.img" hay que hacer lo siguiente en Linux: # cp /cdrom/initrd.img /root/tmp1 # mkdir /root/tmp1/initrd # cd /root/tmp1/initrd # gunzip -c../initrd.img cpio -i Y con esto se ha descomprimido (similar a un archivo tar) o similar a como

6 cuando en Windows comprimimos un directorio con todos su subdirectorios y lo metemos todo en 1 solo archivo.zip cuando lo descomprimimos tenemos todos los subdirectorios, pues igual. Y por lo tanto para ver el contenido y como ya estamos en el directorio /root/tmp1/intird # ls -la Se ha modificado el archivo "init" sólo añadiendo 1 linea con 1 llamada a la función "patch_keymaps" en la linea 172, para no alterar demasiado este archivo y ser respetuoso con lo hecho por Chih-Wei Huang. Y sólo se ha añadido el archivo "scripts/5-keymaps" que sólo tiene esta función "patch_keymaps". Para que se pueda ver más fácilmente el contenido de éste archivo "5-keymaps" hay una copia en CD de instalación en el directorio "1-readme" y únicamente se ha modificado esto, todo lo demás es idéntico a la versión original y oficial de " Y si se mira el resto de scripts que hay la mayoría son de Chih-Wei Huang por lo que se verá que hay un motón de trabajo de esta persona, y similar con el resto de imágenes. Muchas gracias Chih-Wei Huang por ofrecernos y darnos tu trabajo con esta distribución gratuita y libre. Y después de añadir lo indicado para crear la imagen y suponiendo que seguimos en el directorio /root/tmp1/initrd : # find. cpio -o -H newc gzip >../initrd.img Y ya esta... Un detalle hay versiones en pruebas que están cogiendo cosas de la versión de Android para x86 de Intel (que incomprensiblemente, que yo sepa, no existe en versión instalable en una partición de un PC y hay que usar qemu encima de Windows ) Pero para poder añadir estos archivos en "system.img" ("system.sfs") hay que hacer más grande la imagen (creo que también existen comandos para hacer una imagen más grande, pero no los conozco). Una explicación rápida de como meter las bibliotecas que permiten la emulación de ARM de Intel en la imagen "system.sfs" y por tanto en la imagen "system.img": Para usar las bibliotecas de Intel que permite la emulación de ARM que están en el CD de instalación en el directorio "4-Intel-ARM-Emulator": Pero primero necesitamos una imagen "system.img" más grande digamos de unos 400MB hay que tener en cuenta que luego al formatearla se pierde espacio. Para crear un archivo de imagen se usa el comando "dd" Por ejemplo para crear la imagen "system.img" con 400MB 1024 bytes es 1Kbyte 1024x1024 es un MB 400MB son 1024x1024x400 = bytes Pero como hay que indicar el número de bloques y cada bloque ocupa 512bytes / 512 =

7 Empezando desde cero en Linux: $ sudo bash # cd /root # mkdir tmp1 # mkdir img1 # cd /root/tmp1 # dd if=/dev/zero of=system.img count= Con esto tenemos un archivo vacío y hay que formatearlo, y como "system.img" es de tipo ext3: # mkfs -t ext3 -F system.img Y de forma similar a lo hecho con las imágenes hay que montarla # mount system.img /root/img1 Realmente si miramos el interior de la imagen no está totalmente vacía esta el directorio "lost+found", pero como "system.img" va a meterse luego dentro de "system.sfs" y es de sólo lectura no necesitamos este directori "lost+found", luego lo eliminamos con: # rm -r /root/img1/* Con esto tememos una imagen vacía y tenemos que copiar el contenido de la imagen original "system.img" que está en la raiz del CD de instalación, dentro de la nueva imagen "system.img" más grande que hemos creado. # cd /root # mkdir /root/tmp2 # mkdir /root/img2 # cp /cdrom/system.sfs /root/tmp2 Hay que montar la imagen "system.sfs" # mount /root/tmp2/system.sfs /root/img2 Dentro de la imagen "system.sfs" esta la imagen "system.img" # cp /root/img2/system.img /root/tmp2 # umount /root/img2 # mount /root/tmp2/system.img Y ahora ya tenemos el contenido de las 2 imágenes "system.img" accesibles en "/root/img1" tenemos la imagen nueva vacía que acabamos de crear y en "/root/img2" tenemos la imagen con el contenido original que tenemos que copiar a la nueva imagen y para esto usamos el comando "cp" pero con el parámetro -R para que copie directorios y subdirectorios y con el parámetro -p para que preserve o copie también las propiedades de permisos de usuario y propietarios de los archivos. # cp -R -p /root/img2/* /root/img1 # umount /root/img2 Y para no liarse como ya no necesitamos la imagen original mejor borrarla # rm /root/tmp2/* Luego hay que copiar las bibliotecas que están en el CD de instalación del directorio "4-Intel-ARM-Emulator" a tmp2 que esta vacío # cp /cdrom/4-intel-arm-emulator/* /root/tmp2 hay que poner: "libhoudini.so" dentro de /bin

8 "libdvm_houdini.so" dentro de /bin "houdini_armlibs.tgz" dentro de /bin/arm (lógicamente antes hay que descomprimirlo) # cp /root/tmp2/libhoudini.so /root/img1/bin # cp /root/tmp2/libdvm_houdini.so /root/img1/bin poner los permisos y propietarios correctamente # chmod 0644 /root/img1/bin/libhoudini.so # chmod 0644 /root/img1/bin/libdvm_houdini.so # chown root:root /root/img1/bin/libhoudini.so # chown root:root /root/img1/bin/libdvm_houdini.so Crear un subdirectorio "arm" para descomprimir "houdini_armlibs.tgz" # mkdir /root/tmp2/arm # cd /root/tmp2/arm # tar -zxpf../houdini_armlibs.tgz Copiar los archivos descomprimidos a la imagen "system.img" # mkdir /root/img1/bin/arm # cp /root/tmp2/arm/* /root/img1/bin/arm poner los permisos y propietarios correctamente (por si acaso) # chmod 0644 /root/img1/bin/arm/* # chown root:root /root/img1/bin/arm/* borrar los archivos de tmp2 que ya no vamos a usar # cd /root # rm -R /root/tmp2/* # rmdir tmp2 desmontar "system.img" y crear la nueva imagen "system.sfs" # sync # sync # umount /root/img1 # cd /root/tmp1 # rm system.sfs # mksquashfs system.img system.sfs Y ya esta... Ya tenemos la nueva imagen "system.sfs" dentro de /root/tmp1 con las bibliotecas del emulador ARM de Intel dentro. Una explicación con más detalle: Para poder hacer este cambio es necesario usar el comando de Linux "mksquashfs" y que yo sepa solo existe para Linux o Cygwin. En concreto he usado Linux Ubuntu que se puede descargar desde "http//: y para tener el comando "mksquashfs" es necesario los paquetes "liblzo2-2_2.06-1_i386.deb" y sobre todo "squashfs-tools_4.2-4build1_i386.deb" que se pueden descargar de la propia ubuntu o más fácilmente desde " que te busca los paquetes y te deja elegir varios orígenes y recomiendo elegir el lugar original de ubuntu, estos paquetes también existen para "Debian" " Hay muchas formas de hacerlo, pero yo recomiendo:

9 1º) Crear 4 particiones: 1º Partición para Windows XP / Windows 7 (Yo he usado Windows XP) 2º Partición para Linux Ubuntu (i386 Desktop) 3º Partición swap para Linux Ubuntu (4GB) (swap es la memoria de intercambio de memoria virtual con el disco duro para que así tengamos 4GB de RAM virtual en el sistema operativo, si tu portátil ya tiene 4GB no es necesaria esta partición, es más recomiendo que no lo uses) 4º Partición Para Android x RC2 y formatearla como FAT32 (es más fácil si se formatea como FAT32 porque así se accede directamente a esta desde Android, Windows y Linux) también existe un driver para Windows que permite leer y escribir en las particiones ext2/ext3/ext4 aunque la propia página web advierte que ext4 esta parcialmente implementada, te puedes bajar el driver de " Para crear estas particiones se puede arrancar Linux Ubuntu en modo LiveCD y ejecutar "gparted" que viene con el propio linux al arrancarlo en modo LiveCD y se puede modificar fácilmente el sistema de particiones del disco duro. Sino te quieres complicar tanto la vida posiblemente baste instalar Windows y Android 4.0 RC en el disco duro y luego usar Ubuntu en modo LiveCD todo el rato e instalar los 2 paquetes "liblzo2-2_2.06-1_i386.deb" y "squashfs-tools_4.2-4build1_i386.deb" en modo LiveCD pero pienso que a la larga va a suponer más complicaciones que trabajar un poco más al principio y tener los 3 sistemas operativos a la vez. Linux Ubuntu usa el sistema de arranque grub 2.0 que no reconoce al grub más antiguo que viene con la instalación de Android x RC2 (aunque considero que el antiguo más fácil de usar) por lo que recomiendo. 1º) Primero instalar Android 4.0 RC2 y que reconozca Windows y Android y ver que aparece el menú de arranque que permite elegir si arrancar Windows o Android. La configuración de este menú esta en un archivo modo texto "menu.lst" que luego podemos usar para ver la configuración y ver que parámetros hay que pasar al kernel cuando después se instale Linux y nos machaque el grub de Android. Por tanto copiar este archivo menu.lst en la partición de Windows para así tenerlo visible desde Windows, este archivo se puede abrir en Windows con el "WordPad" y guardarlo para que cambie el salto de línea y así luego más fácilmente también se pueda abrir con el "bloc de notas" aunque el salto de línea este en modo Windows funciona con grub de Android y lo reconoce bien y fácilmente podemos modificarlo con el "block de notas". Por ejemplo poner en primer lugar el bloque de arranque de Windows para que por ejemplo se arranque por defecto con Windows. Hacer pruebas para familiarizarse con el "menu.lst". Si nos equivocamos y vemos que no arranca ningún sistema operativo, no pasa nada, arrancamos con el LiveCD de Linux Ubuntu y como nos reconoce la partición de Windows y de Android y tenemos una copia original y correcta de "menu.lst" en la partición de Windows la copiamos en la partición de Android y con esto está todo restablecido. Si aún así no funciona reinstalamos encima Android x86 RC2 en la partición de Android y con eso ya nos reconoce Windows y Android (pero esto significa que hemos hecho algo excesivamente mal y conviene que entendamos mejor como funciona todo antes de continuar y hacer una copia de lo importante de Windows por si la volvemos a liar y hay que reinstalar Windows desde cero) 2º) Segundo instalar Linux Ubuntu en el disco duro con lo que nos va a machacar el grub de Android con el grub 2.0 de Ubuntu y nos aparecerá un nuevo menú de arranque en el que sólo tendremos Ubuntu y Windows. No aparecerá Android por lo que habrá que añadirlo a mano y para eso nos hace falta el archivo "menu.lst" que tenemos en la partición de Windows y en la de Android (pero mejor hacer una copia en la partición de Windows

10 (o tenerlo impreso o copiado en un papel). El archivo de configuración del grub 2.0 en Linux esta en el directorio "\boot\grub" y el nombre ha cambiado ahora se llama "grup.cfg". Realmente para hacerlo bien el propio manual que se puede ver al ejecutar en un terminal "$ man grub" ó "$ info grub" hay que añadir una serie de archivos dentro del directorio "/etc/grub.d" (al final lo he hecho correctamente y hay un ejemplo del arhico que hay que añadir en el CD en el directorio "3-grub2-ubuntu12.04" lógicamente cambiando antes el número de partición y los comandos adecuados que se le pasen al kernel de Android-x86, yo tengo un netbook Assus eeepc 1000HD) y luego ejecutar un comando para que modifique el archivo "grub.cfg" ya que sino en el momento que actualicemos el sistema operativo desde Ubuntu va a ejecutar este ejecutable y nos va a machacar nuestro archivo "grub.cfg", pero sinceramente no me he leído toda esta documentación y directamente he modificado el archivo "grub.cfg" y he hecho la correspondiente copia de seguridad y asi cuando actualizo el sistema y me lo machaca simplemente lo copio encima y ya está. Como antes que no se os olvide hacer una copia del archivo original y correcto "grub.cfg" a la partición Windows ya que si nos equivocamos y no arranca con ningún sistema operativo, no pasa nada, arrancamos con el LiveCD de Ubuntu y copiamos el archivo "grub.cfg" original que tenemos guardado en la partición de Windows a la partición de Ubuntu y con eso esta todo restablecido. En el archivo de configuración de grup 2.0 en lugar de la palabra clave "kernel" usa "linux" Si por ejemplo en el antiguo "menu.lst" tenemos los 2 siguientes bloques de menú para la versión eeepc y que son el primer bloque para arrancar android en modo normal y el segundo en modo debug: title Android-x RC2 kernel /android-4.0-rc2/kernel quiet root=/dev/ram0 androidboot.hardware=eeepc acpi_sleep=s3_bios,s3_mode SRC=/android-4.0-RC2 initrd /android-4.0-rc2/initrd.img title Android-x RC2 (Debug mode) kernel /android-4.0-rc2/kernel root=/dev/ram0 androidboot.hardware=eeepc acpi_sleep=s3_bios,s3_mode DEBUG=1 SRC=/android-4.0-RC2 initrd /android-4.0-rc2/initrd.img En el archivo "grub.cfg" de ubuntu habra que poner el siguiente bloque que si se fija uno bien dentro tienen los 2 bloques igualmente. ### BEGIN /etc/grub.d/10_android ### menuentry 'Android-x RC2 (on /dev/sda4)' --class gnu-linux --class gnu --class os { insmod gzio insmod part_msdos set root='(hd0,msdos4)' linux /android-4.0-rc2/kernel quiet root=/dev/ram0 androidboot.hardware=eeepc acpi_sleep=s3_bios,s3_mode SRC=/android-4.0-RC2 initrd /android-4.0-rc2/initrd.img } menuentry 'Android-x RC2 (Debug mode) (on /dev/sda4)' --class gnu-linux --class gnu --class os { insmod gzio

11 insmod part_msdos set root='(hd0,msdos4)' linux /android-4.0-rc2/kernel root=/dev/ram0 androidboot.hardware=eeepc acpi_sleep=s3_bios,s3_mode DEBUG=1 SRC=/android-4.0-RC2 initrd /android-4.0-rc2/initrd.img } ### END /etc/grub.d/10_android ### Como se verá salvo el añadido de las siguientes 4 lineas, el resto es idéntico, lo único que en lugar de kernel pone linux: menuentry... insmod gzio insmod part_msdos set root='(hd0,msdos4)' La linea: set root='(hd0,msdos4)' significa que el sistema de particiones es el de msdos ya que actualmente hay sistemas de particiones efi incluso existen otros sistemas y que Android esta en el disco duro 0 en la partición 4 (las particiones no se numeran desde 0 sino que empiezan desde 1) Cuando se usa gparted se indica el tipo de partición no obstante estas lineas son una copia de las líneas iniciales del bloque de ubuntu, por lo que si tu sistema de particiones es efi u otro sistema que linux entienda simplemente tendrás que copiar lo que ponga en el bloque ubuntu. Con esto ya debería aparecer 2 nuevas líneas que permitan arrancar el Android-x86 en modo normal y en modo debug. 3º) Al instalar Ubuntu se instalan bastantes programas pero no se instala el programa "mksquashfs" y para ello son necesarios los paquetes "liblzo2-2_2.06-1_i386.deb" y sobre todo "squashfs-tools_4.2-4build1_i386.deb" que se pueden descargar de la propia ubuntu o más fácilmente desde " que te busca los paquetes y te deja elegir varios orígenes y recomiendo elegir el lugar original de ubuntu, estos paquetes también existen para "Debian" " Para instalar un conjunto de paquetes tipo.deb desde una terminal hay que ejecutar en modo administrador o root: $ cd (para ir al directorio home de nuestro usuario) $ cd Descargas (para ir al subdirectorio Descargas que se esta suponiendo que es donde están los paquetes que se quieren instalar) $ ls -l *.deb (para listar los paquetes que acaban en.deb y verificar que se está en el directorio donde están los paquetes que queremos instalar) $ sudo dpkg -i *.deb (para instalar en modo administrador o modo root todos los paquetes del directorio actual que acaben en.deb. El programa verifica las interdependencias e instala primero los que no dependan de otros paquetes y por último los que dependan de los primeros, si algún paquete depende de otro paquete que no esta instalado aparece un mensaje de error que lo indica) También hay un programa que de forma visual permite instalar un grupo de paquetes que tengamos en un directorio que se llama "synaptic". Hay que elegir en el menú "Archivos"/"Añadir paquetes descargados" y elegir el directorio donde están los paquetes que queramos instalar También hay otro programa más parecido a dpkg pero de forma visual que permite instalar, pero sólo un paquete cada vez, que se lama "gdebi" con

12 este programa podemos ver si un paquete tiene dependencias que no están instaladas para comprobar que paquetes dependen unos de otros (pero esto es sólo por si queremos tener un mayor control y estar seguros de que paquetes dependen de otros) pero lo más cómodo es usar "synaptic" que instala un grupo de paquetes e igualmente da un error si falta algún paquete en la lista de interdependencias de paquetes, incluso si tenemos paciencia y aprendemos a usarlo bien nos muestra informes de interdependencias y entonces ya no usaremos "gdebi". Ademas si a la hora de instalar paquetes ocurre algo que estropea el registro de instalación "synaptic" lo arregla. 4º) El directorio "/system/usr/keychars" y su contenido, está en la imagen "system.sfs" en la raiz del CD de instalación, y cuando se instala al disco duro está en el directorio "/android-4.0-rc2/system.sfs" Como cualquier otra imagen de Linux se puede montar usando el comando de Linux "mount" aunque hay que estar como administrador ó root $ sudo bash (para ponerse en modo administrador ó root) # cd /root (cambiar al directorio /root) # mkdir /root/tmp1 (crear el subdirectorio tmp1 dentro del directorio /root) # cp /cdrom/system.sfs /root/tmp1 (copiar system.sfs desde el cdrom a tmp1) # mkdir /root/img (crear el subdirectorio img) # mount -t squashfs /root/tmp1/system.sfs /root/img -o loop (montar la imagen system.sfs en el directorio /root/img) (realmente con "mount /root/tmp1/system.sfs /root/img" suele funcionar). pero el tipo squashfs es de solo lectura. Dentro de esta imagen hay otra imagen ya de tipo normal "system.img" por lo que: # cp /root/img/system.img /root/tmp1 (copiar el archivo system.img a tmp1) # umount /root/img (desmontar la imagen que esta montada en /root/img) # mount /root/tmp1/system.img /root/img -o loop (montar la imagen system.img en el directorio /root/img) (si vuestro linux es un poco quisquilloso habrá que decir el tipo de imagen "mount -t ext3 /root/tmp/system.img /root/img -o loop" pero curiosamente si no se pone tipo lo monta como ext4 por lo que mejor si se puede no poner tipo) y suponiendo que el archivo "Generic_es.kcm" está en la raíz del CD # cp /cdrom/generic_es.kcm /root/tmp1 (copiar Generic_es.kmc que está en el directorio /cdrom a /root/tmp1) # cp /root/tmp1/generic_es.kcm /root/img/usr/keychars (copiar Generic_es.kcm desde /root/tmp1 a /root/img/usr/keychars y por lo tanto lo esta copiando dentro de la imagen system.img) # sync (sincronizar los discos duros, es decir escribir y vaciar lo que este en la memoria caché escribiéndolo en los discos duros) # sync (repetir por si acaso, realmente no haría falta) # umount /root/img (desmontar la imagen system.img que estaba montada en el directorio /root/img como esta imagen si que es de escritura antes se ha ejecutado sync para que se escribiese el contenido de la memoria cache en la imagen, teóricamente no debería hacer falta sync ya que se supone que umount hace un sync pero he comprobado que en ocasiones da error por lo que mejor hacer antes un sync incluso 2 veces por si acaso) # mkdir /root/tmp2 (crear el subdirectorio tmp2 # mksquashfs /root/tmp1/system.img /root/tmp2/system.sfs (crear una imagen de tipo squashfs en la que se meterá dentro el archivo system.img y esta imagen se crea en /root/tmp2 y con el nombre system.sfs) Y ya tenemos el archivo "Generic_es.kcm" dentro de la imagen "system.sfs" que está en el directorio "/root/tmp2"

13 Luego hay que usar algún programa de modificación de imágenes iso para cambiar el archivo "system.sfs" y otro programa para crear el CD a partir de la nueva imagen.iso... y ya está. Lógicamente si nos queremos hacer nuestro propio archivo Generic_es.kcm no vamos a quemar un CD con cada prueba, se puede copiar el archivo "system.sfs" a la partición del disco duro donde tengamos instalado Android y arrancar el ordenador con Android y sin vemos que de repente hacemos alguna modificación en el archivo "Generic_es.kcm" y el teclado está con el de Estados Unidos es porque hemos puesto algún carácter por encima del ascii 127 o hemos cometido algún error sintáctico. Cuando el archivo "Generic_es.kcm" esta mal lo que hace Android-x86 es usar el archivo "Generic.kcm". Otro tipo de temas interesantes: Durante la explicación mencioné que recomendaba crear la partición donde se instalaba Android-x86 como tipo FAT porque es más fácil acceder a ella desde Windows, Linux y Android-x86. Windows y Linux te montan las particiones automáticamente (en Linux hay que pinchar encima del nombre y entonces se monta) Pero para acceder a una partición desde Android-x86 hay que hacerlo manualmente y cuidado porque Android es muy muy quisquilloso y la sintaxis no es como en Linux que coge valores por defecto, en Android hay que poner todos los parámetros y de forma perfecta: (reamente hay 2 grupos de comandos los comandos "busybox" son los de linux y no hace falta poner todos los parámetros, eso lo explico más adelante) Todos los comandos en Android-x86 se realizan a través de la APP "Terminal Emulator" recomiendo cambiar en el menú el usar los caracterer UTF-8, también en el menú se puede cambiar la ruta incial del PATH y por defecto está "export PATH=/data/usr/bin:$PATH" recomiendo poner: "export PATH=/data/usr/bin:/system/xbin:$PATH" para usar primero los comandos de "/system/xbin" que son los del "busybox" más estandar con linux que los comandos de "/system/bin" y con este sistema usa el interprete de comandos "bash" con lo que al hacer un "ls" sale con colorines para distinguir el tipo de archivo por lo que recomiendo cambiar el fondo de la pantalla a negro para poder ver los colorines, después de cambiar las opciones hay que salir de "Terminal Emulator" con el comando "exit" para que realmente se salga y se apliquen los cambios. Cuidado porque si se cambia el teclado físico con exit no es suficiente para que se descargue de la memoria y se cambie el teclado, es necesario matar la app con "kill" esto se cuenta en: "Como_cambiar_el_teclado_en_modo_LiveCD.txt" "How_to_change_keyboard_in_LiveCD_mode.txt". 1º) Abrir la APP "Terminal Emulator" y teclear lo siguiente: $ su (para ser superusuario, administrador o root) # cd /mnt/sdcard (para ir al directorio /mnt/sdcard) # mkdir hd (para crear el sudirectorio "hd" de Hard Disk (disco duro)) # mount -t vfat /dev/block/sda4 /mnt/sdcard/hd (para montar como tipo versatile fat es decir un montón de tipos y sub tipos de particiones entre ellos la fat32 y se monta el dispositivo "/dev/block/sda4",

14 lo de "sda4" es porque "s" es de tipo serial ide ó scsi que es el nuevo tipo de controladora de discos duros, "d" de disco duro, "a" porque es la primera unidad de disco duro, la segunda unidad es "sdb4" y la tercera "sdc4" y lo de "4" porque es la partición 4 (el número de partición empieza desde 1) # cd /mnt/sdcard/hd (para ir al directorio /mnt/sdcard/hd que es el disco duro) # ls -la (para listar el contenido del directorio y ver los archivos) # cd / (para desmontar un disco tenemos que estar fuera) # umount /mnt/sdcard/hd (para desmontar el disco duro) De forma similar también se puede montar la unidad de cd-rom # cd /mnt/sdcard (para ir al directorio /mnt/sdcard ) # mkdir cdrom (para crear el subdirectorio cdrom ) # mount -r -t iso9660 /dev/block/sr0 /mnt/sdcard/cdrom (para montar como tipo solo lectura "-r" y de tipo cdrom "-t iso9660" y se monta el dispositivo /dev/block/sr0, lo de "sr0" es porque "s" es el tipo serial ide ó scsi que es el nuevo tipo de controladora de disco duro, "r" porque es una unidad cd-rom/dvd-rom, 0 es porque es la primera unidad de cdrom, aquí han mantenido el antiguo sistema ya que antes los discos duros se llamaban hd0 y el número de la unidad era un número en lugar de la letra actual, como en un cd-room no hay particiones han mantenido el antiguo sistema y la primera unidad empieza en 0 por lo que si tenemos otra segunda unidad será "sr1". Todo este proyecto lo he realizado usando un netbook asus eeepc HD1000 que viene sin unidad de cdrom pero he conectado una externa en un puerto usb y funciona bien. # cd /mnt/sdcard/cdrom (para ir al subirectorio cdrom que es la unidad cd-rom) # ls -la (para listar el contenido del cd-rom) # cd / (para estar fuera de la unidad cd-rom) # umount /mnt/sdcard/cdrom (para desmontar la unidad de cd-rom y entonces al pulsar el botón de extraer cd ya funciona y ya nos permite sacar el cd y meter otro distinto, luego hay que cerrar la bandeja para que se meta el cd, y volver a montarla para poder leer el nuevo cd) En esta nueva versión de Android 4.0 RC2 si que funciona si metemos un pendrive-usb pero tiene que estar formateado como tipo FAT32 y ojo del tipo antiguo ya que no reconoce todos los tipos de FAT32. Con Windows en el icono de "MiPc" y luego con el botón derecho en el menú contextual elegir "Administrar" y luego "Administración de discos" y elegimos la unidad de pendrive-usb y con el botón derecho del ratón en el menú contextual elegir "Formatear..." y hay que elegir FAT32 y este tipo si que lo reconoce Android. Cuando se mete un pendrive-usb lo monta automáticamente y para sacarlo hay que extraerlo de forma segura igual que en Windows y para ello hay que ir a la APP "Ajustes" y en "Almacenamiento" / "Almacenamiento USB" pinchar encima de "Desactivar tarjeta SD". Mientras esta montado un pendrive-usb esta montado en "/mnt/usb". En el "Google market/play store" hay aplicaciones que te permiten hacer una copia de seguridad de las APPs que tengas instaladas por ejemplo la APP "File Expert" lo permite y las guarda en "/mnt/sdcard/backup_apps" aunque le puedes cambiar el directorio por defecto. Y asi las puedes guardar en la unidad del disco duro de tu pc (previamente montado) y tener las APP's guardadas por si reinstalas el sistema o copiarlas en un Pendrive-usb para pasarlas a otro PC con Android-x86 o a un móvil o tablet normal con el microprocesador ARM y probar como de compatibles son y si funcionan igual en un tablet normal con mircroprocesador ARM y en un PC con Android-x86. (para copiarlas al pendribe-usb es necesario tener derechos de administrador desde la APP "Terminal" se puede cambiar a modo administrador con el comando "su" ).

15 Había una antigua versión de "File Expert" "File_Expert_3.2.6.apk" que permitía conseguir los derechos de administrador marcando una de las opciones del menú de la APP y copiar de forma normal, pero ahora curiosamente esta opción sólo está disponible en la versión "File Expert Pro" que ya no es gratuita, pero puedes copiarlos también con el comando "cp" habiéndose puesto antes en modo administrador: $ su # cp /mnt/sdcard/backup_apps/* /mnt/usb Otra posibilidad es montar el pendrive-usb manualmente dentro del directorio "/mnt/sdcard/usb" para ello metemos el pendrive-usb solo que entonces Android lo auto-monta y hay que ir a la APP "Ajustes" y en "Almacenamiento" / "Almacenamiento USB" pinchar encima de "Desactivar tarjeta SD". Luego ir a la APP "Terminal Emulator" y teclear lo siguiente: $ su # cd /mnt/sdcard # mkdir /mnt/sdcard/usb (para crear el subdirectorio "USB" dentro de "/mnt/sdcard" # mount -t vfat /dev/block/vold/8:17 /mnt/sdcard/usb (lo de 8:17 es porque he visto que es el que usa Android cuando se automonta par poder ver un listado de las unidades montadas basta con ejecutar el comando mount sin parámetros) Y ahora ya está montado el pendrive-usb pero sobre un directorio que permite leer y sobre todo escribir por lo que podemos usar cualquier gestor de archivos como por ejemplo el que viene con el propio Android 4.0 RC2 que se llama "Open Manager" Para poder sacar de forma segura el pendrive-usb hay que demontarlo y para ello ejecutamos la APP "Terminal Emulator" y ejecutamos $ su # umount /mnt/sdcard/usb Y ya podemos sacar el pendrive-usb También podemos montar la partición de Linux-ubuntu desde Android En ubuntu la partición es de tipo ext4 y es una partición que es como si hiciera una copia en otra partición por lo que ocupa 2 particiones y hay que ir probado con las 2 posibles, en mi caso se monta en la partición nº 5 es decir sda5 $ su # mkdir /mnt/sdcard/ubuntu # mount -t ext4 /dev/block/sda5 /mnt/sdcard/ubuntu y para desmontarlo como en el resto de las ocasiones basta con teclear # umount /mnt/sdcard/ubuntu Al principio de este apartado mecione que hay 2 tipos de comandos, los que están en "/system/bin" que son los quisquillosos y hay que poner los parámetros perfectos y son los que por defecto biene en la ruta de ejecutables de la variable de entorno PATH $ echo $PATH /data/usr/bin:/system/bin:/system/xbin Los comandos del directorio "/sytem/xbin" son los de busybox y son muy parecidos a

16 los de linux y no hace falta poner todos los parámetros. Hay comando repetidos y entre ellos esta "mount" para usar el mount de busybox hay 2 formas: 1º) $ su # /system/xbin/mount /dev/block/sda5 /mnt/sdcard/ubuntu (como se verá no ha hecho falta especificar al comienzo -t ext4) # ls /mnt/sdcard/ubuntu # umount /mnt/sdcard/ubuntu 2º) cambiar para que en el PATH coja primero los de busybox $ su # export PATH=/data/usr/bin:/system/xbin:/system/bin # mount /dev/block/sda5 /mnt/sdcard/ubuntu (como se verá no ha hecho falta especificar al comienzo -t ext4) # ls /mnt/sdcard/ubuntu # umount /mnt/sdcard/ubuntu y si hacemos un "ls / " veremos que nos lo muestra de colorines como en linux El busybox es poner los comandos de Linux que le falta a Android ya que Android en el fondo es un Linux, incluso tiene el comando de "man" pero no funciona porque no están metidos los manuales ni las variables de entorno que le harían falta pero si se meten supongo que funcionaria bien. Es una pena que Android no reconozca particiones de tipo "ntfs" que son las de Windows. Hay apps que permiten reconocerlas como "NTFSMount.apk" pero que yo sepa sólo hay versiones para microprocesadores ARM y se puede encontrar este tipo de APPs en " Y fin de la película...