Java Code Examples for android.support.v4.app.ActivityCompat

public static void requestRuntimePermission(Activity activity, String[] permissions,
                                            OnRequestPermissionsListener listener) {
    Activity topActivity = activity;
    if (null == topActivity) {
        return;
    }
    mListener = listener;
    List<String> permissionList = new ArrayList<>();
    for (String permission : permissions) {
        if (ContextCompat.checkSelfPermission(topActivity, permission)
                != PackageManager.PERMISSION_GRANTED) {

            permissionList.add(permission);
        }
    }
    if (!permissionList.isEmpty()) {
        ActivityCompat.requestPermissions(topActivity,
                permissionList.toArray(new String[permissionList.size()]),
                PERMISSION_REQUEST_CODE);
    } else {
        mListener.onGranted();
    }
}
 

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, "Storage access permissions are required to upload/download files.",
                Snackbar.LENGTH_LONG)
                .setAction("Okay", 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);
    }
}
 

@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {

	// update the summeries:
	updateSummaries();

	// Screen Orientation:
	String screenOrientation = sharedPreferences.getString(getString(R.string.pref_screenOrientation), "auto");
	setScreenOrientation(screenOrientation);

	// check WRITE_EXTERNAL_STORAGE permission if logging is active:
	if(sharedPreferences.getBoolean(getString(R.string.pref_logging), false)) {
		if (ContextCompat.checkSelfPermission(this.getActivity(), "android.permission.WRITE_EXTERNAL_STORAGE")
				!= PackageManager.PERMISSION_GRANTED) {
			// request permission:
			ActivityCompat.requestPermissions(this.getActivity(), new String[]{"android.permission.WRITE_EXTERNAL_STORAGE"},
					PERMISSION_REQUEST_LOGGING_WRITE_FILES);
		}
	}
}
 

private void requestPermissions(){
	try {
		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
			int permission = ActivityCompat.checkSelfPermission(this,
					Manifest.permission.WRITE_EXTERNAL_STORAGE);
			if(permission!= PackageManager.PERMISSION_GRANTED) {
				ActivityCompat.requestPermissions(this,new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE,
						Manifest.permission.LOCATION_HARDWARE,Manifest.permission.READ_PHONE_STATE,
						Manifest.permission.WRITE_SETTINGS,Manifest.permission.READ_EXTERNAL_STORAGE,
						Manifest.permission.RECORD_AUDIO,Manifest.permission.READ_CONTACTS},0x0010);
			}
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

public void startAuth(FingerprintManager manager,
                      FingerprintManager.CryptoObject cryptoObject) {

    cancellationSignal = new CancellationSignal();

    if (ActivityCompat.checkSelfPermission(context,
            Manifest.permission.USE_FINGERPRINT) !=
            PackageManager.PERMISSION_GRANTED) {
        return;
    }
    manager.authenticate(cryptoObject, cancellationSignal, 0, this, null);
}
 

private void requestPermissions() {
        boolean shouldProvideRationale =
                ActivityCompat.shouldShowRequestPermissionRationale(this,
                        android.Manifest.permission.ACCESS_COARSE_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.");

        } 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".
                startLocationPermissionRequest();
        }
}
 

@Override
public void onBackPressed() {
    //获取数据返回获取
    long currPosition = exoPlayerManager.getCurrentPosition();
    if (exoPlayerManager.onBackPressed()) {//使用播放返回键监听
        isBack=true;
        Toast.makeText(MainListInfoCustomActivity.this, "返回", Toast.LENGTH_LONG).show();
        Intent intent = new Intent();
        intent.putExtra("isEnd", isEnd);
        intent.putExtra("currPosition", currPosition);
        Log.d(TAG, "sss:" + exoPlayerManager.getCurrentPosition());
        setResult(RESULT_OK, intent);
        ActivityCompat.finishAfterTransition(this);
    }

}
 

