androidx.core.app.ActivityCompat Java Examples

public void qrButtonClicked(View v){
    if (ContextCompat.checkSelfPermission(this,
            Manifest.permission.CAMERA)
            != PackageManager.PERMISSION_GRANTED) {

        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.CAMERA},
                CAMERA_REQUEST_PERMISSION);
    }else {
        if (passwordEditText.isEnabled()) {

            Intent qrIntent = new Intent(LoginActivity.this, SimpleScannerActivity.class);
            startActivityForResult(qrIntent, RESULT_QR_CODE);

        }
    }
}
 

@TargetApi(Build.VERSION_CODES.M)
void getPermission2Do(String text, int type, int operation, int option){
    String permission = operation == ActionDialog.ACTION_IMPORT ?
            Manifest.permission.READ_EXTERNAL_STORAGE :
            Manifest.permission.WRITE_EXTERNAL_STORAGE;

    if (ActivityCompat.checkSelfPermission(this, permission)
            != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, new String[]{permission},
                PERMISSION_REQUEST);
        mActionType = type;
        mText = text;
        mOperation = operation;
        mOption = option;
    }
    else {
        new ImportExportTask(this, text, Application.getInstance().getPassword(),
                type, operation, option).execute();
    }
}
 

private void refreshUI() {
    TextView enabledTextView = findViewById(R.id.enabled_textview);
    TextView notEnabledTextView = findViewById(R.id.not_enabled_textview);
    Button claimButton = findViewById(R.id.claim_button);
    TextView instructions = findViewById(R.id.instructions);

    if (GlobalPrivilegesManager.getEnabledPrivileges().size() > 0) {
        notEnabledTextView.setVisibility(View.GONE);
        claimButton.setVisibility(View.GONE);
        instructions.setVisibility(View.GONE);
        enabledTextView.setVisibility(View.VISIBLE);
        enabledTextView.setText(getEnabledText());
    } else {
        enabledTextView.setVisibility(View.GONE);
        claimButton.setVisibility(View.VISIBLE);
        instructions.setVisibility(View.VISIBLE);
        notEnabledTextView.setVisibility(View.VISIBLE);
    }
    ActivityCompat.invalidateOptionsMenu(this);
}
 

private void startScan() {

        if (!hasPermissions() || isScanning) {
            return;
        }

        isScanning = true;
        deviceList.clear();
        bluetoothDevices.clear();

        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            provisionManager.searchBleEspDevices(deviceNamePrefix, bleScanListener);
            updateProgressAndScanBtn();
        } else {
            Log.e(TAG, "Not able to start scan as Location permission is not granted.");
            Toast.makeText(BLEProvisionLanding.this, "Please give location permission to start BLE scan", Toast.LENGTH_LONG).show();
        }
    }
 

private void requestPermissionsIfNotGranted(String[] perms, int resultCode) {
    ArrayList<String> permissionsToAskFor = new ArrayList<>();
    if (perms != null) { // This is created (or not) by the child activity
        for (String permissionToHave : perms) {
            if (!checkPermission(permissionToHave)) {
                permissionsToAskFor.add(permissionToHave);
            }
        }
    }

    if (permissionsToAskFor.size() > 0) {
        for (String permission : permissionsToAskFor) {
            Log.i("[Permission] Requesting " + permission + " permission");
        }
        String[] permissions = new String[permissionsToAskFor.size()];
        permissions = permissionsToAskFor.toArray(permissions);

        KeyguardManager km = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);
        boolean locked = km.inKeyguardRestrictedInputMode();
        if (!locked) {
            // This is to workaround an infinite loop of pause/start in Activity issue
            // if incoming call ends while screen if off and locked
            ActivityCompat.requestPermissions(this, permissions, resultCode);
        }
    }
}
 

/**
 * 处理请求权限的响应
 *
 * @param requestCode  请求码
 * @param permissions  权限数组
 * @param grantResults 请求权限结果数组
 */
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    boolean isPermissions = true;
    for (int i = 0; i < permissions.length; i++) {
        if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
            isPermissions = false;
            if (!ActivityCompat.shouldShowRequestPermissionRationale(this, permissions[i])) { //用户选择了"不再询问"
                if (isToast) {
                    Toast.makeText(this, "请手动打开该应用需要的权限", Toast.LENGTH_SHORT).show();
                    isToast = false;
                }
            }
        }
    }
    isToast = true;
    if (isPermissions) {
        Log.d("onRequestPermission", "onRequestPermissionsResult: " + "允许所有权限");
        selectPicture();
    } else {
        Log.d("onRequestPermission", "onRequestPermissionsResult: " + "有权限不允许");
        finish();
    }
}
 

