コード例 #1
0
 private void requestPermissionForCameraAndMicrophone() {
   if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)
       || ActivityCompat.shouldShowRequestPermissionRationale(
           this, Manifest.permission.RECORD_AUDIO)) {
     Toast.makeText(this, R.string.permissions_needed, Toast.LENGTH_LONG).show();
   } else {
     ActivityCompat.requestPermissions(
         this,
         new String[] {Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO},
         CAMERA_MIC_PERMISSION_REQUEST_CODE);
   }
 }
コード例 #2
0
ファイル: Preffrag.java プロジェクト: Nilpo/AmazeFileManager
  private void requestGplusPermission() {
    final String[] PERMISSIONS = {Manifest.permission.GET_ACCOUNTS, Manifest.permission.INTERNET};
    if (ActivityCompat.shouldShowRequestPermissionRationale(
            getActivity(), Manifest.permission.GET_ACCOUNTS)
        || ActivityCompat.shouldShowRequestPermissionRationale(
            getActivity(), Manifest.permission.INTERNET)) {
      // 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 request has been denied previously.

      String fab_skin = (BaseActivity.accentSkin);
      final MaterialDialog materialDialog =
          Futils.showBasicDialog(
              getActivity(),
              fab_skin,
              theme,
              new String[] {
                getResources().getString(R.string.grantgplus),
                getResources().getString(R.string.grantper),
                getResources().getString(R.string.grant),
                getResources().getString(R.string.cancel),
                null
              });
      materialDialog
          .getActionButton(DialogAction.POSITIVE)
          .setOnClickListener(
              new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                  ActivityCompat.requestPermissions(getActivity(), PERMISSIONS, 66);
                  materialDialog.dismiss();
                }
              });
      materialDialog
          .getActionButton(DialogAction.NEGATIVE)
          .setOnClickListener(
              new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                  getActivity().finish();
                }
              });
      materialDialog.setCancelable(false);
      materialDialog.show();

    } else {
      // Contact permissions have not been granted yet. Request them directly.
      ActivityCompat.requestPermissions(getActivity(), PERMISSIONS, 66);
    }
  }
コード例 #3
0
ファイル: WallAdapter.java プロジェクト: WunderEye/H2Icons
 private void checkForStoragePermission(int position, SimpleItemViewHolder holder) {
   if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)
       == PackageManager.PERMISSION_GRANTED) {
     getWallpaper(position);
   } else {
     if (ActivityCompat.shouldShowRequestPermissionRationale(
         (Activity) context, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
       Snackbar.make(
               holder.mainView, R.string.permission_storage_rationale, Snackbar.LENGTH_INDEFINITE)
           .setAction(
               R.string.ok,
               new View.OnClickListener() {
                 @Override
                 public void onClick(View view) {
                   ActivityCompat.requestPermissions(
                       (Activity) context,
                       new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
                       REQUEST_STORAGE);
                 }
               })
           .show();
     } else {
       reqPos = position;
       ActivityCompat.requestPermissions(
           ((Activity) context),
           new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
           REQUEST_STORAGE);
     }
   }
 }
コード例 #4
0
ファイル: Fragment2.java プロジェクト: aremox/LaMora-a
 /**
  * Check if we have the GET_ACCOUNTS permission and request it if we do not.
  *
  * @return true if we have the permission, false if we do not.
  */
 private boolean checkAccountsPermission() {
   final String perm = Manifest.permission.GET_ACCOUNTS;
   int permissionCheck = ContextCompat.checkSelfPermission(getContext(), perm);
   if (permissionCheck == PackageManager.PERMISSION_GRANTED) {
     // We have the permission
     return true;
   } else if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(), perm)) {
     // Need to show permission rationale, display a snackbar and then request
     // the permission again when the snackbar is dismissed.
     Snackbar.make(
             recViewLogin.findViewById(R.id.login_layout),
             R.string.contacts_permission_rationale,
             Snackbar.LENGTH_INDEFINITE)
         .setAction(
             android.R.string.ok,
             new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                 // Request the permission again.
                 ActivityCompat.requestPermissions(
                     getActivity(), new String[] {perm}, RC_PERM_GET_ACCOUNTS);
               }
             })
         .show();
     return false;
   } else {
     // No explanation needed, we can request the permission.
     ActivityCompat.requestPermissions(getActivity(), new String[] {perm}, RC_PERM_GET_ACCOUNTS);
     return false;
   }
 }
