Note the Phone app also handles these sequences too (in a couple of relatively obscure places * in the UI), so there's a separate version of this class under apps/Phone. * *
TODO: there's lots of duplicated code between this class and the corresponding class under * apps/Phone. Let's figure out a way to unify these two classes (in the framework? in a common * shared library?) */ public class SpecialCharSequenceMgr { private static final String TAG = "SpecialCharSequenceMgr"; private static final String TAG_SELECT_ACCT_FRAGMENT = "tag_select_acct_fragment"; private static final String MMI_IMEI_DISPLAY = "*#06#"; private static final String MMI_REGULATORY_INFO_DISPLAY = "*#07#"; /** ***** This code is used to handle SIM Contact queries ***** */ private static final String ADN_PHONE_NUMBER_COLUMN_NAME = "number"; private static final String ADN_NAME_COLUMN_NAME = "name"; private static final int ADN_QUERY_TOKEN = -1; /** * Remembers the previous {@link QueryHandler} and cancel the operation when needed, to prevent * possible crash. * *
QueryHandler may call {@link ProgressDialog#dismiss()} when the screen is already gone, * which will cause the app crash. This variable enables the class to prevent the crash on {@link * #cleanup()}. * *
TODO: Remove this and replace it (and {@link #cleanup()}) with better implementation. One * complication is that we have SpecialCharSequenceMgr in Phone package too, which has *slightly* * different implementation. Note that Phone package doesn't have this problem, so the class on * Phone side doesn't have this functionality. Fundamental fix would be to have one shared * implementation and resolve this corner case more gracefully. */ private static QueryHandler sPreviousAdnQueryHandler; /** This class is never instantiated. */ private SpecialCharSequenceMgr() {} public static boolean handleChars(Context context, String input, EditText textField) { //get rid of the separators so that the string gets parsed correctly String dialString = PhoneNumberUtils.stripSeparators(input); if (handleDeviceIdDisplay(context, dialString) || handleRegulatoryInfoDisplay(context, dialString) || handlePinEntry(context, dialString) || handleAdnEntry(context, dialString, textField) || handleSecretCode(context, dialString)) { return true; } if (MotorolaUtils.handleSpecialCharSequence(context, input)) { return true; } return false; } /** * Cleanup everything around this class. Must be run inside the main thread. * *
This should be called when the screen becomes background.
*/
public static void cleanup() {
Assert.isMainThread();
if (sPreviousAdnQueryHandler != null) {
sPreviousAdnQueryHandler.cancel();
sPreviousAdnQueryHandler = null;
}
}
/**
* Handles secret codes to launch arbitrary activities in the form of *#*# This code works alongside the Asynchronous query handler {@link QueryHandler} and query
* cancel handler implemented in {@link SimContactQueryCookie}.
*/
static boolean handleAdnEntry(Context context, String input, EditText textField) {
/* ADN entries are of the form "N(N)(N)#" */
TelephonyManager telephonyManager =
(TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
if (telephonyManager == null
|| telephonyManager.getPhoneType() != TelephonyManager.PHONE_TYPE_GSM) {
return false;
}
// if the phone is keyguard-restricted, then just ignore this
// input. We want to make sure that sim card contacts are NOT
// exposed unless the phone is unlocked, and this code can be
// accessed from the emergency dialer.
KeyguardManager keyguardManager =
(KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
if (keyguardManager.inKeyguardRestrictedInputMode()) {
return false;
}
int len = input.length();
if ((len > 1) && (len < 5) && (input.endsWith("#"))) {
try {
// get the ordinal number of the sim contact
final int index = Integer.parseInt(input.substring(0, len - 1));
// The original code that navigated to a SIM Contacts list view did not
// highlight the requested contact correctly, a requirement for PTCRB
// certification. This behaviour is consistent with the UI paradigm
// for touch-enabled lists, so it does not make sense to try to work
// around it. Instead we fill in the the requested phone number into
// the dialer text field.
// create the async query handler
final QueryHandler handler = new QueryHandler(context.getContentResolver());
// create the cookie object
final SimContactQueryCookie sc =
new SimContactQueryCookie(index - 1, handler, ADN_QUERY_TOKEN);
// setup the cookie fields
sc.contactNum = index - 1;
sc.setTextField(textField);
// create the progress dialog
sc.progressDialog = new ProgressDialog(context);
sc.progressDialog.setTitle(R.string.simContacts_title);
sc.progressDialog.setMessage(context.getText(R.string.simContacts_emptyLoading));
sc.progressDialog.setIndeterminate(true);
sc.progressDialog.setCancelable(true);
sc.progressDialog.setOnCancelListener(sc);
sc.progressDialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND);
List Note, access to the textField field is going to be synchronized, because the user can
* request a cancel at any time through the UI.
*/
private static class SimContactQueryCookie implements DialogInterface.OnCancelListener {
public ProgressDialog progressDialog;
public int contactNum;
// Used to identify the query request.
private int mToken;
private QueryHandler mHandler;
// The text field we're going to update
private EditText textField;
public SimContactQueryCookie(int number, QueryHandler handler, int token) {
contactNum = number;
mHandler = handler;
mToken = token;
}
/** Synchronized getter for the EditText. */
public synchronized EditText getTextField() {
return textField;
}
/** Synchronized setter for the EditText. */
public synchronized void setTextField(EditText text) {
textField = text;
}
/**
* Cancel the ADN query by stopping the operation and signaling the cookie that a cancel request
* is made.
*/
@Override
public synchronized void onCancel(DialogInterface dialog) {
// close the progress dialog
if (progressDialog != null) {
progressDialog.dismiss();
}
// setting the textfield to null ensures that the UI does NOT get
// updated.
textField = null;
// Cancel the operation if possible.
mHandler.cancelOperation(mToken);
}
}
/**
* Asynchronous query handler that services requests to look up ADNs
*
* Queries originate from {@link #handleAdnEntry}.
*/
private static class QueryHandler extends NoNullCursorAsyncQueryHandler {
private boolean mCanceled;
public QueryHandler(ContentResolver cr) {
super(cr);
}
/** Override basic onQueryComplete to fill in the textfield when we're handed the ADN cursor. */
@Override
protected void onNotNullableQueryComplete(int token, Object cookie, Cursor c) {
try {
sPreviousAdnQueryHandler = null;
if (mCanceled) {
return;
}
SimContactQueryCookie sc = (SimContactQueryCookie) cookie;
// close the progress dialog.
sc.progressDialog.dismiss();
// get the EditText to update or see if the request was cancelled.
EditText text = sc.getTextField();
// if the TextView is valid, and the cursor is valid and positionable on the
// Nth number, then we update the text field and display a toast indicating the
// caller name.
if ((c != null) && (text != null) && (c.moveToPosition(sc.contactNum))) {
String name = c.getString(c.getColumnIndexOrThrow(ADN_NAME_COLUMN_NAME));
String number = c.getString(c.getColumnIndexOrThrow(ADN_PHONE_NUMBER_COLUMN_NAME));
// fill the text in.
text.getText().replace(0, 0, number);
// display the name as a toast
Context context = sc.progressDialog.getContext();
CharSequence msg =
ContactDisplayUtils.getTtsSpannedPhoneNumber(
context.getResources(), R.string.menu_callNumber, name);
Toast.makeText(context, msg, Toast.LENGTH_SHORT).show();
}
} finally {
MoreCloseables.closeQuietly(c);
}
}
public void cancel() {
mCanceled = true;
// Ask AsyncQueryHandler to cancel the whole request. This will fail when the query is
// already started.
cancelOperation(ADN_QUERY_TOKEN);
}
}
}
#*#*.
*
* @param context the context to use
* @param input the text to check for a secret code in
* @return true if a secret code was encountered and handled
*/
static boolean handleSecretCode(Context context, String input) {
// Secret codes are accessed by dialing *#*##*#*
int len = input.length();
if (len <= 8 || !input.startsWith("*#*#") || !input.endsWith("#*#*")) {
return false;
}
String secretCode = input.substring(4, len - 4);
TelephonyManagerCompat.handleSecretCode(context, secretCode);
return true;
}
/**
* Handle ADN requests by filling in the SIM contact number into the requested EditText.
*
*