@Override
public void onItemClick(View view, final int position) {
    //Toast.makeText(getActivity(),"item click detected", Toast.LENGTH_SHORT).show();
    if(position < 0 || position >= listNovelItemAid.size()) {
        // ArrayIndexOutOfBoundsException
        Toast.makeText(getActivity(), "ArrayIndexOutOfBoundsException: " + position + " in size " + listNovelItemAid.size(), Toast.LENGTH_SHORT).show();
        return;
    }

    // go to detail activity
    Intent intent = new Intent(getActivity(), NovelInfoActivity.class);
    intent.putExtra("aid", listNovelItemAid.get(position));
    intent.putExtra("from", "list");
    intent.putExtra("title", ((TextView) view.findViewById(R.id.novel_title)).getText());

    if(Build.VERSION.SDK_INT < 21) {
        startActivity(intent);
    }
    else {
        ActivityOptionsCompat options = ActivityOptionsCompat.makeSceneTransitionAnimation(getActivity(),
                Pair.create(view.findViewById(R.id.novel_cover), "novel_cover"),
                Pair.create(view.findViewById(R.id.novel_title), "novel_title"));
        ActivityCompat.startActivity(getActivity(), intent, options.toBundle());
    }
}
 

private void requestStoragePermissions() {
    if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(),
            Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
        // Provide an additional rationale to the user if the permission was not granted
        // and the user would benefit from additional context for the use of the permission.
        // For example if the user has previously denied the permission.
        Snackbar.make(mRootLayout, getString(R.string.request_external_storage),
                Snackbar.LENGTH_LONG)
                .setAction(getString(R.string.accept_permission), new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                                PERMISSION_WRITE_EXTERNAL_STORAGE);
                    }
                })
                .show();
    } else {
        // Permission has not been granted yet. Request it directly.
        requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                PERMISSION_WRITE_EXTERNAL_STORAGE);
    }
}
 

/*************************
 * Favorite Modification
 ************************/

@Override
protected boolean modifyFavorites(MenuItem item) {
    if (!prefHelper.isOnline(getActivity())) {
        Toast.makeText(getActivity(), R.string.no_connection, Toast.LENGTH_SHORT).show();
        return true;
    }
    if (databaseManager.isFavorite(lastComicNumber)) {
        //new DeleteComicImageTask(lastComicNumber).execute(true);
        removeFavorite(lastComicNumber, true);
        item.setIcon(R.drawable.ic_favorite_off_24dp);
    } else {
        if (!(ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED)) {
            ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 2);
            return true;
        }
        //new SaveComicImageTask(lastComicNumber).execute(true);
        addFavorite(lastComicNumber, true);
        item.setIcon(R.drawable.ic_favorite_on_24dp);
    }
    return true;
}
 

private void askForPermission(String permission, Integer requestCode) {
    if (ContextCompat.checkSelfPermission(getActivity(), permission) != PackageManager.PERMISSION_GRANTED) {

        // Should we show an explanation?
        if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(), permission)) {

            //This is called if user has denied the permission before
            //In this case I am just asking the permission again
            ActivityCompat.requestPermissions(getActivity(), new String[]{permission}, requestCode);

        } else {

            ActivityCompat.requestPermissions(getActivity(), new String[]{permission}, requestCode);
        }
    } else {
    }
}
 

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    Bundle arguments = getArguments();
    final int requestCode = arguments.getInt(ARGUMENT_PERMISSION_REQUEST_CODE);
    finishActivity = arguments.getBoolean(ARGUMENT_FINISH_ACTIVITY);

    return new AlertDialog.Builder(getActivity())
            .setMessage(R.string.permission_rationale_location)
            .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    // After click on Ok, request the permission.
                    ActivityCompat.requestPermissions(getActivity(),
                            new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                            requestCode);
                    // Do not finish the Activity while requesting permission.
                    finishActivity = false;
                }
            })
            .setNegativeButton(android.R.string.cancel, null)
            .create();
}
 

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_qr_scan);
    surfaceView = findViewById(R.id.surfaceView);
    if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(this) == ConnectionResult.SUCCESS) {
        initQrReader();
    } else {
        setResult(GOOGLE_PLAY_SERVICES_UNAVAILABLE);
        finish();
    }

    if (qrReader != null) {
        if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, PERMISSION_CAMERA);
        }
    }
}
 

