Android OS Versions

Android OS Versions


Android is the most popular mobile operating system developed by Google based on the Linux kernel and designed primarily for touch-screen mobile devices such as smartphones and tablet .The first commercial version   Android 1.0  was released in September 2008. Android has a great journey of 5 year and in this journey we see many updates in Android versions.

Continue reading Android OS Versions

AsyncTask: Always not the Best Choice

Anyone that has done any sort of Android Development knows about the AsyncTask. Many developers live and breath by it. However, it can’t solve every problem that requires asynchronous messaging.

An AsyncTask provides a few handy functions that allow it to update the UI whenever it’s done doing work. OnProgreesUpdateOnPreExecute, and OnPostExecute allow the AsyncTask to update the UI with whatever information it needs. These methods work great when developing an Android client, but what about a Library?
Continue reading AsyncTask: Always not the Best Choice

Tips for More Efficient Application Development

The best recipe for becoming a complete flop in Google Play is to release an app that is battery and memory hungry with a slow interface. Most likely, these qualities will ensure negative reviews from users and result in a bad reputation, even if your app has great design and a unique idea.

Every drawback in product efficiency, battery and memory consumption can really affect your app’s success. That’s why it is critical to develop well-optimized, smooth running apps that never make Android system guard against them. We will not speak about efficient coding, since it goes without saying that the code you write should stand any performance test. But even brilliant code takes time to run. In today’s post, we’ll talk about how to minimize this time and make Android apps that users love.

Efficient threading

Tip 1. How to off-load operations onto threads in background

Since by default all operations in an app run on the main thread (UI thread) in the foreground, the app responsiveness might be affected, which will imminently result in hangs, freezes and even system errors.

To reinforce responsiveness, you should shift long-running tasks (e.g. network or database operations, complex calculations) from an app’s main thread to a separate background thread. The most effective way to accomplish this task is at a class level. You can use AsyncTask class or IntentService class to organize background work. Once you have implemented an IntentService, it starts when needed and handles requests (Intents) using a worker thread.

When using IntentService, you should consider the following limitations:

  • This class does not put results to UI, so to show results to users use Activity.
  • Only one request is processed at a time.
  • Any request processing can not be interrupted.

Tip 2. How to avoid ANR and stay responsive

The same approach of off-loading long-running operations from the UI thread will save your users from the “Application Not Responding” (ANR) dialog. What you need to do is to create a background worker thread by extending AsyncTask and implementing doInBackground() method.

Another option is to create a Thread or HandlerThread class of your own. Keep in mind that unless you specify “background” priority for the thread, it will slow down the app since the default thread priority is the same as of the UI thread.

Tip 3. How to initiate queries on separate threads

Displaying data is not immediate, although you can fasten it by using CursorLoader objects, which allows not to distract Activity from interacting with a user while query is processing in the background.

Armed with this object your app would initiate a separate background thread for each ContentProvider query and return results to Activity from which the query was called only when the query is finished.

Tip 4. What else you can do

  • Use StrictMode to detect potentially lengthy operations you do in the UI thread.
  • Use special tools, i.g. Systrace, Traceview, to find bottlenecks in your app responsiveness.
  • Show progress to users with a progress bar.
  • Display splash screens if initial setup is time-consuming.

Device battery life optimization

We cannot blame users for angrily uninstalling applications that abuse battery life. The main threats to battery life are:

  • Regular wake-ups for updates
  • Data transfer via EDGE and 3G
  • Textual data parsing, regex without JIT

Tip 5. How to optimize networking issues

  1. Make your app skip operations if there is no connection; update only if 3G or WiFi is connected and there is no roaming.
  2. Choose compact data format, e.g. binary formats that combine text and binary data into one request.
  3. Use efficient parser; consider choosing stream parsers over tree parsers.
  4. For faster UX lessen round-trip times to server.
  5. When possible use framework GZIP libs for text data to make the best use of CPU resources.

Tip 6. How to optimize apps working in foreground

  1. When designing wakelocks, set the lowest level possible.
  2. To avoid battery costs caused by potential bugs you might have missed, use specific timeouts.
  3. Enable android:keepScreenOn.
  4. In addition to GC (garbage collection) consider recycling Java objects manually, e.g. XmlPullParserFactory and BitmapFactory; Matcher.reset(newString) for regex; StringBuilder.setLength(0).
  5. Mind synchronization issues, although it can be safe when driven by UI thread.
  6. Recycling strategies are used heavily in ListView.
  7. Use coarse network location not GPS when possible. Just compare 1mAh for GPS (25 sec. * 140mA) and 0.1mAh for network (2 seconds * 180mA).
  8. Make sure to unregister as GPS location updates can continue even after onPause(). When all applications unregister, users can enable GPS in Settings without blowing the battery budget.
  9. Since the calculation of a floating point requires lots of battery power, you might consider using microdegrees for bulk geo math and caching values when performing DPI tasks with DisplayMetrics.

