Implementing Host List Context Menu and Delete Feature

remoting/android/java/src/org/chromium/chromoting/HostListManager.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chromoting;
 
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
 
@@ skipping 16 matching lines @@
 /** Helper for fetching and modifying the host list. */
 public class HostListManager {
     public enum Error {
         AUTH_FAILED,
         NETWORK_ERROR,
         SERVICE_UNAVAILABLE,
         UNEXPECTED_RESPONSE,
         UNKNOWN,
     }
 
+    public enum RequestType {
+        RETRIEVE_HOST_LIST,
+        UPDATE_HOST,
+        DELETE_HOST
+    }
+
     /** Callback for receiving the host list, or getting notified of an error. */
     public interface Callback {
         void onHostListReceived(HostInfo[] response);
         void onHostUpdated();
         void onHostDeleted();
-        void onError(Error error);
+        void onError(RequestType type, Error error);
     }
 
     /**
      * Represents a response from the directory server.
      * If the request failed, |error| will not be null and |body| will be null.
      * If the request succeeds, |error| will be null and |body| will not be null.
      **/
     private static class Response {
         public final Error error;
         public final String body;
@@ skipping 41 matching lines @@
             @Override
             public void run() {
                 doRetrieveHostList(authToken, callback);
             }
         });
     }
 
     private void doRetrieveHostList(String authToken, Callback callback) {
         Response response = sendRequest(authToken, HOST_LIST_PATH, "GET", null, null);
         if (response.error != null) {
-            postError(callback, response.error);
+            postError(callback, RequestType.RETRIEVE_HOST_LIST, response.error);
             return;
         }
 
         // Parse directory response.
         ArrayList<HostInfo> hostList = new ArrayList<HostInfo>();
         try {
             JSONObject data = new JSONObject(response.body).getJSONObject("data");
             if (data.has("items")) {
                 JSONArray hostsJson = data.getJSONArray("items");
 
                 int index = 0;
                 while (!hostsJson.isNull(index)) {
                     JSONObject hostJson = hostsJson.getJSONObject(index);
                     // If a host is only recently registered, it may be missing some of the keys
                     // below. It should still be visible in the list, even though a connection
                     // attempt will fail because of the missing keys. The failed attempt will
                     // trigger reloading of the host-list, by which time the keys will hopefully be
                     // present, and the retried connection can succeed.
                     HostInfo host = HostInfo.create(hostJson);
                     hostList.add(host);
                     ++index;
                 }
             }
         } catch (JSONException ex) {
             // Logging the exception stack trace may be too spammy.
             Log.e(TAG, "Error parsing host list response: %s", ex.getMessage());
-            postError(callback, Error.UNEXPECTED_RESPONSE);
+            postError(callback, RequestType.RETRIEVE_HOST_LIST, Error.UNEXPECTED_RESPONSE);
             return;
         }
 
         sortHosts(hostList);
 
         final Callback callbackFinal = callback;
         final HostInfo[] hosts = hostList.toArray(new HostInfo[hostList.size()]);
         mMainThread.post(new Runnable() {
             @Override
             public void run() {
                 callbackFinal.onHostListReceived(hosts);
             }
         });
     }
 
     /**
      * Updates a host on the background thread. On success, callback.onHostUpdated() will be called,
      * otherwise callback.onError() will be called with an error-code describing the failure.
      */
