Developer Friendly Android Libraries

         Developer-friendly Android Libraries

Hi Guys,
Here is my list of favorite libraries, which I believe can save you some precious time while developing applications and ensure they are good-looking and user-friendly and they will provide the best smartphone application experience to end users.

Rajawali:

Rajawali is a 3D engine for Android based on OpenGL ES 2.0/3.0. It can be used for normal apps as well as live wallpapers.

This is one of my favorites. As you know I am Android Applications and Games Developer I really recommend this one. If you are thinking of developing live wallpapers or 3D games, this library might be very handy. One can easily export the 3D models from tools like Blender and render them on the devices using openGLES with this library. Adding animations like rotation, or scaling on user events is a cakewalk

Download it here: https://github.com/MasDennis/Rajawali

ActionBar Sherlock:

This one deserves to be at the top of the list. Action-bar was introduced in API-11 of the Android SDK and the support library by Google does not provide a proper backport. 

The library will automatically use the native action bar when appropriate or will automatically wrap a custom implementation around your layouts. This allows you to easily develop an application with an action bar for every version of Android from 2.x and up. It works seamlessly with newer views such as NavigationDrawer, SlidingPaneLayout, Fragments, etc.

Download it here: http://actionbarsherlock.com
How to use: http://actionbarsherlock.com/usage.html

RoboGuice 2:

RoboGuice 2 smoothes out some of the wrinkles in your Android development experience and makes things simple and fun. Do you always forget to check for null when you getIntent().getExtras()? RoboGuice 2 will help you. Think casting findViewById() to a TextView shouldn’t be necessary? RoboGuice 2 is on it.RoboGuice 2 takes the guesswork out of development. Inject your View, Resource, System Service, or any other object, and let RoboGuice 2 take care of the details.RoboGuice 2 slims down your application code. Less code means fewer opportunities for bugs. It also makes your code easier to follow -- no longer is your code littered with the mechanics of the Android platform, but now it can focus on the actual logic unique to your application.

Download it here: https://github.com/roboguice/roboguice

GSON:

Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object. Gson can work with arbitrary Java objects including pre-existing objects that you do not have source-code of.This is a powerful and lightweight JSON parser, specifically for Android. If you have a Web-service returning JSON, use jsonschema2pojo.org  (or some other similar tool) to generate the POJOs, and with a single line of code, you can parse the JSON using this library. Use GSON along with ActiveAndroid and you can reduce the development time considerably.

Gson Goals:

1. Provide simple toJson() and fromJson() methods to convert Java objects to JSON and vice-versa
2. Allow pre-existing unmodifiable objects to be converted to and from JSON
3. Extensive support of Java Generics
4. Allow custom representations for objects
5. Support arbitrarily complex objects (with deep inheritance hierarchies and extensive use of generic types)

Download it here: http://code.google.com/p/google-gson/

ActiveAndroid:

ActiveAndroid is an active record style ORM (object relational mapper). What does that mean exactly? Well, ActiveAndroid allows you to save and retrieve SQLite database records without ever writing a single SQL statement. Each database record is wrapped neatly into a class with methods like save() and delete(). This is a simple ORM solution for your applications. It is as easy as creating objects and saving them to the SQLite database. The setup of classes makes use of Java annotations. This saves a whole lot of time on configurations, and gives the developer more time to spend on the login than on the syntaxes. Once used, you will find it hard to live without it.

Download it here: https://github.com/pardom/ActiveAndroid

ViewPagerIndicator:

This is another cool library from the developer of Actionbar. It makes the viewpager more usable and enables easier navigation between fragments. Users have a clear idea of where they have navigated.
Features:

1. New IconPageIndicator! Uses state-list images to represent pages.
2. TabPageIndicator now supports icons via IconPagerAdapter interface.
3. Support android:background attribute on Canvas-based views.
4. Title indicator allows for drawing its line, underline, and/or triangle on top of the titles for placement underneath a ViewPager.
5. Tab indicator now supports ICS-style dividers (see styled sample).

Download it here: http://viewpagerindicator.com/

Crouton:

Crouton is a class that can be used by Android developers that feel the need for an alternative to the Context insensitive Toast.

A Crouton will be displayed at the position the developer decides. Standard will be the top of an application window. You can line up multiple Croutons for display, that will be shown one after another. It is nicely implemented and highly customizable. It gives your application a notification system which is cleaner and more aesthetic than native toasts, and is rightly named croutons.

Download it here: https://github.com/keyboardsurfer/Crouton

Universal Image Loader:

Handling large bitmaps does gives nightmares to many Android developers. The Universal Image Uploader is a lightweight library which saves you the effort of handling bitmaps and provides great support for caching images. One can easily figure out how to decode the bitmaps in the app. Definitely a lifesaver of a library.
Features:

1. Multithread image loading
2. Possibility of wide tuning ImageLoader's configuration (thread executors, downloader, decoder, memory and disc cache, display image options, and others)
3. Possibility of image caching in memory and/or on device's file system (or SD card)
4. Possibility to "listen" loading process
5. Possibility to customize every display image call with separated options
6. Widget support
7. Android 2.0+ support

