Java Examples for android.R.string

/**
	 * Display a standard alert dialog 
	 * @param ctx
	 * @param msg
	 */
public static void showErrorDialog(Context ctx, CharSequence msg) {
    new AlertDialog.Builder(ctx).setTitle(android.R.string.dialog_alert_title).setIcon(android.R.drawable.ic_dialog_alert).setMessage(msg).setCancelable(true).setNeutralButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
        }
    }).create().show();
}

@Override
public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
    Symbol symbol = ASTHelpers.getSymbol(tree);
    // "android.R.string.yes" out of symbol, just "yes"
    if (symbol == null || symbol.owner == null || symbol.getKind() != ElementKind.FIELD || !symbol.isStatic() || !R_STRING_CLASSNAME.contentEquals(symbol.owner.getQualifiedName())) {
        return Description.NO_MATCH;
    }
    String misleading = symbol.getSimpleName().toString();
    String preferred = MISLEADING.get(misleading);
    if (preferred == null) {
        return Description.NO_MATCH;
    }
    return buildDescription(tree).setMessage(String.format("%s.%s is not \"%s\" but \"%s\"; prefer %s.%s for clarity", R_STRING_CLASSNAME, misleading, ASSUMED_MEANINGS.get(misleading), ASSUMED_MEANINGS.get(preferred), R_STRING_CLASSNAME, preferred)).addFix(// Keep the way tree refers to android.R.string as it is but replace the identifier
    SuggestedFix.replace(tree, tree.getExpression() + "." + preferred)).build();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    this.setCancelable(false);
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.openvpn_install_error_title).setMessage(msg).setPositiveButton(android.R.string.ok, new OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            getActivity().finish();
        }
    }).setCancelable(false).create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    String additionalMessage = getArguments().getString("additionalMessage");
    final int managementMode = getArguments().getInt("managementMode");
    final long certHandlingStrategyId = getArguments().getLong("certHandlingStrategyId");
    final String endpoint = getArguments().getString("endpoint");
    final boolean startActivity = getArguments().getBoolean("startActivity");
    StringBuilder message = new StringBuilder(getString(R.string.dialog_certificate_missing_start));
    if (additionalMessage != null) {
        message.append('\n').append(additionalMessage).append('\n');
    }
    message.append(getString(R.string.dialog_certificate_missing_end));
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle(android.R.string.dialog_alert_title).setMessage(message.toString()).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            if (startActivity) {
                final Intent intent = new Intent(getActivity(), AuthenticatorActivity_.class);
                intent.putExtra(AuthenticatorActivity.SHOW_ADVANCED_AUTHENTICATOR, true);
                startActivity(intent);
            } else {
                ((AuthenticatorActivity) getActivity()).btnAdvancedClicked();
            }
        }
    }).setNegativeButton(android.R.string.no, null);
    return builder.create();
}

public static void showConfirmDialog(final Activity activity, String title, String message, DialogInterface.OnClickListener positiveButtonListener) throws NullActivityException {
    if (positiveButtonListener == null) {
        positiveButtonListener = new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int which) {
                dialog.cancel();
            }
        };
    }
    if (activity == null) {
        throw new NullActivityException();
    }
    new AlertDialog.Builder(activity).setTitle(title).setMessage(message).setPositiveButton(android.R.string.ok, positiveButtonListener).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
        }
    }).show();
}

@Override
public Dialog onCreateDialog(Bundle state) {
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.open_browser).setMessage(getArguments().getString("url")).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(getArguments().getString("url")));
            getActivity().startActivity(intent);
        }
    }).setNegativeButton(android.R.string.no, null).create();
}

@Override
protected void onClick() {
    if (!isChecked() && !KissApplication.getRootHandler(getContext()).isRootAvailable()) {
        //show error dialog
        new AlertDialog.Builder(getContext()).setMessage(R.string.root_mode_error).setPositiveButton(android.R.string.ok, new OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
            // does nothing
            }
        }).show();
    } else {
        super.onClick();
    }
    try {
        KissApplication.resetRootHandler(getContext());
    } catch (NullPointerException e) {
    }
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new AlertDialog.Builder(getActivity()).setInverseBackgroundForced(UIUtils.shouldDialogInverseBackground(getActivity())).setTitle(R.string.file_exists).setMessage(R.string.overwrite_question).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            ((Overwritable) getTargetFragment()).overwrite();
        }
    }).setNegativeButton(android.R.string.cancel, null).create();
}

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new AlertDialog.Builder(getActivity(), R.style.BaseDialog).setTitle(R.string.dialog_clear_title).setMessage(R.string.dialog_clear_content).setPositiveButton(android.R.string.yes, ( dialog,  which) -> {
        sendResult();
    }).setNegativeButton(android.R.string.no, ( dialog,  which) -> {
        dismiss();
    }).create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.are_you_sure).setMessage(R.string.training_dialog_submission).setNegativeButton(android.R.string.cancel, null).setPositiveButton(android.R.string.yes, new OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            Intent i = new Intent(mContext, ListenActivity.class);
            i.putExtra(ListenActivity.EXTRA_SUBMISSION, true);
            startActivity(i);
        }
    }).create();
}

public static void confirmFav(final Context context, final HashMap<String, String> movieMap, final String movie_id, final String movie_id_final, final int flagFavorite) {
    new AlertDialog.Builder(context).setTitle("Favorite").setMessage("Are you sure you want to add this to favorite section?").setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
            OfflineMovies offlineMovies = new OfflineMovies(context);
            offlineMovies.saveMovie(movieMap, movie_id, movie_id_final, flagFavorite);
        }
    }).setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
            dialog.cancel();
        }
    }).show();
}

public static void showDialog(Context ctx, String str) {
    AlertDialog.Builder builder = new AlertDialog.Builder(ctx, R.style.set_dialog);
    builder.setMessage(str);
    builder.setNeutralButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
        }
    });
    builder.create().show();
}

public static void askForPermission(final Activity activity, final int requestCode, final String permission, @StringRes final int askTitle, @StringRes final int askContent) {
    if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
        MaterialDialog.Builder builder = new MaterialDialog.Builder(activity).title(askTitle).content(askContent).positiveText(android.R.string.yes).negativeText(android.R.string.no).onPositive(( dialog,  which) -> ActivityCompat.requestPermissions(activity, new String[] { permission }, requestCode));
        builder.show();
    } else {
        ActivityCompat.requestPermissions(activity, new String[] { permission }, requestCode);
    }
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog builder = new AlertDialog.Builder(getActivity()).setMessage(getString(R.string.root_access_dialog)).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            //                        FlurryAgent.logEvent("Dialog_Root_Allowed_Access");
            PreferenceManager.getDefaultSharedPreferences(Aptoide.getContext()).edit().putBoolean("allowRoot", true).commit();
        }
    }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            PreferenceManager.getDefaultSharedPreferences(Aptoide.getContext()).edit().putBoolean("allowRoot", false).commit();
        }
    }).create();
    return builder;
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    Builder builder = new Builder(this);
    builder.setTitle(R.string.settings_forget_certificates);
    builder.setMessage(R.string.settings_forget_certificates_long);
    builder.setPositiveButton(android.R.string.yes, new OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            File dir = getApplicationContext().getDir(KEYSTORE_DIR, Context.MODE_PRIVATE);
            File keyStoreFile = new File(dir + File.separator + KEYSTORE_FILE);
            keyStoreFile.delete();
            finish();
        }
    });
    builder.setNegativeButton(android.R.string.no, new OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            finish();
        }
    });
    builder.create().show();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setMessage(R.string.guided_mode_warning).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            if (coord != null) {
                listener.onForcedGuidedPoint(coord);
            }
        }
    }).setNegativeButton(android.R.string.cancel, null);
    return builder.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle(R.string.no_contact_information).setMessage(R.string.no_contact_information_message).setNegativeButton(android.R.string.cancel, null).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            startActivity(new Intent(getActivity(), ContactDetailActivity.class));
        }
    });
    return builder.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new AlertDialog.Builder(getActivity()).setMessage(getArguments().getString(ARG_MESSAGE)).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            evManager.fire(new GDFSDialogConfirmEvent(true));
        }
    }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            evManager.fire(new GDFSDialogConfirmEvent(false));
        }
    }).setOnCancelListener(new DialogInterface.OnCancelListener() {

        @Override
        public void onCancel(DialogInterface dialog) {
            evManager.fire(new GDFSDialogConfirmEvent(false));
        }
    }).create();
}

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setMessage(getString(R.string.workaround_warning)).setOnCancelListener(new DialogInterface.OnCancelListener() {

        @Override
        public void onCancel(DialogInterface dialog) {
            WorkaroundConfirmation.this.finish();
        }
    }).setPositiveButton(getString(android.R.string.yes), new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
            SharedPreferences prefs = WorkaroundConfirmation.this.getSharedPreferences(WorkaroundConfirmation.this.getPackageName() + "_preferences", MODE_MULTI_PROCESS);
            SharedPreferences.Editor editor = prefs.edit();
            editor.putBoolean("workaround_ignore", true);
            editor.commit();
            WorkaroundConfirmation.this.finish();
        }
    }).setNegativeButton(getString(android.R.string.no), new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
            WorkaroundConfirmation.this.finish();
        }
    });
    AlertDialog alert = builder.create();
    alert.show();
}

