Friday, January 1, 2016

MVP : Event Bus pattern instead of Listener

This question more towards paradigm. Why is that we don't use Event Bus instead of listeners in an MVP environment ? Typically, the "P" part has dependency injection of view and model references. Sure this has an advantage of showing explicit contract between the view and model via presenter, which is more readable.
However, wouldn't it be a cleaner approach to have presenter listen to events from views and events carry the view payload (eg: json representation). Same is the case with presenter talking back to the view. View will listen for events from presenter. Major advantage is, we don't have to write interfaces for each contract between view and presenter. If you look at the code you will see that presenter is getting exposed to view details like Text Fields, which i believe is increasing coupling between view and presenter. Say, if i'm replacing front end JavaFx instead of Vaadin, i will have to alter presenter as well.
This class is an example from a live project. Here we have different types of events ie i don't create event class for different cases. Eg: LoginViewEvent , DashBoardEvent etc which i believe is a maintenance pain.
public class UrayEvent {

    public static enum EventType {


        private final int value;

        private EventType(int value) {

            this.value = value;

        public int getValue() {

            return value;

    public static class Event {

        private final EventType type;
        private final Object payload;

        public Event(EventType type, Object eventPayload) {

            this.type = type;
            this.payload = eventPayload;

        public EventType getEventType() {

            return type;

        public Object getEventPayload() {

            return payload;

Simple enough, the view send the event  DOCUMENT_EDIT_COMPLETE .The presenter layer handles this event. I found this way, a better way to decouple views from presenter.
    public void handle(UrayEvent.Event event) {

        switch (event.getEventType()) {
            case DOCUMENT_EDIT_COMPLETE:
                  // event payload contains document model data
                  // like document id etc
  • Less boiler plate code, 
  • For n-views we don't need n-interfaces
  • New event means adding event element to enum and updating respective subscribe methods handling this event.
  • Memory leak if we forget to unregister  from eventbus (faced it plenty of time)
1) This approach means, there would larger set enum elements as the application grow. Is this approach an anti pattern ?
2) As we saw it uses Event Bus extensively are there any drawbacks of using bus system instead of interface-listener pattern ?
Wanted your valuable suggestion on this regard. The main issue is, if i blindly apply this pattern extensively across the project i shouldn't regret doing so, what would be a possible pitfall in this approach.

Wednesday, December 23, 2015

Android Internals : just what application developers needs to know

It is always good (not a must) to know the internals of a software platform, to be an efficient developer. After having exposed to the internals, many facts will make more sense to during the development, further you will get the clear picture of how each components connect and interact with each other.

Its been a while since the inception of the Android Mobile platform. Since then, there has been higher demand for android developers, not to mention how it made easy for existing Java developers to migrate. Statistics show, most mobile and embedded devices will default to Android soon or later.Learning this platform would be worth the time spend. 

This article, will explain only necessary internal details just enough for user-space developer. Once complete we will have a clear picture of entire android stack starting from the source tree organisation, architecture component interaction, start up sequence, to how an application is launched.

1. Architecture


Fig 1 Conceptual Architecture 
1.1 Kernel 

A the bottom most level, the host operating system, is the Linux kernel.
Theoretically it could be any host kernel, practically, however it is a difficult task to achieve. Though, Linux kernel is being used, there were many kernel specific patches those were added to support various user level android policies and drivers. 

Kernel patches (Details are skipped)
  • Wake Locks
  • Binder
  • Klogger                                
  • Anonymous Share Memory
  • Alarm Timers
  • Low Memory Killer
  • Network Security policy   
Other than the patches above, one has to keep in mind, the device manufactures do add custom patches to support their hardware, what is mentioned above are core kernel patches for a android system to work. 

Source Tree : kernel

1.2 Android Runtime 

Consist of the Dalvik virtual machine, which is just like JVM on tbe desktop, that executes the android applications we run, Java runtime, that comes from the Apache Harmony project, system daemons, the init binary  and various supporting binaries. Dalvik virtual machine executes dex files instead of class files. dex files are generated by post processing class files with dx utility.   

Oracle Java    = Java Language    + class file + JVM    + JRE libs
Android Java = Java Language    + dex file   + DVM  + Apache Harmony Project 

Most of the java.* , org.w3c.* junit.* org.json.* in the android API comes from here, including the sql jdbc driver

Source Tree: libcore ,  dalvik , system 

1.3 Libraries 

This is where, the 3rd party native libraries (C/C++) are hosted, they act as a support layer for low level access from the java libraries, it consist of google developed C library called Bionic, it is stripped down library from BSD standard C library. Bionic isn't compliance with POSIX, so native (non java) application and library porting from POSIX system is a hurdle. Though only few libraries have been mentioned in the diagram, it consist of more, starting from libusb to webRTC, kindly see the source tree

The Application frame work access these libraries via JNI , one such example to site would be sqlite, we will see a source relation, check the links

So, in nutshell, these libraries are accessed by the application frame work via JNI.  

Source Tree:  external

1.4 Application Framework 

Ah, finally we are at the top, the android.* APIs you see in the Android API reference sprouts from here, this is what we mostly use while developing an android applications. Framework don't just consist of developer apis, but, various services and interfaces to communicate with them. Services are not directly accessible via framework , however, via kernel supported mechanism called Binder. In short andorid.*  APIs connected to service / system server via binder.  

Source Tree: framework

1.5 Applications 

There is were we have all the fun, we use the SDKs to access these framework APIs to develop the applications. Most of the application developers play here. There are other species of developers who hack the frameworks , android services and even the kernel subsystem to build custom roms, one such community is the CyanaogenMOD, we should say they are the first class android developers and us to be economy developers. ;-). Most android devices have set of default applications like dialers, mms, browsers you can find its source tree over here.

2. Android Hardware Abstraction Layer 

Kernel does provide HAL , however Google engineers felt it wasn't enough, one reason could be GPL license that the kernel has. So, in order to make device manufacturers implement non GPLed drivers in the user space, this may be a favorable choice. 

Libhardware provides interface for various devices and sensors, the device manufacturers can develop drivers in closed source environment, complying to these interfaces. Few of the interfaces are listed here. 
  • Audio (                
  • Graphics (,,                
  • Camera (          
  • GPS (                   
  • Sensors (       
  • Radio Interface (  
All that the manufacturer has to do is to put their library into /system/libs/hw

Case Study : If you like to know how RIL is used for receiving calls, sending sms, receving sms etc take a look into this answer.

3. Android File System 

Android though is Linux based doesn't strictly abide to the FHS , instead has a custom hierarchy

/system                    Immutable directory coming from the original build.
                                It contains native binaries and libraries, framework jar files, 
                                configuration files, standard apps, etc.
/system/app             All the pre-installed apps
/system/bin              Binaries installed on the system (toolbox, vold, surfaceflinger)
/system/etc               Configuration files
/system/fonts            Fonts installed on the system
/system/framework  Jar fi les for the framework
/system/lib               Shared objects for the system libraries
/system/modules      Kernel modules
/system/xbin            External binaries
/data                        changing content of the system are put: 
                                apps, data added by the user, data generated by all the apps at runtime, etc. 

/etc                         Symbolic link to /system/etc
/dev                       Mount point for tmpfs filesystem
/proc                      Mount point for procfs filesystem which provide access to kernel data structures 
/sbin                       Contains various daemons
/root                       As usual the root home directory
/mnt                       Mount point for external and internal filesystems 
                              and some security related filessytem

/sys                        Mount point for sysfs filesystem which has information on 
                              kernel's device objects
/sdcard                   Symbolic link to /mnt/sdcard
/cache                    Used by application to save data temporarily like Google Play Store download etc 
/d                           Symbolic link to /sys/kernel/debug  
/acct                      Mount point for the acct cgroup (control group), 
                              which provides for user accounting.
/vendor                  Symbolic link to /system/vendor 

4. Source Code Organisation Overview

bionic/            is where Android's standard C library is stored
bootable/        contains code samples regarding the boot of an Android device. In this folder, 
                       you will find the protocol used by all Android bootloaders and a recovery image
build/              holds the core components of the build system
cts/                 The Compatibility Test Suite
dalvik/            contains the source code of the Dalvik virtual machine
development/ holds the development tools, debug applications, API samples, etc
device/            contains the device-speci c components
external/         is one of the largest folders in the source code, it contains all the external 
                       projects used in the Android code
frameworks/   holds the source code of the various parts of the framework
hardware/       contains all the hardware abstraction layers
libcore/           is the Java core library
ndk/                is the place where you will nd the Native Development Kit, which allows to build native
                       applications for Android
packages/        contains the standard Android applications
prebuilt/          holds all the prebuilt binaries, most notably the toolchains
sdk/                is where you will nd the Software Development Kit
system/           contains all the basic pieces of the Android system: init, shell, the volume manager, etc.

5. System Startup

Fig 2. start up sequence 

Start up sequence till init is quite straight forward, this is similar usual x86 boot process, finally calling Init , however Android system differs starting from the init sequence. The init itself was written from scratch and not same as the one seen on Linux distribution.

Once the kernel start /init process, it reads the file name /init.rc and /init.(machine-name).rc , these rc script, first of all sets the environment variables,  mounts various file system to its respective mount points, starts various daemons like rild (radio interface layer daemon), adb , vold, netd etc. Init become mother of all the process created subsequently. The next core job of init is to start up the Zygote, which is the mother of all the android applications

Lets take a deeper view into Zygote start up,

Init runs the /system/bin/app_process and name it zygote
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

The entry above from ./init.rc that start the app_process to startup the zygote.

As seen in the source line 188 of app_main.cpp

188    if (zygote) {
189        runtime.start("",
190                startSystemServer ? "start-system-server" : "");
191    }

It start up the java implementation of Zygote , and 'start-system-server' flag is passed as the parameter. This is exactly what we had passed in the entry from the init.rc. The line 189 does many other tasks under the hood, the runtine.start() at line 839 start up up the Dalvik virtual machine, see line 443 of AndroidRuntime.cpp for more information.Ahead of zygote invocation, Dalvik runtime was setup and Dalvik virtual machine was initialized. ZygoteInit::main() get called at line 888 of AndroidRuntime.cpp , which start up the System Server this can be seen at line 544 of, finally it runs runSelectLoopMode() and waits for future request to fork() new zygote instances which specialize into the android application.The System server is started in a two sequence process , first a libary is called to initialize the native services, which can be seen at line 1064 of , then java based core services are run by ServerThread::run() which is seen at like 1067 of Check the source to find out the sequence of the services started, core services line the PowerManager, ActivityManager, Sensor Service etc and other non critical services are started this way. The main being the AcitivityManager, which handles the our Andorid Application.


501            /* Request to fork the system server process */
502            pid = Zygote.forkSystemServer(
503                    parsedArgs.uid, parsedArgs.gid,
504                    parsedArgs.gids,
505                    parsedArgs.debugFlags,
506                    null,
507                    parsedArgs.permittedCapabilities,
508                    parsedArgs.effectiveCapabilities);
509        } catch (IllegalArgumentException ex) {
510            throw new RuntimeException(ex);
511        }

544            if (argv[1].equals("start-system-server")) {
545                startSystemServer();
546            } else if (!argv[1].equals("")) {
547                throw new RuntimeException(argv[0] + USAGE_STRING);
548            }
Code Snippet Showing How System Server is started

Ah finally we have reached the end,  though this was quick introduction into the android internals, it is my humble opinion that , information above would be sufficient enough to get you started with griping the Android APIs. This introduction will hopefully help you understand the relations and component interaction, which would make android application programming more exiting. Where go from here ? Now you can start reading Application Fundamentals from the android main resource, trust me, many things will make more sense now.


Friday, November 13, 2015

UNIX (tm) Version History

Well this about history of UNIX,main reason to write this is because of confusion about various versions and how they came to be.What ever given below are not my keystrokes rather from distributed sources like Wikipedia and others. What make this blog different , well i have compiled only necessary information for understanding version confusion.

Unix (officially trademarked as UNIX, sometimes also written as Unix with small caps) is a computer operating system originally developed in 1969 by a group of AT&T employees at Bell Labs, including Ken Thompson, Dennis Ritchie, Douglas McIlroy, and Joe Ossanna.As of 2007, the owner of the trademark is The Open Group.Only systems fully compliant with and certified to the Single UNIX Specification are qualified to use the trademark; others are called "Unix system-like" or "Unix-like".Commercial start ups, the most notable of which are Solaris, HP-UX, AIX, and Mac OS X.

AT&T made Unix available to universities and commercial firms, as well as the United States government under licenses. The licenses included all source code including the machine-dependent parts of the kernel, which were written in PDP-11 assembly code. Copies of the annotated Unix kernel sources circulated widely in the late 1970s in the form of a much-copied book by John Lions of the University of New South Wales, the Lions' Commentary on UNIX 6th Edition, with Source Code, which led to considerable use of Unix as an educational example.

Version 5 and especially Version 6 led to a plethora of different Unix versions. Version 7 Unix, the last version of Research Unix to be released widely, was released in 1979. Versions 8, 9 and 10 were developed through the 1980s but were only released to a few universities.AT&T licensed UNIX System III, based largely on Version 7, for commercial use, the first version launching in 1982. This also included support for the VAX. AT&T continued to issue licenses for older Unix versions.To end the confusion between all its differing internal versions, AT&T combined them into UNIX System V Release 1.

Since the newer commercial UNIX licensing terms were not as favorable for academic use as the older versions of Unix, the Berkeley researchers continued to develop BSD Unix as an alternative to UNIX System III and V.the most important aspect of the BSD development effort was the addition of TCP/IP network code to the mainstream Unix kernel.

Other companies began to offer commercial versions of the UNIX System for their own mini-computers and workstations. Most of these new Unix flavors were developed from the System V base under a license from AT&T; however, others were based on BSD instead. One of the leading developers of BSD, Bill Joy, went on toco-found Sun Microsystems in 1982 and created SunOS for their workstation computers.

In 1991, a group of BSD developers (Donn Seeley, Mike Karels, Bill Jolitz, and Trent Hein) left the University of California to found Berkeley Software Design, Inc (BSDI). BSDI produced a fully functional commercial version of BSD Unix for the inexpensive and ubiquitous Intel platform, which started a wave of interest in the use of inexpensive hardware for production computing. Shortly after it was founded, Bill Jolitz left BSDI to pursue distribution of 386BSD, the free software ancestor of FreeBSD, OpenBSD, and NetBSD.A free derivative of BSD Unix, 386BSD, was also released in 1992 and led to the NetBSD and FreeBSD projects.

With the 1994 settlement of a lawsuit that UNIX Systems Laboratories brought against the University of California and Berkeley Software Design Inc. (USL v. BSDi), it was clarified that Berkeley had the right to distribute BSD Unix ¿ for free, if it so desired. Since then, BSD Unix has been developed in several different directions, including OpenBSD and DragonFly BSD.

Shortly after UNIX System V Release 4 was produced, AT&T sold all its rights to UNIX to Novell. (Dennis Ritchie likened this to the Biblical story of Esau selling his birthright for the proverbial "mess of pottage".[7]) Novell developed its own version, UnixWare, merging its NetWare with UNIX System V Release 4. Novell tried to use this to battle against Windows NT, but their core markets suffered considerably.

In 1993, Novell decided to transfer the UNIX trademark and certification rights to the X/Open Consortium. In 1996, X/Open merged with OSF, creating the Open Group. Various standards by the Open Group now define what is and what is not a "UNIX" operating system, notably the post-1998 Single UNIX Specification.

Beginning in the late 1980s, an open operating system standardization effort now known as POSIX provided a common baseline for all operating systems; IEEE based POSIX around the common structure of the major competing variants of the Unix system, publishing the first POSIX standard in 1988. In the early 1990s a separate but very similar effort was started by an industry consortium, the Common Open Software Environment (COSE) initiative, which eventually became the Single UNIX Specification administered by The Open Group. Starting in 1998 the Open Group and IEEE started the Austin Group, to provide a common definition of POSIX and the Single UNIX Specification.

In 1983, Richard Stallman announced the GNU project, an ambitious effort to create a free software Unix-like system; "free" in that everyone who received a copy would be free to use, study, modify, and redistribute it. The GNU project's own kernel development project, GNU Hurd, had not produced a working kernel, but in 1992 Linus Torvalds released the Linux kernel as free software under the GNU General Public License. In addition to their use in the Linux operating system, many GNU packages ¿ such as the GNU Compiler Collection (and the rest of the GNU toolchain), the GNU C library and the GNU core utilities ¿ have gone on to play central roles in other free Unix systems as well.

Linux distributions, comprising Linux and large collections of compatible software have become popular both with individual users and in business. Popular distributions include Red Hat Enterprise Linux, Fedora, SUSE Linux Enterprise, openSUSE, Debian GNU/Linux, Ubuntu, Mandriva Linux, Slackware Linux and Gentoo.

Friday, October 30, 2015

Android and Microsoft SQL (MS SQL SERVER 2008) marriage

All you have to do is use the appropriate driver, being a opensource fan , i'd recommend using JTDS.

Instructions below assumes you are using

  • Android Developer Tools Build id: v22.0.1-685705,
  • Eclipse Version: 4.2.1.v20130118 Build id: M20130204-1200
  • JTDS 1.2.5 

 though things will work out other versions higher than this and possibly lower as well , its just to ensure a known state where things worked out.

So, once the JTDS is jar is download, first step is to include jar to your build path

Next, though it seems like a bug, go to order and Export tab and enable jtds

Since the database connection operation is networked related, all network operations should be in different thread away from the main UI thread,  so use  AsyncTask.

Working code is can be downloaded from here , read the code, it is well documented.

git clone

Saturday, May 30, 2015

Java : convert milliseconds hours, minutes, seconds ,days

An example using built in  TimeUnit .
                            long uptime = System.currentTimeMillis();

                            long days = TimeUnit.MILLISECONDS
                            uptime -= TimeUnit.DAYS.toMillis(days);

                            long hours = TimeUnit.MILLISECONDS
                            uptime -= TimeUnit.HOURS.toMillis(hours);

                            long minutes = TimeUnit.MILLISECONDS
                            uptime -= TimeUnit.MINUTES.toMillis(minutes);

                            long seconds = TimeUnit.MILLISECONDS

uptime:22hr 15min 40sec 14 days