Move router service message sending to its own thread (#1871)

* Added queueing to send messages to router service via transport broker on a different thread

* update unit test

* Remove old logic

* Add new class to hold all task queue logic for the TransportBroker

* Refactor logic in TransportBroker to new class created

* fix comment

* Rename SendMessageToRouterService

* Refactor SendToRouterServiceTaskMaster into base

* Update thread name for RouterServiceMessageEmitter

* Remove extra threadin queue object for RS emiiter

* Refctor emitter callback

* Remove extra emitter task class

* Merge adding to tail in emitter

* Update method modifiers in emitter

* Remove extra method in emitter for polling

* Fix increment to retryCount in transportBroker

* Remove custom linked list in favor of LinkedList

in the emitter.

* Add null checks in emitter

* Remove throwing NPE in emitter

* Additional cleanup for #1871

* Add library scope annotation to emitter

---------

Co-authored-by: “JKAST” <julian.kast@live.com>

Author: joeygrover

android/sdl_android/src/androidTest/java/com/smartdevicelink/transport/TransportBrokerTest.java

@@ -117,24 +117,24 @@ public void testSendMessageToRouterService() {
         broker.routerServiceMessenger = null;
         broker.isBound = true;
 
-        assertFalse(broker.sendMessageToRouterService(message));
+        assertFalse(broker.sendMessageToRouterService(message, 0));
 
         broker.routerServiceMessenger = new Messenger(handler); //So it's not ambiguous
 
         broker.isBound = false;
 
-        assertFalse(broker.sendMessageToRouterService(message));
+        assertFalse(broker.sendMessageToRouterService(message, 0));
 
         broker.isBound = true;
         broker.registeredWithRouterService = true;
 
         message = null;
 
-        assertFalse(broker.sendMessageToRouterService(message));
+        assertFalse(broker.sendMessageToRouterService(message, 0));
 
         message = new Message();
 
-        assertTrue(broker.sendMessageToRouterService(message));
+        assertTrue(broker.sendMessageToRouterService(message, 0));
 
     }
 

android/sdl_android/src/main/java/com/smartdevicelink/transport/RouterServiceMessageEmitter.java

@@ -0,0 +1,91 @@
+package com.smartdevicelink.transport;
+
+import android.os.Message;
+
+import androidx.annotation.RestrictTo;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+@RestrictTo(RestrictTo.Scope.LIBRARY)
+public class RouterServiceMessageEmitter extends Thread {
+
+    protected final Object QUEUE_LOCK = new Object();
+    private boolean isHalted = false, isWaiting = false;
+    private final Callback callback;
+    private final Queue<Message> queue = new LinkedList<>();
+
+    public RouterServiceMessageEmitter(Callback callback) {
+        this.setName("RouterServiceMessageEmitter");
+        this.setDaemon(true);
+        this.callback = callback;
+    }
+
+    @Override
+    public void run() {
+        while (!isHalted) {
+            try {
+                Message message;
+                synchronized (QUEUE_LOCK) {
+                    message = getNextTask();
+                    if (message != null && callback != null) {
+                        callback.onMessageToSend(message);
+                    } else {
+                        isWaiting = true;
+                        QUEUE_LOCK.wait();
+                        isWaiting = false;
+                    }
+                }
+            } catch (InterruptedException e) {
+                break;
+            }
+        }
+    }
+
+    protected void alert() {
+        if (isWaiting) {
+            synchronized (QUEUE_LOCK) {
+                QUEUE_LOCK.notify();
+            }
+        }
+    }
+
+    protected void close() {
+        this.isHalted = true;
+        if (queue != null) {
+            queue.clear();
+        }
+    }
+
+    /**
+     * Insert the task in the queue where it belongs
+     *
+     * @param message the new Message that needs to be added to the queue to be handled
+     */
+    public void add(Message message) {
+        synchronized (this) {
+            if (message != null && queue != null) {
+                queue.add(message);
+            }
+        }
+    }
+
+    /**
+     * Remove the head of the queue
+     *
+     * @return the old head of the queue
+     */
+    private Message getNextTask() {
+        synchronized (this) {
+            if (queue != null) {
+                return queue.poll();
+            } else {
+                return null;
+            }
+        }
+    }
+
+    protected interface Callback {
+        boolean onMessageToSend(Message message);
+    }
+}

android/sdl_android/src/main/java/com/smartdevicelink/transport/TransportBroker.java

@@ -91,6 +91,7 @@ public class TransportBroker {
 
     Messenger routerServiceMessenger = null;
     final Messenger clientMessenger;
+    private RouterServiceMessageEmitter routerServiceMessageEmitter;
 
     boolean isBound = false, registeredWithRouterService = false;
     private String routerPackage = null, routerClassName = null;
@@ -109,6 +110,13 @@ private void initRouterConnection() {
 
             public void onServiceConnected(ComponentName className, IBinder service) {
                 DebugTool.logInfo(TAG, "Bound to service " + className.toString());
+                routerServiceMessageEmitter = new RouterServiceMessageEmitter(new RouterServiceMessageEmitter.Callback() {
+                    @Override
+                    public boolean onMessageToSend(Message message) {
+                        return sendMessageToRouterService(message, 0);
+                    }
+                });
+                routerServiceMessageEmitter.start();
                 routerServiceMessenger = new Messenger(service);
                 isBound = true;
                 //So we just established our connection
@@ -118,7 +126,7 @@ public void onServiceConnected(ComponentName className, IBinder service) {
 
             public void onServiceDisconnected(ComponentName className) {
                 DebugTool.logInfo(TAG, "Unbound from service " + className.getClassName());
-                routerServiceMessenger = null;
+                shutDownRouterServiceMessenger();
                 registeredWithRouterService = false;
                 isBound = false;
                 onHardwareDisconnected(null, null);
@@ -127,7 +135,12 @@ public void onServiceDisconnected(ComponentName className) {
     }
 
     protected boolean sendMessageToRouterService(Message message) {
-        return sendMessageToRouterService(message, 0);
+        if (routerServiceMessageEmitter != null) {
+            routerServiceMessageEmitter.add(message);
+            routerServiceMessageEmitter.alert();
+        }
+        // Updated to only return true as we have added sending messages to SdlRouterService to be on a different thread.
+        return true;
     }
 
     protected boolean sendMessageToRouterService(Message message, int retryCount) {
@@ -152,7 +165,7 @@ protected boolean sendMessageToRouterService(Message message, int retryCount) {
                             } catch (InterruptedException e1) {
                                 e1.printStackTrace();
                             }
-                            return sendMessageToRouterService(message, retryCount++);
+                            return sendMessageToRouterService(message, ++retryCount);
                         } else {
                             //DeadObject, time to kill our connection
                             DebugTool.logInfo(TAG, "Dead object while attempting to send packet");
@@ -431,7 +444,7 @@ public boolean start() {
     public void resetSession() {
         synchronized (INIT_LOCK) {
             unregisterWithRouterService();
-            routerServiceMessenger = null;
+            shutDownRouterServiceMessenger();
             unBindFromRouterService();
             isBound = false;
         }
@@ -445,7 +458,7 @@ public void stop() {
         synchronized (INIT_LOCK) {
             unregisterWithRouterService();
             unBindFromRouterService();
-            routerServiceMessenger = null;
+            shutDownRouterServiceMessenger();
             currentContext = null;
 
         }
@@ -629,8 +642,7 @@ private void unregisterWithRouterService() {
         } else {
             DebugTool.logWarning(TAG, "Unable to unregister, not bound to router service");
         }
-
-        routerServiceMessenger = null;
+        shutDownRouterServiceMessenger();
     }
 
     protected ComponentName getRouterService() {
@@ -747,4 +759,15 @@ public void removeSession(long sessionId) {
         msg.setData(bundle);
         this.sendMessageToRouterService(msg);
     }
+
+    /**
+     * Method to shut down RouterServiceMessenger
+     */
+    private void shutDownRouterServiceMessenger() {
+        routerServiceMessenger = null;
+        if (routerServiceMessageEmitter != null) {
+            routerServiceMessageEmitter.close();
+        }
+        routerServiceMessageEmitter = null;
+    }
 }