private void showSuccessDialog(String msg) {
    new AlertDialog.Builder(mContext).setMessage(msg).setCancelable(false).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            dialog.dismiss();
            onFinish();
        }
    }).create().show();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.dialog_title).setMessage(R.string.dialog_message).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            if (mOnAlertDialogListener != null) {
                mOnAlertDialogListener.OnPositiveButtonClick();
            }
        }
    }).setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
        }
    }).create();
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_alert_dialog_sample);
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setIcon(android.R.drawable.ic_dialog_alert);
    builder.setTitle(R.string.dialog_title);
    builder.setMessage(R.string.dialog_message);
    builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
        // OKƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ
        }
    });
    builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
        // ƒLƒƒƒ“ƒZƒ‹ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ
        }
    });
    AlertDialog dialog = builder.create();
    dialog.show();
}

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final long highestItemIdBeforeSync = getIntent().getLongExtra("highestItemIdBeforeSync", 0);
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    // set title
    alertDialogBuilder.setTitle(getString(R.string.no_wifi_available));
    // set dialog message
    alertDialogBuilder.setMessage(getString(R.string.do_you_want_to_download_without_wifi)).setCancelable(true).setPositiveButton(getString(android.R.string.yes), new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
            Intent service = new Intent(DownloadImagesActivity.this, DownloadImagesService.class);
            service.putExtra(DownloadImagesService.LAST_ITEM_ID, highestItemIdBeforeSync);
            service.putExtra(DownloadImagesService.DOWNLOAD_MODE_STRING, DownloadImagesService.DownloadMode.PICTURES_ONLY);
            DownloadImagesActivity.this.startService(service);
            DownloadImagesActivity.this.finish();
        }
    }).setNegativeButton(getString(android.R.string.no), new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
            DownloadImagesActivity.this.finish();
        }
    });
    AlertDialog alertDialog = alertDialogBuilder.create();
    alertDialog.show();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final EditText nameText = new EditText(getActivity());
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.custom_listname).setView(nameText).setNegativeButton(android.R.string.cancel, null).setPositiveButton(android.R.string.ok, new OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            customListsFragment.createList(nameText.getText().toString());
        }
    }).create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    OnClickListener clickListener = new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int whichButton) {
            dialog.dismiss();
        }
    };
    String versionInfo = RawReader.readTextRaw(getActivity().getApplicationContext(), R.raw.version_info);
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle(R.string.new_version);
    builder.setPositiveButton(android.R.string.ok, clickListener);
    builder.setMessage(versionInfo);
    return builder.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    Bundle args = getArguments();
    String title = args.getString(TITLE);
    String message = args.getString(MESSAGE);
    AlertDialog.Builder builder = new Builder(getActivity());
    builder.setTitle(title).setMessage(message);
    builder.setPositiveButton(android.R.string.ok, null);
    return builder.create();
}

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
    builder.setTitle(R.string.dialog_remote_backup_drive_restore_title);
    builder.setMessage(R.string.dialog_remote_backup_drive_restore_message);
    builder.setCancelable(true);
    builder.setPositiveButton(android.R.string.ok, this);
    builder.setNegativeButton(android.R.string.cancel, this);
    return builder.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setMessage(R.string.guided_mode_warning).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            if (coord != null) {
                listener.onForcedGuidedPoint(coord);
            }
        }
    }).setNegativeButton(android.R.string.cancel, null);
    return builder.create();
}

public static void show(Context context, int title_id, String message, final String jid, final Ok ok) {
    new AlertDialog.Builder(context).setTitle(title_id).setMessage(message).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
            ok.ok(jid);
        }
    }).setNegativeButton(android.R.string.no, null).create().show();
}

public static void show(Context context, int title_id, String message, final String jid, final Ok ok) {
    new AlertDialog.Builder(context).setTitle(title_id).setMessage(message).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
            ok.ok(jid);
        }
    }).setNegativeButton(android.R.string.no, null).create().show();
}

public static AlertDialog showDownloadDialog(final Context activity) {
    AlertDialog.Builder downloadDialog = new AlertDialog.Builder(activity);
    downloadDialog.setTitle(IntentIntegrator.DEFAULT_TITLE);
    downloadDialog.setMessage(IntentIntegrator.DEFAULT_MESSAGE);
    downloadDialog.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            Uri uri = Uri.parse("amzn://apps/android?asin=B004R1FCII");
            Intent intent = new Intent(Intent.ACTION_VIEW, uri);
            try {
                activity.startActivity(intent);
            } catch (ActivityNotFoundException anfe) {
                Log.w(TAG, "Amazon is not installed; cannot install");
            }
        }
    });
    downloadDialog.setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
        }
    });
    return downloadDialog.show();
}

public static void showInfoDialog(Context ctx, String msg) {
    AlertDialog.Builder builder = new AlertDialog.Builder(ctx);
    builder.setMessage(msg);
    builder.setPositiveButton(ctx.getString(android.R.string.ok), new OnClickListener() {

        public void onClick(DialogInterface dialog, int arg1) {
            dialog.cancel();
        }
    });
    AlertDialog alert = builder.create();
    alert.show();
}

public static void newRequestErrorDialog(Context context, String errorMessage) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setNeutralButton(android.R.string.ok, ( dialog,  which) -> dialog.dismiss()).setTitle(R.string.download_error_request_error).setMessage(context.getString(R.string.download_request_error_dialog_message_prefix) + errorMessage);
    builder.create().show();
}

public void showSingleChoiceDialog() {
    AlertDialog.Builder builder = new AlertDialog.Builder(ConfirmationDialogActivity.this);
    builder.setTitle(R.string.confirmation_dialog_title);
    //list of items
    String[] items = getResources().getStringArray(R.array.ringtone_list);
    builder.setSingleChoiceItems(items, 0, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
        // item selected logic
        }
    });
    String positiveText = getString(android.R.string.ok);
    builder.setPositiveButton(positiveText, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
        // positive button logic
        }
    });
    String negativeText = getString(android.R.string.cancel);
    builder.setNegativeButton(negativeText, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
        // negative button logic
        }
    });
    AlertDialog dialog = builder.create();
    // display dialog
    dialog.show();
}

private void initView() {
    View backImageView = findViewByResName("backImageView");
    backImageView.setTag(android.R.string.cancel);
    backImageView.setOnClickListener(this);
    View okImageView = findViewByResName("okImageView");
    okImageView.setTag(android.R.string.ok);
    okImageView.setOnClickListener(this);
    gridViewAdapter = new PlatformGridViewAdapter(activity);
    gridViewAdapter.setCustomerLogos(customerLogos);
    GridView gridView = (GridView) findViewByResName("gridView");
    gridView.setAdapter(gridViewAdapter);
    new AsyncTask<Void, Void, Platform[]>() {

        @Override
        protected Platform[] doInBackground(Void... params) {
            return ShareSDK.getPlatformList();
        }

        @Override
        protected void onPostExecute(Platform[] platforms) {
            gridViewAdapter.setData(platforms, hiddenPlatforms);
        }
    }.execute();
}