private static String getUserIdentity(Context context) {
    if (ActivityCompat.checkSelfPermission(context, Manifest.permission.GET_ACCOUNTS) ==
            PackageManager.PERMISSION_GRANTED) {
        AccountManager manager = (AccountManager) context.getSystemService(Context.ACCOUNT_SERVICE);
        @SuppressLint("MissingPermission") Account[] list = manager.getAccounts();
        String emailId = null;
        for (Account account : list) {
            if (account.type.equalsIgnoreCase("com.google")) {
                emailId = account.name;
                break;
            }
        }
        if (emailId != null) {
            return emailId;
        }
    }
    return "";
}
 

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    dt = new DataHelper(this);

    ep = getSharedPreferences("Settings", 0);

    invalidateOptionsMenu();
    loadScreen();

    // request permissions
    ActivityCompat.requestPermissions(this, Constants.permissions, Constants.PERM_REQ);
    createDirs();

    if (ep.getInt("UpdateVersion", -1) < Utils.getVersion(this)) {
        ep.edit().putInt("UpdateVersion", Utils.getVersion(this)).apply();
        showChangelog(true, false);
    }

    checkIntent();
}
 

public void requestPermission() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {

        if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE
            }, MY_PERMISSIONS_WRITE_STORAGE);

        } else {
            ActivityCompat.requestPermissions(this,
                    new String[]{
                            Manifest.permission.WRITE_EXTERNAL_STORAGE
                    },
                    MY_PERMISSIONS_WRITE_STORAGE);

        }
    } else onPermissionGranted();
}
 

@Override
public void itemClicked(View view, MediaInfo item, int position) {
    if (view instanceof ImageButton) {
        Utils.showQueuePopup(getActivity(), view, item);
    } else {
        String transitionName = getString(R.string.transition_image);
        VideoListAdapter.ViewHolder viewHolder =
                (VideoListAdapter.ViewHolder) mRecyclerView.findViewHolderForPosition(position);
        Pair<View, String> imagePair = Pair
                .create((View) viewHolder.getImageView(), transitionName);
        ActivityOptionsCompat options = ActivityOptionsCompat
                .makeSceneTransitionAnimation(getActivity(), imagePair);

        Intent intent = new Intent(getActivity(), LocalPlayerActivity.class);
        intent.putExtra("media", item);
        intent.putExtra("shouldStart", false);
        ActivityCompat.startActivity(getActivity(), intent, options.toBundle());
    }
}
 

/**
 * Requests the {@link Manifest.permission#ACCESS_FINE_LOCATION}
 * permission.
 */

private void requestLocationPermission() {
  if (ActivityCompat.checkSelfPermission(this,
          Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED || mUserDeniedPermission) {
    // Permission has been granted (or denied and ignored), set up the toolbar and fragments.
    setUpToolbar();
    setUpFragments();
  } else {
    ActivityCompat.requestPermissions(this, new String[]{ Manifest.permission.ACCESS_FINE_LOCATION},
            PERMISSION_REQUEST_LOCATION);
  }
}
 

public static void requestLocationPermission(@NonNull Activity activity) {
    Log.d(TAG, "Requesting location permission");
    ActivityCompat.requestPermissions(activity, new String[]{
            Manifest.permission.ACCESS_FINE_LOCATION,
            Manifest.permission.ACCESS_COARSE_LOCATION
    }, REQUEST_CODE_LOCATION_PERMISSIONS);
}
 

private void showSendLogDialog() {

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                    SEND_LOG_ID_REQUEST);
            return;
        }

        LayoutInflater inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        @SuppressLint("InflateParams") View includeDeviceInfoView = inflater.inflate(R.layout.dialog_send_log, null, false);
        final CheckBox includeDeviceInfoCheckBox = includeDeviceInfoView.findViewById(android.R.id.checkbox);

        // allow user to choose whether or not to include device info in report, use preferences for persistence
        includeDeviceInfoCheckBox.setChecked(PreferenceHelper.getIncludeDeviceInfoPreference(this));
        includeDeviceInfoCheckBox.setOnCheckedChangeListener((buttonView, isChecked) -> PreferenceHelper.setIncludeDeviceInfoPreference(LogcatActivity.this, isChecked));

        final CheckBox includeDmesgCheckBox = includeDeviceInfoView.findViewById(R.id.checkbox_dmesg);

        // allow user to choose whether or not to include device info in report, use preferences for persistence
        includeDmesgCheckBox.setChecked(PreferenceHelper.getIncludeDmesgPreference(this));
        includeDmesgCheckBox.setOnCheckedChangeListener((buttonView, isChecked) -> PreferenceHelper.setIncludeDmesgPreference(LogcatActivity.this, isChecked));

        new MaterialDialog.Builder(LogcatActivity.this)
                .title(R.string.share_log)
                .customView(includeDeviceInfoView, false)
                .negativeText(android.R.string.cancel)
                .positiveText(android.R.string.ok)
                .onPositive((materialDialog, dialogAction) -> {
                    sendLogToTargetApp(false, includeDeviceInfoCheckBox.isChecked(), includeDmesgCheckBox.isChecked());
                    materialDialog.dismiss();
                }).show();
    }
 

