• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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.Dialog;
20 import android.app.ProgressDialog;
21 import android.content.BroadcastReceiver;
22 import android.content.ContentResolver;
23 import android.content.ContentUris;
24 import android.content.ContentValues;
25 import android.content.Context;
26 import android.content.Intent;
27 import android.content.IntentFilter;
28 import android.database.Cursor;
29 import android.net.Uri;
30 import android.os.Bundle;
31 import android.os.Handler;
32 import android.os.HandlerThread;
33 import android.os.Looper;
34 import android.os.Message;
35 import android.preference.Preference;
36 import android.preference.PreferenceActivity;
37 import android.preference.PreferenceGroup;
38 import android.preference.PreferenceScreen;
39 import android.provider.Telephony;
40 import android.util.Log;
41 import android.view.Menu;
42 import android.view.MenuItem;
43 import android.widget.Toast;
44 
45 import com.android.internal.telephony.Phone;
46 import com.android.internal.telephony.TelephonyIntents;
47 import com.android.internal.telephony.TelephonyProperties;
48 
49 import java.util.ArrayList;
50 
51 public class ApnSettings extends PreferenceActivity implements
52         Preference.OnPreferenceChangeListener {
53     static final String TAG = "ApnSettings";
54 
55     public static final String EXTRA_POSITION = "position";
56     public static final String RESTORE_CARRIERS_URI =
57         "content://telephony/carriers/restore";
58     public static final String PREFERRED_APN_URI =
59         "content://telephony/carriers/preferapn";
60 
61     public static final String APN_ID = "apn_id";
62 
63     private static final int ID_INDEX = 0;
64     private static final int NAME_INDEX = 1;
65     private static final int APN_INDEX = 2;
66     private static final int TYPES_INDEX = 3;
67 
68     private static final int MENU_NEW = Menu.FIRST;
69     private static final int MENU_RESTORE = Menu.FIRST + 1;
70 
71     private static final int EVENT_RESTORE_DEFAULTAPN_START = 1;
72     private static final int EVENT_RESTORE_DEFAULTAPN_COMPLETE = 2;
73 
74     private static final int DIALOG_RESTORE_DEFAULTAPN = 1001;
75 
76     private static final Uri DEFAULTAPN_URI = Uri.parse(RESTORE_CARRIERS_URI);
77     private static final Uri PREFERAPN_URI = Uri.parse(PREFERRED_APN_URI);
78 
79     private static boolean mRestoreDefaultApnMode;
80 
81     private RestoreApnUiHandler mRestoreApnUiHandler;
82     private RestoreApnProcessHandler mRestoreApnProcessHandler;
83 
84     private String mSelectedKey;
85 
86     private IntentFilter mMobileStateFilter;
87 
88     private final BroadcastReceiver mMobileStateReceiver = new BroadcastReceiver() {
89         @Override
90         public void onReceive(Context context, Intent intent) {
91             if (intent.getAction().equals(
92                     TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) {
93                 Phone.DataState state = getMobileDataState(intent);
94                 switch (state) {
95                 case CONNECTED:
96                     if (!mRestoreDefaultApnMode) {
97                         fillList();
98                     } else {
99                         showDialog(DIALOG_RESTORE_DEFAULTAPN);
100                     }
101                     break;
102                 }
103             }
104         }
105     };
106 
getMobileDataState(Intent intent)107     private static Phone.DataState getMobileDataState(Intent intent) {
108         String str = intent.getStringExtra(Phone.STATE_KEY);
109         if (str != null) {
110             return Enum.valueOf(Phone.DataState.class, str);
111         } else {
112             return Phone.DataState.DISCONNECTED;
113         }
114     }
115 
116     @Override
onCreate(Bundle icicle)117     protected void onCreate(Bundle icicle) {
118         super.onCreate(icicle);
119 
120         addPreferencesFromResource(R.xml.apn_settings);
121         getListView().setItemsCanFocus(true);
122 
123         mMobileStateFilter = new IntentFilter(
124                 TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED);
125     }
126 
127     @Override
onResume()128     protected void onResume() {
129         super.onResume();
130 
131         registerReceiver(mMobileStateReceiver, mMobileStateFilter);
132 
133         if (!mRestoreDefaultApnMode) {
134             fillList();
135         } else {
136             showDialog(DIALOG_RESTORE_DEFAULTAPN);
137         }
138     }
139 
140     @Override
onPause()141     protected void onPause() {
142         super.onPause();
143 
144         unregisterReceiver(mMobileStateReceiver);
145     }
146 
fillList()147     private void fillList() {
148         String where = "numeric=\""
149             + android.os.SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, "")
150             + "\"";
151 
152         Cursor cursor = getContentResolver().query(Telephony.Carriers.CONTENT_URI, new String[] {
153                 "_id", "name", "apn", "type"}, where, null,
154                 Telephony.Carriers.DEFAULT_SORT_ORDER);
155 
156         PreferenceGroup apnList = (PreferenceGroup) findPreference("apn_list");
157         apnList.removeAll();
158 
159         ArrayList<Preference> mmsApnList = new ArrayList<Preference>();
160 
161         mSelectedKey = getSelectedApnKey();
162         cursor.moveToFirst();
163         while (!cursor.isAfterLast()) {
164             String name = cursor.getString(NAME_INDEX);
165             String apn = cursor.getString(APN_INDEX);
166             String key = cursor.getString(ID_INDEX);
167             String type = cursor.getString(TYPES_INDEX);
168 
169             ApnPreference pref = new ApnPreference(this);
170 
171             pref.setKey(key);
172             pref.setTitle(name);
173             pref.setSummary(apn);
174             pref.setPersistent(false);
175             pref.setOnPreferenceChangeListener(this);
176 
177             boolean selectable = ((type == null) || !type.equals("mms"));
178             pref.setSelectable(selectable);
179             if (selectable) {
180                 if ((mSelectedKey != null) && mSelectedKey.equals(key)) {
181                     pref.setChecked();
182                 }
183                 apnList.addPreference(pref);
184             } else {
185                 mmsApnList.add(pref);
186             }
187             cursor.moveToNext();
188         }
189         cursor.close();
190 
191         for (Preference preference : mmsApnList) {
192             apnList.addPreference(preference);
193         }
194     }
195 
196     @Override
onCreateOptionsMenu(Menu menu)197     public boolean onCreateOptionsMenu(Menu menu) {
198         super.onCreateOptionsMenu(menu);
199         menu.add(0, MENU_NEW, 0,
200                 getResources().getString(R.string.menu_new))
201                 .setIcon(android.R.drawable.ic_menu_add);
202         menu.add(0, MENU_RESTORE, 0,
203                 getResources().getString(R.string.menu_restore))
204                 .setIcon(android.R.drawable.ic_menu_upload);
205         return true;
206     }
207 
208     @Override
onOptionsItemSelected(MenuItem item)209     public boolean onOptionsItemSelected(MenuItem item) {
210         switch (item.getItemId()) {
211         case MENU_NEW:
212             addNewApn();
213             return true;
214 
215         case MENU_RESTORE:
216             restoreDefaultApn();
217             return true;
218         }
219         return super.onOptionsItemSelected(item);
220     }
221 
addNewApn()222     private void addNewApn() {
223         startActivity(new Intent(Intent.ACTION_INSERT, Telephony.Carriers.CONTENT_URI));
224     }
225 
226     @Override
onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)227     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
228         int pos = Integer.parseInt(preference.getKey());
229         Uri url = ContentUris.withAppendedId(Telephony.Carriers.CONTENT_URI, pos);
230         startActivity(new Intent(Intent.ACTION_EDIT, url));
231         return true;
232     }
233 
onPreferenceChange(Preference preference, Object newValue)234     public boolean onPreferenceChange(Preference preference, Object newValue) {
235         Log.d(TAG, "onPreferenceChange(): Preference - " + preference
236                 + ", newValue - " + newValue + ", newValue type - "
237                 + newValue.getClass());
238         if (newValue instanceof String) {
239             setSelectedApnKey((String) newValue);
240         }
241 
242         return true;
243     }
244 
setSelectedApnKey(String key)245     private void setSelectedApnKey(String key) {
246         mSelectedKey = key;
247         ContentResolver resolver = getContentResolver();
248 
249         ContentValues values = new ContentValues();
250         values.put(APN_ID, mSelectedKey);
251         resolver.update(PREFERAPN_URI, values, null, null);
252     }
253 
getSelectedApnKey()254     private String getSelectedApnKey() {
255         String key = null;
256 
257         Cursor cursor = getContentResolver().query(PREFERAPN_URI, new String[] {"_id"},
258                 null, null, Telephony.Carriers.DEFAULT_SORT_ORDER);
259         if (cursor.getCount() > 0) {
260             cursor.moveToFirst();
261             key = cursor.getString(ID_INDEX);
262         }
263         cursor.close();
264         return key;
265     }
266 
restoreDefaultApn()267     private boolean restoreDefaultApn() {
268         showDialog(DIALOG_RESTORE_DEFAULTAPN);
269         mRestoreDefaultApnMode = true;
270 
271         if (mRestoreApnUiHandler == null) {
272             mRestoreApnUiHandler = new RestoreApnUiHandler();
273         }
274 
275         if (mRestoreApnProcessHandler == null) {
276             HandlerThread restoreDefaultApnThread = new HandlerThread(
277                     "Restore default APN Handler: Process Thread");
278             restoreDefaultApnThread.start();
279             mRestoreApnProcessHandler = new RestoreApnProcessHandler(
280                     restoreDefaultApnThread.getLooper(), mRestoreApnUiHandler);
281         }
282 
283         mRestoreApnProcessHandler
284                 .sendEmptyMessage(EVENT_RESTORE_DEFAULTAPN_START);
285         return true;
286     }
287 
288     private class RestoreApnUiHandler extends Handler {
289         @Override
handleMessage(Message msg)290         public void handleMessage(Message msg) {
291             switch (msg.what) {
292                 case EVENT_RESTORE_DEFAULTAPN_COMPLETE:
293                     fillList();
294                     getPreferenceScreen().setEnabled(true);
295                     mRestoreDefaultApnMode = false;
296                     dismissDialog(DIALOG_RESTORE_DEFAULTAPN);
297                     Toast.makeText(
298                         ApnSettings.this,
299                         getResources().getString(
300                                 R.string.restore_default_apn_completed),
301                         Toast.LENGTH_LONG).show();
302                     break;
303             }
304         }
305     }
306 
307     private class RestoreApnProcessHandler extends Handler {
308         private Handler mRestoreApnUiHandler;
309 
RestoreApnProcessHandler(Looper looper, Handler restoreApnUiHandler)310         public RestoreApnProcessHandler(Looper looper, Handler restoreApnUiHandler) {
311             super(looper);
312             this.mRestoreApnUiHandler = restoreApnUiHandler;
313         }
314 
315         @Override
handleMessage(Message msg)316         public void handleMessage(Message msg) {
317             switch (msg.what) {
318                 case EVENT_RESTORE_DEFAULTAPN_START:
319                     ContentResolver resolver = getContentResolver();
320                     resolver.delete(DEFAULTAPN_URI, null, null);
321                     mRestoreApnUiHandler
322                         .sendEmptyMessage(EVENT_RESTORE_DEFAULTAPN_COMPLETE);
323                     break;
324             }
325         }
326     }
327 
328     @Override
onCreateDialog(int id)329     protected Dialog onCreateDialog(int id) {
330         if (id == DIALOG_RESTORE_DEFAULTAPN) {
331             ProgressDialog dialog = new ProgressDialog(this);
332             dialog.setMessage(getResources().getString(R.string.restore_default_apn));
333             dialog.setCancelable(false);
334             return dialog;
335         }
336         return null;
337     }
338 
339     @Override
onPrepareDialog(int id, Dialog dialog)340     protected void onPrepareDialog(int id, Dialog dialog) {
341         if (id == DIALOG_RESTORE_DEFAULTAPN) {
342             getPreferenceScreen().setEnabled(false);
343         }
344     }
345 }
346