#asynctask

In diesem Tutorial möchte ich beschreiben wie man eine asynchrone Aufgabe auslagert und parallel dazu einen Dialog anzeigt. Den ProgressDialog habe ich bereits im Tutorial Android, ProgressDialog für lange Operationen erläutert. Es gibt bereits einige Beispiele dazu im Internet und die Lösungen sind zumeist praktikabel und funktionell. Jedoch sind diese zumeist mit einer inneren Klasse (wie in der offiziellen Dokumentation https://developer.android.com/reference/android/os/AsyncTask) und blähen dadurch den Quellcode unnötig auf. Ich möchte gerne einen anderen Weg gehen und den AsyncTask auslagern und mit einem Callback versehen so halten wir unseren Quellcode schlank und haben immer das Wesentliche im blick.

Projekt erstellen

Für die nachfolgenden Schritte benötigen wir ein einfaches, leeres Android Projekt mit einer Activity (EmptyActivity).  Gerne möchte ich dir der einfachheithalber ein Download für ein Projekt anbieten welches du dir in Android Studio importieren kannst.   Layout erstellen Für das Ausführen des asynchronen Task benötigen wir eine Schaltfläche und für die Anzeige der Daten  TextView Elemente. Diese Elemente fügen wir über den Designer auf das Layout "activity_main.xml".

Interface ICallback erzeugen

Für die Verarbeitung des Ergebnisses unseres asynchronen Tasks benötigen wir ein Interfaces. Dieses ermöglicht es uns späterer mehrere Implementationen für eventuelle verschiedene Ausführungen zu implementieren. package de.draegerit.asynctaskcallbackapp; public interface ICallback { void handleResult(Result result); } Nun müssen wir uns eine innere Klasse schreiben welche das Interface "ICallback" implementiert. Mit dem implementieren des Interfaces müssen wir zusätzlich die Methode "handleResult" implementieren. class CallbackImpl implements ICallback { @Override public void handleResult(Result result) { } } package de.draegerit.asynctaskcallbackapp; public class Result { private int size; private String filename; private String message; public int getSize() { return size; } public void setSize(int size) { this.size = size; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } public String getFilename() { return filename; } public void setFilename(String filename) { this.filename = filename; } }

asynchronen Task erstellen

Nun können wir uns eine öffentliche Klasse für den asynchronen Task erstellen welchen wir mit der Schaltfläche starten wollen. In diesem Beispiel möchte ich eine einfache Datei aus dem Internet laden. Da ich in diesem Tutorial beschreiben möchte wie ein asynchroner Task mit einem Callback ausgestattet werden kann überspringe ich die Erläuterungen für das herunterladen von Dateien. In dem Kontruktors des asynchronen Task wird der Context und zusätzlich ein Callback übergeben. package de.draegerit.asynctaskcallbackapp; import android.app.ProgressDialog; import android.content.Context; import android.content.DialogInterface; import android.os.AsyncTask; import android.util.Log; import java.io.DataInputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.lang.ref.WeakReference; import java.net.URL; import java.net.URLConnection; public class RequestAsyncTask extends AsyncTask { //TAG für den Logger private static final String TAG = "RequestAsyncTask"; //Zieldatei private static final String ADDRESS = "http://progs.draeger-it.blog/example.file"; //Schwache Referenz auf den Context private WeakReference contextRef; //ProgressDialog für die Fortschrittsanzeige private ProgressDialog progressDialog; //Das Ergebniss des asynchronen Tasks private Result result; //Der Callback welcher zum schluss ausgeführt werden soll. private ICallback callback; //Variable welche gesetzt wird wenn die Schaltfläche "Abbrechen" im ProgressDialog betätigt wird. private boolean abortDownload; /** * Konstruktor * @param ctx - der Context * @param callback - der Callback welcher zum Schluss ausgeführt werden soll */ public RequestAsyncTask(Context ctx, ICallback callback) { contextRef = new WeakReference(ctx); this.callback = callback; } @Override protected Result doInBackground(Void... voids) { result = new Result(); try { //Die Progressbar soll den Fortschritt in Prozent anzeigen. progressDialog.setMax(100); DataInputStream stream = null; //Dateiname generieren String filename = String.valueOf(System.currentTimeMillis()).concat(".file"); result.setFilename(filename); //Referenz des Context laden Context ctx = contextRef.get(); try (FileOutputStream outputStream = ctx.openFileOutput(filename, Context.MODE_PRIVATE);){ File privateFileDirectory = ctx.getFilesDir(); Log.i(TAG, privateFileDirectory.getAbsolutePath()); //Aufbau der Verbindung URL u = new URL(ADDRESS); URLConnection conn = u.openConnection(); //ermitteln der Dateigröße int contentLength = conn.getContentLength(); //ablegen der Dateigröße in unseren Result result.setSize(contentLength); //Datenstream öffnen stream = new DataInputStream(u.openStream()); byte buffer = new byte; int count; int total = 0; int percent; //Solange der Stream noch Daten hat und die Variable abortDownload nicht Boolean.True ist, mache... while (((count = stream.read(buffer)) != -1) && !abortDownload) { outputStream.write(buffer, 0, count); total += count; percent = (total * 100) / contentLength; progressDialog.setProgress(percent); } } catch (Exception e) { //Wenn ein Fehler auftritt so soll dieser in unser Result gespeichert werden. result.setMessage(e.getMessage()); e.printStackTrace(); } finally { //Zum Schluss den Datenstream schließen if (stream != null) { try { stream.close(); } catch (IOException e) { //Wenn ein Fehler auftritt so soll dieser in unser Result gespeichert werden. result.setMessage(e.getMessage()); e.printStackTrace(); } } } } catch (Exception e) { //Wenn ein Fehler auftritt so soll dieser in unser Result gespeichert werden. result.setMessage(e.getMessage()); e.printStackTrace(); } //Rückgabe unseres Ergebnisses. return result; } @Override protected void onPreExecute() { super.onPreExecute(); //Anzeigen des ProgressDialoges, //dieses geschieht noch bevor der Download gestartet wird. progressDialog = getWaitDialog(); progressDialog.show(); } @Override protected void onPostExecute(Result result) { super.onPostExecute(result); //nach dem Download (erfolgreich oder nicht) //soll der ProgressDialog geschlossen werden. progressDialog.dismiss(); //Ausführen des Callbacks callback.handleResult(result); } /** * Liefert einen ProgressDialog * @return ein ProgressDialog */ private ProgressDialog getWaitDialog() { Context context = contextRef.get(); String titel = context.getResources().getString(R.string.msg_loaddialog_titel); String message = context.getResources().getString(R.string.msg_loaddialog_message); ProgressDialog progressDialog = new ProgressDialog(context); progressDialog.setTitle(titel); progressDialog.setMessage(message); progressDialog.setCancelable(false); progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); progressDialog.setButton(ProgressDialog.BUTTON_POSITIVE, context.getResources().getString(R.string.abort), new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { abortDownload = true; } }); return progressDialog; } } Für dieses Beispiel habe ich eine Datei mit ca. 30MB auf eine Subdomain (http://progs.draeger-it.blog/example.file) geladen. Ich kann & möchte nicht garantieren das diese Datei auf ewig bereitgestellt wird. Die Datei selbst habe ich mit dem Befehl "fsutil file createnew example.file 3000000" unter Microsoft Windows 10 erstellt.

ProgressDialog - Download im Vorgang Wichtig ist hier die Methode "onPostExecute", diese Methode wird zum Schluss ausgeführt und in diesem Beispiel werde ich hier den Callback aufrufen. @Override protected void onPostExecute(Result result) { super.onPostExecute(result); //nach dem Download (erfolgreich oder nicht) //soll der ProgressDialog geschlossen werden. progressDialog.dismiss(); //Ausführen des Callbacks callback.handleResult(result); }

Ausführen des asynchronen Task

Für das Ausführen des asynchronen Task haben wir im ersten Schritt eine Schaltfläche erzeugt. Nun wollen wir an diese Schaltfläche einen Listener hängen und in diesem den Task starten. public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Button startBtn = findViewById(R.id.startBtn); startBtn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { RequestAsyncTask requestAsyncTask = new RequestAsyncTask(MainActivity.this, new CallbackImpl()); requestAsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); } }); } Nun müssen wir noch ein Callback implementieren. In diesem Callback werde ich 2 Textfelder (jeweils mit Dateiname, Dateigröße) und / oder ein Feld mit der Fehlermeldung einer Exception befüllen. class CallbackImpl implements ICallback { @Override public void handleResult(Result result) { //Wenn das Feld "message" leer bzw. NULL ist dann ist kein Fehler aufgetreten. boolean showErrorMessage = result.getMessage() == null; TextView errorMsgTextView = findViewById(R.id.errorMsgTextView); //Wenn keine Fehlermeldung aufgetreten ist dann soll das TextView Element ausgeblendet werden. errorMsgTextView.setVisibility(showErrorMessage ? View.VISIBLE : View.INVISIBLE); if(showErrorMessage){ errorMsgTextView.setText(result.getMessage()); } TextView dateinameTextView = findViewById(R.id.dateinameTextView); dateinameTextView.setText(result.getFilename()); TextView dateigroesseTextView = findViewById(R.id.dateigroesseTextView); dateigroesseTextView.setText(String.valueOf(result.getSize()).concat(" byte")); } }

Download

Fazit

Android AsyncTask is Deprecated: Here’s another way – Android Coding by DMTechnolab

If you’re in Android development, I’m pretty sure you know about it Android AsyncTask. The AsyncTask class helped us execute some code in the background thread. With the help of AsyncTask we can execute something on the background thread and return the result to the UI thread. If you want to learn about AsyncTask you can see this Android MySQL tutorial, Where I used AsyncTask. But Android…

android looper , handler, handlerthread

기본개념 정리와 실제 예제

my review point is 9 / 10

https://youtu.be/Yo3VT-fZr68     thread, handler, looper를 이용한 코드예시

https://youtu.be/dSb-K024A6U

https://youtu.be/E81yFwQ0NpI

https://youtu.be/b80LbWVERL4

The AsyncTask help us to perform some operation in background and update the results or status of the work to main thread. Here in this tutorial of  “Android AsyncTask Example in Kotlin”  we will learn about how to implement the AsyncTask using Kotlin code in Android for performing the background operation.

Prerequisite

We required AndroidStudio 3.0 or later

At the time of wiring this tutorial we…

Android AsyncTask explained is an abstract class that it is performing heavy tasks in the background, check out the post below to get more in depth about Android Async Task. (more…)

original source : https://blog.mindorks.com/android-core-looper-handler-and-handlerthread-bd54d69fe91a

참고자료 : https://stackoverflow.com/questions/12877944/what-is-the-relationship-between-looper-handler-and-messagequeue-in-android

A Looper is a message handling loop: it reads and processes items from a MessageQueue. The Looper class is usually used in conjunction with a HandlerThread (a subclass of Thread).

A Handler is a utility class that facilitates interacting with a Looper—mainly by posting messages and Runnable objects to the thread's MessageQueue. When a Handler is created, it is bound to a specific Looper (and associated thread and message queue).

In typical usage, you create and start a HandlerThread, then create a Handler object (or objects) by which other threads can interact with the HandlerThread instance. The Handler must be created while running on the HandlerThread, although once created there is no restriction on what threads can use the Handler's scheduling methods (post(Runnable), etc.)

The main thread (a.k.a. UI thread) in an Android application is set up as a handler thread before your application instance is created.

Aside from the class docs, there's a nice discussion of all of this here.

It's widely known that it's illegal to update UI components directly from threads other than main thread in android. This android document (Handling Expensive Operations in the UI Thread) suggests the steps to follow if we need to start a separate thread to do some expensive work and update UI after it's done. The idea is to create a Handler object associated with main thread, and post a Runnable to it at appropriate time. This Runnable will be invoked on the main thread. This mechanism is implemented with Looper and Handler classes.

The Looper class maintains a MessageQueue, which contains a list messages. An important character of Looper is that it's associated with the thread within which the Looper is created. This association is kept forever and can't be broken nor changed. Also note that a thread can't be associated with more than one Looper. In order to guarantee this association, Looper is stored in thread-local storage, and it can't be created via its constructor directly. The only way to create it is to call prepare static method on Looper. prepare method first examines ThreadLocal of current thread to make sure that there isn't already a Looper associated with the thread. After the examination, a new Looper is created and saved in ThreadLocal. Having prepared the Looper, we can call loop method on it to check for new messages and have Handler to deal with them.

As the name indicates, the Handler class is mainly responsible for handling (adding, removing, dispatching) messages of current thread's MessageQueue. A Handler instance is also bound to a thread. The binding between Handler and Thread is achieved via Looper and MessageQueue. A Handler is always bound to a Looper, and subsequently bound to the thread associated with the Looper. Unlike Looper, multiple Handler instances can be bound to the same thread. Whenever we call post or any methods alike on the Handler, a new message is added to the associated MessageQueue. The target field of the message is set to current Handler instance. When the Looper received this message, it invokes dispatchMessage on message's target field, so that the message routes back to to the Handler instance to be handled, but on the correct thread. The relationships between Looper, Handler and MessageQueue is shown below:

Let's start with the Looper. You can understand the relationship between Looper, Handler and MessageQueue more easily when you understand what Looper is. Also you can better understand what Looper is in the context of GUI framework. Looper is made to do 2 things.

1) Looper transforms a normal thread, which terminates when its run() method returns, into something that runs continuously until Android app is running, which is needed in GUI framework (Technically, it still terminates when run() method returns. But let me clarify what I mean, below).

2) Looper provides a queue where jobs to be done are enqueued, which is also needed in GUI framework.

