Android handler with runnable

Understanding of Thread, Handler, Looper, Message, Runnable and HandlerThread

Being an Android developer, you should know about these basic but important elements which will build up your basic knowledge. If you have any confusion to understand about any of the above elements then this post is for you. Or, if you want to use a library and just never interested about what is happening under the hood then you may stop reading here.

You may find the definitions easily, so let’s start from an example. I need to complete a task using Thread which will print some logs.

Now, when I said thread then you should be confused about which one I meant. We know the simple and mostly uttered line -> whenever an android app starts Linux OS run a process ( only one per app) and that process will initiate a thread( as android framework is single threaded) to maintain the whole UI work named Main Thread or UI Thread.

With this single process you may start as many threads you want but only restriction is that you will not be able to run or accomplish any ui task. So, please remember that we have an issue here that..

we may want to complete any task by using a background thread and after finishing that task we need to update the ui.

We will know the solution later. Now we will see a simple thread example:

The log tag style is mine but the msg is very much important by which you will see and learn the core thing. The above code will be executed by the below statement:

Please run it now and try to understand from the output. Another element which I want to describe now is Runnable.

Runnable is nothing but an interface, please accept it. Okey, I will give you reference from Android Bible Link.

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments called run .

Let’s sync -> should be implemented by any class( we used testRunnable) and whose instances ( that means new testRunnable()) intended to be executed by a thread. So, new Thread() which is a thread but we have to put our runnable to be executed by this.

Don’t be afraid, the above is code is not mine. I just pasted it from Java Thread class. So, our statement will be:

Hey wait, why do we need this runnable? Now we are going in. This runnable is able to run by its own! Yes, it it.

If you are 99% sure about the output then please run the above code because you should be 100%.

Now the question you have, what is the speciality when we run any runnable without a background thread, I mean in the main thread just like above. There is no meaning! Its just like a kingdom(Runnable) without the king (Thread).

Another simple question is what is the use case I mean why do we need runnable as we can execute anything within the Thread’s run method. Yes, we do need a runnable.

Suppose, you need to execute 2 different tasks in two different steps of a program using thread.

Now you can pass these runnable as parameters to execute on any background thread at any time.

Handler is the most precious thing on android framework. Yes it is not a java thing. Before knowing about handler we have to know about two things Runnable and Message.

In simple words, Handler is not a thread and Handler is not related to the UI. Handler is just a way of communication, a medium, a bridge or such an element which is used to complete a big task( mostly any thread related task).

If I explain, communication between one thread to another. Medium of background thread to Main Thread or UI Thread. Now, we should learn about Message( as we know little bit about runnable).

By definition, a Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue .

I didn’t mention about MessageQueue because it’s the queue of Message. Message is something like a Bundle. Yes if you know about bundle when passing data from one activity/fragment to another, then just remember in case of Handler you can’t use bundle and you have to use Message Or you may use Runnable also. So, the point is that you are only able to use a Message object or a Runnable object to make any handler functional.

If you just type new Handler().p then android studio will show you the suggestions where you can easily understand that all the other methods asking for runnable as the mandatory parameter. That means if you want to run any task after a certain amount of time or at any specific time then you have to use the combination of Runnable and Handler(you can’t make using one).

As I said above that Runnable is just like Kingdom and here Handler is the King. So, Runnable can’t do anything by its own, means it needs to go with a Thread or a Handler.

To describe about the relation and use of Message and Handler we need to know about Looper. I will discuss the remaining elements to the next posts.

Please clap and share for more useful stories. Thanks a lot.

Источник

Полный список

— работаем с Handler и Runnable

Кроме обработки сообщений, мы можем попросить Handler выполнить кусок кода – Runnable. В прошлых уроках мы работали с сообщениями, которые содержали атрибуты. Мы их обрабатывали в Handler и в зависимости от значений атрибутов выполняли те или иные действия. Runnable же – это кусок кода, который мы пошлем вместо атрибутов сообщения, и он будет выполнен в потоке, с которым работает Handler. Нам уже ничего не надо обрабатывать.

Для отправки кода в работу используется метод post. Как и сообщения, Runnable может быть выполнен с задержкой (postDelayed), и может быть удален из очереди (removeCallbacks). Напишем приложение, которое продемонстрирует все эти возможности.

