Access File Location Android Permission Read From Disk

Overview

By default, an Android app starts with zero permissions granted to it. When the app needs to use any of the protected features of the device (sending network requests, accessing the camera, sending an SMS, etc) information technology must obtain the appropriate permission from the user to exercise so.

Before Marshmallow, permissions were handled at install-time and specified in the AndroidManifest.xml within the project. Full list of permissions can be establish here. After Marshmallow, permissions must now be requested at runtime before beingness used. There are a number of libraries available to make runtime permissions easier. If you to get started quickly, bank check out our guide on managing runtime permissions with PermissionsDispatcher.

Permissions before Marshmallow

Permissions were much simpler before Marshmallow (API 23). All permissions were handled at install-time. When a user went to install an app from the Google Play Store, the user was presented a list of permissions that the app required (some people referred to this equally a "wall of permissions". The user could either accept all the permissions and go along to install the app or determine not to install the app. It was an all or aught approach. In that location was no way to grant only sure permissions to the app and no way for the user to revoke certain permissions afterward the app was installed.

Instance of pre-Marshmallow permissions requested by the Dropbox app:

For an app developer, permissions were very uncomplicated. To request one of the many permissions, simply specify it in the AndroidManifest.xml:

For instance, an awarding that needs to read the user's contacts would add the post-obit to information technology's AndroidManifest.xml:

                      <manifest            xmlns:android=            "http://schemas.android.com/apk/res/android"            packet=            "com.android.app.myapp"            >            <uses-permission            android:proper name=            "android.permission.READ_CONTACTS"            />            ...            </manifest>                  

That's all there was to it. The user had no mode of changing permissions, even subsequently installing the app. This made it easy for developers to bargain with permissions, only wasn't the best user experience.

Permission Updates in Marshmallow

Marshmallow brought big changes to the permissions model. It introduced the concept of runtime permissions. These are permissions that are requested while the app is running (instead of before the app is installed). These permission tin can then exist immune or denied by the user. For canonical permissions, these can besides be revoked at a later time.

This ways in that location are a couple more things to consider when working with permissions for a Marshmallow app. Proceed in mind that your targetSdkVersion must be >= 23 and your emulator / device must be running Marshmallow to see the new permissions model. If this isn't the case, meet the backwards compatibility section to empathize how permissions will deport on your configuration.

Normal Permissions

When you need to add a new permission, first check this page to see if the permission is considered a PROTECTION_NORMAL permission. In Marshmallow, Google has designated certain permissions to be "rubber" and called these "Normal Permissions". These are things like ACCESS_NETWORK_STATE, Internet, etc. which can't practice much damage. Normal permissions are automatically granted at install time and never prompt the user asking for permission.

Important: Normal Permissions must be added to the AndroidManifest:

                      <manifest            xmlns:android=            "http://schemas.android.com/apk/res/android"            package=            "com.android.app.myapp"            >            <uses-permission            android:proper name=            "android.permission.INTERNET"            />            ...            </manifest>                  

Runtime Permissions

If the permission you need to add isn't listed under the normal permissions, y'all'll need to deal with "Runtime Permissions". Runtime permissions are permissions that are requested equally they are needed while the app is running. These permissions volition show a dialog to the user, similar to the following i:

The first pace when adding a "Runtime Permission" is to add it to the AndroidManifest:

                      <manifest            xmlns:android=            "http://schemas.android.com/apk/res/android"            bundle=            "com.codepath.androidpermissionsdemo"            >            <uses-permission            android:proper noun=            "android.permission.READ_CONTACTS"            />            ...            </manifest>                  

Side by side, you lot'll need to initiate the permission request and handle the result. The following code shows how to exercise this in the context of an Activity, but this is also possible from within a Fragment.

                      // MainActivity.java            public            class            MainActivity            extends            AppCompatActivity            {            @Override            protected            void            onCreate            (            Bundle            savedInstanceState            )            {            super            .            onCreate            (            savedInstanceState            );            setContentView            (            R            .            layout            .            activity_main            );            // In an actual app, y'all'd desire to asking a permission when the user performs an action            // that requires that permission.            getPermissionToReadUserContacts            ();            }            // Identifier for the permission request            private            static            terminal            int            READ_CONTACTS_PERMISSIONS_REQUEST            =            1            ;            // Called when the user is performing an activity which requires the app to read the            // user'due south contacts            public            void            getPermissionToReadUserContacts            ()            {            // 1) Use the support library version ContextCompat.checkSelfPermission(...) to avert            // checking the build version since Context.checkSelfPermission(...) is only available            // in Marshmallow            // 2) E'er bank check for permission (fifty-fifty if permission has already been granted)            // since the user can revoke permissions at whatsoever fourth dimension through Settings            if            (            ContextCompat            .            checkSelfPermission            (            this            ,            Manifest            .            permission            .            READ_CONTACTS            )            !=            PackageManager            .            PERMISSION_GRANTED            )            {            // The permission is NOT already granted.            // Check if the user has been asked well-nigh this permission already and denied            // it. If and then, we want to give more explanation virtually why the permission is needed.            if            (            shouldShowRequestPermissionRationale            (            Manifest            .            permission            .            READ_CONTACTS            ))            {            // Testify our own UI to explain to the user why we demand to read the contacts            // before actually requesting the permission and showing the default UI            }            // Burn down off an async request to really go the permission            // This will evidence the standard permission asking dialog UI            requestPermissions            (            new            String            []{            Manifest            .            permission            .            READ_CONTACTS            },            READ_CONTACTS_PERMISSIONS_REQUEST            );            }            }            // Callback with the request from calling requestPermissions(...)            @Override            public            void            onRequestPermissionsResult            (            int            requestCode            ,            @NonNull            String            permissions            [],            @NonNull            int            []            grantResults            )            {            // Make sure it's our original READ_CONTACTS request            if            (            requestCode            ==            READ_CONTACTS_PERMISSIONS_REQUEST            )            {            if            (            grantResults            .            length            ==            1            &&            grantResults            [            0            ]            ==            PackageManager            .            PERMISSION_GRANTED            )            {            Toast            .            makeText            (            this            ,            "Read Contacts permission granted"            ,            Toast            .            LENGTH_SHORT            ).            prove            ();            }            else            {            // showRationale = false if user clicks Never Ask Again, otherwise true            boolean            showRationale            =            shouldShowRequestPermissionRationale            (            this            ,            Manifest            .            permission            .            READ_CONTACTS            );            if            (            showRationale            )            {            // exercise something here to handle degraded manner            }            else            {            Toast            .            makeText            (            this            ,            "Read Contacts permission denied"            ,            Toast            .            LENGTH_SHORT            ).            show            ();            }            }            }            else            {            super            .            onRequestPermissionsResult            (            requestCode            ,            permissions            ,            grantResults            );            }            }            }                  

Permission Groups

Permission Groups avoids spamming the user with a lot of permission requests while assuasive the app developer to merely asking the minimal corporeality of permissions needed at any point in time.

Related permissions are grouped into one of the permission groups. When an app requests a permission that belongs to a particular permission grouping (i.east. READ_CONTACTS), Android asks the user most the higher level group instead (CONTACTS). This way when the app later needs the WRITE_CONTACTS permission, Android tin automatically grant this itself without prompting the user.

In nigh of your interaction with the permission API's you'll exist working with the individual permissions and not the permission groups, simply pay close attending to what the API expects as both permissions and permission groups are Strings.

Backwards Compatibility

There are ii main scenarios to think about when information technology comes to backwards compatibility:

1. Your app is targeting an API less than Marshmallow (TargetSdkVersion < 23), but the emulator / device is Marshmallow:
   • Your app will continue to utilize the erstwhile permissions model.
   • All permissions listed in the AndroidManifest will exist asked for at install time.
   • Users will exist able to revoke permissions later on the app is installed. It'south of import to test this scenario since the results of sure deportment without the appropriate permission can be unexpected.
2. The emulator / device is running something older than Marshmallow, simply you app targets Marshmallow (TargetSdkVersion >= 23):
   • Your app will continue to use the old permissions model.
   • All permissions listed in the AndroidManifest will be asked for at install time.

How to Ask For Permissions

Google recommends in this video that there are four patterns to consider when thinking almost permissions:

Each pattern dictates a different fashion of requesting permissions. For case, when requesting for critical only unclear permissions, utilize a warm welcome screen to aid sympathize a permission is requested. For critical permissions, such as a photographic camera app that needs photographic camera permission, ask up-front for it. Secondary features can be requested later in context, such as a geotagging app when asking for a location permission. For permissions that are secondary and unclear, you should include a rationale caption if you actually demand them.

Storage permissions

Rethink virtually whether you need read/write storage permissions (i.e. android.permission.WRITE_EXTERNAL_STORAGE or android.permission.READ_EXTERNAL_STORAGE), which requite you all files on the SD carte. Instead, you lot should use methods on Context to access package-specific directories on external storage. Your app always accept access to read/write to these directories,and then there is no need to permissions to asking it:

                      // Application-specific call that doesn't require external storage permissions            // Tin exist Environment.DIRECTORY_PICTURES, Environment.DIRECTORY_PODCASTS, Surround.DIRECTORY_RINGTONES,                        // Environment.DIRECTORY_NOTIFICATIONS, Environment.DIRECTORY_PICTURES, or Surround.MOVIES            File            dir            =            MyActivity            .            this            .            getExternalFilesDir            (            Environment            .            DIRECTORY_PICTURES            );                  

Managing Permissions using ADB

Permissions can also be managed on the command-line using adb with the following commands.

Show all Android permissions:

                      $            adb shell pm listing permissions -d -g        

Dumping app permission state:

                      $adb            shell dumpsys package com.PackageName.enterprise        

Granting and revoking runtime permissions:

                      $adb            shell pm grant com.PackageName.enterprise some.permission.Proper name            $adb            shell pm revoke com.PackageName.enterprise android.permission.READ_CONTACTS        

Installing an app with all permissions granted:

                      $adb            install -g myAPP.apk        

References

• http://developer.android.com/guide/topics/security/permissions.html
• http://developer.android.com/preview/features/runtime-permissions.html
• https://github.com/googlesamples/android-RuntimePermissions

norrisbusiouty1960.blogspot.com

Source: https://guides.codepath.com/android/Understanding-App-Permissions

Share this post