private void initView() {
    View backImageView = findViewByResName("backImageView");
    backImageView.setTag(android.R.string.cancel);
    backImageView.setOnClickListener(this);
    View okImageView = findViewByResName("okImageView");
    okImageView.setTag(android.R.string.ok);
    okImageView.setOnClickListener(this);
    gridViewAdapter = new PlatformGridViewAdapter(activity);
    gridViewAdapter.setCustomerLogos(customerLogos);
    GridView gridView = (GridView) findViewByResName("gridView");
    gridView.setAdapter(gridViewAdapter);
    new AsyncTask<Void, Void, Platform[]>() {

        @Override
        protected Platform[] doInBackground(Void... params) {
            return ShareSDK.getPlatformList();
        }

        @Override
        protected void onPostExecute(Platform[] platforms) {
            gridViewAdapter.setData(platforms, hiddenPlatforms);
        }
    }.execute();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    LayoutInflater inflater = getActivity().getLayoutInflater();
    View v = inflater.inflate(R.layout.activity_route, null);
    routeName = (EditText) v.findViewById(R.id.route_name);
    interval = (EditText) v.findViewById(R.id.update_interval);
    builder.setView(v);
    builder.setTitle("Record a Route");
    if (bSwitchButtonPlacement) {
        // Really the positive, but reversed to be compatible with ICS and onward.
        builder.setCancelable(false).setPositiveButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int id) {
                listener.onRecordRouteDialogNegativeClick(dialog);
            }
        }).setNegativeButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int id) {
                int i = 5;
                if (!interval.getText().toString().isEmpty())
                    i = Integer.parseInt(interval.getText().toString());
                listener.onRecordRouteDialogPositiveClick(dialog, routeName.getText().toString(), i);
            }
        });
    } else {
        builder.setCancelable(false).setPositiveButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int id) {
                listener.onRecordRouteDialogNegativeClick(dialog);
            }
        }).setNegativeButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int id) {
                int i = 5;
                if (!interval.getText().toString().isEmpty())
                    i = Integer.parseInt(interval.getText().toString());
                listener.onRecordRouteDialogPositiveClick(dialog, routeName.getText().toString(), i);
            }
        });
    }
    return builder.create();
}

public static void showHelp(Context context, int title_id, int body_id) {
    AlertDialog.Builder ad = new AlertDialog.Builder(context);
    ad.setTitle(title_id);
    ad.setMessage(body_id);
    ad.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
        }
    });
    ad.show();
    return;
}

private void initView() {
    View backImageView = findViewByResName("backImageView");
    backImageView.setTag(android.R.string.cancel);
    backImageView.setOnClickListener(this);
    View okImageView = findViewByResName("okImageView");
    okImageView.setTag(android.R.string.ok);
    okImageView.setOnClickListener(this);
    gridViewAdapter = new PlatformGridViewAdapter(activity);
    gridViewAdapter.setCustomerLogos(customerLogos);
    GridView gridView = (GridView) findViewByResName("gridView");
    gridView.setAdapter(gridViewAdapter);
    new AsyncTask<Void, Void, Platform[]>() {

        @Override
        protected Platform[] doInBackground(Void... params) {
            return ShareSDK.getPlatformList();
        }

        @Override
        protected void onPostExecute(Platform[] platforms) {
            gridViewAdapter.setData(platforms, hiddenPlatforms);
        }
    }.execute();
}

public static int restLoginErrorToMsgId(JSONObject errorObject) {
    // Default to generic error message
    int errorMsgId = org.wordpress.android.R.string.nux_cannot_log_in;
    // Map REST errors to local error codes
    if (errorObject != null) {
        try {
            String error = errorObject.optString("error", "");
            String errorDescription = errorObject.getString("error_description");
            if (error.equals("invalid_request")) {
                if (errorDescription.contains("Incorrect username or password.")) {
                    errorMsgId = org.wordpress.android.R.string.username_or_password_incorrect;
                }
            } else if (error.equals("needs_2fa")) {
                errorMsgId = org.wordpress.android.R.string.account_two_step_auth_enabled;
            } else if (error.equals("invalid_otp")) {
                errorMsgId = org.wordpress.android.R.string.invalid_verification_code;
            }
        } catch (JSONException e) {
            AppLog.e(T.NUX, e);
        }
    }
    return errorMsgId;
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    setStyle(SherlockDialogFragment.STYLE_NORMAL, R.style.Theme_Sherlock_Light_Dialog);
    AlertDialog dialog = null;
    if (hasNegativeButton) {
        dialog = new AlertDialog.Builder(getActivity()).setTitle(mTitle).setMessage(mBody).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int whichButton) {
                if (mListener != null) {
                    mListener.onPositiveButtonSelected(getTag());
                }
                dialog.dismiss();
            }
        }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                if (mListener != null) {
                    mListener.onNegativeButtonSelected(getTag());
                }
                dialog.dismiss();
            }
        }).create();
    } else {
        dialog = new AlertDialog.Builder(getActivity()).setTitle(mTitle).setMessage(mBody).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int whichButton) {
                if (mListener != null) {
                    mListener.onPositiveButtonSelected(getTag());
                }
                dialog.dismiss();
            }
        }).create();
    }
    return dialog;
}

@Override
public void onPermissionsDenied(int requestCode, List<String> perms) {
    if (TextUtils.isEmpty(getRationale4NeverAskAgain())) {
        throw new IllegalArgumentException("Rationale can not be empty .");
    }
    FcPermissions.checkDeniedPermissionsNeverAskAgain(this, getRationale4NeverAskAgain(), R.string.setting, android.R.string.cancel, mOnClickListener, perms);
    onPermissionDenied(requestCode, perms);
}

/*
     * {@inheritDoc}
     */
@Override
protected Dialog onCreateDialog(int id) {
    final AlertDialog.Builder builder = new AlertDialog.Builder(this);
    String message = getIntent().getStringExtra(MESSAGE);
    if (message == null)
        message = getString(android.R.string.cancel) + "?";
    builder.setTitle(R.string.app_name).setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
            finish();
        }
    }).setPositiveButton(android.R.string.yes, new OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
            try {
                stopService(new Intent(getApplicationContext(), Class.forName(getIntent().getStringExtra(SERVICE_TO_TERMINATE))));
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            finish();
        }
    }).setMessage(message);
    return builder.create();
}

@Override
public Dialog onCreateDialog(final Bundle savedInstanceState) {
    final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle(android.R.string.dialog_alert_title);
    builder.setMessage(R.string.sensitive_content_warning);
    builder.setPositiveButton(android.R.string.ok, this);
    builder.setNegativeButton(android.R.string.cancel, null);
    return builder.create();
}

/**
	 * @return the fileStorageProvider
	 */
public FileStorageProvider getFileStorageProvider() {
    if (fileStorageProvider == null) {
        // Check if we can access read/write to the Sapelli folder (created on the SD card or internal mass storage if there is no physical SD card):
        try {
            fileStorageProvider = getCollectorApp().getFileStorageProvider();
        } catch (FileStorageRemovedException e) {
            Log.e(getClass().getSimpleName(), "Error getting fileStorageProvider", e);
            final Runnable useAlternativeStorage = new Runnable() {

                @Override
                public void run() {
                    getPreferences().clearSapelliFolder();
                }
            };
            showDialog(getString(R.string.app_name), getString(R.string.unavailableStorageAccess), R.drawable.sapelli_logo, R.string.useAlternativeStorage, useAlternativeStorage, true, R.string.insertSDcard, null, true);
        } catch (FileStorageUnavailableException e) {
            Log.e(getClass().getSimpleName(), "Error getting fileStorageProvider", e);
            showErrorDialog(getString(R.string.app_name) + " " + getString(R.string.needsStorageAccess), true);
        }
    }
    return fileStorageProvider;
}

