http://nanocr.eu/ - Google’s mismanagement of the Android Market
Android offers several ways to access the UI thread from other threads. You may already be familiar with some of them but here is a comprehensive list: * Activity.runOnUiThread(Runnable) * View.post(Runnable) * View.postDelayed(Runnable, long) * Handler AsyncTask is The goal of AsyncTask is to take care of thread management for you. Whenever you first start an Android application, a thread called "main" is automatically created. The main thread, also called the UI thread, is very important because it is in charge of dispatching the events to the appropriate widgets and this includes the drawing events. It is also the thread you interact with Android widgets on. For instance, if you touch the a button on screen, the UI thread dispatches the touch event to the widget which in turn sets its pressed state and posts an invalidate request to the event queue. The UI thread dequeues the request and notifies the widget to redraw itself. This single thread model can yield poor performance in Android applications that do not consider the implications. Since everything happens on a single thread performing long operations, like network access or database queries, on this thread will block the whole user interface. No event can be dispatched, including drawing events, while the long operation is underway. From the user's perspective, the application appears hung. Even worse, if the UI thread is blocked for more than a few seconds (about 5 seconds currently) the user is presented with the infamous "application not responding" (ANR) dialog.
Android offers several ways to access the UI thread from other threads. You may already be familiar with some of them but here is a comprehensive list: * Activity.runOnUiThread(Runnable) * View.post(Runnable) * View.postDelayed(Runnable, long) * Handler AsyncTask is The goal of AsyncTask is to take care of thread management for you. Whenever you first start an Android application, a thread called "main" is automatically created. The main thread, also called the UI thread, is very important because it is in charge of dispatching the events to the appropriate widgets and this includes the drawing events. It is also the thread you interact with Android widgets on. For instance, if you touch the a button on screen, the UI thread dispatches the touch event to the widget which in turn sets its pressed state and posts an invalidate request to the event queue. The UI thread dequeues the request and notifies the widget to redraw itself. This single thread model can yield poor performance in Android applications that do not consider the implications. Since everything happens on a single thread performing long operations, like network access or database queries, on this thread will block the whole user interface. No event can be dispatched, including drawing events, while the long operation is underway. From the user's perspective, the application appears hung. Even worse, if the UI thread is blocked for more than a few seconds (about 5 seconds currently) the user is presented with the infamous "application not responding" (ANR) dialog.
AsyncTask must be used by subclassing it. It is also very important to remember that an AsyncTask instance has to be created on the UI thread and can be executed only once. You can specify the type, using generics, of the parameters, the progress values and the final value of the task * The method doInBackground() executes automatically on a worker thread * onPreExecute(), onPostExecute() and onProgressUpdate() are all invoked on the UI thread * The value returned by doInBackground() is sent to onPostExecute() * You can call publishProgress() at anytime in doInBackground() to execute onProgressUpdate() on the UI thread * You can cancel the task at any time, from any thread Example: public void onClick(View v) { new DownloadImageTask().execute(" http://example.com/image.png "); } private class DownloadImageTask extends AsyncTask { protected Bitmap doInBackground(String... urls) { return loadImageFromNetwork(urls[0]); } protected void onPostExecute(Bitmap result) { mImageView.setImageBitmap(result); } }
IntentService is a base class for Service s that handle asynchronous requests (expressed as Intent s) on demand. Clients send requests through startService(Intent) calls; the service is started as needed, handles each Intent in turn using a worker thread, and stops itself when it runs out of work. This "work queue processor" pattern is commonly used to offload tasks from an application's main thread. The IntentService class exists to simplify this pattern and take care of the mechanics. To use it, extend IntentService and implement onHandleIntent(Intent) . IntentService will receive the Intents, launch a worker thread, and stop the service as appropriate. All requests are handled on a single worker thread -- they may take as long as necessary (and will not block the application's main loop), but only one request will be processed at a time.
AsyncTask must be used by subclassing it. It is also very important to remember that an AsyncTask instance has to be created on the UI thread and can be executed only once. You can specify the type, using generics, of the parameters, the progress values and the final value of the task * The method doInBackground() executes automatically on a worker thread * onPreExecute(), onPostExecute() and onProgressUpdate() are all invoked on the UI thread * The value returned by doInBackground() is sent to onPostExecute() * You can call publishProgress() at anytime in doInBackground() to execute onProgressUpdate() on the UI thread * You can cancel the task at any time, from any thread Example: public void onClick(View v) { new DownloadImageTask().execute(" http://example.com/image.png "); } private class DownloadImageTask extends AsyncTask { protected Bitmap doInBackground(String... urls) { return loadImageFromNetwork(urls[0]); } protected void onPostExecute(Bitmap result) { mImageView.setImageBitmap(result); } }
AsyncTask must be used by subclassing it. It is also very important to remember that an AsyncTask instance has to be created on the UI thread and can be executed only once. If you don't implement these patterns, it is good to start thinking about them, so you can design your own UIs to closely match the Google recommended patterns (the apps consistent with the general feel of the OS, can feel better, and more integrated).
One of the most important intents we added to Twitter for Android was the ability to sync your Twitter contacts into the phone. This integration also allowed us to give Twitter users with an Android phone the use of the QuickContact widget, which gives users a choice of ways to contact their followers. We recommend: Using this activity upon first signing into an application. If your app has no sign-in, showing this screen at first launch to improve discoverability of contact sync. The good news for developers is you get this highly functional contacts feature for free if users choose to sync contact information into your app. QuickContact for Android provides instant access to a contact's information and communication modes. For example, a user can tap a contact photo and with one more tap launch a call, SMS, or email to that person. Other applications such as Email, Messaging, and Calendar can also reveal the QuickContact widget when you touch a contact photo or status icon.
The dashboard pattern serves as a home orientation activity for your users. It is meant to include the categories or features of your application. We recommend including an Action bar on this screen as well. The dashboard can be static or dynamic. For example, in the case of our dashboard for Twitter, we used the goodness of Live Wallpapers introduced in 2.1 to create an animated dashboard complete with real-time trend bubbles and the Twitter bird silhouette. We recommend: Using this pattern to showcase the most prominent features of your app. Adding some unexpected delight to this screen, making it engaging without overwhelming the user. Exercising caution - for some apps, the user will want to jump directly into the meat of the application. For others, this sort of welcoming dashboard will be the right starting place.
Great place to brand – and use Logo as link to home (consistent with web feel) The Action bar gives your users onscreen access to the most frequently used actions in your application. We recommend you use this pattern if you want to dedicate screen real estate for common actions. Using this pattern replaces the title bar. It works with the Dashboard, as the upper left portion of the Action bar is where we recommend you place a quick link back to the dashboard or other app home screen. We recommend: Placing an Action bar at the top of the screen to house the most common actions for your application that work across all activities. Using no more than 3 onscreen actions for the Action bar. Use the main menu as overflow for actions that are less important. The balance between Action bar and main menu will ensure the richness of interaction that is Android. Making the left-hand region actionable, offering one-touch return to your dashboard or other app home.
The companion widget pattern is something we recommend all developers think about deeply. The widget you create should be more than a big button link into your app. Used correctly, it can provide a place on a home screen that personalizes, albeit in a small window, your application. In the case of Twitter for Android, we designed and built small and large-sized widgets to support different types of functionality. Both widgets let a user view his/her tweetstream. However, the smaller widget hands off to the application to create a reply to a tweet from the stream, whereas the larger one gives direct access to the Tweet compose activity. We recommend: Identify your application in the widget with a brand icon Make this more than a button into your app. Give your user an action or view into the app itself. Keep the activity stateful so that on exiting the application and re-entering a user is returned to the same context in the activity, minimizing the impact of using the dashboard if it is used.
QuickActions is our newest UI pattern. Currently, it has been implemented as a fast, engaging, popup triggered by an onscreen UI element that identifies it in as minimally disruptive way as possible. We recommend you use this pattern for list views that are data intensive where items inside the list have contextual actions associated with them. QuickActions can be used as a replacement for our traditional dialog invoked by long press. By choosing to use this pattern as part of a list, we made it easier for Twitter users to take action on the information in the list view by keeping the item and associated actions in context. We also took the extra step of making it easier to target links in list views by turning off the list view button element as a secondary component to making this pattern even more usable. This way users of Twitter for Android can view links with one tap and/or see the posted tweet on a map by tapping the tweet meta data directly. We recommend: Creating a UI element that is minimal and recognizable as an action popup; either a frame around an image or an icon in a list item. Only using this pattern in applications where the data is intensive. Placing the action popup below or above the information you wish to allow users to take relevant contextual actions on. This will make it easier to associate the actions with the content in view. Turning off the entire list view button element so that regions can be easily targeted for the user.
![Best Practices – Why? ,[object Object],[object Object],[object Object],[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)