blob: 8eaa336d45ed3e98ae7f53bd77c0564212a83f04 [file] [log] [blame]
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001/*
2 * Copyright (C) 2006 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
17package com.android.phone;
18
19import android.app.AlertDialog;
20import android.app.Dialog;
21import android.app.ProgressDialog;
Sailesh Nepalbfb68322013-11-07 14:07:41 -080022import android.content.ComponentName;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070023import android.content.Context;
24import android.content.DialogInterface;
Emily Chaie450cdc2014-03-10 15:10:43 +080025import android.content.res.Resources;
26import android.media.AudioAttributes;
27import android.media.AudioManager;
28import android.media.MediaPlayer;
29import android.media.RingtoneManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070030import android.net.Uri;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070031import android.os.Handler;
32import android.os.Message;
SongFerngWang5ae4f6d2018-10-31 22:11:32 +080033import android.os.PersistableBundle;
Emily Chaie450cdc2014-03-10 15:10:43 +080034import android.os.VibrationEffect;
35import android.os.Vibrator;
Tyler Gunn4d45d1c2014-09-12 22:17:53 -070036import android.telecom.PhoneAccount;
Andrew Leed5165b02014-12-05 15:53:58 -080037import android.telecom.PhoneAccountHandle;
Tyler Gunn4d45d1c2014-09-12 22:17:53 -070038import android.telecom.VideoProfile;
SongFerngWang5ae4f6d2018-10-31 22:11:32 +080039import android.telephony.CarrierConfigManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070040import android.telephony.PhoneNumberUtils;
Santos Cordonf69df962015-02-03 11:15:19 -080041import android.telephony.SubscriptionManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070042import android.text.TextUtils;
43import android.util.Log;
Andrew Leeb3ee4dc2015-01-23 17:35:00 -080044import android.view.ContextThemeWrapper;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070045import android.view.KeyEvent;
46import android.view.LayoutInflater;
47import android.view.View;
48import android.view.WindowManager;
49import android.widget.EditText;
50import android.widget.Toast;
51
52import com.android.internal.telephony.Call;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070053import com.android.internal.telephony.CallStateException;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070054import com.android.internal.telephony.Connection;
Stuart Scottdcf40a92014-12-09 10:45:01 -080055import com.android.internal.telephony.IccCard;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070056import com.android.internal.telephony.MmiCode;
57import com.android.internal.telephony.Phone;
58import com.android.internal.telephony.PhoneConstants;
Stuart Scottdcf40a92014-12-09 10:45:01 -080059import com.android.internal.telephony.PhoneFactory;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070060import com.android.internal.telephony.TelephonyCapabilities;
SongFerngWang5ae4f6d2018-10-31 22:11:32 +080061import com.android.phone.settings.SuppServicesUiUtil;
Emily Chaie450cdc2014-03-10 15:10:43 +080062import com.android.telephony.Rlog;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070063
Emily Chaie450cdc2014-03-10 15:10:43 +080064import java.io.IOException;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070065import java.util.List;
66
67/**
68 * Misc utilities for the Phone app.
69 */
70public class PhoneUtils {
Brad Ebingerd3edc222016-03-23 19:44:38 -070071 public static final String EMERGENCY_ACCOUNT_HANDLE_ID = "E";
Santos Cordon7d4ddf62013-07-10 11:58:08 -070072 private static final String LOG_TAG = "PhoneUtils";
73 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
74
75 // Do not check in with VDBG = true, since that may write PII to the system log.
76 private static final boolean VDBG = false;
77
Santos Cordon7d4ddf62013-07-10 11:58:08 -070078 // Return codes from placeCall()
fionaxuf7885142016-11-27 16:08:39 -080079 public static final int CALL_STATUS_DIALED = 0; // The number was successfully dialed
80 public static final int CALL_STATUS_DIALED_MMI = 1; // The specified number was an MMI code
81 public static final int CALL_STATUS_FAILED = 2; // The call failed
Santos Cordon7d4ddf62013-07-10 11:58:08 -070082
Santos Cordon7d4ddf62013-07-10 11:58:08 -070083 // USSD string length for MMI operations
84 static final int MIN_USSD_LEN = 1;
85 static final int MAX_USSD_LEN = 160;
86
Santos Cordon7d4ddf62013-07-10 11:58:08 -070087 /** Define for not a special CNAP string */
88 private static final int CNAP_SPECIAL_CASE_NO = -1;
89
Emily Chaie450cdc2014-03-10 15:10:43 +080090 /** Define for default vibrate pattern if res cannot be found */
91 private static final long[] DEFAULT_VIBRATE_PATTERN = {0, 250, 250, 250};
92
Yorke Leee0f2b792014-10-15 12:30:44 -070093 /**
94 * Theme to use for dialogs displayed by utility methods in this class. This is needed
95 * because these dialogs are displayed using the application context, which does not resolve
96 * the dialog theme correctly.
97 */
Zheng Zhangd889c772017-11-02 15:49:37 -070098 private static final int THEME = com.android.internal.R.style.Theme_DeviceDefault_Dialog_Alert;
Yorke Leee0f2b792014-10-15 12:30:44 -070099
Etan Cohen37abbab2014-03-07 16:57:03 -0800100 /** USSD information used to aggregate all USSD messages */
Etan Cohen37abbab2014-03-07 16:57:03 -0800101 private static StringBuilder sUssdMsg = new StringBuilder();
102
Tony Mak4c8f3c62015-12-07 02:30:37 +0000103 private static final ComponentName PSTN_CONNECTION_SERVICE_COMPONENT =
104 new ComponentName("com.android.phone",
105 "com.android.services.telephony.TelephonyConnectionService");
106
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700107 /** This class is never instantiated. */
108 private PhoneUtils() {
109 }
110
111 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700112 * For a CDMA phone, advance the call state upon making a new
113 * outgoing call.
114 *
115 * <pre>
116 * IDLE -> SINGLE_ACTIVE
117 * or
118 * SINGLE_ACTIVE -> THRWAY_ACTIVE
119 * </pre>
120 * @param app The phone instance.
121 */
Santos Cordonad1ed6d2013-09-16 03:04:23 -0700122 private static void updateCdmaCallStateOnNewOutgoingCall(PhoneGlobals app,
123 Connection connection) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700124 if (app.cdmaPhoneCallState.getCurrentCallState() ==
125 CdmaPhoneCallState.PhoneCallState.IDLE) {
126 // This is the first outgoing call. Set the Phone Call State to ACTIVE
127 app.cdmaPhoneCallState.setCurrentCallState(
128 CdmaPhoneCallState.PhoneCallState.SINGLE_ACTIVE);
129 } else {
130 // This is the second outgoing call. Set the Phone Call State to 3WAY
131 app.cdmaPhoneCallState.setCurrentCallState(
132 CdmaPhoneCallState.PhoneCallState.THRWAY_ACTIVE);
Santos Cordonad1ed6d2013-09-16 03:04:23 -0700133
Santos Cordonda120f42014-08-06 04:44:34 -0700134 // TODO: Remove this code.
Sailesh Nepal23d9ed72014-07-03 09:40:26 -0700135 //app.getCallModeler().setCdmaOutgoing3WayCall(connection);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700136 }
137 }
138
139 /**
140 * Dial the number using the phone passed in.
141 *
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700142 * @param context To perform the CallerInfo query.
143 * @param phone the Phone object.
144 * @param number to be dialed as requested by the user. This is
145 * NOT the phone number to connect to. It is used only to build the
146 * call card and to update the call log. See above for restrictions.
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700147 *
148 * @return either CALL_STATUS_DIALED or CALL_STATUS_FAILED
149 */
Hall Liu0c2ef0b2019-10-31 15:16:38 -0700150 public static int placeOtaspCall(Context context, Phone phone, String number) {
151 final Uri gatewayUri = null;
Santos Cordon69a69192013-08-22 14:25:42 -0700152
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700153 if (VDBG) {
154 log("placeCall()... number: '" + number + "'"
Hall Liu0c2ef0b2019-10-31 15:16:38 -0700155 + ", GW:'" + gatewayUri + "'");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700156 } else {
157 log("placeCall()... number: " + toLogSafePhoneNumber(number)
Hall Liu0c2ef0b2019-10-31 15:16:38 -0700158 + ", GW: " + (gatewayUri != null ? "non-null" : "null"));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700159 }
160 final PhoneGlobals app = PhoneGlobals.getInstance();
161
162 boolean useGateway = false;
Hall Liu0c2ef0b2019-10-31 15:16:38 -0700163 Uri contactRef = null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700164
165 int status = CALL_STATUS_DIALED;
166 Connection connection;
167 String numberToDial;
Hall Liu0c2ef0b2019-10-31 15:16:38 -0700168 numberToDial = number;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700169
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700170 try {
Tyler Gunnc6514352015-06-02 21:46:34 -0700171 connection = app.mCM.dial(phone, numberToDial, VideoProfile.STATE_AUDIO_ONLY);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700172 } catch (CallStateException ex) {
173 // CallStateException means a new outgoing call is not currently
174 // possible: either no more call slots exist, or there's another
175 // call already in the process of dialing or ringing.
176 Log.w(LOG_TAG, "Exception from app.mCM.dial()", ex);
177 return CALL_STATUS_FAILED;
178
179 // Note that it's possible for CallManager.dial() to return
180 // null *without* throwing an exception; that indicates that
181 // we dialed an MMI (see below).
182 }
183
184 int phoneType = phone.getPhoneType();
185
186 // On GSM phones, null is returned for MMI codes
187 if (null == connection) {
Santos Cordonf77a3392014-07-21 19:48:10 -0700188 status = CALL_STATUS_FAILED;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700189 } else {
190 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
Santos Cordonad1ed6d2013-09-16 03:04:23 -0700191 updateCdmaCallStateOnNewOutgoingCall(app, connection);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700192 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700193 }
194
195 return status;
196 }
197
198 /* package */ static String toLogSafePhoneNumber(String number) {
199 // For unknown number, log empty string.
200 if (number == null) {
201 return "";
202 }
203
204 if (VDBG) {
205 // When VDBG is true we emit PII.
206 return number;
207 }
208
209 // Do exactly same thing as Uri#toSafeString() does, which will enable us to compare
210 // sanitized phone numbers.
211 StringBuilder builder = new StringBuilder();
212 for (int i = 0; i < number.length(); i++) {
213 char c = number.charAt(i);
214 if (c == '-' || c == '@' || c == '.') {
215 builder.append(c);
216 } else {
217 builder.append('x');
218 }
219 }
220 return builder.toString();
221 }
222
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700223 /**
224 * Handle the MMIInitiate message and put up an alert that lets
225 * the user cancel the operation, if applicable.
226 *
227 * @param context context to get strings.
228 * @param mmiCode the MmiCode object being started.
229 * @param buttonCallbackMessage message to post when button is clicked.
230 * @param previousAlert a previous alert used in this activity.
231 * @return the dialog handle
232 */
233 static Dialog displayMMIInitiate(Context context,
234 MmiCode mmiCode,
235 Message buttonCallbackMessage,
236 Dialog previousAlert) {
Tyler Gunn77ee9382019-10-31 13:08:23 -0700237 log("displayMMIInitiate: " + Rlog.pii(LOG_TAG, mmiCode.toString()));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700238 if (previousAlert != null) {
239 previousAlert.dismiss();
240 }
241
242 // The UI paradigm we are using now requests that all dialogs have
243 // user interaction, and that any other messages to the user should
244 // be by way of Toasts.
245 //
246 // In adhering to this request, all MMI initiating "OK" dialogs
247 // (non-cancelable MMIs) that end up being closed when the MMI
248 // completes (thereby showing a completion dialog) are being
249 // replaced with Toasts.
250 //
251 // As a side effect, moving to Toasts for the non-cancelable MMIs
252 // also means that buttonCallbackMessage (which was tied into "OK")
253 // is no longer invokable for these dialogs. This is not a problem
254 // since the only callback messages we supported were for cancelable
255 // MMIs anyway.
256 //
257 // A cancelable MMI is really just a USSD request. The term
258 // "cancelable" here means that we can cancel the request when the
259 // system prompts us for a response, NOT while the network is
260 // processing the MMI request. Any request to cancel a USSD while
261 // the network is NOT ready for a response may be ignored.
262 //
263 // With this in mind, we replace the cancelable alert dialog with
264 // a progress dialog, displayed until we receive a request from
265 // the the network. For more information, please see the comments
266 // in the displayMMIComplete() method below.
267 //
268 // Anything that is NOT a USSD request is a normal MMI request,
269 // which will bring up a toast (desribed above).
270
271 boolean isCancelable = (mmiCode != null) && mmiCode.isCancelable();
272
273 if (!isCancelable) {
Tyler Gunn13fe2492017-05-22 14:14:20 -0700274 log("displayMMIInitiate: not a USSD code, displaying status toast.");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700275 CharSequence text = context.getText(R.string.mmiStarted);
276 Toast.makeText(context, text, Toast.LENGTH_SHORT)
277 .show();
278 return null;
279 } else {
Tyler Gunn13fe2492017-05-22 14:14:20 -0700280 log("displayMMIInitiate: running USSD code, displaying intermediate progress.");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700281
282 // create the indeterminate progress dialog and display it.
Alex Hills779841a2015-10-22 13:23:28 -0400283 ProgressDialog pd = new ProgressDialog(context, THEME);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700284 pd.setMessage(context.getText(R.string.ussdRunning));
285 pd.setCancelable(false);
286 pd.setIndeterminate(true);
287 pd.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
288
289 pd.show();
290
291 return pd;
292 }
293
294 }
295
296 /**
297 * Handle the MMIComplete message and fire off an intent to display
298 * the message.
299 *
300 * @param context context to get strings.
301 * @param mmiCode MMI result.
302 * @param previousAlert a previous alert used in this activity.
303 */
304 static void displayMMIComplete(final Phone phone, Context context, final MmiCode mmiCode,
305 Message dismissCallbackMessage,
306 AlertDialog previousAlert) {
307 final PhoneGlobals app = PhoneGlobals.getInstance();
308 CharSequence text;
309 int title = 0; // title for the progress dialog, if needed.
310 MmiCode.State state = mmiCode.getState();
311
Tyler Gunn13fe2492017-05-22 14:14:20 -0700312 log("displayMMIComplete: state=" + state);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700313
314 switch (state) {
315 case PENDING:
316 // USSD code asking for feedback from user.
317 text = mmiCode.getMessage();
Tyler Gunn13fe2492017-05-22 14:14:20 -0700318 log("displayMMIComplete: using text from PENDING MMI message: '" + text + "'");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700319 break;
320 case CANCELLED:
321 text = null;
322 break;
323 case COMPLETE:
SongFerngWang5ae4f6d2018-10-31 22:11:32 +0800324 PersistableBundle b = null;
325 if (SubscriptionManager.isValidSubscriptionId(phone.getSubId())) {
326 b = app.getCarrierConfigForSubId(
327 phone.getSubId());
328 } else {
329 b = app.getCarrierConfig();
330 }
331
332 if (b.getBoolean(CarrierConfigManager.KEY_USE_CALLER_ID_USSD_BOOL)) {
333 text = SuppServicesUiUtil.handleCallerIdUssdResponse(app, context, phone,
334 mmiCode);
335 if (mmiCode.getMessage() != null && !text.equals(mmiCode.getMessage())) {
336 break;
337 }
338 }
339
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700340 if (app.getPUKEntryActivity() != null) {
341 // if an attempt to unPUK the device was made, we specify
342 // the title and the message here.
343 title = com.android.internal.R.string.PinMmi;
344 text = context.getText(R.string.puk_unlocked);
345 break;
346 }
347 // All other conditions for the COMPLETE mmi state will cause
348 // the case to fall through to message logic in common with
349 // the FAILED case.
350
351 case FAILED:
352 text = mmiCode.getMessage();
Tyler Gunn13fe2492017-05-22 14:14:20 -0700353 log("displayMMIComplete (failed): using text from MMI message: '" + text + "'");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700354 break;
355 default:
356 throw new IllegalStateException("Unexpected MmiCode state: " + state);
357 }
358
359 if (previousAlert != null) {
360 previousAlert.dismiss();
361 }
362
363 // Check to see if a UI exists for the PUK activation. If it does
364 // exist, then it indicates that we're trying to unblock the PUK.
365 if ((app.getPUKEntryActivity() != null) && (state == MmiCode.State.COMPLETE)) {
366 if (DBG) log("displaying PUK unblocking progress dialog.");
367
368 // create the progress dialog, make sure the flags and type are
369 // set correctly.
Alex Hills779841a2015-10-22 13:23:28 -0400370 ProgressDialog pd = new ProgressDialog(app, THEME);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700371 pd.setTitle(title);
372 pd.setMessage(text);
373 pd.setCancelable(false);
374 pd.setIndeterminate(true);
375 pd.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG);
376 pd.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
377
378 // display the dialog
379 pd.show();
380
381 // indicate to the Phone app that the progress dialog has
382 // been assigned for the PUK unlock / SIM READY process.
383 app.setPukEntryProgressDialog(pd);
384
SongFerngWangdfa107a2018-10-29 20:31:58 +0800385 } else if ((app.getPUKEntryActivity() != null) && (state == MmiCode.State.FAILED)) {
Youming Yeef84f3e2019-04-15 14:05:02 -0700386 createUssdDialog(app, context, text, phone,
SongFerngWangdfa107a2018-10-29 20:31:58 +0800387 WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
388 // In case of failure to unlock, we'll need to reset the
389 // PUK unlock activity, so that the user may try again.
390 app.setPukEntryActivity(null);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700391 } else {
392 // In case of failure to unlock, we'll need to reset the
393 // PUK unlock activity, so that the user may try again.
394 if (app.getPUKEntryActivity() != null) {
395 app.setPukEntryActivity(null);
396 }
397
398 // A USSD in a pending state means that it is still
399 // interacting with the user.
400 if (state != MmiCode.State.PENDING) {
Youming Yeef84f3e2019-04-15 14:05:02 -0700401 createUssdDialog(app, context, text, phone,
SongFerngWangdfa107a2018-10-29 20:31:58 +0800402 WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700403 } else {
Tyler Gunn13fe2492017-05-22 14:14:20 -0700404 log("displayMMIComplete: USSD code has requested user input. Constructing input "
405 + "dialog.");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700406
407 // USSD MMI code that is interacting with the user. The
408 // basic set of steps is this:
409 // 1. User enters a USSD request
410 // 2. We recognize the request and displayMMIInitiate
411 // (above) creates a progress dialog.
412 // 3. Request returns and we get a PENDING or COMPLETE
413 // message.
414 // 4. These MMI messages are caught in the PhoneApp
415 // (onMMIComplete) and the InCallScreen
416 // (mHandler.handleMessage) which bring up this dialog
417 // and closes the original progress dialog,
418 // respectively.
419 // 5. If the message is anything other than PENDING,
420 // we are done, and the alert dialog (directly above)
421 // displays the outcome.
422 // 6. If the network is requesting more information from
423 // the user, the MMI will be in a PENDING state, and
424 // we display this dialog with the message.
425 // 7. User input, or cancel requests result in a return
426 // to step 1. Keep in mind that this is the only
427 // time that a USSD should be canceled.
428
429 // inflate the layout with the scrolling text area for the dialog.
Andrew Leeb3ee4dc2015-01-23 17:35:00 -0800430 ContextThemeWrapper contextThemeWrapper =
431 new ContextThemeWrapper(context, R.style.DialerAlertDialogTheme);
432 LayoutInflater inflater = (LayoutInflater) contextThemeWrapper.getSystemService(
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700433 Context.LAYOUT_INFLATER_SERVICE);
434 View dialogView = inflater.inflate(R.layout.dialog_ussd_response, null);
435
436 // get the input field.
437 final EditText inputText = (EditText) dialogView.findViewById(R.id.input_field);
438
439 // specify the dialog's click listener, with SEND and CANCEL logic.
440 final DialogInterface.OnClickListener mUSSDDialogListener =
441 new DialogInterface.OnClickListener() {
442 public void onClick(DialogInterface dialog, int whichButton) {
443 switch (whichButton) {
444 case DialogInterface.BUTTON_POSITIVE:
445 // As per spec 24.080, valid length of ussd string
446 // is 1 - 160. If length is out of the range then
447 // display toast message & Cancel MMI operation.
448 if (inputText.length() < MIN_USSD_LEN
449 || inputText.length() > MAX_USSD_LEN) {
450 Toast.makeText(app,
451 app.getResources().getString(R.string.enter_input,
452 MIN_USSD_LEN, MAX_USSD_LEN),
453 Toast.LENGTH_LONG).show();
454 if (mmiCode.isCancelable()) {
455 mmiCode.cancel();
456 }
457 } else {
458 phone.sendUssdResponse(inputText.getText().toString());
459 }
460 break;
461 case DialogInterface.BUTTON_NEGATIVE:
462 if (mmiCode.isCancelable()) {
463 mmiCode.cancel();
464 }
465 break;
466 }
467 }
468 };
469
470 // build the dialog
Andrew Leeb3ee4dc2015-01-23 17:35:00 -0800471 final AlertDialog newDialog = new AlertDialog.Builder(contextThemeWrapper)
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700472 .setMessage(text)
473 .setView(dialogView)
474 .setPositiveButton(R.string.send_button, mUSSDDialogListener)
475 .setNegativeButton(R.string.cancel, mUSSDDialogListener)
476 .setCancelable(false)
477 .create();
478
479 // attach the key listener to the dialog's input field and make
480 // sure focus is set.
481 final View.OnKeyListener mUSSDDialogInputListener =
482 new View.OnKeyListener() {
483 public boolean onKey(View v, int keyCode, KeyEvent event) {
484 switch (keyCode) {
485 case KeyEvent.KEYCODE_CALL:
486 case KeyEvent.KEYCODE_ENTER:
487 if(event.getAction() == KeyEvent.ACTION_DOWN) {
488 phone.sendUssdResponse(inputText.getText().toString());
489 newDialog.dismiss();
490 }
491 return true;
492 }
493 return false;
494 }
495 };
496 inputText.setOnKeyListener(mUSSDDialogInputListener);
497 inputText.requestFocus();
498
499 // set the window properties of the dialog
500 newDialog.getWindow().setType(
501 WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG);
502 newDialog.getWindow().addFlags(
503 WindowManager.LayoutParams.FLAG_DIM_BEHIND);
504
505 // now show the dialog!
506 newDialog.show();
Andrew Leeb3ee4dc2015-01-23 17:35:00 -0800507
508 newDialog.getButton(DialogInterface.BUTTON_POSITIVE)
509 .setTextColor(context.getResources().getColor(R.color.dialer_theme_color));
510 newDialog.getButton(DialogInterface.BUTTON_NEGATIVE)
511 .setTextColor(context.getResources().getColor(R.color.dialer_theme_color));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700512 }
Emily Chaie450cdc2014-03-10 15:10:43 +0800513
514 if (mmiCode.isNetworkInitiatedUssd()) {
515 playSound(context);
516 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700517 }
518 }
519
Emily Chaie450cdc2014-03-10 15:10:43 +0800520 private static void playSound(Context context) {
521 AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
522 int callsRingerMode = audioManager.getRingerMode();
523
524 if (callsRingerMode == AudioManager.RINGER_MODE_NORMAL) {
525 log("playSound : RINGER_MODE_NORMAL");
526 try {
527 Uri notificationUri = RingtoneManager.getDefaultUri(
528 RingtoneManager.TYPE_NOTIFICATION);
529 MediaPlayer mediaPlayer = new MediaPlayer();
530 mediaPlayer.setDataSource(context, notificationUri);
531 AudioAttributes aa = new AudioAttributes.Builder()
532 .setLegacyStreamType(AudioManager.STREAM_NOTIFICATION)
533 .setUsage(AudioAttributes.USAGE_NOTIFICATION)
534 .build();
535 mediaPlayer.setAudioAttributes(aa);
536 mediaPlayer.setLooping(false);
537 mediaPlayer.prepare();
538 mediaPlayer.start();
539 } catch (IOException e) {
540 log("playSound exception : " + e);
541 }
542 } else if (callsRingerMode == AudioManager.RINGER_MODE_VIBRATE) {
543 log("playSound : RINGER_MODE_VIBRATE");
544 Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
545 // Use NotificationManagerService#DEFAULT_VIBRATE_PATTERN if
546 // R.array.config_defaultNotificationVibePattern is not defined.
547 long[] pattern = getLongArray(context.getResources(),
548 R.array.config_defaultNotificationVibePattern, DEFAULT_VIBRATE_PATTERN);
549 vibrator.vibrate(VibrationEffect.createWaveform(pattern, -1));
550 }
551 }
552
553 private static long[] getLongArray(Resources r, int resid, long[] def) {
554 int[] ar = r.getIntArray(resid);
555 if (ar == null) {
556 return def;
557 }
558 final int len = ar.length;
559 long[] out = new long[len];
560 for (int i = 0; i < len; i++) {
561 out[i] = ar[i];
562 }
563 return out;
564 }
565
SongFerngWang5ae4f6d2018-10-31 22:11:32 +0800566 /**
567 * It displays the message dialog for user about the mmi code result message.
568 *
569 * @param app This is {@link PhoneGlobals}
570 * @param context Context to get strings.
571 * @param text This is message's result.
Youming Yeef84f3e2019-04-15 14:05:02 -0700572 * @param phone This is phone to create sssd dialog.
SongFerngWang5ae4f6d2018-10-31 22:11:32 +0800573 * @param windowType The new window type. {@link WindowManager.LayoutParams}.
574 */
575 public static void createUssdDialog(PhoneGlobals app, Context context, CharSequence text,
Youming Yeef84f3e2019-04-15 14:05:02 -0700576 Phone phone, int windowType) {
SongFerngWangdfa107a2018-10-29 20:31:58 +0800577 log("displayMMIComplete: MMI code has finished running.");
578
579 log("displayMMIComplete: Extended NW displayMMIInitiate (" + text + ")");
580 if (text == null || text.length() == 0) {
581 return;
582 }
583
584 // displaying system alert dialog on the screen instead of
585 // using another activity to display the message. This
586 // places the message at the forefront of the UI.
Jack Yu52b754d2020-03-27 19:39:53 -0700587 AlertDialog ussdDialog = new AlertDialog.Builder(context, THEME)
588 .setPositiveButton(R.string.ok, null)
589 .setCancelable(true)
590 .setOnDismissListener(new DialogInterface.OnDismissListener() {
591 @Override
592 public void onDismiss(DialogInterface dialog) {
593 sUssdMsg.setLength(0);
594 }
595 })
596 .create();
SongFerngWangdfa107a2018-10-29 20:31:58 +0800597
Jack Yu52b754d2020-03-27 19:39:53 -0700598 ussdDialog.getWindow().setType(windowType);
599 ussdDialog.getWindow().addFlags(
600 WindowManager.LayoutParams.FLAG_DIM_BEHIND);
SongFerngWangdfa107a2018-10-29 20:31:58 +0800601
SongFerngWangdfa107a2018-10-29 20:31:58 +0800602 if (sUssdMsg.length() != 0) {
Jack Yu52b754d2020-03-27 19:39:53 -0700603 sUssdMsg.insert(0, "\n")
SongFerngWangdfa107a2018-10-29 20:31:58 +0800604 .insert(0, app.getResources().getString(R.string.ussd_dialog_sep))
605 .insert(0, "\n");
606 }
Youming Yeef84f3e2019-04-15 14:05:02 -0700607 if (phone != null && phone.getCarrierName() != null) {
Jack Yu52b754d2020-03-27 19:39:53 -0700608 ussdDialog.setTitle(app.getResources().getString(R.string.carrier_mmi_msg_title,
Youming Yeef84f3e2019-04-15 14:05:02 -0700609 phone.getCarrierName()));
610 } else {
Jack Yu52b754d2020-03-27 19:39:53 -0700611 ussdDialog
Youming Yeef84f3e2019-04-15 14:05:02 -0700612 .setTitle(app.getResources().getString(R.string.default_carrier_mmi_msg_title));
613 }
SongFerngWangdfa107a2018-10-29 20:31:58 +0800614 sUssdMsg.insert(0, text);
Jack Yu52b754d2020-03-27 19:39:53 -0700615 ussdDialog.setMessage(sUssdMsg.toString());
616 ussdDialog.show();
SongFerngWangdfa107a2018-10-29 20:31:58 +0800617 }
618
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700619 /**
620 * Cancels the current pending MMI operation, if applicable.
621 * @return true if we canceled an MMI operation, or false
622 * if the current pending MMI wasn't cancelable
623 * or if there was no current pending MMI at all.
624 *
625 * @see displayMMIInitiate
626 */
627 static boolean cancelMmiCode(Phone phone) {
628 List<? extends MmiCode> pendingMmis = phone.getPendingMmiCodes();
629 int count = pendingMmis.size();
630 if (DBG) log("cancelMmiCode: num pending MMIs = " + count);
631
632 boolean canceled = false;
633 if (count > 0) {
634 // assume that we only have one pending MMI operation active at a time.
635 // I don't think it's possible to enter multiple MMI codes concurrently
636 // in the phone UI, because during the MMI operation, an Alert panel
637 // is displayed, which prevents more MMI code from being entered.
638 MmiCode mmiCode = pendingMmis.get(0);
639 if (mmiCode.isCancelable()) {
640 mmiCode.cancel();
641 canceled = true;
642 }
643 }
644 return canceled;
645 }
646
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700647
648 //
649 // Misc UI policy helper functions
650 //
651
652 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700653 * Check if a phone number can be route through a 3rd party
654 * gateway. The number must be a global phone number in numerical
655 * form (1-800-666-SEXY won't work).
656 *
657 * MMI codes and the like cannot be used as a dial number for the
658 * gateway either.
659 *
660 * @param number To be dialed via a 3rd party gateway.
661 * @return true If the number can be routed through the 3rd party network.
662 */
Santos Cordon69a69192013-08-22 14:25:42 -0700663 private static boolean isRoutableViaGateway(String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700664 if (TextUtils.isEmpty(number)) {
665 return false;
666 }
667 number = PhoneNumberUtils.stripSeparators(number);
668 if (!number.equals(PhoneNumberUtils.convertKeypadLettersToDigits(number))) {
669 return false;
670 }
671 number = PhoneNumberUtils.extractNetworkPortion(number);
672 return PhoneNumberUtils.isGlobalPhoneNumber(number);
673 }
674
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700675 /**
676 * Returns whether the phone is in ECM ("Emergency Callback Mode") or not.
677 */
678 /* package */ static boolean isPhoneInEcm(Phone phone) {
679 if ((phone != null) && TelephonyCapabilities.supportsEcm(phone)) {
Shuo Qiandd210312017-04-12 22:11:33 +0000680 return phone.isInEcm();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700681 }
682 return false;
683 }
684
685 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700686 * Returns true when the given call is in INCOMING state and there's no foreground phone call,
687 * meaning the call is the first real incoming call the phone is having.
688 */
689 public static boolean isRealIncomingCall(Call.State state) {
690 return (state == Call.State.INCOMING && !PhoneGlobals.getInstance().mCM.hasActiveFgCall());
691 }
692
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700693 //
694 // General phone and call state debugging/testing code
695 //
696
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700697 private static void log(String msg) {
698 Log.d(LOG_TAG, msg);
699 }
700
Nancy Chene53a0642015-03-12 11:20:12 -0700701 public static PhoneAccountHandle makePstnPhoneAccountHandle(String id) {
702 return makePstnPhoneAccountHandleWithPrefix(id, "", false);
703 }
704
Nancy Chen32031f42015-03-04 21:00:07 -0800705 public static PhoneAccountHandle makePstnPhoneAccountHandle(int phoneId) {
706 return makePstnPhoneAccountHandle(PhoneFactory.getPhone(phoneId));
707 }
708
Andrew Leed5165b02014-12-05 15:53:58 -0800709 public static PhoneAccountHandle makePstnPhoneAccountHandle(Phone phone) {
710 return makePstnPhoneAccountHandleWithPrefix(phone, "", false);
711 }
712
713 public static PhoneAccountHandle makePstnPhoneAccountHandleWithPrefix(
714 Phone phone, String prefix, boolean isEmergency) {
Andrew Leed5165b02014-12-05 15:53:58 -0800715 // TODO: Should use some sort of special hidden flag to decorate this account as
716 // an emergency-only account
Brad Ebingerd3edc222016-03-23 19:44:38 -0700717 String id = isEmergency ? EMERGENCY_ACCOUNT_HANDLE_ID : prefix +
Brad Ebinger4fe48112016-04-13 11:21:53 -0700718 String.valueOf(phone.getFullIccSerialNumber());
Nancy Chene53a0642015-03-12 11:20:12 -0700719 return makePstnPhoneAccountHandleWithPrefix(id, prefix, isEmergency);
720 }
721
722 public static PhoneAccountHandle makePstnPhoneAccountHandleWithPrefix(
723 String id, String prefix, boolean isEmergency) {
724 ComponentName pstnConnectionServiceName = getPstnConnectionServiceName();
Andrew Leed5165b02014-12-05 15:53:58 -0800725 return new PhoneAccountHandle(pstnConnectionServiceName, id);
726 }
Stuart Scottdcf40a92014-12-09 10:45:01 -0800727
Santos Cordonf69df962015-02-03 11:15:19 -0800728 public static int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
Santos Cordon21e78ac2015-02-06 05:19:29 -0800729 if (phoneAccount != null
730 && phoneAccount.hasCapabilities(PhoneAccount.CAPABILITY_SIM_SUBSCRIPTION)) {
731 return getSubIdForPhoneAccountHandle(phoneAccount.getAccountHandle());
732 }
733 return SubscriptionManager.INVALID_SUBSCRIPTION_ID;
734 }
735
736 public static int getSubIdForPhoneAccountHandle(PhoneAccountHandle handle) {
Nancy Chen31f9ba12016-01-06 11:42:12 -0800737 Phone phone = getPhoneForPhoneAccountHandle(handle);
738 if (phone != null) {
739 return phone.getSubId();
Santos Cordonf69df962015-02-03 11:15:19 -0800740 }
741 return SubscriptionManager.INVALID_SUBSCRIPTION_ID;
742 }
743
Ta-wei Yen845f6992016-06-16 12:53:46 -0700744 public static Phone getPhoneForPhoneAccountHandle(PhoneAccountHandle handle) {
Nancy Chen31f9ba12016-01-06 11:42:12 -0800745 if (handle != null && handle.getComponentName().equals(getPstnConnectionServiceName())) {
746 return getPhoneFromIccId(handle.getId());
747 }
748 return null;
749 }
750
Nancy Chene53a0642015-03-12 11:20:12 -0700751 /**
752 * Determine if a given phone account corresponds to an active SIM
753 *
754 * @param sm An instance of the subscription manager so it is not recreated for each calling of
755 * this method.
756 * @param handle The handle for the phone account to check
757 * @return {@code true} If there is an active SIM for this phone account,
758 * {@code false} otherwise.
759 */
760 public static boolean isPhoneAccountActive(SubscriptionManager sm, PhoneAccountHandle handle) {
Shuo Qianb87f0dc2020-01-06 15:59:12 -0800761 return sm.getActiveSubscriptionInfoForIcc(handle.getId()) != null;
Nancy Chene53a0642015-03-12 11:20:12 -0700762 }
763
Santos Cordonf69df962015-02-03 11:15:19 -0800764 private static ComponentName getPstnConnectionServiceName() {
Tony Mak4c8f3c62015-12-07 02:30:37 +0000765 return PSTN_CONNECTION_SERVICE_COMPONENT;
Santos Cordonf69df962015-02-03 11:15:19 -0800766 }
767
Santos Cordon80855d52015-02-10 04:33:36 -0800768 private static Phone getPhoneFromIccId(String iccId) {
769 if (!TextUtils.isEmpty(iccId)) {
770 for (Phone phone : PhoneFactory.getPhones()) {
Brad Ebinger4fe48112016-04-13 11:21:53 -0700771 String phoneIccId = phone.getFullIccSerialNumber();
Santos Cordon80855d52015-02-10 04:33:36 -0800772 if (iccId.equals(phoneIccId)) {
773 return phone;
774 }
775 }
776 }
Santos Cordon80855d52015-02-10 04:33:36 -0800777 return null;
778 }
779
Stuart Scottdcf40a92014-12-09 10:45:01 -0800780 /**
781 * Register ICC status for all phones.
782 */
783 static final void registerIccStatus(Handler handler, int event) {
784 for (Phone phone : PhoneFactory.getPhones()) {
785 IccCard sim = phone.getIccCard();
786 if (sim != null) {
787 if (VDBG) Log.v(LOG_TAG, "register for ICC status, phone " + phone.getPhoneId());
788 sim.registerForNetworkLocked(handler, event, phone);
789 }
790 }
791 }
792
793 /**
Amit Mahajanf5d92c82018-11-02 17:44:40 -0700794 * Register ICC status for all phones.
795 */
796 static final void registerIccStatus(Handler handler, int event, int phoneId) {
797 Phone[] phones = PhoneFactory.getPhones();
798 IccCard sim = phones[phoneId].getIccCard();
799 if (sim != null) {
800 if (VDBG) {
801 Log.v(LOG_TAG, "register for ICC status, phone " + phones[phoneId].getPhoneId());
802 }
803 sim.registerForNetworkLocked(handler, event, phones[phoneId]);
804 }
805 }
806
807 /**
808 * Unregister ICC status for a specific phone.
809 */
810 static final void unregisterIccStatus(Handler handler, int phoneId) {
811 Phone[] phones = PhoneFactory.getPhones();
812 IccCard sim = phones[phoneId].getIccCard();
813 if (sim != null) {
814 if (VDBG) {
815 Log.v(LOG_TAG, "unregister for ICC status, phone " + phones[phoneId].getPhoneId());
816 }
817 sim.unregisterForNetworkLocked(handler);
818 }
819 }
820
821 /**
Stuart Scottdcf40a92014-12-09 10:45:01 -0800822 * Set the radio power on/off state for all phones.
823 *
824 * @param enabled true means on, false means off.
825 */
826 static final void setRadioPower(boolean enabled) {
827 for (Phone phone : PhoneFactory.getPhones()) {
828 phone.setRadioPower(enabled);
829 }
830 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700831}