@Override
protected void onClick() {
    super.onClick();
    AlertDialog.Builder alertDialog;
    switch(getKey()) {
        case "credits":
            alertDialog = new AlertDialog.Builder(activity);
            alertDialog.setTitle("Credits");
            WebView wv = new WebView(activity);
            wv.loadUrl("file:///android_asset/wamod_credits.html");
            wv.setWebViewClient(new WebViewClient() {

                @Override
                public boolean shouldOverrideUrlLoading(WebView view, String url) {
                    view.loadUrl(url);
                    return true;
                }
            });
            alertDialog.setView(wv);
            alertDialog.setNegativeButton(activity.getResources().getString(android.R.string.ok), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int id) {
                    dialog.dismiss();
                }
            });
            alertDialog.show();
            break;
        case "conversation_style_entry_config":
            Intent intent = new Intent(App.getContext(), ConfigurationActivity.class);
            activity.startActivity(intent);
            break;
        case "checkforupdates":
            new CheckIn().execute(activity);
            break;
        case "restoredefaults":
            alertDialog = new AlertDialog.Builder(activity);
            alertDialog.setTitle(activity.getResources().getString(Resources.string.wamod_settings_miscellaneous_app_restoredefaults_title));
            alertDialog.setMessage(activity.getResources().getString(Resources.string.wamod_settings_miscellaneous_app_restoredefaults_message));
            alertDialog.setPositiveButton(activity.getResources().getString(android.R.string.yes), new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int id) {
                    Utils.edit.putInt("wamodversion", 0);
                    Utils.edit.apply();
                    Utils.initWAMOD();
                    Toast.makeText(activity, activity.getResources().getString(Resources.string.wamod_restartwamod), Toast.LENGTH_LONG).show();
                }
            });
            alertDialog.setNegativeButton(activity.getResources().getString(android.R.string.no), new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int id) {
                }
            });
            alertDialog.show();
            break;
        case "wamodthemes_unlinkdevice":
            alertDialog = new AlertDialog.Builder(activity);
            alertDialog.setTitle(activity.getResources().getString(Resources.string.wamod_settings_wamodthemes_unlink_title));
            alertDialog.setMessage(activity.getResources().getString(Resources.string.wamod_settings_wamodthemes_unlink_message));
            alertDialog.setPositiveButton(activity.getResources().getString(android.R.string.yes), new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int id) {
                    UnlinkWAMODThemes async = new UnlinkWAMODThemes();
                    async.activity = activity;
                    async.execute();
                }
            });
            alertDialog.setNegativeButton(activity.getResources().getString(android.R.string.no), new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int id) {
                }
            });
            alertDialog.show();
            break;
        case "wamodthemes_qts_upload":
            if (!Utils.isOfficialWAMOD()) {
                AlertDialog.Builder unofficial = new AlertDialog.Builder(activity);
                unofficial.setMessage(activity.getResources().getString(Resources.getString("wamod_qts_upload_unofficial_message")));
                unofficial.show();
                return;
            }
            AlertDialog.Builder builder2 = new AlertDialog.Builder(activity);
            builder2.setTitle(Utils.context.getResources().getString(Resources.string.wamod_qts_upload));
            builder2.setMessage(Utils.context.getResources().getString(Resources.string.wamod_qts_upload_prompt));
            builder2.setPositiveButton(activity.getResources().getString(android.R.string.ok), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    Upload qtsUpload = new Upload();
                    Upload.activity = activity;
                    qtsUpload.execute();
                }
            });
            builder2.setNegativeButton(activity.getResources().getString(android.R.string.cancel), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            });
            builder2.show();
            break;
        case "wamodthemes_qts_download":
            AlertDialog.Builder builder = new AlertDialog.Builder(activity);
            builder.setTitle(Utils.context.getResources().getString(Resources.string.wamod_qts_download));
            final EditText input = new EditText(activity);
            input.setInputType(InputType.TYPE_CLASS_TEXT);
            input.setHint(Utils.context.getResources().getString(Resources.string.wamod_qts_download_themeid));
            builder.setView(input);
            builder.setPositiveButton(activity.getResources().getString(android.R.string.ok), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    Download qtsDownload = new Download();
                    Download.activity = activity;
                    Download.themeid = input.getText().toString();
                    qtsDownload.execute();
                }
            });
            builder.setNegativeButton(activity.getResources().getString(android.R.string.cancel), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            });
            builder.show();
            break;
        case "wamod_privacy_restorecustomprivacy":
            AlertDialog.Builder dialog = new AlertDialog.Builder(activity);
            dialog.setTitle(activity.getResources().getString(Resources.getString("wamod_settings_privacy_restorecustomprivacy")));
            dialog.setMessage(activity.getResources().getString(Resources.getString("wamod_settings_privacy_restorecustomprivacy_message")));
            dialog.setPositiveButton(activity.getResources().getString(android.R.string.yes), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    SharedPreferences privacyPrefs = Utils.context.getSharedPreferences("wamod_privacy", 0);
                    SharedPreferences.Editor privacyPrefs_Edit = privacyPrefs.edit();
                    boolean general_freezelastseen = privacyPrefs.getBoolean("general_freezelastseen", false);
                    boolean general_alwaysonline = privacyPrefs.getBoolean("general_alwaysonline", false);
                    boolean general_reportreceived = privacyPrefs.getBoolean("general_reportreceived", true);
                    boolean general_reportread = privacyPrefs.getBoolean("general_reportread", true);
                    boolean general_reporttyping = privacyPrefs.getBoolean("general_reporttyping", true);
                    privacyPrefs_Edit.clear();
                    privacyPrefs_Edit.putBoolean("general_freezelastseen", general_freezelastseen);
                    privacyPrefs_Edit.putBoolean("general_alwaysonline", general_alwaysonline);
                    privacyPrefs_Edit.putBoolean("general_reportreceived", general_reportreceived);
                    privacyPrefs_Edit.putBoolean("general_reportread", general_reportread);
                    privacyPrefs_Edit.putBoolean("general_reporttyping", general_reporttyping);
                    privacyPrefs_Edit.apply();
                }
            });
            dialog.setNegativeButton(activity.getResources().getString(android.R.string.no), null);
            Utils.tintAndShowDialog(dialog);
            break;
        case "wamod_privacy_restoredefaultprivacy":
            AlertDialog.Builder dialog2 = new AlertDialog.Builder(activity);
            dialog2.setTitle(activity.getResources().getString(Resources.getString("wamod_settings_privacy_restoredefaultprivacy")));
            dialog2.setMessage(activity.getResources().getString(Resources.getString("wamod_settings_privacy_restoredefaultprivacy_message")));
            dialog2.setPositiveButton(activity.getResources().getString(android.R.string.yes), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    SharedPreferences privacyPrefs2 = Utils.context.getSharedPreferences("wamod_privacy", 0);
                    SharedPreferences.Editor privacyPrefs_Edit2 = privacyPrefs2.edit();
                    privacyPrefs_Edit2.clear();
                    privacyPrefs_Edit2.putBoolean("general_freezelastseen", false);
                    privacyPrefs_Edit2.putBoolean("general_alwaysonline", false);
                    privacyPrefs_Edit2.putBoolean("general_reportreceived", true);
                    privacyPrefs_Edit2.putBoolean("general_reportread", true);
                    privacyPrefs_Edit2.putBoolean("general_reporttyping", true);
                    privacyPrefs_Edit2.apply();
                }
            });
            dialog2.setNegativeButton(activity.getResources().getString(android.R.string.no), null);
            Utils.tintAndShowDialog(dialog2);
            break;
        case "debugging_getfirebasetoken":
            String token = com.google.firebase.iid.FirebaseInstanceId.getInstance().getToken();
            Utils.copyToClipboard(token);
            Toast.makeText(activity, "Token copied to clipboard: " + token, Toast.LENGTH_LONG).show();
            break;
        case "debugging_switchaccount0":
            AccountsManager accountsManager = App.getAccountsManager();
            ArrayList<AccountsManager.Account> accounts = accountsManager.getAccounts();
            App.getAccountsManager().switchToAccount(accounts.get(0));
            break;
        case "debugging_showaccounts":
            App.getAccountsManager().showAccountsList(activity);
            break;
    }
}