public void launch(Intent intent) {

        intent.putExtras(createBundle());
        if (Build.VERSION.SDK_INT >= 16) {
            ActivityCompat.startActivity(activity, intent, createOptions());
            return;
        }
        activity.startActivity(intent);
        activity.overridePendingTransition(0, 0);
    }
 

/**
 * 跳转到视频播放
 *
 * @param activity
 * @param view
 */
public static void goToVideoPickPlayer(Activity activity, View view) {
    Intent intent = new Intent(activity, PlayPickActivity.class);
    intent.putExtra(PlayActivity.TRANSITION, true);
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
        Pair pair = new Pair<>(view, PlayActivity.IMG_TRANSITION);
        ActivityOptionsCompat activityOptions = ActivityOptionsCompat.makeSceneTransitionAnimation(
                activity, pair);
        ActivityCompat.startActivity(activity, intent, activityOptions.toBundle());
    } else {
        activity.startActivity(intent);
        activity.overridePendingTransition(R.anim.abc_fade_in, R.anim.abc_fade_out);
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (hasPermissions(this, RUNTIME_PERMISSIONS)) {
        setupMapFragmentView();
    } else {
        ActivityCompat
                .requestPermissions(this, RUNTIME_PERMISSIONS, REQUEST_CODE_ASK_PERMISSIONS);
    }
}
 

private boolean checkPermissions() {
    if (ActivityCompat.checkSelfPermission(this.getContext(),
            Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
        fragment.requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, WRITE_EXTERNAL_PERMISSION);
        return true;
    }
    return false;
}
 

private void requestPermission(String permission) {
    Activity activity = registrar.activity();
    permission = getManifestPermission(permission);
    if (permission == null) {
        return;
    }
    Log.i(LOG_TAG, "Requesting permission " + permission);
    String[] perm = {permission};
    ActivityCompat.requestPermissions(activity, perm, 0);
}
 

private void alertForWiFi() {

        AlertDialog.Builder builder = new AlertDialog.Builder(this, R.style.AlertDialogTheme);
        builder.setCancelable(false);
        builder.setMessage(R.string.error_wifi_off);

        // Set up the buttons
        builder.setPositiveButton(R.string.btn_ok, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {

                dialog.dismiss();
                espDevice = null;
                hideLoading();
                if (codeScanner != null) {
                    codeScanner.releaseResources();
                    codeScanner.startPreview();
                    if (ActivityCompat.checkSelfPermission(AddDeviceActivity.this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
                            && ActivityCompat.checkSelfPermission(AddDeviceActivity.this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
                        provisionManager.scanQRCode(codeScanner, qrCodeScanListener);
                    } else {
                        Log.e(TAG, "Permissions are not granted");
                    }
                }
            }
        });

        builder.show();
    }
 

private void showSaveLogZipDialog() {

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                    SEND_LOG_ID_REQUEST);
            return;
        }

        LayoutInflater inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        @SuppressLint("InflateParams") View includeDeviceInfoView = inflater.inflate(R.layout.dialog_send_log, null, false);
        final CheckBox includeDeviceInfoCheckBox = includeDeviceInfoView.findViewById(android.R.id.checkbox);

        // allow user to choose whether or not to include device info in report, use preferences for persistence
        includeDeviceInfoCheckBox.setChecked(PreferenceHelper.getIncludeDeviceInfoPreference(this));
        includeDeviceInfoCheckBox.setOnCheckedChangeListener((buttonView, isChecked) -> PreferenceHelper.setIncludeDeviceInfoPreference(LogcatActivity.this, isChecked));

        final CheckBox includeDmesgCheckBox = includeDeviceInfoView.findViewById(R.id.checkbox_dmesg);

        // allow user to choose whether or not to include device info in report, use preferences for persistence
        includeDmesgCheckBox.setChecked(PreferenceHelper.getIncludeDmesgPreference(this));
        includeDmesgCheckBox.setOnCheckedChangeListener((buttonView, isChecked) -> PreferenceHelper.setIncludeDmesgPreference(LogcatActivity.this, isChecked));

        new MaterialDialog.Builder(LogcatActivity.this)
                .title(R.string.save_log_zip)
                .customView(includeDeviceInfoView, false)
                .negativeText(android.R.string.cancel)
                .positiveText(android.R.string.ok)
                .onPositive((materialDialog, dialogAction) -> {
                    saveLogToTargetApp(includeDeviceInfoCheckBox.isChecked(), includeDmesgCheckBox.isChecked());
                    materialDialog.dismiss();
                }).show();
    }
 

