/** Preferred way to show this dialog */ public static void show(FragmentManager fragmentManager) { ClearFrequentsDialog dialog = new ClearFrequentsDialog(); dialog.show(fragmentManager, "clearFrequents"); }
/** * This tells the progress dialog to dismiss itself after guaranteeing to be shown for the * specified time in {@link #show(FragmentManager, CharSequence, CharSequence, long)}. */ @Override public void dismiss() { mAllowStateLoss = false; dismissWhenReady(); }
@Override public void onClick(View v) { finish(); } };
/** * Show the call subject dialog given a phone number to dial (e.g. from the dialpad). * * @param activity The activity. * @param number The number to dial. */ public static void start(Activity activity, String number) { start(activity, -1 /* photoId */, null /* photoUri */, null /* contactUri */, number /* nameOrNumber */, false /* isBusiness */, number /* number */, null /* displayNumber */, null /* numberLabel */, null /* phoneAccountHandle */); }
/** * Creates and shows an indeterminate progress dialog. Once the progress dialog is shown, it * will be shown for at least the minDisplayTime (in milliseconds), so that the progress dialog * does not flash in and out to quickly. */ public static IndeterminateProgressDialog show(FragmentManager fragmentManager, CharSequence title, CharSequence message, long minDisplayTime) { IndeterminateProgressDialog dialogFragment = new IndeterminateProgressDialog(); dialogFragment.mTitle = title; dialogFragment.mMessage = message; dialogFragment.mMinDisplayTime = minDisplayTime; dialogFragment.show(fragmentManager, TAG); dialogFragment.mShowTime = System.currentTimeMillis(); dialogFragment.setCancelable(false); return dialogFragment; }
@Override public void onClick(DialogInterface dialog, int which) { if (!PermissionsUtil.hasContactsPermissions(context)) { return; } final IndeterminateProgressDialog progressDialog = IndeterminateProgressDialog.show( getFragmentManager(), getString(R.string.clearFrequentsProgress_title), null, 500); final AsyncTask<Void, Void, Void> task = new AsyncTask<Void, Void, Void>() { @Override protected Void doInBackground(Void... params) { resolver.delete(ContactsContract.DataUsageFeedback.DELETE_USAGE_URI, null, null); return null; } @Override protected void onPostExecute(Void result) { progressDialog.dismiss(); } }; task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); } };
/** * Populates the contact info fields based on the current contact information. */ private void updateContactInfo() { if (mContactUri != null) { setPhoto(mPhotoID, mPhotoUri, mContactUri, mNameOrNumber, mIsBusiness); } else { mContactPhoto.setVisibility(View.GONE); } mNameView.setText(mNameOrNumber); if (!TextUtils.isEmpty(mNumberLabel) && !TextUtils.isEmpty(mDisplayNumber)) { mNumberView.setVisibility(View.VISIBLE); mNumberView.setText(getString(R.string.call_subject_type_and_number, mNumberLabel, mDisplayNumber)); } else { mNumberView.setVisibility(View.GONE); mNumberView.setText(null); } }
@Override public void onClick(View v) { String subject = mCallSubjectView.getText().toString(); Intent intent = CallUtil.getCallWithSubjectIntent(mNumber, mPhoneAccountHandle, subject); TelecomManagerCompat.placeCall( CallSubjectDialog.this, (TelecomManager) getSystemService(Context.TELECOM_SERVICE), intent); mSubjectHistory.add(subject); saveSubjectHistory(mSubjectHistory); finish(); } };
/** * Updates the character limit display, coloring the text RED when the limit is reached or * exceeded. */ private void updateCharacterLimit() { String subjectText = mCallSubjectView.getText().toString(); final int length; // If a message encoding is specified, use that to count bytes in the message. if (mMessageEncoding != null) { length = subjectText.getBytes(mMessageEncoding).length; } else { // No message encoding specified, so just count characters entered. length = subjectText.length(); } mCharacterLimitView.setText( getString(R.string.call_subject_limit, length, mLimit)); if (length >= mLimit) { mCharacterLimitView.setTextColor(getResources().getColor( R.color.call_subject_limit_exceeded)); } else { mCharacterLimitView.setTextColor(getResources().getColor( R.color.dialtacts_secondary_text_color)); } }
/** * Save the old dialog that is about to get destroyed in case this is due to a change * in device orientation. This will allow us to intercept the callback to * {@link #onDismiss(DialogInterface)} in case the callback happens after a new progress dialog * instance was created. */ @Override public void onDestroyView() { mOldDialog = getDialog(); super.onDestroyView(); }
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setRetainInstance(true); }
@Override public void onStart() { super.onStart(); mActivityReady = true; // Check if superDismiss() had been called before. This can happen if in a long // running operation, the user hits the home button and closes this fragment's activity. // Upon returning, we want to dismiss this progress dialog fragment. if (mCalledSuperDismiss) { superDismiss(); } }
@Override public void onClick(View v) { hideSoftKeyboard(CallSubjectDialog.this, mCallSubjectView); showCallHistory(mSubjectList.getVisibility() == View.GONE); } };
/** * Reads arguments from the fragment arguments and populates the necessary instance variables. */ private void readArguments() { Bundle arguments = getIntent().getExtras(); if (arguments == null) { Log.e(TAG, "Arguments cannot be null."); return; } mPhotoID = arguments.getLong(ARG_PHOTO_ID); mPhotoUri = arguments.getParcelable(ARG_PHOTO_URI); mContactUri = arguments.getParcelable(ARG_CONTACT_URI); mNameOrNumber = arguments.getString(ARG_NAME_OR_NUMBER); mIsBusiness = arguments.getBoolean(ARG_IS_BUSINESS); mNumber = arguments.getString(ARG_NUMBER); mDisplayNumber = arguments.getString(ARG_DISPLAY_NUMBER); mNumberLabel = arguments.getString(ARG_NUMBER_LABEL); mPhoneAccountHandle = arguments.getParcelable(ARG_PHONE_ACCOUNT_HANDLE); }
@Override public Dialog onCreateDialog(Bundle savedInstanceState) { // Create the progress dialog and set its properties final ProgressDialog dialog = new ProgressDialog(getActivity()); dialog.setIndeterminate(true); dialog.setIndeterminateDrawable(null); dialog.setTitle(mTitle); dialog.setMessage(mMessage); return dialog; }
@Override public Dialog onCreateDialog(Bundle savedInstanceState) { final Context context = getActivity().getApplicationContext(); final ContentResolver resolver = getActivity().getContentResolver(); final OnClickListener okListener = new OnClickListener() { @Override return new AlertDialog.Builder(getActivity()) .setTitle(R.string.clearFrequentsConfirmation_title) .setMessage(R.string.clearFrequentsConfirmation)
/** * Creates a call subject dialog. * * @param activity The current activity. * @param photoId The photo ID (used to populate contact photo). * @param photoUri The photo Uri (used to populate contact photo). * @param contactUri The Contact URI (used so quick contact can be invoked from contact photo). * @param nameOrNumber The name or number of the callee. * @param isBusiness {@code true} if a business is being called (used for contact photo). * @param number The raw number to dial. * @param displayNumber The number to dial, formatted for display. * @param numberLabel The label for the number (if from a contact). * @param phoneAccountHandle The phone account handle. */ public static void start(Activity activity, long photoId, Uri photoUri, Uri contactUri, String nameOrNumber, boolean isBusiness, String number, String displayNumber, String numberLabel, PhoneAccountHandle phoneAccountHandle) { Bundle arguments = new Bundle(); arguments.putLong(ARG_PHOTO_ID, photoId); arguments.putParcelable(ARG_PHOTO_URI, photoUri); arguments.putParcelable(ARG_CONTACT_URI, contactUri); arguments.putString(ARG_NAME_OR_NUMBER, nameOrNumber); arguments.putBoolean(ARG_IS_BUSINESS, isBusiness); arguments.putString(ARG_NUMBER, number); arguments.putString(ARG_DISPLAY_NUMBER, displayNumber); arguments.putString(ARG_NUMBER_LABEL, numberLabel); arguments.putParcelable(ARG_PHONE_ACCOUNT_HANDLE, phoneAccountHandle); start(activity, arguments); }
/** * This tells the progress dialog to dismiss itself (with state loss) after guaranteeing to be * shown for the specified time in * {@link #show(FragmentManager, CharSequence, CharSequence, long)}. */ @Override public void dismissAllowingStateLoss() { mAllowStateLoss = true; dismissWhenReady(); }
@Override public void onClick(View view) { if (view.getId() == R.id.primary_action_button && !TextUtils.isEmpty(voicemailUri)) { mVoicemailPrimaryActionButtonClicked = true; mExpandCollapseListener.onClick(primaryActionView); } else if (view.getId() == R.id.call_with_note_action) { CallSubjectDialog.start( (Activity) mContext, info.photoId, info.photoUri, info.lookupUri, (String) nameOrNumber /* top line of contact view in call subject dialog */, isBusiness, number, TextUtils.isEmpty(info.name) ? null : displayNumber, /* second line of contact view in dialog. */ numberType, /* phone number type (e.g. mobile) in second line of contact view */ accountHandle); } else { final IntentProvider intentProvider = (IntentProvider) view.getTag(); if (intentProvider != null) { final Intent intent = intentProvider.getIntent(mContext); // See IntentProvider.getCallDetailIntentProvider() for why this may be null. if (intent != null) { DialerUtils.startActivityWithErrorToast(mContext, intent); } } } }
@Override public boolean onMenuItemClick(MenuItem item) { int resId = item.getItemId(); if (resId == R.id.menu_2s_pause) { updateDialString(PAUSE); return true; } else if (resId == R.id.menu_add_wait) { updateDialString(WAIT); return true; } else if (resId == R.id.menu_call_with_note) { CallSubjectDialog.start(getActivity(), mDigits.getText().toString()); hideAndClearDialpad(false); return true; } else { return false; } }