コード例 #5
0
  private void getPermission() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.GET_ACCOUNTS)
        != PackageManager.PERMISSION_GRANTED) {

      if (ActivityCompat.shouldShowRequestPermissionRationale(
          this, Manifest.permission.GET_ACCOUNTS)) {

        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Permission Request");
        builder.setMessage(
            "To bring you timely alerts we would require few permissions such as account details. Please grant the permissions to continue using these features");
        builder.setPositiveButton(
            "OK",
            new DialogInterface.OnClickListener() {
              @Override
              public void onClick(DialogInterface dialogInterface, int i) {
                dialogInterface.dismiss();
                ActivityCompat.requestPermissions(
                    MainActivity.this,
                    new String[] {Manifest.permission.GET_ACCOUNTS},
                    MY_PERMISSIONS_REQUEST_GET_ACCOUNTS);
              }
            });
        builder.create().show();

      } else {
        ActivityCompat.requestPermissions(
            this,
            new String[] {Manifest.permission.GET_ACCOUNTS},
            MY_PERMISSIONS_REQUEST_GET_ACCOUNTS);
      }
    } else {
      setupUser();
    }
  }
コード例 #6
0
  void startAvatarTaker() {
    int permissionCheck =
        ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.CAMERA);

    if (permissionCheck == PackageManager.PERMISSION_DENIED) {
      // Should we show an explanation?
      if (ActivityCompat.shouldShowRequestPermissionRationale(
          getActivity(), Manifest.permission.CAMERA)) {

        // Show an expanation to the user *asynchronously* -- don't block
        // this thread waiting for the user's response! After the user
        // sees the explanation, try again to request the permission.
        Snackbar.make(mView, R.string.grant_perms, Snackbar.LENGTH_LONG).show();
      } else {

        // No explanation needed, we can request the permission.

        ActivityCompat.requestPermissions(
            getActivity(),
            new String[] {Manifest.permission.CAMERA},
            MY_PERMISSIONS_REQUEST_CAMERA);

        // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
        // app-defined int constant. The callback method gets the
        // result of the request.
      }
    } else {

      startActivityForResult(getPickImageChooserIntent(), 200);
    }
  }
コード例 #7
0
    @Override
    public void onPermissionsDenied(
        @NonNull String[] grantedPermissions,
        @NonNull String[] deniedPermissions,
        @NonNull String[] declinedPermissions) {
      MainSettingsActivity activity = mMainSettingsActivityWeakReference.get();
      if (activity == null) return;
      // if the result is DENIED and the OS says "do not show rationale", it means the user has
      // ticked "Don't ask me again".
      final boolean userSaysDontAskAgain =
          !ActivityCompat.shouldShowRequestPermissionRationale(
              activity, Manifest.permission.READ_CONTACTS);
      // the user has denied us from reading the Contacts information.
      // I'll ask them to whether they want to grant anyway, or disable ContactDictionary
      AlertDialog.Builder builder = new AlertDialog.Builder(activity);
      builder.setCancelable(true);
      builder.setIcon(R.drawable.ic_notification_contacts_permission_required);
      builder.setTitle(R.string.notification_read_contacts_title);
      builder.setMessage(activity.getString(R.string.contacts_permissions_dialog_message));
      builder.setPositiveButton(
          activity.getString(
              userSaysDontAskAgain
                  ? R.string.navigate_to_app_permissions
                  : R.string.allow_permission),
          activity.mContactsDictionaryDialogListener);
      builder.setNegativeButton(
          activity.getString(R.string.turn_off_contacts_dictionary),
          activity.mContactsDictionaryDialogListener);

      if (activity.mAlertDialog != null && activity.mAlertDialog.isShowing())
        activity.mAlertDialog.dismiss();
      activity.mAlertDialog = builder.create();
      activity.mAlertDialog.show();
    }