Project name: P0841_HandlerRunnable
Build Target: Android 2.3.3
Application name: HandlerRunnable
Package name: ru.startandroid.develop.p0841handlerrunnable
Create Activity: MainActivity

ProgressBar, отображающий текущий прогресс. CheckBox, который будет включать отображение доп.информации в TextView.

В onCreate мы прописываем обработчик для CheckBox. При включении галки отображается TextView и в работу отправляется задание showInfo. При выключении галки – задание showInfo удаляется из очереди.

Далее в новом потоке эмулируем какое-либо действие — запускаем счетчик с паузами. В каждой итерации цикла отправляем в работу задание updateProgress, которое обновляет ProgressBar.

updateProgress – код, который обновляет значение ProgressBar.

showInfo – код, который обновляет TextView и сам себя планирует на выполнение через 1000 мсек. Т.е мы включаем CheckBox, showInfo срабатывает первый раз и само себя планирует на следующий раз. Т.е. этот код лежит в очереди сообщений, обрабатывается и снова кладет себя туда. Так продолжается, пока мы явно его не удалим из очереди (removeCallbacks), выключив CheckBox.

Будем выводить что-нибудь в лог из showInfo, чтобы увидеть, когда он работает, а когда нет.

Все сохраним и запустим приложение. Побежал ProgressBar.

Появился TextView, который отображает текущее значение счетчика.

В логи при этом добавляется раз в секунду запись:

Выключим CheckBox. Текст исчез.

И логи перестали идти. Значит, задание showInfo успешно удалилось из очереди и больше не работает.

Если снова включим CheckBox – оно снова начнет срабатывать и само себя помещать в очередь с задержкой исполнения. Выключаем CheckBox – удаляем его из очереди.

На следующем уроке:

— рассмотрим еще пару способов запуска Runnbale в UI-потоке

Присоединяйтесь к нам в Telegram:

— в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.

— в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

— ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня

— новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме

Источник

Android Basics – Using Handler and Runnable to Schedule Code

You will Learn about

• Handler
• post method
• postDelayed method
• Main Thread

Android runs every App in a separate Process for Security and Scalability.

So when you Run your App Android starts a Thread for the same.

A New Thread

Now if you want to run code which needs to run in the background then its recommended to use a separate thread for doing that.

This will not only improve user experience but also prevent delays and crashes.

Handlers

Handlers can be used to Schedule code to run at a future time. Lets take an example.

Suppose you want your App to display a message a the user after 5 seconds, like “Do you need any Help ?”. Handlers can help us achieve this.

By using post and postDelayed methods. Post method can be used to start a code immediately. While using postDelayed you can delay the code execution.

Lets look at an example. I have created a method sayHello() to display a message to the user after 5 seconds. We will specify this in milliseconds.

I will be calling this method from the onCreate() in the MainActivity.

public void sayHello() <
Handler handler = new Handler();
handler.postDelayed(new Runnable() <
@Override
public void run() <
Toast.makeText(MainActivity.this, “Do you need any Help ?”, Toast.LENGTH_SHORT).show();
>
>, 5000);
>

As you can see this code will help you delay the code execution by 5000 milliseconds. Cool, isn’t it !!

Источник

Android Handler with Example

In the previous article, we have talked about Thread . As we know it is possible to access UI components inside the worker thread using some of the methods like

• Activity.runOnUiThread(Runnable) ,
• View.post(Runnable)
• View.postDelayed(Runnable, long)

But there is one more alternative in android i.e Handler which also allows you communicate back with the UI thread from other background thread. In this article, we will talk about Handler in brief.

Main Thread

Android handles all the UI operations and input events from one single thread which is known as Main or UI thread. Android collects all events in this thread in a queue and processes this queue with an instance of the Looper class.

Android supports Thread class to perform asynchronous processing.

Why Handler

By the android single thread model rule, we can not access UI elements (bitmap, text view, button, etc..) directly for another thread defined inside that activity. If you need to update the UI from any worker thread, you need to connect it with the main thread. To achieve this Android comes with the classes i.e. Handler or AsyncTask.

A Handler allows you to communicate back with the UI thread from other background thread. This is useful in android as android doesn’t allow other threads to communicate directly with UI thread.

How Handler Works

