content: /*
   * Copyright (C) 2011 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.net;
  
  import android.content.Context;
  import android.net.wifi.WifiInfo;
  import android.net.wifi.WifiManager;
  import android.os.Build;
  import android.telephony.TelephonyManager;
  import com.android.internal.util.Objects;
  
  import static android.net.ConnectivityManager.TYPE_WIFI;
  
  /**
   * Network definition that includes strong identity. Analogous to combining
   * {@link NetworkInfo} and an IMSI.
   *
   * @hide
   */
  public class NetworkIdentity {
      /**
       * When enabled, combine all {@link #mSubType} together under
       * {@link #SUBTYPE_COMBINED}.
       */
      public static final boolean COMBINE_SUBTYPE_ENABLED = true;
  
      public static final int SUBTYPE_COMBINED = -1;
  
      final int mType;
      final int mSubType;
      final String mSubscriberId;
      final String mNetworkId;
      final boolean mRoaming;
  
      public NetworkIdentity(
              int type, int subType, String subscriberId, String networkId, boolean roaming) {
          mType = type;
          mSubType = COMBINE_SUBTYPE_ENABLED ? SUBTYPE_COMBINED : subType;
          mSubscriberId = subscriberId;
          mNetworkId = networkId;
          mRoaming = roaming;
      }
  
      /**
       * {@hide}
       */
      public static String getNetworkTypeName(int type) {
          switch (type) {
              case 0:
                  return "MOBILE";
              case TYPE_WIFI:
                  return "WIFI";
              case 2:
                  return "MOBILE_MMS";
              case 3:
                  return "MOBILE_SUPL";
              case 4:
                  return "MOBILE_DUN";
              case 5:
                  return "MOBILE_HIPRI";
              case 6:
                  return "WIMAX";
              case 7:
                  return "BLUETOOTH";
              case 8:
                  return "DUMMY";
              case 9:
                  return "ETHERNET";
              case 10:
                  return "MOBILE_FOTA";
              case 11:
                  return "MOBILE_IMS";
              case 12:
                  return "MOBILE_CBS";
              case 13:
                  return "WIFI_P2P";
              default:
                  return Integer.toString(type);
          }
      }
  
      /**
       * {@hide}
       */
      public static boolean isNetworkTypeMobile(int networkType) {
          switch (networkType) {
              case 0:
              case 2:
              case 3:
              case 4:
              case 5:
              case 10:
              case 11:
              case 12:
                  return true;
              default:
                  return false;
          }
      }
  
      @Override
      public int hashCode() {
          return Objects.hashCode(mType, mSubType, mSubscriberId, mNetworkId, mRoaming);
      }
  
      @Override
      public boolean equals(Object obj) {
          if (obj instanceof NetworkIdentity) {
              final NetworkIdentity ident = (NetworkIdentity) obj;
              return mType == ident.mType && mSubType == ident.mSubType && mRoaming == ident.mRoaming
                      && Objects.equal(mSubscriberId, ident.mSubscriberId)
                      && Objects.equal(mNetworkId, ident.mNetworkId);
          }
          return false;
      }
  
      @Override
      public String toString() {
          final StringBuilder builder = new StringBuilder("[");
          builder.append("type=").append(getNetworkTypeName(mType));
          builder.append(", subType=");
          if (COMBINE_SUBTYPE_ENABLED) {
              builder.append("COMBINED");
          } else if (isNetworkTypeMobile(mType)) {
              builder.append(getNetworkTypeName(mSubType));
          } else {
              builder.append(mSubType);
          }
          if (mSubscriberId != null) {
              builder.append(", subscriberId=").append(scrubSubscriberId(mSubscriberId));
          }
          if (mNetworkId != null) {
              builder.append(", networkId=").append(mNetworkId);
          }
          if (mRoaming) {
              builder.append(", ROAMING");
          }
          return builder.append("]").toString();
      }
  
      public int getType() {
          return mType;
      }
  
      public int getSubType() {
          return mSubType;
      }
  
      public String getSubscriberId() {
          return mSubscriberId;
      }
  
      public String getNetworkId() {
          return mNetworkId;
      }
  
      public boolean getRoaming() {
          return mRoaming;
      }
  
      /**
       * Scrub given IMSI on production builds.
       */
      public static String scrubSubscriberId(String subscriberId) {
          if ("eng".equals(Build.TYPE)) {
              return subscriberId;
          } else if (subscriberId != null) {
              // TODO: parse this as MCC+MNC instead of hard-coding
              return subscriberId.substring(0, Math.min(6, subscriberId.length())) + "...";
          } else {
              return "null";
          }
      }
  
      /**
       * Build a {@link NetworkIdentity} from the given {@link NetworkState},
       * assuming that any mobile networks are using the current IMSI.
       */
      public static NetworkIdentity buildNetworkIdentity(Context context, NetworkState state) {
          final int type = state.networkInfo.getType();
          final int subType = state.networkInfo.getSubtype();
  
          // TODO: consider moving subscriberId over to LinkCapabilities, so it
          // comes from an authoritative source.
  
          String subscriberId = null;
          String networkId = null;
          boolean roaming = false;
  
          if (isNetworkTypeMobile(type)) {
              final TelephonyManager telephony = (TelephonyManager) context.getSystemService(
                      Context.TELEPHONY_SERVICE);
              roaming = telephony.isNetworkRoaming();
              if (state.subscriberId != null) {
                  subscriberId = state.subscriberId;
              } else {
                  subscriberId = telephony.getSubscriberId();
              }
  
          } else if (type == TYPE_WIFI) {
              if (state.networkId != null) {
                  networkId = state.networkId;
              } else {
                  final WifiManager wifi = (WifiManager) context.getSystemService(
                          Context.WIFI_SERVICE);
                  final WifiInfo info = wifi.getConnectionInfo();
                  networkId = info != null ? info.getSSID() : null;
              }
          }
  
          return new NetworkIdentity(type, subType, subscriberId, networkId, roaming);
      }
  }
  