blob: 22cff07994b5641be3a7bb159b02d85be3fe2ba8 [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)) {
Tyler Gunn3fc09c02020-05-08 16:35:55 -0700366 log("displaying PUK unblocking progress dialog.");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700367
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
Sooraj Sasindran9dbb2882021-10-19 11:40:34 -0700471 final AlertDialog newDialog =
472 FrameworksUtils.makeAlertDialogBuilder(contextThemeWrapper)
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700473 .setMessage(text)
474 .setView(dialogView)
475 .setPositiveButton(R.string.send_button, mUSSDDialogListener)
476 .setNegativeButton(R.string.cancel, mUSSDDialogListener)
477 .setCancelable(false)
478 .create();
479
480 // attach the key listener to the dialog's input field and make
481 // sure focus is set.
482 final View.OnKeyListener mUSSDDialogInputListener =
483 new View.OnKeyListener() {
484 public boolean onKey(View v, int keyCode, KeyEvent event) {
485 switch (keyCode) {
486 case KeyEvent.KEYCODE_CALL:
487 case KeyEvent.KEYCODE_ENTER:
488 if(event.getAction() == KeyEvent.ACTION_DOWN) {
489 phone.sendUssdResponse(inputText.getText().toString());
490 newDialog.dismiss();
491 }
492 return true;
493 }
494 return false;
495 }
496 };
497 inputText.setOnKeyListener(mUSSDDialogInputListener);
498 inputText.requestFocus();
499
500 // set the window properties of the dialog
501 newDialog.getWindow().setType(
502 WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG);
503 newDialog.getWindow().addFlags(
504 WindowManager.LayoutParams.FLAG_DIM_BEHIND);
505
506 // now show the dialog!
507 newDialog.show();
Andrew Leeb3ee4dc2015-01-23 17:35:00 -0800508
509 newDialog.getButton(DialogInterface.BUTTON_POSITIVE)
510 .setTextColor(context.getResources().getColor(R.color.dialer_theme_color));
511 newDialog.getButton(DialogInterface.BUTTON_NEGATIVE)
512 .setTextColor(context.getResources().getColor(R.color.dialer_theme_color));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700513 }
Emily Chaie450cdc2014-03-10 15:10:43 +0800514
515 if (mmiCode.isNetworkInitiatedUssd()) {
516 playSound(context);
517 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700518 }
519 }
520
Emily Chaie450cdc2014-03-10 15:10:43 +0800521 private static void playSound(Context context) {
522 AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
523 int callsRingerMode = audioManager.getRingerMode();
524
525 if (callsRingerMode == AudioManager.RINGER_MODE_NORMAL) {
526 log("playSound : RINGER_MODE_NORMAL");
527 try {
528 Uri notificationUri = RingtoneManager.getDefaultUri(
529 RingtoneManager.TYPE_NOTIFICATION);
530 MediaPlayer mediaPlayer = new MediaPlayer();
531 mediaPlayer.setDataSource(context, notificationUri);
532 AudioAttributes aa = new AudioAttributes.Builder()
533 .setLegacyStreamType(AudioManager.STREAM_NOTIFICATION)
534 .setUsage(AudioAttributes.USAGE_NOTIFICATION)
535 .build();
536 mediaPlayer.setAudioAttributes(aa);
537 mediaPlayer.setLooping(false);
538 mediaPlayer.prepare();
539 mediaPlayer.start();
540 } catch (IOException e) {
541 log("playSound exception : " + e);
542 }
543 } else if (callsRingerMode == AudioManager.RINGER_MODE_VIBRATE) {
544 log("playSound : RINGER_MODE_VIBRATE");
545 Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
546 // Use NotificationManagerService#DEFAULT_VIBRATE_PATTERN if
547 // R.array.config_defaultNotificationVibePattern is not defined.
548 long[] pattern = getLongArray(context.getResources(),
549 R.array.config_defaultNotificationVibePattern, DEFAULT_VIBRATE_PATTERN);
550 vibrator.vibrate(VibrationEffect.createWaveform(pattern, -1));
551 }
552 }
553
554 private static long[] getLongArray(Resources r, int resid, long[] def) {
555 int[] ar = r.getIntArray(resid);
556 if (ar == null) {
557 return def;
558 }
559 final int len = ar.length;
560 long[] out = new long[len];
561 for (int i = 0; i < len; i++) {
562 out[i] = ar[i];
563 }
564 return out;
565 }
566
SongFerngWang5ae4f6d2018-10-31 22:11:32 +0800567 /**
568 * It displays the message dialog for user about the mmi code result message.
569 *
570 * @param app This is {@link PhoneGlobals}
571 * @param context Context to get strings.
572 * @param text This is message's result.
Youming Yeef84f3e2019-04-15 14:05:02 -0700573 * @param phone This is phone to create sssd dialog.
SongFerngWang5ae4f6d2018-10-31 22:11:32 +0800574 * @param windowType The new window type. {@link WindowManager.LayoutParams}.
575 */
576 public static void createUssdDialog(PhoneGlobals app, Context context, CharSequence text,
Youming Yeef84f3e2019-04-15 14:05:02 -0700577 Phone phone, int windowType) {
SongFerngWangdfa107a2018-10-29 20:31:58 +0800578 log("displayMMIComplete: MMI code has finished running.");
579
580 log("displayMMIComplete: Extended NW displayMMIInitiate (" + text + ")");
581 if (text == null || text.length() == 0) {
582 return;
583 }
584
585 // displaying system alert dialog on the screen instead of
586 // using another activity to display the message. This
587 // places the message at the forefront of the UI.
Jack Yu52b754d2020-03-27 19:39:53 -0700588 AlertDialog ussdDialog = new AlertDialog.Builder(context, THEME)
589 .setPositiveButton(R.string.ok, null)
590 .setCancelable(true)
591 .setOnDismissListener(new DialogInterface.OnDismissListener() {
592 @Override
593 public void onDismiss(DialogInterface dialog) {
594 sUssdMsg.setLength(0);
595 }
596 })
597 .create();
SongFerngWangdfa107a2018-10-29 20:31:58 +0800598
Jack Yu52b754d2020-03-27 19:39:53 -0700599 ussdDialog.getWindow().setType(windowType);
600 ussdDialog.getWindow().addFlags(
601 WindowManager.LayoutParams.FLAG_DIM_BEHIND);
SongFerngWangdfa107a2018-10-29 20:31:58 +0800602
SongFerngWangdfa107a2018-10-29 20:31:58 +0800603 if (sUssdMsg.length() != 0) {
Jack Yu52b754d2020-03-27 19:39:53 -0700604 sUssdMsg.insert(0, "\n")
SongFerngWangdfa107a2018-10-29 20:31:58 +0800605 .insert(0, app.getResources().getString(R.string.ussd_dialog_sep))
606 .insert(0, "\n");
607 }
Youming Yeef84f3e2019-04-15 14:05:02 -0700608 if (phone != null && phone.getCarrierName() != null) {
Jack Yu52b754d2020-03-27 19:39:53 -0700609 ussdDialog.setTitle(app.getResources().getString(R.string.carrier_mmi_msg_title,
Youming Yeef84f3e2019-04-15 14:05:02 -0700610 phone.getCarrierName()));
611 } else {
Jack Yu52b754d2020-03-27 19:39:53 -0700612 ussdDialog
Youming Yeef84f3e2019-04-15 14:05:02 -0700613 .setTitle(app.getResources().getString(R.string.default_carrier_mmi_msg_title));
614 }
SongFerngWangdfa107a2018-10-29 20:31:58 +0800615 sUssdMsg.insert(0, text);
Jack Yu52b754d2020-03-27 19:39:53 -0700616 ussdDialog.setMessage(sUssdMsg.toString());
617 ussdDialog.show();
SongFerngWangdfa107a2018-10-29 20:31:58 +0800618 }
619
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700620 /**
621 * Cancels the current pending MMI operation, if applicable.
622 * @return true if we canceled an MMI operation, or false
623 * if the current pending MMI wasn't cancelable
624 * or if there was no current pending MMI at all.
625 *
626 * @see displayMMIInitiate
627 */
628 static boolean cancelMmiCode(Phone phone) {
629 List<? extends MmiCode> pendingMmis = phone.getPendingMmiCodes();
630 int count = pendingMmis.size();
631 if (DBG) log("cancelMmiCode: num pending MMIs = " + count);
632
633 boolean canceled = false;
634 if (count > 0) {
635 // assume that we only have one pending MMI operation active at a time.
636 // I don't think it's possible to enter multiple MMI codes concurrently
637 // in the phone UI, because during the MMI operation, an Alert panel
638 // is displayed, which prevents more MMI code from being entered.
639 MmiCode mmiCode = pendingMmis.get(0);
640 if (mmiCode.isCancelable()) {
641 mmiCode.cancel();
642 canceled = true;
643 }
644 }
645 return canceled;
646 }
647
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700648
649 //
650 // Misc UI policy helper functions
651 //
652
653 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700654 * Check if a phone number can be route through a 3rd party
655 * gateway. The number must be a global phone number in numerical
656 * form (1-800-666-SEXY won't work).
657 *
658 * MMI codes and the like cannot be used as a dial number for the
659 * gateway either.
660 *
661 * @param number To be dialed via a 3rd party gateway.
662 * @return true If the number can be routed through the 3rd party network.
663 */
Santos Cordon69a69192013-08-22 14:25:42 -0700664 private static boolean isRoutableViaGateway(String number) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700665 if (TextUtils.isEmpty(number)) {
666 return false;
667 }
668 number = PhoneNumberUtils.stripSeparators(number);
669 if (!number.equals(PhoneNumberUtils.convertKeypadLettersToDigits(number))) {
670 return false;
671 }
672 number = PhoneNumberUtils.extractNetworkPortion(number);
673 return PhoneNumberUtils.isGlobalPhoneNumber(number);
674 }
675
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700676 /**
677 * Returns whether the phone is in ECM ("Emergency Callback Mode") or not.
678 */
679 /* package */ static boolean isPhoneInEcm(Phone phone) {
680 if ((phone != null) && TelephonyCapabilities.supportsEcm(phone)) {
Shuo Qiandd210312017-04-12 22:11:33 +0000681 return phone.isInEcm();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700682 }
683 return false;
684 }
685
686 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700687 * Returns true when the given call is in INCOMING state and there's no foreground phone call,
688 * meaning the call is the first real incoming call the phone is having.
689 */
690 public static boolean isRealIncomingCall(Call.State state) {
691 return (state == Call.State.INCOMING && !PhoneGlobals.getInstance().mCM.hasActiveFgCall());
692 }
693
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700694 //
695 // General phone and call state debugging/testing code
696 //
697
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700698 private static void log(String msg) {
699 Log.d(LOG_TAG, msg);
700 }
701
Nancy Chene53a0642015-03-12 11:20:12 -0700702 public static PhoneAccountHandle makePstnPhoneAccountHandle(String id) {
703 return makePstnPhoneAccountHandleWithPrefix(id, "", false);
704 }
705
Nancy Chen32031f42015-03-04 21:00:07 -0800706 public static PhoneAccountHandle makePstnPhoneAccountHandle(int phoneId) {
707 return makePstnPhoneAccountHandle(PhoneFactory.getPhone(phoneId));
708 }
709
Andrew Leed5165b02014-12-05 15:53:58 -0800710 public static PhoneAccountHandle makePstnPhoneAccountHandle(Phone phone) {
711 return makePstnPhoneAccountHandleWithPrefix(phone, "", false);
712 }
713
714 public static PhoneAccountHandle makePstnPhoneAccountHandleWithPrefix(
715 Phone phone, String prefix, boolean isEmergency) {
Andrew Leed5165b02014-12-05 15:53:58 -0800716 // TODO: Should use some sort of special hidden flag to decorate this account as
717 // an emergency-only account
Brad Ebingerd3edc222016-03-23 19:44:38 -0700718 String id = isEmergency ? EMERGENCY_ACCOUNT_HANDLE_ID : prefix +
Shuo Qian075851e2021-10-11 12:59:06 -0700719 String.valueOf(phone.getSubId());
Nancy Chene53a0642015-03-12 11:20:12 -0700720 return makePstnPhoneAccountHandleWithPrefix(id, prefix, isEmergency);
721 }
722
723 public static PhoneAccountHandle makePstnPhoneAccountHandleWithPrefix(
724 String id, String prefix, boolean isEmergency) {
725 ComponentName pstnConnectionServiceName = getPstnConnectionServiceName();
Andrew Leed5165b02014-12-05 15:53:58 -0800726 return new PhoneAccountHandle(pstnConnectionServiceName, id);
727 }
Stuart Scottdcf40a92014-12-09 10:45:01 -0800728
Santos Cordonf69df962015-02-03 11:15:19 -0800729 public static int getSubIdForPhoneAccount(PhoneAccount phoneAccount) {
Santos Cordon21e78ac2015-02-06 05:19:29 -0800730 if (phoneAccount != null
731 && phoneAccount.hasCapabilities(PhoneAccount.CAPABILITY_SIM_SUBSCRIPTION)) {
732 return getSubIdForPhoneAccountHandle(phoneAccount.getAccountHandle());
733 }
734 return SubscriptionManager.INVALID_SUBSCRIPTION_ID;
735 }
736
737 public static int getSubIdForPhoneAccountHandle(PhoneAccountHandle handle) {
Nancy Chen31f9ba12016-01-06 11:42:12 -0800738 Phone phone = getPhoneForPhoneAccountHandle(handle);
739 if (phone != null) {
740 return phone.getSubId();
Santos Cordonf69df962015-02-03 11:15:19 -0800741 }
742 return SubscriptionManager.INVALID_SUBSCRIPTION_ID;
743 }
744
Ta-wei Yen845f6992016-06-16 12:53:46 -0700745 public static Phone getPhoneForPhoneAccountHandle(PhoneAccountHandle handle) {
Nancy Chen31f9ba12016-01-06 11:42:12 -0800746 if (handle != null && handle.getComponentName().equals(getPstnConnectionServiceName())) {
Shuo Qian075851e2021-10-11 12:59:06 -0700747 return getPhoneFromSubId(handle.getId());
Nancy Chen31f9ba12016-01-06 11:42:12 -0800748 }
749 return null;
750 }
751
Nancy Chene53a0642015-03-12 11:20:12 -0700752 /**
753 * Determine if a given phone account corresponds to an active SIM
754 *
755 * @param sm An instance of the subscription manager so it is not recreated for each calling of
756 * this method.
757 * @param handle The handle for the phone account to check
758 * @return {@code true} If there is an active SIM for this phone account,
759 * {@code false} otherwise.
760 */
761 public static boolean isPhoneAccountActive(SubscriptionManager sm, PhoneAccountHandle handle) {
Shuo Qian075851e2021-10-11 12:59:06 -0700762 return sm.getActiveSubscriptionInfo(Integer.parseInt(handle.getId())) != null;
Nancy Chene53a0642015-03-12 11:20:12 -0700763 }
764
Santos Cordonf69df962015-02-03 11:15:19 -0800765 private static ComponentName getPstnConnectionServiceName() {
Tony Mak4c8f3c62015-12-07 02:30:37 +0000766 return PSTN_CONNECTION_SERVICE_COMPONENT;
Santos Cordonf69df962015-02-03 11:15:19 -0800767 }
768
Shuo Qian075851e2021-10-11 12:59:06 -0700769 private static Phone getPhoneFromSubId(String subId) {
770 if (!TextUtils.isEmpty(subId)) {
Santos Cordon80855d52015-02-10 04:33:36 -0800771 for (Phone phone : PhoneFactory.getPhones()) {
Shuo Qian075851e2021-10-11 12:59:06 -0700772 String phoneSubId = Integer.toString(phone.getSubId());
773 if (subId.equals(phoneSubId)) {
Santos Cordon80855d52015-02-10 04:33:36 -0800774 return phone;
775 }
776 }
777 }
Santos Cordon80855d52015-02-10 04:33:36 -0800778 return null;
779 }
780
Stuart Scottdcf40a92014-12-09 10:45:01 -0800781 /**
782 * Register ICC status for all phones.
783 */
784 static final void registerIccStatus(Handler handler, int event) {
785 for (Phone phone : PhoneFactory.getPhones()) {
786 IccCard sim = phone.getIccCard();
787 if (sim != null) {
788 if (VDBG) Log.v(LOG_TAG, "register for ICC status, phone " + phone.getPhoneId());
789 sim.registerForNetworkLocked(handler, event, phone);
790 }
791 }
792 }
793
794 /**
Amit Mahajanf5d92c82018-11-02 17:44:40 -0700795 * Register ICC status for all phones.
796 */
797 static final void registerIccStatus(Handler handler, int event, int phoneId) {
798 Phone[] phones = PhoneFactory.getPhones();
799 IccCard sim = phones[phoneId].getIccCard();
800 if (sim != null) {
801 if (VDBG) {
802 Log.v(LOG_TAG, "register for ICC status, phone " + phones[phoneId].getPhoneId());
803 }
804 sim.registerForNetworkLocked(handler, event, phones[phoneId]);
805 }
806 }
807
808 /**
809 * Unregister ICC status for a specific phone.
810 */
811 static final void unregisterIccStatus(Handler handler, int phoneId) {
812 Phone[] phones = PhoneFactory.getPhones();
813 IccCard sim = phones[phoneId].getIccCard();
814 if (sim != null) {
815 if (VDBG) {
816 Log.v(LOG_TAG, "unregister for ICC status, phone " + phones[phoneId].getPhoneId());
817 }
818 sim.unregisterForNetworkLocked(handler);
819 }
820 }
821
822 /**
Stuart Scottdcf40a92014-12-09 10:45:01 -0800823 * Set the radio power on/off state for all phones.
824 *
825 * @param enabled true means on, false means off.
826 */
827 static final void setRadioPower(boolean enabled) {
828 for (Phone phone : PhoneFactory.getPhones()) {
829 phone.setRadioPower(enabled);
830 }
831 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700832}