private Location getLastKnownLocation(){
    if( ActivityCompat.checkSelfPermission( this, Manifest.permission.ACCESS_FINE_LOCATION ) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission( this, Manifest.permission.ACCESS_COARSE_LOCATION ) != PackageManager.PERMISSION_GRANTED ){
        return null;
    }
    LocationManager locationManager =
            (LocationManager) this.getSystemService( LOCATION_SERVICE );
    List<String> providers = locationManager.getProviders( true );
    Location bestLocation = null;
    for( String provider : providers ){
        Location l = locationManager.getLastKnownLocation( provider );
        if( l == null ){
            continue;
        }
        if( bestLocation == null || l.getAccuracy() < bestLocation.getAccuracy() ){
            bestLocation = l; // Found best last known location;
        }
    }
    return bestLocation;
}
 

/********************************** 以下是权限检查部分 ********************************/
private void checkPermission(){
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
            == PackageManager.PERMISSION_GRANTED) {
        mCameraView.start();
    } else if (ActivityCompat.shouldShowRequestPermissionRationale(this,
            Manifest.permission.CAMERA)) {
        ConfirmationDialogFragment
                .newInstance(R.string.camera_permission_confirmation,
                        new String[]{Manifest.permission.CAMERA},
                        REQUEST_CAMERA_PERMISSION,
                        R.string.camera_permission_not_granted)
                .show(getSupportFragmentManager(), FRAGMENT_DIALOG);
    } else {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA},
                REQUEST_CAMERA_PERMISSION);
    }
}
 

protected void requestStoragePermissions() {
    if(PermissionUtil.hasStoragePermission(this)) {
        again();
    } else {
        if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
            Utils.showRetrySnackBar(this, "Storage permissions are needed for Exploring.", new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    ActivityCompat.requestPermissions(BaseActivity.this, storagePermissions, REQUEST_STORAGE);
                }
            });
        } else {
            ActivityCompat.requestPermissions(this, storagePermissions, REQUEST_STORAGE);
        }
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    if (Utils.hasLollipop()) requestWindowFeature(Window.FEATURE_CONTENT_TRANSITIONS);
    super.onCreate(savedInstanceState);

    if (Utils.hasLollipop()) {
        getWindow().setExitTransition(new Fade());
    }

    //TODO: Remove after evaluation testing
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    Intent intent = new Intent(this, MainActivity.class);
    ActivityOptionsCompat options = ActivityOptionsCompat.makeSceneTransitionAnimation(this);
    ActivityCompat.startActivity(this, intent, options.toBundle());
    ActivityCompat.finishAfterTransition(this);
}
 

private void cheseFile() {
    int checkCode = ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE);
    int checkRead = ContextCompat.checkSelfPermission(MainActivity.this,Manifest.permission.READ_EXTERNAL_STORAGE);
    //如果拒绝
    if (checkCode== PackageManager.PERMISSION_DENIED||checkRead==PackageManager.PERMISSION_DENIED){
        //申请权限
        if (checkCode==PackageManager.PERMISSION_DENIED){
            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},100);
        }
        if (checkRead==PackageManager.PERMISSION_DENIED){
            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},101);
        }
    }else if (checkCode==PackageManager.PERMISSION_GRANTED){
        if (mSelected!=null&&mSelected.size()>0)
        mSelected.clear();
        CANPLAY=false;
        doSomething();
    }
}
 

private void requestPermissions() {
        boolean shouldProvideRationale =
                ActivityCompat.shouldShowRequestPermissionRationale(this,
                        android.Manifest.permission.ACCESS_COARSE_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.");

        } 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".
                startLocationPermissionRequest();
        }
}
 

private static boolean isReadStoragePermissionGranted(Activity activity) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (activity.checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE)
                == PackageManager.PERMISSION_GRANTED) {
            Timber.d("Permission is granted");
            return true;
        } else {

            Timber.d("Permission is revoked");
            ActivityCompat.requestPermissions(activity,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                    activity.getResources().getInteger(R.integer.read_external_storage_request));
            return false;
        }
    } else { //permission is automatically granted on sdk<23 upon installation
        Timber.d("Permission is granted");
        return true;
    }
}
 