コード例 #8
0
ファイル: MainActivity.java プロジェクト: itamar6587/TCMP_L7
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Log.d(TAG, "MainActivity  - onCreate");

    // Check that the Permission to read From External storage - if the checkselfPermission is null
    // than it means that the user has clicked on "Never Ask me again".
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)
        != PackageManager.PERMISSION_GRANTED) {
      // Check if we should show the Permission RAtional behind the reason we are asking for the
      // Permissions
      if (ActivityCompat.shouldShowRequestPermissionRationale(
          this, Manifest.permission.READ_EXTERNAL_STORAGE)) {
        // Show a Fragment that explains why I need this permission
      } else {
        ActivityCompat.requestPermissions(
            this,
            new String[] {Manifest.permission.READ_EXTERNAL_STORAGE},
            READ_EXTERNAL_STORAGE_REQUEST_CODE);
      }
    }

    // Create the List from Storage
    getExternalRootFolderList();

    // Conect the Fragment to the Activity
    listFragment = new FolderViewFragment();
    getSupportFragmentManager()
        .beginTransaction()
        .add(R.id.fragment_container, listFragment)
        .commit();
  }
コード例 #9
0
  /**
   * 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 not granted, requesting...");

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

    if (!ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
      Log.d(TAG, "We do not need to show permission rationale");
      ActivityCompat.requestPermissions(this, permissions, RC_HANDLE_CAMERA_PERM);
      return;
    }

    final Activity thisActivity = this;

    Log.i(TAG, "Showing Request Permissions Rationale");
    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(android.R.string.ok, listener)
        .show();
  }
コード例 #10
0
ファイル: ToolbarActivity.java プロジェクト: GDR/SearchView
 @SuppressWarnings("SameParameterValue")
 private void perm(String permission, int permission_request) {
   if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
     if (!ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
       ActivityCompat.requestPermissions(this, new String[] {permission}, permission_request);
     }
   }
 }
コード例 #11
0
  public static boolean shouldShowRationale(Activity activity, String... permissions) {
    for (String permission : permissions) {
      if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
        return true;
      }
    }

    return false;
  }
コード例 #12
0
 public void requestInternetPermission() {
   if (ActivityCompat.shouldShowRequestPermissionRationale(
       activity, Manifest.permission.INTERNET)) {
     permissionCallback.onPermissionExplanationRequired(true, Manifest.permission.INTERNET);
   } else {
     ActivityCompat.requestPermissions(
         activity, new String[] {Manifest.permission.INTERNET}, INTERNET_PERMISSION);
   }
 }
コード例 #13
0
 /**
  * Requests the fine location permission. If a rationale with an additional explanation should be
  * shown to the user, displays a dialog that triggers the request.
  */
 public static void requestPermission(
     AppCompatActivity activity, int requestId, String permission, boolean finishActivity) {
   if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
     // Display a dialog with rationale.
     RationaleDialog.newInstance(requestId, finishActivity)
         .show(activity.getSupportFragmentManager(), "dialog");
   } else {
     // Location permission has not been granted yet, request it.
     ActivityCompat.requestPermissions(activity, new String[] {permission}, requestId);
   }
 }
