this is a slightly more detailed/complete and a terse version of the following blog post that was forwarded to the android-builders mailing list.

http://blog.decat.org/aosp-step-by-step-instructions-for-setting-up-a-chrooted-ubuntu-10-04-64bit-build-environment-on-ubuntu-11-10-and-12-04-hosts

Starting from the 12.04 command line do the following things (mostly in order)

• sudo apt-get update
• sudo apt-get upgrade
• sudo apt-get install dchroot debootstrap

sudo tee -a /etc/schroot/schroot.conf <<EOF
 [lucid]
 description=Ubuntu 10.04 LTS (Lucid Lynx)
 location=/var/chroot/lucid
 priority=3
 users=<<your user name here>>
 groups=<<your user name here>>
 root-groups=root
 EOF

sudo debootstrap --variant=buildd --arch amd64 lucid /var/chroot/lucid http://archive.ubuntu.com/ubuntu/

sudo tee -a /var/chroot/lucid/etc/debian_chroot <<EOF
 $HOSTNAME-chroot-lucid)
EOF

• sudo cp /etc/resolv.conf /var/chroot/lucid/etc/
• sudo cp /etc/passwd /var/chroot/lucid/etc/
• sudo cp /etc/group /var/chroot/lucid/etc/
• FSTAB changes: (to host 12.04 /etc/fstab)

#bind mount for lucid
/proc /var/chroot/lucid/proc bind defaults,bind 0 0
/home /var/chroot/lucid/home bind defaults,bind 0 0

• sudo chroot /var/chroot/lucid/
• sources.list changes:  (the chroot /etc/apt/sources.list)

 #make sure the following 2 lines are in the sources.list
 deb http://archive.ubuntu.com/ubuntu lucid main
 deb http://archive.ubuntu.com/ubuntu lucid universe

• now install the android build dependencies;
• apt-get update

  sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl \
               zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev \
               ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \
               tofrodos gawk mkisofs

Feel free to add whatever else you may need (vim, ctags, cscope ccache, etc...)

• Now you may want to have a script “lucid.sh” to log in into the chroot and as the correct user:
• note: if you installed Java the way you are *supposed to* in $HOME/bin/ and set up the paths in your .profile then the java support “just works” otherwise you deserve what you get.

#!/bin/sh
sudo chroot /var/chroot/lucid/ su - `whoami`

Seems to work.

8 or 9 months ago I did some playing with the IOIO using an older version of Ubuntu.  I’ve gotten some time to catch up on my hobbies and picked up the IOIO again.  (thinking of making a ultrasonic collision warning system for my bike by hooking up some range finders to the IOIO and having it talk to my phone to warn of collision.) I had forgotten most of what I managed to get working in the past and I’m back to hopefully capture more of the details that tripped me up this time.

First installing the MPLAB-X no longer has problems with 64 bit ubuntu.

Product Version: MPLAB X IDE v1.10
Java: 1.6.0_24; OpenJDK 64-Bit Server VM 20.0-b12
System: Linux version 3.2.0-23-generic running on amd64; UTF-8; en_US (mplab)
Userdir: /home/mgross/.mplab_ide/dev/v1.10

Had a few gotchas with the C30 compiler for the pic24.  (hmm I see its not using my official JDK for oracle I thought I had my path’s set up correctly…)  See previous blog post for the work around on the C30 compiler.

Next building the FW for the IOIO is a bit confusing as there are 3 flavors of IOIO “historically”  I think only one flavor can be purchased today so I don’t know the value of having the older versions tagging along in the config files.  Further there are 3 different names for the HW I’m using where each one needs to be used while building each of the firmware projects.  Anyway, I am using the SparkFun IOIO build SPRK0016 (there are 5 of these it seems).  I think this refers to the version of the layout (in eagle).  Then there are 3 different IOIO00** targets.  (I use IOIO0023).  Then there are a number of different PIC variants  (I use PIC24FJ256DA206) .. mostly.  Unless you are building one of the projects that include _adb as a variant to the PIC24FJ256DA206.