/**
 * 更新Dialog
 *
 * @param url
 * @param version
 * @param desc
 * @param force
 */
private void showUpdateDialog(String url, String version, String desc, boolean force) {
    if (updateDialog == null) {
        updateDialog = new UpdateDialog(mContext);
        updateDialog.setValue(url, version, desc, force);
        updateDialog.setOnClickUpdateListener(() -> {
            updateDialog.cancel();
            if (ContextCompat.checkSelfPermission(mContext, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions((Activity) mContext, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, PERMISSION_WRITE_STORAGE);
            } else {
                updateDialog.onClickUpdate();
            }
        });
    }
    updateDialog.show();
}
 

public void onAttachClick() {
    final int permissionStatus = ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.READ_EXTERNAL_STORAGE
    );

    if (permissionStatus != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(
                this,
                new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                REQUEST_ATTACH_PERMISSION
        );

        return;
    }

    final Intent attach = new Intent(Intent.ACTION_GET_CONTENT)
            .addCategory(Intent.CATEGORY_OPENABLE)
            .setType("*/*");

    startActivityForResult(attach, REQUEST_ATTACH_FILE);
}
 

@Override
public void onCreate(Bundle savedInstanceState) {
    Log.i(TAG, "called onCreate");
    super.onCreate(savedInstanceState);
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

    setContentView(R.layout.activity_main);

    if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.CAMERA)
            != PackageManager.PERMISSION_GRANTED) {
        Log.i("permission", "request READ_EXTERNAL_STORAGE");
        ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.CAMERA}, REQUEST_CAMERA);
    }else {
        Log.i("permission", "READ_EXTERNAL_STORAGE already granted");
        camera_granted = true;
    }

    mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.main_activity_surface_view);
    mOpenCvCameraView.setCvCameraViewListener(this);
}
 

public void onAddDocumentClick() {
  pickImageDialog = new PickImageDialogBuilder(this)
      .build()
      .setListener(new PickImageDialog.Listener() {
        @Override
        public void execute(Intent intent, int requestCode) {
          if (requestCode == REQUEST_CAPTURE_PHOTO) {
            if (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
              ActivityCompat.requestPermissions(AddElephantActivity.this, new String[]{Manifest.permission.CAMERA}, 0);
            } else {
              startActivityForResult(intent, requestCode);
            }
          } else {
            startActivityForResult(intent, requestCode);
          }
        }
      })
      .setCaptureCode(REQUEST_CAPTURE_PHOTO)
      .setImportCode(REQUEST_IMPORT_PHOTO)
      .load();
  pickImageDialog.show();
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_devices);
    ButterKnife.bind(this);

    // initialize the DevicesAdapter and the RecyclerView
    devicesAdapter = new DevicesAdapter();
    devicesRecyclerView.setAdapter(devicesAdapter);
    devicesRecyclerView.setLayoutManager(new LinearLayoutManager(this));

    // check that we have Location permissions
    if (ContextCompat.checkSelfPermission(getApplicationContext(),
            Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
        initializeBridgefy();
    } else {
        ActivityCompat.requestPermissions(this,
                new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, 0);
    }
}
 

public void get_file(){
	String[] perms = {Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA};

	//Checking for storage permission to write images for upload
	if (ASWP_FUPLOAD && ASWP_CAMUPLOAD && !check_permission(2) && !check_permission(3)) {
		ActivityCompat.requestPermissions(MainActivity.this, perms, file_perm);

	//Checking for WRITE_EXTERNAL_STORAGE permission
	} else if (ASWP_FUPLOAD && !check_permission(2)) {
		ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, file_perm);

	//Checking for CAMERA permissions
	} else if (ASWP_CAMUPLOAD && !check_permission(3)) {
		ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.CAMERA}, file_perm);
	}
}
 