-    public void putHost(final String authToken, final String hostId, final String hostName,
+    public void updateHost(final String authToken, final String hostId, final String hostName,
                         final String publicKey, final Callback callback) {
         runOnNetworkThread(new Runnable() {
             @Override
             public void run() {
-                doPutHost(authToken, hostId, hostName, publicKey, callback);
+                doUpdateHost(authToken, hostId, hostName, publicKey, callback);
             }
         });
     }
 
-    private void doPutHost(String authToken, String hostId, String hostName, String publicKey,
+    private void doUpdateHost(String authToken, String hostId, String hostName, String publicKey,
                            final Callback callback) {
         String requestJson;
         try {
             JSONObject data = new JSONObject();
             data.put("hostId", hostId);
             data.put("hostName", hostName);
             data.put("publicKey", publicKey);
             JSONObject request = new JSONObject();
             request.put("data", data);
             requestJson = request.toString();
         } catch (JSONException ex) {
             Log.e(TAG, "Error creating put host JSON string: %s", ex.getMessage());
-            postError(callback, Error.UNKNOWN);
+            postError(callback, RequestType.UPDATE_HOST, Error.UNKNOWN);
             return;
         }
         Response response = sendRequest(authToken, HOST_LIST_PATH + '/' + hostId, "PUT",
                 "application/json", requestJson);
         if (response.error != null) {
-            postError(callback, response.error);
+            postError(callback, RequestType.UPDATE_HOST, response.error);
         } else {
             mMainThread.post(new Runnable() {
                 @Override
                 public void run() {
                     callback.onHostUpdated();
                 }
             });
         }
     }
 
     /**
      * Deletes a host on the background thread. On success, callback.onHostUpdated() will be called,
      * otherwise callback.onError() will be called with an error-code describing the failure.
      */
     public void deleteHost(final String authToken, final String hostId,
                            final Callback callback) {
         runOnNetworkThread(new Runnable() {
             @Override
             public void run() {
                 doDeleteHost(authToken, hostId, callback);
             }
         });
     }
 
     private void doDeleteHost(String authToken, String hostId, final Callback callback) {
         Response response = sendRequest(authToken, HOST_LIST_PATH + '/' + hostId, "DELETE",
                 null, null);
         if (response.error != null) {
-            postError(callback, response.error);
+            postError(callback, RequestType.DELETE_HOST, response.error);
         } else {
             mMainThread.post(new Runnable() {
                 @Override
                 public void run() {
                     callback.onHostDeleted();
                 }
             });
         }
     }
 
     /** Posts error to callback on main thread. */
-    private void postError(Callback callback, Error error) {
-        final Callback callbackFinal = callback;
-        final Error errorFinal = error;
+    private void postError(final Callback callback, final RequestType type, final Error error) {
         mMainThread.post(new Runnable() {
             @Override
             public void run() {
-                callbackFinal.onError(errorFinal);
+                callback.onError(type, error);
             }
         });
     }
 
     private static void sortHosts(ArrayList<HostInfo> hosts) {
         Comparator<HostInfo> hostComparator = new Comparator<HostInfo>() {
             @Override
             public int compare(HostInfo a, HostInfo b) {
                 if (a.isOnline != b.isOnline) {
                     return a.isOnline ? -1 : 1;
@@ skipping 30 matching lines @@
                 byte[] requestBytes = requestBody.getBytes("UTF-8");
                 OutputStream outStream = link.getOutputStream();
                 outStream.write(requestBytes);
                 outStream.close();
             }
 
             // Listen for the server to respond.
             int status = link.getResponseCode();
             switch (status) {
                 case HttpURLConnection.HTTP_OK:  // 200
+                case HttpURLConnection.HTTP_NO_CONTENT:  // 204
                     break;
                 case HttpURLConnection.HTTP_UNAUTHORIZED:  // 401
                     error = Error.AUTH_FAILED;
                     break;
                 case HttpURLConnection.HTTP_BAD_GATEWAY:  // 502
                 case HttpURLConnection.HTTP_UNAVAILABLE:  // 503
                     error = Error.SERVICE_UNAVAILABLE;
                     break;
                 default:
                     error = Error.UNKNOWN;
@@ skipping 15 matching lines @@
             throw new RuntimeException("Unexpected error while fetching host list: ", ex);
         } catch (IOException ex) {
             return new Response(Error.NETWORK_ERROR, null);
         } finally {
             if (link != null) {
                 link.disconnect();
             }
         }
     }
 }