As you may know, when an application is launched, the system creates a thread of execution for the application, called “main”, and Android applications normally run entirely on a single thread by default the “main thread”. But main thread is not some secret, special thread. It's just a normal thread that you can also create with new Thread() code, which means it terminates when its run() method returns! Think of below example.

This Article covers Android Looper, Handler, and HandlerThread. These are among the building blocks of Android OS.

In my own experience, I have used them in a very limited context until recently. My use case involved sending tasks to the main/ui thread, primarily to update the UI from any other thread. The other aspects of the multi-threaded operation were handled through alternate ways like ThreadPoolExecutor, IntentService, and AsyncTask.

MultiThreading and task running are old subjects. Java itself has java.util.concurrent package and Fork/Join framework to facilitate it. Several libraries have been written to streamline asynchronous operations. RxJava is the most popular library today for reactive programming and designing an asynchronous application.

So, why am I writing about the old school?

Looper, Handler, and HandlerThread are the Android’s way of solving the problems of asynchronous programming. They are not old school, but a neat structure on which a complex android framework is built.

For new developers, it’s highly recommended to understand the principles behind them and experienced one’s should revisit this topic to recollect the minor details.

Use Cases:

The main thread in Android is built with a Looper and Handlers. So, the understanding of it is essential to create an unblocked responsive UI.

