Wednesday, October 29, 2014

Android makeIn/fadeIn and makeOut/fadeOut Animation

If you want to make swipe in/out animation, Android by default provides a utility class called AnimationUtils. The class AnimationUtils Defines common utilities for working with animations.

1. Swipe out/ Fade out Effect.
The AnimationUtils class have static method called makeOutAnimation , used to exhibit swipe out/fade out animations.

Animation anim = AnimationUtils.makeOutAnimation(context, fromLeft);

It creates an animation for objects becoming visible. Uses a slide and fade effect.

2. Swipe In/ Fade In Effect.
The AnimationUtils class have static method called makeInAnimation , used to exhibit swipe out/fade out animations.

Animation anim = AnimationUtils.makeInAnimation(context, fromLeft);

It creates an animation for objects becoming invisible. Uses a slide and fade effect.

Android Application Designing for Performance

An Android application should be fast. Well, it's probably more accurate to say that it should be efficient. That is, it should execute as efficiently as possible in the mobile device environment, with its limited computing power and data storage, smaller screen, and constrained battery life.
In this blog I am providing best practices to follow to design for performance.

1. Avoid Creating Objects
Object creating in android is more expensive than creating object in Java. Try to avoid creating objects as possible as you do. More objects mean more work to GC. More works to GC means little "hiccups" in the user experience.

Generally speaking, avoid creating short-term temporary objects if you can. Fewer objects created mean less-frequent garbage collection, which has a direct impact on user experience.  If possible pool the objects, so it can be reused.

2.  Keep Blocking Operations Off the Main UI Thread
Use AsyncTask, Thread, IntentService, or Custom background service to do the heavy work. Use Loaders to simplify state management of long loading data, such as cursors. You cannot afford for your application to lag or freeze while some processing is going on. If an operation takes time and resources, offload that processing and perform it asynchronously so that your application remains responsive and the user can go about their business

3. Use Native Methods
 C/C++ code that easily runs 10-100x faster than doing the same thing in a Java loop.

4. Prefer Virtual Over Interface
Suppose you have a HashMap object. You can declare it as a HashMap or as a generic Map:

Map myMap1 = new HashMap();

HashMap myMap2 = new HashMap();
Which is better?

Conventional wisdom says that you should prefer Map, because it allows you to change the underlying implementation to anything that implements the Map interface. Conventional wisdom is correct for conventional programming, but isn't so great for embedded systems. Calling through an interface reference can take 2x longer than a virtual method call through a concrete reference.

If you have chosen a HashMap because it fits what you're doing, there is little value in calling it a Map. Given the availability of IDEs that refractor your code for you, there's not much value in calling it a Map even if you're not sure where the code is headed. (Again, though, public APIs are an exception: a good API usually trumps small performance concerns.)

5. Prefer Static Over Virtual
If you don't need to access an object's fields, make your method static. It can be called faster, because it doesn't require a virtual method table indirection. It's also good practice, because you can tell from the method signature that calling the method can't alter the object's state.

6. Avoid Internal Getters/Setters
In native languages like C++ it's common practice to use getters (e.g. i = getCount()) instead of accessing the field directly (i = mCount). This is an excellent habit for C++, because the compiler can usually inline the access, and if you need to restrict or debug field access you can add the code at any time.

On Android, this is a bad idea. Virtual method calls are expensive, much more so than instance field lookups. It's reasonable to follow common object-oriented programming practices and have getters and setters in the public interface, but within a class you should always access fields directly.

7. Declare Constants Final
Consider the following declaration at the top of a class:

static int intVal = 42;
static String strVal = "Hello, world!";
The compiler generates a class initializer method, called <clinit>, that is executed when the class is first used. The method stores the value 42 into intVal, and extracts a reference from the classfile string constant table for strVal. When these values are referenced later on, they are accessed with field lookups.

We can improve matters with the "final" keyword:
static final int intVal = 42;
static final String strVal = "Hello, world!";
The class no longer requires a <clinit> method, because the constants go into classfile static field initializers, which are handled directly by the VM. Code accessing intVal will use the integer value 42 directly, and accesses to strVal will use a relatively inexpensive "string constant" instruction instead of a field lookup.

