handlerthread code added

maciej-nowak · maciej-nowak · commit ad10b0a346a5 · 2019-05-07T23:10:35.000+02:00
diff --git a/handlerthread/HandlerActivity.kt b/handlerthread/HandlerActivity.kt
@@ -0,0 +1,50 @@
+class HandlerActivity : AppCompatActivity() {
+
+    val START = 1
+    val FINISH = 2
+
+    val runnable = Runnable {
+        //some background job
+        handler.sendMessage(createMessage(FINISH, "result")) //send message to handle action
+        handler.post { 
+            //do action on UI without message communication
+        }
+    }
+
+    val thread: Thread = Thread(runnable)
+
+    val handler = object: Handler(Looper.getMainLooper()) { //pass Looper of thread owner
+        override fun handleMessage(msg: Message?) {
+            super.handleMessage(msg)
+            if(msg?.what == START && thread.state == Thread.State.NEW) {
+                thread.start()
+            }
+            else if(msg?.what == FINISH) {
+                //some action with msj.obj result
+            }
+        }
+    }
+
+    fun createMessage(what : Int, obj : Any) : Message {
+        val message = Message()
+        message.what = what
+        message.obj = obj
+        return message
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_handler)
+
+        button.setOnClickListener {
+            //instead of direct thread.start() it can be done by sending message
+            handler.sendEmptyMessage(START)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        handler.removeCallbacksAndMessages(null) //remove pending work from MessageQueue
+        thread.interrupt()
+    }	
+}
diff --git a/handlerthread/HandlerThreadActivity.kt b/handlerthread/HandlerThreadActivity.kt
@@ -0,0 +1,47 @@
+class HandlerThreadActivity : AppCompatActivity() {
+
+    //work to do by requestHandler
+    val runnable = Runnable {
+        //some background job
+        responseHandler.sendMessage(Message()) //send message or post the job
+        responseHandler.post { 
+            //some UI action
+        }
+    }
+
+    //handler on the main thread, override handleMessage if needed
+    val responseHandler = object: Handler(Looper.getMainLooper()) {
+        override fun handleMessage(msg: Message?) {
+            super.handleMessage(msg)
+            //some action on UI
+        }
+    }
+
+    //handler on the background thread of handlerThread object
+    lateinit var requestHandler: Handler
+
+    //instead of Thread use reusable HandlerThread
+    //this can be also done by extend HandlerThread class and putting there Handler object
+    val handlerThread = HandlerThread("HandlerThread")
+    
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_handler_thread)
+
+        handlerThread.start() //start the thread
+        requestHandler = Handler(handlerThread.looper) //now Looper of handlerThread can be passed
+
+        button.setOnClickListener {
+            requestHandler.post(runnable) //post the job to MessageQueue
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        //remove tasks and messages from handlers
+        requestHandler.removeCallbacksAndMessages(null)
+        responseHandler.removeCallbacksAndMessages(null)
+        handlerThread.quitSafely() //quit HandlerThread's Looper
+        handlerThread.interrupt() //stop current job
+    }
+}
diff --git a/handlerthread/README.md b/handlerthread/README.md
@@ -0,0 +1,2 @@
+# handlerthread
+This is repository of http://androidcode.pl blog. It shows uses HandlerThread in Android. It is a part of Background processing - HandlerThread post in the blog.
diff --git a/handlerthread/ThreadActivity.kt b/handlerthread/ThreadActivity.kt
@@ -0,0 +1,27 @@
+class ThreadActivity : AppCompatActivity() {
+
+    val runnable = Runnable {
+        //some background job
+        runOnUiThread { 
+            //UI job if needed
+        }
+    }
+    val thread = Thread(runnable) //pass runnable or create anonymous object
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_thread)
+
+        button.setOnClickListener {
+            //do not allow start thread if is started
+            if(thread.state == Thread.State.NEW)
+                thread.start()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if(thread.state != Thread.State.TERMINATED)
+            thread.interrupt() //stop the thread if needed
+    }
+}
diff --git a/handlerthread/ThreadPoolActivity.kt b/handlerthread/ThreadPoolActivity.kt
@@ -0,0 +1,44 @@
+class ThreadPoolActivity : AppCompatActivity() {
+
+    //this ExecutorService is wrapped ThreadPoolExecutor (this class extends ExecutorService)
+    //equivalent of ThreadPoolExecutor with min and max only 1 thread in pool and LinkedBlockingQueue
+    val executor : ExecutorService = Executors.newSingleThreadExecutor()
+
+    val runnable = Runnable {
+        //some background job
+        uiHandler.post {
+            //some UI job
+        }
+    }
+
+    val callable = Callable {
+        //some background job and return result
+        return@Callable "result"
+    }
+
+    val uiHandler = Handler()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_thread_pool)
+
+        button1.setOnClickListener {
+            //use executor with Runnable        
+            executor.execute(runnable)
+        }
+
+        button2.setOnClickListener {
+            //use executor with Callable        
+            val future : Future<String> = executor.submit(callable)
+            val result = future.get()
+            //this can be canceled by run future.cancel()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        //remove tasks and messages from handlers
+        uiHandler.removeCallbacksAndMessages(null)
+        executor.shutdownNow() //kill all threads
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+# handlerthread`
	`2`	`+This is repository of http://androidcode.pl blog. It shows uses HandlerThread in Android. It is a part of Background processing - HandlerThread post in the blog.`