Empress Markets

News & Events


Press Releases

Product Profile

Success Stories

Technical News

White Papers

Join Mailing List

For More Info


Empress Technical News -  May 2010

    Empress Support for Android Mobile Environment
  Build Smart Android Device with Empress Database

                                                                                                          Click here to see Empress Press Release on Android


Embedded devices running Linux range from cell phones, PDAs, multimedia devices and TV set-top boxes. Google’s Android is yet another Linux platform that empowers the development of embedded devices specifically targeted to mobile devices. Android, which is based on a Linux Kernel, is an operating system and software stack for mobile devices that includes middleware and key applications. It enables developers to write Java code controlling the embedded device via Google-developed Java libraries through a Dalvik Virtual Machine.

As a platform Android has been extended to other embedded devices.  Those “smarter” embedded devices that deal with richer and larger amounts of data would require a more sophisticated database technology than SQLite, which is a storage mechanism provided in the Android software stack.  Empress Embedded Database can provide this more sophisticated Technology

Figure 1 describes the Android platform architecture. Developers would typically use the Google Android SDK to build Java applications and package them in the .apk format and deliver them to users via the Android Market.

If the application requires non-Java code such as C or C++ code, Google provides another development kit, the Native Development Kit (NDK). The Android NDK allows developers to create Java programs that interface to C or C++ libraries using Java Native Interface (JNI) wrappers, which are compatible with the SDK environment.

Android Platform Architecture
        Figure 1
: Android Platform Architecture


If the embedded device is manufactured by a vendor who wishes to alter the default Android environment for its users, the vendor could use the Android Source Code with a special Toolchain to do so.

In the following text we will describe how Empress fits in the Android picture and how an Empress database is ported to one of the mobile devices the Google Nexus One phone.

Empowering Google Android with Empress Database Technology

How does Empress fit in the Android picture? There are several ways embedded developers can use Empress database technologies inside an Android device.

The first way is described in Figure 2. The Empress JDBC pure Java client could be packaged inside as a Java application to remotely access an Empress database located somewhere on a local network or on the Internet.

JDBC Remote Access
        Figure 2
: Empress JDBC Client Accesses Empress Database on the Remote Location


The second way is described in Figure 3. The Empress JDBC local access Java client could be packaged inside as a Java application to access an Empress database locally on the same device where the database is located.

JDBC Local Access
        Figure 3
: Empress JDBC Client Accesses Empress Database on the Local Device


The third way is described in Figure 4. An Embedded developer can utilize different Empress APIs (such as ODBC or mr Kernel Level C/C++ API) to develop their application that could access Empress databases locally.

Empress on Local Device
        Figure 4
: Empress Database on the Local Device


Figure 5 shows how each method can be used concurrently. The diagrams from Figure 2, 3 & 4 show scenarios of Empress usage and Figure 5 shows that those scenarios can all be used at the same time.

How It All Works
        Figure 5
: How Everything Fits Together


In the following text we will describe how the actual port on the specific device, in this case a Nexus One phone, was done with Empress.

Porting Empress Database to Nexus One Phone

In the past the Android platform has been used for several phones including the initial HTC phone, a developer platform from HTC, the Motorola Droid and now the Google Nexus One as manufactured by HTC for Google.

Since the Google Nexus One implemented the 2.1 version of the Android SDK and it was the only phone from Google, it seemed like the perfect candidate for porting Empress to it. Google had also just released the SDK for the Nexus One as well.

Getting The Phone

The Nexus One is available from T-Mobile in the USA as a locked phone, or from Google on-line as either a locked phone for T-Mobile or as an unlocked phone with no carrier.  The unlocked phone was selected for porting as it is the most flexible version available. The phone was ordered through Google on-line and had free next day FedEx shipping bundled into the price. It arrived the next day as promised.

The Nexus One and T-Mobile were also encountering some usability problems with the T-Mobile network at the time, so phone orders from Google were not as high as expected and consequently there was enough stock for same day processing.

Setting Up The Phone

The Nexus One came with a 4GB micro SD card but no SIM card. The battery needed to be charged before operation and that took about two hours. Once the phone was charged, it was setup by entering a Gmail account and configured for the local Wireless Network (WiFi). At this point, there was no telephone service but the Nexus One could surf the web and run applications. A SIM card was later acquired and installed in the phone to allow phone calls and data access.

Setting Up The SDK Development Environment

The Android 2.1 Software Development Kit (SDK) allows developers to create Java programs that can be run on an unmodified Nexus One. Android also supplies a number of Java APIs that can be called. In addition, developers can add in their own Java libraries. Internally, Android runs the Dalvik Virtual Machine (VM), so that the SDK converts Java programs and libraries to Dalvik Byte Code for execution on the Android runtime Dalvik VM. This has the side effect of Google not needing to pay royalties to Sun Microsystems for Java usage, since Android executes a Dalvik VM, not a Java VM. The code is supposed to be more compact as well.