コード例 #14
0
 public void requestExternalStoragePermission() {
   if (ActivityCompat.shouldShowRequestPermissionRationale(
       activity, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
     permissionCallback.onPermissionExplanationRequired(
         true, Manifest.permission.WRITE_EXTERNAL_STORAGE);
   } else {
     ActivityCompat.requestPermissions(
         activity,
         new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
         EXTERNAL_STORAGE_PERMISSION);
   }
 }
コード例 #15
0
ファイル: Home.java プロジェクト: HKMOpen/KAM
 private void requestPermission() {
   if (ActivityCompat.shouldShowRequestPermissionRationale(
           this, Manifest.permission.READ_EXTERNAL_STORAGE)
       || ActivityCompat.shouldShowRequestPermissionRationale(
           this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
     Snackbar.make(
             mainContent,
             "Permission is required to continue using this " + "function!",
             Snackbar.LENGTH_INDEFINITE)
         .setAction(
             "Okay",
             new View.OnClickListener() {
               @Override
               public void onClick(View view) {
                 ActivityCompat.requestPermissions(Home.this, EXTERNAL_STORAGE, REQUEST_STORAGE);
               }
             })
         .show();
   } else {
     ActivityCompat.requestPermissions(this, EXTERNAL_STORAGE, REQUEST_STORAGE);
   }
 }
コード例 #16
0
ファイル: PermissionUtils.java プロジェクト: Zankio/CCULife
  public static boolean checkPermission(Activity activity, String permission, int code) {
    if (ContextCompat.checkSelfPermission(activity, permission)
        != PackageManager.PERMISSION_GRANTED) {

      if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
        ActivityCompat.requestPermissions(activity, new String[] {permission}, code);
      } else {
        ActivityCompat.requestPermissions(activity, new String[] {permission}, code);
      }
      return false;
    }
    return true;
  }
コード例 #17
0
 /** Convenience method to ask user to grant permissions. */
 @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
 protected void requestPermissions() {
   boolean shouldShowRationale =
       ActivityCompat.shouldShowRequestPermissionRationale(
               this, Manifest.permission.READ_EXTERNAL_STORAGE)
           || ActivityCompat.shouldShowRequestPermissionRationale(
               this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
           || ActivityCompat.shouldShowRequestPermissionRationale(
               this, Manifest.permission.RECORD_AUDIO);
   if (shouldShowRationale) {
     CommonUtils.getInstance().showMessage(R.string.Grant_necessary_permissions);
   } else {
     ActivityCompat.requestPermissions(
         this,
         new String[] {
           Manifest.permission.READ_EXTERNAL_STORAGE,
           Manifest.permission.WRITE_EXTERNAL_STORAGE,
           Manifest.permission.RECORD_AUDIO
         },
         MY_PERMISSIONS_REQUEST);
   }
 }
コード例 #18
0
 public void requestExternalStoragePermission(
     AppCompatActivity appCompatActivity, PermissionCallback callback, boolean requestFromDialog) {
   if (ActivityCompat.shouldShowRequestPermissionRationale(
           appCompatActivity, Manifest.permission.WRITE_EXTERNAL_STORAGE)
       && !requestFromDialog) {
     callback.onPermissionExplanationRequired(true, Manifest.permission.WRITE_EXTERNAL_STORAGE);
   } else {
     ActivityCompat.requestPermissions(
         appCompatActivity,
         new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
         EXTERNAL_STORAGE_PERMISSION);
   }
 }
コード例 #19
0
 @Override
 protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);
   if (savedInstanceState == null) {
     if (ActivityCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO)
             == PackageManager.PERMISSION_GRANTED
         && ActivityCompat.checkSelfPermission(this, Manifest.permission.MODIFY_AUDIO_SETTINGS)
             == PackageManager.PERMISSION_GRANTED) {
       openFragment();
     } else {
       if (ActivityCompat.shouldShowRequestPermissionRationale(
               this, Manifest.permission.RECORD_AUDIO)
           || ActivityCompat.shouldShowRequestPermissionRationale(
               this, Manifest.permission.MODIFY_AUDIO_SETTINGS)) {
         AlertDialog.OnClickListener onClickListener =
             new DialogInterface.OnClickListener() {
               @Override
               public void onClick(DialogInterface dialog, int which) {
                 if (which == DialogInterface.BUTTON_POSITIVE) {
                   requestPermissions();
                 } else if (which == DialogInterface.BUTTON_NEGATIVE) {
                   permissionsNotGranted();
                 }
               }
             };
         new AlertDialog.Builder(this)
             .setTitle(getString(R.string.title_permissions))
             .setMessage(Html.fromHtml(getString(R.string.message_permissions)))
             .setPositiveButton(getString(R.string.btn_next), onClickListener)
             .setNegativeButton(getString(R.string.btn_cancel), onClickListener)
             .show();
       } else {
         requestPermissions();
       }
     }
   }
 }
