Ubuntu on Android

De GiLUG
La revisió el 10:02, 8 feb 2013 per Narcisgarcia (discussió | contribucions) (Anotar la arquitectura)
Salta a: navegació, cerca

Català - Castellano - English


Introduction: This is a guide to make work an Ubuntu GNU/Linux container inside an Android operating system session, and by this way have the desktop computer functionality without loosing performance. This is a very detailed guide, also useful to people who wants to create a wizard or improve the procedure.

Notes:

  • At the moment of writing this guide (november 2011), Canonical still doesn't have its own solucion ready. The best working version for the default desktop (Unity) is the 12.04 (Precise)
  • The total downloads proposed can reach to 1GiB of data; if you do all from the device, take care of the data plan prices that applies the internet access provider.
  • The possibility of using an LXC container has been explored to have a completely normal container, but didn't worked because of the use of bionic lic instead of GNU libc by Android.

TRANSLATION IN PROGRESS

Superuser permissions (root)

It's a requirement to have "su" access to manage the operating system. Es un requisito tener acceso "su" para administrar el sistema operativo. You can see the guide Open permissions in Android

Terminal access

Local terminal

It's advisable always to have a Terminal application (that you can get freely with F-Droid) available to can do managements with mobility, but it's more comfortable to do the long and complex preparations from a desktop computer, controlling the device connected through USB.

Remote control

In the Ubuntu GNU/Linux distribution, since version 12.01 in the universal repository there is available the package android-tools-adb that allows the remote control to a device with Android in USB debug mode. There is also an independent repository that provides android-tools for previous versions.

To use the Android Debug Bridge (ADB) you must have the device working, plugged through USB, and with the mode "USB debug" enabled in the developer preferences of Android.

ADB through USB
  • To check the connectivity:
adb devices