Download it here: https://github.com/nostra13/Android-Universal-Image-Loader

AChartEngine:

This plots neat and elegant graphs in various styles. The javadocs might not be great, and it might not be all that easy to develop with only a few resources available and a large number of classes, but the output is definitely worth the effort.

Download it here: http://www.achartengine.org/

Robotium:

Robotium is an Android test automation framework that has full support for native and hybrid applications. Robotium makes it easy to write powerful and robust automatic black-box tests for Android applications. With the support of Robotium, test case developers can write function, system and acceptance test scenarios, spanning multiple Android activities. This is an automation testing framework for Android. Developers and testers can generate test cases and ensure that minor changes do not introduce new bugs. It might seem to be an overhead in the early stages of development but helps keep maintenance work easy.

Download it here: http://code.google.com/p/robotium/

ZXing:

ZXing ("zebra crossing") is an open-source, multi-format 1D/2D barcode image processing library implemented in Java, with ports to other languages.This quickly adds support for scanning bar codes in an Android application. Easy to configure and use. It has a high scanning efficiency.

Download it here: https://github.com/zxing/zxing OR http://code.google.com/p/zxing/

Tesseract:

Tesseract is probably the most accurate open source OCR engine available. Combined with the Leptonica Image Processing Library it can read a wide variety of image formats and convert them to text in over 60 languages. It was one of the top 3 engines in the 1995 UNLV Accuracy test. Between 1995 and 2006 it had little work done on it, but since then it has been improved extensively by Google.
Tesseract is a highly optimized optical character reader library available for Android. This is a cross-platform library and will require some basic knowledge of using NDK in an Android app.

Download it here: http://code.google.com/p/tesseract-ocr/

So these are my favorite developer friendly android libraries which are used in industry by many developers, I do use many of them and I listed them here by asking many of my friends who develops android apps & games that what they prefer to use.
If you think something is missing out of this list just point out I would love to include it as well.

    Hope this will help you guys a lot... Stay tuned for next article!

Read More...

What is Android Architecture?

                                  Android Architecture

Hi folks,
In our previous Android Tutorials, we have discussed quite a few concepts of Android development.
We have successfully set up android development environment in our last tutorial; I think that it is time to start with Android Architecture before starting basic android programing we must be aware of android architecture and layer's in android stack .

So lets take a take a quick walk through of the Android Architecture.

Android Architecture: Layers in the Android Stack

The Android stack, as the guys over at Google call it, has a number of layers, and each layer groups together several programs. In this tutorial I’ll walk you through the various layers in Android stack and the functions they are responsible for.

Following are the different layers in the Android stack:

1. Linux Kernel Layer
2. Libraries Layer
3. Application Framework Layer
4. Applications layer

Kernel Layer:

The basic layer is the Linux kernel. The whole Android OS is built on top of the Linux 2.6 Kernel with some further architectural changes made by Google. It is this Linux that interacts with the hardware and contains all the essential hardware drivers.

At the bottom of the Android stack is the Linux Kernel. It never really interacts with the users and developers, but is at the heart of the whole system. Its importance stems from the fact that it provides the following functions in the Android system:

• Hardware Abstraction
• Memory Management Programs
• Security Settings
• Power Management Software
• Other Hardware Drivers (Drivers are programs that control hardware devices.)
• Support for Shared Libraries
• Network Stack

As the Android is built on a most popular and proven foundation, it made the porting of Android to variety of hardware, a relatively painless task.

Libraries Layer

The next layer in the Android architecture includes Android’s native libraries. Libraries carry a set of instructions to guide the device in handling different types of data. For instance, the playback and recording of various audio and video formats is guided by the Media Framework Library.
This layer enables the device to handle different types of data. These libraries are written in c or c++ language and are specific for a particular hardware.

Some of the important native libraries include the following:

Surface Manager: It is used for compositing window manager with off-screen buffering. Off-screen buffering means you cant directly draw into the screen, but your drawings go to the off-screen buffer. There it is combined with other drawings and form the final screen the user will see. This off screen buffer is the reason behind the transparency of windows.

Media framework: Media framework provides different media codecs allowing the recording and playback of different media formats.

SQLite: SQLite is the database engine used in android for data storage purposes.

WebKit: It is the browser engine used to display HTML content.

OpenGL & SGL: Used to render 2D or 3D graphics content to the screen.

Free Type: Font Rendering.

Open SSL

Android Runtime

Android Runtime consists of Dalvik Virtual machine and Core Java libraries.

Dalvik Virtual Machine

It is a type of JVM used in android devices to run apps and is optimized for low processing power and low memory environments. Unlike the JVM, the Dalvik Virtual Machine doesn’t run .class files, instead it runs .dex files. .dex files are built from .class file at the time of compilation and provides hifger efficiency in low resource environments. The Dalvik VM allows multiple instance of Virtual machine to be created simultaneously providing security, isolation, memory management and threading support. It is developed by Dan Bornstein of Google.

