multithreading - Best practice to handle orientation change: Android

Question

I was going through various practices to handle orientation change with threads and AsyncTask. I came across following solutions:

1. Attach-detach model : Attaching and detaching activity to threads and AsyncTask while preserving their instance. (Source: 1, 2)

2. Headless fragment way : Using a non-UI/headless fragment to do all the thread related operations and retaining its instance on configuration change. (Source: 1, 2)

Are there any other approaches to handle this scenario? What is the recommended practice? I'm asking this because I couldn't find a generic solution anywhere in the Android docs.

Answer 1

Some summaries

There are several methods mentioned above that are good practices but I thought I might sum them up with short explanations. Below are some of the most popular libraries being used currently for http networking, asynchronous work / threading, and caching.

My current project (just preferences)

I personally am currently using Otto, Loaders, Volley, Ormlite, and a network stack based on Apache and Services. I do hope to replace, the network stack at some point with either Volley, Retrofit, and maybe eventually Robospice.

I personally very much like Otto and Volley

---

RoboSpice (Modular)

• https://github.com/octo-online/robospice
• http://www.youtube.com/watch?v=ONaD1mB8r-A
• a plugin / modular approach to long-running tasks
• this is like the "swiss-army-knife" of libraries, but you need to know what each tool does.
• Handles REST calls
• persists data through orientation and other changes
• can handle disk and memory caching )
• works with various HTTP libraries and persistence libraries (Gson, Jackson, Spring, OkHttp, and many of the below libraries)
• beta for Ormlite support, I think

Retrofit (REST)

• https://github.com/square/retrofit
• Annotation library to make REST very easy. Works with Robospice.

Volley (Networking data & Images)

• https://android.googlesource.com/platform/frameworks/volley
• https://developers.google.com/events/io/sessions/325304728
• This is the networking code that runs the Google Play Store
• Fast, reliable
• Handles most caching for you with some sensible defaults
• very easy to use
• built specifically for very fast image, json, etc loading
• Handles all threading for you.

Picasso (images)

• https://github.com/square/picasso
• Http library for loading images
• fast
• very easy to use

Loaders (Android)

• well supported
• persist through orientation change and save/load of fragment state
• can be difficult to get right
• no caching

AsyncTask (Android)

• simple way for background work from the UI thread
• must be canceled and be careful about tasks that return after an activity or fragment is torn down.

Otto (event bus)

• https://github.com/square/otto
• Event bus that makes a-sync work between components and fragments easy
• Very powerful @Produce ability retains the last event and can produce it on demand for any new interested subscribers to the bus

Headless Fragments (?)

• I personally have never seen this used other than Vogella's tutorials, so I'm not sure on this one.

Service (Android)

• The old school way
• ultimate control, you must do everything yourself
• usually used with Appache or HURL client and
• pass Parcels around via Intents