The developers writing libraries cannot afford to use third party libraries because of the library size. So, for them, the best option is to utilize the existing available resource. Writing own solution for it may not always get that level of efficiency and optimization.

The same argument can also be made for companies/individuals shipping out SDKs. The clients can have varied implementations, but all of them will share the common android framework APIs.

Understanding them fully will enhance the capacity to follow the Android SDK and package classes in general.

Let’s start the exploration/revision with a questionnaire.

I expect the reader to have the basic understanding of java threads. If you need, then get a quick overview of java Thread and Runnable.

What is the problem with java thread?

Java threads are one-time use only and die after executing its run method.

Can we improve upon it?

The Thread is a double edged sword. We can speed up the execution by distributing the tasks among threads of execution, but can also slow it down when threads are in excess. Thread creation in itself is an overhead. So, the best option is to have an optimum number of threads and reuse them for tasks execution.

Model for thread reusability:

The thread is kept alive, in a loop via it’s run() method.

The task is executed serially by that thread and is maintained in a queue (MessageQueue).

The thread must be terminated when done.

What is the Android’s way of doing it?

The above model is implemented in the Android via Looper, Handler, and HandlerThread. The System can be visualized to be a vehicle as in the article’s cover.

MessageQueue is a queue that has tasks called messages which should be processed.

