Ubuntu on Android

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.

Prepare the space

To allow working of the links and device accesses is needed that the new container resides in a properly partition for GNU/Linux, such as Ext3 or Ext4. With the mount command you can see the format of each volume, and with the following syntax it's seen very clear:

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

And it can be filtered to see only what is interesting for us:

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'

Once seen the compatible paths, you must value the free space available with this command:

df

If in the free space there isn't mention of the measurement unity (100K, 100M, 100G), this means that it's expressed in K (KiB). Care that the path /cache works as an "internal trash" and its content can be deleted automatically.

You need at least 100MiB for an elemental installation (only core), or near 250MiB for a debootstrap, but can be reached a use of 2 or 3GiB if you install all the big desktop applications of common use, and apart counting some working space. Also installations "for all the pockets" can be done.

For the rest of the guide we will suppose that you choosed the partition /data , and then you put the new operating system in /data/ubuntu . Then you must enable permissions for writing, executing, devices and superuser in the partition, and create the subdirectory:

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

Get an operating system base

This is the way to build from another computer (supposing the armhf architecture) in an Ext2/Ext3 partition:

sudo debootstrap --verbose --arch=armhf --foreign precise precise-armhf

• To trainsport the directory tree from a device to another, must be copied qith superuser permissions, to not loose the files and directories attributes. To open in this way a folder explorer with Ubuntu, you can execute (Alt+F2) "gksudo nautilus".

But here we also propose the way to do it completely from the Android device: downloading a prepared base (from official website) with only one of the following commands, depending on version and variant you need (more versions are published in cdimage.ubuntu.com):

wget http://cdimage.ubuntu.com/ubuntu-core/releases/precise/release/ubuntu-core-12.04.2-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

Note: The "preinstalled" ones have all the software for a typical installation, but also elements that bust be cleaned to boot the container.

With the file downloaded, it's the turn of unpack it:

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

Adjust the base

Correct come links in the base's directory, to adequate them to the situation:

chmod 755 "$RootPoint"
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 "$RootPoint"

Clean directories that sometimes have content for a native installation:

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

Mount Android resources

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

If you want to make Android's folders available, you must check which partitions are mounted. It can be done with a simple mount or with this command that simplifies information:

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'

If, for example, you want to mount /mnt/sdcard , do the following:

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

Enter to the new system and set the basic services

Since the implementation of the services starting system Upstart the Chroot containers don't start the services as a normal installation, and it must be done manually.

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

Sure that appears something mounted, to don't fail some utilities:

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

Complete the debootstrap if it's the case, in the same architecture:

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

Patch to avoid Upstart services startup error:

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

Configure the network:

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

Check if there are repositories set:

cat /etc/apt/sources.list

If there wasn't anything, or the "universe" are disabled with #, write them with the following commands (example for Ubuntu 12.04, called "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

Install services and tools to avoid bad messages (the packages -es are for castillian language):

Note: if appears some asking or message square, the option is changed with the TABulator key, and buttons are pressed with spacebar, thing to be easier if you are working with ADB from a computer.

apt-get install dbus dbus-x11
mkdir -p /var/run/dbus
apt-get install language-pack-es
update-locale
DefaultLanguage="es_ES.UTF-8"
export LANG="$DefaultLanguage"
export LANGUAGE="$DefaultLanguage"
echo "LANG=\"$DefaultLanguage\"" >> /etc/default/locale
echo "LANGUAGE=\"$DefaultLanguage\"" >> /etc/default/locale

Start DBus service that has a lot of applications depending on (cannot benefit with Android's one):

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

Install the basic part of Ubuntu and apply updates. This process takes time:

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

Install desktop and applications you are interested in. This process can take MUCH TIME:

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

(if appears some asking or message square, the option is changed with the TABulator key, and buttons are pressed with spacebar).

Open a normal user account

Using the desktop and applications as normal user (not root) improves the security and the admission by some elements that requires it.

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
UserName=user
adduser --add_extra_groups --gecos "" $UserName

Include the new account ($UserName) in the common user group and administration groups there is:

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

Create an special group where to include the user, to be able to open input ports

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

Enable graphical interface

Although it appeared some X-Server tool to use applications directly in the screen without remote control, for the moment we expose the traditional method 2011-2012 (supposing in the example the device screen has a resolution of 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

It will be waiting for connections (you will see PORT=5900). It's necessary to not close this terminal while you want to have Ubuntu available.

Open Ubuntu desktop from Android

Any remote control program for VNC can be used, that can be found easily with the F-Droid package manager.

Connect to the address localhost and with the normal port 5900. Without user (nickname) nor password. You have an enough secure access because it only will allow connections from the same device (-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