コード例 #20
0
 private void requestLocationPermission() {
   if (checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION)
       != PackageManager.PERMISSION_GRANTED) {
     if (!ActivityCompat.shouldShowRequestPermissionRationale(
         this, Manifest.permission.ACCESS_COARSE_LOCATION)) {
       // User Denied and selected "Don't ask again" --> Show info that he needs to go to settings
       showSettingsDialog();
     } else {
       ActivityCompat.requestPermissions(
           this, MainActivity.PERMISSIONS_LOCATION, MainActivity.REQUEST_LOCATION);
     }
   } else {
     Snackbar.make(mLayout, "You already have this permission, FOOL!", Snackbar.LENGTH_SHORT);
   }
 }
コード例 #21
0
  private void requestNetworkStatePermission() {
    // Permission has not been granted and must be requested.

    /**
     * if (ActivityCompat.shouldShowRequestPermissionRationale(this,
     * Manifest.permission.ACCESS_NETWORK_STATE)) { // 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. // Display a SnackBar with a button to request the missing
     * permission. Snackbar.make(mLayout, "Permission Access Network State is Required.",
     * Snackbar.LENGTH_INDEFINITE).setAction("OK", new View.OnClickListener() { @Override public
     * void onClick(View view) { // Request the permission
     * ActivityCompat.requestPermissions(MainActivity.this, new
     * String[]{Manifest.permission.ACCESS_NETWORK_STATE}, PERMISSION_REQUEST_NETWORK_STATE); }
     * }).show();
     *
     * <p>} else { Snackbar.make(mLayout, "Permission Access Network State is not available.
     * Requesting permission.", Snackbar.LENGTH_SHORT).show(); // Request the permission. The result
     * will be received in onRequestPermissionResult(). ActivityCompat.requestPermissions(this, new
     * String[]{Manifest.permission.ACCESS_NETWORK_STATE}, PERMISSION_REQUEST_NETWORK_STATE); }
     */
    if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.INTERNET)) {
      // 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.
      // Display a SnackBar with a button to request the missing permission.
      Snackbar.make(mLayout, "Permission Internet is Required.", Snackbar.LENGTH_INDEFINITE)
          .setAction(
              "OK",
              new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                  // Request the permission
                  ActivityCompat.requestPermissions(
                      MainActivity.this,
                      new String[] {Manifest.permission.INTERNET},
                      PERMISSION_REQUEST_INTERNET);
                }
              })
          .show();

    } else {
      Snackbar.make(
              mLayout, "Internet is not available. Requesting permission.", Snackbar.LENGTH_SHORT)
          .show();
      // Request the permission. The result will be received in onRequestPermissionResult().
      ActivityCompat.requestPermissions(
          this, new String[] {Manifest.permission.INTERNET}, PERMISSION_REQUEST_INTERNET);
    }
  }