public void ensurePermission(final @NonNull String permission) {
    Builder dialogBuilder = new AlertDialog.Builder(getActivity())
            .setCancelable(false);

    if (ActivityCompat.checkSelfPermission(getActivity(), permission) != PERMISSION_GRANTED ||
            ActivityCompat.shouldShowRequestPermissionRationale(getActivity(), permission)) {
        dialogBuilder.setTitle(R.string.location_permission_dialog_title)
                .setMessage(R.string.location_permission_dialog_text)
                .setPositiveButton(R.string.got_it, (dialog, which) -> {
                    dialog.dismiss();
                    requestPermission(permission);
                });
    } else {
        // user has explicitly denied this permission to setup.
        // show a simple dialog and bail out.
        dialogBuilder.setTitle(R.string.location_permission_denied_dialog_title)
                .setMessage(R.string.location_permission_denied_dialog_text)
                .setPositiveButton(R.string.settings, (dialog, which) -> {
                    dialog.dismiss();
                    Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                    String pkgName = getActivity().getApplicationInfo().packageName;
                    intent.setData(Uri.parse("package:" + pkgName));
                    startActivity(intent);
                })
                .setNegativeButton(R.string.exit_setup, (dialog, which) -> {
                    Client client = (Client) getActivity();
                    client.onUserDeniedPermission(permission);
                });
    }

    dialogBuilder.show();
}
 

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_ffmpeg_command);
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
            != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                100);
    }
    init();
}
 

@SuppressLint("BatteryLife")
private static void askForPermission(Activity activity, String[] permission, Integer requestCode) {
    boolean test = false;
    boolean testBattery = false;
    for (String s : permission) {
        test = test || (ContextCompat.checkSelfPermission(activity, s) != PackageManager.PERMISSION_GRANTED);
        if (s.equals(Manifest.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)) {
            PowerManager powerManager = (PowerManager) activity.getSystemService(Context.POWER_SERVICE);
            String packageName = activity.getPackageName();
            testBattery = testBattery || !powerManager.isIgnoringBatteryOptimizations(packageName);
        }
    }
    if (test) {
        ActivityCompat.requestPermissions(activity, permission, requestCode);
    }
    if (testBattery) {
        try {
            Intent i = new Intent();
            i.setAction(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
            i.setData(Uri.parse("package:" + activity.getPackageName()));
            activity.startActivityForResult(i, CASE_BATTERY);
        } catch (ActivityNotFoundException e) {
            permission_battery_optimization_failed = true;
            OKDialog.show(activity, MainApp.gs(R.string.permission), MainApp.gs(R.string.alert_dialog_permission_battery_optimization_failed), activity::recreate);
        }
    }
}
 

private void requestPermissions() {
    boolean shouldProvideRationale =
            ActivityCompat.shouldShowRequestPermissionRationale(this,
                    Manifest.permission.ACCESS_FINE_LOCATION);

    // Provide an additional rationale to the user. This would happen if the user denied the
    // request previously, but didn't check the "Don't ask again" checkbox.
    if (shouldProvideRationale) {
        Log.i(TAG, "Displaying permission rationale to provide additional context.");
        showSnackbar(R.string.permission_rationale,
                android.R.string.ok, new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        // Request permission
                        ActivityCompat.requestPermissions(MainActivity.this,
                                new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                                REQUEST_PERMISSIONS_REQUEST_CODE);
                    }
                });
    } else {
        Log.i(TAG, "Requesting permission");
        // Request permission. It's possible this can be auto answered if device policy
        // sets the permission in a given state or the user denied the permission
        // previously and checked "Never ask again".
        ActivityCompat.requestPermissions(MainActivity.this,
                new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                REQUEST_PERMISSIONS_REQUEST_CODE);
    }
}