src/com/android/settings/ApnSettings.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings;
  18
  19 import android.app.Activity;
  20 import android.app.Dialog;
  21 import android.app.ProgressDialog;
  22 import android.content.BroadcastReceiver;
  23 import android.content.ContentResolver;
  24 import android.content.ContentUris;
  25 import android.content.ContentValues;
  26 import android.content.Context;
  27 import android.content.Intent;
  28 import android.content.IntentFilter;
  29 import android.database.Cursor;
  30 import android.net.Uri;
  31 import android.os.Bundle;
  32 import android.os.Handler;
  33 import android.os.HandlerThread;
  34 import android.os.Looper;
  35 import android.os.Message;
  36 import android.os.UserManager;
  37 import android.preference.Preference;
  38 import android.preference.PreferenceActivity;
  39 import android.preference.PreferenceGroup;
  40 import android.preference.PreferenceScreen;
  41 import android.provider.Telephony;
  42 import android.telephony.SubscriptionInfo;
  43 import android.util.Log;
  44 import android.view.LayoutInflater;
  45 import android.view.Menu;
  46 import android.view.MenuInflater;
  47 import android.view.MenuItem;
  48 import android.view.View;
  49 import android.widget.TextView;
  50 import android.widget.Toast;
  51
  52 import com.android.internal.telephony.Phone;
  53 import com.android.internal.telephony.PhoneConstants;
  54 import com.android.internal.telephony.TelephonyIntents;
  55 import com.android.internal.telephony.TelephonyProperties;
  56 import android.telephony.TelephonyManager;
  57
  58 import java.util.ArrayList;
  59
  60 public class ApnSettings extends SettingsPreferenceFragment implements
  61         Preference.OnPreferenceChangeListener {
  62     static final String TAG = "ApnSettings";
  63
  64     public static final String EXTRA_POSITION = "position";
  65     public static final String RESTORE_CARRIERS_URI =
  66         "content://telephony/carriers/restore";
  67     public static final String PREFERRED_APN_URI =
  68         "content://telephony/carriers/preferapn";
  69
  70     public static final String APN_ID = "apn_id";
  71
  72     private static final int ID_INDEX = 0;
  73     private static final int NAME_INDEX = 1;
  74     private static final int APN_INDEX = 2;
  75     private static final int TYPES_INDEX = 3;
  76
  77     private static final int MENU_NEW = Menu.FIRST;
  78     private static final int MENU_RESTORE = Menu.FIRST + 1;
  79
  80     private static final int EVENT_RESTORE_DEFAULTAPN_START = 1;
  81     private static final int EVENT_RESTORE_DEFAULTAPN_COMPLETE = 2;
  82
  83     private static final int DIALOG_RESTORE_DEFAULTAPN = 1001;
  84
  85     private static final Uri DEFAULTAPN_URI = Uri.parse(RESTORE_CARRIERS_URI);
  86     private static final Uri PREFERAPN_URI = Uri.parse(PREFERRED_APN_URI);
  87
  88     private static boolean mRestoreDefaultApnMode;
  89
  90     private RestoreApnUiHandler mRestoreApnUiHandler;
  91     private RestoreApnProcessHandler mRestoreApnProcessHandler;
  92     private HandlerThread mRestoreDefaultApnThread;
  93     private SubscriptionInfo mSubscriptionInfo;
  94
  95     private UserManager mUm;
  96
  97     private String mSelectedKey;
  98
  99     private IntentFilter mMobileStateFilter;
 100
 101     private boolean mUnavailable;
 102
 103     private final BroadcastReceiver mMobileStateReceiver = new BroadcastReceiver() {
 104         @Override
 105         public void onReceive(Context context, Intent intent) {
 106             if (intent.getAction().equals(
 107                     TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) {
 108                 PhoneConstants.DataState state = getMobileDataState(intent);
 109                 switch (state) {
 110                 case CONNECTED:
 111                     if (!mRestoreDefaultApnMode) {
 112                         fillList();
 113                     } else {
 114                         showDialog(DIALOG_RESTORE_DEFAULTAPN);
 115                     }
 116                     break;
 117                 }
 118             }
 119         }
 120     };
 121
 122     private static PhoneConstants.DataState getMobileDataState(Intent intent) {
 123         String str = intent.getStringExtra(PhoneConstants.STATE_KEY);
 124         if (str != null) {
 125             return Enum.valueOf(PhoneConstants.DataState.class, str);
 126         } else {
 127             return PhoneConstants.DataState.DISCONNECTED;
 128         }
 129     }
 130
 131     @Override
 132     public void onCreate(Bundle icicle) {
 133         super.onCreate(icicle);
 134         final Activity activity = getActivity();
 135         final int subId = activity.getIntent().getIntExtra("sub_id", -1);
 136
 137         mUm = (UserManager) getSystemService(Context.USER_SERVICE);
 138
 139         mMobileStateFilter = new IntentFilter(
 140                 TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED);
 141
 142         if (!mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
 143             setHasOptionsMenu(true);
 144         }
 145
 146         mSubscriptionInfo = Utils.findRecordBySubId(activity, subId);
 147     }
 148
 149     @Override
 150     public void onActivityCreated(Bundle savedInstanceState) {
 151         super.onActivityCreated(savedInstanceState);
 152
 153         TextView empty = (TextView) getView().findViewById(android.R.id.empty);
 154         if (empty != null) {
 155             empty.setText(R.string.apn_settings_not_available);
 156             getListView().setEmptyView(empty);
 157         }
 158
 159         if (mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
 160             mUnavailable = true;
 161             setPreferenceScreen(new PreferenceScreen(getActivity(), null));
 162             return;
 163         }
 164
 165         addPreferencesFromResource(R.xml.apn_settings);
 166
 167         getListView().setItemsCanFocus(true);
 168     }
 169
 170     @Override
 171     public void onResume() {
 172         super.onResume();
 173
 174         if (mUnavailable) {
 175             return;
 176         }
 177
 178         getActivity().registerReceiver(mMobileStateReceiver, mMobileStateFilter);
 179
 180         if (!mRestoreDefaultApnMode) {
 181             fillList();
 182         }
 183     }
 184
 185     @Override
 186     public void onPause() {
 187         super.onPause();
 188
 189         if (mUnavailable) {
 190             return;
 191         }
 192
 193         getActivity().unregisterReceiver(mMobileStateReceiver);
 194     }
 195
 196     @Override
 197     public void onDestroy() {
 198         super.onDestroy();
 199
 200         if (mRestoreDefaultApnThread != null) {
 201             mRestoreDefaultApnThread.quit();
 202         }
 203     }
 204
 205     private void fillList() {
 206         final TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
 207         final String mccmnc = mSubscriptionInfo == null ? ""
 208             : tm.getSimOperator(mSubscriptionInfo.getSubscriptionId());
 209         Log.d(TAG, "mccmnc = " + mccmnc);
 210         final String where = "numeric=\""
 211             + mccmnc
 212             + "\" AND NOT (type='ia' AND (apn=\"\" OR apn IS NULL))";
 213
 214         Cursor cursor = getContentResolver().query(Telephony.Carriers.CONTENT_URI, new String[] {
 215                 "_id", "name", "apn", "type"}, where, null,
 216                 Telephony.Carriers.DEFAULT_SORT_ORDER);
 217
 218         if (cursor != null) {
 219             PreferenceGroup apnList = (PreferenceGroup) findPreference("apn_list");
 220             apnList.removeAll();
 221
 222             ArrayList<Preference> mmsApnList = new ArrayList<Preference>();
 223
 224             mSelectedKey = getSelectedApnKey();
 225             cursor.moveToFirst();
 226             while (!cursor.isAfterLast()) {
 227                 String name = cursor.getString(NAME_INDEX);
 228                 String apn = cursor.getString(APN_INDEX);
 229                 String key = cursor.getString(ID_INDEX);
 230                 String type = cursor.getString(TYPES_INDEX);
 231
 232                 ApnPreference pref = new ApnPreference(getActivity());
 233
 234                 pref.setKey(key);
 235                 pref.setTitle(name);
 236                 pref.setSummary(apn);
 237                 pref.setPersistent(false);
 238                 pref.setOnPreferenceChangeListener(this);
 239
 240                 boolean selectable = ((type == null) || !type.equals("mms"));
 241                 pref.setSelectable(selectable);
 242                 if (selectable) {
 243                     if ((mSelectedKey != null) && mSelectedKey.equals(key)) {
 244                         pref.setChecked();
 245                     }
 246                     apnList.addPreference(pref);
 247                 } else {
 248                     mmsApnList.add(pref);
 249                 }
 250                 cursor.moveToNext();
 251             }
 252             cursor.close();
 253
 254             for (Preference preference : mmsApnList) {
 255                 apnList.addPreference(preference);
 256             }
 257         }
 258     }
 259
 260     @Override
 261     public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
 262         if (!mUnavailable) {
 263             menu.add(0, MENU_NEW, 0,
 264                     getResources().getString(R.string.menu_new))
 265                     .setIcon(android.R.drawable.ic_menu_add)
 266                     .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
 267             menu.add(0, MENU_RESTORE, 0,
 268                     getResources().getString(R.string.menu_restore))
 269                     .setIcon(android.R.drawable.ic_menu_upload);
 270         }
 271
 272         super.onCreateOptionsMenu(menu, inflater);
 273     }
 274
 275     @Override
 276     public boolean onOptionsItemSelected(MenuItem item) {
 277         switch (item.getItemId()) {
 278         case MENU_NEW:
 279             addNewApn();
 280             return true;
 281
 282         case MENU_RESTORE:
 283             restoreDefaultApn();
 284             return true;
 285         }
 286         return super.onOptionsItemSelected(item);
 287     }
 288
 289     private void addNewApn() {
 290         startActivity(new Intent(Intent.ACTION_INSERT, Telephony.Carriers.CONTENT_URI));
 291     }
 292
 293     @Override
 294     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
 295         int pos = Integer.parseInt(preference.getKey());
 296         Uri url = ContentUris.withAppendedId(Telephony.Carriers.CONTENT_URI, pos);
 297         startActivity(new Intent(Intent.ACTION_EDIT, url));
 298         return true;
 299     }
 300
 301     public boolean onPreferenceChange(Preference preference, Object newValue) {
 302         Log.d(TAG, "onPreferenceChange(): Preference - " + preference
 303                 + ", newValue - " + newValue + ", newValue type - "
 304                 + newValue.getClass());
 305         if (newValue instanceof String) {
 306             setSelectedApnKey((String) newValue);
 307         }
 308
 309         return true;
 310     }
 311
 312     private void setSelectedApnKey(String key) {
 313         mSelectedKey = key;
 314         ContentResolver resolver = getContentResolver();
 315
 316         ContentValues values = new ContentValues();
 317         values.put(APN_ID, mSelectedKey);
 318         resolver.update(PREFERAPN_URI, values, null, null);
 319     }
 320
 321     private String getSelectedApnKey() {
 322         String key = null;
 323
 324         Cursor cursor = getContentResolver().query(PREFERAPN_URI, new String[] {"_id"},
 325                 null, null, Telephony.Carriers.DEFAULT_SORT_ORDER);
 326         if (cursor.getCount() > 0) {
 327             cursor.moveToFirst();
 328             key = cursor.getString(ID_INDEX);
 329         }
 330         cursor.close();
 331         return key;
 332     }
 333
 334     private boolean restoreDefaultApn() {
 335         showDialog(DIALOG_RESTORE_DEFAULTAPN);
 336         mRestoreDefaultApnMode = true;
 337
 338         if (mRestoreApnUiHandler == null) {
 339             mRestoreApnUiHandler = new RestoreApnUiHandler();
 340         }
 341
 342         if (mRestoreApnProcessHandler == null ||
 343             mRestoreDefaultApnThread == null) {
 344             mRestoreDefaultApnThread = new HandlerThread(
 345                     "Restore default APN Handler: Process Thread");
 346             mRestoreDefaultApnThread.start();
 347             mRestoreApnProcessHandler = new RestoreApnProcessHandler(
 348                     mRestoreDefaultApnThread.getLooper(), mRestoreApnUiHandler);
 349         }
 350
 351         mRestoreApnProcessHandler
 352                 .sendEmptyMessage(EVENT_RESTORE_DEFAULTAPN_START);
 353         return true;
 354     }
 355
 356     private class RestoreApnUiHandler extends Handler {
 357         @Override
 358         public void handleMessage(Message msg) {
 359             switch (msg.what) {
 360                 case EVENT_RESTORE_DEFAULTAPN_COMPLETE:
 361                     Activity activity = getActivity();
 362                     if (activity == null) {
 363                         mRestoreDefaultApnMode = false;
 364                         return;
 365                     }
 366                     fillList();
 367                     getPreferenceScreen().setEnabled(true);
 368                     mRestoreDefaultApnMode = false;
 369                     removeDialog(DIALOG_RESTORE_DEFAULTAPN);
 370                     Toast.makeText(
 371                         activity,
 372                         getResources().getString(
 373                                 R.string.restore_default_apn_completed),
 374                         Toast.LENGTH_LONG).show();
 375                     break;
 376             }
 377         }
 378     }
 379
 380     private class RestoreApnProcessHandler extends Handler {
 381         private Handler mRestoreApnUiHandler;
 382
 383         public RestoreApnProcessHandler(Looper looper, Handler restoreApnUiHandler) {
 384             super(looper);
 385             this.mRestoreApnUiHandler = restoreApnUiHandler;
 386         }
 387
 388         @Override
 389         public void handleMessage(Message msg) {
 390             switch (msg.what) {
 391                 case EVENT_RESTORE_DEFAULTAPN_START:
 392                     ContentResolver resolver = getContentResolver();
 393                     resolver.delete(DEFAULTAPN_URI, null, null);
 394                     mRestoreApnUiHandler
 395                         .sendEmptyMessage(EVENT_RESTORE_DEFAULTAPN_COMPLETE);
 396                     break;
 397             }
 398         }
 399     }
 400
 401     @Override
 402     public Dialog onCreateDialog(int id) {
 403         if (id == DIALOG_RESTORE_DEFAULTAPN) {
 404             ProgressDialog dialog = new ProgressDialog(getActivity());
 405             dialog.setMessage(getResources().getString(R.string.restore_default_apn));
 406             dialog.setCancelable(false);
 407             return dialog;
 408         }
 409         return null;
 410     }
 411 }