private void verifyNecessaryPermissions() {
    int permissionCheckCamera = ContextCompat.checkSelfPermission(getApplicationContext(),
            Manifest.permission.CAMERA);

    if (permissionCheckCamera != PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.CAMERA, Manifest.permission.CAMERA},
                AppConstants.PERMISSION_REQUEST);
    }

    int permissionCheckInternet = ContextCompat.checkSelfPermission(getApplicationContext(),
            Manifest.permission.INTERNET);

    if (permissionCheckInternet != PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.INTERNET, Manifest.permission.INTERNET},
                AppConstants.PERMISSION_REQUEST);
    }
}
 

private void getCurrentLocation() {
    mMap.clear();
    if(ActivityCompat.checkSelfPermission(this,android.Manifest.permission.ACCESS_FINE_LOCATION)!= PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this,android.Manifest.permission.ACCESS_COARSE_LOCATION)!=PackageManager.PERMISSION_GRANTED )
    {
        //Creating a location object
        return ;}
    Location location = LocationServices.FusedLocationApi.getLastLocation(googleApiClient);
    if (location != null) {
        //Getting longitude and latitude
        longitude = location.getLongitude();
        latitude = location.getLatitude();

        //moving the map to location
        moveMap();
    }
}
 

private void decodeImage() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        int result = ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.READ_EXTERNAL_STORAGE);
        if (result != PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(getContext(), R.string.read_permission_msg, Toast.LENGTH_SHORT).show();
            String[] permissions = {Manifest.permission.READ_EXTERNAL_STORAGE,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE};
            requestPermissions(permissions, REQUEST_READ_EXTERNAL_STORAGE);
            return;
        }
    }

    try {
        Intent getIntent = new Intent(Intent.ACTION_GET_CONTENT);
        getIntent.setType("image/*");

        Intent pickIntent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        pickIntent.setType("image/*");

        Intent chooserIntent = Intent.createChooser(getIntent, getString(R.string.select_image));
        chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, new Intent[]{pickIntent});

        startActivityForResult(chooserIntent, REQUEST_PICK_IMAGE);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	/* Hide 'home' icon on old themes */
	getActionBar().setDisplayShowHomeEnabled(false);

	prefs = getPreferences(Context.MODE_PRIVATE);

	topDirectory = Environment.getExternalStorageDirectory();
	currentDirectory = new File(prefs.getString("currentDirectory", topDirectory.getAbsolutePath()));

	adapter = new ArrayAdapter<Item>(this, android.R.layout.simple_list_item_1);
	setListAdapter(adapter);

	if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED)
		ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, PERMISSION_REQUEST);
}
 

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_PERMISSION_SETTING) {
        if (ActivityCompat.checkSelfPermission(getActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
            //Got Permission
            Toast.makeText(getActivity(),"Permissions Granted",Toast.LENGTH_LONG).show();
        }
    }
}
 

private static boolean askForPermissions(Activity activity, @NonNull String[] permissions) {
    boolean hasPermissions = true;

    for (String permission : permissions) {
        hasPermissions &= ActivityCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED;
    }

    if (!hasPermissions) {
        ActivityCompat.requestPermissions(activity, permissions, EMAIL_PERMISSIONS_REQUEST);
    }

    return hasPermissions;
}
 

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

    //check if the device has a bluetooth or not
    //and show Toast message if it does't have
    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    bluetoothDevicesAdapter = new BluetoothDevicesAdapter(this, bluetoothDevicesNamesList);

    if (mBluetoothAdapter == null) {
        Toast.makeText(this, R.string.does_not_have_bluetooth, Toast.LENGTH_LONG).show();
        finish();
    } else if (!mBluetoothAdapter.isEnabled()) {
        Intent enableIntentBluetooth = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(enableIntentBluetooth, REQUEST_ENABLE_BT);
    } else if (mBluetoothAdapter.isEnabled()) {
        PairedDevicesList();
    }

    setBroadCastReceiver();

    //request location permission for bluetooth scanning for android API 23 and above
    ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_ENABLE_FINE_LOCATION);


    //press the button to start search new Devices
    searchForNewDevices.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            searchForNewDevices.setEnabled(false);
            bluetoothDevicesAdapter.clear();
            PairedDevicesList();
            NewDevicesList();
        }
    });

}
 

