[Feedback] Add connection type data to feedback reports.

chrome/android/java/src/org/chromium/chrome/browser/feedback/ConnectivityTask.java

 // Copyright 2015 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.chrome.browser.feedback;
 
 import android.os.SystemClock;
 
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.browser.profiles.Profile;
+import org.chromium.net.ConnectionType;
+import org.chromium.net.NetworkChangeNotifier;
 
 import java.util.Collections;
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.Map;
 
 import javax.annotation.Nullable;
 
 /**
  * A utility class for checking if the device is currently connected to the Internet by using
@@ skipping 12 matching lines @@
 
     /**
      * The key for the data describing how long time from the connection check was started,
      * until the data was collected. This is to better understand the connection data.
      * This string is user visible.
      */
     @VisibleForTesting
     static final String CONNECTION_CHECK_ELAPSED_KEY = "Connection check elapsed (ms)";
 
     /**
+     * The key for the data describing the current connection type.
+     * This string is user visible.
+     */
+    @VisibleForTesting
+    static final String CONNECTION_TYPE_KEY = "Connection type";
+
+    /**
+     * The key for the data describing the bandwidth of the current connection. The data is
+     * represented as Mbps.
+     * This string is user visible.
+     */
+    @VisibleForTesting
+    static final String CONNECTION_BANDWIDTH_KEY = "Connection bandwidth (Mbps)";
+
+    /**
      * The key for the data describing whether Chrome was able to successfully connect to the
      * HTTP connection check URL using the Chrome network stack.
      * This string is user visible.
      */
     @VisibleForTesting
     static final String CHROME_HTTP_KEY = "HTTP connection check (Chrome network stack)";
 
     /**
      * The key for the data describing whether Chrome was able to successfully connect to the
      * HTTPS connection check URL using the Chrome network stack.
@@ skipping 11 matching lines @@
     static final String SYSTEM_HTTP_KEY = "HTTP connection check (Android network stack)";
 
     /**
      * The key for the data describing whether Chrome was able to successfully connect to the
      * HTTPS connection check URL using the Android network stack.
      * This string is user visible.
      */
     @VisibleForTesting
     static final String SYSTEM_HTTPS_KEY = "HTTPS connection check (Android network stack)";
 