@OnClick({ R.id.player_count_value, R.id.player_count_description })
public void changePlayerCount() {
    View numberPickerLayout = getLayoutInflater().inflate(R.layout.dialog_number_picker, null);
    final NumberPicker numberPicker = (NumberPicker) numberPickerLayout.findViewById(R.id.number_picker);
    numberPicker.setValue(Integer.valueOf(playerCountValue.getText().toString()));
    numberPicker.setMinValue(2);
    numberPicker.setMaxValue(100);
    numberPicker.setWrapSelectorWheel(false);
    numberPicker.setDescendantFocusability(NumberPicker.FOCUS_BLOCK_DESCENDANTS);
    final TextView playersTextView = (TextView) numberPickerLayout.findViewById(R.id.number_picker_text);
    playersTextView.setText(R.string.activity_host_game_players_count_players);
    new AlertDialog.Builder(this).setView(numberPickerLayout).setTitle(R.string.activity_host_game_players_count_title).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            playerCountValue.setText(String.valueOf(numberPicker.getValue()));
        }
    }).setNegativeButton(android.R.string.cancel, null).show();
}

@Override
public void onFilePicked(String path, String mode) {
    Log.i(TAG, "selected dir path = " + path);
    mContext = this;
    if ("restore".equals(mode)) {
        final File file = new File(path);
        final AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
        alertDialogBuilder.setTitle(file.getName());
        alertDialogBuilder.setMessage(R.string.do_restore);
        alertDialogBuilder.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int which) {
                SystemCommand.restore_rom(file.getPath());
                SystemCommand.reboot("recovery");
            }
        });
        alertDialogBuilder.setNegativeButton(android.R.string.no, null);
        alertDialogBuilder.create().show();
    } else if ("manage".equals(mode)) {
        final AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
        final CharSequence[] actions = { getText(R.string.backup_manage_rename), getText(R.string.backup_manage_delete) };
        mSelectedDir = new File(path);
        alertDialogBuilder.setTitle(mSelectedDir.getName());
        alertDialogBuilder.setItems(actions, mOnClickListener);
        alertDialogBuilder.create().show();
    }
}

@Override
protected Dialog onCreateDialog(int id) {
    switch(id) {
        case DELETE_DIALOG_ID:
            return new AlertDialog.Builder(this).setMessage(R.string.confirm_delete).setPositiveButton(android.R.string.yes, m_deleteListener).setNegativeButton(android.R.string.no, m_deleteListener).setCancelable(false).create();
    }
    return super.onCreateDialog(id);
}

@Test
public void testCheckInput() throws Exception {
    Activity activity = mActivityRule.getActivity();
    solo.unlockScreen();
    // just click it
    solo.clickOnButton(0);
    assertTrue(solo.waitForDialogToOpen());
    assertTrue(solo.searchText(activity.getString(R.string.msg_no_name)));
    solo.clickOnText(activity.getString(android.R.string.ok));
    // clear everything
    solo.clearEditText(0);
    solo.clearEditText(1);
    solo.clickOnButton(0);
    assertTrue(solo.waitForDialogToOpen());
    assertTrue(solo.searchText(activity.getString(R.string.msg_no_name)));
    solo.clickOnText(activity.getString(android.R.string.ok));
    // this test will work on release build only
    if (!BuildConfig.DEBUG) {
        // fill the name
        solo.enterText(0, "Instrumentation Test");
        solo.clickOnButton(0);
        assertTrue(solo.waitForDialogToOpen());
        assertTrue(solo.searchText(activity.getString(R.string.msg_invalid_number)));
        solo.clickOnText(activity.getString(android.R.string.ok));
    }
}

/**
	 * Displays an input dialog
	 * 
	 * @param title					title to display
	 * @param body					message to show
	 * @param input					input to use
	 * @param iconId				icon to use, may be {@code null}
	 * @param positiveListener		listener for positive button
	 * @param negativeListener		listener for negative button
	 */
public static void showInputDialog(Context context, CharSequence title, CharSequence body, EditText input, Integer iconId, DialogInterface.OnClickListener positiveListener, DialogInterface.OnClickListener negativeListener) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setTitle(title);
    if (iconId != null) {
        builder.setIcon(iconId);
    }
    if (body != null) {
        builder.setMessage(body);
    }
    builder.setView(input);
    builder.setPositiveButton(context.getText(android.R.string.ok), positiveListener);
    builder.setNegativeButton(context.getText(android.R.string.cancel), negativeListener);
    AlertDialog ad = builder.create();
    ad.show();
}

public AlertDialog getPairingDialog(String message) {
    TextView title = (TextView) activity.getLayoutInflater().inflate(android.R.layout.simple_list_item_1, null);
    title.setText(message);
    final EditText input = new EditText(activity);
    input.setInputType(InputType.TYPE_CLASS_NUMBER);
    return new AlertDialog.Builder(activity).setCustomTitle(title).setView(input).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
            String value = input.getText().toString().trim();
            for (DeviceService service : device.getServices()) service.sendPairingKey(value);
        }
    }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
            dialog.cancel();
        // pickerDialog.dismiss();
        }
    }).create();
}

@NonNull
@Override
public Dialog onCreateDialog(final Bundle savedInstanceState) {
    final Context wrapped = ThemeUtils.getDialogThemedContext(getActivity());
    final AlertDialog.Builder builder = new AlertDialog.Builder(wrapped);
    builder.setTitle(android.R.string.dialog_alert_title);
    builder.setMessage(R.string.sensitive_content_warning);
    builder.setPositiveButton(android.R.string.ok, this);
    builder.setNegativeButton(android.R.string.cancel, null);
    return builder.create();
}

@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    if (position == 0) {
        final SpannableString message = new SpannableString(getText(R.string.open_source_info_content));
        Linkify.addLinks(message, Linkify.WEB_URLS);
        AlertDialog dialog = new AlertDialog.Builder(this).setTitle(R.string.open_source_info).setMessage(message).setPositiveButton(android.R.string.ok, null).show();
        // Make the link clickable
        ((TextView) dialog.findViewById(android.R.id.message)).setMovementMethod(LinkMovementMethod.getInstance());
    } else if (position == 1) {
        WebView webView = new WebView(this);
        webView.loadUrl("file:///android_asset/usage_policy.html");
        new AlertDialog.Builder(this).setTitle(R.string.usage_policy).setView(webView).setPositiveButton(android.R.string.ok, null).show();
    } else if (position == 2) {
        WebView webView = new WebView(this);
        webView.loadUrl("file:///android_asset/used_licenses.html");
        new AlertDialog.Builder(this).setTitle(R.string.open_source_licenses).setView(webView).setPositiveButton(android.R.string.ok, null).show();
    }
}

public static Dialog createDownloadDialog(Context context, @StringRes int titleResource, @StringRes int messageResource, DialogInterface.OnClickListener listener) {
    AlertDialog.Builder alertDialog = new AlertDialog.Builder(context).setTitle(context.getString(titleResource)).setMessage(context.getString(messageResource)).setIcon(R.drawable.ic_file_download_black_24dp).setNegativeButton(context.getString(R.string.no), listener).setPositiveButton(context.getString(R.string.yes), listener);
    return alertDialog.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final Context context = getActivity();
    final String note = getArguments().getString(BUNDLE_KEY_NOTE);
    setCancelable(true);
    return new AlertDialog.Builder(context).setIconAttribute(android.R.attr.alertDialogIcon).setTitle(android.R.string.dialog_alert_title).setMessage(note).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            final Callback a = (Callback) getActivity();
            a.onNoteDialogComplete();
            dismiss();
        }
    }).setNegativeButton(context.getString(android.R.string.cancel), new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.cancel();
        }
    }).create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final Context context = getActivity();
    final String note = getArguments().getString(BUNDLE_KEY_NOTE);
    setCancelable(true);
    return new AlertDialog.Builder(context).setIconAttribute(android.R.attr.alertDialogIcon).setTitle(android.R.string.dialog_alert_title).setMessage(note).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            final Callback a = (Callback) getActivity();
            a.onNoteDialogComplete();
            dismiss();
        }
    }).setNegativeButton(context.getString(android.R.string.cancel), new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.cancel();
        }
    }).create();
}