public static void start(final Activity activity, final View view, final String url) {
        Intent imageIntent = new Intent(activity, ImageDisplayActivity.class);
        imageIntent.putExtra("name", "photo");
        imageIntent.putExtra("url", url);
        LogUtil.e("启动图片浏览界面11");
        ActivityCompat.startActivity(activity, imageIntent, ActivityOptionsCompat.makeSceneTransitionAnimation(activity, view, "photo").toBundle());
}
 

/**
 * This check is necessary only with Android 6.0+ and/or SDK 22+
 */
private boolean checkPermission() {
    int fineLocation = ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION);

    if (fineLocation != PackageManager.PERMISSION_GRANTED) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                    PERMISSION_REQUEST_CODE_FINE_LOCATION);
        }
        return false;
    } else {
        return true;
    }
}
 

@TargetApi(Build.VERSION_CODES.M)
public void startListening(FingerprintManager.CryptoObject cryptoObject) {
    //android studio 上，没有这个会报错
    if (ActivityCompat.checkSelfPermission(context, Manifest.permission.USE_FINGERPRINT)
            != PackageManager.PERMISSION_GRANTED) {
        throw new FPerException(PERMISSION_DENIED_ERROE);
    }
    manager.authenticate(cryptoObject, null, 0, mSelfCancelled, null);
}
 

@TargetApi(Build.VERSION_CODES.M)
private void initPermission() {
  if (ContextCompat.checkSelfPermission(this,
      android.Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
    ActivityCompat.requestPermissions(this,
        new String[]{
            Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.RECORD_AUDIO
        },
        MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
  }
}
 

/** 寫入資料**/
public void writeInfo(String fileName, String strWrite) {
    //WRITE_EXTERNAL_STORAGE
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
            != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                WRITE_EXTERNAL_STORAGE_REQUEST_CODE);
    }
    try {

        String fullPath = Environment.getExternalStorageDirectory().getAbsolutePath();
        String savePath = fullPath + File.separator + "/" + fileName;

        File file = new File(savePath);

        if (!file.exists()) {
            file.createNewFile();
        }

        FileWriter fw = new FileWriter(file.getAbsoluteFile());
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write(strWrite);

        bw.close();

    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

private void requestCameraPermission() {
    Log.w(TAG, "Camera permission is not granted. Requesting permission");

    final String[] permissions = new String[]{Manifest.permission.CAMERA};

    if (!ActivityCompat.shouldShowRequestPermissionRationale(this,
            Manifest.permission.CAMERA)) {
        ActivityCompat.requestPermissions(this, permissions, RC_HANDLE_CAMERA_PERM);
    }
}
 

public boolean requestPerms() {
    if ((ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
            || ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
        Log.d(Util.LOG_TAG, "Requesting I/O permissions");
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,
                Manifest.permission.WRITE_EXTERNAL_STORAGE}, Util.PERMISSION_REQUEST_STORAGE);
        return false;
    } else {
        Log.d(Util.LOG_TAG, "Permissions already granted, loading media");
        return true;
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // When the compile and target version is higher than 22, please request the
    // following permissions at runtime to ensure the
    // SDK work well.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.VIBRATE,
                        Manifest.permission.INTERNET, Manifest.permission.ACCESS_WIFI_STATE,
                        Manifest.permission.WAKE_LOCK, Manifest.permission.ACCESS_COARSE_LOCATION,
                        Manifest.permission.ACCESS_NETWORK_STATE, Manifest.permission.ACCESS_FINE_LOCATION,
                        Manifest.permission.CHANGE_WIFI_STATE, Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS,
                        Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.SYSTEM_ALERT_WINDOW,
                        Manifest.permission.READ_PHONE_STATE,
                }
                , 1);
    }

    setContentView(R.layout.activity_way_point);

    IntentFilter filter = new IntentFilter();
    filter.addAction(DJIDemoApplication.FLAG_CONNECTION_CHANGE);
    registerReceiver(mReceiver, filter);

    mapView = (MapView) findViewById(R.id.map);
    mapView.onCreate(savedInstanceState);

    initMapView();
    initUI();
    addListener();

}
 

