Permissions

Android Permissions Beginning with Android 6.0 (Marshmallow, API level 23), users must grant certain permissions to an application at runtime, not simply when the application is installed. Streamlines the application installation process Gives the user more control over the application’s functionality user can grant some permissions and deny others User can revoke the permissions at any time e.g., by going to the application’s Settings screen But … This approach complicates things for application developers. ©SoftMoore Consulting

Normal and Dangerous Permissions System permissions are divided into several protection levels, but from a developer perspective, the two most important protection levels are normal and dangerous permissions. Normal permissions require access to data or resources outside the application, but they pose very little risk to the user’s privacy or the operation of other applications. e.g., set an alarm or access the internet Dangerous permissions cover areas where an application needs data or resources that involve the user’s private information or that could potentially affect the operation of other applications. e.g., access to the user’s location or contact information ©SoftMoore Consulting

Declaring Permissions in the Manifest Regardless of whether a permission is categorized as normal or dangerous, all permissions needed by an application must be declared in the manifest. <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="edu.citadel.android.permission"> <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.CALL_PHONE" /> <application ... <activity </activity> </application> </manifest> ©SoftMoore Consulting

Checking for Permissions An application that needs a dangerous permission must check whether that permission is granted every time it performs an operation that requires that permission. Even if a permission was granted previously, the user can still revoke the permission by going to the application’s Settings screen. To check if an application has a permission, call method ContextCompat.checkSelfPermission(). ©SoftMoore Consulting

Checking for Permissions (continued) Example int permissionCheck = ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE); if (permissionCheck == PackageManager.PERMISSION_GRANTED) { makeCall(); } If the application does not have the permission, this method returns PERMISSION_DENIED, and the application must explicitly ask the user for permission. ©SoftMoore Consulting

Requesting Permissions If an application doesn’t already have the permission it needs, it can call requestPermissions() to request the appropriate permissions. The application passes an array of the permissions it wants to request plus an integer request code to identify this permission request. The requestPermissions() method functions asynchronously. method returns immediately system presents a dialog box to the user ©SoftMoore Consulting

Permission Groups All dangerous permissions belong to permission groups. Examples Permission group CONTACTS includes permissions READ_CONTACTS, WRITE_CONTACTS, and GET_ACCOUNTS. Permission group PHONE includes permissions READ_PHONE_STATE, CALL_PHONE, READ_CALL_LOG, etc. An application requests a specific permission, but the system dialog box requests permission for an entire group; i.e., it does not describe the specific permission within the group that is being requested. If the user grants permission, then all permissions within the group are granted. ©SoftMoore Consulting

Example: Requesting Permissions private static final int PERMISSION_REQUEST_CALL_PHONE = 100; ... // must check for permissions at runtime before placing a call int permissionCheck = ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE); if (permissionCheck == PackageManager.PERMISSION_GRANTED) { makeCall(); } else // request the permission ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, PERMISSION_REQUEST_CALL_PHONE); passes an array of requests so that more than one permission can be requested at the same time ©SoftMoore Consulting

Example: Requesting Permissions (continued) ©SoftMoore Consulting

Handling the Response to the Permission Request When the user responds to a permissions dialog request, the system invokes the application’s onRequestPermissionsResult() method, passing it the user’s response and the request code that was initially passed to requestPermissions(). An application will need to override method onRequestPermissionsResult() to find out whether the permission was granted. ©SoftMoore Consulting

Example: Handling the Response to the Permission Request @Override public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) { if (requestCode == PERMISSION_REQUEST_CALL_PHONE) if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) makeCall(); } else ... // notify user that permission was denied value passed to method requestPermissions() ©SoftMoore Consulting

Permission Request Rationale In some circumstances, you might want to help the user understand why an application needs a certain dangerous permission. One approach is to provide an explanation only if the user has already turned down that permission request. To help in these situations where the user might need an explanation, Android provides a utility method, shouldShowRequestPermissionRationale(). returns true if the app has requested this permission previously and the user denied the request usually called in method onRequestPermissionResult() if the permission was not granted ©SoftMoore Consulting

Example: Permission Request Rationale private void checkCallPhonePermission() { int permissionCheck = ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE); if (permissionCheck == PackageManager.PERMISSION_GRANTED) ... } else if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CALL_PHONE)) ... // show explanation asynchronously; do not block UI thread ... // call method ActivityCompat.requestPermissions() after checking if permission has been granted but before requesting the permission ©SoftMoore Consulting

Example: Permission Request Rationale (continued) private void checkCallPhonePermission() { // must check for permissions at runtime before placing a call int permissionCheck = ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE); if (permissionCheck == PackageManager.PERMISSION_GRANTED) makeCall(); } else if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CALL_PHONE)) // show explanation asynchronously -- do not block ui thread String message = " ... "; Toast toast = Toast.makeText(MainActivity.this, message, Toast.LENGTH_LONG); toast.show(); // request the permission ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, PERMISSION_REQUEST_CALL_PHONE); ©SoftMoore Consulting

Permission Usage Notes Try not to overwhelm the user with permission requests. Consider using an intent. Rather than have an application perform a task, use an intent to ask another application to perform the task, and get results from the other application. Ask only for the permissions needed. Explain why the permissions are needed by the application; e.g., in a Toast or Snackbar, or in a separate tutorial. ©SoftMoore Consulting

Making a Phone Call in Android /** * Initiates a telephone call to the specified phone number. */ private void makeCall() { try Uri uri = Uri.parse("tel:" + phoneNumToCall); Intent intent = new Intent(Intent.ACTION_CALL, uri); startActivity(intent); } catch (SecurityException ex) String errorMsg = "No permission to make phone call."; Log.e(LOG_TAG, errorMsg, ex); ©SoftMoore Consulting

Making a Phone Call in Android (continiued) ©SoftMoore Consulting

Relevant Links Normal and Dangerous Permissions Normal Permissions https://developer.android.com/guide/topics/permissions/requesting.html#normal-dangerous Normal Permissions https://developer.android.com/guide/topics/permissions/normal-permissions.html Requesting Permissions at Run Time https://developer.android.com/training/permissions/requesting.html Permissions Usage Notes https://developer.android.com/training/permissions/usage-notes.html Android Runtime Permissions Request Tutorial http://www.truiton.com/2016/04/obtaining-runtime-permissions-android-marshmallow-6-0/ ©SoftMoore Consulting