Teleca 2b changes.
[android/platform/packages/apps/Phone.git] / src / com / android / phone / CdmaOptions.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
18 package com.android.phone;
19
20 import android.os.Bundle;
21 import android.os.Handler;
22 import android.os.Message;
23 import android.os.AsyncResult;
24 import android.preference.ListPreference;
25 import android.preference.Preference;
26 import android.preference.PreferenceActivity;
27 import android.preference.PreferenceScreen;
28 import android.util.Log;
29
30 import com.android.internal.telephony.Phone;
31 import com.android.internal.telephony.PhoneFactory;
32
33 /**
34  * List of Phone-specific settings screens.
35  */
36 public class CdmaOptions extends PreferenceActivity implements Preference.OnPreferenceChangeListener{
37     
38     // debug data
39     private static final String LOG_TAG = "CdmaOptions";
40     private static final boolean DBG = true;
41     
42     //String keys for preference lookup
43     private static final String BUTTON_CDMA_ROAMING_KEY = "cdma_roaming_mode_key";
44     private static final String BUTTON_CDMA_NW_PREFERENCE_KEY = "cdma_network_prefernces_key";
45     private static final String BUTTON_CDMA_SUBSCRIPTION_KEY = "subscription_key";
46     private static final String BUTTON_CB_SMS_EXPAND_KEY = "cdma_cell_broadcast_sms_key";
47     
48     // Used for CDMA roaming mode
49     private static final int CDMA_ROAMING_MODE_HOME = 0;
50     private static final int CDMA_ROAMING_MODE_AFFILIATED = 1;
51     private static final int CDMA_ROAMING_MODE_ANY = 2;
52     
53     //preferredCdmaRoamingMode  0 - Home Networks only, preferred
54     //                          1 - Roaming on affiliated networks
55     //                          2 - Roaming on any network
56     static final int preferredCdmaRoamingMode = 0;
57     
58     // Used for CDMA subscription mode
59     private static final int CDMA_SUBSCRIPTION_RUIM_SIM = 0;
60     private static final int CDMA_SUBSCRIPTION_NV = 1;
61     
62     //preferredSubscriptionMode  0 - RUIM/SIM, preferred
63     //                           1 - NV
64     static final int preferredSubscriptionMode = CDMA_SUBSCRIPTION_NV;
65     
66     //UI objects
67     private ListPreference mButtonCdmaRoam;
68     private ListPreference mButtonCdmaNwPreference;
69     private ListPreference mButtonCdmaSubscription;
70     private PreferenceScreen mButtonCbSmsExpand;
71     
72     private Phone mPhone;
73     private MyHandler mHandler;
74
75     
76     /** 
77      * Invoked on each preference click in this hierarchy, overrides 
78      * PreferenceActivity's implementation.  Used to make sure we track the
79      * preference click events.
80      */
81     @Override
82     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
83         if (preference == mButtonCdmaRoam) {
84             if (DBG) log("onPreferenceTreeClick: preference == mButtonCdmaRoam.");
85             //displays the value taken from the Settings.System
86             int cdmaRoamingMode = android.provider.Settings.Secure.getInt(mPhone.getContext().getContentResolver(),
87                     android.provider.Settings.Secure.CDMA_ROAMING_MODE, preferredCdmaRoamingMode);            
88             mButtonCdmaRoam.setValue(Integer.toString(cdmaRoamingMode));
89             return true;
90         } 
91         else if (preference == mButtonCdmaNwPreference) {
92             if (DBG) log("onPreferenceTreeClick: preference == mButtonCdmaNwPreference.");
93             return true;
94         }
95         else if (preference == mButtonCdmaSubscription) {
96             if (DBG) log("onPreferenceTreeClick: preference == mButtonCdmaSubscription.");
97             int cdmaSubscriptionMode = android.provider.Settings.Secure.getInt(mPhone.getContext().getContentResolver(),
98                     android.provider.Settings.Secure.CDMA_SUBSCRIPTION_MODE, preferredSubscriptionMode);            
99             mButtonCdmaSubscription.setValue(Integer.toString(cdmaSubscriptionMode));
100             return true;
101         }
102         else {
103             // if the button is anything but the simple toggle preference,
104             // we'll need to disable all preferences to reject all click
105             // events until the sub-activity's UI comes up.
106             preferenceScreen.setEnabled(false);
107             // Let the intents be launched by the Preference manager
108             return false;
109         }
110     }
111
112     public void onCreate(Bundle icicle) {
113         super.onCreate(icicle);
114
115         addPreferencesFromResource(R.xml.cdma_options);
116         
117         mPhone = PhoneFactory.getDefaultPhone();
118         mHandler = new MyHandler();
119
120         //get UI object references
121         PreferenceScreen prefSet = getPreferenceScreen();
122
123         mButtonCdmaRoam = (ListPreference) prefSet.findPreference(BUTTON_CDMA_ROAMING_KEY);
124         mButtonCdmaSubscription = 
125                 (ListPreference) prefSet.findPreference(BUTTON_CDMA_SUBSCRIPTION_KEY);
126         mButtonCdmaNwPreference = 
127                 (ListPreference) prefSet.findPreference(BUTTON_CDMA_NW_PREFERENCE_KEY);
128         mButtonCbSmsExpand = (PreferenceScreen) prefSet.findPreference(BUTTON_CB_SMS_EXPAND_KEY);
129
130         if (mPhone.getPhoneName().equals("CDMA")) {
131             // set the listener for the mButtonCdmaRoam list preference so we can issue 
132             // change CDMA Roaming Mode.
133             mButtonCdmaRoam.setOnPreferenceChangeListener(this);
134             // set the listener for the mButtonCdmaRoam list preference so we can issue 
135             // change CDMA Roaming Mode.
136             mButtonCdmaSubscription.setOnPreferenceChangeListener(this);
137
138             //Get the settingsCdmaRoamingMode from Settings.System and displays it
139             int settingsCdmaRoamingMode = android.provider.Settings.Secure.getInt(
140                     mPhone.getContext().getContentResolver(),
141                     android.provider.Settings.Secure.CDMA_ROAMING_MODE, 
142                     preferredCdmaRoamingMode);
143             mButtonCdmaRoam.setValue(Integer.toString(settingsCdmaRoamingMode));
144
145             //Get the settingsCdmaSubscriptionMode from Settings.System and displays it
146             int settingsCdmaSubscriptionMode = android.provider.Settings.Secure.getInt(
147                     mPhone.getContext().getContentResolver(),
148                     android.provider.Settings.Secure.CDMA_SUBSCRIPTION_MODE, 
149                     preferredSubscriptionMode);
150             mButtonCdmaSubscription.setValue(Integer.toString(settingsCdmaSubscriptionMode));
151         } else {
152             mButtonCdmaRoam.setEnabled(false);
153             mButtonCdmaSubscription.setEnabled(false);
154             mButtonCbSmsExpand.setEnabled(false);
155         }
156     }
157
158     @Override
159     protected void onResume() {
160         super.onResume();
161
162         mPhone = PhoneFactory.getDefaultPhone();
163         // upon resumption from the sub-activity, make sure we re-enable the
164         // preferences.
165         getPreferenceScreen().setEnabled(true);
166
167         if (mPhone.getPhoneName().equals("CDMA")) {
168             mPhone.queryCdmaRoamingPreference(
169                     mHandler.obtainMessage(MyHandler.MESSAGE_QUERY_ROAMING_PREFERENCE));
170         } else {
171             mButtonCdmaRoam.setEnabled(false);
172             mButtonCdmaSubscription.setEnabled(false);
173             mButtonCbSmsExpand.setEnabled(false);
174         }
175     }
176
177     /**
178      * Implemented to support onPreferenceChangeListener to look for preference
179      * changes specifically on CLIR.
180      *
181      * @param preference is the preference to be changed, should be mButtonCdmaRoam.
182      * @param objValue should be the value of the selection, NOT its localized
183      * display value.
184      */
185     public boolean onPreferenceChange(Preference preference, Object objValue) {
186         mPhone = PhoneFactory.getDefaultPhone();
187         if (preference == mButtonCdmaRoam) {
188             //NOTE onPreferenceChange seems to be called even if there is no change
189             //Check if the button value is changed from the System.Setting
190             mButtonCdmaRoam.setValue((String) objValue);
191             int buttonCdmaRoamingMode;
192             buttonCdmaRoamingMode = Integer.valueOf((String) objValue).intValue();
193             int settingsCdmaRoamingMode = android.provider.Settings.Secure.getInt(mPhone.getContext().getContentResolver(),
194                     android.provider.Settings.Secure.CDMA_ROAMING_MODE, preferredCdmaRoamingMode);
195             if (buttonCdmaRoamingMode != settingsCdmaRoamingMode) {
196                 int statusCdmaRoamingMode; 
197                 switch(buttonCdmaRoamingMode) {
198                     case CDMA_ROAMING_MODE_ANY:
199                         statusCdmaRoamingMode = Phone.CDMA_RM_ANY;
200                         break;
201                     case CDMA_ROAMING_MODE_AFFILIATED:
202                         statusCdmaRoamingMode = Phone.CDMA_RM_AFFILIATED;
203                         break;
204                     case CDMA_ROAMING_MODE_HOME:
205                     default:
206                         statusCdmaRoamingMode = Phone.CDMA_RM_HOME;
207                 }
208                 //Set the Settings.Secure network mode       
209                 android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
210                         android.provider.Settings.Secure.CDMA_ROAMING_MODE, 
211                         buttonCdmaRoamingMode );
212                 //Set the roaming preference mode
213                 mPhone.setCdmaRoamingPreference(statusCdmaRoamingMode, mHandler
214                         .obtainMessage(MyHandler.MESSAGE_SET_ROAMING_PREFERENCE));
215             }
216         }
217         if (preference == mButtonCdmaSubscription) {
218             //NOTE onPreferenceChange seems to be called even if there is no change
219             //Check if the button value is changed from the System.Setting
220             mButtonCdmaSubscription.setValue((String) objValue);
221             int buttonCdmaSubscriptionMode;
222             buttonCdmaSubscriptionMode = Integer.valueOf((String) objValue).intValue();
223             int settingsCdmaSubscriptionMode = android.provider.Settings.Secure.getInt(mPhone.getContext().getContentResolver(),
224                     android.provider.Settings.Secure.CDMA_SUBSCRIPTION_MODE, preferredSubscriptionMode);
225             if (buttonCdmaSubscriptionMode != settingsCdmaSubscriptionMode) {
226                 int statusCdmaSubscriptionMode; 
227                 switch(buttonCdmaSubscriptionMode) {
228                     case CDMA_SUBSCRIPTION_NV:
229                         statusCdmaSubscriptionMode = Phone.CDMA_SUBSCRIPTION_NV;
230                         break;
231                     case CDMA_SUBSCRIPTION_RUIM_SIM:
232                         statusCdmaSubscriptionMode = Phone.CDMA_SUBSCRIPTION_RUIM_SIM;
233                         break;
234                     default:
235                         statusCdmaSubscriptionMode = Phone.PREFERRED_CDMA_SUBSCRIPTION;
236                 } 
237                 //Set the Settings.System network mode        
238                 android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
239                         android.provider.Settings.Secure.CDMA_SUBSCRIPTION_MODE, 
240                         buttonCdmaSubscriptionMode );
241                 //Set the CDMA subscription mode
242                 mPhone.setCdmaSubscription(statusCdmaSubscriptionMode, mHandler
243                         .obtainMessage(MyHandler.MESSAGE_SET_CDMA_SUBSCRIPTION));
244             }
245         }
246
247         // always let the preference setting proceed.
248         return true;
249     }
250
251     private class MyHandler extends Handler {
252
253         private static final int MESSAGE_QUERY_ROAMING_PREFERENCE = 0;
254         private static final int MESSAGE_SET_ROAMING_PREFERENCE = 1;
255         private static final int MESSAGE_SET_CDMA_SUBSCRIPTION = 2;
256
257         @Override
258         public void handleMessage(Message msg) {
259             switch (msg.what) {
260                 case MESSAGE_QUERY_ROAMING_PREFERENCE:
261                     handleQueryCdmaRoamingPreference(msg);
262                     break;
263                     
264                 case MESSAGE_SET_ROAMING_PREFERENCE:
265                     handleSetCdmaRoamingPreference(msg);
266                     break;
267                 case MESSAGE_SET_CDMA_SUBSCRIPTION:
268                     handleSetCdmaSubscriptionMode(msg);
269                     break;
270             }
271         }
272
273         private void handleQueryCdmaRoamingPreference(Message msg) {
274             mPhone = PhoneFactory.getDefaultPhone();
275             AsyncResult ar = (AsyncResult) msg.obj;
276             
277             if (ar.exception == null) {
278                 int statusCdmaRoamingMode = ((int[])ar.result)[0];
279                 int settingsRoamingMode = android.provider.Settings.Secure.getInt(mPhone.getContext().getContentResolver(),
280                         android.provider.Settings.Secure.CDMA_ROAMING_MODE, preferredCdmaRoamingMode);
281                 //check that statusCdmaRoamingMode is from an accepted value
282                 if (statusCdmaRoamingMode == Phone.CDMA_RM_HOME ||  
283                         statusCdmaRoamingMode == Phone.CDMA_RM_AFFILIATED ||
284                         statusCdmaRoamingMode == Phone.CDMA_RM_ANY ) {
285                     //check changes in statusCdmaRoamingMode and updates settingsRoamingMode 
286                     if (statusCdmaRoamingMode != settingsRoamingMode) {
287                         settingsRoamingMode = statusCdmaRoamingMode;
288                         //changes the Settings.Secure accordingly to statusCdmaRoamingMode
289                         android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
290                                 android.provider.Settings.Secure.CDMA_ROAMING_MODE, 
291                                 settingsRoamingMode );
292                     }
293                     //changes the mButtonPreferredNetworkMode accordingly to modemNetworkMode
294                     mButtonCdmaRoam.setValue(
295                             Integer.toString(statusCdmaRoamingMode));
296                 }
297                 else {
298                     resetCdmaRoamingModeToDefault();
299                 } 
300             } 
301         }
302
303         private void handleSetCdmaRoamingPreference(Message msg) {
304             mPhone = PhoneFactory.getDefaultPhone();
305             AsyncResult ar = (AsyncResult) msg.obj;
306             
307             if (ar.exception == null) {
308                 int cdmaRoamingMode = Integer.valueOf(mButtonCdmaRoam.getValue()).intValue();
309                 android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
310                         android.provider.Settings.Secure.CDMA_ROAMING_MODE, 
311                         cdmaRoamingMode );
312             } else {
313                 mPhone.queryCdmaRoamingPreference(obtainMessage(MESSAGE_QUERY_ROAMING_PREFERENCE));
314             }
315         }
316
317         private void resetCdmaRoamingModeToDefault() {
318             mPhone = PhoneFactory.getDefaultPhone();
319             //set cdmaRoamingMode to default
320             int cdmaRoamingMode = preferredCdmaRoamingMode;
321             int statusCdmaRoamingMode = Phone.CDMA_RM_HOME;
322             //set the mButtonCdmaRoam
323             mButtonCdmaRoam.setValue(Integer.toString(cdmaRoamingMode));
324             //set the Settings.System 
325             android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
326                         android.provider.Settings.Secure.CDMA_ROAMING_MODE, 
327                         cdmaRoamingMode );            
328             //Set the Status
329             mPhone.setCdmaRoamingPreference(statusCdmaRoamingMode, 
330                     this.obtainMessage(MyHandler.MESSAGE_SET_ROAMING_PREFERENCE));
331         }
332     }
333
334     private void handleSetCdmaSubscriptionMode(Message msg) {
335         mPhone = PhoneFactory.getDefaultPhone();
336         AsyncResult ar = (AsyncResult) msg.obj;
337
338         if (ar.exception == null) {
339             int cdmaSubscriptionMode = Integer.valueOf(mButtonCdmaSubscription.getValue()).intValue();
340             android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
341                     android.provider.Settings.Secure.CDMA_SUBSCRIPTION_MODE, 
342                     cdmaSubscriptionMode );
343         } 
344     }
345
346     private static void log(String msg) {
347         Log.d(LOG_TAG, msg);
348     }
349 }
350
351