Remove LooperExecutor and replace it with built-in HandlerThread.

webrtc/examples/androidapp/src/org/appspot/apprtc/WebSocketRTCClient.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.RoomParametersFetcher.RoomParametersFetcherEvents;
 import org.appspot.apprtc.WebSocketChannelClient.WebSocketChannelEvents;
 import org.appspot.apprtc.WebSocketChannelClient.WebSocketConnectionState;
 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.os.HandlerThread;
 import android.util.Log;
 
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.webrtc.IceCandidate;
 import org.webrtc.SessionDescription;
 
 /**
  * Negotiates signaling for chatting with https://appr.tc "rooms".
@@ skipping 11 matching lines @@
   private static final String ROOM_JOIN = "join";
   private static final String ROOM_MESSAGE = "message";
   private static final String ROOM_LEAVE = "leave";
 
   private enum ConnectionState {
     NEW, CONNECTED, CLOSED, ERROR
   };
   private enum MessageType {
     MESSAGE, LEAVE
   };
-  private final LooperExecutor executor;
+  private final Handler handler;
   private boolean initiator;
   private SignalingEvents events;
   private WebSocketChannelClient wsClient;
   private ConnectionState roomState;
   private RoomConnectionParameters connectionParameters;
   private String messageUrl;
   private String leaveUrl;
 
-  public WebSocketRTCClient(SignalingEvents events, LooperExecutor executor) {
+  public WebSocketRTCClient(SignalingEvents events) {
     this.events = events;
-    this.executor = executor;
     roomState = ConnectionState.NEW;
-    executor.requestStart();
+    final HandlerThread handlerThread = new HandlerThread(TAG);
+    handlerThread.start();
+    handler = new Handler(handlerThread.getLooper());
   }
 
   // --------------------------------------------------------------------
   // AppRTCClient interface implementation.
   // Asynchronously connect to an AppRTC room URL using supplied connection
   // parameters, retrieves room parameters and connect to WebSocket server.
   @Override
   public void connectToRoom(RoomConnectionParameters connectionParameters) {
     this.connectionParameters = connectionParameters;
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         connectToRoomInternal();
       }
     });
   }
 
   @Override
   public void disconnectFromRoom() {
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         disconnectFromRoomInternal();
+        handler.getLooper().quit();
       }
     });
-    executor.requestStop();
   }
 
   // Connects to room - function runs on a local looper thread.
   private void connectToRoomInternal() {
     String connectionUrl = getConnectionUrl(connectionParameters);
     Log.d(TAG, "Connect to room: " + connectionUrl);
     roomState = ConnectionState.NEW;
-    wsClient = new WebSocketChannelClient(executor, this);
+    wsClient = new WebSocketChannelClient(handler, this);
 
     RoomParametersFetcherEvents callbacks = new RoomParametersFetcherEvents() {
       @Override
       public void onSignalingParametersReady(
           final SignalingParameters params) {
-        WebSocketRTCClient.this.executor.execute(new Runnable() {
+        WebSocketRTCClient.this.handler.post(new Runnable() {
           @Override
           public void run() {
             WebSocketRTCClient.this.signalingParametersReady(params);
           }
         });
       }
 
       @Override
       public void onSignalingParametersError(String description) {
         WebSocketRTCClient.this.reportError(description);
@@ skipping 62 matching lines @@
     events.onConnectedToRoom(signalingParameters);
 
     // Connect and register WebSocket client.
     wsClient.connect(signalingParameters.wssUrl, signalingParameters.wssPostUrl);
     wsClient.register(connectionParameters.roomId, signalingParameters.clientId);
   }
 
   // Send local offer SDP to the other participant.
   @Override
   public void sendOfferSdp(final SessionDescription sdp) {
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         if (roomState != ConnectionState.CONNECTED) {
           reportError("Sending offer SDP in non connected state.");
           return;
         }
         JSONObject json = new JSONObject();
         jsonPut(json, "sdp", sdp.description);
         jsonPut(json, "type", "offer");
         sendPostMessage(MessageType.MESSAGE, messageUrl, json.toString());
         if (connectionParameters.loopback) {
           // In loopback mode rename this offer to answer and route it back.
           SessionDescription sdpAnswer = new SessionDescription(
               SessionDescription.Type.fromCanonicalForm("answer"),
               sdp.description);
           events.onRemoteDescription(sdpAnswer);
         }
       }
     });
   }
 
   // Send local answer SDP to the other participant.
   @Override
   public void sendAnswerSdp(final SessionDescription sdp) {
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         if (connectionParameters.loopback) {
           Log.e(TAG, "Sending answer in loopback mode.");
           return;
         }
         JSONObject json = new JSONObject();
         jsonPut(json, "sdp", sdp.description);
         jsonPut(json, "type", "answer");
         wsClient.send(json.toString());
       }
     });
   }
 
   // Send Ice candidate to the other participant.
   @Override
   public void sendLocalIceCandidate(final IceCandidate candidate) {
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         JSONObject json = new JSONObject();
         jsonPut(json, "type", "candidate");
         jsonPut(json, "label", candidate.sdpMLineIndex);
         jsonPut(json, "id", candidate.sdpMid);
         jsonPut(json, "candidate", candidate.sdp);
         if (initiator) {
           // Call initiator sends ice candidates to GAE server.
           if (roomState != ConnectionState.CONNECTED) {
             reportError("Sending ICE candidate in non connected state.");
             return;
           }
           sendPostMessage(MessageType.MESSAGE, messageUrl, json.toString());
           if (connectionParameters.loopback) {
             events.onRemoteIceCandidate(candidate);
           }
         } else {
           // Call receiver sends ice candidates to websocket server.
           wsClient.send(json.toString());
         }
       }
     });
   }
 
   // Send removed Ice candidates to the other participant.
   @Override
   public void sendLocalIceCandidateRemovals(final IceCandidate[] candidates) {
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         JSONObject json = new JSONObject();
         jsonPut(json, "type", "remove-candidates");
         JSONArray jsonArray =  new JSONArray();
         for (final IceCandidate candidate : candidates) {
           jsonArray.put(toJsonCandidate(candidate));
         }
         jsonPut(json, "candidates", jsonArray);
         if (initiator) {
@@ skipping 82 matching lines @@
 
   @Override
   public void onWebSocketError(String description) {
     reportError("WebSocket error: " + description);
   }
 
   // --------------------------------------------------------------------
   // Helper functions.
   private void reportError(final String errorMessage) {
     Log.e(TAG, errorMessage);
-    executor.execute(new Runnable() {
+    handler.post(new Runnable() {
       @Override
       public void run() {
         if (roomState != ConnectionState.ERROR) {
           roomState = ConnectionState.ERROR;
           events.onChannelError(errorMessage);
         }
       }
     });
   }
 
@@ skipping 48 matching lines @@
     return json;
   }
 
   // Converts a JSON candidate to a Java object.
   IceCandidate toJavaCandidate(JSONObject json) throws JSONException {
     return new IceCandidate(json.getString("id"),
                             json.getInt("label"),
                             json.getString("candidate"));
   }
 }