Core Java Libraries
These are different from Java SE and Java ME libraries. However these libraries provides most of the functionalities defined in the Java SE libraries.

Application Framework Layer

Android applications directly interact with these blocks of the Android architecture. These programs manage the basic functions of phone like resource management, voice call management etc.

Important blocks of Application framework are:

Activity Manager: Manages the activity life cycle of applications.

Content Providers: Manage the data sharing between applications.

Telephony Manager: Manages all voice calls. We use telephony manager if we want to access voice calls in our application.

Location Manager: Location management, using GPS or cell tower.

Resource Manager: Manage the various types of resources we use in our Application.

Application Layer

The applications is the topmost layer of the Android stack. An average user of the Android device would mostly interact with this layer (for basic functions, such as making phone calls, accessing the Web browser etc.) and this is where our applications are gonna fit. Several standard applications comes pre-installed with every device, such as:

• SMS client app
• Dialer
• Web browser
• Contact manager
• Games etc.

As a developer we are able to write an app which replace any existing system app. That is, you are not limited in accessing any particular feature. You are practically limitless and can whatever you want to do with the android (as long as the users of your app permits it). Thus Android is opening endless opportunities to the developer.

I hope you are clear with the basic Android architecture now! So, in next tutorial we will see what are the android app components. So, Stay tuned for more android development tutorials.

This tutorial has been written with an aim to teach you and explore a little bit about what is android architecture. #Some of Stats/Info mentioned in this post are taken from Wikipedia. They are subjected to changes as android technology is growing very fast.

Read More...

How to Set up an Android Development Environment

How to Set up an Android Development Environment

Hello Guys,
Welcome back to my second tutorial on android application development series as promised in last tutorial, we will take a look at Ho to set up an android development environment.
Android is based on the Java development language and any beginner-level Java developer can jump right in and start developing applications.
The purpose of this guide is to outline in detail the steps necessary to set up the initial development environment for creating Android applications. The guide will address the installation of the Android Software Development Kit (SDK) and the initial set-up necessary for allowing Android OS emulation.

Most preferred operating systems which are used for development:

• Microsoft Windows XP or later version.
• Mac OS X 10.5.8 or later version with Intel chip.
• Linux including GNU C Library 2.7 or later.

Second thing is that all the required tools to develop Android applications are available at free of cost and can be downloaded from the Web. Following is the list of software's you will need before you start your Android application programming.

• Java JDK5 or JDK6
• Android SDK
• Eclipse IDE for Java Developers (optional)
• Android Development Tools (ADT) Eclipse Plugin (optional)

So let us have a look how to proceed to set required environment.

Steps:

1. Download an IDE:

For the purpose of this example, will be using Eclipse. You can download the latest version of the software here: http://www.eclipse.org/downloads/packages/release/indigo/r.
You must choose the version that corresponds to your OS of choice. Install Eclipse. Make sure to take note of the installation directory and workspace for later reference.

2. Download and install the Java Runtime Environment (JRE).

You can find the download file here: http://www.oracle.com/technetwork/java/javase/downloads/jre-6u25-download-346243.html.

3. Install the Android SDK:

• The SDK starter package includes the Android SDK and AVD Manager. This is a tool that we will now use to download some required SDK components into our development environment.
• The starter package we downloaded only contains the newest version of the SDK tools. In order to develop Android applications, we will need to download at least one Android platform so we can emulate a phone/tablet via our computer hardware.
• In the root of the SDK directory, find and execute the SDK Manager.exe file. Note: Right-click and run as administrator to avoid any permission declination.

4. Download and Install the Android Development Tools (ADT) plugin for Eclipse

• Google provides a custom plugin for Eclipse, called ADT, that aids developers in creating Android applications faster and more efficiently.
• Open Eclipse and select Help and Install New Software

• Click Add
• In the pop-up dialog, type 'ADT Plugin' in the Name field and enter the following URL in the location field: https://dl-ssl.google.com/android/eclipse/

Now select all the listed plug-ins using Select All button and click Next button which will guide you ahead to install Android Development Tools and other required plugins.

5 - Create Android Virtual Device

Well last to test your Android applications you will need a virtual Android device. So before we start writing our code, let us create an Android virtual device. Launch Android AVD Manager using Eclipse menu options: Window > AVD Manager> which will launch Android AVD Manager. Use New button to create a new Android Virtual Device and enter the following information, before clicking Create AVD button.

If your AVD is created successfully it means your environment is ready for Android application development. Better you re-start your machine and once you are done with this last step, you are ready to proceed for your first Android example but before that we will see few more important concepts related to Android Application Development, in our next tutorial named: What is Android Architecture?

This tutorial has been written with an aim to teach you Set up an Android Development Environment. #Some of Stats/Info mentioned in this post are taken from Wikipedia. They are subjected to changes as android technology is growing very fast.

.

Read More...