I have an AsyncTask which which takes an ArrayList of music files to play. In the doInBackground method, I loop through the ArrayList and play the songs one-by-one. I'd like to put a status message on a TextView of the UI or something to indicate which song is playing, but getting the error Only the original thread that created a view hierarchy can touch its views. If I only update the UI widgets from onPreExecute() and onPostExecute() the list has already been played. Is there a way to use onProgressUpdate or other AsyncTask method to do this?
This is certainly possible. Here's a basic example if you had Strings you wanted to display for song name, album name, and artist name (I haven't fully implemented the AsyncTask, just the parts relevant to onProgressUpdate):
private class myAsyncTask extends AsyncTask<Void, String, Void>
{
protected Void doInBackground(Void... voids)
{
//Get some list of songs, named songs
for(Song song in songs)//This is the loop where you're playing your songs
{
publishProgress(song.name, song.album, song.artist);
//Play the song and wait for it to finish
}
return null;
}
protected void onProgressUpdate(String... songData)
{
//Assuming three text views exist to display your data
nameTextView.setText(songData[0]);
albumTextView.setText(songData[1]);
artistTextView.setText(songData[2]);
}
}
The important things to note are the the second class in the angle brackets is the type of parameters for onProgressUpdate, and that publishProgress gets called in doInBackground to trigger onProgressUpdate. Most examples that you'll find for onProgressUpdate involve increasing the fill on a ProgressBar, but the method runs on the UI thread and can interact with any Views that can be accessed by your AsyncTask. If you're still having some trouble, post your current AsyncTask so that it'll be easier to help integrate this example class into what you already have. Here are the docs for AsyncTask for more information.Hope this helps!
You should be able to use onProgressUpdate() to perform the update from the UI thread. Or, you could do it like this (which is typical when not using AsyncTask).
Post an event on the UI thread that updates your UI like this:
view.post( new Runnable() {
#Override
public void run() {
// Update your UI
}
});
It will be running on the UI thread so it can access and update the view.
Yes there is.
When you decalre your AsyncTask, you decalre the types that go into each part of the task:
public class MyTask extends AsyncTask<URL,Integer,Long> {
.
.
.
}
The types in order, for this example:
URL gets passed to doInBackground via execute
Integer gets to onProgressUpdate (via publishProgress)
Long gets to onPostExecute, also the return value of doInBackground
In your doInBackground(), you can call publishProgress(), which will in turn call onProgessUpdate() on the main thread (assuming you created your AsyncTask on the main thread).
There is a complete example in the reference docs under Usage (link).
Related
How to keep UI thread waiting until i get data from AsyncTask.
i trying to load some information and image from server and display it into textview and imageview respectively. But UI thread access the field before background thread complete its task. So null value is retrieved and application get crashed.
You can update the UI in onPostExecute of AsyncTask after doing your background tasks.
For the crash, by accessing the field on UI thread => You need to shift this code also to the onPostExecute method.
So the required data will be available, the field will have a value.
So the crash issue can be resolved.
If you are building an application that basically scrapes the html source and then you manipulate this "string", what you can do is
private class Scrapper extends AsyncTask<String, Void, Void> {
#Override
protected Void doInBackground(String... params) {
//Get the source here
}
Then in the onCreate Method
Scrapper scrapper = new Scrapper();
String URLSource = scrapper.execute("url here").get();
//Additional code to manipulate the string
However it is generally not recommended to do it this way, since apparently it will put the entire UI Thread on hold and there will be a long delay if the source is large.
I am using this following code for getting all songs stored in the sdcard.
https://stackoverflow.com/a/12227047/2714061
Well why does this code take so long to return this list of songs.
I have included this code in a function which is called from the oncreate method in my player's playlist.
This is what happens.
1: When the application runs is executed for the first time on my android ph, the playlist has nothing to show, and hence is seen empty.
2: Well after for instance-> 30sec when I again call for the playlist it returns instantly all the songs.
Hence, giving the feel as though this thing takes time to execute?
Why does this happen?
How about using an asynchronous task, reading a file or downloading something, takes time that requires the user to wait, you must think of using an Asynchronous task for this purpose,
1: From the developer reference we have :
AsyncTask enables proper and easy use of the UI thread. This class allows to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers. http://developer.android.com/reference/android/os/AsyncTask.html
An asynchronous task is defined by 3 generic types, called Params, Progress and Result, and 4 steps, called onPreExecute, doInBackground, onProgressUpdate and onPostExecute.
2: So you may include an Async task class as:
class DoBackgroundTask extends AsyncTask<URL, Void, ArrayList> {
/*
URL is the file directory or URL to be fetched, remember we can pass an array of URLs,
Void is simple void for the progress parameter, you may change it to Integer or Double if you also want to do something on progress,
Arraylist is the type of object returned by doInBackground() method.
*/
#Override
protected ArrayList doInBackground(URL... url) {
//Do your background work here
//i.e. fetch your file list here
return fileList; // return your fileList as an ArrayList
}
protected void onPostExecute(ArrayList result) {
//Do updates on GUI here
//i.e. fetch your file list from result and show on GUI
}
#Override
protected void onProgressUpdate(Integer... values) {
// Do something on progress update
}
}
//Meanwhile, you may show a progressbar while the files load, or are fetched.
This AsyncTask can be called from you onCreate method by calling its execute method and passing the arguments to it:
new DoBackgroundTask().execute(URL);
3: And at last, there is also a very nice tutorial about AsyncTasks here, http://www.vogella.com/articles/AndroidBackgroundProcessing/article.html
How the ProgressValue (passing in the onPostExecute() in AsyncTask ) represents. it's value depends on what ?
When you create your AsyncTask class, you may specify types of the parameters, progress and result:
private class MyTask extends AsyncTask<ParamType, ProgressType, ResultType> { ... }
If you want to use progress values to update the progress bar, I'd recommend to use Integer, so your class declaration will look like this:
private class MyTask extends AsyncTask<ParamType, Integer, ResultType> { ... }
the following call should be made somewhere from doInBackground():
publishProgress(progress_value); // progress_valus is integer
and your onProgressUpdate() member will look like this:
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
dialog.setProgress(values[0]); // dialog is the ProgressDialog
}
Do you mean onProgressUpdate()?
The progress value is anything you want. If you want to display a percentage-complete progress bar, you can use integers in the range 0..100. If you want to display a textual message, then pass a String.
At certain points in your background operation, call publishProgress() with whatever value you want to send (integer, String, etc.). This will be passed into your onProgressUpdate() method on the main thread, so you can display the value in your UI, if you want.
If you know how much work to do, and how far through the operation you are (perhaps your background operation runs in a loop), then on each iteration of the loop you could publish the progress as percentage of how much work is left to do.
If the background task contains a bunch of distinct operations, then maybe you want to send a message like "Loading data", "Preparing report", or something.
It's entirely up to you to decide what values to send, and how to calculate them.
I sent "Scores Activity" to doinbackground then run a function on Scores Activity but getting
"Only the original thread that created a view hierarchy can touch its views." on "birinci.setText(txt);" line.
what am I missing here looks using same context?
Scores Activity
{
Object[] stuff = {this.dhn, Scores.this};
ConnectXML runXML = new ConnectXML();
runXML.execute(stuff);
}
public void setScoreListUpdate(String txt)
{
birinci.setText(txt);
}
private Scores myScores;
protected String doInBackground(Object... arguments) {
myScores = (Scores)stuff[1];
myScores.setScoreListUpdate(result);
}
The error message already gives the answer: you can't touch (edit/modify/update/etc.) any views from a thread that did not create them. Since anything that is executed in the doInBackgrund(...) of an AsyncTask is done by a separate thread, you can't do any direct view manipulations in there.
The solution is quite simple: override the other methods an AsyncTask provides, depending on your needs. If you're trying to update a view after all work is done, simply override onPostExecute(...). If you want to indicate some sort of progress while the work is being done in the background, use onProgressUpdate(...). Everything in there is being executed by the main UI thread (which created all views).
Please have read through the documentation on AsyncTask, since that describes the different steps and possibilities quite clearly.
I don't understand what I am supposed to put in here and where these arguments end up? What exactly should I put, and where exactly will it go? Do I need to include all 3 or can I include 1,2,20?
Google's Android Documentation Says that :
An asynchronous task is defined by 3 generic types, called Params, Progress and Result, and 4 steps, called onPreExecute, doInBackground, onProgressUpdate and onPostExecute.
AsyncTask's generic types :
The three types used by an asynchronous task are the following:
Params, the type of the parameters sent to the task upon execution.
Progress, the type of the progress units published during the background computation.
Result, the type of the result of the background computation.
Not all types are always used by an asynchronous task. To mark a type as unused, simply use the type Void:
private class MyTask extends AsyncTask<Void, Void, Void> { ... }
You Can further refer : http://developer.android.com/reference/android/os/AsyncTask.html
Or You Can clear whats the role of AsyncTask by refering Sankar-Ganesh's Blog
Well The structure of a typical AsyncTask class goes like :
private class MyTask extends AsyncTask<X, Y, Z>
protected void onPreExecute(){
}
This method is executed before starting the new Thread. There is no input/output values, so just initialize variables or whatever you think you need to do.
protected Z doInBackground(X...x){
}
The most important method in the AsyncTask class. You have to place here all the stuff you want to do in the background, in a different thread from the main one. Here we have as an input value an array of objects from the type “X” (Do you see in the header? We have “...extends AsyncTask” These are the TYPES of the input parameters) and returns an object from the type “Z”.
protected void onProgressUpdate(Y y){
}
This method is called using the method publishProgress(y) and it is usually used when you want to show any progress or information in the main screen, like a progress bar showing the progress of the operation you are doing in the background.
protected void onPostExecute(Z z){
}
This method is called after the operation in the background is done. As an input parameter you will receive the output parameter of the doInBackground method.
What about the X, Y and Z types?
As you can deduce from the above structure:
X – The type of the input variables value you want to set to the background process. This can be an array of objects.
Y – The type of the objects you are going to enter in the onProgressUpdate method.
Z – The type of the result from the operations you have done in the background process.
How do we call this task from an outside class? Just with the following two lines:
MyTask myTask = new MyTask();
myTask.execute(x);
Where x is the input parameter of the type X.
Once we have our task running, we can find out its status from “outside”. Using the “getStatus()” method.
myTask.getStatus();
and we can receive the following status:
RUNNING - Indicates that the task is running.
PENDING - Indicates that the task has not been executed yet.
FINISHED - Indicates that onPostExecute(Z) has finished.
Hints about using AsyncTask
Do not call the methods onPreExecute, doInBackground and onPostExecute manually. This is automatically done by the system.
You cannot call an AsyncTask inside another AsyncTask or Thread. The call of the method execute must be done in the UI Thread.
The method onPostExecute is executed in the UI Thread (here you can call another AsyncTask!).
The input parameters of the task can be an Object array, this way you can put whatever objects and types you want.
I'm too late to the party but thought this might help someone.
Keep it simple!
An AsyncTask is background task which runs in the background thread. It takes an Input, performs Progress and gives Output.
ie AsyncTask<Input,Progress,Output>.
In my opinion the main source of confusion comes when we try to memorize the parameters in the AsyncTask.
The key is Don't memorize.
If you can visualize what your task really needs to do then writing the AsyncTask with the correct signature would be a piece of cake.
Just figure out what your Input, Progress and Output are and you will be good to go.
For example:
Heart of the AsyncTask!
doInBackgound() method is the most important method in an AsyncTask because
Only this method runs in the background thread and publish data to UI thread.
Its signature changes with the AsyncTask parameters.
So lets see the relationship
doInBackground() and onPostExecute(),onProgressUpdate() are also related
Show me the code
So how will I write the code for DownloadTask?
DownloadTask extends AsyncTask<String,Integer,String>{
#Override
public void onPreExecute()
{}
#Override
public String doInbackGround(String... params)
{
// Download code
int downloadPerc = // calculate that
publish(downloadPerc);
return "Download Success";
}
#Override
public void onPostExecute(String result)
{
super.onPostExecute(result);
}
#Override
public void onProgressUpdate(Integer... params)
{
// show in spinner, access UI elements
}
}
How will you run this Task
new DownLoadTask().execute("Paradise.mp3");
Refer to following links:
http://developer.android.com/reference/android/os/AsyncTask.html
http://labs.makemachine.net/2010/05/android-asynctask-example/
You cannot pass more than three arguments, if you want to pass only 1 argument then use void for the other two arguments.
1. private class DownloadFilesTask extends AsyncTask<URL, Integer, Long>
2. protected class InitTask extends AsyncTask<Context, Integer, Integer>
An asynchronous task is defined by a computation that runs on a background thread and whose result is published on the UI thread. An asynchronous task is defined by 3 generic types, called Params, Progress and Result, and 4 steps, called onPreExecute, doInBackground, onProgressUpdate and onPostExecute.
in Short, There are 3 parameters in AsyncTask
parameters for Input use in DoInBackground(String... params)
parameters for show status of progress use in OnProgressUpdate(String... status)
parameters for result use in OnPostExcute(String... result)
Note : - [Type of parameters can vary depending on your requirement]