(must show a "list" with a rare identifier that says it's a device)

  • To open a terminal session in the device:
adb shell
  • To start a superuser (root) session, and have Android administration permissions:
su
  • To end as superuser and after also close the terminal session:
exit
exit
ADB through network

Many connections through USB aren't much stable (break often and you realize that are writing in your computer), and in these cases it's solved with net (Wifi). When this is done, it's important that the device hasn't direct internet connection (for example with the telephony provider) and it's working in a communication through the local Wifi.

  • From Android, to see the enabled network devices (default... dev -->):
ip route list
  • From Android, to see the IP address of a network device (for example wlan0):
ifconfig wlan0
  • From the computer, to set the communication to be through network (for example to the IP 192.168.1.122):
adb connect 192.168.1.122
  • To open a terminal session in the device:
adb shell
  • To start a superuser (root) session, and have Android administration permissions:
su
  • To end as superuser and after also close the terminal session:
exit
exit
Additional notes
  • In this guide, where written commands are indicated, they are to be run in a local or remote terminal window.
  • If you get messages as "Operation not permitted" , it's often because you didn't begin as superuser (su)

Chech the available tools

In a terminal check this command:

chroot

It can answer two things: the help presentatiom (with "usage: chroot...") or the error message "chroot: not found". In this last case (not found) you have an Android variant very clipped, and you need to replace it for another one more free such as CyanogenMod or Replicant. Other alternatives more technical are: Superimpose directories over Android or To format a memory card.

Take note of the architecture

The processor generation used by Android can be looked with one of the following commands:

uname -m
cat /proc/cpuinfo

If the device's ARM processor supports floating-point (ARMv7 or superior, for example armv7l matches), then you can use "armhf" instead of "armel". This enhaces some processes speed.

Preparar el espacio

Para que funcionen los enlaces y accesos a dispositivo hace falta que el nuevo contenedor esté en una partición apropiada para GNU/Linux, como por ejemplo Ext3 o Ext4. Con la instrucción mount se puede ver el formato de cada volumen, y con esta sintaxis se ve muy claro:

mount | cut -f 1-5 -d ' ' | sed -e 's/ on / /g' | sed -e 's/ type / /g' | cut -f 2-3 -d ' '

Y se puede filtrar para ver sólo lo que nos interesa:

mount | cut -f 1-5 -d ' ' | sed -e 's/ on / /g' | sed -e 's/ type / /g' | cut -f 2-3 -d ' ' | sed -e '/ext.$/!d'

Una vez vistas las rutas compatibles, debe valorar el espacio libre que hay con esta instrucción:

df

Si en el espacio libre (Free) no se menciona la unidad de medida (100K, 100M, 100G), significa que se expresa en K (KiB). A tener en cuenta tambien que la ruta /cache funciona «como una papelera interna» y que su contenido puede ser borrado automáticamente.

Necesita almenos 100MiB para una instalación elemental (core solo), o hacia los 250MiB para un debootstrap, pero se puede llegar a utilizar 2 o 3GiB si instala todas las grandes aplicaciones de escritorio de uso común, aparte de contyar con un poco de espacio de trabajo. Igualmente se pueden hacer instalaciones «para todos los bolsillos».

Para el resto de guía supondremos que ha escogido la partición /data, y entonces el nuevo sistema operativo lo pone en /data/ubuntu. Debe habilitar entonces los permisos de escritura, ejecución, dispositivos y superusuario en la partición, y crear el subdirectorio::

mount -o remount,rw,dev,exec,suid,noatime /data
PuntoRaiz="/data/ubuntu"
mkdir "$PuntoRaiz"
cd "$PuntoRaiz"

Obtener una base de sistema operativo

Esta sería la manera de construirlo desde otro ordenador (suponiendo arquitectura para armhf) en una partición Ext2/Ext3:

sudo debootstrap --verbose --arch=armhf --foreign precise precise-armhf
  • Para transportar el arbol de directorios de un dispositivo a otro, hay que copiarlo con permisos de superusuario, para que los atributos y propietarios de ficheros y directorios no se pierdan por el camino. Para abrir así un explorador de carpetas con Ubuntu, se puede ejecutar (Alt+F2) «gksudo nautilus».

Pero aqui tambien proponemos la manera de hacerlo completamente desde el aparato con Android: descargando una base preparada (del web oficial) con sólo una de estas instrucciones, según la versión y variante que necesite (se publicaran más versiones en cdimage.ubuntu.com):

wget http://cdimage.ubuntu.com/ubuntu-core/releases/precise/release/ubuntu-core-12.04.1-core-armhf.tar.gz
wget http://cdimage.ubuntu.com/ubuntu-core/releases/oneiric/release/ubuntu-core-11.10-core-armel.tar.gz
wget http://cdimage.ubuntu.com/ubuntu-core/releases/quantal/release/ubuntu-core-12.10-core-armhf.tar.gz
wget http://cdimage.ubuntu.com/releases/precise/release/ubuntu-12.04-preinstalled-desktop-armhf+ac100.tar.gz
wget http://cdimage.ubuntu.com/releases/oneiric/release/ubuntu-11.10-preinstalled-desktop-armel+ac100.tar.gz

Nota: Las «preinstaled» traen todo el software de una instalación típica, pero tambien elementos que hay que limpiar para arrancar el contenedor.

Con el fichero descargado, toca desempaquetarlo:

tar -xzf ubuntu-core-12.04.1-core-armhf.tar.gz
rm ubuntu-core-12.04.1-core-armhf.tar.gz

Adaptar la base

Corrija algunos enlaces dentro del directorio de la base, para adecuarlos más a la situación:

chmod 755 "$PuntoRaiz"
if [ -d /acct ] ; then mkdir -p acct ; fi
cd var
if [ -L run ] ; then rm run ; ln -s ../run run ; fi
if [ -L lock ] ; then rm lock ; ln -s ../run/lock lock ; fi
cd "$PuntoRaiz"

Limpie directorios que a veces vienen con contenido para una instalación nativa:

if [ -d proc ] ; then rm -R proc/* ; fi
if [ -d dev ] ; then rm -R dev/* ; fi
if [ -d sys ] ; then rm -R sys/* ; fi
if [ -d var/run/dbus ] ; then rm -R var/run/dbus/* ; fi

Montar recursos de Android

mount -o bind "/proc" "$PuntoRaiz/proc"
mount -o bind "/dev" "$PuntoRaiz/dev"
mount -o bind "/dev/pts" "$PuntoRaiz/dev/pts"
mount -o bind "/sys" "$PuntoRaiz/sys"
if [ -d /acct ] ; then mount -o bind "/acct" "$PuntoRaiz/acct" ; fi
if [ -d /dev/cpuctl ] ; then mount -o bind "/dev/cpuctl" "$PuntoRaiz/dev/cpuctl" ; fi

Si quiere hacer disponibles las carpetas de Android, se debe que mirar qué particiones hay montadas. Se puede hacer con un simple mount o con esta instrucción que simplifica la información:

mount | sed -e '/ \/mnt\//!d' | sed -e '/^\//!d' | cut -f 2,3 -d ' ' | cut -f 2- -d '/' | cut -f 1 -d ' ' | sed -e 's/^/\//g'

Si por ejemplo queremos montar /mnt/sdcard hacemos:

mkdir -p "$PuntoRaiz/mnt/sdcard"
mount -o bind "/mnt/sdcard" "$PuntoRaiz/mnt/sdcard"

Entrar en el nuevo sistema y establecer servicios elementales

Desde la incorporación del sistema de inicio de servicios Upstart, los contenedores Chroot no inician los servicios como una instalación normal, y hay que hacerlo manualmente.

chroot "$PuntoRaiz" /bin/su
mount -a

Asegúrese de que figure alguna cosa montada, para que no fallen algunas utilidades:

if [ "$(mount)" = "" ] ; then mount -o bind /selinux /selinux ; fi

Complete el debootstrap si es el caso, en la misma arquitectura:

if [ -x /debootstrap/debootstrap ] ; then /debootstrap/debootstrap --second-stage ; fi

Parche para evitar error de inicio de servicios Upstart:

dpkg-divert --local --rename --add /sbin/initctl
ln -s /bin/true /sbin/initctl

Configure la red:

echo "nameserver 4.2.2.2" > /etc/resolv.conf
echo "nameserver 8.8.8.8" >> /etc/resolv.conf
echo "nameserver 8.8.4.4" >> /etc/resolv.conf
echo "127.0.0.1 localhost" > /etc/hosts

Compruebe si hay repositorios establecidos:

cat /etc/apt/sources.list

Si no había nada, o los «universe» estan deshabilitados con #, escribalos con las siguientes instrucciones (ejemplo para Ubuntu 12.04, llamado «precise»):

Version="precise"
echo "deb http://ports.ubuntu.com/ ${Version} main universe" > /etc/apt/sources.list
echo "# deb-src http://ports.ubuntu.com/ ${Version} main universe" >> /etc/apt/sources.list
echo "" >> /etc/apt/sources.list
echo "deb http://ports.ubuntu.com/ ${Version}-updates main universe" >> /etc/apt/sources.list
echo "# deb-src http://ports.ubuntu.com/ ${Version}-updates main universe" >> /etc/apt/sources.list
echo "" >> /etc/apt/sources.list
echo "deb http://ports.ubuntu.com/ ${Version}-security main universe" >> /etc/apt/sources.list
echo "# deb-src http://ports.ubuntu.com/ ${Version}-security main universe" >> /etc/apt/sources.list
apt-get update

Instale servicios y herramientas para evitar quejas (los paquetes -es son para el idioma castellano):

Nota: si aparece algún recuadro de pregunta o mensaje, se cambia de opción con el TABulador, y se pulsan los botones con el espacio, lo cual es fácil de hacer si se está trabajando con ADB desde un ordenador.
apt-get install dbus dbus-x11
mkdir -p /var/run/dbus
apt-get install language-pack-es
update-locale
IdiomaPredeterminado="es_ES.UTF-8"
export LANG="$IdiomaPredeterminado"
export LANGUAGE="$IdiomaPredeterminado"
echo "LANG=\"$IdiomaPredeterminado\"" >> /etc/default/locale
echo "LANGUAGE=\"$IdiomaPredeterminado\"" >> /etc/default/locale

Inicie el servicio DBus del cual dependen muchas aplicaciones (no se puede aprovechar el de Android):

DbusPid="$(dbus-daemon --system --print-pid --fork)"

Instale la parte básica de Ubuntu y aplique actualizaciones. Este proceso tarda bastante:

apt-get install ubuntu-minimal ubuntu-standard
apt-get upgrade

Instale escritorio y aplicaciones que le interese. Este proceso puede tardar MUCHO:

apt-get install sudo ubuntu-desktop libreoffice libreoffice-l10n-es language-pack-gnome-es

(si aparece un recuadro de mensaje o pregunta, se desplaza con el TABulador, y se pulsa con el espacio).

Abrir una cuenta de usuario normal

Utilizando el escritorio y aplicaciones como usuario normal (no root) mejora la seguridad y la admisión por parte de algunos elementos que lo requieren.

cp -a /etc/adduser.conf /etc/adduser.conf.bak
cat /etc/adduser.conf.bak | sed -e 's/^#EXTRA_GROUPS=/EXTRA_GROUPS=/g' > /etc/adduser.conf
NombreUsuaria=usuario
adduser --add_extra_groups --gecos "" $NombreUsuaria

Incluir la nueva cuenta ($NombreUsuaria) en el grupo común de usuarios y grupos de administración que haya:

usermod --append --groups users $NombreUsuaria
usermod --append --groups sudo $NombreUsuaria
usermod --append --groups adm $NombreUsuaria
usermod --append --groups admin $NombreUsuaria

Crear un grupo especial en donde incluir el usuario, para que pueda abrir puertos de entrada

addgroup --gid 3003 sockets
usermod --append --groups sockets $NombreUsuaria

Habilitar interfaz gráfica

Aunque ya ha aparecido alguna herramienta X-Server para utilizar aplicaciones en pantalla directamente sin control remoto, de momento exponemos el método tradicional 2011-2012 (suponiendo como ejemplo que la pantalla del aparato tiene una resolución de 1280x720):

apt-get install xvfb x11vnc xtightvncviewer
if [ "$Copyrect" = "" ] ; then CrOptions="-nowirecopyrect -noscrollcopyrect" ; else CrOptions="-ncache" ; fi
MoreOptions="-create -localhost -xrandr $CrOptions -rfbport 5900 -nopw -forever -permitfiletransfer -nevershared -scale 1/1"
echo "x11vnc $MoreOptions -env FD_GEOM=${1:-1280x720x16} -afteraccept 'x-session-manager &' -logfile '.x11vnc.log'" > /tmp/xvnc.sh
chmod a+rx /tmp/xvnc.sh
su -l $NombreUsuaria -c /tmp/xvnc.sh

Se quedará esperando conexiones (verá PORT=5900). Es necesario no cerrar este terminal mientras se quiera tener Ubuntu disponible.

Abrir el escritorio de Ubuntu desde Android

Se puede utilizar cualquier programa de control remot per VNC, que se puede encontrar fácilmente con el Gestor de paquetes F-Droid.

Se conecta a la dirección localhost y con el puerto normal 5900. Sin usuario (nickname) ni tampoco contraseña (password). Tiene un acceso suficientemente seguro porque sólo admitirá conexiones desde el mismo aparato (-localhost).

Salida

Si quiere volver a utilizar Android es suficiente con cerrar el VNC, o símplemente minimizarlo para hacer otras cosas. Si detiene el aparato con Android no pasa nada; es como si tambien detuviera el escritorio de Ubuntu como si fuera un ordenador.

Si quiere detener el sistema Ubuntu sin detener ni reiniciar Android, debe salir de la sesión por el mismo escritorio de Ubuntu, igual como si lo hiciera de un ordenador normal: con el botón gráfico de detener el ordenador, pero la opción de salir como usuario. Si ve una ventana de terminal tambien cerrándola se finaliza la sesión. Con las siguientes indicaciones hará una salida completamente limpia del contenedor.

Detener servicios: En la ventana de Terminal en donde tenía el x11vnc esperando conexiones, si este todavía espera, lo puede interrumpir con {Control} + {C}. Después el resto:

kill $DbusPid
rm -f /var/run/dbus/pid
if [ "$(mount | grep -e "/selinux")" != "" ] ; then umount /selinux ; fi
umount -a
exit

Si por ejemplo ha montado la carpeta de Android /mnt/sdcard :

umount "$PuntoRaiz/mnt/sdcard"
if [ -d /dev/cpuctl ] ; then umount "$PuntoRaiz/dev/cpuctl" ; fi
if [ -d /acct ] ; then umount "$PuntoRaiz/acct" ; fi
umount "$PuntoRaiz/sys"
umount "$PuntoRaiz/dev/pts"
umount "$PuntoRaiz/dev"
umount "$PuntoRaiz/proc"
exit
exit

Para repetir la experiencia

  • Si no ha finalizado la sesión dentro de Ubuntu, símplemente puede volver a conectar con el programa-cliente de VNC.
  • Lo mejor, está claro, es poder tener iconos directos en el escritorio de Android, tanto para montar el contenedor como para conectar con el escritorio por VNC. Este wiki agradecerá mucho las aportaciones sobre este tema.

En otros casos, como por ejemplo que haya detenido el aparato o finalizado el contenedor Ubuntu completamente, escriba estas instrucciones en una ventana de Terminal (datos del mismo ejemplo de esta página, que hay que personalizar):

su
mount -o remount,rw,dev,exec,suid,noatime /data
PuntoRaiz="/data/ubuntu"
mount -o bind "/proc" "$PuntoRaiz/proc"
mount -o bind "/dev" "$PuntoRaiz/dev"
mount -o bind "/dev/pts" "$PuntoRaiz/dev/pts"
mount -o bind "/sys" "$PuntoRaiz/sys"
if [ -d /acct ] ; then mount -o bind "/acct" "$PuntoRaiz/acct" ; fi
if [ -d /dev/cpuctl ] ; then mount -o bind "/dev/cpuctl" "$PuntoRaiz/dev/cpuctl" ; fi
mount -o bind "/mnt/sdcard" "$PuntoRaiz/mnt/sdcard"
chroot "$PuntoRaiz" /bin/su
mount -a
if [ "$(mount)" = "" ] ; then mount -o bind /selinux /selinux ; fi
DbusPid="$(dbus-daemon --system --print-pid --fork)"
NombreUsuaria=usuari
if [ "$Copyrect" = "" ] ; then CrOptions="-nowirecopyrect -noscrollcopyrect" ; else CrOptions="-ncache" ; fi
MoreOptions="-create -localhost -xrandr $CrOptions -rfbport 5900 -nopw -forever -permitfiletransfer -nevershared -scale 1/1"
echo "x11vnc $MoreOptions -env FD_GEOM=${1:-1280x720x16} -afteraccept 'x-session-manager &' -logfile '.x11vnc.log'" > /tmp/xvnc.sh
chmod a+rx /tmp/xvnc.sh
su -l $NombreUsuaria -c /tmp/xvnc.sh

Conectar con la aplicación-cliente de VNC a la dirección localhost y con el puerto normal 5900. Sin usuario ni tampoco contraseña.

Evidentemente lo mejor es tener las instrucciones en scripts (ficheros de texto ejecutables): del primer «mount» hasta el «chroot» en un script en Android (por ejemplo /system/bin/m) y el resto en un script en Ubuntu (por ejemplo /usr/local/bin/x). De esta forma, en un terminal ya sólo habría que hacer:

su
m
x

Y para hacerlo en una sola instrucción, puede cambiar la instrucción chroot "$PuntoRaiz" /bin/su por chroot "$PuntoRaiz" /bin/su -c /usr/local/bin/x , y entonces tambien un script en Android (/system/bin/u) que contenga una sola línea con su -c m . Con esto, inicia el servicio con una sola instrucción en el terminal:

u

(recuerde a dar permiso de ejecución a los scripts, por ejemplo con: chmod 755 /system/bin/u )

Lanzadores en el escritorio de Android

Con el SL4A puede preparar un programillo Bash (Shell script) que tambien se puede ejecutar con mostrar la ventana de terminal (background). Con esto puede sustituir «u» que hemos puesto de ejemplo, creando un script llamado por ejemplo Ubuntu.sh y con contenido su -c m

Para crear un icono en el escritorio (Home) que lance la Ubuntu de fondo, oprima el fondo del escritorio durante un rato hasta que abra un menú de opciones, y elija crear un acceso/lanzador personalizado (Custom shortcut). Seleccione la actividad "Scripts" que lleva el icono de los ojos iluminados (SL4A), seleccione su programillo "Ubuntu.sh" y elija que se inicie de fondo/background (botón con engranaje). Le puede acabar personalizando el título como «Ubuntu 0» y acepta.

La misma técnica puede utilizar para crear un lanzador que conecte directamente por VNC: pulsando largamente en el fondo del escritorio, Lanzador personalizado (Custom shortcut), elegir actividad (Pick your activity), Conexión VNC, elegir la de «localhost:5900», póngale un título como «Ubuntu 1» y acepte.

Con estos dos lanzadores, ya tiene la Ubuntu en 2 pulsaciones: primero al icono SL4A que trabaja de fondo, y después al icono de VNC que le conecta. No lance nuévamente el icono de SL4A si no se ha asegurado de que está detenido. Puede conectar y desconectar tantas veces como quiera mientras la Ubuntu esté arrancada de fondo con SL4A.

Un problema detectado: Si se le abre el menú pero no le aparece la opción de crear lanzador/acceso/shortcut en el escritorio (sólo ofrece cambiar el fondo), seguramente está utilizando el escritorio «Trebuchet» que tiene alguna carencia. Puede instalar el gestor de escritorio AnDerWeb para arreglarlo, pero no aprovecha los iconos que tuviera colocados con el anterior.

Como ver las cosas más grandes

Hay aparatos de bolsillo que tienen una gran densidad de puntos en una pantalla táctil, es decir, mucha resolución en una pantalla tan pequeña. Aprovechar toda la resolución en estas situaciones hace difícil acertar los elementos del escritorio con el dedo.

Si en el ejemplo de esta guía queremos ver las cosas el doble de grandes, cambiamos la resolución de 1280x720 por 640x360, y la escala de 1/1 por 2/1. Esto significa dividir por 2 la resolución y aumentar la pequeña imagen al soble para que igualmente llene la pantalla. La operación se puede hacer en cualquier proporción; aquí un ejemplo para hacerlo a dos tercios (que implica un 50% de aumento):

MoreOptions="-create -localhost -xrandr $CrOptions -rfbport 5900 -nopw -forever -permitfiletransfer -nevershared -scale 3/2"
echo "x11vnc $MoreOptions -env FD_GEOM=${1:-853x480x16} -afteraccept 'x-session-manager &' -logfile '.x11vnc.log'" > /tmp/xvnc.sh

1280/3x2 = 853 ; 720/3x2 = 480 ; escala 3/2