The Tor Browser: mobile/android/base/GeckoNetworkManager.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoNetworkManager.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoNetworkManager.java

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 package org.mozilla.gecko;
 import org.mozilla.gecko.mozglue.JNITarget;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.net.ConnectivityManager;
 import android.net.DhcpInfo;
 import android.net.NetworkInfo;
 import android.net.wifi.WifiManager;
 import android.telephony.TelephonyManager;
 import android.util.Log;
 /*
  * A part of the work of GeckoNetworkManager is to give an general connection
  * type based on the current connection. According to spec of NetworkInformation
  * API version 3, connection types include: bluetooth, cellular, ethernet, none,
  * wifi and other. The objective of providing such general connection is due to
  * some security concerns. In short, we don't want to expose the information of
  * exact network type, especially the cellular network type.
  *
  * Current connection is firstly obtained from Android's ConnectivityManager,
  * which is represented by the constant, and then will be mapped into the
  * connection type defined in Network Information API version 3.
  */
 public class GeckoNetworkManager extends BroadcastReceiver {
     private static final String LOGTAG = "GeckoNetworkManager";
     static private final GeckoNetworkManager sInstance = new GeckoNetworkManager();
     // Connection Type defined in Network Information API v3.
     private enum ConnectionType {
         CELLULAR(0),
         BLUETOOTH(1),
         ETHERNET(2),
         WIFI(3),
         OTHER(4),
         NONE(5);
         public final int value;
         private ConnectionType(int value) {
             this.value = value;
         }
     }
     private enum InfoType {
         MCC,
         MNC
     }
     private ConnectionType mConnectionType = ConnectionType.NONE;
     private final IntentFilter mNetworkFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
     // Whether the manager should be listening to Network Information changes.
     private boolean mShouldBeListening = false;
     // Whether the manager should notify Gecko that a change in Network
     // Information happened.
     private boolean mShouldNotify = false;
     // The application context used for registering receivers, so
     // we can unregister them again later.
     private volatile Context mApplicationContext;
     public static GeckoNetworkManager getInstance() {
         return sInstance;
     }
     @Override
     public void onReceive(Context aContext, Intent aIntent) {
         updateConnectionType();
     }
     public void start(final Context context) {
         // Note that this initialization clause only runs once.
         mApplicationContext = context.getApplicationContext();
         if (mConnectionType == ConnectionType.NONE) {
             mConnectionType = getConnectionType();
         }
         mShouldBeListening = true;
         updateConnectionType();
         if (mShouldNotify) {
             startListening();
         }
     }
     private void startListening() {
         final Context appContext = mApplicationContext;
         if (appContext == null) {
             Log.w(LOGTAG, "Not registering receiver: no context!");
             return;
         }
         Log.v(LOGTAG, "Registering receiver.");
         appContext.registerReceiver(this, mNetworkFilter);
     }
     public void stop() {
         mShouldBeListening = false;
         if (mShouldNotify) {
             stopListening();
         }
     }
     private void stopListening() {
         if (null == mApplicationContext) {
             return;
         }
         mApplicationContext.unregisterReceiver(this);
     }
     private int wifiDhcpGatewayAddress() {
         if (mConnectionType != ConnectionType.WIFI) {
             return 0;
         }
         if (null == mApplicationContext) {
             return 0;
         }
         try {
             WifiManager mgr = (WifiManager) mApplicationContext.getSystemService(Context.WIFI_SERVICE);
             DhcpInfo d = mgr.getDhcpInfo();
             if (d == null) {
                 return 0;
             }
             return d.gateway;
         } catch (Exception ex) {
             // getDhcpInfo() is not documented to require any permissions, but on some devices
             // requires android.permission.ACCESS_WIFI_STATE. Just catch the generic exception
             // here and returning 0. Not logging because this could be noisy.
             return 0;
         }
     }
     private void updateConnectionType() {
         ConnectionType previousConnectionType = mConnectionType;
         mConnectionType = getConnectionType();
         if (mConnectionType == previousConnectionType || !mShouldNotify) {
             return;
         }
         GeckoAppShell.sendEventToGecko(GeckoEvent.createNetworkEvent(
                                        mConnectionType.value,
                                        mConnectionType == ConnectionType.WIFI,
                                        wifiDhcpGatewayAddress()));
     }
     public double[] getCurrentInformation() {
         return new double[] { mConnectionType.value,
                               (mConnectionType == ConnectionType.WIFI) ? 1.0 : 0.0,
                               wifiDhcpGatewayAddress()};
     }
     public void enableNotifications() {
         // We set mShouldNotify *after* calling updateConnectionType() to make sure we
         // don't notify an eventual change in mConnectionType.
         mConnectionType = ConnectionType.NONE; // force a notification
         updateConnectionType();
         mShouldNotify = true;
         if (mShouldBeListening) {
             startListening();
         }
     }
     public void disableNotifications() {
         mShouldNotify = false;
         if (mShouldBeListening) {
             stopListening();
         }
     }
     private ConnectionType getConnectionType() {
         final Context appContext = mApplicationContext;
         if (null == appContext) {
             return ConnectionType.NONE;
         }
         ConnectivityManager cm = (ConnectivityManager) appContext.getSystemService(Context.CONNECTIVITY_SERVICE);
         if (cm == null) {
             Log.e(LOGTAG, "Connectivity service does not exist");
             return ConnectionType.NONE;
         }
         NetworkInfo ni = null;
         try {
             ni = cm.getActiveNetworkInfo();
         } catch (SecurityException se) {} // if we don't have the permission, fall through to null check
         if (ni == null) {
             return ConnectionType.NONE;
         }
         switch (ni.getType()) {
         case ConnectivityManager.TYPE_BLUETOOTH:
             return ConnectionType.BLUETOOTH;
         case ConnectivityManager.TYPE_ETHERNET:
             return ConnectionType.ETHERNET;
         case ConnectivityManager.TYPE_MOBILE:
         case ConnectivityManager.TYPE_WIMAX:
             return ConnectionType.CELLULAR;
         case ConnectivityManager.TYPE_WIFI:
             return ConnectionType.WIFI;
         default:
             Log.w(LOGTAG, "Ignoring the current network type.");
             return ConnectionType.OTHER;
         }
     }
     private static int getNetworkOperator(InfoType type, Context context) {
         if (null == context) {
             return -1;
         }
         TelephonyManager tel = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
         if (tel == null) {
             Log.e(LOGTAG, "Telephony service does not exist");
             return -1;
         }
         String networkOperator = tel.getNetworkOperator();
         if (networkOperator == null || networkOperator.length() <= 3) {
             return -1;
         }
         if (type == InfoType.MNC) {
             return Integer.parseInt(networkOperator.substring(3));
         } else if (type == InfoType.MCC) {
             return Integer.parseInt(networkOperator.substring(0, 3));
         }
         return -1;
     }
     /**
      * These are called from JavaScript ctypes. Avoid letting ProGuard delete them.
      *
      * Note that these methods must only be called after GeckoAppShell has been
      * initialized: they depend on access to the context.
      */
     @JNITarget
     public static int getMCC() {
         return getNetworkOperator(InfoType.MCC, GeckoAppShell.getContext().getApplicationContext());
     }
     @JNITarget
     public static int getMNC() {
         return getNetworkOperator(InfoType.MNC, GeckoAppShell.getContext().getApplicationContext());
     }
 }

The Tor Browser / annotate

mobile/android/base/GeckoNetworkManager.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoNetworkManager.java