This section describes tests of the type-based Felix on Android, which were created as semestral work for the KIV/OPSWI subject.

These main topics are described:

running Felix on Android from device shell
- preparing OSGi bundles for Android
embedding Felix into Android application
modifications of JaCC and OBCC projects to make them runnable on Android
tools for performance tests on Android
results of the tests

Development tools

Installation

Install Android SDK: http://developer.android.com/sdk/installing.html
Install Eclipse with ADT plugin: http://developer.android.com/sdk/eclipse-adt.html#installing
Install Eclipse with MAT plugin: http://www.eclipse.org/mat/downloads.php

Usage of the development tools – quick guide

Run eclipse with ADT
Click on Android SDK icon
- Here you can create and start emulators
Change perspective to DDMS. You have these views here:
- LogCat console – shows standard output and other debug outputs
- File Explorer – for browsing, uploading and downloading files on the device
- Device – you can select a device and view running processes
Open /platform-tools directory
- You have the most important Android development tools here: dx, adb, aapt
Open /tools directory
- You have other useful tools here: hprof-conv, traceview

Running type-based Felix on Android

Running Felix from device shell

To all jar files, include it´s dalvik equivalent
- create dalvik equivalent from a jar file:
```
dx --dex --output=classes.dex JAR_file.jar
```
- include dalvik equivalent into the jar file:
```
aapt add JAR_file.jar classes.dex
```

Run emulator and push all felix files into it :

adb push JAR_file.jar path_emulator/JAR_file.jar

Start emulator shell:
```
adb shell
```

Run Felix with command:

/system/bin/dalvikvm -Xbootclasspath:/system/framework/core.jar -classpath bin/felix.jar org.apache.felix.main.Main

Complete description is available at: http://felix.apache.org/site/apache-felix-framework-and-google-android.html

Embedding type based Felix into Android application

Checkout JaCC, OBCC, and felix-resolver-integration projects
Modify bundle-loader project :
Remove all code which is using javax.xml.stream package, because this package is not present on Android.
[Fixed in revision 794]
Modify bundle-parser project :
Catch an exception thrown by line 25:
```
ClassReader cr = new ClassReader(currentClass);
```
It’s probably caused by a bug in linux or VFS library.
Modify javatypes-cmp project: replace java.lang.String.isEmpty() method with Equals method in cz.zcu.kiv.jacc.compare.javatypes.impl.result.ResultImpl class.
[Fixed in revision 617]
Run maven install on these projects in this order:
- JaCC and OBCC reactor poms, felix-framework-3.0.9
- bundle-loader, bundle-parser
- felix-3-0-9-hooks
- felix-main-3.0.9
Create new Android project .
Add these libraries on classpath:
- All JaCC and OBCC projects
- slf4j-api, slf4j-simple, log4j-over-slf4j
- commons-vfs, asm, bcel
Add permission to write to external storage – add this line to AndroidManifest.xml:
```
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
```
Load config in onCreate method of the main activity
- TIP: you can adjust code from org.apache.felix.main.Main class to load configuration files from specified location, for example /mnt/sdcard/felix/conf/

Modify paths in configuration, for example:

org.osgi.framework.storage=/mnt/sdcard/felix/cache
felix.auto.deploy.dir=/mnt/sdcard/felix/bundle

Add JaCC, OBCC and libraries configuration to System properties
Deploy bundles to the felix.auto.deploy.dir on the device . Deploy also config files, if it’s required by the code added in previous three steps.
Start Felix framework in onStart method of the main activity:
```
	m_felix = new Felix(config);
	m_felix.start();
```
Load bundles from bundle directory after starting Felix. You can use AutoProcessor class from Felix main project.
```
	AutoProcessor.process(config, m_felix.getBundleContext());
```

Stop bundles and framework in onStop method of the main activity:

	for(org.osgi.framework.Bundle b: m_felix.getBundleContext().getBundles()) {
		if(b.equals(m_felix)) continue;
		b.stop();
	}
	m_felix.stop();
	m_felix.waitForStop(0);