コード例 #22
0
 /** Fires the permission rationale dialog or the permission request dialog. */
 private void firePermissionRequest() {
   String locationPermission = Manifest.permission.ACCESS_FINE_LOCATION;
   if (mRationaleDialog == null) {
     boolean rationale =
         ActivityCompat.shouldShowRequestPermissionRationale(this, locationPermission);
     if (rationale) {
       // Show the rationale dialog
       mRationaleDialog =
           new AlertDialog.Builder(this)
               .setTitle(R.string.later_location_rationale_title)
               .setMessage(R.string.later_location_rationale)
               .setPositiveButton(R.string.later_location_rationale_button, this)
               .setOnCancelListener(this)
               .create();
       mRationaleDialog.show();
     } else {
       if (SharedPreferencesManager.isFirstLocationPermissionRequest(this)) {
         // Request permissions
         SharedPreferencesManager.locationPermissionRequested(this);
         ActivityCompat.requestPermissions(
             this, new String[] {locationPermission}, LOCATION_PERMISSION_RC);
         mRationaleDialog = null;
       } else {
         // If this is not the first time but rationale is false, it means that the
         //  user has tapped never ask again. In this case, if the user really
         //  wants this feature he will have to go to settings and enable location
         //  manually, otherwise, this will not work at all.
         mLocationDisabledDialog =
             new AlertDialog.Builder(this)
                 .setTitle(R.string.later_location_disabled_title)
                 .setMessage(R.string.later_location_disabled)
                 .setPositiveButton(R.string.later_location_disabled_button_positive, this)
                 .setNegativeButton(R.string.later_location_disabled_button_negative, this)
                 .setOnCancelListener(this)
                 .create();
         mLocationDisabledDialog.show();
       }
     }
   } else {
     // Request permissions
     SharedPreferencesManager.locationPermissionRequested(this);
     ActivityCompat.requestPermissions(
         this, new String[] {locationPermission}, LOCATION_PERMISSION_RC);
     mRationaleDialog = null;
   }
 }
コード例 #23
0
 private boolean checkForPermissions() {
   int canI = ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE);
   if (canI != PackageManager.PERMISSION_GRANTED) {
     if (ActivityCompat.shouldShowRequestPermissionRationale(
         this, Manifest.permission.READ_EXTERNAL_STORAGE)) {
       // Show an expanation to the user *asynchronously* -- don't block
       // this thread waiting for the user's response! After the user
       // sees the explanation, try again to request the permission.
     } else {
       // No explanation needed, we can request the permission.
       ActivityCompat.requestPermissions(
           this, new String[] {Manifest.permission.READ_EXTERNAL_STORAGE}, 33);
       // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
       // app-defined int constant. The callback method gets the
       // result of the request.
     }
     return false;
   }
   return true;
 }
コード例 #24
0
 @Override
 public void onClick(DialogInterface dialog, final int which) {
   switch (which) {
     case DialogInterface.BUTTON_POSITIVE:
       if (ActivityCompat.shouldShowRequestPermissionRationale(
           MainSettingsActivity.this, Manifest.permission.READ_CONTACTS)) {
         startContactsPermissionRequest();
       } else {
         startAppPermissionsActivity();
       }
       break;
     case DialogInterface.BUTTON_NEGATIVE:
       SharedPreferences sharedPreferences =
           PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
       final SharedPreferences.Editor editor = sharedPreferences.edit();
       editor.putBoolean(getString(R.string.settings_key_use_contacts_dictionary), false);
       SharedPreferencesCompat.EditorCompat.getInstance().apply(editor);
       break;
   }
 }