Tip 7. How to optimize apps working in background

  1. Since each process requires 2MB and might be restarted when foreground apps need memory, make sure the services are short-lived.
  2. Keep memory usage low.
  3. Design app to update every 30 minutes but only if device is already awake.
  4. Services that pall or sleep are bad, that is why you should use AlarmManager or <receiver> manifest elements: stopSelf() when finished. When you start service using AlarmManager, apply the *_WAKEUP flags with caution. Let Android bin your application update together with the rest through setInexactRepeating(). When using <receiver>, enable/disable its components in manifest dynamically, especially when no-ops.

Tip 8. What else you can do

  • Check current states of battery and network before launching a full update; wait for better states for bulk transfers.
  • Provide users with battery usage options, e.g. update intervals and background behavior.

Implementing UI that leaves minimum memory footprints

Tip 9. How to identify layout performance problems

When creating UI sticking solely to basic features of layout managers, you risk to create memory abusing apps with annoying delays in the UI. The first step to implementation of a smooth, memory caring UI is to search your application for potential layout performance bottlenecks with Hierarchy Viewer tool included into Android SDK: <sdk>/tools/.

Another great tool for discovering performance issues is Lint. It scans application sources for possible bugs along with view hierarchy optimizations.

Tip 10. How to fix them

If layout performance results reveal certain drawbacks, you might consider to flatten the layout by converting it from LinearLayout class to RelativeLayout class, lowing level hierarchy.

To perfection and beyond

Even though each tip mentioned above might seem like a rather small improvement, you might see unexpectedly efficient results if these tips become an essential part of your daily coding. Let Google Play see more brilliant apps that work smoothly, quickly, and consume less battery power, bringing the Android world one more step closer to perfection.

How to create great launcher icons in five easy steps

Creating great launcher icons quick and easy!

Some stuff you need to know

All apps need a launcher icon.

Our apps may run on devices with different screen sizes and densities so we’ll need different size icons.

Android has created 5 buckets for the different screen densities:

Screen density Required Icon sizes folder
Medium 48 x 48 drawable-mdpi
High 72 x 72 drawable-hdpi
Extra High 96 x 96 drawable-xhdpi
Extra-Extra-High 144 x 144 drawable-xxhdpi
Extra-Extra-Extra High 192 x 192 drawable-xxxhdpi


There is also a low density bucket but there’s no need to worry about that as Android will scale down the high density icon for this.

Continue reading How to create great launcher icons in five easy steps

Master Notifications: Some stuff you should know.

Notification icon

Master the basics of Android notifications

Notifications inform the user about something. They appear in the Notification area at the top of the screen.

The Notification area

Notification area

Here are a couple of examples:

  • The battery is getting low
  • An email has arrived
  • Your file download is complete

Users can read them whenever the like. They just drag the notification drawer down to open it.

Continue reading Master Notifications: Some stuff you should know.

15 quirky Android XML layout parameters to know

15 quirky Android XML layout parameters to know

After working on Android widgets for the last two years I’ve learned a lot about limitations, inconsistencies, and ghostly parameters in Android XML layout files. Some parameters are simply “overly clever” so I’ll offer some standard settings you should use.

These come in handy so take a moment to review. Continue reading 15 quirky Android XML layout parameters to know

Android Development Tools

Hello All,

Here are few important android development tools

1] XAppDbg: XAppDbg is an app development tool that can be used to change parameters in your code during runtime. This can save you a lot of time, since you don’t have to build and run your application for each small change. Go to the XAppDbg page to download and learn more about this open sourced tool.
Read More
Continue reading Android Development Tools

Android vs iOS guide for newbies

In tech years, the iOS vs. Android argument seems like it is half a century old and has stretched the limits of human tolerance for passive-aggressive retorts. Since 2008 the ongoing comparisons between these operating systems have been in the spotlight because of the growing Android market and the possible iOS expectation that everything be done through Apple and with Apple products.

Continue reading Android vs iOS guide for newbies

Dissect layouts using Android’s Hierarchy View

Wouldn’t it be great if when you came across a user interface (UI) that really works you could get a behind-the-scenes look at the blueprints that brought together all those layouts, widgets, and views in such an ideal manner? Well guess what? You can do so, and I highly recommend you get into the habit of it.

Continue reading Dissect layouts using Android’s Hierarchy View