public AlertDialog getPairingDialog(String message) {
    TextView title = (TextView) activity.getLayoutInflater().inflate(android.R.layout.simple_list_item_1, null);
    title.setText(message);
    final EditText input = new EditText(activity);
    input.setInputType(InputType.TYPE_CLASS_NUMBER);
    return new AlertDialog.Builder(activity).setCustomTitle(title).setView(input).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
            String value = input.getText().toString().trim();
            for (DeviceService service : device.getServices()) service.sendPairingKey(value);
        }
    }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
            dialog.cancel();
        // pickerDialog.dismiss();
        }
    }).create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle(R.string.dialog_title_what);
    builder.setMessage(R.string.dialog_content_what);
    builder.setNeutralButton(android.R.string.ok, new OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dismiss();
        }
    });
    return builder.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getActivity());
    View rootView = inflater.inflate(R.layout.licenses, null);
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setView(rootView).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
        }
    });
    // Create the AlertDialog object and return it
    return builder.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater dialogInflater = getActivity().getLayoutInflater();
    View openSourceLicensesView = dialogInflater.inflate(R.layout.fragment_open_source_licenses, null);
    AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(getActivity());
    dialogBuilder.setView(openSourceLicensesView).setNeutralButton(android.R.string.ok, null);
    return dialogBuilder.create();
}

@Override
public void onCreate(Bundle state) {
    super.onCreate(state);
    setContentView(R.layout.main);
    getListView().setOnItemClickListener(this);
    final File f = new File(Environment.getExternalStorageDirectory(), "RTP_list/Standard");
    if (!f.isDirectory()) {
        DialogInterface.OnClickListener cl = new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                if (which == DialogInterface.BUTTON_POSITIVE) {
                    startService(new Intent(ServiceFileTask.ACTION_PUSH_TASK).putExtra("queueid", -1).putExtra("task", new TaskDecompressZip(f, R.raw.standard)));
                }
            }
        };
        new AlertDialog.Builder(this).setMessage("!stub! extract rtp confirm").setNegativeButton(android.R.string.no, cl).setPositiveButton(android.R.string.yes, cl).show();
    }
}

public static int getConnectionStateSummary(int connectionState) {
    switch(connectionState) {
        case BluetoothProfile.STATE_CONNECTED:
            return R.string.bluetooth_connected;
        case BluetoothProfile.STATE_CONNECTING:
            return R.string.bluetooth_connecting;
        case BluetoothProfile.STATE_DISCONNECTED:
            return R.string.bluetooth_disconnected;
        case BluetoothProfile.STATE_DISCONNECTING:
            return R.string.bluetooth_disconnecting;
        default:
            return 0;
    }
}

public static int getConnectionStateSummary(int connectionState) {
    switch(connectionState) {
        case BluetoothProfile.STATE_CONNECTED:
            return R.string.bluetooth_connected;
        case BluetoothProfile.STATE_CONNECTING:
            return R.string.bluetooth_connecting;
        case BluetoothProfile.STATE_DISCONNECTED:
            return R.string.bluetooth_disconnected;
        case BluetoothProfile.STATE_DISCONNECTING:
            return R.string.bluetooth_disconnecting;
        default:
            return 0;
    }
}

public static void newRequestErrorDialog(Context context, String errorMessage) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setNeutralButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
        }
    }).setTitle(R.string.download_error_request_error).setMessage(context.getString(R.string.download_request_error_dialog_message_prefix) + errorMessage);
    builder.create().show();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = getActivity().getLayoutInflater();
    View view = inflater.inflate(R.layout.dialog_contact_our, null);
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()).setView(view).setNegativeButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
        }
    });
    return builder.create();
}

public void onClick(DialogInterface dialog, int which) {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(c);
    try {
        FileWriter fw = new FileWriter(file);
        PrintWriter pw = new PrintWriter(fw);
        Map<String, ?> prefsMap = prefs.getAll();
        for (Map.Entry<String, ?> entry : prefsMap.entrySet()) {
            pw.println(entry.getKey() + "::" + entry.getValue().toString());
        }
        pw.close();
        fw.close();
        ToastUtils.showToastInUiThread(c, MainApp.sResources.getString(R.string.exported));
    } catch (FileNotFoundException e) {
        ToastUtils.showToastInUiThread(c, MainApp.sResources.getString(R.string.filenotfound) + " " + file);
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void run() {
    new AlertDialog.Builder(activity).setTitle(R.string.DLG_question_title).setMessage(text).setView(view).setIcon(android.R.drawable.ic_dialog_alert).setPositiveButton(android.R.string.ok, okListener).setNegativeButton(android.R.string.cancel, cancelListener).show().setOwnerActivity(activity);
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    WebView webView = new WebView(getActivity());
    webView.loadUrl("file:///android_asset/licenses.html");
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.about_licenses).setView(webView).setPositiveButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
            dialog.dismiss();
        }
    }).create();
}

public static AlertDialog create(final Activity activity) {
    final AlertDialog.Builder builder = new AlertDialog.Builder(activity);
    final View layout = View.inflate(activity, R.layout.livemapinfo, null);
    builder.setView(layout);
    final int showCount = Settings.getLiveMapHintShowCount();
    Settings.setLiveMapHintShowCount(showCount + 1);
    builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(final DialogInterface dialog, final int which) {
            dialog.dismiss();
        }
    });
    return builder.create();
}

public void onClickImgMakeDonate(View v) {
    AlertDialog.Builder dlgAlert = new AlertDialog.Builder(this);
    dlgAlert.setMessage(getResources().getString(R.string.donate_info));
    dlgAlert.setTitle(getResources().getString(R.string.app_name));
    dlgAlert.setPositiveButton(getResources().getString(android.R.string.ok), null);
    dlgAlert.setCancelable(true);
    dlgAlert.create().show();
    Intent intent = new Intent(this, DonationsActivity.class);
    this.startActivity(intent);
}

public AlertDialog createLoadErrorDialog() {
    AlertDialog dialog = new AlertDialog.Builder(viewer).setIcon(android.R.drawable.ic_menu_close_clear_cancel).setTitle(R.string.dialog_load_error_title).setMessage(R.string.dialog_load_error_text).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
        }
    }).create();
    return dialog;
}

public static void newRequestErrorDialog(Context context, String errorMessage) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setNeutralButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
        }
    }).setTitle(R.string.download_error_request_error).setMessage(context.getString(R.string.download_request_error_dialog_message_prefix) + errorMessage);
    builder.create().show();
}

public static Dialog createNetworkProblemDialog(Context context, OnClickListener onClickListener) {
    return new AlertDialog.Builder(context).setIcon(android.R.drawable.ic_dialog_alert).setTitle("Ett fel inträffade").setMessage("Kunde inte ansluta till servern. Försök igen, eller Cancel för att gå tillbaka till föregående vy.").setPositiveButton(R.string.retry, onClickListener).setNegativeButton(android.R.string.cancel, onClickListener).create();
}

public static void alert(String title, Object value, Context ctx) {
    String text = value != null ? value.toString() : "null";
    new AlertDialog.Builder(ctx).setTitle(title).setMessage(text).setCancelable(false).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
        }
    }).setIcon(android.R.drawable.ic_dialog_alert).show();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.welcome_dialog_title).setMessage(R.string.welcome_dialog_content).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int whichButton) {
            ProfileEditFragment profileEditFragment = new ProfileEditFragment();
            profileEditFragment.setProfile(null, profileManagerFragment);
            profileEditFragment.setCancelable(false);
            profileEditFragment.show(getActivity().getSupportFragmentManager(), "profileEditor");
        }
    }).create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final SpannableString s = new SpannableString(getActivity().getString(R.string.about_text));
    Linkify.addLinks(s, Linkify.ALL);
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setMessage(s).setTitle(getActivity().getString(R.string.about_title)).setPositiveButton(getActivity().getString(android.R.string.ok), new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
        }
    });
    return builder.create();
}

public static void Show(int EerrorRes, Activity activity) {
    AlertDialog.Builder builder = new AlertDialog.Builder(activity);
    builder.setMessage(EerrorRes);
    builder.setTitle(R.string.sError);
    builder.setNeutralButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
            dialog.cancel();
        }
    });
    AlertDialog alert = builder.create();
    alert.show();
}

public void showErrorDialog() {
    AlertDialog.Builder builder = new AlertDialog.Builder(ctx);
    builder.setTitle(R.string.error_dialog_default_title);
    builder.setMessage(errorMessageId);
    builder.setIcon(android.R.drawable.ic_dialog_alert);
    builder.setCancelable(false);
    builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
        }
    });
    builder.create().show();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = ((LayoutInflater) getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE));
    View v = inflater.inflate(R.layout.fragment_helpdialog, null);
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.dlg_help_title).setView(v).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
        }
    }).create();
}

