android design considerations: AsyncTask vs Service (IntentService?)
android, android-asynctask, android-intentservice, background-process
Solution
In my opinion this is the most tricky/hard part of a mainstream/average Android development. For instance on BlackBerry this is IN TIMES easier.
Definitely you need to use a `Service`.
`AsyncTask` does not suit, because it is tightly "bound" to your `Activity` via a `Context` handle (otherwise you would not be able to update UI of the `Activity` from your `AsyncTask`). However an `Activity` can be killed by OS once the `Activity` went in background. An example reason of going to background can be an incoming call - user switches to Phone application so your `Activity` becomes invisible. In this case (depending on the current RAM state) OS may decide to kill one of the background (invisible to the user) activities.
Some devs workaround this by arranging a static stuff for having a long-running actions inside of. Some recommend to use `Application` instance. This is because static stuff and `Application` exist while the whole app process exists. However those are incorrect workarounds. Processes in Android are also may be killed when OS decides it is time to. Android OS have its own considerations about what it can kill and in what order. All processes are devided to 5 levels of "killability". Here is the doc where those levels are specified. It is interesting to read there:
Because a process running a service is ranked higher than one with background activities, an activity that initiates a long-running operation might do well to start a service for that operation, rather than simply spawn a thread — particularly if the operation will likely outlast the activity. Examples of this are playing music in the background and uploading a picture taken by the camera to a web site. Using a service guarantees that the operation will have at least "service process" priority, regardless of what happens to the activity.
Your `Activity` where users initiate a long-running action should show a `ProgressDialog` to make sure user does not do anything else while the action is running. The guide is here.
Also, you'd most likely want to use the `NotificationManager` for notifying the user about your long-running action completion (or failure) if your `Activity` is currently invisible. Here is the NotificationManager info to start from.
Problem
I'm designing an android app which will need to do the following steps: - user pushes a button or otherwise indicates to "sync data". - sync process will use REST web services to move data to and from the server. - the data will be stored locally in a sqlite database. - the sync process should provide status updates/messages to the UI - the user should not be allowed to wander off to other parts of the application and do more work during the sync process. The first time the sync process runs, it may take 10-20 minutes. After the initial sync, less data will be transferred and stored and I expect the process to take 1-2 minutes or less. I've been doing a lot of reading about android's `AsyncTask` and various examples of using a Service ... But I don't fully understand the design considerations and trade-offs of choosing one design over the other. I currently have my demo project stubbed out using an AsyncTask. After watching (most of) Developing Android REST client applications: http://code.google.com/events/io/2010/sessions/developing-RESTful-android-apps.html# I'm left confused the design patterns described here feel overly complex, perhaps because I just "don't get it" yet. I come from a java, spring, web and desktop application background. Thinking and designing in terms of a handheld device is quite new to me. (What happens when the screen layout is changed? What happens when the phone rings while I'm running a sync?) Taking 2 steps back, if the initial sync IS going to be such a long running process, is there a better way for me to think about the problem->solution, the user experience, the user expectations of an application running on a phone? Would love to hear from some more experienced android developers out there who have already wrestled with these questions.