コード例 #25
0
  private void requestPermission() {

    // Permission has not been granted and must be requested.
    if (ActivityCompat.shouldShowRequestPermissionRationale(
        mActivity, Manifest.permission.ACCESS_FINE_LOCATION)) {

      ActivityCompat.requestPermissions(
          mActivity, new String[] {Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSION_REQUEST);

    } else {

      if (mOnPermissionListener != null) {
        mOnPermissionListener.OnPermissionChanged(false);
      }

      // Request the permission. The result will be received in onRequestPermissionResult().
      ActivityCompat.requestPermissions(
          mActivity, new String[] {Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSION_REQUEST);
    }
  }
コード例 #26
0
  /**
   * Request a set of permissions, showing rationale if the system requests it.
   *
   * @param activity Activity requesting permissions. Should implement {@link
   *     android.support.v4.app.ActivityCompat.OnRequestPermissionsResultCallback}
   * @param rationale a message explaining why the application needs this set of permissions, will
   *     be displayed if the user rejects the request the first time.
   * @param requestCode request code to track this request, must be < 256.
   * @param perms a set of permissions to be requested.
   */
  public static void requestPermissions(
      final Activity activity, String rationale, final int requestCode, final String... perms) {
    // Check if all permissions were already granted.
    if (hasPermissions(activity.getApplicationContext(), perms)) {
      return;
    }

    boolean shouldShowRationale = false;
    for (String perm : perms) {
      shouldShowRationale =
          shouldShowRationale
              || ActivityCompat.shouldShowRequestPermissionRationale(activity, perm);
    }

    if (shouldShowRationale) {
      AlertDialog dialog =
          new AlertDialog.Builder(activity)
              .setMessage(rationale)
              .setPositiveButton(
                  android.R.string.ok,
                  new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                      executePermissionsRequest(activity, perms, requestCode);
                    }
                  })
              .setNegativeButton(
                  android.R.string.cancel,
                  new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                      // Do nothing, user does not want to request
                    }
                  })
              .create();
      dialog.show();
    } else {
      executePermissionsRequest(activity, perms, requestCode);
    }
  }
コード例 #27
0
ファイル: Utility.java プロジェクト: ChampIsMe/NsureAndroid
 @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
 public static boolean checkPermission(final Context context) {
   int currentAPIVersion = Build.VERSION.SDK_INT;
   if (currentAPIVersion >= android.os.Build.VERSION_CODES.M) {
     if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_EXTERNAL_STORAGE)
         != PackageManager.PERMISSION_GRANTED) {
       if (ActivityCompat.shouldShowRequestPermissionRationale(
           (Activity) context, Manifest.permission.READ_EXTERNAL_STORAGE)) {
         AlertDialog.Builder alertBuilder = new AlertDialog.Builder(context);
         alertBuilder.setCancelable(true);
         alertBuilder.setTitle("Permission necessary");
         alertBuilder.setMessage("External storage permission is necessary");
         alertBuilder.setPositiveButton(
             android.R.string.yes,
             new DialogInterface.OnClickListener() {
               @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
               public void onClick(DialogInterface dialog, int which) {
                 ActivityCompat.requestPermissions(
                     (Activity) context,
                     new String[] {Manifest.permission.READ_EXTERNAL_STORAGE},
                     MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE);
               }
             });
         AlertDialog alert = alertBuilder.create();
         alert.show();
       } else {
         ActivityCompat.requestPermissions(
             (Activity) context,
             new String[] {Manifest.permission.READ_EXTERNAL_STORAGE},
             MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE);
       }
       return false;
     } else {
       return true;
     }
   } else {
     return true;
   }
 }