Declaring a method or class "final" does not confer any immediate performance benefits, but it does allow certain optimizations. For example, if the compiler knows that a "getter" method can't be overridden by a sub-class, it can inline the method call.

You can also declare local variables final. However, this has no definitive performance benefits. For local variables, only use "final" if it makes the code clearer (or you have to, e.g. for use in an anonymous inner class).

8. Use Enhanced For Loop Syntax with Caution
The enhanced for loop (also sometimes known as "for-each" loop) can be used for collections that implement the Iterable interface. With these objects, an iterator is allocated to make interface calls to hasNext() and next(). With an ArrayList, you're better off walking through it directly, but for other collections the enhanced for loop syntax will be equivalent to explicit iterator usage.

Nevertheless, the following code shows an acceptable use of the enhanced for loop:

public class Foo {
    int mSplat;
    static Foo mArray[] = new Foo[27];

    public static void zero() {
        int sum = 0;
        for (int i = 0; i < mArray.length; i++) {
            sum += mArray[i].mSplat;

    public static void one() {
        int sum = 0;
        Foo[] localArray = mArray;
        int len = localArray.length;

        for (int i = 0; i < len; i++) {
            sum += localArray[i].mSplat;

    public static void two() {
        int sum = 0;
        for (Foo a: mArray) {
            sum += a.mSplat;

zero() retrieves the static field twice and gets the array length once for every iteration through the loop.

one() pulls everything out into local variables, avoiding the lookups.

two() uses the enhanced for loop syntax introduced in version 1.5 of the Java programming language. The code generated by the compiler takes care of copying the array reference and the array length to local variables, making it a good choice for walking through all elements of an array. It does generate an extra local load/store in the main loop (apparently preserving "a"), making it a teensy bit slower and 4 bytes longer than one().

To summarize all that a bit more clearly: enhanced for loop syntax performs well with arrays, but be cautious when using it with Iterable objects since there is additional object creation.

9. Avoid Enums
Enums are very convenient, but unfortunately can be painful when size and speed matter. For example, this:

public class Foo {
   public enum Shrubbery { GROUND, CRAWLING, HANGING }
turns into a 900 byte .class file (Foo$Shrubbery.class). On first use, the class initializer invokes the <init> method on objects representing each of the enumerated values. Each object gets its own static field, and the full set is stored in an array (a static field called "$VALUES"). That's a lot of code and data, just for three integers.


Shrubbery shrub = Shrubbery.GROUND;
causes a static field lookup. If "GROUND" were a static final int, the compiler would treat it as a known constant and inline it.

The flip side, of course, is that with enums you get nicer APIs and some compile-time value checking. So, the usual trade-off applies: you should by all means use enums for public APIs, but try to avoid them when performance matters.

In some circumstances it can be helpful to get enum integer values through the ordinal() method. For example, replace:

for (int n = 0; n < list.size(); n++) {
    if (list.items[n].e == MyEnum.VAL_X)
       // do stuff 1
    else if (list.items[n].e == MyEnum.VAL_Y)
       // do stuff 2

   int valX = MyEnum.VAL_X.ordinal();
   int valY = MyEnum.VAL_Y.ordinal();
   int count = list.size();
   MyItem items = list.items();

   for (int  n = 0; n < count; n++)
        int  valItem = items[n].e.ordinal();

        if (valItem == valX)
          // do stuff 1
        else if (valItem == valY)
          // do stuff 2

In some cases, this will be faster, though this is not guaranteed.

10. Use Package Scope with Inner Classes
Consider the following class definition:

public class Foo {
    private int mValue;

    public void run() {
        Inner in = new Inner();
        mValue = 27;

    private void doStuff(int value) {
        System.out.println("Value is " + value);

    private class Inner {
        void stuff() {

The key things to note here are that we define an inner class (Foo$Inner) that directly accesses a private method and a private instance field in the outer class. This is legal, and the code prints "Value is 27" as expected.

The problem is that Foo$Inner is technically (behind the scenes) a totally separate class, which makes direct access to Foo's private members illegal. To bridge that gap, the compiler generates a couple of synthetic methods:

/*package*/ static int Foo.access$100(Foo foo) {
    return foo.mValue;
/*package*/ static void Foo.access$200(Foo foo, int value) {

The inner-class code calls these static methods whenever it needs to access the "mValue" field or invoke the "doStuff" method in the outer class. What this means is that the code above really boils down to a case where you're accessing member fields through accessor methods instead of directly. Earlier we talked about how accessors are slower than direct field accesses, so this is an example of a certain language idiom resulting in an "invisible" performance hit.

We can avoid this problem by declaring fields and methods accessed by inner classes to have package scope, rather than private scope. This runs faster and removes the overhead of the generated methods. (Unfortunately it also means the fields could be accessed directly by other classes in the same package, which runs counter to the standard OO practice of making all fields private. Once again, if you're designing a public API you might want to carefully consider using this optimization.)

11. Avoid Float
Before the release of the Pentium CPU, it was common for game authors to do as much as possible with integer math. With the Pentium, the floating point math co-processor became a built-in feature, and by interleaving integer and floating-point operations your game would actually go faster than it would with purely integer math. The common practice on desktop systems is to use floating point freely.

Unfortunately, embedded processors frequently do not have hardware floating point support, so all operations on "float" and "double" are performed in software. Some basic floating point operations can take on the order of a millisecond to complete.

Also, even for integers, some chips have hardware multiply but lack hardware divide. In such cases, integer division and modulus operations are performed in software — something to think about if you're designing a hash table or doing lots of math.

12. Some Sample Performance Numbers
To illustrate some of our ideas, here is a table listing the approximate run times for a few basic actions. Note that these values should NOT be taken as absolute numbers: they are a combination of CPU and wall clock time, and will change as improvements are made to the system. However, it is worth noting how these values apply relative to each other — for example, adding a member variable currently takes about four times as long as adding a local variable.

Add a local variable
Add a member variable
Call String.length()
Call empty static native method
Call empty static method
Call empty virtual method
Call empty interface method
Call Iterator:next() on a HashMap
Call put() on a HashMap
Inflate 1 View from XML
Inflate 1 LinearLayout containing 1 TextView
Inflate 1 LinearLayout containing 6 View objects
Inflate 1 LinearLayout containing 6 TextView objects
Launch an empty activity

13. Closing Notes
The best way to write good, efficient code for embedded systems is to understand what the code you write really does. If you really want to allocate an iterator, by all means use enhanced for loop syntax on a List; just make it a deliberate choice, not an inadvertent side effect.

Forewarned is forearmed! Know what you're getting into! Insert your favorite maxim here, but always think carefully about what your code is doing, and be on the lookout for ways to speed it up.

Tuesday, October 14, 2014

Singleton design pattern in java

Singleton patterns comes under creational design patterns. The Singleton's purpose is to control object creation, limiting the number of objects to one only.  Since there is only one Singleton instance, any instance fields of a Singleton will occur only once per class, just like static fields. Singletons often control access to resources such as database connections or sockets.

Singleton ensures that a class has only one instance, and provide a global point of access to it.

Singleton applications

1.     Abstract Factory, Builder, and Prototype can use Singleton in their implementation.
2.     Facade objects are often Singletons because only one Facade object is required.
3.     State objects are often Singletons.
4.     The advantage of Singleton over global variables is that you are absolutely sure of the number of instances when you use Singleton, and, you can change your mind and manage any number of instances.
5.     The Singleton design pattern is one of the most inappropriately used patterns. Singletons are intended to be used when a class must have exactly one instance, no more, no less. Designers frequently use Singletons in a misguided attempt to replace global variables. A Singleton is, for intents and purposes, a global variable. The Singleton does not do away with the global; it merely renames it.
6.     When is Singleton unnecessary? Short answer: most of the time. Long answer: when it's simpler to pass an object resource as a reference to the objects that need it, rather than letting objects access the resource globally. The real problem with Singletons is that they give you such a good excuse not to think carefully about the appropriate visibility of an object. Finding the right balance of exposure and protection for an object is critical for maintaining flexibility.
7.     Our group had a bad habit of using global data, so I did a study group on Singleton. The next thing I know Singletons appeared everywhere and none of the problems related to global data went away. The answer to the global data question is not, "Make it a Singleton." The answer is, "Why in the hell are you using global data?" Changing the name doesn't change the problem. In fact, it may make it worse because it gives you the opportunity to say, "Well I'm not doing that, I'm doing this" – even though this and that are the same thing.

Check list

1.     Define a private static attribute in the "single instance" class.
2.     Define a public static accessor function in the class.
3.     Do "lazy initialization" (creation on first use) in the accessor function.
4.     Define all constructors to be protected or private.
5.     Clients may only use the accessor function to manipulate the Singleton.

Singleton Implementation

public class Singleton {
  // Private constructor prevents instantiation from other classes
  private Singleton() {}

   * SingletonHolder is loaded on the first execution of Singleton.getInstance()
   * or the first access to SingletonHolder.INSTANCE, not before.
  private static class SingletonHolder {
    private static final Singleton INSTANCE = new Singleton();

  public static Singleton getInstance() {
    return SingletonHolder.INSTANCE;

Monday, October 13, 2014

Android System Building Commands

The build system uses some pre-set environment variables and a series of 'make' files in order to build an Android system and prepare it for deployment to a platform

Make targets

Here is a list of different make targets you can use to build different parts of the system:
Make sdk
Build the tools that are part of an SDK (adb, fastboot, etc.)
Make snod
Builds system image from currently available binaries
Make services
Creates the services JAR that contains all system services
Make runtime
Builds native code which serves as the glue between the Java-based Android framework and native stuff used for its functionality
Make droid
The default make
Make modules
Shows a list of all modules that can be built by using make <MODULE_NAME>
Make clean
Remove all built files (prepare for a new build). Same as rm -rf out/<configuration>
make all
make everything, whether it is included in the product definition or not

Helper macros and functions

There are some helper macros and functions that are installed when you source They are documented at the top of, but here is information about a few of them:
croot- change directory to the top of the tree
m - execute 'make' from the top of the tree (even if your current directory is somewhere else)
mm - builds all of the modules in the current directory
mmm <dir1> ... - build all of the modules in the supplied directories
cgrep <pattern> - grep on all local C/C++ files
jgrep <pattern> - grep on all local Java files
resgrep <pattern> - grep on all local res/*.xml files
godir <filename> - go to the directory containing a file

Speeding up the build

You can use the '-j' option with make, to start multiple threads of make execution concurrently.
Ex: make -j4

Thursday, October 9, 2014

System applications in Android framework

Android applications are two types.

1)      System applications
2)      User applications

System app is located under /system/app folder. System apps are granted the ability to request certain system-only permissions that are never available to user apps. 

The source code for all system applications are located at ANDROID_SRC/packages/. In this recipe, we will learn the significance of the most important packages at this location.

Navigate to the /packages directory under ANDROID_SRC/.
The following table summarizes the four top-level directories and the code they contain:
Directory  name
Contains code for Activity-based applications. Always contains a UI element.
Random tools maintained by Googlers. Contents may be archived without notice.
The sources for the three default IMEs (as per 2.3.4_r1), that is LatinIME, OpenWnn, and PinyinIME
Code for all major content providers including Contacts and SMS/MMS
Code for wallpapers that ship with the open source system

Now, we will learn the purpose of the most important directories under Apps and Providers.

Directories under /Apps:

Directory name
The frontend of the Android browser
The camera app
Frontend Contacts application
Application that lets you view images and videos on your SD card
The default launcher screen
MMS/SMS application
NFC control application including native library that interacts with NFC chip. Includes the NFC manager and Nfc service
The dialer application and call-answering UI
System settings and secure settings application

Directories under /Providers:
Directory name
Maintains a database of all installed applications
Code that maintains the Contacts datastore that is used by innumerable services on the device
Stores three types of data: SMS content, MMS content, and current network configuration

All of the above applications have a make file that is picked up by the Android built system during a full system build. The built APKs are packaged into system.img and during system bootup they are installed into the /system/app directory.