General description of embedding Felix into an application is available at: http://felix.apache.org/site/apache-felix-framework-launching-and-embedding.html

GUI OSGi bundles on Android

It’s possible to create GUI from bundles, but there is a limitation: you can’t add any Android resources from a bundle, so you have to create layouts dynamically. Unfortunately, I haven’t found any tool for generating java code from xml layout definitions.
The Felix application and all bundles are the same Android application, so they share all Android resources and Android manifest. To be able to use Android packages from a bundle, you have to change Felix configuration:

org.osgi.framework.system.packages.extra=android.*

Description of possible architecture of GUI bundles is available at: https://opensource.luminis.net/wiki/display/SITE/Creating+a+dynamic+OSGi+application+on+Android

Tools used for performance tests

Traceview

Traceview is a tool for profiling Android applications. Collecting trace information has to be switched on and off in program code. A file file with .trace suffix is generated for each switching on and off, so it’s possible to examine more parts of the program. The file has to be downloaded to PC and displayed with the traceview tool.
This tool helps a lot with finding of inefficient parts of code. It displays time spent in methods with and without time spent in called sub-methods. We can see also how many times were the methods called and how many times were they called recursively. From a method, it’s possible to move to sub-methods called from it or to methods from which it was called. When a method is selected, its individual calls are displayed on time-line. Disadvantage of this tool is that the measured time is only relative, because its measuring slows down the application significantly.
More information about this tool is at: http://developer.android.com/guide/developing/debugging/debugging-tracing.html

Eclipse MAT

Eclipse Memory Analyzer is a Java heap analyzer. It can display .hprof file, which contains a heap snapshot. The file can be generated from code or from console. This tool is designed for standard JVM, but it can be used also for Dalvik VM after conversion of the .hprof file:

hprof-conv <android-hprof-file> <out-hprof-file>

Disadvantage of this tool is that the heap snapshot has to be generated at the momemt, when the application is using the biggest amount of memory.

Bundles used in tests

CoCoME

The CoCoME application was chosen for performance testing. For more information about CoCoME, see http://www.cocome.org.
The application was transformed to the OSGi bundles by Bohdan Mixánek, Pavel Bžoch and Peter Cipov . To run it in Felix framework, following bundles has to be present in the bundle auto deploy directory:

CoCoME bundles
org.osgi.compendium-4.2.0.jar
com.springsource.org.postgresql.jdbc4.jar
com.springsource.org.hibernate.jar
com.springsource.org.apache.derby.jar

Parkoviste

Parkoviste is a small synthetic aplication created by KIV. To run this application, OSGi Compendium bundle has to be also present. To run this application on Android, manifest header „Bundle-RequiredExecutionEnvironment“ has to be removed from manifest of each bundle.

Null application

Null application is a trivial application consisting of two bundles, client and server. Client contains only one trivial class, server contains one trivial class and interface.

Build script

Build script for packaging both example aplications for Android and deploing them on an Android device is available here: http://svn.assembla.com/svn/obcc/documentation/trunk/androidTest/build.xml. Before running this script, properties in the beginning of the script with correct paths has to be set. The script requires Ant task library ant-contrib.

Test applications for Android and PC

Two test applications were prepared, one for Android, one for PC. Both applications run one of the example applications on the type-based Felix. The measurement is done only on the resolve process , once with the type compatibility checking, once without it. The felix cache has to be always cleared before tests.
Two measurement methods are tested separatelly. The first method is simple time mesurement, which has no impact on the application performance and so gives accurate absolute time results. The second method uses Traceview and Eclipse MAT to generate more detailed results, but these results are incomparable with results from the first method.
The memory snapshots are generated in cz.zcu.kiv.osgi.felix.hook.KivHook class for each compared packages immediatelly after the comparison is done. At that moment, both compared class hierarchies are loaded and the comarison result is generated. If the type compatibility checking hook is not configured, another simple hook that only generates the snapshots is active.

The test application for Android can be downloaded from http://svn.assembla.com/svn/obcc/documentation/trunk/androidTest/cz.zcu.kiv.obcc.androidTest.zip.

Usage

