Remove LooperExecutor and replace it with built-in HandlerThread.

webrtc/examples/androidapp/src/org/appspot/apprtc/WebSocketChannelClient.java

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.appspot.apprtc;
 
 import org.appspot.apprtc.util.AsyncHttpURLConnection;
 import org.appspot.apprtc.util.AsyncHttpURLConnection.AsyncHttpEvents;
-import org.appspot.apprtc.util.LooperExecutor;
 
+import android.os.Handler;
 import android.util.Log;
 
 import de.tavendo.autobahn.WebSocket.WebSocketConnectionObserver;
 import de.tavendo.autobahn.WebSocketConnection;
 import de.tavendo.autobahn.WebSocketException;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.LinkedList;
 
 /**
  * WebSocket client implementation.
  *
  * <p>All public methods should be called from a looper executor thread
  * passed in a constructor, otherwise exception will be thrown.
  * All events are dispatched on the same thread.
  */
 
 public class WebSocketChannelClient {
   private static final String TAG = "WSChannelRTCClient";
   private static final int CLOSE_TIMEOUT = 1000;
   private final WebSocketChannelEvents events;
-  private final LooperExecutor executor;
+  private final Handler handler;
   private WebSocketConnection ws;
   private WebSocketObserver wsObserver;
   private String wsServerUrl;
   private String postServerUrl;
   private String roomID;
   private String clientID;
   private WebSocketConnectionState state;
   private final Object closeEventLock = new Object();
   private boolean closeEvent;
   // WebSocket send queue. Messages are added to the queue when WebSocket
@@ skipping 10 matching lines @@
   /**
    * Callback interface for messages delivered on WebSocket.
    * All events are dispatched from a looper executor thread.
    */
   public interface WebSocketChannelEvents {
     void onWebSocketMessage(final String message);
     void onWebSocketClose();
     void onWebSocketError(final String description);
   }
 
-  public WebSocketChannelClient(LooperExecutor executor, WebSocketChannelEvents events) {
-    this.executor = executor;
+  public WebSocketChannelClient(Handler handler, WebSocketChannelEvents events) {
+    this.handler = handler;
     this.events = events;
     roomID = null;
     clientID = null;
     wsSendQueue = new LinkedList<String>();
     state = WebSocketConnectionState.NEW;
   }
 
   public WebSocketConnectionState getState() {
     return state;
   }
@@ skipping 112 matching lines @@
             }
           }
         }
       }
     }
     Log.d(TAG, "Disconnecting WebSocket done.");
   }
 
   private void reportError(final String errorMessage) {
     Log.e(TAG, errorMessage);
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         if (state != WebSocketConnectionState.ERROR) {
           state = WebSocketConnectionState.ERROR;
           events.onWebSocketError(errorMessage);
         }
       }
     });
   }
 
   // Asynchronously send POST/DELETE to WebSocket server.
   private void sendWSSMessage(final String method, final String message) {
     String postUrl = postServerUrl + "/" + roomID + "/" + clientID;
     Log.d(TAG, "WS " + method + " : " + postUrl + " : " + message);
     AsyncHttpURLConnection httpConnection = new AsyncHttpURLConnection(
         method, postUrl, message, new AsyncHttpEvents() {
           @Override
           public void onHttpError(String errorMessage) {
             reportError("WS " + method + " error: " + errorMessage);
           }
 
           @Override
           public void onHttpComplete(String response) {
           }
         });
     httpConnection.send();
   }
 
-   // Helper method for debugging purposes. Ensures that WebSocket method is
-   // called on a looper thread.
+  // Helper method for debugging purposes. Ensures that WebSocket method is
+  // called on a looper thread.
   private void checkIfCalledOnValidThread() {
-    if (!executor.checkOnLooperThread()) {
+    if (Thread.currentThread() != handler.getLooper().getThread()) {
       throw new IllegalStateException(
           "WebSocket method is not called on valid thread");
     }
   }
 
   private class WebSocketObserver implements WebSocketConnectionObserver {
     @Override
     public void onOpen() {
       Log.d(TAG, "WebSocket connection opened to: " + wsServerUrl);
-      executor.execute(new Runnable() {
+      handler.post(new Runnable() {
         @Override
         public void run() {
           state = WebSocketConnectionState.CONNECTED;
           // Check if we have pending register request.
           if (roomID != null && clientID != null) {
             register(roomID, clientID);
           }
         }
       });
     }
 
     @Override
     public void onClose(WebSocketCloseNotification code, String reason) {
       Log.d(TAG, "WebSocket connection closed. Code: " + code
           + ". Reason: " + reason + ". State: " + state);
       synchronized (closeEventLock) {
         closeEvent = true;
         closeEventLock.notify();
       }
-      executor.execute(new Runnable() {
+      handler.post(new Runnable() {
         @Override
         public void run() {
           if (state != WebSocketConnectionState.CLOSED) {
             state = WebSocketConnectionState.CLOSED;
             events.onWebSocketClose();
           }
         }
       });
     }
 
     @Override
     public void onTextMessage(String payload) {
       Log.d(TAG, "WSS->C: " + payload);
       final String message = payload;
-      executor.execute(new Runnable() {
+      handler.post(new Runnable() {
         @Override
         public void run() {
           if (state == WebSocketConnectionState.CONNECTED
               || state == WebSocketConnectionState.REGISTERED) {
             events.onWebSocketMessage(message);
           }
         }
       });
     }
 
     @Override
     public void onRawTextMessage(byte[] payload) {
     }
 
     @Override
     public void onBinaryMessage(byte[] payload) {
     }
   }
 
 }