public static void showMessage(Activity owningActivity, int titleRessourceId, int messageRessourceId, String messageId) {
    File f = new File(owningActivity.getFilesDir(), "seen_" + messageId);
    try {
        // should be shown
        if (f.createNewFile())
            new AlertDialog.Builder(owningActivity).setIcon(android.R.drawable.ic_dialog_info).setMessage(messageRessourceId).setTitle(titleRessourceId).setPositiveButton(android.R.string.ok, null).create().show();
    } catch (IOException e) {
    }
}

public void sendBugReport(final Throwable e) {
    AlertDialog dialog = new AlertDialog.Builder(parent).setPositiveButton(android.R.string.yes, new OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            ArrayList<Throwable> al = new ArrayList<Throwable>();
            al.add(e);
            Intent intent = send(BugReportExceptionHandler.buildStackTraceMessage(al));
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            parent.startActivity(intent);
        }
    }).setNegativeButton(android.R.string.no, null).create();
    dialog.setMessage(parent.getString(R.string.bug_report_ask_user));
    dialog.setTitle(R.string.bug_report_ask_user_title);
    dialog.setIcon(android.R.drawable.ic_dialog_alert);
    dialog.show();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final Activity activity = getActivity();
    return new AlertDialog.Builder(activity).setMessage(getArguments().getString(ARG_MESSAGE)).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            activity.finish();
        }
    }).create();
}

public static int getConnectionStateSummary(int connectionState) {
    switch(connectionState) {
        case BluetoothProfile.STATE_CONNECTED:
            return R.string.bluetooth_connected;
        case BluetoothProfile.STATE_CONNECTING:
            return R.string.bluetooth_connecting;
        case BluetoothProfile.STATE_DISCONNECTED:
            return R.string.bluetooth_disconnected;
        case BluetoothProfile.STATE_DISCONNECTING:
            return R.string.bluetooth_disconnecting;
        default:
            return 0;
    }
}

/**
	 *  显示æ??醒dialog
	 * @param pTitle
	 * @param pMessage
	 * @param pOkClickListener
	 * @param pCancelClickListener
	 * @param pDismissListener
	 * @return
	 */
protected AlertDialog showAlertDialog(int pTitle, int pMessage, DialogInterface.OnClickListener pOkClickListener, DialogInterface.OnClickListener pCancelClickListener, DialogInterface.OnDismissListener pDismissListener) {
    mAlertDialog = new AlertDialog.Builder(this).setTitle(pTitle).setMessage(pMessage).setPositiveButton(android.R.string.ok, pOkClickListener).setNegativeButton(android.R.string.cancel, pCancelClickListener).show();
    if (pDismissListener != null) {
        mAlertDialog.setOnDismissListener(pDismissListener);
    }
    return mAlertDialog;
}

@Override
public void onClick(View v) {
    String link = website.getText().toString();
    if (link.equals("") || link.contains(" ")) {
        Toast.makeText(activity, org.qaoverflow.q2android.R.string.missing_website, Toast.LENGTH_LONG).show();
        return;
    }
    link = Q2AWebsite.sanitizeWebsite(link);
    website.setText(link);
    link = link + "xml-rpc";
    if (!Q2AWebsite.isValidWebsite(link)) {
        Toast.makeText(activity, org.qaoverflow.q2android.R.string.missing_website, Toast.LENGTH_LONG).show();
        return;
    }
    Uri url = Uri.parse(link);
    Intent i = new Intent(Intent.ACTION_VIEW, url);
    activity.startActivity(i);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Bundle bundle = getIntent().getExtras();
    if (bundle != null && bundle.containsKey(ScheduledReceiver.SCHEDULE_TYPE)) {
        action = bundle.getInt(ScheduledReceiver.SCHEDULE_TYPE, 0);
        if (ScheduledReceiver.SCHEDULE_RATING == action || ScheduledReceiver.SCHEDULE_ACCOUNT == action) {
            String title = bundle.getString("title");
            String msg = bundle.getString("message");
            String okStr = bundle.getString("ok");
            String cancelStr = bundle.getString("cancel");
            AlertDialogFragment fragment = AlertDialogFragment.getInstance(title, msg, TextUtils.isEmpty(okStr) ? getString(android.R.string.ok) : okStr, TextUtils.isEmpty(cancelStr) ? getString(android.R.string.cancel) : cancelStr);
            fragment.show(getSupportFragmentManager(), ScheduledReceiver.SCHEDULE_TYPE + action);
        } else {
            AlertDialogFragment fragment = AlertDialogFragment.getInstance("Unknow type", "Please set a correct type!", getString(android.R.string.ok), getString(android.R.string.cancel));
            fragment.show(getSupportFragmentManager(), ScheduledReceiver.SCHEDULE_TYPE + action);
        }
    } else {
        finish();
    }
}

/**
     * Creates a dialog to display in case of network problems.
     * @param activity the activity
     * @param onClickListener the on click listener for the retry button  
     * @return a dialog
     */
public static AlertDialog createNetworkProblemDialog(Activity activity, OnClickListener onClickListener) {
    return new AlertDialog.Builder(activity).setTitle(activity.getText(R.string.attention_label)).setMessage(activity.getText(R.string.network_problem_message)).setPositiveButton(activity.getText(R.string.retry), onClickListener).setNegativeButton(activity.getText(android.R.string.cancel), null).create();
}

public static Dialog createOkDialog(final Context context, final int title, final int message) {
    final View view = LayoutInflater.from(context).inflate(R.layout.dialog_textview, null);
    final TextView textView = (TextView) view.findViewById(R.id.text);
    textView.setText(message);
    return new AlertDialog.Builder(context).setTitle(title).setCancelable(false).setPositiveButton(android.R.string.ok, null).setView(view).create();
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setTitle(getResources().getString(R.string.database_title) + " " + dbManager.getCurrentNeo4jDatabaseName());
    relationshipCreatePropertyButton.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            askCreateProperty();
        }
    });
    relationshipDeleteButton.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            confirmDeletionOfRelationship();
        }
    });
    Formatter formatter = new Formatter();
    formatter.format(getResources().getString(R.string.relationship_properties_text), relationshipId);
    relationshipPropertiesTitle.setText(formatter.toString());
    formatter.close();
}

@Override
public boolean onPreferenceClick(Preference preference) {
    final ViewGroup numberPickerView = (ViewGroup) LayoutInflater.from(mContext).inflate(R.layout.grid_number_picker, null);
    int minValue = 4, maxValue = 15;
    final NumberPicker npvc = (NumberPicker) numberPickerView.findViewById(R.id.numberPickerVerticalColumn);
    npvc.setMinValue(minValue);
    npvc.setMaxValue(maxValue);
    npvc.setValue(Integer.parseInt(sharedPrefs.getString("xcounthomescreen", "" + 4)));
    final NumberPicker npvr = (NumberPicker) numberPickerView.findViewById(R.id.numberPickerVerticalRow);
    npvr.setMinValue(minValue);
    npvr.setMaxValue(maxValue);
    npvr.setValue(Integer.parseInt(sharedPrefs.getString("ycounthomescreen", "" + 4)));
    final MaterialDialog numberPickerDialog = new MaterialDialog.Builder(mActivity).title(R.string.pref_grid_size_vert_summary).customView(numberPickerView, true).cancelable(false).theme(Theme.DARK).positiveText(android.R.string.ok).callback(new MaterialDialog.ButtonCallback() {

        @Override
        public void onPositive(MaterialDialog materialDialog) {
            // due to legacy reasons we need to save them as strings... -.-
            SharedPreferences.Editor editor = sharedPrefs.edit();
            editor.putString("ycounthomescreen", "" + npvr.getValue()).putString("xcounthomescreen", "" + npvc.getValue()).apply();
            materialDialog.dismiss();
        }
    }).build();
    numberPickerView.findViewById(R.id.horizontallayout).setVisibility(View.GONE);
    numberPickerDialog.show();
    return true;
}