The Android SDK can be run on Linux, Windows and Mac. The SDK was installed on Windows XP, Ubuntu 9 and Red Hat Enterprise Linux 5.4. An emulator for the Android environment was included in the package (see Figure 6). 


Android Emulator







Figure 6
: Android Emulator


After the installation and setup, Eclipse was also downloaded to allow for a GUI based development environment. The SDK and emulator ran slower on Linux than Windows, so the Windows environment was mainly used. There was also a command line interface that could run with the emulator or the actual device that allowed execution of certain Linux commands if they were not blocked by restrictive permissions. Thus commands such as “ls –l”, “mount” or “cd” were unrestricted, but commands such as “su” were restricted.

Setting Up The NDK Development Environment

The Android 1.6 Native Development Kit (NDK) allows developers to create Java programs that interface to C or C++ libraries using JNI wrappers, which are compatible with the SDK environment. This allows developers to use C programs within Java.

The Android NDK was also installed on Linux and Windows, but mainly used on Windows alongside the SDK.

Setting Up An EABI Development Environment

Ubuntu 7, 8 and 9 were set up for an EABI Development Environment. The base OMAP-ZOOM EABI for the Access Linux Platform (ALP) has options for running on the Android EABI including building kernels, root file systems, programs and utilities written in C. Google is known to be slow in posting updated versions of the Android kernel, device drivers and utilities on the web, so the latest updates were not available from Google.

At the first stage of the port, our goal was to do as much as possible without having to “root” the phone or modify the image. In many ways, the Nexus One phone environment was more restrictive than Windows CE installed on an embedded device. With Windows CE, programming is in C and has many more system calls available. The Nexus One has been strongly restricted in terms of adding pure C programs. well, dangerous system calls were not available.

Porting Empress Java to the Nexus One

The Nexus One phone was connected to the Windows SDK/NDK development environment by USB cable. ConnectBot, which provides “ssh” and a local command line window, was downloaded from the Google Applications store in case it was needed.

The Eclipse GUI was then used to write a simple “Hello World” program in Java. While the Nexus One was plugged in via USB connection, Eclipse could actively debug and/or run a program on the phone or the Android emulator. The Android SDK website provided information on the Java methods that were available for the “Hello World” program. The “Hello World” program did not have a “main”, but interfaced to a running thread on Android. The program not only ran, but a copy was automatically downloaded and installed onto the device. This created some conflicts with the next iteration of the “Hello World” program and the program that had been downloaded to the device had to be removed using Settings-> Applications-> Manage Applications. Eventually the “Hello World” program and its automatic downloads were operating properly without side effects.

Once the “Hello World” was finished, an investigation showed that Java SQL methods were available. One of the Eclipse menus allowed unchanged Empress Java methods to be included in a Java program build. Java Code was written and successfully compiled as an Empress Client on the Nexus One (see Figure 2). One of the early problems was that the Java program did not allow access to the network. An XML file was edited to allow network access privileges and the program proceeded to the next problem – timeout on accessing the server. This was solved by configuring the phone’s WiFi and VPN capabilities.

Now the program could “create tables”, “insert”, “select”, “update” and “delete” data in a database.  After working through a number of operational requirements and dealing with some minor coding differences, the Empress Java Client application was complete.

After this exercise many other applications (in the .apk format) were implemented that show Empress usage that fit other ways of usage (see Figure 3, 4 and 5). These applications were run on both the Android Emulator and the Nexus One.

Empress On Android
        Figure 7
: Empress running on Android Emulator

In Conclusion

The Android platform gives an excellent vehicle to embedded developers to build embedded mobile applications. As a platform Android has been extended to other embedded devices. Those “smarter” embedded devices that deal with richer and larger amounts of data would require a more sophisticated database technology than SQLite, which is a storage mechanism provided in the Android software stack.  Empress Embedded Database can provide this more sophisticated Technology.

Google Android and Empress Database Technology can be essential components for making smart embedded devices do what they should.


Empress Software Inc.



GSA Contracts
Privacy Policy 
Contact US

Empress RDBMS
Empress Servers
Empress API
Free Trial 
Empress iPad Apps

Mobile Apps Development
Technical Support

Training Courses
Empress Extreme  

Business Alliances
Partner Programs  
GSA Program
Distributors Program

Empress Markets
News and Events
Press releases
Technical News
Success Stories

        USA: 301-220-1919                 Canada & International:       905-513-8888         
Copyright © 2014           Empress Software Inc.            Join Empress Mailing List