/**
 * deletes a event in the local android event db for a given uid (the _id property of the event-model)
 *
 * @param uid {String} - a uid of a event which will be deleted
 * @return {Integer} - the id of the deleted event
 */
public Integer deleteEventByUid(String uid) {
    if (ActivityCompat.checkSelfPermission(this.context, Manifest.permission.WRITE_CALENDAR) != PackageManager.PERMISSION_GRANTED) {
        PermissionsUtil.checkPermissions(CALENDAR_PERMISSION_CALLBACK_ID, (Activity) this.context, Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR);
        return -1;
    }


    Uri uri = Events.CONTENT_URI;
    String whereQuery = "(" + Events.UID_2445 + " = \'" + uid + "\')";
    return this.contentResolver.delete(uri, whereQuery, null);
}
 

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    if (requestCode == REQUEST_PERMISSION) {
        // for each permission check if the user granted/denied them
        // you may want to group the rationale in a single dialog,
        // this is just an example
        int len = permissions.length;
        for (int i = 0; i < len; i++) {
            String permission = permissions[i];
            if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
                // user rejected the permission
                boolean showRationale = ActivityCompat.shouldShowRequestPermissionRationale(RequestPermissionsActivity.this, permission );
                if (! showRationale) {
                    // user also CHECKED "never ask again"
                    // you can either enable some fall back,
                    // disable features of your app
                    // or open another dialog explaining
                    // again the permission and directing to
                    // the app setting

                } else if (Manifest.permission.WRITE_CONTACTS.equals(permission)) {
                    // todo define strings
                    showRationale(permission, R.string.permission_denied_contacts);
                    // user did NOT check "never ask again"
                    // this is a good place to explain the user
                    // why you need the permission and ask if he wants
                    // to accept it (the rationale)
                }
                //else if ( /* possibly check more permissions...*/ ) {}
            }
        }
    }
}
 

@Override
public void onBackPressed() {
    if (exoPlayerManager.onBackPressed()) {
        ActivityCompat.finishAfterTransition(this);
        exoPlayerManager.onDestroy();
    }
}
 

public void setResultAndFinish() {
    isReturning = true;
    Intent data = new Intent();
    data.setAction(SHARED_ELEMENT_RETURN_TRANSITION);
    data.putExtra(AlbumActivity.ALBUM_PATH, album.getPath());
    data.putExtra(AlbumActivity.EXTRA_CURRENT_ALBUM_POSITION, viewPager.getCurrentItem());
    setResult(RESULT_OK, data);
    ActivityCompat.finishAfterTransition(this);
}
 

/**
 * Handles the requesting of the camera permission.  This includes
 * showing a "Snackbar" message of why the permission is needed then
 * sending the request.
 */
private void requestCameraPermission() {
    Log.w(TAG, "Camera permission is not granted. Requesting permission");

    final String[] permissions = new String[]{Manifest.permission.CAMERA};

    if (!ActivityCompat.shouldShowRequestPermissionRationale(this,
            Manifest.permission.CAMERA)) {
        ActivityCompat.requestPermissions(this, permissions, RC_HANDLE_CAMERA_PERM);
        return;
    }

    final Activity thisActivity = this;

    View.OnClickListener listener = new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            ActivityCompat.requestPermissions(thisActivity, permissions,
                    RC_HANDLE_CAMERA_PERM);
        }
    };

    Snackbar.make(mGraphicOverlay, R.string.permission_camera_rationale,
            Snackbar.LENGTH_INDEFINITE)
            .setAction(R.string.ok, listener)
            .show();
}
 

@RequiresApi(api = Build.VERSION_CODES.M)
private void requestWriteExternalStoragePermission(int requestCode) {

    if (!ActivityCompat.shouldShowRequestPermissionRationale(this,
            Manifest.permission.WRITE_EXTERNAL_STORAGE)) {

        requestPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE, requestCode);
    }
}
 