public static boolean finishWhenExpired(final Activity pActivity, final GregorianCalendar pExpirationDate, final int pTitleResourceID, final int pMessageResourceID, final Intent pOkIntent, final Intent pCancelIntent) {
    final SharedPreferences spref = SimplePreferences.getInstance(pActivity);
    final long now = System.currentTimeMillis();
    final long lastuse = Math.max(now, spref.getLong(PREFERENCES_BETAUTILS_ID, -1));
    spref.edit().putLong(PREFERENCES_BETAUTILS_ID, lastuse).commit();
    final GregorianCalendar lastuseDate = new GregorianCalendar();
    lastuseDate.setTimeInMillis(lastuse);
    if (lastuseDate.after(pExpirationDate)) {
        final Builder alertDialogBuilder = new AlertDialog.Builder(pActivity).setTitle(pTitleResourceID).setIcon(android.R.drawable.ic_dialog_alert).setMessage(pMessageResourceID);
        alertDialogBuilder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pOkIntent != null) {
                    pActivity.startActivity(pOkIntent);
                }
                pActivity.finish();
            }
        });
        alertDialogBuilder.setNegativeButton(android.R.string.cancel, new OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pCancelIntent != null) {
                    pActivity.startActivity(pCancelIntent);
                }
                pActivity.finish();
            }
        }).create().show();
        return true;
    } else {
        return false;
    }
}

public static boolean finishWhenExpired(final Activity pActivity, final GregorianCalendar pExpirationDate, final int pTitleResourceID, final int pMessageResourceID, final Intent pOkIntent, final Intent pCancelIntent) {
    final SharedPreferences spref = SimplePreferences.getInstance(pActivity);
    final long now = System.currentTimeMillis();
    final long lastuse = Math.max(now, spref.getLong(PREFERENCES_BETAUTILS_ID, -1));
    spref.edit().putLong(PREFERENCES_BETAUTILS_ID, lastuse).commit();
    final GregorianCalendar lastuseDate = new GregorianCalendar();
    lastuseDate.setTimeInMillis(lastuse);
    if (lastuseDate.after(pExpirationDate)) {
        final Builder alertDialogBuilder = new AlertDialog.Builder(pActivity).setTitle(pTitleResourceID).setIcon(android.R.drawable.ic_dialog_alert).setMessage(pMessageResourceID);
        alertDialogBuilder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pOkIntent != null) {
                    pActivity.startActivity(pOkIntent);
                }
                pActivity.finish();
            }
        });
        alertDialogBuilder.setNegativeButton(android.R.string.cancel, new OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pCancelIntent != null) {
                    pActivity.startActivity(pCancelIntent);
                }
                pActivity.finish();
            }
        }).create().show();
        return true;
    } else {
        return false;
    }
}

public static boolean finishWhenExpired(final Activity pActivity, final GregorianCalendar pExpirationDate, final int pTitleResourceID, final int pMessageResourceID, final Intent pOkIntent, final Intent pCancelIntent) {
    final SharedPreferences spref = SimplePreferences.getInstance(pActivity);
    final long now = System.currentTimeMillis();
    final long lastuse = Math.max(now, spref.getLong(PREFERENCES_BETAUTILS_ID, -1));
    spref.edit().putLong(PREFERENCES_BETAUTILS_ID, lastuse).commit();
    final GregorianCalendar lastuseDate = new GregorianCalendar();
    lastuseDate.setTimeInMillis(lastuse);
    if (lastuseDate.after(pExpirationDate)) {
        final Builder alertDialogBuilder = new AlertDialog.Builder(pActivity).setTitle(pTitleResourceID).setIcon(R.drawable.ic_dialog_alert).setMessage(pMessageResourceID);
        alertDialogBuilder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pOkIntent != null) {
                    pActivity.startActivity(pOkIntent);
                }
                pActivity.finish();
            }
        });
        alertDialogBuilder.setNegativeButton(android.R.string.cancel, new OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pCancelIntent != null) {
                    pActivity.startActivity(pCancelIntent);
                }
                pActivity.finish();
            }
        }).create().show();
        return true;
    } else {
        return false;
    }
}

public static boolean finishWhenExpired(final Activity pActivity, final GregorianCalendar pExpirationDate, final int pTitleResourceID, final int pMessageResourceID, final Intent pOkIntent, final Intent pCancelIntent) {
    final SharedPreferences spref = SimplePreferences.getInstance(pActivity);
    final long now = System.currentTimeMillis();
    final long lastuse = Math.max(now, spref.getLong(PREFERENCES_BETAUTILS_ID, -1));
    spref.edit().putLong(PREFERENCES_BETAUTILS_ID, lastuse).commit();
    final GregorianCalendar lastuseDate = new GregorianCalendar();
    lastuseDate.setTimeInMillis(lastuse);
    if (lastuseDate.after(pExpirationDate)) {
        final Builder alertDialogBuilder = new AlertDialog.Builder(pActivity).setTitle(pTitleResourceID).setIcon(android.R.drawable.ic_dialog_alert).setMessage(pMessageResourceID);
        alertDialogBuilder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pOkIntent != null) {
                    pActivity.startActivity(pOkIntent);
                }
                pActivity.finish();
            }
        });
        alertDialogBuilder.setNegativeButton(android.R.string.cancel, new OnClickListener() {

            @Override
            public void onClick(final DialogInterface pDialog, final int pWhich) {
                if (pCancelIntent != null) {
                    pActivity.startActivity(pCancelIntent);
                }
                pActivity.finish();
            }
        }).create().show();
        return true;
    } else {
        return false;
    }
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setMessage(mMsg).setTitle(mTitle).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            if (mListener != null) {
                mListener.onConfirmClicked();
            }
        }
    }).setNegativeButton(android.R.string.cancel, null);
    return builder.create();
}

private void verifyBluetooth() {
    try {
        if (!IBeaconManager.getInstanceForApplication(this).checkAvailability()) {
            final AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle("Bluetooth not enabled");
            builder.setMessage("Please enable bluetooth in settings and restart this application.");
            builder.setPositiveButton(android.R.string.ok, null);
            builder.setOnDismissListener(new DialogInterface.OnDismissListener() {

                @Override
                public void onDismiss(DialogInterface dialog) {
                    finish();
                    System.exit(0);
                }
            });
            builder.show();
        }
    } catch (RuntimeException e) {
        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Bluetooth LE not available");
        builder.setMessage("Sorry, this device does not support Bluetooth LE.");
        builder.setPositiveButton(android.R.string.ok, null);
        builder.setOnDismissListener(new DialogInterface.OnDismissListener() {

            @Override
            public void onDismiss(DialogInterface dialog) {
                finish();
                System.exit(0);
            }
        });
        builder.show();
    }
}

public void notifyCurrencyCanNotBeDeleted() {
    new MaterialDialog.Builder(getContext()).title(R.string.attention).icon(new UIHelper(getContext()).getIcon(GoogleMaterial.Icon.gmd_warning)).content(R.string.currency_can_not_deleted).positiveText(android.R.string.ok).onPositive(new MaterialDialog.SingleButtonCallback() {

        @Override
        public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
            dialog.dismiss();
        }
    }).build().show();
}

public static Dialog getDialog(final int id, String title, String message, Context context, final Listener listener) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setTitle(title);
    builder.setMessage(message);
    builder.setCancelable(true);
    builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            listener.onConfirmationDialogResponse(id, true);
        }
    });
    builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            listener.onConfirmationDialogResponse(id, false);
        }
    });
    Dialog dialog = builder.create();
    dialog.setCanceledOnTouchOutside(false);
    return dialog;
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle("title").setIcon(R.mipmap.ic_launcher).setMessage(mExample).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
            mListener.onSimpleDialogPositiveClick(SimpleDialogFragment.this);
        }
    }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int id) {
            mListener.onSimpleDialogNegativeClick(SimpleDialogFragment.this);
        }
    });
    return builder.create();
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final File databaseFile = (File) getArguments().getSerializable(KEY_DATABASE);
    final String tableName = getArguments().getString(KEY_TABLE);
    return new AlertDialog.Builder(getActivity()).setTitle(R.string.dbinspector_clear_table_confirm).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
            deleteTable(getActivity(), databaseFile, tableName);
        }
    }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int whichButton) {
            dismiss();
        }
    }).create();
}