• Activity’s main UI thread already has a MessageQueue and a Looper created by the framework and it can be retrieved by calling Looper.getMainLooper().
• The MessageQueue consist of tasks that need to update the UI. This task could be as simple as rendering a button or doing something on click of a button etc. A task may be a Message or a Runnable object.
• If you want to send some task from a background thread to the message queue of the mainThread then we cannot do it directly. But Handler makes it possible.
• Handler contains the reference of this message queue and is associated with the Looper of the MainThread. So in the background thread when you send a task (Message or Runnable object) using handler it gets added in the message queue of the MainThread.
• The Looper of the main Thread loops through the message queue and take one task at a time and send it to the handler. The handler will then execute the task and update the UI.

Handler

• Handler allows you to send and process Message and runnable objects associated with a thread’s MessageQueue .
• Handler instance is associated with a single thread and that thread’s MessageQueue.
• When you create a new Handler, it is bound to the thread/message queue of the thread that is creating it.
• It will deliver messages and runnables to that message queue and execute them as they come out of the message queue.
• The background thread can communicate with the handler, which will do all of its work on the activity’s UI thread. For example, if you want to update the progress bar from the background thread what you do is get the handler which belongs to the main thread and simply sends a message updating the progress bar.

There are two main uses for a Handler:

1. To schedule messages and runnables to be executed at some point in the future.

To enqueue an action to be performed on a different thread than your own.

There are two ways of communicating with the handler:

Message

Defines a message containing a description and arbitrary data object that can be sent to a handler.

While the constructor of message is public, the best way to get one of these is to call Message.obtain() or one of the Handler obtainMessage methods which will pull them from the pool of recycled objects.

How to send Message objects?

sendMessage() : Puts the message on the queue immediately.

sendMessageAtFrontOfQueue() : Puts the message on the queue immediately and places it in front of the message queue so your message takes priority over all others.

sendmessageAtTime() : puts the message on the queue at the stated time, expressed in the form of milliseconds based on system uptime(Systemclock.uptimeMillis()).

sendMessageDelayed() : puts the message on the queue after a delay, expressed in milliseconds.

sendEmptyMessage() : sends an empty message object to the queue, allowing you to skip the obtainMessage() step.

To process these messages, Handler needs to implement handleMessage() , which will be called with each message that appears on the message queue. There the Handler can update the UI as needed.

Note : sendMessage() can be called in any threads but the handler code (i.e handleMessage() ) will always be running in the Thread which the Handler’s Looper resides in.

Now to understand the working of Thread Looper Handler when the task in the MessageQueue will be a message look at the below diagram:

• The main thread has message queue which consists of lot’s of messages and a looper which loops through the message queue.
• The handler is capable of two things that can handle messages that come from the looper and can also send messages from a different thread.
• Thread1 let’s say want to send message to the main thread indicating to update the progress bar so what you do is you get the handler reference and you call sendMessage of the Handler and that message goes inside the message queue of the main thread.
• The looper is going to run one message at a time and ultimately when it comes to your message the looper is going to open the message up and is going to forward the message to the handler.
• Now the handler object is going to have this method called handleMessage inside which whatever code you have written is going to be executed in the main thread.
• Each thread can have its own looper and its own handler, for now, the main thread is the one who has its own looper that’s gonna take one message at a time and its own handler who’s gonna pick one message up and run it. Other thread can use a reference to this handler to send messages to the main thread.

Runnable

Runnable is an interface which contains one single method run() with no arguments. The post versions methods of Handler class accept the Runnable objects to be added to the message queue and the code written inside the run method will be executed by the thread to which this handler is attached.

How to send Runnable objects?

post(Runnable r) : Causes the Runnable r to be added to the message queue. The runnable will be run on the thread to which this handler is attached.

postAtTime(Runnable r, long uptimeMillis) : Causes the Runnable r to be added to the message queue, to be run at a specific time given by uptimeMillis .

postDelayed(Runnable r, long delayMillis) : Causes the Runnable r to be added to the message queue, to be run after the specified amount of time elapses.

In the above Thread Looper Handler diagram when you want to send a Runnable object from the background thread (Thread 1) to the main thread using the post method of the handler then it gets added in the message queue of the main thread and then it gets executed inside the thread to which handler is attached (the UI thread).

Handler Example

Now let’s take an example in which we are downloading an image over the network in an imageView on button click. In the below example we are communicating with handler using both message and Runnable object.

MainActivity.java

activity_main.xml

When you run the application HandlerDemo it will look like this as shown below:

I hope this article will help you in understanding what is Handler, why we use it, it’s working and its example.

Источник