1 /*
2  * Copyright (C) 2009 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.phone;
18 
19 import android.app.Activity;
20 import android.app.Dialog;
21 import android.app.ProgressDialog;
22 import android.app.AlertDialog;
23 import android.content.BroadcastReceiver;
24 import android.content.ComponentName;
25 import android.content.Context;
26 import android.content.DialogInterface;
27 import android.content.DialogInterface.OnDismissListener;
28 import android.content.Intent;
29 import android.content.IntentFilter;
30 import android.content.ServiceConnection;
31 import android.content.res.Resources;
32 import android.os.AsyncResult;
33 import android.os.Bundle;
34 import android.os.CountDownTimer;
35 import android.os.Handler;
36 import android.os.IBinder;
37 import android.os.Looper;
38 import android.os.Message;
39 import android.os.SystemProperties;
40 import android.util.Log;
41 
42 import com.android.internal.telephony.Phone;
43 import com.android.internal.telephony.TelephonyIntents;
44 import com.android.internal.telephony.TelephonyProperties;
45 
46 /**
47  * Displays dialog that enables users to exit Emergency Callback Mode
48  *
49  * @see EmergencyCallbackModeService
50  */
51 public class EmergencyCallbackModeExitDialog extends Activity implements OnDismissListener {
52 
53     private static final String TAG = "EmergencyCallbackMode";
54 
55     /** Intent to trigger the Emergency Callback Mode exit dialog */
56     static final String ACTION_SHOW_ECM_EXIT_DIALOG =
57             "com.android.phone.action.ACTION_SHOW_ECM_EXIT_DIALOG";
58     /** Used to get the users choice from the return Intent's extra */
59     public static final String EXTRA_EXIT_ECM_RESULT = "exit_ecm_result";
60 
61     public static final int EXIT_ECM_BLOCK_OTHERS = 1;
62     public static final int EXIT_ECM_DIALOG = 2;
63     public static final int EXIT_ECM_PROGRESS_DIALOG = 3;
64     public static final int EXIT_ECM_IN_EMERGENCY_CALL_DIALOG = 4;
65 
66     AlertDialog mAlertDialog = null;
67     ProgressDialog mProgressDialog = null;
68     CountDownTimer mTimer = null;
69     EmergencyCallbackModeService mService = null;
70     Handler mHandler = null;
71     int mDialogType = 0;
72     long mEcmTimeout = 0;
73     private boolean mInEmergencyCall = false;
74     private static final int ECM_TIMER_RESET = 1;
75     private Phone mPhone = null;
76 
77     @Override
onCreate(Bundle savedInstanceState)78     public void onCreate(Bundle savedInstanceState) {
79         super.onCreate(savedInstanceState);
80 
81         mPhone = PhoneGlobals.getInstance().getPhoneInEcm();
82         // Check if phone is in Emergency Callback Mode. If not, exit.
83         final boolean isInEcm = Boolean.parseBoolean(
84                 SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE));
85         Log.i(TAG, "ECMModeExitDialog launched - isInEcm: " + isInEcm + " phone:" + mPhone);
86         if (mPhone == null || !isInEcm) {
87             finish();
88             return;
89         }
90 
91         mHandler = new Handler();
92 
93         // Start thread that will wait for the connection completion so that it can get
94         // timeout value from the service
95         Thread waitForConnectionCompleteThread = new Thread(null, mTask,
96                 "EcmExitDialogWaitThread");
97         waitForConnectionCompleteThread.start();
98 
99         // Register ECM timer reset notfication
100         mPhone.registerForEcmTimerReset(mTimerResetHandler, ECM_TIMER_RESET, null);
101 
102         // Register receiver for intent closing the dialog
103         IntentFilter filter = new IntentFilter();
104         filter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED);
105         registerReceiver(mEcmExitReceiver, filter);
106     }
107 
108     @Override
onDestroy()109     public void onDestroy() {
110         super.onDestroy();
111         try {
112             unregisterReceiver(mEcmExitReceiver);
113         } catch (IllegalArgumentException e) {
114             // Receiver was never registered - silently ignore.
115         }
116         // Unregister ECM timer reset notification
117         if (mPhone != null) {
118             mPhone.unregisterForEcmTimerReset(mHandler);
119         }
120     }
121 
122     @Override
onRestoreInstanceState(Bundle savedInstanceState)123     protected void onRestoreInstanceState(Bundle savedInstanceState) {
124         super.onRestoreInstanceState(savedInstanceState);
125         mDialogType = savedInstanceState.getInt("DIALOG_TYPE");
126     }
127 
128     @Override
onSaveInstanceState(Bundle outState)129     protected void onSaveInstanceState(Bundle outState) {
130         super.onSaveInstanceState(outState);
131         outState.putInt("DIALOG_TYPE", mDialogType);
132     }
133 
134     /**
135      * Waits until bind to the service completes
136      */
137     private Runnable mTask = new Runnable() {
138         public void run() {
139             Looper.prepare();
140 
141             // Bind to the remote service
142             bindService(new Intent(EmergencyCallbackModeExitDialog.this,
143                     EmergencyCallbackModeService.class), mConnection, Context.BIND_AUTO_CREATE);
144 
145             // Wait for bind to finish
146             synchronized (EmergencyCallbackModeExitDialog.this) {
147                 try {
148                     if (mService == null) {
149                         EmergencyCallbackModeExitDialog.this.wait();
150                     }
151                 } catch (InterruptedException e) {
152                     Log.d("ECM", "EmergencyCallbackModeExitDialog InterruptedException: "
153                             + e.getMessage());
154                     e.printStackTrace();
155                 }
156             }
157 
158             // Get timeout value and call state from the service
159             if (mService != null) {
160                 mEcmTimeout = mService.getEmergencyCallbackModeTimeout();
161                 mInEmergencyCall = mService.getEmergencyCallbackModeCallState();
162                 try {
163                     // Unbind from remote service
164                     unbindService(mConnection);
165                 } catch (IllegalArgumentException e) {
166                     // Failed to unbind from service. Don't crash as this brings down the entire
167                     // radio.
168                     Log.w(TAG, "Failed to unbind from EmergencyCallbackModeService");
169                 }
170             }
171 
172             // Show dialog
173             mHandler.post(new Runnable() {
174                 public void run() {
175                     showEmergencyCallbackModeExitDialog();
176                 }
177             });
178         }
179     };
180 
181     /**
182      * Shows Emergency Callback Mode dialog and starts countdown timer
183      */
showEmergencyCallbackModeExitDialog()184     private void showEmergencyCallbackModeExitDialog() {
185         if (!this.isResumed()) {
186             Log.w(TAG, "Tried to show dialog, but activity was already finished");
187             return;
188         }
189         if(mInEmergencyCall) {
190             mDialogType = EXIT_ECM_IN_EMERGENCY_CALL_DIALOG;
191             showDialog(EXIT_ECM_IN_EMERGENCY_CALL_DIALOG);
192         } else {
193             if (getIntent().getAction().equals(
194                     TelephonyIntents.ACTION_SHOW_NOTICE_ECM_BLOCK_OTHERS)) {
195                 mDialogType = EXIT_ECM_BLOCK_OTHERS;
196                 showDialog(EXIT_ECM_BLOCK_OTHERS);
197             } else if (getIntent().getAction().equals(ACTION_SHOW_ECM_EXIT_DIALOG)) {
198                 mDialogType = EXIT_ECM_DIALOG;
199                 showDialog(EXIT_ECM_DIALOG);
200             }
201 
202             mTimer = new CountDownTimer(mEcmTimeout, 1000) {
203                 @Override
204                 public void onTick(long millisUntilFinished) {
205                     CharSequence text = getDialogText(millisUntilFinished);
206                     mAlertDialog.setMessage(text);
207                 }
208 
209                 @Override
210                 public void onFinish() {
211                     //Do nothing
212                 }
213             }.start();
214         }
215     }
216 
217     /**
218      * Creates dialog that enables users to exit Emergency Callback Mode
219      */
220     @Override
onCreateDialog(int id)221     protected Dialog onCreateDialog(int id) {
222         switch (id) {
223         case EXIT_ECM_BLOCK_OTHERS:
224         case EXIT_ECM_DIALOG:
225             CharSequence text = getDialogText(mEcmTimeout);
226             mAlertDialog = new AlertDialog.Builder(EmergencyCallbackModeExitDialog.this)
227                     .setIcon(R.drawable.ic_emergency_callback_mode)
228                     .setTitle(R.string.phone_in_ecm_notification_title)
229                     .setMessage(text)
230                     .setPositiveButton(R.string.alert_dialog_yes,
231                             new DialogInterface.OnClickListener() {
232                                 public void onClick(DialogInterface dialog,int whichButton) {
233                                     // User clicked Yes. Exit Emergency Callback Mode.
234                                     mPhone.exitEmergencyCallbackMode();
235 
236                                     // Show progress dialog
237                                     showDialog(EXIT_ECM_PROGRESS_DIALOG);
238                                     mTimer.cancel();
239                                 }
240                             })
241                     .setNegativeButton(R.string.alert_dialog_no,
242                             new DialogInterface.OnClickListener() {
243                                 public void onClick(DialogInterface dialog, int whichButton) {
244                                     // User clicked No
245                                     setResult(RESULT_OK, (new Intent()).putExtra(
246                                             EXTRA_EXIT_ECM_RESULT, false));
247                                     finish();
248                                 }
249                             }).create();
250             mAlertDialog.setOnDismissListener(this);
251             return mAlertDialog;
252 
253         case EXIT_ECM_IN_EMERGENCY_CALL_DIALOG:
254             mAlertDialog = new AlertDialog.Builder(EmergencyCallbackModeExitDialog.this)
255                     .setIcon(R.drawable.ic_emergency_callback_mode)
256                     .setTitle(R.string.phone_in_ecm_notification_title)
257                     .setMessage(R.string.alert_dialog_in_ecm_call)
258                     .setNeutralButton(R.string.alert_dialog_dismiss,
259                             new DialogInterface.OnClickListener() {
260                                 public void onClick(DialogInterface dialog, int whichButton) {
261                                     // User clicked Dismiss
262                                     setResult(RESULT_OK, (new Intent()).putExtra(
263                                             EXTRA_EXIT_ECM_RESULT, false));
264                                     finish();
265                                 }
266                             }).create();
267             mAlertDialog.setOnDismissListener(this);
268             return mAlertDialog;
269 
270         case EXIT_ECM_PROGRESS_DIALOG:
271             mProgressDialog = new ProgressDialog(EmergencyCallbackModeExitDialog.this);
272             mProgressDialog.setMessage(getText(R.string.progress_dialog_exiting_ecm));
273             mProgressDialog.setIndeterminate(true);
274             mProgressDialog.setCancelable(false);
275             return mProgressDialog;
276 
277         default:
278             return null;
279         }
280     }
281 
282     /**
283      * Returns dialog box text with updated timeout value
284      */
getDialogText(long millisUntilFinished)285     private CharSequence getDialogText(long millisUntilFinished) {
286         // Format time
287         int minutes = (int)(millisUntilFinished / 60000);
288         String time = String.format("%d:%02d", minutes,
289                 (millisUntilFinished % 60000) / 1000);
290 
291         switch (mDialogType) {
292         case EXIT_ECM_BLOCK_OTHERS:
293             return String.format(getResources().getQuantityText(
294                     R.plurals.alert_dialog_not_avaialble_in_ecm, minutes).toString(), time);
295         case EXIT_ECM_DIALOG:
296             return String.format(getResources().getQuantityText(R.plurals.alert_dialog_exit_ecm,
297                     minutes).toString(), time);
298         }
299         return null;
300     }
301 
302     /**
303      * Closes activity when dialog is dismissed
304      */
305     @Override
onDismiss(DialogInterface dialog)306     public void onDismiss(DialogInterface dialog) {
307         EmergencyCallbackModeExitDialog.this.setResult(RESULT_OK, (new Intent())
308                 .putExtra(EXTRA_EXIT_ECM_RESULT, false));
309         finish();
310     }
311 
312     /**
313      * Listens for Emergency Callback Mode state change intents
314      */
315     private BroadcastReceiver mEcmExitReceiver = new BroadcastReceiver() {
316         @Override
317         public void onReceive(Context context, Intent intent) {
318             // Received exit Emergency Callback Mode notification close all dialogs
319             if (intent.getAction().equals(
320                     TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED)) {
321                 if (intent.getBooleanExtra("phoneinECMState", false) == false) {
322                     if (mAlertDialog != null)
323                         mAlertDialog.dismiss();
324                     if (mProgressDialog != null)
325                         mProgressDialog.dismiss();
326                     EmergencyCallbackModeExitDialog.this.setResult(RESULT_OK, (new Intent())
327                             .putExtra(EXTRA_EXIT_ECM_RESULT, true));
328                     finish();
329                 }
330             }
331         }
332     };
333 
334     /**
335      * Class for interacting with the interface of the service
336      */
337     private ServiceConnection mConnection = new ServiceConnection() {
338         public void onServiceConnected(ComponentName className, IBinder service) {
339             mService = ((EmergencyCallbackModeService.LocalBinder)service).getService();
340             // Notify thread that connection is ready
341             synchronized (EmergencyCallbackModeExitDialog.this) {
342                 EmergencyCallbackModeExitDialog.this.notify();
343             }
344         }
345 
346         public void onServiceDisconnected(ComponentName className) {
347             mService = null;
348         }
349     };
350 
351     /**
352      * Class for receiving framework timer reset notifications
353      */
354     private Handler mTimerResetHandler = new Handler () {
355         public void handleMessage(Message msg) {
356             switch (msg.what) {
357                 case ECM_TIMER_RESET:
358                     if(!((Boolean)((AsyncResult) msg.obj).result).booleanValue()) {
359                         EmergencyCallbackModeExitDialog.this.setResult(RESULT_OK, (new Intent())
360                                 .putExtra(EXTRA_EXIT_ECM_RESULT, false));
361                         finish();
362                     }
363                     break;
364             }
365         }
366     };
367 }
368