Import the project to eclipse with Android plugin and import also all JaCC and OBCC projects , felix-3-0-9-hooks and felix-framework-3.0.9 from felix-resolver-integration subproject.

Before running the application, upload config files and bundles on the device. The path is set as static constant of FelixActivity class to value “/sdcard/felix”. Under this directory, create “conf” and “bundle” subdirectories. Upload both config files from “conf” directory of the project to the “conf” directory on the device. Prepare some OSGi bundles for Android (as described in “Running Felix from device shell”) and upload them to the “bundle” directory on the device . Ensure that paths in Felix configuration of the Felix cache and auto-deploy directory are correctly set.

For making the upload faster, ant build script was prepared, as described in “Build script”.

For generating trace and heapdump information of resolving without type-checking, configure Felix hooks in conf/config.properties:

test.trace.enabled=true
felix.resolver.hooks.classes=cz.zcu.kiv.osgi.felix.hook.HeapDumpHook

For generating trace and heapdump information of resolving with type-checking, add heap dump code from HeapDumpHook to cz.zcu.kiv.osgi.felix.hook.KivHook and configure Felix hooks:

felix.resolver.hooks.classes=cz.zcu.kiv.osgi.felix.hook.KivHook

Results

Tests were executed on Android device: Vodafone 845 , and on PC: processor Intel Core i7 , RAM 8GB.
Time in milliseconds measured by the first method :

	null application	Parkoviste	CoCoME
Android	1978	4409	59382
Android with type checking	3615	12165	282829
PC	28	58	234
PC with type checking	256	1345	10437

Memory consumption in MB :

Package	Without type checking	With type checking
null package	1,8	2
org.osgi.framework	8,3	12,3
org.cocome.tradingsystem.application.store	2,5	7
org.cocome.tradingsystem.data.store	2,5	6,9
org.cocome.tradingsystem.application.reporting	2,5	6,8
cz.zcu.kiv.cosi.parkoviste.brana	2,1	2,5
cz.zcu.kiv.cosi.parkoviste.konfigurace	2,1	2,4

On Android device, one OutOfMemoryError was thrown while type checking .
The difference between memory consumption with type checking and without type checking gives memory consumption of JaCC and OBCC library and loaded package representation. For the “null package”, the memory consumption of the loaded package representation is negligible, because the package contains only two trivial classes and one interface. Therefore, this difference gives the memory consumption of the JaCC and OBCC library.

Heap dumps can be downloaded from http://svn.assembla.com/svn/obcc/documentation/trunk/androidTest/heapdump.zip.

Traceview results :

The Traceview tool doesn’t work properly on resolving of CoCoME bundles and it gives very different results for resolving of Parkoviste bundles. According to Traceview, the type checking consumed only 45% of the whole resolving time, but according to measured real time it should be aproximatelly 64%.

The results can be downloaded from http://svn.assembla.com/svn/obcc/documentation/trunk/androidTest/traceview.zip.

Conclusion

Several code adjustments were needed to run JaCC and OBCC projects on Android. The VFS library throws sometimes an IO exception. This is caused probably by an error in the VFS library or in Linux.
The Felix can be embedded into an Android application. Advantages of using an OSGi framework on Android, which is a plugin platform itself, are less overhead time of bundle communication and possibility to transfer an OSGi application from PC to Android device. There is also other approach, which transforms every OSGi bundle into an Android bundle, but this loses the first advantage.
The performance of resolving with type checking was measured relatively to resolving without type checking. The tests were made on Android device and on PC with two absolutelly different OSGi applications , the first is only a simple example application, the other is an enterprise application. In real life, the application would be something between. Results of time consuption are quite similar for both tested applications, on the contrary, the memory consumption results differs a lot.
On Android, the time consumption of type-based resolving is 3 – 5 times higher than standard resolving. The memory consumption is quite decent for the small example, but it significantly grows for bigger applications .
On PC, the time consumption increase of the type-based resolving is much more significant. It is approximatelly 9 times higher for the trivial application, 23 times higher for the simple application and 45 times higher for the enterprise application.