How would you use OE to build Android and what would be your goal? I have some interest, but just getting it to build and run under OE sounds like an overly simple task. I can dream up some reasons to do this and additional tasks, but I want to hear your vision.
I had to give some thought to what you were talking about before
replying, but you're very correct; its quite easy to use OE to simply
_build_ an Android image and add the TI proprietary binaries. That
would be too simple for a GSOC project.
Considering the Android build system, I honestly have very few gripes
with it. It's reasonably fast (considering the amount of code that it
compiles) and it has a high degree of consistence with a simple-to-use
Android.mk syntax and variable cleaning.
However, having 'ported' a few libraries over to the Android build
system myself, compiling / linking against bionic, I found that such
an endeavor usually requires just a few patches against the official
(external) project release, which is something that could easily be
pulled together into a git repository (on gitorious for example). A
good example of this is my psqldroid port (I haven't yet put this up
on gitorious, but you can find it on google code).
Where this gets interesting is in the repo internals. I haven't yet
gotten deeply into repo itself yet, but there is some indication that
a sort of 'overlay' concept is possible through the .repo/manifest.xml
file. For example, there is a <default> tag, which contains the
default revision and remote repository. But then it might be possible
to patch that manifest with additional <remote> tags and then specify
additional projects pulling from repositories other than the default
kernel.org (e.g. gitorious).
Leveraging OE as the patch-and-run-make system, and a sort of
directory of pre-ported libraries / patch files, this could
potentially aid the community tremendously by collecting several
options for common "external/" projects (and the patches required to
make them compile) in a single place.
So if, for example, several different platforms (not even necessarily
OMAP) want to make use of a certain library (e.g. postgresql), then
they could just specify something like
ANDROID_EXTRA="postgresql lame x264"
in the Bitbake local.conf file, and an OE module for Android could
automatically apply the required manfest.xml entries, apply any
necessary patches, and then build the Android image automatically
(alongside the Angstrom image). This would be quite useful for
community projects that use the same SoC - e.g. BeagleBoard, AI TB,
OpenPandora (... an Android gaming system?!).
Having the Android build system contained within OE would allow
maximum re-use of components without needing to 'shop around'.
Everything would be right there at the developer's fingertips in the
OE build system.
So implementing something like that would require a fair amount of
work in OE itself, possibly some in the repo source code, and then
getting 1 or 2 proof-of-concept builds working would be the final
That's just an example of the potential I see ... did you have
something else in mind?