private void checkPermission() {
    Log.d("onCreate", "checkPermission");
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        int permissionCheck = ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION);
        if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_CODE_ACCESS_FINE_LOCATION);
        }
    }

}
 

public void requestPermission(@NonNull String permission){
    if (ContextCompat.checkSelfPermission(context,permission) == PackageManager.PERMISSION_GRANTED){
        if (callback != null){
            callback.success();
        }
    }else {
        ActivityCompat.requestPermissions((Activity) context,new String[]{permission},REQUEST_CODE);
    }
}
 

private synchronized void gpsStart() {
    if (!mStarted) {
        if (ActivityCompat.checkSelfPermission(mainActivity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
            ActivityCompat.checkSelfPermission(mainActivity, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED)
        {
            return;
        }
        mLocationManager.requestLocationUpdates(mProvider.getName(), minTime, minDistance, this);
        mStarted = true;
    }
}
 

/**
 * Make request permission
 * @param activity Activity
 */
private static void requestPermission(Activity activity) {

    if (ActivityCompat.shouldShowRequestPermissionRationale(activity, android.Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
        Log.d(TAG, "Write External Storage permission allows us to do store shortcuts data. Please allow this permission in App Settings.");
    } else {
        ActivityCompat.requestPermissions(activity, new String[]{android.Manifest.permission.WRITE_EXTERNAL_STORAGE}, 111);
        Log.d(TAG, "Write External Storage permission allows us to do store shortcuts data.");
    }
}
 

/**
 * Return true if the permission available, else starts permission request from user
 */
public static boolean requestPermission(@NonNull final Activity activity,
                                        @NonNull final String permission) {

    if (checkForPermission(activity, permission)) {
        return true;
    }

    int requestCode = getRequestCodeByPermission(permission);

    ActivityCompat.requestPermissions(activity,
            new String[]{permission},
            requestCode);
    return false;
}
 

private void checkPermission() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        boolean isCoarse = (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) ==
                PackageManager.PERMISSION_GRANTED);
        boolean isFine = (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) ==
                PackageManager.PERMISSION_GRANTED);

        if (!isCoarse || !isFine) {
            ActivityCompat.requestPermissions(this, new String[]{
                            Manifest.permission.ACCESS_COARSE_LOCATION,
                            Manifest.permission.ACCESS_FINE_LOCATION},
                    1);
        }
    }
}
 

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

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

    } else {
        installApk();
    }

}
 

private void upload() {
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        return;
    }
    location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
    if (location == null) {
        noOfRetries++;
        if(noOfRetries>3){
            //TODO dialog box prompting user to disable tracking
        }
        MainMenuActivity.this.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Message.message(MainMenuActivity.this, "location not available");
            }
        });
        Log.d("No location recieved", "it was in vain");
    } else {
        noOfRetries = 0;
        Log.d("upload", "null");
        mLatitude = String.valueOf(location.getLatitude());
        mLongitude = String.valueOf(location.getLongitude());

        MainMenuActivity.this.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Message.message(MainMenuActivity.this, "Latitude: " + mLatitude + " Longitude: " + mLongitude);
            }
        });

        Log.d("lats", mLatitude);
        Log.d("longs", mLongitude);

        updateLocationDB();
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
	if (Utils.hasLollipop()) requestWindowFeature(Window.FEATURE_CONTENT_TRANSITIONS);
	super.onCreate(savedInstanceState);

	if (Utils.hasLollipop()) {
		getWindow().setExitTransition(new Fade());
	}

	Intent intent = new Intent(this, MainActivity.class);
	ActivityOptionsCompat options = ActivityOptionsCompat.makeSceneTransitionAnimation(this);
	ActivityCompat.startActivity(this, intent, options.toBundle());
	ActivityCompat.finishAfterTransition(this);
}
 

/**
 * 获取权限集中需要申请权限的列表
 *
 * @param permissions
 * @return
 * @since 2.5.0
 */