-    private static String getHumanReadableString(Type type) {
+    private static String getHumanReadableType(Type type) {
         switch (type) {
             case CHROME_HTTP:
                 return CHROME_HTTP_KEY;
             case CHROME_HTTPS:
                 return CHROME_HTTPS_KEY;
             case SYSTEM_HTTP:
                 return SYSTEM_HTTP_KEY;
             case SYSTEM_HTTPS:
                 return SYSTEM_HTTPS_KEY;
             default:
                 throw new IllegalArgumentException("Unknown connection type: " + type);
         }
     }
 
-    static String getHumanReadableString(int result) {
+    static String getHumanReadableResult(int result) {
         switch (result) {
             case ConnectivityCheckResult.UNKNOWN:
                 return "UNKNOWN";
             case ConnectivityCheckResult.CONNECTED:
                 return "CONNECTED";
             case ConnectivityCheckResult.NOT_CONNECTED:
                 return "NOT_CONNECTED";
             case ConnectivityCheckResult.TIMEOUT:
                 return "TIMEOUT";
             case ConnectivityCheckResult.ERROR:
                 return "ERROR";
             default:
                 throw new IllegalArgumentException("Unknown result value: " + result);
         }
     }
 
+    static String getHumanReadableConnectionType(int connectionType) {
+        switch (connectionType) {
+            case ConnectionType.CONNECTION_UNKNOWN:
+                return "Unknown";
+            case ConnectionType.CONNECTION_ETHERNET:
+                return "Ethernet";
+            case ConnectionType.CONNECTION_WIFI:
+                return "WiFi";
+            case ConnectionType.CONNECTION_2G:
+                return "2G";
+            case ConnectionType.CONNECTION_3G:
+                return "3G";
+            case ConnectionType.CONNECTION_4G:
+                return "4G";
+            case ConnectionType.CONNECTION_NONE:
+                return "NONE";
+            case ConnectionType.CONNECTION_BLUETOOTH:
+                return "Bluetooth";
+            default:
+                return "Unknown connection type " + connectionType;
+        }
+    }
+
     /**
      * ConnectivityResult is the callback for when the result of a connectivity check is ready.
      */
     interface ConnectivityResult {
         /**
          * Called when the FeedbackData is ready.
          */
         void onResult(FeedbackData feedbackData);
     }
 
     /**
      * FeedbackData contains the set of information that is to be included in a feedback report.
      */
     static final class FeedbackData {
         private final Map<Type, Integer> mConnections;
         private final int mTimeoutMs;
         private final long mElapsedTimeMs;
+        private final int mConnectionType;
+        private final double mBandwidthInMbps;
 
-        FeedbackData(Map<Type, Integer> connections, int timeoutMs, long elapsedTimeMs) {
+        FeedbackData(Map<Type, Integer> connections, int timeoutMs, long elapsedTimeMs,
+                int connectionType, double bandwidthInMbps) {
             mConnections = connections;
             mTimeoutMs = timeoutMs;
             mElapsedTimeMs = elapsedTimeMs;
+            mConnectionType = connectionType;
+            mBandwidthInMbps = bandwidthInMbps;
         }
 
         /**
          * @return a {@link Map} with information about connection status for different connection
          * types.
          */
         @VisibleForTesting
         Map<Type, Integer> getConnections() {
             return Collections.unmodifiableMap(mConnections);
         }
@@ skipping 13 matching lines @@
         long getElapsedTimeMs() {
             return mElapsedTimeMs;
         }
 
         /**
          * @return a {@link Map} with all the data fields for this feedback.
          */
         Map<String, String> toMap() {
             Map<String, String> map = new HashMap<>();
             for (Map.Entry<Type, Integer> entry : mConnections.entrySet()) {
-                map.put(getHumanReadableString(entry.getKey()),
-                        getHumanReadableString(entry.getValue()));
+                map.put(getHumanReadableType(entry.getKey()),
+                        getHumanReadableResult(entry.getValue()));
             }
             map.put(CONNECTION_CHECK_TIMEOUT_KEY, String.valueOf(mTimeoutMs));
             map.put(CONNECTION_CHECK_ELAPSED_KEY, String.valueOf(mElapsedTimeMs));
+            map.put(CONNECTION_TYPE_KEY, getHumanReadableConnectionType(mConnectionType));
+            map.put(CONNECTION_BANDWIDTH_KEY, String.valueOf(mBandwidthInMbps));
             return map;
         }
     }
 
     /**
      * The type of network stack and connectivity check this result is about.
      */
     public enum Type { CHROME_HTTP, CHROME_HTTPS, SYSTEM_HTTP, SYSTEM_HTTPS }
 
     private class SingleTypeTask implements ConnectivityChecker.ConnectivityCheckerCallback {
@@ skipping 26 matching lines @@
                     ConnectivityChecker.checkConnectivitySystemNetworkStack(true, timeoutMs, this);
                     break;
                 default:
                     Log.e(TAG, "Failed to recognize type " + mType);
             }
         }
 
         @Override
         public void onResult(int result) {
             ThreadUtils.assertOnUiThread();
-            Log.v(TAG, "Got result for " + getHumanReadableString(mType) + ": result = "
-                            + getHumanReadableString(result));
+            Log.v(TAG, "Got result for " + getHumanReadableType(mType) + ": result = "
+                            + getHumanReadableResult(result));
             mResult.put(mType, result);
             if (isDone()) postCallbackResult();
         }
 
         private void postCallbackResult() {
             if (mCallback == null) return;
             ThreadUtils.postOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     mCallback.onResult(get());
@@ skipping 42 matching lines @@
         Map<Type, Integer> result = new EnumMap<Type, Integer>(Type.class);
         // Ensure the map is filled with a result for all {@link Type}s.
         for (Type type : Type.values()) {
             if (mResult.containsKey(type)) {
                 result.put(type, mResult.get(type));
             } else {
                 result.put(type, ConnectivityCheckResult.UNKNOWN);
             }
         }
         long elapsedTimeMs = SystemClock.elapsedRealtime() - mStartCheckTimeMs;
-        return new FeedbackData(result, mTimeoutMs, elapsedTimeMs);
+        NetworkChangeNotifier ncn = NetworkChangeNotifier.getInstance();
+        int connectionType = ncn.getCurrentConnectionType();
+        double bandwidthInMbps = ncn.getCurrentMaxBandwidthInMbps();
+        return new FeedbackData(result, mTimeoutMs, elapsedTimeMs, connectionType, bandwidthInMbps);
     }
 
     /**
      * Starts an asynchronous request for checking whether the device is currently connected to the
      * Internet using both the Chrome and the Android system network stack.
      *
      * The result will be given back in the {@link ConnectivityResult} callback that is passed in,
      * either when all results have been gathered successfully or if a timeout happened. The result
      * can also be retrieved by calling {@link #get}, and this call must happen from the main
      * thread. {@link #isDone} can be used to see if all requests have been completed. It is OK to
      * get the result before {@link #isDone()} returns true.
      *
      * @param profile the context to do the check in.
      * @param timeoutMs number of milliseconds to wait before giving up waiting for a connection.
      * @param callback the callback for the result. May be null.
      * @return a ConnectivityTask to retrieve the results.
      */
     public static ConnectivityTask create(
             Profile profile, int timeoutMs, @Nullable ConnectivityResult callback) {
         ThreadUtils.assertOnUiThread();
         return new ConnectivityTask(profile, timeoutMs, callback);
     }
 }