Handler enqueues task in the MessageQueue using Looper and also executes them when the task comes out of the MessageQueue.

Looper is a worker that keeps a thread alive, loops through MessageQueue and sends messages to the corresponding handler to process.

Finally Thread gets terminated by calling Looper’s quit() method.

One thread can have only one unique Looper and can have many unique Handlers associated with it.

Creating Looper and MessageQueue for a Thread:

A thread gets a Looper and MessageQueue by calling Looper.prepare() after its running. Looper.prepare() identifies the calling thread, creates a Looperand MessageQueue object and associate the thread with them in ThreadLocal storage class. Looper.loop() must be called to start the associated looper. Similarly, the looper must be terminated explicitly through looper.quit().

class LooperThread extends Thread {      public Handler mHandler;      public void run() {          Looper.prepare();          mHandler = new Handler() {              public void handleMessage(Message msg) {                 // process incoming messages here                 // this will run in non-ui/background thread              }          };          Looper.loop();      }  }

Creating Handler for a Thread:

A Handler gets implicitly associated with the thread that instantiates it via thread’s Looper, but we can explicitly tie it to a thread by passing the thread’s looper in the constructor of the Handler.

handler = new Handler() {    @Override    public void handleMessage(Message msg) {        // process incoming messages here        // this will run in the thread, which instantiates it    } };

Sending messages to the MessageQueue via Handler can be done by two modes:

Message: It is a class that defines various useful methods to deal with message data. To send an object we set the obj variable.

Message msg = new Message(); msg.obj = "Ali send message"; handler.sendMessage(msg);

Detailed overview of Message class can be found here: https://developer.android.com/reference/android/os/Message.html

2. Runnable: A runnable can also be posted in the MessageQueue. Ex: posting and running a task in the main thread.

new Handler(Looper.getMainLooper()).post(new Runnable() {    @Override    public void run() {        // this will run in the main thread    } });

In the above example, we create a Handler and provide Looper associated with the main thread. This associate this handler to the main thread. When we post the Runnable, it gets queued in the main thread’s MessageQueue and then executed in the main thread.

Handler is capable of message manipulation in a wide variety of ways, which can found here: https://developer.android.com/reference/android/os/Handler.html

Creating an own thread and providing Lopper and MessageQueue is not the right way to deal with the problem. So, Android has provided HandlerThread (subclass of Thread) to streamline the process. Internally it does the same things that we have done but in a robust way. So, always use HandlerThread.

One of the ways to create the HandlerThread is to subclass it and most of the time you will be using this method.

private class MyHandlerThread extends HandlerThread {    Handler handler;    public MyHandlerThread(String name) {        super(name);    }    @Override    protected void onLooperPrepared() {        handler = new Handler(getLooper()) {            @Override            public void handleMessage(Message msg) {                // process incoming messages here                // this will run in non-ui/background thread            }        };    } }

Note: We have instantiated the Handler when the onLooperPrepared() is called. So, that Handler can be associated with that Looper.

Looper is only prepared after HandlerThread’s start() is called i.e. after the thread is running.

A Handler can be associated with a HandlerThread, only after it’s Looper is prepared.

Other way to create the HandlerThread:

HandlerThread handlerThread = new HandlerThread("MyHandlerThread"); handlerThread.start(); Handler handler = new Handler(handlerThread.getLooper());

Note: HandlerThread needs to call myHandlerThread.quit() to free the resources and stop the execution of the thread.

I would suggest practicing the above codes, so you can grasp their little details.

I have created an example project for Post Office simulation. Post Office is built upon HandlerThread and Clients communicate with the help of the Post Office. A Simulator class creates few Client Bots and delegate their communication to the MainActivity, which renders it in a live feed.

The link to this Example:

MindorksOpenSource/post-office-simulator-looper-example post-office-simulator-looper-example - This Android project simulates a Post Office using HandlerThreadgithub.com

Thanks for reading this article. Be sure to click ❤ below to recommend this article if you found it helpful. It would let others get this article in search and spread the knowledge.

For more about programming, follow me and Mindorks, so you’ll get notified when we write new posts.

Check out all the Mindorks best articles here.

Android – loading images from SD Card in ListView

ListView is a very common widget in Android to show list. Now to show a list with images from web url can be done using several libraries like Fresco, Glide, Volley etc but loading images from SD Card or local storage is little tricky as it takes longer time to load and which results jerk in scroll of the listview. To solve this issue you need to load the images asynchronously within the listview…

Kate

This week I delved into getting the JSON data from the server. Our app now updates a list view from with the data. I learned a lot about how AsyncTask works. At first I was struggling with how to return something from my class that extended AsynTask to the MainActivity, but after reading enough stack overflow posts, I finally realized that whatever is returned in doInBackground actually goes to onPostExecute. Once I figured this out, printing the data to the screen was easy. I then started researching how to create a list view that can be dynamically updating from JSON data pulled from an API. I found a very good tutorial (that also helped me with the previous step, pulling the JSON data) here: https://www.learn2crack.com/2013/11/listview-from-json-example.html

The next steps will be making the UI look like our wireframes, implementing the HTTP Post protocol so users can add their own free food events from the add page, and parsing from the Facebook API into the server.

Zach

The server is officially up and running via Heroku. Now that we have figured out how to make asynchronous requests from the app, we are able to get data from the server. We are still working on posting data to the server from our app.

I started working with the Facebook Graph API this week. I registered my Facebook account as a developer account and created an app called JumboEats. Facebook has a tool called Graph API Explorer that allows developers to try out different requests and see what data they return. This has been really helpful in learning how to use the API. I’m having some trouble figuring out how to access all of the groups that a user (i.e., me) is a member of. The YouTube videos “Getting Started with the Graph API” from the Facebook Developers account (https://www.youtube.com/watch?v=WteK95AppF4) and ”RESTful Web API Design with Node.js: Facebook Graph API | packtpub.com" from Packt Video (https://www.youtube.com/watch?v=_F9cLrI_thg) have been really helpful. They breakdown the API’s overall structure and give examples of how to use it.