private static List<String> findDeniedPermissions(String[] permissions) {
    List<String> needRequestPermissonList = new ArrayList<String>();
    for (String perm : permissions) {
        if (ContextCompat.checkSelfPermission(context, perm) != PackageManager.PERMISSION_GRANTED) {
            needRequestPermissonList.add(perm);
        } else if (ActivityCompat.shouldShowRequestPermissionRationale(context, perm)) {
            needRequestPermissonList.add(perm);
        }
    }
    return needRequestPermissonList;
}
 

public void setUpMap() {

        googleMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

            return;
        }
        googleMap.setMyLocationEnabled(true);
        googleMap.setTrafficEnabled(true);
        googleMap.setIndoorEnabled(true);
        googleMap.setBuildingsEnabled(true);
        googleMap.getUiSettings().setZoomControlsEnabled(true);
    }
 

@Override
public void onItemClicked(View view, SettingsCategoryAdapter.SettingsCategoryViewHolder settingsCategoryViewHolder) {
	SettingsCategory category = settingsCategoryViewHolder.getData();

	ActivityOptionsCompat settingsAnim = ActivityOptionsCompat.makeCustomAnimation(this, R.anim.slide_in_right_anim, R.anim.fade_out_semi_anim); // First animation is how the new activity enters - Second is how the current activity exits
	ActivityCompat.startActivity(this, category.getIntent(), settingsAnim.toBundle());
}
 

@Override
protected void onPause() {
    super.onPause();

    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

        return;
    }
    localM.removeUpdates(this);

}
 

public void doTakePhotoAction() {
    int permissionCheck = ContextCompat.checkSelfPermission(AddProductActivity.this, android.Manifest.permission.CAMERA);
    if (permissionCheck == PackageManager.PERMISSION_DENIED) {
        ActivityCompat.requestPermissions(AddProductActivity.this, new String[]{android.Manifest.permission.CAMERA}, 0);
    } else {
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        String url = "profile.jpg";
        mlmageCaptureUri = Uri.fromFile(new File(Environment.getExternalStorageDirectory(), url));
        intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, mlmageCaptureUri);
        startActivityForResult(intent, PICK_FROM_CAMERA);
        Log.i(TAG, "test1-camera");
    }
}
 

@TargetApi(23)
public void startAuth(FingerprintManager manager, FingerprintManager.CryptoObject cryptoObject) {
    CancellationSignal cancellationSignal = new CancellationSignal();
    if (ActivityCompat.checkSelfPermission(context, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) {
        return;
    }
    manager.authenticate(cryptoObject, cancellationSignal, 0, this, null);
}
 

/**
 * App Permissions for Audio
 **/
private void setupPermissions() {
    // If we don't have the record audio permission...
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
        // And if we're on SDK M or later...
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // Ask again, nicely, for the permissions.
            String[] permissionsWeNeed = new String[]{ Manifest.permission.RECORD_AUDIO };
            requestPermissions(permissionsWeNeed, MY_PERMISSION_RECORD_AUDIO_REQUEST_CODE);
        }
    } else {
        // Otherwise, permissions were granted and we are ready to go!
        mAudioInputReader = new AudioInputReader(mVisualizerView, this);
    }
}
 

private void checkPermission() {
    if (ContextCompat.checkSelfPermission(getActivity().getApplicationContext()
            , Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.ACCESS_COARSE_LOCATION},
                1);
    }else{
        initLocation();
    }
}
 

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.");
        Snackbar.make(
                findViewById(R.id.activity_main),
                R.string.permission_rationale,
                Snackbar.LENGTH_INDEFINITE)
                .setAction(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);
                    }
                })
                .show();
    } 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);
    }
}
 

private void requestStoragePermission() {
	String[] permissions = new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE };
	if (!hasStoragePermission()) {
		Log.e(TAG, "No storage permission at the moment. Requesting...");
		ActivityCompat.requestPermissions(this, permissions, REQUEST_STORAGE);
	} else {
		Log.e(TAG, "We already have storage permission. Yay!");
		// new image is about to be saved
		if (mPendingImageUrlToSave != null)
			saveImageToDisk(mPendingImageUrlToSave);
	}
}