A number of the projects are libraries and a few are test code and then there is the bootloader and AppLayerV1.  (which are the main ones to build)  The thing to remember is to build the lib’s first.  The following is a list of the projects and build targets I used:

• AppLayerV1 (IOIO0023)
• Blink (IOIO0023)  <– demo FW you don’t use.
• Bootloader (SPRK0016)
• LatencyTester (IOIO0023) <– demo FW you don’t use
• libadb (PIC24FJ256DA206)
• libbtstack (PIC24FJ256DA206)
• libconn (PIC24FJ256DA206)
• libusb (PIC24FJ256DA206 and PIC24FJ256DA206_ADB)  If you are using BT to talk to the IOIO use PIC24FJ256DA206.  The adb version is needed for to build the bootloader, and the non-adb flavor is needed for the AppLayerV2… You should build both.

Next you can spend time to figure out the zip file packaging of the *.ioio files the boot loader uses or you can use you Picket3 and just blast the FW.  I have a Pickit 3 and I’m not too patient so I use it for starters.  Later I’ll start using the boot loader to program new FW which is a cool thing.

what you need to do is find the *.hex files for the AppLayerV1 and the Bootloader and concatenate them into one fw.hex file.  Next you need to find the lines in the file with the following in them:

“:00000001FF”

there will be 2 of them.  Keep the last one (at the end of the file) and delete the other line.

• or you can use the script already in the repo: “tools/merge-hex“

Now you can make a fw project in MPLAB-X out of an existing hex file and use mplab-x to program the target.  (It works for me)

Setting up and Building the different APK’s:

This was very hard for me as I’m not a Java / Eclipse guy and nothing seemed to work right the first time.

Note: you need to set compiler compatibility to 1.6 under the java options dialog.

As I’m building on a new box with Ubuntu 12.04beta I had to reinstall all new “everytings”:

• Android SDK [[http://developer.android.com/sdk/index.html]]
• eclipse [[http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/indigo/SR2/eclipse-jee-indigo-SR2-linux-gtk-x86_64.tar.gz&url=http://mirror.cc.vt.edu/pub/eclipse/technology/epp/downloads/release/indigo/SR2/eclipse-jee-indigo-SR2-linux-gtk-x86_64.tar.gz&mirror_id=504]]
• ADT pluggin [[http://developer.android.com/sdk/eclipse-adt.html]]
• ant  (apt-get ant ?  I think I used synaptic to install ant)

Next you need to run “android” from the sdk and down load all the support bits for the following android versions:

• android-3 (cupcake or donut)
• android-7 (froyo)
• android-10 (gingerbread) Note: you want API-10 and higher if you want to use open-accessory.

Next you can use ant to build from each application under the software IOIO directory:

• android update project -p . -t android-10
• ant release (or ant debug)
• when you are done the APK will be in ./bin/.

Or you can build the APK’s using eclipse and pull you hair out trying to understand why nothing works:

• first after following the directions on [[http://developer.android.com/sdk/eclipse-adt.html]] which are *very* important.   You need to open up some projects.  First do the core libraries:
• ioio_lib
• right click select properties and look at the Android properties.  Set build target to Android 2.3.3 (api level 10/ android-10)
• next go to the Java Compiler and turn of Enable project specific settings and turn it off.
• ioio_lib_bluetood
• do the same things done to ioio_lib
• ioio_lib_accessory
• do the same things don to ioio_lib
• Finally add applications HelloIOIO and do the same things done to the libs.
• If you now select clean and build all everything might build.  If not select build all a second time.
• it seems the libs may not be build the first time before the app is compiled so the second “build all” works.

One last note: some of the projects don’t seem to build but most of them are.

I’m not a fan of eclipse yet.  Maybe it will grow on me as I learn more about java.  (or maybe not.)

I almost forgot, After all this I did get the HelloIOIO application to turn on and off the LED on the IOIO over Bluetooth.

I just updated my old kick a round laptop (HP-g62: i3, 8GB RAM, 500GB HD) with Ubuntu 12.04LTS beta2 and installed the packages recommended by source.android.com and yocto quick quick start and a handful of python (sci-py and friends) and some assorted things I like to have.  Then I installed MPLabX 1.10 and mplab-c30 compiler (mplabx-ide-v1.10-linux-installer.run mplabc30-v3.30c-linux-installer.run)

After this I pulled the latest IOIO code (https://github.com/ytai/ioio) and started to build the FW.

I got a few different errors trying to build that came up from the compiler.

“Could not open resource file: /opt/microchip/mplabc30/v3.30c/bin/bin/c3vicefoinfono”

“Could not open … /opt/microchip/mplabc30/v3.30c/bin/bin/../bin/c3vic.infoinfo”  and a few other complaints.

To debug this I used strace -ff -o trace followed by the command line copied from the mplabx IDE and grep for info in the trace.* files created by the strace command.

It turned out I needed to add a few symbolic links to /opt/microchip/mplabc30/v3.30c/bin/bin:

cd /opt/microchip/mplabc30/v3.30c/bin/bin

sudo ln -s ../c30_device.info

sudo ln -s ../device_files

Now things seem to compile.

I don’t know why I am seeing this issue on 12.04.  (Note: on 11.04 I have the same compiler installed and it doesn’t give me any guff)

Installing was a pain in the butt. The graphics would start flickering on modesets with the install kernel. After upgrading the kernel to 3.2.3 vanilla disabling modeset resulted in a black screen with a blinking cursor.

So, to install use the ubuntu-alt cd and do a text mode installation. (avoid the mode set epileptic fit inducing flicker.) After the install is finished within grub ad nomodeset to the kernel command line and / or remove the spash command line. Then after building 3.2.3 kenel and installing it change things by removing the nomodeset you added before and also remove the splash option. Now the system should boot ok to a usable home screen.

Also WRT graphics I have gone ahead and just blacklisted radeon as well. The radeon driver takes too long to boot and for my use I don’t really give a shit about having more graphics umph anyway.

Audio will not work (because the snd_usb_audio device confuses ALSA. Fix this by adding snd_usb_audio to the blacklist.cfg file in /etc/modeprobe.d diretory.

Now about the only thing not working is the clickpad.

hear I use may pad and work scripts.
pad:
#!/bin/sh
/usr/bin/synclient TapButton1=1 TapButton2=0 TapButton3=0 LBCornerButton=2 RBCornerButton=0 LTCornerButton=2 RTCornerButton=3 VertEdgeScroll=0 VertEdgeScroll=0 HorizEdgeScroll=0 CornerCoasting=0 VertTwoFingerScroll=1 HorizTwoFingerScroll=1 PalmDetect=0 EmulateTwoFingerMinW=100 AreaBottomEdge=3900

work:
#!/bin/sh
/usr/bin/synclient TapButton1=0 TapButton2=0 TapButton3=0 LBCornerButton=2 RBCornerButton=0 LTCornerButton=2 RTCornerButton=3 VertEdgeScroll=0 VertEdgeScroll=0 HorizEdgeScroll=0 CornerCoasting=0 VertTwoFingerScroll=1 HorizTwoFingerScroll=1 PalmDetect=1 EmulateTwoFingerMinW=100 AreaBottomEdge=3900

FWIW I have a Displayport to HDMI converter cable and it works very well for driving my external 1080p display.

The Android Open Source Project has issues with the newest GCC host compiler where the build of ICS falls over in annoying ways on the new distro.  To get around this issue I tried building my own compiler but, that was a pain in the ass with getting the multi-lib support working then in my googleing for how to do that with the old compilers I found the following blog post that is all gold to me.  Using it when building AOSP works well. 

Setup:

http://www.android-dev.ro/2011/12/13/building-android-4-0-on-ubuntu-11-10/
sudo apt-get install gcc-4.4 g++-4.4 g++-4.4-multilib gcc-4.4-multilib
sudo ln -s /usr/lib/i386-linux-gnu/libX11.so.6 /usr/lib/i386-linux-gnu/libX11.so
cd to your AOSP ics directory: make CC=gcc-4.4 CXX=g++-4.4 -j4

Shiny!

Well, maybe not 100% shiny. Building rowboat for the beagle board falls over on the kernel and the sgx build using the CC=gcc-4.4 CXX=g++-4.4 command line hack. They get confused by the CC and the CXX.  The work around I have done for this is to hack the AOSP build/core/combo/select.mk file:

diff --git a/build/core/combo/select.mk b/build/core/combo/select.mk
index 916320b..8116723 100644
--- a/build/core/combo/select.mk
+++ b/build/core/combo/select.mk
@@ -25,8 +25,8 @@ combo_os_arch := $($(combo_target)OS)-$($(combo_target)ARCH)

 # Set reasonable defaults for the various variables

-$(combo_target)CC := $(CC)
-$(combo_target)CXX := $(CXX)
+$(combo_target)CC := gcc-4.4
+$(combo_target)CXX := g++-4.4
 $(combo_target)AR := $(AR)

 $(combo_target)BINDER_MINI := 0

Now its more shiny but not perfect. I don’t need to change my command line to build on 11.10 but, I do have to remember this hack every time I set up a project.

make sure your .gitconfig has the correct user name:
i.e.:
[review "review.cyanogenmod.com"]
username = mgross

After weeks of farting around with the thing and multiple web sites for custom mods I’ve been able to build from SRC both CWM and Cyanogen mod 7 for the gTablet.  I lost a week on the assumption that the kernel was for the 1.2 version of the FW (For the default this is not the case) and hunting around for the right git tree, branch name and default config file for the kernel.

The following assumes that you have started with nvflashed gtab.nvflash.1.2.branch.20110508_with_cwm version of the system and then put CM7 on it from one of the ROM download sites.

All this BS is encapsulated in the bash script: cyanogen-build4gtablet.sh  if it works then you will have the following files:

out/target/product/smb_a1002/update-cm-7.1.0-RC1-smb_a1002-KANG-signed.zip <– the android build

out/ target/product/smb_a1002/utilities/update.zip <– recovery OS (ClockWorkMod)  (but the updater-scrip is no right.  It should use recovery.img and instead it does some other stuff attempting to update the current recovery partition when it really should just use the img file.  See http://review.cyanogenmod.com/#change,7626 to see how to fix that.)

Also if you where wondering what the mtd partition table is:

<6>[   12.356419] tegra_nand tegra_nand: tegra_nand_probe: probing (c06af4d0)
<6>[   12.364346] tegra_nand tegra_nand: tegra_nand_scan: found NAND chip (Vendor = 0xad, DevId = 0xdc)
<5>[   12.974292] 7 cmdlinepart partitions found on MTD device tegra_nand
<5>[   12.980549] Creating 7 MTD partitions on "tegra_nand":
<5>[   12.985690] 0x000000bc0000-0x000001bc0000 : "misc"
<5>[   12.991329] 0x000003cc0000-0x000004cc0000 : "recovery"
<5>[   12.997107] 0x000004d40000-0x000005d40000 : "boot"
<5>[   13.002522] 0x000005dc0000-0x000015580000 : "system"
<5>[   13.008779] 0x000015600000-0x00001ff80000 : "cache"
<5>[   13.014742] 0x000000740000-0x000000b40000 : "bootbmp"
<5>[   13.020397] 0x000001c40000-0x000003c40000 : "logodata"

This is just a bunch of notes and links gathered in the course of getting cyanogen onto a viewsonic gtablet:

First some background:

1. The gtablet is a derivative of a few reference platforms and you may see the following “code names” that imply gTablet:
• upc300 <– SKU ID ViewSonic uses
• harmony <– what NVidea calls it
• smb_a1002 <– what cyanogen mod calls it if you are building the image from scratch you’ll want to know this one.
2. there are a number of forums and sites for information on the gTablet and building an image for it.  (it confused me)
• http://viewsonic-gtablet-for-dummies.webs.com/ <– this is the best one
• http://raywaldo.com/topic/gtab-tablet-computing/
• http://www.slatedroid.com/topic/17751-recovery-12-based-recovery-options-recovery-pack-cwm-standard-recovery-g-tablet/
• http://forum.xda-developers.com/forumdisplay.php?f=841 <– anoying but has a few of useful posts like the following:
• http://forum.xda-developers.com/showthread.php?t=916198
• http://droidbasement.com/db-blog/ <– the blog of the developer of the kernel used by cyanogen
• https://github.com/pershoot/gtab-2632 <– kernel used by cyanoge lately…
• http://www.cyanogenmod.com/
• http://forum.cyanogenmod.com/forum/188-viewsonic-g-tablet/
• http://wiki.cyanogenmod.com/wiki/Viewsonic_G_Tablet:_Compile_CyanogenMod_%28Linux%29
• http://wiki.cyanogenmod.com/wiki/Viewsonic_G_Tablet:_Full_Update_Guide
3. The gTablet has spiffy FW that makes it hard to brick (but you can get damn close).  There is a boot loader that can be reflashed and then there is the android recovery image that can also be reflashed.  You want the 1.2 branch of the nvflash.
• http://viewsonic-gtablet-for-dummies.webs.com/nvflash.htm  (flashing from linux works great don’t bother with the windows flash tool)
• if building the kernel (see below) be sure the CONFIG_NEWBL is set otherwise it will hang at boot time.
• Odds are if you got a gTablet lately its got 1.2 FW.
• Older versions of the Cyanogen ROM may assume 1.1 FW and fail to boot (don’t back rev your FW to fix this! You’ll just use a newer ROM that works with 1.2 FW)
• http://viewsonic-gtablet-for-dummies.webs.com/rom.htm
• The fist thing to do when you get the gTab is to put ClockworkMod (recovery tool) on it. http://viewsonic-gtablet-for-dummies.webs.com/clockworkmod.htm I’m having good luck with cwm v3028
• At this point you can install Honycomb or your own Cyanogen builds without too much trouble.
4. Building Cyanogen for the G-Tablet (using canned kernel)
• follow the compile link above
• Gotchas:
• extract-files.sh disn’t find all the files the first time for me and I had to manually get the ones that didn’t get found.
• don’t forget to run the get-rommanager step or the build will crap out (on the rommanager APK build)
• vendor/cyanogen/get-rommanager
• DO NOT EVER RUN THE ROM-MANAGER!!!! it will fsck your tablet and put you back to nvflashing (I had to crack open my tablet to hit a hidden reset button to power cycle to get back to nvflash.  Others just let the battery drain to zero to do the same thing)
• 1.1 FW doesn’t boot with current kernel checked into the cyanogen tree.
• DSP manager crashes and hoses audio (but if you unistall it using tatainium backup audio works again)
5. Hacking the kernel for the gtablet
• First there are at least 3 different kernels and I can’t say for sure which one is good for what:
• pershoot : https://github.com/pershoot/gtab-2632 <–known to work by me and is used by cyanogen
• Clemsyn : https://github.com/search?q=clemsyn&type=Everything&repo=&langOverride=&start_value=1 but I can’t say which one to use or what branches   Note: I think one of the clemsyn kernels is used in a Honycom Rom)
• http://www.linuxboxsolution.com/ has a HC ROM port and a git tree related to it is https://github.com/linuxboxsolution/LBSGtab.git The tree isn’t too nice as its hard to see a patch set in there.  Its not much more than a tarball.
• for the pershoot kernel I’ve used both the “gingerbread” and “master” branches seem to work.
• use the “pershoot_tegra_harmony_android-newbl_defconfig” to build the kernel.
• The wifi driver “bcm4329.ko” is built as dhd.ko and you get to hand place it where it needs to go in the ROM image yourself.
• note: I’m still not 100% the dhd.ko driver I build works yet.  (maybe later today I’ll have it working?)

• CROSS=/home/mgross/work/cyanogen/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin/arm-eabi-

  PATH=/home/mgross/work/cyanogen/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin:$PATH

  export CROSS

  export PATH

  make ARCH=arm CROSS_COMPILE=$CROSS mrproper

  make ARCH=arm CROSS_COMPILE=$CROSS pershoot_tegra_harmony_android-newbl_defconfig

  time make ARCH=arm CROSS_COMPILE=$CROSS -j 4

• note: my cyanogen tree was checked into “/home/mgross/work/cyanogen” and I’m building the kernel with the same tool chain used to build the cyanogen ROM.
6. Installation hacks / gotchas
• http://review.cyanogenmod.com/#change,7464 <– is needed with the CWM v3028

mplabx beta 7.01 is not good with JDK7 (32bit) but works fine with 64 bit.

Mostly I copying http://elco.crsndoo.com/wordpress/2011/03/how-to-make-mplab-x-work-properly-on-64bit-linux/ Only the first few times I tried it I was using jdk7 which does not work.

To install mplabx on ubutnu11.04-x86_64 I did the following:

• download 32bit Linux JDK6 update 26 (jdk-6u26-linux-i586.bin) unpacked it and moved it to $HOME/bin/jdk1.6.0_26-32bit.
• next I created 2 scripts one for installing as root and one for running mplabx.
• I also modified the start up

To run MPLABX you need to set jdkhome == JAVA_HOME and PATH to point to the 32bit jdk6 first then you can run mplabx.

For installing MPLABX you need to expand $HOME such that it works properly. (you’ll need to update this script to match where you put the JDK2.6 – 32bit.)

Scripts:
To run mplabx
—-

#!/bin/sh

export JAVA_HOME=$HOME/bin/jdk1.6.0_26-32bit
export jdkhome=$JAVA_HOME
export PATH=$HOME/bin/jdk6.0_26-32bit/bin:$HOME/bin:$PATH

/usr/bin/mplab_ide

<EOF>

To install mplabx (update with your $HOME path if copying me) run this scrip as root.
—–

#!/bin/sh

JAVA_HOME=/home/mgross/bin/jdk1.6.0_26-32bit
PATH=/home/mgross/bin/jdk6.0_26-32bit/bin:$PATH

/home/mgross/Downloads/mplabx-ide-beta7.01-linux-32-bit-installer.bin
<EOF>

This is a outline on how to build the images to run the IOIO [http://codaset.com/ytai/ioio/wiki] with a nexus 1 phone.

HW:

• rooted Nexus-1 running CyanogenMod 7.1.0-RC1-N1
• PICkit3
• IOIO board  The device is a “pic24jf256DA206″ board
• 5V -12V DC PSU good to 2A output. (what I’m using is overkill 5V at 8A)

Downloads to get:

• android-sdk_r12-linux_x86.tgz
• eclipse-SDK-3.7-linux-gtk.tar.gz
• jdk-6u26-linux-i586.bin
• mplabc30-v3.30b-linux-installer.run
• mplabx-ide-beta7.01-linux-32-bit-installer.bin
• http://ww1.microchip.com/downloads/mplab/X_Beta/index.html
• IOIO code base

• git clone https://codaset.com/ytai/ioio.git

• At the time of this writing the tip was: 8f8704f updated App-IOIO0300 to get rid of excessive logging

Pin outs between PICkit3 and IOIO:
The programmer : the IOIO

pin1 : MCLR,
pin2 : 3.3
pin3 : gnd
pin4 : 36
pin5 : 35
pin6 : no-connect

Pain points:

• Android SDK installation
• Eclipse setup with ADT
• ADT / eclipse environment has gotchas WRT configuring builds and the need to clean the projects before a build will succeed.
• MPLAB-X installation (have to play games with JAVA_HOME as root)
• MPLAB-X beta 7.01 vrs jdk1.7.0 (hint you need to use jdk1.6.0_26 for now)
• PICkit3 use from MPLAB-X (wasn’t so bad after I figured it out)
• IOIO FW code structure and undocumented packaging tools for building boot FW and *.ioioapp files the ioio manager uses.
• IOIO SW code structure and undocumented set up for building up ADK builds
• IOIO git project has IDE config files in it that get changed by simply opening the projects.  (annoying but common with IDE use)
• Not knowing MPLab, PIC, or JAVA very well.

Details:

First install the JDK, eclipse and android SDK all into $HOME:

• I install the JDK into $HOME/bin and setup JAVA_HOME and PATH environment variables in my $HOME/.profile file:
• mkdir $HOME/bin
• cd $HOME/bin
• tar -xf ../Downloads/android*.tgz
• run the android-sdk-linux_x86/tools/android command and download the android SDK versions you want.  (I just go them all)
• tar -xf ../Downloads/eclips*.tar.gz
• chmod +x ../Downloads/jdk*.bin
• ../Dowloads/jdk*.bin

• Then set-up your environment variables in $HOME/.profile

JAVA_HOME=$HOME/bin/jdk1.6.0_26

PATH="$HOME/bin/eclipse:$HOME/bin/jdk1.6.0_26/bin:$HOME/bin/android-sdk-linux_x86/tools:$HOME/bin:$PATH"

• mplabx beta 7.01 doesn’t install on x86_64 versions of Ubuntu.
• I’m pretty sure there isn’t a good technical reason for this.  One can install on a 64bit Linux provided you set up the 32bit JDK and poin the JAVA_HOME to it.  Still this is a work around.
• I’m running mplabx in its own virtual-box VM of ubuntu 11.04 32bit.
• There is one link I found on the Internet calling out an mplabx install hack using JAVA_HOME and PATH names that worked for someone.  But, it didn’t work so much for me.
• The mplabx installer looks in selected paths for the JDK installation.  Set up a JAVA_HOME environment variable to point to the JDK you want to be used with the installer program.
• or use the following script run as root:

#!/bin/sh

JAVA_HOME=/home/mgross/bin/jdk1.6.0_26

PATH=/home/mgross/bin/jdk1.6.0_26/bin:$PATH

/home/mgross/Downloads/mplabx-ide-beta7.01-linux-32-bit-installer.bin

• what system global configuration does it touch after installing????  It wants me to reboot to start using it?  This scares me.

 Building the APK’s

• Install the ADT
• configure android plugin to point to sdk
• set android build output to verbose
• set general / workspace to not “Build automatically”
• use import existing project to import ioio_lib into workspace
• use android tools > fix project properties (not sure what it does)
• set project build target to Android 3.0
• disable “Enable project specific settings” (if set under properties java compiler)
• mkdir a directory “ioio/software/IOIOLib/res”
• project / clean
• build.
• import ioiomanager project
• android tools > fixproject properties
• change android build target to android 3.0

HelloIOIO

• import existing project ioio/software/applications/helloIOIO (leaving the lib and ioiomanager projects where they are in the IDE.
• select project properties and set the build target to android 3.0
• select project clean
• build project
• Run As 1 Android Application (with phone connected to development host) to load APK

Building the FW:

• use Open Project to open the IOIO/firmware/bootloader and IOIO/firmware/app_layer_v1 projects
• for the boot loader I needed to use the SPRK0016 target
• if you are going to use the IOIOmanager built above instead of the one from the app-store, then you will want to disable the security check in the bootloader FW. (using the -DBYPASS_SECURITY compiler option.)
• for the AppLayerV1 I needed the IOIO0003 target
• both build.

building *.ioioapp files and using the IOIO Manager:

• todo

Loading the FW with pickit3 through MPLabX

• locate the *.hex files:  find ioio/firmware -name *.hex
• concatenate them

•  for b in `find ioio/firmware -name *.hex`;do cat $b >>flash.hex; done

• edit flash.hex and clean out extra “:00000001FF” from middle of the file.
• create a new project in mplabx category “Microchip Embedded” and project “Prebuilt (Hex,Loadable Image) project navigate to flash.hex and select ok, select the device (from me its pic24fj256da206)
• finally select “make and program device to flash the IOIO

At this point you should be able to run the test apk on your Android phone and turn on the yellow LED.

There are a couple of painfully boring screen casts with audio that is way too quite walking through setting up a VBox guest with 11.04 and the above tools.

ioio-setup-1

ioio-setup-2