Fix for ART-runtime in CM-11

Since two days the ART-runtime is broken on CM-11 (do not mix up with my A.R.T. - tool ;-). You will get an bootloop when you are running on ART and update to one of the latest nightlies.
For those who are building CM-11 from the sources, you can fix the bug by applying the following patch to the ART-runtime project:

diff --git a/runtime/native/dalvik_system_Zygote.cc b/runtime/native/dalvik_system_Zygote.cc
index d6cc249..4b24192 100644
--- a/runtime/native/dalvik_system_Zygote.cc
+++ b/runtime/native/dalvik_system_Zygote.cc
@@ -552,7 +552,7 @@ static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArra
   return pid;
 }
 
-static jint Zygote_nativeForkAndSpecialize_new(JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
+static jint Zygote_nativeForkAndSpecialize(JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
                                            jint debug_flags, jobjectArray rlimits,
                                            jint mount_external, jstring se_info, jstring se_name,
                                            jintArray fdsToClose) {
@@ -560,13 +560,6 @@ static jint Zygote_nativeForkAndSpecialize_new(JNIEnv* env, jclass, jint uid, ji
                                  se_info, se_name, false, fdsToClose);
 }
 
-static jint Zygote_nativeForkAndSpecialize(JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
-                                           jint debug_flags, jobjectArray rlimits,
-                                           jint mount_external, jstring se_info, jstring se_name) {
-  return ForkAndSpecializeCommon(env, uid, gid, gids, debug_flags, rlimits, 0, 0, mount_external,
-                                 se_info, se_name, false, NULL);
-}
-
 static jint Zygote_nativeForkSystemServer(JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
                                           jint debug_flags, jobjectArray rlimits,
                                           jlong permittedCapabilities, jlong effectiveCapabilities) {
@@ -590,8 +583,7 @@ static jint Zygote_nativeForkSystemServer(JNIEnv* env, jclass, uid_t uid, gid_t
 }
 
 static JNINativeMethod gMethods[] = {
-  NATIVE_METHOD(Zygote, nativeForkAndSpecialize_new, "(II[II[[IILjava/lang/String;Ljava/lang/String;[I)I"),
-  NATIVE_METHOD(Zygote, nativeForkAndSpecialize, "(II[II[[IILjava/lang/String;Ljava/lang/String;)I"),
+  NATIVE_METHOD(Zygote, nativeForkAndSpecialize, "(II[II[[IILjava/lang/String;Ljava/lang/String;[I)I"),
   NATIVE_METHOD(Zygote, nativeForkSystemServer, "(II[II[[IJJ)I"),
 };

Update Nexus 7 to Android 4.3 manually without loosing data

Sometimes one has modified some system files and OTA is failing due to those modifications. The easiest way in that case would be to do the update manually by using the factory image. Unfortunately applying the factory image directly does a factory reset, so all data will be lost, but knowing the principles behind, you can go to the lastest Androis version without loosing your data.

Get the factory image from Google and extract the following files from it:

• bootloader-grouper-4.23.img
• boot.img
• system.img

If you have root and want to keep it, get
- UPDATE-SuperSU-v1.51.zip
and copy it to /sdcard and be sure, that you have a custom recovery installed on your device.

Then do a nandroid backup before starting (it's always better to have it) and then do a

fastboot flash bootloader bootloader-grouper-4.23.img
fastboot reboot-bootloader
fastboot flash boot boot.img
fastboot flash system system.img

reboot into recovery and flash UPDATE-SuperSU-v1.51.zip

Do a reboot system and, congrats, you should be on Android 4.3 without loosing any data.

Enable usbnet on ADS_Magpie / ezGingerbread

Currently I am playing around with my old G1 to set up a communication channel to a different android / Linux device. WiFi / Bluetooth is no problem at all, but I wanted to use a direct USB connection.
Having an USB Host mode available I was wondering how easy / complicate it would be to set up usbnet on the G1. As it turned out, it was surprisingly easy, because everything is already prepared within the kernel (which is available from Github):

echo 1 > /sys/devices/virtual/usb_composite/rndis

Afterwards one can configure an IP address and set the link up:

ip addr add dev usb0 10.0.0.2/24
ip link set usb0 up

There is only one thing to be regarded: after enabling usbnet, adb over usb will no longer work, so it's better to switch to WiFi before.

Android Remote Toolkit

Some weeks ago, shortly after I bought my Nexus 7, I started on a new project, called Android Remote Toolkit (ART). The reason for this was very simple: I didn't find a suitable backup solution for my tablet.

• CWM with nandroid is working, but stores the backup on the device itself. What's worth a backup on a device if it's later no longer accessible :(
• TWRP offered the possibility to store the nandroid files to OTG, which is much better, but still uncomfortable.

I was looking for a solution where I could save the device backups directly to my PC or NAS. I looked around, but I didn't find any toolkit which was providing this functionality, to I started to write it by myself.

Looking around a bit, I found the Googles Tradefederation Project which provides many functions related to ADB and fastboot. I had a deeper look into it and decided to write a toolkit based on this lib. Today I finished what I would call Release 0.1 alpha, a set of useful functions which are working quite well, even if providing only a command line interface.
I will improve the toolkit step by step within the following weeks. Some ideas I have in mind are:

• restore backup either using fastboot or using adb
• create flashable zip from backup
• provide a gui
• integrate drivers (like +Adam Outler's +CASUAL)

ART is written in Java, so principally it's running on Linux / iOS and Windows.The sources can be found on Github/AndDiSa/ART. Binaries are nor available yet, but I will provide a first release soon.

Print current branch of each project

When you are working on/with Android AOSP you are working with many projects and repositories having all their different bases and probably also different branches or tags.If you are doing your changes, generally you create a new branch, do your modifications, commit your changes, probably revert or switch to a different branch,execute the repo sync command and so on.
For me it happens often, that I do not exactly know, which project is currently checked out on which branch. If you are working on one single project, it's not a big problem. You execute

git branch

in the current working directory and you will get the info immediately. Working and switching between several projects, it's a pain to do it in that way. For that situation I wrote a small script which is doing that for all my projects:

while read line; do (cd $line; echo $line "`git branch`";) done <.repo/project.list

Creating a small shell script with the content shown above I can execute that script from the base directory of my projects and I am getting a full overview of the current status.

Native OTG USB disk support for Nexus 7 (WiFi) with Android 4.2.2

On XDA developers there was a discussion on native OTG USB stick support for the Nexus 7 and somebody provided also a patch which should enable this feature. Unfortunately he mixed up several things and the patch was not working. He was quite on a good way, but he missed some things, so I decided to dig around a bit to see how OTG-USB can be supported.

Since Android 4.2 the situation has become worse because of permissions and security changes and multi user support. The patch I am discribing here is not multi user compatible, i.e. all user will see all files on the external disk. So be warned if you want to use this feature.

First I want to describe a bit the modifications which need to be done to enable native OTG USB

1. platform.xml is to be modified in such a way, that media_rw is allowed to access the external storage
   <permission name="android.permission.WRITE_EXTERNAL_STORAGE" >
      <group gid="sdcard_rw" />
      <group gid="media_rw" />
   </permission>
   
2. vold.fstab is to be modified in such a way, that the usb is mounted automatically when the stick is plugged in
   # Mounts the first usable partition of the specified device
   dev_mount usbdisk /mnt/otg-usb auto /devices/platform/tegra-ehci.0
   
3. init.grouper.rc is to be modified that on startup the mount directory is created
   on init
   ...
      mkdir /mnt/otg-usb 0777 sdcard_rw sdcard_rw
   
4. storage_list.xml in framework-res.apk is to be modified that the external storage is added
   <!-- external USB OTG storage -->
   <storage android:mountPoint="/mnt/otg-usb"
      android:storageDescription="@string/storage_usb"
      android:primary="false"
      android:removable="true" />
   

As you can see on the different files to be modified, several components of the Android system are involved, i.e.

• prepare a new ramdisk.img
• prepare a new framework-res.apk
• patch the platform.xml

I prepared an update.zip which applies the required modifications. The update.zip contains:

• a new boot.img including my kernel (based on android-tegra3-grouper-3.1-jb-mr1.1, but I've added DM9601 and KSM support) and a ramdisk.img with the required modifications for the otg-usb support.
• a patched framework-res.apk
• a modified platform.xml

This update is compatible only with stock Android 4.2.2 (JDQ39) and it will break future OTA updates!
If you want to apply this patch, so be sure you know what you are doing and do it on your own risk. I am not responsible for any bricks, data loss, etc.
Please note: I've tested this only on the Nexus 7 (WiFi) and I am not sure, whether it will work on the GSM-version, too, even if I believe it should work, it's disabled in the updater script at the moment.

Another thing to note: Currently only vFAT partitions are recognized. NTFS principially is supported, but vold is not handling NTFS correctly and displays an empty filesystem / a partition to be formatted.

Update 21.02.2013: I've added a pached vold to the new otg-usb-enable-20130221.zip. Now it's possible to mount also NTFS filesystems, but read only at the moment.

Using an Davicom 9601 based USB-Ethernet-Adapter with the Nexus 7

Some weeks ago I bought an USB ethernet adapter on Amazon. Unfortunately that adapter is not working with the Nexus 7, because the chipset is not supported by the kernel out of the box.
I found out, that the USB-Adapter (JP1082) is based on the Davicom 9601 chipset, which principally is supported by the linux kernel, so I decided to build a kernel which is supporting that adapter.

I did a git clone of the nexus 7 kernel sources from https://android.googlesource.com/kernel/tegra and a checkout of the latest kernel branch

git checkout android-tegra3-grouper-3.1-jb-mr1.1

after running

make ARCH=arm tegra3_android_defconfig

to create the default nexus kernel configuration the Davicom adapter needs to be added to the configuration by opening .config and changing the line

# CONFIG_USB_NET_DM9601 is not set

to

CONFIG_USB_NET_DM9601=y

Now the kernel is ready to be built:

make ARCH=arm zImage

after a successfull compilation the kernel can be booted by

fastboot boot arch/arm/boot/zImage

After booting the device and connecting the USB-ethernet adapter to the OTG-cable, you need to open a terminal window and call

/system/bin/dhcpcd eth0

to configure the ethernet link. That's all!

anacron simulation on a Synology NAS

This is a post not directly related to Android, but to my NAS where I am storing all my personal files. I bought the Synology DS212+ some month ago and I am very happy with it. Having two 2TB hard disks build in, another external harddisk is connected via USB 3.0 for backup resons. This Harddisk I am switching on and off manually from time to time and when it is switched on, a cron job should back up all the files of the DS using rsnapshot to my backup disk.

On a first glance this should not be such a big problem, but digging into it there are some problems to be solved:

1. starting the backup once via cron, the external harddisk might be switched off and no backup will be done :(
2. starting the backup regularly via cron might lead to multiple backups for a single day :(

Unfortunately Synology is not providing anacron which provides the possibility to specify such "run once a period" tasks. I digged a bit around, but I couldn't find a simple suitable solution for my needs, so I wrote a small shell script which does the trick:

#!/bin/ash
#
# shell script to run a job once a period
# it takes three parameters:
# - name of the runfile
# - period definition ("1 day", "2 days", ..., "1 week", "2 weeks", ... "1 month", etc.)
# - program to be executed (i.e. backup-program / script)
#
#
# some helper functions
#

date2stamp () {
    date --utc --date "$1" +%s
}

stamp2date (){
    date --utc --date "1970-01-01 $1 sec" "+%Y-%m-%d %T"
}

dateDiff (){
    case $1 in
        -s)   sec=1;      shift;;
        -m)   sec=60;     shift;;
        -h)   sec=3600;   shift;;
        -d)   sec=86400;  shift;;
        *)    sec=86400;;
    esac
    dte1=$(date2stamp $1)
    dte2=$(date2stamp $2)
    diffSec=$((dte2-dte1))
    echo $((diffSec/sec))
}
###########################################################
#
#main program
###########################################################
EXECUTE="0"
RUNFILE=/var/run/$1
LOCKFILE=/var/run/"$1".lock
if [ -f $LOCKFILE ]
then
        echo "other process running -> exiting" >> /var/log/runOnce.log
        exit 2
fi  
touch $LOCKFILE
#      
# check whether runfile exists
#      
NOW=`date -d 'now' --iso-8601`
if [ -f $RUNFILE ]
then
        NEXTRUN=`cat $RUNFILE`
        # check wether next run date is in the past
        if [ `dateDiff -d "$NEXTRUN" "$NOW"` -ge 0 ]
        then
                EXECUTE="1"
        fi
else
        # did not run yet -> run forced
        EXECUTE="1"
        NEXTRUN=`date -d 'now' --iso-8601`
fi

if [ "$EXECUTE" == "1" ]
then    
        # execute (i.e. backup)
        $3
        STATUS_CODE=$?
        if [ $STATUS_CODE -eq 0 ]
        then
                # set next execution date
                while [ `dateDiff -d "$NEXTRUN" "$NOW"` -ge 0 ]
                do
                        # add period
                        NEXTRUN=`date -d "$NEXTRUN + $2" --iso-8601`
                done
                # set next execution date
                echo $NEXTRUN > $RUNFILE
        fi      
fi      
rm $LOCKFILE
exit 0

This script in combination with some entries in my crontab did the trick. ;)

0 18-23 * * * root /root/runOnce.sh backupDaily "1 day" /root/runDailyBackup.sh
20 18-23 * * * root /root/runOnce.sh backupWeekly "1 week" /root/runWeeklyBackup.sh
40 18-23 * * * root /root/runOnce.sh backupMonthly "1 month" /root/runMonthlyBackup.sh

G1 celebrates it's 4th birthday

Today four years ago the first G1s were put to the market. Ok, my G1 is no longer in it's first configuration (Android 1.5 Cupcake) because I've upgraded to ADS_Magpie (Gingerbread 2.3.7), but I am still using and loving it ... ;-) More on the G1's history you can read on: T-Mobile G1 Celebrates Its 4th Birthday (That’s 80 In Smartphone Years)

Nexus 7 MTP automount on OpenSuse 11.4

Unfortunately Android 4.x devices cannot be mounted as a VFAT device any longer. While with 4.0 only the PTP mode is supported (which can be used to transfer photos only), on 4.1 you can switch between PTP mode and MTP mode in the settings.

While Windows has an acceptable MTP support, on Linux systems MTP is not supported out of the box, even worse if you want to automount your android device when connecting it. Looking around, I found Han-Wen Nienhuys go-mtpfs project on Github.

install mtpfs support

go-mtpfs is based on libmtp. For OpenSuse 11.4 you need to download the latest rpm from pbone.net and to install it on your system

After that, you can either checkout the go-mtpfs project from github and compile it by yourself or, probably more easy, download the binary from here.

You can install the binaries in every place you like, but it should be either on your path configuration or you need to define the full path to the binary when using it.

configure automount

Automount on current Linux systems is initiated by the udev system. In /etc/udev/rules.d/ you will find a set of rules which define what should happen when a new device is added, removed, ...

Create or modify a new ruleset, i.e./etc/udev/rules.d/50-android.rules. Here we need to add the following rules regarding the Nexus 7 device:

# Google Nexus 7 16 Gb Bootloader & recovery mode
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e40", MODE="0666" # Bootloader
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="d001", MODE="0666" # Recovery

# Google Nexus 7 16 Gb PTP mode (camera)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e43", MODE="0666" # PTP media
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e44", MODE="0666" # PTP media with USB debug on

# Google Nexus 7 16 Gb MTP mode (multimedia device)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e41", MODE="0666" # MTP media
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e42", MODE="0666" # MTP media with USB debug on

# Google Nexus 7 MTP mode : automatic mount when plugged
ENV{ID_MODEL}=="Nexus", ENV{ID_MODEL_ID}=="4e41", ACTION=="add", RUN+="/usr/bin/sudo -u /go-mtpfs /media/nexus7"
ENV{ID_MODEL}=="Nexus", ENV{ID_MODEL_ID}=="4e42", ACTION=="add", RUN+="/usr/bin/sudo -u /go-mtpfs /media/nexus7"

# Google Nexus 7 MTP mode : automatic unmount when unplugged
ENV{ID_MODEL}=="Nexus", ENV{ID_MODEL_ID}=="4e41", ACTION=="remove", RUN+="/usr/bin/fusermount -u /media/nexus7"
ENV{ID_MODEL}=="Nexus", ENV{ID_MODEL_ID}=="4e42", ACTION=="remove", RUN+="/usr/bin/fusermount -u /media/nexus7"

Be sure, that the mount point /media/nexus7 exists and is accessable for your user.

After sudo /etc/init.d/boot.udev restart your Nexus 7 device should be mounted automatically to /media/nexus7 when plugged to your PC.

If you want to mount other devices, you only need to add the corresponding rules, i.e. you need to know the corresponding idVendor/idProduct values. Those you can figure out using the dmesg command after the device is plugged.

compile android 4.x on a 32-bit environment

Compiling Android from the sources should be the basis for your own modifications / improvements the the Android system. Unfortunately Google removed 32-bit support with Gingerbread (Android 2.3), but nevertheless with some minor modifications to the build scripts it was still possible to build on 32-bit Linux systems. When I got my Nexus 7, I intended to compile the Jelly Bean sources, but unfortunately I still have a 32-bit OpenSuse Linux machine and compilation failed. I dearched the web, but the only answers I could get were: "you need a 64-bit environment", "yopu need to buy a new machine", ... I was very disappointed, but then I found Yath's project on Github. Following his instructions compiling Jelly Bean on a 32-bit Linux machine is still possible and I can wait soem additional months to buy a new machine ... ;-)

Nexus 7 partition sizes (16Gb model)

Partition Name	Partition Description	by_name	Size in Blocks	Size in MB
mmcblk0p1	recovery	SOS	12288	12
mmcblk0p2	boot	LNX	8192	8
mmcblk0p3	system	APP	665600	650
mmcblk0p4	cache	CAC	453632	443
mmcblk0p5	misc	MSC	512	0.5
mmcblk0p6	staging	USP	10240	10
mmcblk0p7	provisioned	PER	5120	5
mmcblk0p8	unknown	MDA	512	0.5
mmcblk0p9	userdata	UDA	14103552	13773
mmcblk0boot0			2048	2
mmcblk0boot1			2048	2

remote debugging over TCP/IP

You can debug your applications on your Android device not only over USB, but also over a TCP/IP (LAN / WLAN) connection. To enable tcp debugging you have to enter the following commands on your device:

setprop service.adb.tcp.port 5555
stop adbd
start adbd

To start debugging enter on your PC:

adb tcpip
adb connect <ip of device>
...

now you can debug as you are used to debugging over USB.

To disable debugging you have to enter the following commands on your device:

setprop service.adb.tcp.port -1
stop adbd
start adbd

More info can be found on Android Debug Bridge