コード例 #28
0
  @Override
  public void onRequestPermissionsResult(
      int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if (requestCode != PERMISSIONS_REQUEST_CODE) {
      return;
    }

    for (int i = 0; i < permissions.length; i++) {
      String permission = permissions[i];
      if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
        if (ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
          Log.i(TAG, "Permission denied without 'NEVER ASK AGAIN': " + permission);
          showRequestPermissionsSnackbar();
        } else {
          Log.i(TAG, "Permission denied with 'NEVER ASK AGAIN': " + permission);
          showLinkToSettingsSnackbar();
        }
      } else {
        Log.i(TAG, "Permission granted, do something");
      }
    }
  }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.fragment_tabs_pager);
    mTabHost = (TabHost) findViewById(android.R.id.tabhost);
    mTabHost.setup();

    ViewPager mViewPager = (ViewPager) findViewById(R.id.pager);

    mTabsAdapter = new TabsAdapter(this, mTabHost, mViewPager);

    mTabsAdapter.addTab(mTabHost.newTabSpec("Corona").setIndicator("Corona"), CoronaFragment.class);

    // Based on: http://developer.android.com/training/permissions/requesting.html#perm-request
    // Check for the READ_CONTACTS permission before trying
    // to make a CursorLoader with the contact list.
    int readContactsPermissionState =
        ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS);
    if (readContactsPermissionState == PackageManager.PERMISSION_DENIED) {
      // Should we show an explanation?
      if (ActivityCompat.shouldShowRequestPermissionRationale(
          this, Manifest.permission.READ_CONTACTS)) {

        // Show an explanation to the user *asynchronously* -- don't block
        // this thread waiting for the user's response! After the user
        // sees the explanation, try again to request the permission.
        final FragmentActivity thisActivity = this;
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        DialogInterface.OnClickListener requestClickListener =
            new DialogInterface.OnClickListener() {
              @Override
              public void onClick(DialogInterface arg0, int which) {
                // Request the READ_CONTACTS permission!
                ActivityCompat.requestPermissions(
                    thisActivity,
                    new String[] {Manifest.permission.READ_CONTACTS},
                    READ_CONTACTS_REQUEST_CODE);
              }
            };

        // Compose the message for this alert.
        builder.setTitle("Corona Cards Tabs Sample Needs Permission");
        builder.setMessage(
            "To make the native tab for this sample, access to the "
                + "device's Contacts is needed! Request access now?");
        builder.setPositiveButton("Request", requestClickListener);
        builder.setNegativeButton(android.R.string.cancel, null);
        AlertDialog readContactsRationaleDialog = builder.create();
        readContactsRationaleDialog.setCanceledOnTouchOutside(false);
        readContactsRationaleDialog.show();

      } else {
        // Request the READ_CONTACTS permission!
        ActivityCompat.requestPermissions(
            this, new String[] {Manifest.permission.READ_CONTACTS}, READ_CONTACTS_REQUEST_CODE);
      }
    } else {
      // We're safe to create the native tab.
      createNativeTab();
    }

    if (savedInstanceState != null) {
      mTabHost.setCurrentTabByTag(savedInstanceState.getString("tab"));
    }
  }
コード例 #30
0
  public void checkIn(View view) {
    boolean gps_enabled = false;
    boolean network_enabled = false;

    int permissionCheck =
        ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION);

    LocationManager lm = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
    try {
      gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
    } catch (Exception ex) {
    }

    try {
      network_enabled = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    } catch (Exception ex) {
    }

    if (!gps_enabled || !network_enabled) {
      AlertDialog.Builder dialog = new AlertDialog.Builder(this);
      dialog.setMessage("GPS and/or network connection not enabled, please enable to continue");
      dialog.setPositiveButton(
          "Location settings",
          new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int parameter) {
              Intent inte = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
              startActivity(inte);
            }
          });
      dialog.setNegativeButton(
          "Cancel",
          new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int parameter) {}
          });
      dialog.show();
    } else {
      if (currentapiVersion >= android.os.Build.VERSION_CODES.M) {
        if (permissionCheck == PackageManager.PERMISSION_DENIED) {
          if (ActivityCompat.shouldShowRequestPermissionRationale(
              this, Manifest.permission.ACCESS_FINE_LOCATION)) {

            // Show an expanation to the user *asynchronously* -- don't block
            // this thread waiting for the user's response! After the user
            // sees the explanation, try again to request the permission.

          } else {
            ActivityCompat.requestPermissions(
                this,
                new String[] {Manifest.permission.ACCESS_FINE_LOCATION},
                MY_PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
          }
        } else {
          initGPS();
          finishTracking();
        }
      } else {
        initGPS();
        finishTracking();
      }
    }
  }