├── CONTRIBUTING.md
├── settings.gradle
├── gradle
    └── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
├── easypermissions
    ├── proguard-rules.pro
    ├── src
    │   ├── main
    │   │   ├── java
    │   │   │   └── pub
    │   │   │   │   └── devrel
    │   │   │   │       └── easypermissions
    │   │   │   │           ├── helper
    │   │   │   │               ├── package-info.java
    │   │   │   │               ├── SupportFragmentPermissionHelper.java
    │   │   │   │               ├── AppCompatActivityPermissionsHelper.java
    │   │   │   │               ├── LowApiPermissionsHelper.java
    │   │   │   │               ├── BaseSupportPermissionsHelper.java
    │   │   │   │               ├── ActivityPermissionHelper.java
    │   │   │   │               └── PermissionHelper.java
    │   │   │   │           ├── AfterPermissionGranted.java
    │   │   │   │           ├── AppSettingsDialogHolderActivity.java
    │   │   │   │           ├── RationaleDialogClickListener.java
    │   │   │   │           ├── RationaleDialogConfig.java
    │   │   │   │           ├── RationaleDialogFragmentCompat.java
    │   │   │   │           ├── RationaleDialogFragment.java
    │   │   │   │           ├── PermissionRequest.java
    │   │   │   │           ├── AppSettingsDialog.java
    │   │   │   │           └── EasyPermissions.java
    │   │   ├── res
    │   │   │   └── values
    │   │   │   │   ├── colors.xml
    │   │   │   │   ├── strings.xml
    │   │   │   │   └── styles.xml
    │   │   └── AndroidManifest.xml
    │   └── test
    │   │   └── java
    │   │       └── pub
    │   │           └── devrel
    │   │               └── easypermissions
    │   │                   ├── testhelper
    │   │                       ├── TestActivity.java
    │   │                       ├── TestSupportFragmentActivity.java
    │   │                       ├── ActivityController.java
    │   │                       ├── FragmentController.java
    │   │                       ├── TestAppCompatActivity.java
    │   │                       └── TestFragment.java
    │   │                   ├── EasyPermissionsLowApiTest.java
    │   │                   ├── RationaleDialogClickListenerTest.java
    │   │                   ├── AppSettingsDialogTest.java
    │   │                   └── EasyPermissionsTest.java
    ├── gradle.properties
    └── build.gradle
├── app
    ├── src
    │   └── main
    │   │   ├── res
    │   │       ├── mipmap-hdpi
    │   │       │   └── ic_launcher.png
    │   │       ├── mipmap-mdpi
    │   │       │   └── ic_launcher.png
    │   │       ├── mipmap-xhdpi
    │   │       │   └── ic_launcher.png
    │   │       ├── mipmap-xxhdpi
    │   │       │   └── ic_launcher.png
    │   │       ├── mipmap-xxxhdpi
    │   │       │   └── ic_launcher.png
    │   │       ├── values
    │   │       │   ├── colors.xml
    │   │       │   ├── dimens.xml
    │   │       │   ├── styles.xml
    │   │       │   └── strings.xml
    │   │       ├── values-w820dp
    │   │       │   └── dimens.xml
    │   │       └── layout
    │   │       │   ├── fragment_main.xml
    │   │       │   ├── activity_basic.xml
    │   │       │   └── activity_main.xml
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── pub
    │   │           └── devrel
    │   │               └── easypermissions
    │   │                   └── sample
    │   │                       ├── MainFragment.java
    │   │                       └── MainActivity.java
    ├── proguard-rules.pro
    └── build.gradle
├── .gitignore
├── .github
    ├── ISSUE_TEMPLATE.md
    └── workflows
    │   └── test.yml
├── gradle.properties
├── PUBLISHING.md
├── gradlew.bat
├── gradlew
├── README.md
└── LICENSE


/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | Not Found
2 | 


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app', ':easypermissions'
2 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googlesamples/easypermissions/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/easypermissions/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | -keepclassmembers class * {
2 |     @pub.devrel.easypermissions.AfterPermissionGranted <methods>;
3 | }
4 | 


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googlesamples/easypermissions/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googlesamples/easypermissions/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googlesamples/easypermissions/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googlesamples/easypermissions/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googlesamples/easypermissions/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/helper/package-info.java:
--------------------------------------------------------------------------------
1 | @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
2 | package pub.devrel.easypermissions.helper;
3 | 
4 | import androidx.annotation.RestrictTo;
5 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="colorPrimary">#3F51B5</color>
4 |     <color name="colorPrimaryDark">#303F9F</color>
5 |     <color name="colorAccent">#FF4081</color>
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <!-- Default screen margins, per the Android Design guidelines. -->
3 |     <dimen name="activity_horizontal_margin">16dp</dimen>
4 |     <dimen name="activity_vertical_margin">16dp</dimen>
5 | </resources>
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Gradle files
 2 | .gradle
 3 | build
 4 | 
 5 | # Local configuration file (sdk path, etc)
 6 | local.properties
 7 | 
 8 | # IntelliJ project files
 9 | **.iml
10 | .idea
11 | 
12 | # Android Studio captures folder
13 | captures/
14 | 
15 | # Misc
16 | .DS_Store
17 | .classpath
18 | .project
19 | .settings
20 | .vscode
21 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <!-- Use system defaults for devs not using AppCompat -->
4 |     <color name="colorPrimary">#ff212121</color>
5 |     <color name="colorPrimaryDark">@android:color/black</color>
6 |     <color name="colorAccent">#ff80cbc4</color>
7 | </resources>
8 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | ## Basic Information
 2 | 
 3 | Device type: ________
 4 | OS version: ________
 5 | EasyPermissions version: ________
 6 | 
 7 | ## Describe the problem
 8 | 
 9 | What happened?  What did you expect to happen?
10 | 
11 | ## Code and logs
12 | 
13 | ```
14 | // TODO(you): show the code that produces the problem,
15 | //            and any relevant logs.
16 | ```
17 | 


--------------------------------------------------------------------------------
/app/src/main/res/values-w820dp/dimens.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <!-- Example customization of dimensions originally defined in res/values/dimens.xml
3 |          (such as screen margins) for screens with more than 820dp of available width. This
4 |          would include 7" and 10" devices in landscape (~960dp and ~1280dp respectively). -->
5 |     <dimen name="activity_horizontal_margin">64dp</dimen>
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | name: test
 2 | 
 3 | on:
 4 |   - pull_request
 5 |   - push
 6 | 
 7 | jobs:
 8 |   build:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - uses: actions/checkout@v2
12 |       - name: set up JDK 1.8
13 |         uses: actions/setup-java@v1
14 |         with:
15 |           java-version: 1.8
16 |       - name: Build with Gradle
17 |         run: |
18 |           ./gradlew build :easypermissions:test
19 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 |     <!-- Base application theme. -->
 4 |     <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
 5 |         <!-- Customize your theme here. -->
 6 |         <item name="colorPrimary">@color/colorPrimary</item>
 7 |         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
 8 |         <item name="colorAccent">@color/colorAccent</item>
 9 |     </style>
10 | 
11 | </resources>
12 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="rationale_ask">This app may not work correctly without the requested permissions.</string>
3 |     <string name="rationale_ask_again">
4 |         This app may not work correctly without the requested permissions.
5 |         Open the app settings screen to modify app permissions.
6 |     </string>
7 |     <string name="title_settings_dialog">Permissions Required</string>
8 | </resources>
9 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/fragment_main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <FrameLayout
 3 |     xmlns:android="http://schemas.android.com/apk/res/android"
 4 |     android:layout_width="wrap_content"
 5 |     android:layout_height="wrap_content">
 6 | 
 7 |     <Button
 8 |         android:id="@+id/button_sms"
 9 |         android:layout_width="wrap_content"
10 |         android:layout_height="wrap_content"
11 |         android:text="@string/sms" />
12 | 
13 | </FrameLayout>
14 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest
 3 |     xmlns:android="http://schemas.android.com/apk/res/android"
 4 |     package="pub.devrel.easypermissions">
 5 | 
 6 |     <application>
 7 |         <activity
 8 |             android:name="pub.devrel.easypermissions.AppSettingsDialogHolderActivity"
 9 |             android:exported="false"
10 |             android:label=""
11 |             android:theme="@style/EasyPermissions.Transparent"/>
12 |     </application>
13 | 
14 | </manifest>
15 | 


--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_basic.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout
 3 |     xmlns:android="http://schemas.android.com/apk/res/android"
 4 |     xmlns:tools="http://schemas.android.com/tools"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent"
 7 |     android:orientation="vertical"
 8 |     tools:context=".BasicActivity">
 9 | 
10 |     <Button
11 |         android:id="@+id/button_request"
12 |         android:layout_width="wrap_content"
13 |         android:layout_height="wrap_content"
14 |         android:text="Request"
15 |         tools:ignore="HardcodedText"/>
16 | 
17 | </LinearLayout>
18 | 


--------------------------------------------------------------------------------
/easypermissions/gradle.properties:
--------------------------------------------------------------------------------
 1 | GROUP=pub.devrel
 2 | POM_ARTIFACT_ID=easypermissions
 3 | VERSION_NAME=3.0.0
 4 | 
 5 | POM_NAME=EasyPermissions
 6 | POM_PACKAGING=aar
 7 | 
 8 | POM_DESCRIPTION=A wrapper library for basic Android M system permissions logic
 9 | 
10 | POM_URL=https://github.com/googlesamples/easypermissions
11 | POM_SCM_URL=https://github.com/googlesamples/easypermissions
12 | POM_SCM_CONNECTION=https://github.com/googlesamples/easypermissions.git
13 | 
14 | POM_LICENCE_NAME=The Apache Software License, Version 2.0
15 | POM_LICENCE_URL=http://www.apache.org/licenses/LICENSE-2.0.txt
16 | POM_LICENCE_DIST=repo
17 | 
18 | POM_DEVELOPER_NAME=Google
19 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 | 
 4 |     <style name="EasyPermissions" parent="Theme.AppCompat.DayNight.DarkActionBar">
 5 |         <item name="colorPrimary">@color/colorPrimary</item>
 6 |         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
 7 |         <item name="colorAccent">@color/colorAccent</item>
 8 |     </style>
 9 | 
10 |     <style name="EasyPermissions.Transparent">
11 |         <item name="android:windowIsTranslucent">true</item>
12 |         <item name="android:windowBackground">@android:color/transparent</item>
13 |         <item name="android:windowContentOverlay">@null</item>
14 |         <item name="android:windowNoTitle">true</item>
15 |         <item name="android:windowIsFloating">true</item>
16 |         <item name="android:backgroundDimEnabled">false</item>
17 |     </style>
18 | 
19 | </resources>
20 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 |     <string name="app_name">Easy Permissions</string>
 3 |     <string name="yes">Yes</string>
 4 |     <string name="no">No</string>
 5 | 
 6 |     <string name="rationale_camera">This app needs access to your camera so you can take pictures.</string>
 7 |     <string name="rationale_location_contacts">This app needs access to your location and contacts to know where and who you are.</string>
 8 |     <string name="rationale_sms">This app needs access to your sms to read all your great messages.</string>
 9 |     <string name="returned_from_app_settings_to_activity">
10 |         Returned from app settings to MainActivity with the following permissions:
11 |         \n\nCamera: %s
12 |         \nLocation &amp; Contacts: %s
13 |         \nSMS: %s
14 |     </string>
15 |     <string name="camera">Camera</string>
16 |     <string name="location_and_contacts">Location and Contacts</string>
17 |     <string name="sms">SMS</string>
18 | </resources>
19 | 


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | 
 3 | # IDE (e.g. Android Studio) users:
 4 | # Gradle settings configured through the IDE *will override*
 5 | # any settings specified in this file.
 6 | 
 7 | # For more details on how to configure your build environment visit
 8 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 9 | 
10 | # Specifies the JVM arguments used for the daemon process.
11 | # The setting is particularly useful for tweaking memory settings.
12 | org.gradle.jvmargs=-Xmx1536m
13 | 
14 | # When configured, Gradle will run in incubating parallel mode.
15 | # This option should only be used with decoupled projects. More details, visit
16 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
17 | # org.gradle.parallel=true
18 | 
19 | # Configure on demand
20 | org.gradle.configureondemand=true
21 | 
22 | # Required by Robolectric 4.x
23 | #android.enableUnitTestBinaryResources=true
24 | 
25 | # Move transitive dependencies to AndroidX
26 | android.useAndroidX=true
27 | android.enableJetifier=true
28 | 


--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
 1 | apply plugin: 'com.android.application'
 2 | 
 3 | android {
 4 |     compileSdkVersion 30
 5 |     testOptions.unitTests.includeAndroidResources = true
 6 | 
 7 |     defaultConfig {
 8 |         applicationId "pub.devrel.easypermissions.sample"
 9 |         minSdkVersion 14
10 |         targetSdkVersion 30
11 |         versionCode 1
12 |         versionName "1.0"
13 |     }
14 | 
15 |     buildTypes {
16 |         release {
17 |             minifyEnabled true
18 |             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
19 |         }
20 |     }
21 | 
22 |     compileOptions {
23 |         // Flag to enable support for the new language APIs
24 |         coreLibraryDesugaringEnabled false
25 |         // Sets Java compatibility to Java 8
26 |         sourceCompatibility JavaVersion.VERSION_1_8
27 |         targetCompatibility JavaVersion.VERSION_1_8
28 |     }
29 | }
30 | 
31 | dependencies {
32 |     implementation 'androidx.appcompat:appcompat:1.1.0'
33 |     implementation "androidx.annotation:annotation:1.1.0"
34 |     implementation project(':easypermissions')
35 | }
36 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/AfterPermissionGranted.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Google Inc. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package pub.devrel.easypermissions;
17 | 
18 | import java.lang.annotation.ElementType;
19 | import java.lang.annotation.Retention;
20 | import java.lang.annotation.RetentionPolicy;
21 | import java.lang.annotation.Target;
22 | 
23 | @Retention(RetentionPolicy.RUNTIME)
24 | @Target(ElementType.METHOD)
25 | public @interface AfterPermissionGranted {
26 | 
27 |     int value();
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestActivity.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.testhelper;
 2 | 
 3 | import android.app.Activity;
 4 | 
 5 | import java.util.List;
 6 | 
 7 | import androidx.annotation.NonNull;
 8 | import pub.devrel.easypermissions.AfterPermissionGranted;
 9 | import pub.devrel.easypermissions.EasyPermissions;
10 | 
11 | public class TestActivity extends Activity
12 |         implements EasyPermissions.PermissionCallbacks, EasyPermissions.RationaleCallbacks {
13 | 
14 |     public static final int REQUEST_CODE = 1;
15 | 
16 |     @Override
17 |     public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
18 | 
19 |     }
20 | 
21 |     @Override
22 |     public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
23 | 
24 |     }
25 | 
26 |     @AfterPermissionGranted(REQUEST_CODE)
27 |     public void afterPermissionGranted() {
28 | 
29 |     }
30 | 
31 |     @Override
32 |     public void onRationaleAccepted(int requestCode) {
33 | 
34 |     }
35 | 
36 |     @Override
37 |     public void onRationaleDenied(int requestCode) {
38 | 
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/helper/SupportFragmentPermissionHelper.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.helper;
 2 | 
 3 | import android.content.Context;
 4 | import androidx.annotation.NonNull;
 5 | import androidx.fragment.app.Fragment;
 6 | import androidx.fragment.app.FragmentManager;
 7 | 
 8 | /**
 9 |  * Permissions helper for {@link Fragment} from the support library.
10 |  */
11 | class SupportFragmentPermissionHelper extends BaseSupportPermissionsHelper<Fragment> {
12 | 
13 |     public SupportFragmentPermissionHelper(@NonNull Fragment host) {
14 |         super(host);
15 |     }
16 | 
17 |     @Override
18 |     public FragmentManager getSupportFragmentManager() {
19 |         return getHost().getChildFragmentManager();
20 |     }
21 | 
22 |     @Override
23 |     public void directRequestPermissions(int requestCode, @NonNull String... perms) {
24 |         getHost().requestPermissions(perms, requestCode);
25 |     }
26 | 
27 |     @Override
28 |     public boolean shouldShowRequestPermissionRationale(@NonNull String perm) {
29 |         return getHost().shouldShowRequestPermissionRationale(perm);
30 |     }
31 | 
32 |     @Override
33 |     public Context getContext() {
34 |         return getHost().getActivity();
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest
 3 |     xmlns:android="http://schemas.android.com/apk/res/android"
 4 |     xmlns:tools="http://schemas.android.com/tools"
 5 |     package="pub.devrel.easypermissions.sample">
 6 | 
 7 |     <uses-permission android:name="android.permission.CAMERA" />
 8 | 
 9 |     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
10 |     <uses-permission android:name="android.permission.READ_CONTACTS" />
11 | 
12 |     <uses-permission android:name="android.permission.READ_SMS" />
13 |     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
14 | 
15 |     <application
16 |         android:label="@string/app_name"
17 |         android:allowBackup="true"
18 |         android:icon="@mipmap/ic_launcher"
19 |         android:supportsRtl="true"
20 |         android:theme="@style/AppTheme"
21 |         tools:ignore="AllowBackup,GoogleAppIndexingWarning">
22 | 
23 |         <activity android:name=".MainActivity">
24 |             <intent-filter>
25 |                 <action android:name="android.intent.action.MAIN" />
26 | 
27 |                 <category android:name="android.intent.category.LAUNCHER" />
28 |             </intent-filter>
29 |         </activity>
30 | 
31 |     </application>
32 | 
33 | </manifest>
34 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/helper/AppCompatActivityPermissionsHelper.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.helper;
 2 | 
 3 | import android.content.Context;
 4 | import androidx.annotation.NonNull;
 5 | import androidx.core.app.ActivityCompat;
 6 | import androidx.fragment.app.FragmentManager;
 7 | import androidx.appcompat.app.AppCompatActivity;
 8 | 
 9 | /**
10 |  * Permissions helper for {@link AppCompatActivity}.
11 |  */
12 | class AppCompatActivityPermissionsHelper extends BaseSupportPermissionsHelper<AppCompatActivity> {
13 | 
14 |     public AppCompatActivityPermissionsHelper(AppCompatActivity host) {
15 |         super(host);
16 |     }
17 | 
18 |     @Override
19 |     public FragmentManager getSupportFragmentManager() {
20 |         return getHost().getSupportFragmentManager();
21 |     }
22 | 
23 |     @Override
24 |     public void directRequestPermissions(int requestCode, @NonNull String... perms) {
25 |         ActivityCompat.requestPermissions(getHost(), perms, requestCode);
26 |     }
27 | 
28 |     @Override
29 |     public boolean shouldShowRequestPermissionRationale(@NonNull String perm) {
30 |         return ActivityCompat.shouldShowRequestPermissionRationale(getHost(), perm);
31 |     }
32 | 
33 |     @Override
34 |     public Context getContext() {
35 |         return getHost();
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout
 3 |     xmlns:android="http://schemas.android.com/apk/res/android"
 4 |     xmlns:tools="http://schemas.android.com/tools"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent"
 7 |     android:orientation="vertical"
 8 |     android:paddingBottom="@dimen/activity_vertical_margin"
 9 |     android:paddingLeft="@dimen/activity_horizontal_margin"
10 |     android:paddingRight="@dimen/activity_horizontal_margin"
11 |     android:paddingTop="@dimen/activity_vertical_margin">
12 | 
13 |     <Button
14 |         android:id="@+id/button_camera"
15 |         android:layout_width="wrap_content"
16 |         android:layout_height="wrap_content"
17 |         android:text="@string/camera" />
18 | 
19 |     <Button
20 |         android:id="@+id/button_location_and_contacts"
21 |         android:layout_width="wrap_content"
22 |         android:layout_height="wrap_content"
23 |         android:text="@string/location_and_contacts" />
24 | 
25 |     <fragment
26 |         android:id="@+id/fragment"
27 |         android:name="pub.devrel.easypermissions.sample.MainFragment"
28 |         android:layout_width="wrap_content"
29 |         android:layout_height="wrap_content"
30 |         tools:layout="@layout/fragment_main" />
31 | 
32 | </LinearLayout>
33 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestSupportFragmentActivity.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.testhelper;
 2 | 
 3 | import android.os.Bundle;
 4 | 
 5 | import java.util.List;
 6 | 
 7 | import androidx.annotation.NonNull;
 8 | import androidx.annotation.Nullable;
 9 | import androidx.fragment.app.FragmentActivity;
10 | import pub.devrel.easypermissions.AfterPermissionGranted;
11 | import pub.devrel.easypermissions.EasyPermissions;
12 | 
13 | public class TestSupportFragmentActivity extends FragmentActivity
14 |         implements EasyPermissions.PermissionCallbacks, EasyPermissions.RationaleCallbacks {
15 | 
16 |     public static final int REQUEST_CODE = 5;
17 | 
18 |     @Override
19 |     protected void onCreate(@Nullable Bundle savedInstanceState) {
20 |       super.onCreate(savedInstanceState);
21 |     }
22 | 
23 |     @Override
24 |     public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
25 | 
26 |     }
27 | 
28 |     @Override
29 |     public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
30 | 
31 |     }
32 | 
33 |     @AfterPermissionGranted(REQUEST_CODE)
34 |     public void afterPermissionGranted() {
35 | 
36 |     }
37 | 
38 |     @Override
39 |     public void onRationaleAccepted(int requestCode) {
40 | 
41 |     }
42 | 
43 |     @Override
44 |     public void onRationaleDenied(int requestCode) {
45 | 
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/ActivityController.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.testhelper;
 2 | 
 3 | import android.app.Activity;
 4 | 
 5 | import androidx.annotation.NonNull;
 6 | import androidx.test.core.app.ActivityScenario;
 7 | 
 8 | import java.util.concurrent.CompletableFuture;
 9 | import java.util.concurrent.ExecutionException;
10 | 
11 | /**
12 |  * Helper class to allow starting Activity, similar to the Robolectric ActivityConroller.
13 |  */
14 | public class ActivityController<T extends Activity> {
15 | 
16 |     private ActivityScenario<T> scenario;
17 | 
18 |     public ActivityController(Class<T> clazz) {
19 |         scenario = ActivityScenario.launch(clazz);
20 |     }
21 | 
22 |     public synchronized T resume() {
23 |         final CompletableFuture<T> ActivityFuture = new CompletableFuture<>();
24 | 
25 |         scenario.onActivity(new ActivityScenario.ActivityAction<T>() {
26 |             @Override
27 |             public void perform(@NonNull T activity) {
28 |                 ActivityFuture.complete(activity);
29 |             }
30 |         });
31 | 
32 |         try {
33 |             return ActivityFuture.get();
34 |         } catch (InterruptedException e) {
35 |             throw new RuntimeException(e);
36 |         } catch (ExecutionException e) {
37 |             throw new RuntimeException(e);
38 |         }
39 |     }
40 | 
41 |     public void reset() {
42 |         scenario.recreate();
43 |     }
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/FragmentController.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.testhelper;
 2 | 
 3 | import androidx.annotation.NonNull;
 4 | import androidx.fragment.app.Fragment;
 5 | import androidx.fragment.app.testing.FragmentScenario;
 6 | 
 7 | import java.util.concurrent.CompletableFuture;
 8 | import java.util.concurrent.ExecutionException;
 9 | 
10 | /**
11 |  * Helper class to allow starting Fragments, similar to the old SupportFragmentController.
12 |  */
13 | public class FragmentController<T extends Fragment> {
14 | 
15 |     private FragmentScenario<T> scenario;
16 | 
17 |     public FragmentController(Class<T> clazz) {
18 |         scenario = FragmentScenario.launch(clazz);
19 |     }
20 | 
21 |     public synchronized T resume() {
22 |         final CompletableFuture<T> fragmentFuture = new CompletableFuture<>();
23 | 
24 |         scenario.onFragment(new FragmentScenario.FragmentAction<T>() {
25 |             @Override
26 |             public void perform(@NonNull T fragment) {
27 |                 fragmentFuture.complete(fragment);
28 |             }
29 |         });
30 | 
31 |         try {
32 |             return fragmentFuture.get();
33 |         } catch (InterruptedException e) {
34 |             throw new RuntimeException(e);
35 |         } catch (ExecutionException e) {
36 |             throw new RuntimeException(e);
37 |         }
38 |     }
39 | 
40 |     public void reset() {
41 |         scenario.recreate();
42 |     }
43 | 
44 | }
45 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestAppCompatActivity.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.testhelper;
 2 | 
 3 | import android.os.Bundle;
 4 | 
 5 | import java.util.List;
 6 | 
 7 | import androidx.annotation.NonNull;
 8 | import androidx.annotation.Nullable;
 9 | import androidx.appcompat.app.AppCompatActivity;
10 | import pub.devrel.easypermissions.AfterPermissionGranted;
11 | import pub.devrel.easypermissions.EasyPermissions;
12 | import pub.devrel.easypermissions.R;
13 | 
14 | public class TestAppCompatActivity extends AppCompatActivity
15 |         implements EasyPermissions.PermissionCallbacks, EasyPermissions.RationaleCallbacks {
16 | 
17 |     public static final int REQUEST_CODE = 3;
18 | 
19 |     @Override
20 |     protected void onCreate(@Nullable Bundle savedInstanceState) {
21 |         getTheme().applyStyle(R.style.Theme_AppCompat, true);
22 |         super.onCreate(savedInstanceState);
23 |     }
24 | 
25 |     @Override
26 |     public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
27 | 
28 |     }
29 | 
30 |     @Override
31 |     public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
32 | 
33 |     }
34 | 
35 |     @AfterPermissionGranted(REQUEST_CODE)
36 |     public void afterPermissionGranted() {
37 | 
38 |     }
39 | 
40 |     @Override
41 |     public void onRationaleAccepted(int requestCode) {
42 | 
43 |     }
44 | 
45 |     @Override
46 |     public void onRationaleDenied(int requestCode) {
47 | 
48 |     }
49 | 
50 | }
51 | 


--------------------------------------------------------------------------------
/easypermissions/build.gradle:
--------------------------------------------------------------------------------
 1 | apply plugin: 'com.android.library'
 2 | 
 3 | // See: https://github.com/vanniktech/gradle-maven-publish-plugin/issues/206
 4 | ext {
 5 |   RELEASE_REPOSITORY_URL = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
 6 |   SNAPSHOT_REPOSITORY_URL = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
 7 | }
 8 | 
 9 | apply plugin: 'com.vanniktech.maven.publish'
10 | 
11 | android {
12 |     compileSdkVersion 30
13 |     testOptions.unitTests.includeAndroidResources = true
14 | 
15 |     defaultConfig {
16 |         minSdkVersion 14
17 |         targetSdkVersion 30
18 |         versionCode 1
19 |         versionName "3.0.0"
20 |     }
21 | 
22 |     buildTypes {
23 |         debug {
24 |             testCoverageEnabled true
25 |         }
26 |         release {
27 |             minifyEnabled false
28 |             consumerProguardFiles 'proguard-rules.pro'
29 |         }
30 |     }
31 | 
32 |     testOptions {
33 |         unitTests {
34 |             includeAndroidResources = true
35 |         }
36 |     }
37 | 
38 | }
39 | 
40 | dependencies {
41 |     api "androidx.appcompat:appcompat:1.1.0"
42 |     api "androidx.annotation:annotation:1.1.0"
43 |     api "androidx.core:core:1.3.0"
44 |     api "androidx.fragment:fragment:1.2.5"
45 | 
46 |     testImplementation 'junit:junit:4.13'
47 |     testImplementation 'com.google.truth:truth:0.42'
48 |     testImplementation 'org.robolectric:robolectric:4.1'
49 |     testImplementation 'androidx.test:core:1.3.0-rc01'
50 |     testImplementation 'androidx.fragment:fragment-testing:1.2.5'
51 |     testImplementation 'org.mockito:mockito-core:2.23.4'
52 | }
53 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/testhelper/TestFragment.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.testhelper;
 2 | 
 3 | import android.os.Bundle;
 4 | import android.view.LayoutInflater;
 5 | import android.view.View;
 6 | import android.view.ViewGroup;
 7 | 
 8 | import java.util.List;
 9 | 
10 | import androidx.annotation.NonNull;
11 | import androidx.annotation.Nullable;
12 | import androidx.fragment.app.Fragment;
13 | import pub.devrel.easypermissions.AfterPermissionGranted;
14 | import pub.devrel.easypermissions.EasyPermissions;
15 | import pub.devrel.easypermissions.R;
16 | 
17 | public class TestFragment extends Fragment
18 |         implements EasyPermissions.PermissionCallbacks, EasyPermissions.RationaleCallbacks {
19 | 
20 |     public static final int REQUEST_CODE = 4;
21 | 
22 |     @Nullable
23 |     @Override
24 |     public View onCreateView(@NonNull LayoutInflater inflater,
25 |                              @Nullable ViewGroup container,
26 |                              @Nullable Bundle savedInstanceState) {
27 |         getContext().getTheme().applyStyle(R.style.Theme_AppCompat, true);
28 |         return super.onCreateView(inflater, container, savedInstanceState);
29 |     }
30 | 
31 |     @Override
32 |     public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
33 | 
34 |     }
35 | 
36 |     @Override
37 |     public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
38 | 
39 |     }
40 | 
41 |     @AfterPermissionGranted(REQUEST_CODE)
42 |     public void afterPermissionGranted() {
43 | 
44 |     }
45 | 
46 |     @Override
47 |     public void onRationaleAccepted(int requestCode) {
48 | 
49 |     }
50 | 
51 |     @Override
52 |     public void onRationaleDenied(int requestCode) {
53 | 
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/PUBLISHING.md:
--------------------------------------------------------------------------------
 1 | ## Publishing
 2 | 
 3 | ### Credentials
 4 | 
 5 | The library is published to Maven Central by the firebase-sonatype account, Googlers can find the
 6 | password for this account in [Valentine](http://valentine/)
 7 | 
 8 | ### GPG Key
 9 | 
10 | You will need to create a private GPG keyring on your machine, if you don't have one do the
11 | following steps:
12 | 
13 |   1. Run `gpg --full-generate-key`
14 |   1. Choose `RSA and RSA` for the key type
15 |   1. Use `4096` for the key size
16 |   1. Use `0` for the expiration (never)
17 |   1. Use any name, email address, and password
18 | 
19 | This creates your key in `~/.gnupg/openpgp-revocs.d/` with `.rev` format. The last 8 characters
20 | before the `.rev` extension are your **Key ID**.
21 | 
22 | To export the key, run:
23 | 
24 | ```
25 | gpg --export-secret-keys -o $HOME/sonatype.gpg
26 | ```
27 | 
28 | Finally upload your key to the keyserver:
29 | 
30 | ```
31 | gpg --keyserver hkp://keys.openpgp.org --send-keys <YOUR KEY ID>
32 | ```
33 | 
34 | ### Local Properties
35 | 
36 | Open your `$HOME/.gradle/gradle.properties` file at and fill in the values:
37 | 
38 | ```
39 | signing.keyId=<KEY ID>
40 | signing.password=<PASSWORD YOU CHOSE>
41 | signing.secretKeyRingFile=<FULL PATH TO YOUR GPG FILE>
42 | mavenCentralRepositoryUsername=firebase-sonatype
43 | mavenCentralRepositoryUsername=<PASSWORD FROM VALENTINE>
44 | ```
45 | 
46 | ### Publish
47 | 
48 | To publish, run:
49 | 
50 | ```
51 | ./gradlew publish
52 | ```
53 | 
54 | ### Release
55 | 
56 | Follow [the instructions here](https://central.sonatype.org/pages/releasing-the-deployment.html):
57 | 
58 |   1. Navigate to https://s01.oss.sonatype.org/ and **Log In**
59 |   1. On the left side click **Build Promotion** and look for the `com.firebase` repo
60 |   1. Click **Close** ... wait a few minutes (you can check status with **Refresh**)
61 |   1. Click **Release**
62 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/helper/LowApiPermissionsHelper.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.helper;
 2 | 
 3 | import android.app.Activity;
 4 | import android.content.Context;
 5 | import androidx.annotation.NonNull;
 6 | import androidx.annotation.StyleRes;
 7 | import androidx.fragment.app.Fragment;
 8 | 
 9 | /**
10 |  * Permissions helper for apps built against API < 23, which do not need runtime permissions.
11 |  */
12 | class LowApiPermissionsHelper<T> extends PermissionHelper<T> {
13 |     public LowApiPermissionsHelper(@NonNull T host) {
14 |         super(host);
15 |     }
16 | 
17 |     @Override
18 |     public void directRequestPermissions(int requestCode, @NonNull String... perms) {
19 |         throw new IllegalStateException("Should never be requesting permissions on API < 23!");
20 |     }
21 | 
22 |     @Override
23 |     public boolean shouldShowRequestPermissionRationale(@NonNull String perm) {
24 |         return false;
25 |     }
26 | 
27 |     @Override
28 |     public void showRequestPermissionRationale(@NonNull String rationale,
29 |                                                @NonNull String positiveButton,
30 |                                                @NonNull String negativeButton,
31 |                                                @StyleRes int theme,
32 |                                                int requestCode,
33 |                                                @NonNull String... perms) {
34 |         throw new IllegalStateException("Should never be requesting permissions on API < 23!");
35 |     }
36 | 
37 |     @Override
38 |     public Context getContext() {
39 |         if (getHost() instanceof Activity) {
40 |             return (Context) getHost();
41 |         } else if (getHost() instanceof Fragment) {
42 |             return ((Fragment) getHost()).getContext();
43 |         } else {
44 |             throw new IllegalStateException("Unknown host: " + getHost());
45 |         }
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/helper/BaseSupportPermissionsHelper.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.helper;
 2 | 
 3 | import androidx.annotation.NonNull;
 4 | import androidx.annotation.StyleRes;
 5 | import androidx.fragment.app.Fragment;
 6 | import androidx.fragment.app.FragmentManager;
 7 | import android.util.Log;
 8 | 
 9 | import pub.devrel.easypermissions.RationaleDialogFragmentCompat;
10 | 
11 | /**
12 |  * Implementation of {@link PermissionHelper} for Support Library host classes.
13 |  */
14 | public abstract class BaseSupportPermissionsHelper<T> extends PermissionHelper<T> {
15 | 
16 |     private static final String TAG = "BSPermissionsHelper";
17 | 
18 |     public BaseSupportPermissionsHelper(@NonNull T host) {
19 |         super(host);
20 |     }
21 | 
22 |     public abstract FragmentManager getSupportFragmentManager();
23 | 
24 |     @Override
25 |     public void showRequestPermissionRationale(@NonNull String rationale,
26 |                                                @NonNull String positiveButton,
27 |                                                @NonNull String negativeButton,
28 |                                                @StyleRes int theme,
29 |                                                int requestCode,
30 |                                                @NonNull String... perms) {
31 | 
32 |         FragmentManager fm = getSupportFragmentManager();
33 | 
34 |         // Check if fragment is already showing
35 |         Fragment fragment = fm.findFragmentByTag(RationaleDialogFragmentCompat.TAG);
36 |         if (fragment instanceof RationaleDialogFragmentCompat) {
37 |             Log.d(TAG, "Found existing fragment, not showing rationale.");
38 |             return;
39 |         }
40 | 
41 |         RationaleDialogFragmentCompat
42 |                 .newInstance(rationale, positiveButton, negativeButton, theme, requestCode, perms)
43 |                 .showAllowingStateLoss(fm, RationaleDialogFragmentCompat.TAG);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/helper/ActivityPermissionHelper.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.helper;
 2 | 
 3 | import android.app.Activity;
 4 | import android.app.Fragment;
 5 | import android.app.FragmentManager;
 6 | import android.content.Context;
 7 | import androidx.annotation.NonNull;
 8 | import androidx.annotation.StyleRes;
 9 | import androidx.core.app.ActivityCompat;
10 | import android.util.Log;
11 | 
12 | import pub.devrel.easypermissions.RationaleDialogFragment;
13 | 
14 | /**
15 |  * Permissions helper for {@link Activity}.
16 |  */
17 | class ActivityPermissionHelper extends PermissionHelper<Activity> {
18 |     private static final String TAG = "ActPermissionHelper";
19 | 
20 |     public ActivityPermissionHelper(Activity host) {
21 |         super(host);
22 |     }
23 | 
24 |     @Override
25 |     public void directRequestPermissions(int requestCode, @NonNull String... perms) {
26 |         ActivityCompat.requestPermissions(getHost(), perms, requestCode);
27 |     }
28 | 
29 |     @Override
30 |     public boolean shouldShowRequestPermissionRationale(@NonNull String perm) {
31 |         return ActivityCompat.shouldShowRequestPermissionRationale(getHost(), perm);
32 |     }
33 | 
34 |     @Override
35 |     public Context getContext() {
36 |         return getHost();
37 |     }
38 | 
39 |     @Override
40 |     public void showRequestPermissionRationale(@NonNull String rationale,
41 |                                                @NonNull String positiveButton,
42 |                                                @NonNull String negativeButton,
43 |                                                @StyleRes int theme,
44 |                                                int requestCode,
45 |                                                @NonNull String... perms) {
46 |         FragmentManager fm = getHost().getFragmentManager();
47 | 
48 |         // Check if fragment is already showing
49 |         Fragment fragment = fm.findFragmentByTag(RationaleDialogFragment.TAG);
50 |         if (fragment instanceof RationaleDialogFragment) {
51 |             Log.d(TAG, "Found existing fragment, not showing rationale.");
52 |             return;
53 |         }
54 | 
55 |         RationaleDialogFragment
56 |                 .newInstance(positiveButton, negativeButton, rationale, theme, requestCode, perms)
57 |                 .showAllowingStateLoss(fm, RationaleDialogFragment.TAG);
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/AppSettingsDialogHolderActivity.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions;
 2 | 
 3 | import android.app.Activity;
 4 | import android.app.Dialog;
 5 | import android.content.Context;
 6 | import android.content.DialogInterface;
 7 | import android.content.Intent;
 8 | import android.net.Uri;
 9 | import android.os.Bundle;
10 | import android.provider.Settings;
11 | import androidx.annotation.RestrictTo;
12 | import androidx.appcompat.app.AlertDialog;
13 | import androidx.appcompat.app.AppCompatActivity;
14 | 
15 | @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
16 | public class AppSettingsDialogHolderActivity extends AppCompatActivity implements DialogInterface.OnClickListener {
17 |     private static final int APP_SETTINGS_RC = 7534;
18 | 
19 |     private AlertDialog mDialog;
20 |     private int mIntentFlags;
21 | 
22 |     public static Intent createShowDialogIntent(Context context, AppSettingsDialog dialog) {
23 |         Intent intent = new Intent(context, AppSettingsDialogHolderActivity.class);
24 |         intent.putExtra(AppSettingsDialog.EXTRA_APP_SETTINGS, dialog);
25 |         return intent;
26 |     }
27 | 
28 |     @Override
29 |     protected void onCreate(Bundle savedInstanceState) {
30 |         super.onCreate(savedInstanceState);
31 |         AppSettingsDialog appSettingsDialog = AppSettingsDialog.fromIntent(getIntent(), this);
32 |         mIntentFlags = appSettingsDialog.getIntentFlags();
33 |         mDialog = appSettingsDialog.showDialog(this, this);
34 |     }
35 | 
36 |     @Override
37 |     protected void onDestroy() {
38 |         super.onDestroy();
39 |         if (mDialog != null && mDialog.isShowing()) {
40 |             mDialog.dismiss();
41 |         }
42 |     }
43 | 
44 |     @Override
45 |     public void onClick(DialogInterface dialog, int which) {
46 |         if (which == Dialog.BUTTON_POSITIVE) {
47 |             Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
48 |                     .setData(Uri.fromParts("package", getPackageName(), null));
49 |             intent.addFlags(mIntentFlags);
50 |             startActivityForResult(intent, APP_SETTINGS_RC);
51 |         } else if (which == Dialog.BUTTON_NEGATIVE) {
52 |             setResult(Activity.RESULT_CANCELED);
53 |             finish();
54 |         } else {
55 |             throw new IllegalStateException("Unknown button type: " + which);
56 |         }
57 |     }
58 | 
59 |     @Override
60 |     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
61 |         super.onActivityResult(requestCode, resultCode, data);
62 |         setResult(resultCode, data);
63 |         finish();
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/app/src/main/java/pub/devrel/easypermissions/sample/MainFragment.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions.sample;
 2 | 
 3 | import android.Manifest;
 4 | import android.os.Bundle;
 5 | import android.util.Log;
 6 | import android.view.LayoutInflater;
 7 | import android.view.View;
 8 | import android.view.ViewGroup;
 9 | import android.widget.Toast;
10 | 
11 | import androidx.annotation.NonNull;
12 | import androidx.fragment.app.Fragment;
13 | 
14 | import java.util.List;
15 | 
16 | import pub.devrel.easypermissions.AfterPermissionGranted;
17 | import pub.devrel.easypermissions.EasyPermissions;
18 | 
19 | /**
20 |  * Created in {@link R.layout#activity_main}
21 |  */
22 | public class MainFragment extends Fragment implements EasyPermissions.PermissionCallbacks {
23 | 
24 |     private static final String TAG = "MainFragment";
25 |     private static final int RC_SMS_PERM = 122;
26 | 
27 |     @Override
28 |     public View onCreateView(@NonNull LayoutInflater inflater,
29 |                              ViewGroup container,
30 |                              Bundle savedInstanceState) {
31 |         super.onCreateView(inflater, container, savedInstanceState);
32 | 
33 |         // Create view
34 |         View v = inflater.inflate(R.layout.fragment_main, container);
35 | 
36 |         // Button click listener
37 |         v.findViewById(R.id.button_sms).setOnClickListener(v1 -> smsTask());
38 | 
39 |         return v;
40 |     }
41 | 
42 |     @Override
43 |     public void onRequestPermissionsResult(int requestCode,
44 |                                            @NonNull String[] permissions,
45 |                                            @NonNull int[] grantResults) {
46 |         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
47 | 
48 |         // EasyPermissions handles the request result.
49 |         EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
50 |     }
51 | 
52 |     @AfterPermissionGranted(RC_SMS_PERM)
53 |     private void smsTask() {
54 |         if (EasyPermissions.hasPermissions(requireContext(), Manifest.permission.READ_SMS)) {
55 |             // Have permission, do the thing!
56 |             Toast.makeText(getActivity(), "TODO: SMS things", Toast.LENGTH_LONG).show();
57 |         } else {
58 |             // Request one permission
59 |             EasyPermissions.requestPermissions(this, getString(R.string.rationale_sms),
60 |                     RC_SMS_PERM, Manifest.permission.READ_SMS);
61 |         }
62 |     }
63 | 
64 |     @Override
65 |     public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
66 |         Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
67 |     }
68 | 
69 |     @Override
70 |     public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
71 |         Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @rem
 2 | @rem Copyright 2015 the original author or authors.
 3 | @rem
 4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
 5 | @rem you may not use this file except in compliance with the License.
 6 | @rem You may obtain a copy of the License at
 7 | @rem
 8 | @rem      https://www.apache.org/licenses/LICENSE-2.0
 9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 | 
17 | @if "%DEBUG%" == "" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem  Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 | 
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 | 
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%" == "" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 | 
32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
34 | 
35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 | 
38 | @rem Find java.exe
39 | if defined JAVA_HOME goto findJavaFromJavaHome
40 | 
41 | set JAVA_EXE=java.exe
42 | %JAVA_EXE% -version >NUL 2>&1
43 | if "%ERRORLEVEL%" == "0" goto execute
44 | 
45 | echo.
46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 | echo.
48 | echo Please set the JAVA_HOME variable in your environment to match the
49 | echo location of your Java installation.
50 | 
51 | goto fail
52 | 
53 | :findJavaFromJavaHome
54 | set JAVA_HOME=%JAVA_HOME:"=%
55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
56 | 
57 | if exist "%JAVA_EXE%" goto execute
58 | 
59 | echo.
60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 | echo.
62 | echo Please set the JAVA_HOME variable in your environment to match the
63 | echo location of your Java installation.
64 | 
65 | goto fail
66 | 
67 | :execute
68 | @rem Setup the command line
69 | 
70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
71 | 
72 | 
73 | @rem Execute Gradle
74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
75 | 
76 | :end
77 | @rem End local scope for the variables with windows NT shell
78 | if "%ERRORLEVEL%"=="0" goto mainEnd
79 | 
80 | :fail
81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
82 | rem the _cmd.exe /c_ return code!
83 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
84 | exit /b 1
85 | 
86 | :mainEnd
87 | if "%OS%"=="Windows_NT" endlocal
88 | 
89 | :omega
90 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/RationaleDialogClickListener.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions;
 2 | 
 3 | import android.app.Activity;
 4 | import android.app.Dialog;
 5 | import android.content.DialogInterface;
 6 | import androidx.fragment.app.Fragment;
 7 | 
 8 | import java.util.Arrays;
 9 | 
10 | import pub.devrel.easypermissions.helper.PermissionHelper;
11 | 
12 | /**
13 |  * Click listener for either {@link RationaleDialogFragment} or {@link RationaleDialogFragmentCompat}.
14 |  */
15 | class RationaleDialogClickListener implements Dialog.OnClickListener {
16 | 
17 |     private Object mHost;
18 |     private RationaleDialogConfig mConfig;
19 |     private EasyPermissions.PermissionCallbacks mCallbacks;
20 |     private EasyPermissions.RationaleCallbacks mRationaleCallbacks;
21 | 
22 |     RationaleDialogClickListener(RationaleDialogFragmentCompat compatDialogFragment,
23 |                                  RationaleDialogConfig config,
24 |                                  EasyPermissions.PermissionCallbacks callbacks,
25 |                                  EasyPermissions.RationaleCallbacks rationaleCallbacks) {
26 | 
27 |         mHost = compatDialogFragment.getParentFragment() != null
28 |                 ? compatDialogFragment.getParentFragment()
29 |                 : compatDialogFragment.getActivity();
30 | 
31 |         mConfig = config;
32 |         mCallbacks = callbacks;
33 |         mRationaleCallbacks = rationaleCallbacks;
34 | 
35 |     }
36 | 
37 |     RationaleDialogClickListener(RationaleDialogFragment dialogFragment,
38 |                                  RationaleDialogConfig config,
39 |                                  EasyPermissions.PermissionCallbacks callbacks,
40 |                                  EasyPermissions.RationaleCallbacks dialogCallback) {
41 | 
42 |         mHost = dialogFragment.getActivity();
43 | 
44 |         mConfig = config;
45 |         mCallbacks = callbacks;
46 |         mRationaleCallbacks = dialogCallback;
47 |     }
48 | 
49 |     @Override
50 |     public void onClick(DialogInterface dialog, int which) {
51 |         int requestCode = mConfig.requestCode;
52 |         if (which == Dialog.BUTTON_POSITIVE) {
53 |             String[] permissions = mConfig.permissions;
54 |             if (mRationaleCallbacks != null) {
55 |                 mRationaleCallbacks.onRationaleAccepted(requestCode);
56 |             }
57 |             if (mHost instanceof Fragment) {
58 |                 PermissionHelper.newInstance((Fragment) mHost).directRequestPermissions(requestCode, permissions);
59 |             } else if (mHost instanceof Activity) {
60 |                 PermissionHelper.newInstance((Activity) mHost).directRequestPermissions(requestCode, permissions);
61 |             } else {
62 |                 throw new RuntimeException("Host must be an Activity or Fragment!");
63 |             }
64 |         } else {
65 |             if (mRationaleCallbacks != null) {
66 |                 mRationaleCallbacks.onRationaleDenied(requestCode);
67 |             }
68 |             notifyPermissionDenied();
69 |         }
70 |     }
71 | 
72 |     private void notifyPermissionDenied() {
73 |         if (mCallbacks != null) {
74 |             mCallbacks.onPermissionsDenied(mConfig.requestCode, Arrays.asList(mConfig.permissions));
75 |         }
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/RationaleDialogConfig.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions;
 2 | 
 3 | import android.app.Dialog;
 4 | import android.content.Context;
 5 | import android.os.Bundle;
 6 | import androidx.annotation.NonNull;
 7 | import androidx.annotation.StyleRes;
 8 | import androidx.appcompat.app.AlertDialog;
 9 | 
10 | /**
11 |  * Configuration for either {@link RationaleDialogFragment} or {@link RationaleDialogFragmentCompat}.
12 |  */
13 | class RationaleDialogConfig {
14 | 
15 |     private static final String KEY_POSITIVE_BUTTON = "positiveButton";
16 |     private static final String KEY_NEGATIVE_BUTTON = "negativeButton";
17 |     private static final String KEY_RATIONALE_MESSAGE = "rationaleMsg";
18 |     private static final String KEY_THEME = "theme";
19 |     private static final String KEY_REQUEST_CODE = "requestCode";
20 |     private static final String KEY_PERMISSIONS = "permissions";
21 | 
22 |     String positiveButton;
23 |     String negativeButton;
24 |     int theme;
25 |     int requestCode;
26 |     String rationaleMsg;
27 |     String[] permissions;
28 | 
29 |     RationaleDialogConfig(@NonNull String positiveButton,
30 |                           @NonNull String negativeButton,
31 |                           @NonNull String rationaleMsg,
32 |                           @StyleRes int theme,
33 |                           int requestCode,
34 |                           @NonNull String[] permissions) {
35 | 
36 |         this.positiveButton = positiveButton;
37 |         this.negativeButton = negativeButton;
38 |         this.rationaleMsg = rationaleMsg;
39 |         this.theme = theme;
40 |         this.requestCode = requestCode;
41 |         this.permissions = permissions;
42 |     }
43 | 
44 |     RationaleDialogConfig(Bundle bundle) {
45 |         positiveButton = bundle.getString(KEY_POSITIVE_BUTTON);
46 |         negativeButton = bundle.getString(KEY_NEGATIVE_BUTTON);
47 |         rationaleMsg = bundle.getString(KEY_RATIONALE_MESSAGE);
48 |         theme = bundle.getInt(KEY_THEME);
49 |         requestCode = bundle.getInt(KEY_REQUEST_CODE);
50 |         permissions = bundle.getStringArray(KEY_PERMISSIONS);
51 |     }
52 | 
53 |     Bundle toBundle() {
54 |         Bundle bundle = new Bundle();
55 |         bundle.putString(KEY_POSITIVE_BUTTON, positiveButton);
56 |         bundle.putString(KEY_NEGATIVE_BUTTON, negativeButton);
57 |         bundle.putString(KEY_RATIONALE_MESSAGE, rationaleMsg);
58 |         bundle.putInt(KEY_THEME, theme);
59 |         bundle.putInt(KEY_REQUEST_CODE, requestCode);
60 |         bundle.putStringArray(KEY_PERMISSIONS, permissions);
61 | 
62 |         return bundle;
63 |     }
64 | 
65 |     AlertDialog createSupportDialog(Context context, Dialog.OnClickListener listener) {
66 |         AlertDialog.Builder builder;
67 |         if (theme > 0) {
68 |             builder = new AlertDialog.Builder(context, theme);
69 |         } else {
70 |             builder = new AlertDialog.Builder(context);
71 |         }
72 |         return builder
73 |                 .setCancelable(false)
74 |                 .setPositiveButton(positiveButton, listener)
75 |                 .setNegativeButton(negativeButton, listener)
76 |                 .setMessage(rationaleMsg)
77 |                 .create();
78 |     }
79 | 
80 |     android.app.AlertDialog createFrameworkDialog(Context context, Dialog.OnClickListener listener) {
81 |         android.app.AlertDialog.Builder builder;
82 |         if (theme > 0) {
83 |             builder = new android.app.AlertDialog.Builder(context, theme);
84 |         } else {
85 |             builder = new android.app.AlertDialog.Builder(context);
86 |         }
87 |         return builder
88 |                 .setCancelable(false)
89 |                 .setPositiveButton(positiveButton, listener)
90 |                 .setNegativeButton(negativeButton, listener)
91 |                 .setMessage(rationaleMsg)
92 |                 .create();
93 |     }
94 | 
95 | }
96 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/RationaleDialogFragmentCompat.java:
--------------------------------------------------------------------------------
 1 | package pub.devrel.easypermissions;
 2 | 
 3 | import android.app.Dialog;
 4 | import android.content.Context;
 5 | import android.os.Bundle;
 6 | import androidx.annotation.NonNull;
 7 | import androidx.annotation.RestrictTo;
 8 | import androidx.annotation.StyleRes;
 9 | import androidx.fragment.app.FragmentManager;
10 | import androidx.appcompat.app.AppCompatDialogFragment;
11 | 
12 | /**
13 |  * {@link AppCompatDialogFragment} to display rationale for permission requests when the request
14 |  * comes from a Fragment or Activity that can host a Fragment.
15 |  */
16 | @RestrictTo(RestrictTo.Scope.LIBRARY)
17 | public class RationaleDialogFragmentCompat extends AppCompatDialogFragment {
18 | 
19 |     public static final String TAG = "RationaleDialogFragmentCompat";
20 | 
21 |     private EasyPermissions.PermissionCallbacks mPermissionCallbacks;
22 |     private EasyPermissions.RationaleCallbacks mRationaleCallbacks;
23 | 
24 |     public static RationaleDialogFragmentCompat newInstance(
25 |             @NonNull String rationaleMsg,
26 |             @NonNull String positiveButton,
27 |             @NonNull String negativeButton,
28 |             @StyleRes int theme,
29 |             int requestCode,
30 |             @NonNull String[] permissions) {
31 | 
32 |         // Create new Fragment
33 |         RationaleDialogFragmentCompat dialogFragment = new RationaleDialogFragmentCompat();
34 | 
35 |         // Initialize configuration as arguments
36 |         RationaleDialogConfig config = new RationaleDialogConfig(
37 |                 positiveButton, negativeButton, rationaleMsg, theme, requestCode, permissions);
38 |         dialogFragment.setArguments(config.toBundle());
39 | 
40 |         return dialogFragment;
41 |     }
42 | 
43 |     /**
44 |      * Version of {@link #show(FragmentManager, String)} that no-ops when an IllegalStateException
45 |      * would otherwise occur.
46 |      */
47 |     public void showAllowingStateLoss(FragmentManager manager, String tag) {
48 |         if (manager.isStateSaved()) {
49 |             return;
50 |         }
51 | 
52 |         show(manager, tag);
53 |     }
54 | 
55 |     @Override
56 |     public void onAttach(Context context) {
57 |         super.onAttach(context);
58 |         if (getParentFragment() != null) {
59 |             if (getParentFragment() instanceof EasyPermissions.PermissionCallbacks) {
60 |                 mPermissionCallbacks = (EasyPermissions.PermissionCallbacks) getParentFragment();
61 |             }
62 |             if (getParentFragment() instanceof EasyPermissions.RationaleCallbacks){
63 |                 mRationaleCallbacks = (EasyPermissions.RationaleCallbacks) getParentFragment();
64 |             }
65 |         }
66 | 
67 |         if (context instanceof EasyPermissions.PermissionCallbacks) {
68 |             mPermissionCallbacks = (EasyPermissions.PermissionCallbacks) context;
69 |         }
70 | 
71 |         if (context instanceof EasyPermissions.RationaleCallbacks) {
72 |             mRationaleCallbacks = (EasyPermissions.RationaleCallbacks) context;
73 |         }
74 |     }
75 | 
76 |     @Override
77 |     public void onDetach() {
78 |         super.onDetach();
79 |         mPermissionCallbacks = null;
80 |         mRationaleCallbacks = null;
81 |     }
82 | 
83 |     @NonNull
84 |     @Override
85 |     public Dialog onCreateDialog(Bundle savedInstanceState) {
86 |         // Rationale dialog should not be cancelable
87 |         setCancelable(false);
88 | 
89 |         // Get config from arguments, create click listener
90 |         RationaleDialogConfig config = new RationaleDialogConfig(getArguments());
91 |         RationaleDialogClickListener clickListener =
92 |                 new RationaleDialogClickListener(this, config, mPermissionCallbacks, mRationaleCallbacks);
93 | 
94 |         // Create an AlertDialog
95 |         return config.createSupportDialog(getContext(), clickListener);
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/RationaleDialogFragment.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions;
  2 | 
  3 | import android.app.Dialog;
  4 | import android.app.DialogFragment;
  5 | import android.app.FragmentManager;
  6 | import android.content.Context;
  7 | import android.os.Build;
  8 | import android.os.Bundle;
  9 | import androidx.annotation.NonNull;
 10 | import androidx.annotation.RestrictTo;
 11 | import androidx.annotation.StyleRes;
 12 | 
 13 | /**
 14 |  * {@link DialogFragment} to display rationale for permission requests when the request comes from
 15 |  * a Fragment or Activity that can host a Fragment.
 16 |  */
 17 | @RestrictTo(RestrictTo.Scope.LIBRARY)
 18 | public class RationaleDialogFragment extends DialogFragment {
 19 | 
 20 |     public static final String TAG = "RationaleDialogFragment";
 21 | 
 22 |     private EasyPermissions.PermissionCallbacks mPermissionCallbacks;
 23 |     private EasyPermissions.RationaleCallbacks mRationaleCallbacks;
 24 |     private boolean mStateSaved = false;
 25 | 
 26 |     public static RationaleDialogFragment newInstance(
 27 |             @NonNull String positiveButton,
 28 |             @NonNull String negativeButton,
 29 |             @NonNull String rationaleMsg,
 30 |             @StyleRes int theme,
 31 |             int requestCode,
 32 |             @NonNull String[] permissions) {
 33 | 
 34 |         // Create new Fragment
 35 |         RationaleDialogFragment dialogFragment = new RationaleDialogFragment();
 36 | 
 37 |         // Initialize configuration as arguments
 38 |         RationaleDialogConfig config = new RationaleDialogConfig(
 39 |                 positiveButton, negativeButton, rationaleMsg, theme, requestCode, permissions);
 40 |         dialogFragment.setArguments(config.toBundle());
 41 | 
 42 |         return dialogFragment;
 43 |     }
 44 | 
 45 |     @Override
 46 |     public void onAttach(Context context) {
 47 |         super.onAttach(context);
 48 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 && getParentFragment() != null) {
 49 |             if (getParentFragment() instanceof EasyPermissions.PermissionCallbacks) {
 50 |                 mPermissionCallbacks = (EasyPermissions.PermissionCallbacks) getParentFragment();
 51 |             }
 52 |             if (getParentFragment() instanceof EasyPermissions.RationaleCallbacks){
 53 |                 mRationaleCallbacks = (EasyPermissions.RationaleCallbacks) getParentFragment();
 54 |             }
 55 | 
 56 |         }
 57 | 
 58 |         if (context instanceof EasyPermissions.PermissionCallbacks) {
 59 |             mPermissionCallbacks = (EasyPermissions.PermissionCallbacks) context;
 60 |         }
 61 | 
 62 |         if (context instanceof EasyPermissions.RationaleCallbacks) {
 63 |             mRationaleCallbacks = (EasyPermissions.RationaleCallbacks) context;
 64 |         }
 65 |     }
 66 | 
 67 |     @Override
 68 |     public void onSaveInstanceState(Bundle outState) {
 69 |         mStateSaved = true;
 70 |         super.onSaveInstanceState(outState);
 71 |     }
 72 | 
 73 |     /**
 74 |      * Version of {@link #show(FragmentManager, String)} that no-ops when an IllegalStateException
 75 |      * would otherwise occur.
 76 |      */
 77 |     public void showAllowingStateLoss(FragmentManager manager, String tag) {
 78 |         // API 26 added this convenient method
 79 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
 80 |             if (manager.isStateSaved()) {
 81 |                 return;
 82 |             }
 83 |         }
 84 | 
 85 |         if (mStateSaved) {
 86 |             return;
 87 |         }
 88 | 
 89 |         show(manager, tag);
 90 |     }
 91 | 
 92 |     @Override
 93 |     public void onDetach() {
 94 |         super.onDetach();
 95 |         mPermissionCallbacks = null;
 96 |     }
 97 | 
 98 |     @NonNull
 99 |     @Override
100 |     public Dialog onCreateDialog(Bundle savedInstanceState) {
101 |         // Rationale dialog should not be cancelable
102 |         setCancelable(false);
103 | 
104 |         // Get config from arguments, create click listener
105 |         RationaleDialogConfig config = new RationaleDialogConfig(getArguments());
106 |         RationaleDialogClickListener clickListener =
107 |                 new RationaleDialogClickListener(this, config, mPermissionCallbacks, mRationaleCallbacks);
108 | 
109 |         // Create an AlertDialog
110 |         return config.createFrameworkDialog(getActivity(), clickListener);
111 |     }
112 | 
113 | }
114 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/helper/PermissionHelper.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions.helper;
  2 | 
  3 | import android.app.Activity;
  4 | import android.content.Context;
  5 | import android.os.Build;
  6 | import androidx.annotation.NonNull;
  7 | import androidx.annotation.StyleRes;
  8 | import androidx.fragment.app.Fragment;
  9 | import androidx.appcompat.app.AppCompatActivity;
 10 | 
 11 | import java.util.List;
 12 | 
 13 | /**
 14 |  * Delegate class to make permission calls based on the 'host' (Fragment, Activity, etc).
 15 |  */
 16 | public abstract class PermissionHelper<T> {
 17 | 
 18 |     private T mHost;
 19 | 
 20 |     @NonNull
 21 |     public static PermissionHelper<? extends Activity> newInstance(Activity host) {
 22 |         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
 23 |             return new LowApiPermissionsHelper<>(host);
 24 |         }
 25 | 
 26 |         if (host instanceof AppCompatActivity)
 27 |             return new AppCompatActivityPermissionsHelper((AppCompatActivity) host);
 28 |         else {
 29 |             return new ActivityPermissionHelper(host);
 30 |         }
 31 |     }
 32 | 
 33 |     @NonNull
 34 |     public static PermissionHelper<Fragment> newInstance(Fragment host) {
 35 |         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
 36 |             return new LowApiPermissionsHelper<>(host);
 37 |         }
 38 | 
 39 |         return new SupportFragmentPermissionHelper(host);
 40 |     }
 41 | 
 42 |     // ============================================================================
 43 |     // Public concrete methods
 44 |     // ============================================================================
 45 | 
 46 |     public PermissionHelper(@NonNull T host) {
 47 |         mHost = host;
 48 |     }
 49 | 
 50 |     private boolean shouldShowRationale(@NonNull String... perms) {
 51 |         for (String perm : perms) {
 52 |             if (shouldShowRequestPermissionRationale(perm)) {
 53 |                 return true;
 54 |             }
 55 |         }
 56 |         return false;
 57 |     }
 58 | 
 59 |     public void requestPermissions(@NonNull String rationale,
 60 |                                    @NonNull String positiveButton,
 61 |                                    @NonNull String negativeButton,
 62 |                                    @StyleRes int theme,
 63 |                                    int requestCode,
 64 |                                    @NonNull String... perms) {
 65 |         if (shouldShowRationale(perms)) {
 66 |             showRequestPermissionRationale(
 67 |                     rationale, positiveButton, negativeButton, theme, requestCode, perms);
 68 |         } else {
 69 |             directRequestPermissions(requestCode, perms);
 70 |         }
 71 |     }
 72 | 
 73 |     public boolean somePermissionPermanentlyDenied(@NonNull List<String> perms) {
 74 |         for (String deniedPermission : perms) {
 75 |             if (permissionPermanentlyDenied(deniedPermission)) {
 76 |                 return true;
 77 |             }
 78 |         }
 79 | 
 80 |         return false;
 81 |     }
 82 | 
 83 |     public boolean permissionPermanentlyDenied(@NonNull String perms) {
 84 |         return !shouldShowRequestPermissionRationale(perms);
 85 |     }
 86 | 
 87 |     public boolean somePermissionDenied(@NonNull String... perms) {
 88 |         return shouldShowRationale(perms);
 89 |     }
 90 | 
 91 |     @NonNull
 92 |     public T getHost() {
 93 |         return mHost;
 94 |     }
 95 | 
 96 |     // ============================================================================
 97 |     // Public abstract methods
 98 |     // ============================================================================
 99 | 
100 |     public abstract void directRequestPermissions(int requestCode, @NonNull String... perms);
101 | 
102 |     public abstract boolean shouldShowRequestPermissionRationale(@NonNull String perm);
103 | 
104 |     public abstract void showRequestPermissionRationale(@NonNull String rationale,
105 |                                                         @NonNull String positiveButton,
106 |                                                         @NonNull String negativeButton,
107 |                                                         @StyleRes int theme,
108 |                                                         int requestCode,
109 |                                                         @NonNull String... perms);
110 | 
111 |     public abstract Context getContext();
112 | 
113 | }
114 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/EasyPermissionsLowApiTest.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions;
  2 | 
  3 | import android.Manifest;
  4 | 
  5 | import org.junit.Before;
  6 | import org.junit.Test;
  7 | import org.junit.runner.RunWith;
  8 | import org.mockito.ArgumentCaptor;
  9 | import org.mockito.Captor;
 10 | import org.mockito.Mockito;
 11 | import org.mockito.MockitoAnnotations;
 12 | import org.robolectric.RobolectricTestRunner;
 13 | import org.robolectric.annotation.Config;
 14 | 
 15 | import java.util.ArrayList;
 16 | 
 17 | import androidx.test.core.app.ApplicationProvider;
 18 | import pub.devrel.easypermissions.testhelper.ActivityController;
 19 | import pub.devrel.easypermissions.testhelper.FragmentController;
 20 | import pub.devrel.easypermissions.testhelper.TestActivity;
 21 | import pub.devrel.easypermissions.testhelper.TestAppCompatActivity;
 22 | import pub.devrel.easypermissions.testhelper.TestFragment;
 23 | import pub.devrel.easypermissions.testhelper.TestSupportFragmentActivity;
 24 | 
 25 | import static com.google.common.truth.Truth.assertThat;
 26 | import static org.mockito.Mockito.times;
 27 | import static org.mockito.Mockito.verify;
 28 | 
 29 | /**
 30 |  * Low-API (SDK = 19) tests for {@link pub.devrel.easypermissions.EasyPermissions}.
 31 |  */
 32 | @RunWith(RobolectricTestRunner.class)
 33 | @Config(sdk = 19)
 34 | public class EasyPermissionsLowApiTest {
 35 | 
 36 |     private static final String RATIONALE = "RATIONALE";
 37 |     private static final String[] ALL_PERMS = new String[]{
 38 |             Manifest.permission.READ_SMS, Manifest.permission.ACCESS_FINE_LOCATION};
 39 | 
 40 |     private TestActivity spyActivity;
 41 |     private TestSupportFragmentActivity spySupportFragmentActivity;
 42 |     private TestAppCompatActivity spyAppCompatActivity;
 43 |     private TestFragment spyFragment;
 44 |     private FragmentController<TestFragment> fragmentController;
 45 |     private ActivityController<TestActivity> activityController;
 46 |     private ActivityController<TestSupportFragmentActivity> supportFragmentActivityController;
 47 |     private ActivityController<TestAppCompatActivity> appCompatActivityController;
 48 |     @Captor
 49 |     private ArgumentCaptor<Integer> integerCaptor;
 50 |     @Captor
 51 |     private ArgumentCaptor<ArrayList<String>> listCaptor;
 52 | 
 53 |     @Before
 54 |     public void setUp() {
 55 |         MockitoAnnotations.initMocks(this);
 56 | 
 57 |         activityController = new ActivityController<>(TestActivity.class);
 58 |         supportFragmentActivityController = new ActivityController<>(TestSupportFragmentActivity.class);
 59 |         appCompatActivityController = new ActivityController<>(TestAppCompatActivity.class);
 60 |         fragmentController = new FragmentController<>(TestFragment.class);
 61 | 
 62 |         spyActivity = Mockito.spy(activityController.resume());
 63 |         spySupportFragmentActivity = Mockito.spy(supportFragmentActivityController.resume());
 64 |         spyAppCompatActivity = Mockito.spy(appCompatActivityController.resume());
 65 |         spyFragment = Mockito.spy(fragmentController.resume());
 66 |     }
 67 | 
 68 |     // ------ General tests ------
 69 | 
 70 |     @Test
 71 |     public void shouldHavePermission_whenHasPermissionsBeforeMarshmallow() {
 72 |         assertThat(EasyPermissions.hasPermissions(ApplicationProvider.getApplicationContext(),
 73 |                 Manifest.permission.ACCESS_COARSE_LOCATION)).isTrue();
 74 |     }
 75 | 
 76 |     // ------ From Activity ------
 77 | 
 78 |     @Test
 79 |     public void shouldCallbackOnPermissionGranted_whenRequestFromActivity() {
 80 |         EasyPermissions.requestPermissions(spyActivity, RATIONALE, TestActivity.REQUEST_CODE, ALL_PERMS);
 81 | 
 82 |         verify(spyActivity, times(1))
 83 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
 84 |         assertThat(integerCaptor.getValue()).isEqualTo(TestActivity.REQUEST_CODE);
 85 |         assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
 86 |     }
 87 | 
 88 |     // ------ From Support Activity ------
 89 | 
 90 |     @Test
 91 |     public void shouldCallbackOnPermissionGranted_whenRequestFromSupportFragmentActivity() {
 92 |         EasyPermissions.requestPermissions(spySupportFragmentActivity, RATIONALE, TestSupportFragmentActivity.REQUEST_CODE, ALL_PERMS);
 93 | 
 94 |         verify(spySupportFragmentActivity, times(1))
 95 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
 96 |         assertThat(integerCaptor.getValue()).isEqualTo(TestSupportFragmentActivity.REQUEST_CODE);
 97 |         assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
 98 |     }
 99 | 
100 | 
101 |     @Test
102 |     public void shouldCallbackOnPermissionGranted_whenRequestFromAppCompatActivity() {
103 |         EasyPermissions.requestPermissions(spyAppCompatActivity, RATIONALE, TestAppCompatActivity.REQUEST_CODE, ALL_PERMS);
104 | 
105 |         verify(spyAppCompatActivity, times(1))
106 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
107 |         assertThat(integerCaptor.getValue()).isEqualTo(TestAppCompatActivity.REQUEST_CODE);
108 |         assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
109 |     }
110 | 
111 |     @Test
112 |     public void shouldCallbackOnPermissionGranted_whenRequestFromFragment() {
113 |         EasyPermissions.requestPermissions(spyFragment, RATIONALE, TestFragment.REQUEST_CODE, ALL_PERMS);
114 | 
115 |         verify(spyFragment, times(1))
116 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
117 |         assertThat(integerCaptor.getValue()).isEqualTo(TestFragment.REQUEST_CODE);
118 |         assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
119 |     }
120 | 
121 | }
122 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/RationaleDialogClickListenerTest.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions;
  2 | 
  3 | import android.Manifest;
  4 | import android.app.Activity;
  5 | import android.app.Dialog;
  6 | import android.content.DialogInterface;
  7 | 
  8 | import androidx.fragment.app.Fragment;
  9 | 
 10 | import org.junit.Before;
 11 | import org.junit.Test;
 12 | import org.junit.runner.RunWith;
 13 | import org.mockito.ArgumentMatchers;
 14 | import org.mockito.Mock;
 15 | import org.mockito.MockitoAnnotations;
 16 | import org.robolectric.RobolectricTestRunner;
 17 | import org.robolectric.annotation.Config;
 18 | 
 19 | import java.util.Arrays;
 20 | 
 21 | import static org.mockito.ArgumentMatchers.anyInt;
 22 | import static org.mockito.Mockito.never;
 23 | import static org.mockito.Mockito.times;
 24 | import static org.mockito.Mockito.verify;
 25 | import static org.mockito.Mockito.when;
 26 | 
 27 | @RunWith(RobolectricTestRunner.class)
 28 | @Config(sdk = 23)
 29 | public class RationaleDialogClickListenerTest {
 30 | 
 31 |     private static final int REQUEST_CODE = 5;
 32 |     private static final String[] PERMS = new String[]{
 33 |             Manifest.permission.READ_SMS, Manifest.permission.ACCESS_FINE_LOCATION};
 34 |     @Mock
 35 |     private RationaleDialogFragment dialogFragment;
 36 |     @Mock
 37 |     private RationaleDialogFragmentCompat dialogFragmentCompat;
 38 |     @Mock
 39 |     private RationaleDialogConfig dialogConfig;
 40 |     @Mock
 41 |     private EasyPermissions.PermissionCallbacks permissionCallbacks;
 42 |     @Mock
 43 |     private EasyPermissions.RationaleCallbacks rationaleCallbacks;
 44 |     @Mock
 45 |     private DialogInterface dialogInterface;
 46 |     @Mock
 47 |     private Activity activity;
 48 |     @Mock
 49 |     private Fragment fragment;
 50 | 
 51 |     @Before
 52 |     public void setUp() {
 53 |         MockitoAnnotations.initMocks(this);
 54 | 
 55 |         when(dialogFragment.getActivity()).thenReturn(activity);
 56 |         dialogConfig.requestCode = REQUEST_CODE;
 57 |         dialogConfig.permissions = PERMS;
 58 |     }
 59 | 
 60 |     @Test
 61 |     public void shouldOnRationaleAccepted_whenPositiveButtonWithRationaleCallbacks() {
 62 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragment, dialogConfig,
 63 |                 permissionCallbacks, rationaleCallbacks);
 64 |         listener.onClick(dialogInterface, Dialog.BUTTON_POSITIVE);
 65 | 
 66 |         verify(rationaleCallbacks, times(1)).onRationaleAccepted(REQUEST_CODE);
 67 |     }
 68 | 
 69 |     @Test
 70 |     public void shouldNotOnRationaleAccepted_whenPositiveButtonWithoutRationaleCallbacks() {
 71 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragment, dialogConfig,
 72 |                 permissionCallbacks, null);
 73 |         listener.onClick(dialogInterface, Dialog.BUTTON_POSITIVE);
 74 | 
 75 |         verify(rationaleCallbacks, never()).onRationaleAccepted(anyInt());
 76 |     }
 77 | 
 78 |     @Test
 79 |     public void shouldRequestPermissions_whenPositiveButtonFromActivity() {
 80 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragment, dialogConfig,
 81 |                 permissionCallbacks, rationaleCallbacks);
 82 |         listener.onClick(dialogInterface, Dialog.BUTTON_POSITIVE);
 83 | 
 84 |         verify(activity, times(1)).requestPermissions(PERMS, REQUEST_CODE);
 85 |     }
 86 | 
 87 |     @Test
 88 |     public void shouldRequestPermissions_whenPositiveButtonFromFragment() {
 89 |         when(dialogFragmentCompat.getParentFragment()).thenReturn(fragment);
 90 | 
 91 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragmentCompat, dialogConfig,
 92 |                 permissionCallbacks, rationaleCallbacks);
 93 |         listener.onClick(dialogInterface, Dialog.BUTTON_POSITIVE);
 94 | 
 95 |         verify(fragment, times(1)).requestPermissions(PERMS, REQUEST_CODE);
 96 |     }
 97 | 
 98 |     @Test
 99 |     public void shouldOnRationaleDenied_whenNegativeButtonWithRationaleCallbacks() {
100 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragment, dialogConfig,
101 |                 permissionCallbacks, rationaleCallbacks);
102 |         listener.onClick(dialogInterface, Dialog.BUTTON_NEGATIVE);
103 | 
104 |         verify(rationaleCallbacks, times(1)).onRationaleDenied(REQUEST_CODE);
105 |     }
106 | 
107 |     @Test
108 |     public void shouldNotOnRationaleDenied_whenNegativeButtonWithoutRationaleCallbacks() {
109 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragment, dialogConfig,
110 |                 permissionCallbacks, null);
111 |         listener.onClick(dialogInterface, Dialog.BUTTON_NEGATIVE);
112 | 
113 |         verify(rationaleCallbacks, never()).onRationaleDenied(anyInt());
114 |     }
115 | 
116 |     @Test
117 |     public void shouldOnPermissionsDenied_whenNegativeButtonWithPermissionCallbacks() {
118 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragment, dialogConfig,
119 |                 permissionCallbacks, rationaleCallbacks);
120 |         listener.onClick(dialogInterface, Dialog.BUTTON_NEGATIVE);
121 | 
122 |         verify(permissionCallbacks, times(1))
123 |                 .onPermissionsDenied(REQUEST_CODE, Arrays.asList(PERMS));
124 |     }
125 | 
126 |     @Test
127 |     public void shouldNotOnPermissionsDenied_whenNegativeButtonWithoutPermissionCallbacks() {
128 |         RationaleDialogClickListener listener = new RationaleDialogClickListener(dialogFragment, dialogConfig,
129 |                 null, rationaleCallbacks);
130 |         listener.onClick(dialogInterface, Dialog.BUTTON_NEGATIVE);
131 | 
132 |         verify(permissionCallbacks, never()).onPermissionsDenied(anyInt(), ArgumentMatchers.<String>anyList());
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env sh
  2 | 
  3 | #
  4 | # Copyright 2015 the original author or authors.
  5 | #
  6 | # Licensed under the Apache License, Version 2.0 (the "License");
  7 | # you may not use this file except in compliance with the License.
  8 | # You may obtain a copy of the License at
  9 | #
 10 | #      https://www.apache.org/licenses/LICENSE-2.0
 11 | #
 12 | # Unless required by applicable law or agreed to in writing, software
 13 | # distributed under the License is distributed on an "AS IS" BASIS,
 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | # See the License for the specific language governing permissions and
 16 | # limitations under the License.
 17 | #
 18 | 
 19 | ##############################################################################
 20 | ##
 21 | ##  Gradle start up script for UN*X
 22 | ##
 23 | ##############################################################################
 24 | 
 25 | # Attempt to set APP_HOME
 26 | # Resolve links: $0 may be a link
 27 | PRG="$0"
 28 | # Need this for relative symlinks.
 29 | while [ -h "$PRG" ] ; do
 30 |     ls=`ls -ld "$PRG"`
 31 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 32 |     if expr "$link" : '/.*' > /dev/null; then
 33 |         PRG="$link"
 34 |     else
 35 |         PRG=`dirname "$PRG"`"/$link"
 36 |     fi
 37 | done
 38 | SAVED="`pwd`"
 39 | cd "`dirname \"$PRG\"`/" >/dev/null
 40 | APP_HOME="`pwd -P`"
 41 | cd "$SAVED" >/dev/null
 42 | 
 43 | APP_NAME="Gradle"
 44 | APP_BASE_NAME=`basename "$0"`
 45 | 
 46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 48 | 
 49 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 50 | MAX_FD="maximum"
 51 | 
 52 | warn () {
 53 |     echo "$*"
 54 | }
 55 | 
 56 | die () {
 57 |     echo
 58 |     echo "$*"
 59 |     echo
 60 |     exit 1
 61 | }
 62 | 
 63 | # OS specific support (must be 'true' or 'false').
 64 | cygwin=false
 65 | msys=false
 66 | darwin=false
 67 | nonstop=false
 68 | case "`uname`" in
 69 |   CYGWIN* )
 70 |     cygwin=true
 71 |     ;;
 72 |   Darwin* )
 73 |     darwin=true
 74 |     ;;
 75 |   MINGW* )
 76 |     msys=true
 77 |     ;;
 78 |   NONSTOP* )
 79 |     nonstop=true
 80 |     ;;
 81 | esac
 82 | 
 83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 84 | 
 85 | 
 86 | # Determine the Java command to use to start the JVM.
 87 | if [ -n "$JAVA_HOME" ] ; then
 88 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 89 |         # IBM's JDK on AIX uses strange locations for the executables
 90 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 91 |     else
 92 |         JAVACMD="$JAVA_HOME/bin/java"
 93 |     fi
 94 |     if [ ! -x "$JAVACMD" ] ; then
 95 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 96 | 
 97 | Please set the JAVA_HOME variable in your environment to match the
 98 | location of your Java installation."
 99 |     fi
100 | else
101 |     JAVACMD="java"
102 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
103 | 
104 | Please set the JAVA_HOME variable in your environment to match the
105 | location of your Java installation."
106 | fi
107 | 
108 | # Increase the maximum file descriptors if we can.
109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
110 |     MAX_FD_LIMIT=`ulimit -H -n`
111 |     if [ $? -eq 0 ] ; then
112 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
113 |             MAX_FD="$MAX_FD_LIMIT"
114 |         fi
115 |         ulimit -n $MAX_FD
116 |         if [ $? -ne 0 ] ; then
117 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
118 |         fi
119 |     else
120 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
121 |     fi
122 | fi
123 | 
124 | # For Darwin, add options to specify how the application appears in the dock
125 | if $darwin; then
126 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
127 | fi
128 | 
129 | # For Cygwin or MSYS, switch paths to Windows format before running java
130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
131 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
132 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
133 | 
134 |     JAVACMD=`cygpath --unix "$JAVACMD"`
135 | 
136 |     # We build the pattern for arguments to be converted via cygpath
137 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
138 |     SEP=""
139 |     for dir in $ROOTDIRSRAW ; do
140 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
141 |         SEP="|"
142 |     done
143 |     OURCYGPATTERN="(^($ROOTDIRS))"
144 |     # Add a user-defined pattern to the cygpath arguments
145 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
146 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
147 |     fi
148 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
149 |     i=0
150 |     for arg in "$@" ; do
151 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
152 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
153 | 
154 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
155 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
156 |         else
157 |             eval `echo args$i`="\"$arg\""
158 |         fi
159 |         i=`expr $i + 1`
160 |     done
161 |     case $i in
162 |         0) set -- ;;
163 |         1) set -- "$args0" ;;
164 |         2) set -- "$args0" "$args1" ;;
165 |         3) set -- "$args0" "$args1" "$args2" ;;
166 |         4) set -- "$args0" "$args1" "$args2" "$args3" ;;
167 |         5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
168 |         6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
169 |         7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
170 |         8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
171 |         9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
172 |     esac
173 | fi
174 | 
175 | # Escape application args
176 | save () {
177 |     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
178 |     echo " "
179 | }
180 | APP_ARGS=`save "$@"`
181 | 
182 | # Collect all arguments for the java command, following the shell quoting and substitution rules
183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
184 | 
185 | exec "$JAVACMD" "$@"
186 | 


--------------------------------------------------------------------------------
/app/src/main/java/pub/devrel/easypermissions/sample/MainActivity.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Google Inc. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package pub.devrel.easypermissions.sample;
 17 | 
 18 | import android.Manifest;
 19 | import android.content.Intent;
 20 | import android.os.Bundle;
 21 | import android.util.Log;
 22 | import android.widget.Toast;
 23 | 
 24 | import androidx.annotation.NonNull;
 25 | import androidx.appcompat.app.AppCompatActivity;
 26 | 
 27 | import java.util.List;
 28 | 
 29 | import pub.devrel.easypermissions.AfterPermissionGranted;
 30 | import pub.devrel.easypermissions.AppSettingsDialog;
 31 | import pub.devrel.easypermissions.EasyPermissions;
 32 | 
 33 | public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks,
 34 |                                                                EasyPermissions.RationaleCallbacks{
 35 | 
 36 |     private static final String TAG = "MainActivity";
 37 |     private static final String[] LOCATION_AND_CONTACTS =
 38 |             {Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.READ_CONTACTS};
 39 | 
 40 |     private static final int RC_CAMERA_PERM = 123;
 41 |     private static final int RC_LOCATION_CONTACTS_PERM = 124;
 42 | 
 43 |     @Override
 44 |     protected void onCreate(Bundle savedInstanceState) {
 45 |         super.onCreate(savedInstanceState);
 46 |         setContentView(R.layout.activity_main);
 47 | 
 48 |         // Button click listener that will request one permission.
 49 |         findViewById(R.id.button_camera).setOnClickListener(v -> cameraTask());
 50 | 
 51 |         // Button click listener that will request two permissions.
 52 |         findViewById(R.id.button_location_and_contacts).setOnClickListener(v -> locationAndContactsTask());
 53 |     }
 54 | 
 55 |     private boolean hasCameraPermission() {
 56 |         return EasyPermissions.hasPermissions(this, Manifest.permission.CAMERA);
 57 |     }
 58 | 
 59 |     private boolean hasLocationAndContactsPermissions() {
 60 |         return EasyPermissions.hasPermissions(this, LOCATION_AND_CONTACTS);
 61 |     }
 62 | 
 63 |     private boolean hasSmsPermission() {
 64 |         return EasyPermissions.hasPermissions(this, Manifest.permission.READ_SMS);
 65 |     }
 66 | 
 67 |     private boolean hasStoragePermission() {
 68 |         return EasyPermissions.hasPermissions(this, Manifest.permission.WRITE_EXTERNAL_STORAGE);
 69 |     }
 70 | 
 71 |     @AfterPermissionGranted(RC_CAMERA_PERM)
 72 |     public void cameraTask() {
 73 |         if (hasCameraPermission()) {
 74 |             // Have permission, do the thing!
 75 |             Toast.makeText(this, "TODO: Camera things", Toast.LENGTH_LONG).show();
 76 |         } else {
 77 |             // Ask for one permission
 78 |             EasyPermissions.requestPermissions(
 79 |                     this,
 80 |                     getString(R.string.rationale_camera),
 81 |                     RC_CAMERA_PERM,
 82 |                     Manifest.permission.CAMERA);
 83 |         }
 84 |     }
 85 | 
 86 |     @AfterPermissionGranted(RC_LOCATION_CONTACTS_PERM)
 87 |     public void locationAndContactsTask() {
 88 |         if (hasLocationAndContactsPermissions()) {
 89 |             // Have permissions, do the thing!
 90 |             Toast.makeText(this, "TODO: Location and Contacts things", Toast.LENGTH_LONG).show();
 91 |         } else {
 92 |             // Ask for both permissions
 93 |             EasyPermissions.requestPermissions(
 94 |                     this,
 95 |                     getString(R.string.rationale_location_contacts),
 96 |                     RC_LOCATION_CONTACTS_PERM,
 97 |                     LOCATION_AND_CONTACTS);
 98 |         }
 99 |     }
100 | 
101 |     @Override
102 |     public void onRequestPermissionsResult(int requestCode,
103 |                                            @NonNull String[] permissions,
104 |                                            @NonNull int[] grantResults) {
105 |         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
106 | 
107 |         // EasyPermissions handles the request result.
108 |         EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
109 |     }
110 | 
111 |     @Override
112 |     public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
113 |         Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
114 |     }
115 | 
116 |     @Override
117 |     public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
118 |         Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
119 | 
120 |         // (Optional) Check whether the user denied any permissions and checked "NEVER ASK AGAIN."
121 |         // This will display a dialog directing them to enable the permission in app settings.
122 |         if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) {
123 |             new AppSettingsDialog.Builder(this).build().show();
124 |         }
125 |     }
126 | 
127 |     @Override
128 |     public void onActivityResult(int requestCode, int resultCode, Intent data) {
129 |         super.onActivityResult(requestCode, resultCode, data);
130 | 
131 |         if (requestCode == AppSettingsDialog.DEFAULT_SETTINGS_REQ_CODE) {
132 |             String yes = getString(R.string.yes);
133 |             String no = getString(R.string.no);
134 | 
135 |             // Do something after user returned from app settings screen, like showing a Toast.
136 |             Toast.makeText(
137 |                     this,
138 |                     getString(R.string.returned_from_app_settings_to_activity,
139 |                               hasCameraPermission() ? yes : no,
140 |                               hasLocationAndContactsPermissions() ? yes : no,
141 |                               hasSmsPermission() ? yes : no),
142 |                     Toast.LENGTH_LONG)
143 |                     .show();
144 |         }
145 |     }
146 | 
147 |     @Override
148 |     public void onRationaleAccepted(int requestCode) {
149 |         Log.d(TAG, "onRationaleAccepted:" + requestCode);
150 |     }
151 | 
152 |     @Override
153 |     public void onRationaleDenied(int requestCode) {
154 |         Log.d(TAG, "onRationaleDenied:" + requestCode);
155 |     }
156 | }
157 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/AppSettingsDialogTest.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions;
  2 | 
  3 | import android.app.Application;
  4 | import android.content.DialogInterface;
  5 | import android.content.Intent;
  6 | import android.widget.Button;
  7 | 
  8 | import org.junit.Before;
  9 | import org.junit.Test;
 10 | import org.junit.runner.RunWith;
 11 | import org.mockito.ArgumentCaptor;
 12 | import org.mockito.Captor;
 13 | import org.mockito.Mock;
 14 | import org.mockito.Mockito;
 15 | import org.mockito.MockitoAnnotations;
 16 | import org.robolectric.RobolectricTestRunner;
 17 | import org.robolectric.annotation.Config;
 18 | import org.robolectric.shadows.ShadowApplication;
 19 | import org.robolectric.shadows.ShadowIntent;
 20 | 
 21 | import java.util.Objects;
 22 | 
 23 | import androidx.appcompat.app.AlertDialog;
 24 | import androidx.test.core.app.ApplicationProvider;
 25 | import pub.devrel.easypermissions.testhelper.ActivityController;
 26 | import pub.devrel.easypermissions.testhelper.FragmentController;
 27 | import pub.devrel.easypermissions.testhelper.TestActivity;
 28 | import pub.devrel.easypermissions.testhelper.TestFragment;
 29 | 
 30 | import static com.google.common.truth.Truth.assertThat;
 31 | import static org.mockito.ArgumentMatchers.any;
 32 | import static org.mockito.ArgumentMatchers.anyInt;
 33 | import static org.mockito.Mockito.times;
 34 | import static org.mockito.Mockito.verify;
 35 | import static org.robolectric.Shadows.shadowOf;
 36 | import static pub.devrel.easypermissions.AppSettingsDialog.DEFAULT_SETTINGS_REQ_CODE;
 37 | 
 38 | @RunWith(RobolectricTestRunner.class)
 39 | @Config(sdk = 23)
 40 | public class AppSettingsDialogTest {
 41 | 
 42 |     private static final String TITLE = "TITLE";
 43 |     private static final String RATIONALE = "RATIONALE";
 44 |     private static final String NEGATIVE = "NEGATIVE";
 45 |     private static final String POSITIVE = "POSITIVE";
 46 |     private ShadowApplication shadowApp;
 47 |     private TestActivity spyActivity;
 48 |     private TestFragment spyFragment;
 49 |     private FragmentController<TestFragment> fragmentController;
 50 |     private ActivityController<TestActivity> activityController;
 51 |     @Mock
 52 |     private DialogInterface.OnClickListener positiveListener;
 53 |     @Mock
 54 |     private DialogInterface.OnClickListener negativeListener;
 55 |     @Captor
 56 |     private ArgumentCaptor<Integer> integerCaptor;
 57 |     @Captor
 58 |     private ArgumentCaptor<Intent> intentCaptor;
 59 | 
 60 |     @Before
 61 |     public void setUp() {
 62 |         MockitoAnnotations.initMocks(this);
 63 |         shadowApp = shadowOf((Application) ApplicationProvider.getApplicationContext());
 64 | 
 65 |         activityController = new ActivityController<>(TestActivity.class);
 66 |         fragmentController = new FragmentController<>(TestFragment.class);
 67 | 
 68 |         spyActivity = Mockito.spy(activityController.resume());
 69 |         spyFragment = Mockito.spy(fragmentController.resume());
 70 |     }
 71 | 
 72 |     // ------ From Activity ------
 73 | 
 74 |     @Test
 75 |     public void shouldShowExpectedSettingsDialog_whenBuildingFromActivity() {
 76 |         new AppSettingsDialog.Builder(spyActivity)
 77 |                 .setTitle(android.R.string.dialog_alert_title)
 78 |                 .setRationale(android.R.string.unknownName)
 79 |                 .setPositiveButton(android.R.string.ok)
 80 |                 .setNegativeButton(android.R.string.cancel)
 81 |                 .setThemeResId(R.style.Theme_AppCompat)
 82 |                 .build()
 83 |                 .show();
 84 | 
 85 |         verify(spyActivity, times(1))
 86 |                 .startActivityForResult(intentCaptor.capture(), integerCaptor.capture());
 87 |         assertThat(integerCaptor.getValue()).isEqualTo(DEFAULT_SETTINGS_REQ_CODE);
 88 |         assertThat(Objects.requireNonNull(intentCaptor.getValue().getComponent()).getClassName())
 89 |                 .isEqualTo(AppSettingsDialogHolderActivity.class.getName());
 90 | 
 91 |         Intent startedIntent = shadowApp.getNextStartedActivity();
 92 |         ShadowIntent shadowIntent = shadowOf(startedIntent);
 93 |         assertThat(shadowIntent.getIntentClass()).isEqualTo(AppSettingsDialogHolderActivity.class);
 94 |     }
 95 | 
 96 |     @Test
 97 |     public void shouldPositiveListener_whenClickingPositiveButtonFromActivity() {
 98 |         AlertDialog alertDialog = new AppSettingsDialog.Builder(spyActivity)
 99 |                 .setTitle(TITLE)
100 |                 .setRationale(RATIONALE)
101 |                 .setPositiveButton(POSITIVE)
102 |                 .setNegativeButton(NEGATIVE)
103 |                 .setThemeResId(R.style.Theme_AppCompat)
104 |                 .build()
105 |                 .showDialog(positiveListener, negativeListener);
106 |         Button positive = alertDialog.getButton(AlertDialog.BUTTON_POSITIVE);
107 |         positive.performClick();
108 | 
109 |         verify(positiveListener, times(1))
110 |                 .onClick(any(DialogInterface.class), anyInt());
111 |     }
112 | 
113 |     @Test
114 |     public void shouldNegativeListener_whenClickingPositiveButtonFromActivity() {
115 |         AlertDialog alertDialog = new AppSettingsDialog.Builder(spyActivity)
116 |                 .setTitle(TITLE)
117 |                 .setRationale(RATIONALE)
118 |                 .setPositiveButton(POSITIVE)
119 |                 .setNegativeButton(NEGATIVE)
120 |                 .setThemeResId(R.style.Theme_AppCompat)
121 |                 .build()
122 |                 .showDialog(positiveListener, negativeListener);
123 |         Button positive = alertDialog.getButton(AlertDialog.BUTTON_NEGATIVE);
124 |         positive.performClick();
125 | 
126 |         verify(negativeListener, times(1))
127 |                 .onClick(any(DialogInterface.class), anyInt());
128 |     }
129 | 
130 |     @Test
131 |     public void shouldShowExpectedSettingsDialog_whenBuildingFromSupportFragment() {
132 |         new AppSettingsDialog.Builder(spyFragment)
133 |                 .setTitle(android.R.string.dialog_alert_title)
134 |                 .setRationale(android.R.string.unknownName)
135 |                 .setPositiveButton(android.R.string.ok)
136 |                 .setNegativeButton(android.R.string.cancel)
137 |                 .setThemeResId(R.style.Theme_AppCompat)
138 |                 .build()
139 |                 .show();
140 | 
141 |         verify(spyFragment, times(1))
142 |                 .startActivityForResult(intentCaptor.capture(), integerCaptor.capture());
143 |         assertThat(integerCaptor.getValue()).isEqualTo(DEFAULT_SETTINGS_REQ_CODE);
144 |         assertThat(Objects.requireNonNull(intentCaptor.getValue().getComponent()).getClassName())
145 |                 .isEqualTo(AppSettingsDialogHolderActivity.class.getName());
146 | 
147 |         Intent startedIntent = shadowApp.getNextStartedActivity();
148 |         ShadowIntent shadowIntent = shadowOf(startedIntent);
149 |         assertThat(shadowIntent.getIntentClass()).isEqualTo(AppSettingsDialogHolderActivity.class);
150 |     }
151 | 
152 |     @Test
153 |     public void shouldPositiveListener_whenClickingPositiveButtonFromSupportFragment() {
154 |         AlertDialog alertDialog = new AppSettingsDialog.Builder(spyFragment)
155 |                 .setTitle(TITLE)
156 |                 .setRationale(RATIONALE)
157 |                 .setPositiveButton(POSITIVE)
158 |                 .setNegativeButton(NEGATIVE)
159 |                 .setThemeResId(R.style.Theme_AppCompat)
160 |                 .build()
161 |                 .showDialog(positiveListener, negativeListener);
162 |         Button positive = alertDialog.getButton(AlertDialog.BUTTON_POSITIVE);
163 |         positive.performClick();
164 | 
165 |         verify(positiveListener, times(1))
166 |                 .onClick(any(DialogInterface.class), anyInt());
167 |     }
168 | 
169 |     @Test
170 |     public void shouldNegativeListener_whenClickingPositiveButtonFromSupportFragment() {
171 |         AlertDialog alertDialog = new AppSettingsDialog.Builder(spyFragment)
172 |                 .setTitle(TITLE)
173 |                 .setRationale(RATIONALE)
174 |                 .setPositiveButton(POSITIVE)
175 |                 .setNegativeButton(NEGATIVE)
176 |                 .setThemeResId(R.style.Theme_AppCompat)
177 |                 .build()
178 |                 .showDialog(positiveListener, negativeListener);
179 |         Button positive = alertDialog.getButton(AlertDialog.BUTTON_NEGATIVE);
180 |         positive.performClick();
181 | 
182 |         verify(negativeListener, times(1))
183 |                 .onClick(any(DialogInterface.class), anyInt());
184 |     }
185 | 
186 | }
187 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # EasyPermissions [![Build Status][1]][2] [![Android Weekly][3]][4]
  2 | 
  3 | EasyPermissions is a wrapper library to simplify basic system permissions logic when targeting
  4 | Android M or higher.
  5 | 
  6 | **Note:** If your app is written in Kotlin consider the [easypermissions-ktx](https://github.com/VMadalin/easypermissions-ktx)
  7 | library which adds Kotlin extensions to the core EasyPermissions library.
  8 | 
  9 | ## Installation
 10 | 
 11 | EasyPermissions is installed by adding the following dependency to your `build.gradle` file:
 12 | 
 13 | ```groovy
 14 | dependencies {
 15 |     // For developers using AndroidX in their applications
 16 |     implementation 'pub.devrel:easypermissions:3.0.0'
 17 |  
 18 |     // For developers using the Android Support Library
 19 |     implementation 'pub.devrel:easypermissions:2.0.1'
 20 | }
 21 | ```
 22 | 
 23 | ## Usage
 24 | 
 25 | ### Basic
 26 | 
 27 | To begin using EasyPermissions, have your `Activity` (or `Fragment`) override the `onRequestPermissionsResult` method:
 28 | 
 29 | ```java
 30 | public class MainActivity extends AppCompatActivity {
 31 |     @Override
 32 |     protected void onCreate(Bundle savedInstanceState) {
 33 |         super.onCreate(savedInstanceState);
 34 |         setContentView(R.layout.activity_main);
 35 |     }
 36 | 
 37 |     @Override
 38 |     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
 39 |         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
 40 | 
 41 |         // Forward results to EasyPermissions
 42 |         EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
 43 |     }
 44 | }
 45 | ```
 46 | 
 47 | ### Request Permissions
 48 | 
 49 | The example below shows how to request permissions for a method that requires both
 50 | `CAMERA` and `ACCESS_FINE_LOCATION` permissions. There are a few things to note:
 51 | 
 52 |   * Using `EasyPermissions#hasPermissions(...)` to check if the app already has the
 53 |     required permissions. This method can take any number of permissions as its final
 54 |     argument.
 55 |   * Requesting permissions with `EasyPermissions#requestPermissions`. This method
 56 |     will request the system permissions and show the rationale string provided if
 57 |     necessary. The request code provided should be unique to this request, and the method
 58 |     can take any number of permissions as its final argument.
 59 |   * Use of the `AfterPermissionGranted` annotation. This is optional, but provided for
 60 |     convenience. If all of the permissions in a given request are granted, *all* methods
 61 |     annotated with the proper request code will be executed(be sure to have an unique request code). The annotated method needs to be *void* and *without input parameters* (instead, you can use *onSaveInstanceState* in order to keep the state of your suppressed parameters). This is to simplify the common
 62 |     flow of needing to run the requesting method after all of its permissions have been granted.
 63 |     This can also be achieved by adding logic on the `onPermissionsGranted` callback.
 64 | 
 65 | ```java
 66 | @AfterPermissionGranted(RC_CAMERA_AND_LOCATION)
 67 | private void methodRequiresTwoPermission() {
 68 |     String[] perms = {Manifest.permission.CAMERA, Manifest.permission.ACCESS_FINE_LOCATION};
 69 |     if (EasyPermissions.hasPermissions(this, perms)) {
 70 |         // Already have permission, do the thing
 71 |         // ...
 72 |     } else {
 73 |         // Do not have permissions, request them now
 74 |         EasyPermissions.requestPermissions(this, getString(R.string.camera_and_location_rationale),
 75 |                 RC_CAMERA_AND_LOCATION, perms);
 76 |     }
 77 | }
 78 | ```
 79 | 
 80 | Or for finer control over the rationale dialog, use a `PermissionRequest`:
 81 | 
 82 | ```java
 83 | EasyPermissions.requestPermissions(
 84 |         new PermissionRequest.Builder(this, RC_CAMERA_AND_LOCATION, perms)
 85 |                 .setRationale(R.string.camera_and_location_rationale)
 86 |                 .setPositiveButtonText(R.string.rationale_ask_ok)
 87 |                 .setNegativeButtonText(R.string.rationale_ask_cancel)
 88 |                 .setTheme(R.style.my_fancy_style)
 89 |                 .build());
 90 | ```
 91 | 
 92 | Optionally, for a finer control, you can have your `Activity` / `Fragment` implement
 93 | the `PermissionCallbacks` interface.
 94 | 
 95 | ```java
 96 | public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {
 97 | 
 98 |     @Override
 99 |     protected void onCreate(Bundle savedInstanceState) {
100 |         super.onCreate(savedInstanceState);
101 |         setContentView(R.layout.activity_main);
102 |     }
103 | 
104 |     @Override
105 |     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
106 |         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
107 | 
108 |         // Forward results to EasyPermissions
109 |         EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
110 |     }
111 | 
112 |     @Override
113 |     public void onPermissionsGranted(int requestCode, List<String> list) {
114 |         // Some permissions have been granted
115 |         // ...
116 |     }
117 | 
118 |     @Override
119 |     public void onPermissionsDenied(int requestCode, List<String> list) {
120 |         // Some permissions have been denied
121 |         // ...
122 |     }
123 | }
124 | ```
125 | 
126 | ### Required Permissions
127 | 
128 | In some cases your app will not function properly without certain permissions. If the user
129 | denies these permissions with the "Never Ask Again" option, you will be unable to request
130 | these permissions from the user and they must be changed in app settings. You can use the
131 | method `EasyPermissions.somePermissionPermanentlyDenied(...)` to display a dialog to the
132 | user in this situation and direct them to the system setting screen for your app:
133 | 
134 | **Note**: Due to a limitation in the information provided by the Android
135 | framework permissions API, the `somePermissionPermanentlyDenied` method only
136 | works after the permission has been denied and your app has received
137 | the `onPermissionsDenied` callback. Otherwise the library cannot distinguish
138 | permanent denial from the "not yet denied" case.
139 | 
140 | ```java
141 | @Override
142 | public void onPermissionsDenied(int requestCode, List<String> perms) {
143 |     Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
144 | 
145 |     // (Optional) Check whether the user denied any permissions and checked "NEVER ASK AGAIN."
146 |     // This will display a dialog directing them to enable the permission in app settings.
147 |     if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) {
148 |         new AppSettingsDialog.Builder(this).build().show();
149 |     }
150 | }
151 | 
152 | @Override
153 | public void onActivityResult(int requestCode, int resultCode, Intent data) {
154 |     super.onActivityResult(requestCode, resultCode, data);
155 | 
156 |     if (requestCode == AppSettingsDialog.DEFAULT_SETTINGS_REQ_CODE) {
157 |         // Do something after user returned from app settings screen, like showing a Toast.
158 |         Toast.makeText(this, R.string.returned_from_app_settings_to_activity, Toast.LENGTH_SHORT)
159 |                 .show();
160 |     }
161 | }
162 | ```
163 | 
164 | ### Interacting with the rationale dialog
165 | 
166 | Implement the `EasyPermissions.RationaleCallbacks` if you want to interact with the rationale dialog.
167 | 
168 | ```java
169 | @Override
170 | public void onRationaleAccepted(int requestCode) {
171 |     // Rationale accepted to request some permissions
172 |     // ...
173 | }
174 | 
175 | @Override
176 | public void onRationaleDenied(int requestCode) {
177 |     // Rationale denied to request some permissions
178 |     // ...
179 | }
180 | ```
181 | 
182 | Rationale callbacks don't necessarily imply permission changes. To check for those, see the `EasyPermissions.PermissionCallbacks`.
183 | 
184 | ## LICENSE
185 | 
186 | ```
187 | 	Copyright 2017 Google
188 | 
189 |    Licensed under the Apache License, Version 2.0 (the "License");
190 |    you may not use this file except in compliance with the License.
191 |    You may obtain a copy of the License at
192 | 
193 |      http://www.apache.org/licenses/LICENSE-2.0
194 | 
195 |    Unless required by applicable law or agreed to in writing, software
196 |    distributed under the License is distributed on an "AS IS" BASIS,
197 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
198 |    See the License for the specific language governing permissions and
199 |    limitations under the License.
200 | 
201 | ```
202 | 
203 | [1]: https://github.com/googlesamples/easypermissions/workflows/test/badge.svg
204 | [2]: https://github.com/googlesamples/easypermissions/actions
205 | [3]: https://img.shields.io/badge/Android%20Weekly-%23185-2CB3E5.svg?style=flat
206 | [4]: http://androidweekly.net/issues/issue-185
207 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/PermissionRequest.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions;
  2 | 
  3 | import android.app.Activity;
  4 | import androidx.annotation.NonNull;
  5 | import androidx.annotation.Nullable;
  6 | import androidx.annotation.RestrictTo;
  7 | import androidx.annotation.Size;
  8 | import androidx.annotation.StringRes;
  9 | import androidx.annotation.StyleRes;
 10 | import androidx.fragment.app.Fragment;
 11 | 
 12 | import java.util.Arrays;
 13 | 
 14 | import pub.devrel.easypermissions.helper.PermissionHelper;
 15 | 
 16 | /**
 17 |  * An immutable model object that holds all of the parameters associated with a permission request,
 18 |  * such as the permissions, request code, and rationale.
 19 |  *
 20 |  * @see EasyPermissions#requestPermissions(PermissionRequest)
 21 |  * @see PermissionRequest.Builder
 22 |  */
 23 | public final class PermissionRequest {
 24 |     private final PermissionHelper mHelper;
 25 |     private final String[] mPerms;
 26 |     private final int mRequestCode;
 27 |     private final String mRationale;
 28 |     private final String mPositiveButtonText;
 29 |     private final String mNegativeButtonText;
 30 |     private final int mTheme;
 31 | 
 32 |     private PermissionRequest(PermissionHelper helper,
 33 |                               String[] perms,
 34 |                               int requestCode,
 35 |                               String rationale,
 36 |                               String positiveButtonText,
 37 |                               String negativeButtonText,
 38 |                               int theme) {
 39 |         mHelper = helper;
 40 |         mPerms = perms.clone();
 41 |         mRequestCode = requestCode;
 42 |         mRationale = rationale;
 43 |         mPositiveButtonText = positiveButtonText;
 44 |         mNegativeButtonText = negativeButtonText;
 45 |         mTheme = theme;
 46 |     }
 47 | 
 48 |     @NonNull
 49 |     @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 50 |     public PermissionHelper getHelper() {
 51 |         return mHelper;
 52 |     }
 53 | 
 54 |     @NonNull
 55 |     public String[] getPerms() {
 56 |         return mPerms.clone();
 57 |     }
 58 | 
 59 |     public int getRequestCode() {
 60 |         return mRequestCode;
 61 |     }
 62 | 
 63 |     @NonNull
 64 |     public String getRationale() {
 65 |         return mRationale;
 66 |     }
 67 | 
 68 |     @NonNull
 69 |     public String getPositiveButtonText() {
 70 |         return mPositiveButtonText;
 71 |     }
 72 | 
 73 |     @NonNull
 74 |     public String getNegativeButtonText() {
 75 |         return mNegativeButtonText;
 76 |     }
 77 | 
 78 |     @StyleRes
 79 |     public int getTheme() {
 80 |         return mTheme;
 81 |     }
 82 | 
 83 |     @Override
 84 |     public boolean equals(Object o) {
 85 |         if (this == o) return true;
 86 |         if (o == null || getClass() != o.getClass()) return false;
 87 | 
 88 |         PermissionRequest request = (PermissionRequest) o;
 89 | 
 90 |         return Arrays.equals(mPerms, request.mPerms) && mRequestCode == request.mRequestCode;
 91 |     }
 92 | 
 93 |     @Override
 94 |     public int hashCode() {
 95 |         int result = Arrays.hashCode(mPerms);
 96 |         result = 31 * result + mRequestCode;
 97 |         return result;
 98 |     }
 99 | 
100 |     @Override
101 |     public String toString() {
102 |         return "PermissionRequest{" +
103 |                 "mHelper=" + mHelper +
104 |                 ", mPerms=" + Arrays.toString(mPerms) +
105 |                 ", mRequestCode=" + mRequestCode +
106 |                 ", mRationale='" + mRationale + '\'' +
107 |                 ", mPositiveButtonText='" + mPositiveButtonText + '\'' +
108 |                 ", mNegativeButtonText='" + mNegativeButtonText + '\'' +
109 |                 ", mTheme=" + mTheme +
110 |                 '}';
111 |     }
112 | 
113 |     /**
114 |      * Builder to build a permission request with variable options.
115 |      *
116 |      * @see PermissionRequest
117 |      */
118 |     public static final class Builder {
119 |         private final PermissionHelper mHelper;
120 |         private final int mRequestCode;
121 |         private final String[] mPerms;
122 | 
123 |         private String mRationale;
124 |         private String mPositiveButtonText;
125 |         private String mNegativeButtonText;
126 |         private int mTheme = -1;
127 | 
128 |         /**
129 |          * Construct a new permission request builder with a host, request code, and the requested
130 |          * permissions.
131 |          *
132 |          * @param activity    the permission request host
133 |          * @param requestCode request code to track this request; must be &lt; 256
134 |          * @param perms       the set of permissions to be requested
135 |          */
136 |         public Builder(@NonNull Activity activity, int requestCode,
137 |                        @NonNull @Size(min = 1) String... perms) {
138 |             mHelper = PermissionHelper.newInstance(activity);
139 |             mRequestCode = requestCode;
140 |             mPerms = perms;
141 |         }
142 | 
143 |         /**
144 |          * @see #Builder(Activity, int, String...)
145 |          */
146 |         public Builder(@NonNull Fragment fragment, int requestCode,
147 |                        @NonNull @Size(min = 1) String... perms) {
148 |             mHelper = PermissionHelper.newInstance(fragment);
149 |             mRequestCode = requestCode;
150 |             mPerms = perms;
151 |         }
152 | 
153 |         /**
154 |          * Set the rationale to display to the user if they don't allow your permissions on the
155 |          * first try. This rationale will be shown as long as the user has denied your permissions
156 |          * at least once, but has not yet permanently denied your permissions. Should the user
157 |          * permanently deny your permissions, use the {@link AppSettingsDialog} instead.
158 |          * <p>
159 |          * The default rationale text is {@link R.string#rationale_ask}.
160 |          *
161 |          * @param rationale the rationale to be displayed to the user should they deny your
162 |          *                  permission at least once
163 |          */
164 |         @NonNull
165 |         public Builder setRationale(@Nullable String rationale) {
166 |             mRationale = rationale;
167 |             return this;
168 |         }
169 | 
170 |         /**
171 |          * @param resId the string resource to be used as a rationale
172 |          * @see #setRationale(String)
173 |          */
174 |         @NonNull
175 |         public Builder setRationale(@StringRes int resId) {
176 |             mRationale = mHelper.getContext().getString(resId);
177 |             return this;
178 |         }
179 | 
180 |         /**
181 |          * Set the positive button text for the rationale dialog should it be shown.
182 |          * <p>
183 |          * The default is {@link android.R.string#ok}
184 |          */
185 |         @NonNull
186 |         public Builder setPositiveButtonText(@Nullable String positiveButtonText) {
187 |             mPositiveButtonText = positiveButtonText;
188 |             return this;
189 |         }
190 | 
191 |         /**
192 |          * @see #setPositiveButtonText(String)
193 |          */
194 |         @NonNull
195 |         public Builder setPositiveButtonText(@StringRes int resId) {
196 |             mPositiveButtonText = mHelper.getContext().getString(resId);
197 |             return this;
198 |         }
199 | 
200 |         /**
201 |          * Set the negative button text for the rationale dialog should it be shown.
202 |          * <p>
203 |          * The default is {@link android.R.string#cancel}
204 |          */
205 |         @NonNull
206 |         public Builder setNegativeButtonText(@Nullable String negativeButtonText) {
207 |             mNegativeButtonText = negativeButtonText;
208 |             return this;
209 |         }
210 | 
211 |         /**
212 |          * @see #setNegativeButtonText(String)
213 |          */
214 |         @NonNull
215 |         public Builder setNegativeButtonText(@StringRes int resId) {
216 |             mNegativeButtonText = mHelper.getContext().getString(resId);
217 |             return this;
218 |         }
219 | 
220 |         /**
221 |          * Set the theme to be used for the rationale dialog should it be shown.
222 |          *
223 |          * @param theme a style resource
224 |          */
225 |         @NonNull
226 |         public Builder setTheme(@StyleRes int theme) {
227 |             mTheme = theme;
228 |             return this;
229 |         }
230 | 
231 |         /**
232 |          * Build the permission request.
233 |          *
234 |          * @return the permission request
235 |          * @see EasyPermissions#requestPermissions(PermissionRequest)
236 |          * @see PermissionRequest
237 |          */
238 |         @NonNull
239 |         public PermissionRequest build() {
240 |             if (mRationale == null) {
241 |                 mRationale = mHelper.getContext().getString(R.string.rationale_ask);
242 |             }
243 |             if (mPositiveButtonText == null) {
244 |                 mPositiveButtonText = mHelper.getContext().getString(android.R.string.ok);
245 |             }
246 |             if (mNegativeButtonText == null) {
247 |                 mNegativeButtonText = mHelper.getContext().getString(android.R.string.cancel);
248 |             }
249 | 
250 |             return new PermissionRequest(
251 |                     mHelper,
252 |                     mPerms,
253 |                     mRequestCode,
254 |                     mRationale,
255 |                     mPositiveButtonText,
256 |                     mNegativeButtonText,
257 |                     mTheme);
258 |         }
259 |     }
260 | }
261 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 | Version 2.0, January 2004
  3 | http://www.apache.org/licenses/
  4 | 
  5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 | 1. Definitions.
  8 | 
  9 | "License" shall mean the terms and conditions for use, reproduction, and
 10 | distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 | "Licensor" shall mean the copyright owner or entity authorized by the copyright
 13 | owner that is granting the License.
 14 | 
 15 | "Legal Entity" shall mean the union of the acting entity and all other entities
 16 | that control, are controlled by, or are under common control with that entity.
 17 | For the purposes of this definition, "control" means (i) the power, direct or
 18 | indirect, to cause the direction or management of such entity, whether by
 19 | contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
 20 | outstanding shares, or (iii) beneficial ownership of such entity.
 21 | 
 22 | "You" (or "Your") shall mean an individual or Legal Entity exercising
 23 | permissions granted by this License.
 24 | 
 25 | "Source" form shall mean the preferred form for making modifications, including
 26 | but not limited to software source code, documentation source, and configuration
 27 | files.
 28 | 
 29 | "Object" form shall mean any form resulting from mechanical transformation or
 30 | translation of a Source form, including but not limited to compiled object code,
 31 | generated documentation, and conversions to other media types.
 32 | 
 33 | "Work" shall mean the work of authorship, whether in Source or Object form, made
 34 | available under the License, as indicated by a copyright notice that is included
 35 | in or attached to the work (an example is provided in the Appendix below).
 36 | 
 37 | "Derivative Works" shall mean any work, whether in Source or Object form, that
 38 | is based on (or derived from) the Work and for which the editorial revisions,
 39 | annotations, elaborations, or other modifications represent, as a whole, an
 40 | original work of authorship. For the purposes of this License, Derivative Works
 41 | shall not include works that remain separable from, or merely link (or bind by
 42 | name) to the interfaces of, the Work and Derivative Works thereof.
 43 | 
 44 | "Contribution" shall mean any work of authorship, including the original version
 45 | of the Work and any modifications or additions to that Work or Derivative Works
 46 | thereof, that is intentionally submitted to Licensor for inclusion in the Work
 47 | by the copyright owner or by an individual or Legal Entity authorized to submit
 48 | on behalf of the copyright owner. For the purposes of this definition,
 49 | "submitted" means any form of electronic, verbal, or written communication sent
 50 | to the Licensor or its representatives, including but not limited to
 51 | communication on electronic mailing lists, source code control systems, and
 52 | issue tracking systems that are managed by, or on behalf of, the Licensor for
 53 | the purpose of discussing and improving the Work, but excluding communication
 54 | that is conspicuously marked or otherwise designated in writing by the copyright
 55 | owner as "Not a Contribution."
 56 | 
 57 | "Contributor" shall mean Licensor and any individual or Legal Entity on behalf
 58 | of whom a Contribution has been received by Licensor and subsequently
 59 | incorporated within the Work.
 60 | 
 61 | 2. Grant of Copyright License.
 62 | 
 63 | Subject to the terms and conditions of this License, each Contributor hereby
 64 | grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 65 | irrevocable copyright license to reproduce, prepare Derivative Works of,
 66 | publicly display, publicly perform, sublicense, and distribute the Work and such
 67 | Derivative Works in Source or Object form.
 68 | 
 69 | 3. Grant of Patent License.
 70 | 
 71 | Subject to the terms and conditions of this License, each Contributor hereby
 72 | grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 73 | irrevocable (except as stated in this section) patent license to make, have
 74 | made, use, offer to sell, sell, import, and otherwise transfer the Work, where
 75 | such license applies only to those patent claims licensable by such Contributor
 76 | that are necessarily infringed by their Contribution(s) alone or by combination
 77 | of their Contribution(s) with the Work to which such Contribution(s) was
 78 | submitted. If You institute patent litigation against any entity (including a
 79 | cross-claim or counterclaim in a lawsuit) alleging that the Work or a
 80 | Contribution incorporated within the Work constitutes direct or contributory
 81 | patent infringement, then any patent licenses granted to You under this License
 82 | for that Work shall terminate as of the date such litigation is filed.
 83 | 
 84 | 4. Redistribution.
 85 | 
 86 | You may reproduce and distribute copies of the Work or Derivative Works thereof
 87 | in any medium, with or without modifications, and in Source or Object form,
 88 | provided that You meet the following conditions:
 89 | 
 90 | You must give any other recipients of the Work or Derivative Works a copy of
 91 | this License; and
 92 | You must cause any modified files to carry prominent notices stating that You
 93 | changed the files; and
 94 | You must retain, in the Source form of any Derivative Works that You distribute,
 95 | all copyright, patent, trademark, and attribution notices from the Source form
 96 | of the Work, excluding those notices that do not pertain to any part of the
 97 | Derivative Works; and
 98 | If the Work includes a "NOTICE" text file as part of its distribution, then any
 99 | Derivative Works that You distribute must include a readable copy of the
100 | attribution notices contained within such NOTICE file, excluding those notices
101 | that do not pertain to any part of the Derivative Works, in at least one of the
102 | following places: within a NOTICE text file distributed as part of the
103 | Derivative Works; within the Source form or documentation, if provided along
104 | with the Derivative Works; or, within a display generated by the Derivative
105 | Works, if and wherever such third-party notices normally appear. The contents of
106 | the NOTICE file are for informational purposes only and do not modify the
107 | License. You may add Your own attribution notices within Derivative Works that
108 | You distribute, alongside or as an addendum to the NOTICE text from the Work,
109 | provided that such additional attribution notices cannot be construed as
110 | modifying the License.
111 | You may add Your own copyright statement to Your modifications and may provide
112 | additional or different license terms and conditions for use, reproduction, or
113 | distribution of Your modifications, or for any such Derivative Works as a whole,
114 | provided Your use, reproduction, and distribution of the Work otherwise complies
115 | with the conditions stated in this License.
116 | 
117 | 5. Submission of Contributions.
118 | 
119 | Unless You explicitly state otherwise, any Contribution intentionally submitted
120 | for inclusion in the Work by You to the Licensor shall be under the terms and
121 | conditions of this License, without any additional terms or conditions.
122 | Notwithstanding the above, nothing herein shall supersede or modify the terms of
123 | any separate license agreement you may have executed with Licensor regarding
124 | such Contributions.
125 | 
126 | 6. Trademarks.
127 | 
128 | This License does not grant permission to use the trade names, trademarks,
129 | service marks, or product names of the Licensor, except as required for
130 | reasonable and customary use in describing the origin of the Work and
131 | reproducing the content of the NOTICE file.
132 | 
133 | 7. Disclaimer of Warranty.
134 | 
135 | Unless required by applicable law or agreed to in writing, Licensor provides the
136 | Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
137 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
138 | including, without limitation, any warranties or conditions of TITLE,
139 | NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
140 | solely responsible for determining the appropriateness of using or
141 | redistributing the Work and assume any risks associated with Your exercise of
142 | permissions under this License.
143 | 
144 | 8. Limitation of Liability.
145 | 
146 | In no event and under no legal theory, whether in tort (including negligence),
147 | contract, or otherwise, unless required by applicable law (such as deliberate
148 | and grossly negligent acts) or agreed to in writing, shall any Contributor be
149 | liable to You for damages, including any direct, indirect, special, incidental,
150 | or consequential damages of any character arising as a result of this License or
151 | out of the use or inability to use the Work (including but not limited to
152 | damages for loss of goodwill, work stoppage, computer failure or malfunction, or
153 | any and all other commercial damages or losses), even if such Contributor has
154 | been advised of the possibility of such damages.
155 | 
156 | 9. Accepting Warranty or Additional Liability.
157 | 
158 | While redistributing the Work or Derivative Works thereof, You may choose to
159 | offer, and charge a fee for, acceptance of support, warranty, indemnity, or
160 | other liability obligations and/or rights consistent with this License. However,
161 | in accepting such obligations, You may act only on Your own behalf and on Your
162 | sole responsibility, not on behalf of any other Contributor, and only if You
163 | agree to indemnify, defend, and hold each Contributor harmless for any liability
164 | incurred by, or claims asserted against, such Contributor by reason of your
165 | accepting any such warranty or additional liability.
166 | 
167 | END OF TERMS AND CONDITIONS
168 | 
169 | APPENDIX: How to apply the Apache License to your work
170 | 
171 | To apply the Apache License to your work, attach the following boilerplate
172 | notice, with the fields enclosed by brackets "[]" replaced with your own
173 | identifying information. (Don't include the brackets!) The text should be
174 | enclosed in the appropriate comment syntax for the file format. We also
175 | recommend that a file or class name and description of purpose be included on
176 | the same "printed page" as the copyright notice for easier identification within
177 | third-party archives.
178 | 
179 |    Copyright 2017 Google
180 | 
181 |    Licensed under the Apache License, Version 2.0 (the "License");
182 |    you may not use this file except in compliance with the License.
183 |    You may obtain a copy of the License at
184 | 
185 |      http://www.apache.org/licenses/LICENSE-2.0
186 | 
187 |    Unless required by applicable law or agreed to in writing, software
188 |    distributed under the License is distributed on an "AS IS" BASIS,
189 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
190 |    See the License for the specific language governing permissions and
191 |    limitations under the License.
192 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/AppSettingsDialog.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions;
  2 | 
  3 | import android.app.Activity;
  4 | import android.content.Context;
  5 | import android.content.DialogInterface;
  6 | import android.content.Intent;
  7 | import android.os.Parcel;
  8 | import android.os.Parcelable;
  9 | import android.text.TextUtils;
 10 | import android.util.Log;
 11 | 
 12 | import androidx.annotation.NonNull;
 13 | import androidx.annotation.Nullable;
 14 | import androidx.annotation.RestrictTo;
 15 | import androidx.annotation.StringRes;
 16 | import androidx.annotation.StyleRes;
 17 | import androidx.appcompat.app.AlertDialog;
 18 | import androidx.fragment.app.Fragment;
 19 | 
 20 | /**
 21 |  * Dialog to prompt the user to go to the app's settings screen and enable permissions. If the user
 22 |  * clicks 'OK' on the dialog, they are sent to the settings screen. The result is returned to the
 23 |  * Activity via {@see Activity#onActivityResult(int, int, Intent)}.
 24 |  * <p>
 25 |  * Use the {@link Builder} to create and display a dialog.
 26 |  */
 27 | public class AppSettingsDialog implements Parcelable {
 28 | 
 29 |     private static final String TAG = "EasyPermissions";
 30 | 
 31 |     public static final int DEFAULT_SETTINGS_REQ_CODE = 16061;
 32 | 
 33 |     @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 34 |     public static final Parcelable.Creator<AppSettingsDialog> CREATOR = new Parcelable.Creator<AppSettingsDialog>() {
 35 |         @Override
 36 |         public AppSettingsDialog createFromParcel(Parcel in) {
 37 |             return new AppSettingsDialog(in);
 38 |         }
 39 | 
 40 |         @Override
 41 |         public AppSettingsDialog[] newArray(int size) {
 42 |             return new AppSettingsDialog[size];
 43 |         }
 44 |     };
 45 | 
 46 |     static final String EXTRA_APP_SETTINGS = "extra_app_settings";
 47 | 
 48 |     @StyleRes
 49 |     private final int mThemeResId;
 50 |     private final String mRationale;
 51 |     private final String mTitle;
 52 |     private final String mPositiveButtonText;
 53 |     private final String mNegativeButtonText;
 54 |     private final int mRequestCode;
 55 |     private final int mIntentFlags;
 56 | 
 57 |     private Object mActivityOrFragment;
 58 |     private Context mContext;
 59 | 
 60 |     private AppSettingsDialog(Parcel in) {
 61 |         mThemeResId = in.readInt();
 62 |         mRationale = in.readString();
 63 |         mTitle = in.readString();
 64 |         mPositiveButtonText = in.readString();
 65 |         mNegativeButtonText = in.readString();
 66 |         mRequestCode = in.readInt();
 67 |         mIntentFlags = in.readInt();
 68 |     }
 69 | 
 70 |     private AppSettingsDialog(@NonNull final Object activityOrFragment,
 71 |                               @StyleRes int themeResId,
 72 |                               @Nullable String rationale,
 73 |                               @Nullable String title,
 74 |                               @Nullable String positiveButtonText,
 75 |                               @Nullable String negativeButtonText,
 76 |                               int requestCode,
 77 |                               int intentFlags) {
 78 |         setActivityOrFragment(activityOrFragment);
 79 |         mThemeResId = themeResId;
 80 |         mRationale = rationale;
 81 |         mTitle = title;
 82 |         mPositiveButtonText = positiveButtonText;
 83 |         mNegativeButtonText = negativeButtonText;
 84 |         mRequestCode = requestCode;
 85 |         mIntentFlags = intentFlags;
 86 |     }
 87 | 
 88 |     static AppSettingsDialog fromIntent(Intent intent, Activity activity) {
 89 |         AppSettingsDialog dialog = intent.getParcelableExtra(AppSettingsDialog.EXTRA_APP_SETTINGS);
 90 | 
 91 |         // It's not clear how this could happen, but in the case that it does we should try
 92 |         // to avoid a runtime crash and just use the default dialog.
 93 |         // https://github.com/googlesamples/easypermissions/issues/278
 94 |         if (dialog == null) {
 95 |             Log.e(TAG, "Intent contains null value for EXTRA_APP_SETTINGS: "
 96 |                     + "intent=" + intent
 97 |                     + ", "
 98 |                     + "extras=" + intent.getExtras());
 99 | 
100 |             dialog = new AppSettingsDialog.Builder(activity).build();
101 |         }
102 | 
103 |         dialog.setActivityOrFragment(activity);
104 |         return dialog;
105 |     }
106 | 
107 |     private void setActivityOrFragment(Object activityOrFragment) {
108 |         mActivityOrFragment = activityOrFragment;
109 | 
110 |         if (activityOrFragment instanceof Activity) {
111 |             mContext = (Activity) activityOrFragment;
112 |         } else if (activityOrFragment instanceof Fragment) {
113 |             mContext = ((Fragment) activityOrFragment).getContext();
114 |         } else {
115 |             throw new IllegalStateException("Unknown object: " + activityOrFragment);
116 |         }
117 |     }
118 | 
119 |     private void startForResult(Intent intent) {
120 |         if (mActivityOrFragment instanceof Activity) {
121 |             ((Activity) mActivityOrFragment).startActivityForResult(intent, mRequestCode);
122 |         } else if (mActivityOrFragment instanceof Fragment) {
123 |             ((Fragment) mActivityOrFragment).startActivityForResult(intent, mRequestCode);
124 |         }
125 |     }
126 | 
127 |     /**
128 |      * Display the built dialog.
129 |      */
130 |     public void show() {
131 |         startForResult(AppSettingsDialogHolderActivity.createShowDialogIntent(mContext, this));
132 |     }
133 | 
134 |     /**
135 |      * Show the dialog. {@link #show()} is a wrapper to ensure backwards compatibility
136 |      */
137 |     AlertDialog showDialog(DialogInterface.OnClickListener positiveListener,
138 |                            DialogInterface.OnClickListener negativeListener) {
139 |         AlertDialog.Builder builder;
140 |         if (mThemeResId != -1) {
141 |             builder = new AlertDialog.Builder(mContext, mThemeResId);
142 |         } else {
143 |             builder = new AlertDialog.Builder(mContext);
144 |         }
145 |         return builder
146 |                 .setCancelable(false)
147 |                 .setTitle(mTitle)
148 |                 .setMessage(mRationale)
149 |                 .setPositiveButton(mPositiveButtonText, positiveListener)
150 |                 .setNegativeButton(mNegativeButtonText, negativeListener)
151 |                 .show();
152 |     }
153 | 
154 |     @Override
155 |     public int describeContents() {
156 |         return 0;
157 |     }
158 | 
159 |     @Override
160 |     public void writeToParcel(@NonNull Parcel dest, int flags) {
161 |         dest.writeInt(mThemeResId);
162 |         dest.writeString(mRationale);
163 |         dest.writeString(mTitle);
164 |         dest.writeString(mPositiveButtonText);
165 |         dest.writeString(mNegativeButtonText);
166 |         dest.writeInt(mRequestCode);
167 |         dest.writeInt(mIntentFlags);
168 |     }
169 | 
170 |     int getIntentFlags() {
171 |         return mIntentFlags;
172 |     }
173 | 
174 |     /**
175 |      * Builder for an {@link AppSettingsDialog}.
176 |      */
177 |     public static class Builder {
178 | 
179 |         private final Object mActivityOrFragment;
180 |         private final Context mContext;
181 |         @StyleRes
182 |         private int mThemeResId = -1;
183 |         private String mRationale;
184 |         private String mTitle;
185 |         private String mPositiveButtonText;
186 |         private String mNegativeButtonText;
187 |         private int mRequestCode = -1;
188 |         private boolean mOpenInNewTask = false;
189 | 
190 |         /**
191 |          * Create a new Builder for an {@link AppSettingsDialog}.
192 |          *
193 |          * @param activity the {@link Activity} in which to display the dialog.
194 |          */
195 |         public Builder(@NonNull Activity activity) {
196 |             mActivityOrFragment = activity;
197 |             mContext = activity;
198 |         }
199 | 
200 |         /**
201 |          * Create a new Builder for an {@link AppSettingsDialog}.
202 |          *
203 |          * @param fragment the {@link Fragment} in which to display the dialog.
204 |          */
205 |         public Builder(@NonNull Fragment fragment) {
206 |             mActivityOrFragment = fragment;
207 |             mContext = fragment.getContext();
208 |         }
209 | 
210 |         /**
211 |          * Set the dialog theme.
212 |          */
213 |         @NonNull
214 |         public Builder setThemeResId(@StyleRes int themeResId) {
215 |             mThemeResId = themeResId;
216 |             return this;
217 |         }
218 | 
219 |         /**
220 |          * Set the title dialog. Default is "Permissions Required".
221 |          */
222 |         @NonNull
223 |         public Builder setTitle(@Nullable String title) {
224 |             mTitle = title;
225 |             return this;
226 |         }
227 | 
228 |         /**
229 |          * Set the title dialog. Default is "Permissions Required".
230 |          */
231 |         @NonNull
232 |         public Builder setTitle(@StringRes int title) {
233 |             mTitle = mContext.getString(title);
234 |             return this;
235 |         }
236 | 
237 |         /**
238 |          * Set the rationale dialog. Default is
239 |          * "This app may not work correctly without the requested permissions.
240 |          * Open the app settings screen to modify app permissions."
241 |          */
242 |         @NonNull
243 |         public Builder setRationale(@Nullable String rationale) {
244 |             mRationale = rationale;
245 |             return this;
246 |         }
247 | 
248 |         /**
249 |          * Set the rationale dialog. Default is
250 |          * "This app may not work correctly without the requested permissions.
251 |          * Open the app settings screen to modify app permissions."
252 |          */
253 |         @NonNull
254 |         public Builder setRationale(@StringRes int rationale) {
255 |             mRationale = mContext.getString(rationale);
256 |             return this;
257 |         }
258 | 
259 |         /**
260 |          * Set the positive button text, default is {@link android.R.string#ok}.
261 |          */
262 |         @NonNull
263 |         public Builder setPositiveButton(@Nullable String text) {
264 |             mPositiveButtonText = text;
265 |             return this;
266 |         }
267 | 
268 |         /**
269 |          * Set the positive button text, default is {@link android.R.string#ok}.
270 |          */
271 |         @NonNull
272 |         public Builder setPositiveButton(@StringRes int textId) {
273 |             mPositiveButtonText = mContext.getString(textId);
274 |             return this;
275 |         }
276 | 
277 |         /**
278 |          * Set the negative button text, default is {@link android.R.string#cancel}.
279 |          * <p>
280 |          * To know if a user cancelled the request, check if your permissions were given with {@link
281 |          * EasyPermissions#hasPermissions(Context, String...)} in {@see
282 |          * Activity#onActivityResult(int, int, Intent)}. If you still don't have the right
283 |          * permissions, then the request was cancelled.
284 |          */
285 |         @NonNull
286 |         public Builder setNegativeButton(@Nullable String text) {
287 |             mNegativeButtonText = text;
288 |             return this;
289 |         }
290 | 
291 |         /**
292 |          * Set the negative button text, default is {@link android.R.string#cancel}.
293 |          */
294 |         @NonNull
295 |         public Builder setNegativeButton(@StringRes int textId) {
296 |             mNegativeButtonText = mContext.getString(textId);
297 |             return this;
298 |         }
299 | 
300 |         /**
301 |          * Set the request code use when launching the Settings screen for result, can be retrieved
302 |          * in the calling Activity's {@see Activity#onActivityResult(int, int, Intent)} method.
303 |          * Default is {@link #DEFAULT_SETTINGS_REQ_CODE}.
304 |          */
305 |         @NonNull
306 |         public Builder setRequestCode(int requestCode) {
307 |             mRequestCode = requestCode;
308 |             return this;
309 |         }
310 | 
311 |         /**
312 |          * Set whether the settings screen should be opened in a separate task. This is achieved by
313 |          * setting {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK#FLAG_ACTIVITY_NEW_TASK} on
314 |          * the Intent used to open the settings screen.
315 |          */
316 |         @NonNull
317 |         public Builder setOpenInNewTask(boolean openInNewTask) {
318 |             mOpenInNewTask = openInNewTask;
319 |             return this;
320 |         }
321 | 
322 |         /**
323 |          * Build the {@link AppSettingsDialog} from the specified options. Generally followed by a
324 |          * call to {@link AppSettingsDialog#show()}.
325 |          */
326 |         @NonNull
327 |         public AppSettingsDialog build() {
328 |             mRationale = TextUtils.isEmpty(mRationale) ?
329 |                     mContext.getString(R.string.rationale_ask_again) : mRationale;
330 |             mTitle = TextUtils.isEmpty(mTitle) ?
331 |                     mContext.getString(R.string.title_settings_dialog) : mTitle;
332 |             mPositiveButtonText = TextUtils.isEmpty(mPositiveButtonText) ?
333 |                     mContext.getString(android.R.string.ok) : mPositiveButtonText;
334 |             mNegativeButtonText = TextUtils.isEmpty(mNegativeButtonText) ?
335 |                     mContext.getString(android.R.string.cancel) : mNegativeButtonText;
336 |             mRequestCode = mRequestCode > 0 ? mRequestCode : DEFAULT_SETTINGS_REQ_CODE;
337 | 
338 |             int intentFlags = 0;
339 |             if (mOpenInNewTask) {
340 |                 intentFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
341 |             }
342 | 
343 |             return new AppSettingsDialog(
344 |                     mActivityOrFragment,
345 |                     mThemeResId,
346 |                     mRationale,
347 |                     mTitle,
348 |                     mPositiveButtonText,
349 |                     mNegativeButtonText,
350 |                     mRequestCode,
351 |                     intentFlags);
352 |         }
353 | 
354 |     }
355 | 
356 | }
357 | 


--------------------------------------------------------------------------------
/easypermissions/src/main/java/pub/devrel/easypermissions/EasyPermissions.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Google Inc. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package pub.devrel.easypermissions;
 17 | 
 18 | import android.Manifest;
 19 | import android.app.Activity;
 20 | import android.content.Context;
 21 | import android.content.pm.PackageManager;
 22 | import android.os.Build;
 23 | import androidx.annotation.IntRange;
 24 | import androidx.annotation.NonNull;
 25 | import androidx.annotation.Size;
 26 | import androidx.core.app.ActivityCompat;
 27 | import androidx.fragment.app.Fragment;
 28 | import androidx.core.content.ContextCompat;
 29 | import android.util.Log;
 30 | import java.lang.reflect.InvocationTargetException;
 31 | import java.lang.reflect.Method;
 32 | import java.util.ArrayList;
 33 | import java.util.List;
 34 | import pub.devrel.easypermissions.helper.PermissionHelper;
 35 | 
 36 | /**
 37 |  * Utility to request and check System permissions for apps targeting Android M (API &gt;= 23).
 38 |  */
 39 | public class EasyPermissions {
 40 | 
 41 |     /**
 42 |      * Callback interface to receive the results of {@code EasyPermissions.requestPermissions()}
 43 |      * calls.
 44 |      */
 45 |     public interface PermissionCallbacks extends ActivityCompat.OnRequestPermissionsResultCallback {
 46 | 
 47 |         void onPermissionsGranted(int requestCode, @NonNull List<String> perms);
 48 | 
 49 |         void onPermissionsDenied(int requestCode, @NonNull List<String> perms);
 50 |     }
 51 | 
 52 |     /**
 53 |      * Callback interface to receive button clicked events of the rationale dialog
 54 |      */
 55 |     public interface RationaleCallbacks {
 56 |         void onRationaleAccepted(int requestCode);
 57 | 
 58 |         void onRationaleDenied(int requestCode);
 59 |     }
 60 | 
 61 |     private static final String TAG = "EasyPermissions";
 62 | 
 63 |     /**
 64 |      * Check if the calling context has a set of permissions.
 65 |      *
 66 |      * @param context the calling context.
 67 |      * @param perms   one ore more permissions, such as {@link Manifest.permission#CAMERA}.
 68 |      * @return true if all permissions are already granted, false if at least one permission is not
 69 |      * yet granted.
 70 |      * @see Manifest.permission
 71 |      */
 72 |     public static boolean hasPermissions(@NonNull Context context,
 73 |                                          @Size(min = 1) @NonNull String... perms) {
 74 |         // Always return true for SDK < M, let the system deal with the permissions
 75 |         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
 76 |             Log.w(TAG, "hasPermissions: API version < M, returning true by default");
 77 | 
 78 |             // DANGER ZONE!!! Changing this will break the library.
 79 |             return true;
 80 |         }
 81 | 
 82 |         // Null context may be passed if we have detected Low API (less than M) so getting
 83 |         // to this point with a null context should not be possible.
 84 |         if (context == null) {
 85 |             throw new IllegalArgumentException("Can't check permissions for null context");
 86 |         }
 87 | 
 88 |         for (String perm : perms) {
 89 |             if (ContextCompat.checkSelfPermission(context, perm)
 90 |                     != PackageManager.PERMISSION_GRANTED) {
 91 |                 return false;
 92 |             }
 93 |         }
 94 | 
 95 |         return true;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Request a set of permissions, showing a rationale if the system requests it.
100 |      *
101 |      * @param host        requesting context.
102 |      * @param rationale   a message explaining why the application needs this set of permissions;
103 |      *                    will be displayed if the user rejects the request the first time.
104 |      * @param requestCode request code to track this request, must be &lt; 256.
105 |      * @param perms       a set of permissions to be requested.
106 |      * @see Manifest.permission
107 |      */
108 |     public static void requestPermissions(
109 |             @NonNull Activity host, @NonNull String rationale,
110 |             @IntRange(from = 0, to = 255) int requestCode, @Size(min = 1) @NonNull String... perms) {
111 |         requestPermissions(
112 |                 new PermissionRequest.Builder(host, requestCode, perms)
113 |                         .setRationale(rationale)
114 |                         .build());
115 |     }
116 | 
117 |     /**
118 |      * Request permissions from a Support Fragment with standard OK/Cancel buttons.
119 |      *
120 |      * @see #requestPermissions(Activity, String, int, String...)
121 |      */
122 |     public static void requestPermissions(
123 |             @NonNull Fragment host, @NonNull String rationale,
124 |             @IntRange(from = 0, to = 255) int requestCode, @Size(min = 1) @NonNull String... perms) {
125 |         requestPermissions(
126 |                 new PermissionRequest.Builder(host, requestCode, perms)
127 |                         .setRationale(rationale)
128 |                         .build());
129 |     }
130 | 
131 |     /**
132 |      * Request a set of permissions.
133 |      *
134 |      * @param request the permission request
135 |      * @see PermissionRequest
136 |      */
137 |     public static void requestPermissions(PermissionRequest request) {
138 | 
139 |         // Check for permissions before dispatching the request
140 |         if (hasPermissions(request.getHelper().getContext(), request.getPerms())) {
141 |             notifyAlreadyHasPermissions(
142 |                     request.getHelper().getHost(), request.getRequestCode(), request.getPerms());
143 |             return;
144 |         }
145 | 
146 |         // Request permissions
147 |         request.getHelper().requestPermissions(
148 |                 request.getRationale(),
149 |                 request.getPositiveButtonText(),
150 |                 request.getNegativeButtonText(),
151 |                 request.getTheme(),
152 |                 request.getRequestCode(),
153 |                 request.getPerms());
154 |     }
155 | 
156 |     /**
157 |      * Handle the result of a permission request, should be called from the calling {@link
158 |      * Activity}'s {@link ActivityCompat.OnRequestPermissionsResultCallback#onRequestPermissionsResult(int,
159 |      * String[], int[])} method.
160 |      * <p>
161 |      * If any permissions were granted or denied, the {@code object} will receive the appropriate
162 |      * callbacks through {@link PermissionCallbacks} and methods annotated with {@link
163 |      * AfterPermissionGranted} will be run if appropriate.
164 |      *
165 |      * @param requestCode  requestCode argument to permission result callback.
166 |      * @param permissions  permissions argument to permission result callback.
167 |      * @param grantResults grantResults argument to permission result callback.
168 |      * @param receivers    an array of objects that have a method annotated with {@link
169 |      *                     AfterPermissionGranted} or implement {@link PermissionCallbacks}.
170 |      */
171 |     public static void onRequestPermissionsResult(@IntRange(from = 0, to = 255) int requestCode,
172 |                                                   @NonNull String[] permissions,
173 |                                                   @NonNull int[] grantResults,
174 |                                                   @NonNull Object... receivers) {
175 |         // Make a collection of granted and denied permissions from the request.
176 |         List<String> granted = new ArrayList<>();
177 |         List<String> denied = new ArrayList<>();
178 |         for (int i = 0; i < permissions.length; i++) {
179 |             String perm = permissions[i];
180 |             if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
181 |                 granted.add(perm);
182 |             } else {
183 |                 denied.add(perm);
184 |             }
185 |         }
186 | 
187 |         // iterate through all receivers
188 |         for (Object object : receivers) {
189 |             // Report granted permissions, if any.
190 |             if (!granted.isEmpty()) {
191 |                 if (object instanceof PermissionCallbacks) {
192 |                     ((PermissionCallbacks) object).onPermissionsGranted(requestCode, granted);
193 |                 }
194 |             }
195 | 
196 |             // Report denied permissions, if any.
197 |             if (!denied.isEmpty()) {
198 |                 if (object instanceof PermissionCallbacks) {
199 |                     ((PermissionCallbacks) object).onPermissionsDenied(requestCode, denied);
200 |                 }
201 |             }
202 | 
203 |             // If 100% successful, call annotated methods
204 |             if (!granted.isEmpty() && denied.isEmpty()) {
205 |                 runAnnotatedMethods(object, requestCode);
206 |             }
207 |         }
208 |     }
209 | 
210 |     /**
211 |      * Check if at least one permission in the list of denied permissions has been permanently
212 |      * denied (user clicked "Never ask again").
213 |      *
214 |      * <b>Note</b>: Due to a limitation in the information provided by the Android
215 |      * framework permissions API, this method only works after the permission
216 |      * has been denied and your app has received the onPermissionsDenied callback.
217 |      * Otherwise the library cannot distinguish permanent denial from the
218 |      * "not yet denied" case.
219 |      *
220 |      * @param host              context requesting permissions.
221 |      * @param deniedPermissions list of denied permissions, usually from {@link
222 |      *                          PermissionCallbacks#onPermissionsDenied(int, List)}
223 |      * @return {@code true} if at least one permission in the list was permanently denied.
224 |      */
225 |     public static boolean somePermissionPermanentlyDenied(@NonNull Activity host,
226 |                                                           @NonNull List<String> deniedPermissions) {
227 |         return PermissionHelper.newInstance(host)
228 |                 .somePermissionPermanentlyDenied(deniedPermissions);
229 |     }
230 | 
231 |     /**
232 |      * @see #somePermissionPermanentlyDenied(Activity, List)
233 |      */
234 |     public static boolean somePermissionPermanentlyDenied(@NonNull Fragment host,
235 |                                                           @NonNull List<String> deniedPermissions) {
236 |         return PermissionHelper.newInstance(host)
237 |                 .somePermissionPermanentlyDenied(deniedPermissions);
238 |     }
239 | 
240 |     /**
241 |      * Check if a permission has been permanently denied (user clicked "Never ask again").
242 |      *
243 |      * @param host             context requesting permissions.
244 |      * @param deniedPermission denied permission.
245 |      * @return {@code true} if the permissions has been permanently denied.
246 |      */
247 |     public static boolean permissionPermanentlyDenied(@NonNull Activity host,
248 |                                                       @NonNull String deniedPermission) {
249 |         return PermissionHelper.newInstance(host).permissionPermanentlyDenied(deniedPermission);
250 |     }
251 | 
252 |     /**
253 |      * @see #permissionPermanentlyDenied(Activity, String)
254 |      */
255 |     public static boolean permissionPermanentlyDenied(@NonNull Fragment host,
256 |                                                       @NonNull String deniedPermission) {
257 |         return PermissionHelper.newInstance(host).permissionPermanentlyDenied(deniedPermission);
258 |     }
259 | 
260 |     /**
261 |      * See if some denied permission has been permanently denied.
262 |      *
263 |      * @param host  requesting context.
264 |      * @param perms array of permissions.
265 |      * @return true if the user has previously denied any of the {@code perms} and we should show a
266 |      * rationale, false otherwise.
267 |      */
268 |     public static boolean somePermissionDenied(@NonNull Activity host,
269 |                                                @NonNull String... perms) {
270 |         return PermissionHelper.newInstance(host).somePermissionDenied(perms);
271 |     }
272 | 
273 |     /**
274 |      * @see #somePermissionDenied(Activity, String...)
275 |      */
276 |     public static boolean somePermissionDenied(@NonNull Fragment host,
277 |                                                @NonNull String... perms) {
278 |         return PermissionHelper.newInstance(host).somePermissionDenied(perms);
279 |     }
280 | 
281 |     /**
282 |      * Run permission callbacks on an object that requested permissions but already has them by
283 |      * simulating {@link PackageManager#PERMISSION_GRANTED}.
284 |      *
285 |      * @param object      the object requesting permissions.
286 |      * @param requestCode the permission request code.
287 |      * @param perms       a list of permissions requested.
288 |      */
289 |     private static void notifyAlreadyHasPermissions(@NonNull Object object,
290 |                                                     int requestCode,
291 |                                                     @NonNull String[] perms) {
292 |         int[] grantResults = new int[perms.length];
293 |         for (int i = 0; i < perms.length; i++) {
294 |             grantResults[i] = PackageManager.PERMISSION_GRANTED;
295 |         }
296 | 
297 |         onRequestPermissionsResult(requestCode, perms, grantResults, object);
298 |     }
299 | 
300 |     /**
301 |      * Find all methods annotated with {@link AfterPermissionGranted} on a given object with the
302 |      * correct requestCode argument.
303 |      *
304 |      * @param object      the object with annotated methods.
305 |      * @param requestCode the requestCode passed to the annotation.
306 |      */
307 |     private static void runAnnotatedMethods(@NonNull Object object, int requestCode) {
308 |         Class clazz = object.getClass();
309 |         if (isUsingAndroidAnnotations(object)) {
310 |             clazz = clazz.getSuperclass();
311 |         }
312 | 
313 |         while (clazz != null) {
314 |             for (Method method : clazz.getDeclaredMethods()) {
315 |                 AfterPermissionGranted ann = method.getAnnotation(AfterPermissionGranted.class);
316 |                 if (ann != null) {
317 |                     // Check for annotated methods with matching request code.
318 |                     if (ann.value() == requestCode) {
319 |                         // Method must be void so that we can invoke it
320 |                         if (method.getParameterTypes().length > 0) {
321 |                             throw new RuntimeException(
322 |                                     "Cannot execute method " + method.getName() + " because it is non-void method and/or has input parameters.");
323 |                         }
324 | 
325 |                         try {
326 |                             // Make method accessible if private
327 |                             if (!method.isAccessible()) {
328 |                                 method.setAccessible(true);
329 |                             }
330 |                             method.invoke(object);
331 |                         } catch (IllegalAccessException e) {
332 |                             Log.e(TAG, "runDefaultMethod:IllegalAccessException", e);
333 |                         } catch (InvocationTargetException e) {
334 |                             Log.e(TAG, "runDefaultMethod:InvocationTargetException", e);
335 |                         }
336 |                     }
337 |                 }
338 |             }
339 | 
340 |             clazz = clazz.getSuperclass();
341 |         }
342 |     }
343 | 
344 |     /**
345 |      * Determine if the project is using the AndroidAnnotations library.
346 |      */
347 |     private static boolean isUsingAndroidAnnotations(@NonNull Object object) {
348 |         if (!object.getClass().getSimpleName().endsWith("_")) {
349 |             return false;
350 |         }
351 |         try {
352 |             Class clazz = Class.forName("org.androidannotations.api.view.HasViews");
353 |             return clazz.isInstance(object);
354 |         } catch (ClassNotFoundException e) {
355 |             return false;
356 |         }
357 |     }
358 | }
359 | 


--------------------------------------------------------------------------------
/easypermissions/src/test/java/pub/devrel/easypermissions/EasyPermissionsTest.java:
--------------------------------------------------------------------------------
  1 | package pub.devrel.easypermissions;
  2 | 
  3 | import android.Manifest;
  4 | import android.app.Application;
  5 | import android.app.Dialog;
  6 | import android.app.Fragment;
  7 | import android.content.pm.PackageManager;
  8 | import android.widget.TextView;
  9 | 
 10 | import org.junit.Before;
 11 | import org.junit.Test;
 12 | import org.junit.runner.RunWith;
 13 | import org.mockito.ArgumentCaptor;
 14 | import org.mockito.Captor;
 15 | import org.mockito.Mockito;
 16 | import org.mockito.MockitoAnnotations;
 17 | import org.robolectric.RobolectricTestRunner;
 18 | import org.robolectric.annotation.Config;
 19 | import org.robolectric.shadows.ShadowApplication;
 20 | 
 21 | import java.util.ArrayList;
 22 | import java.util.Arrays;
 23 | import java.util.Collections;
 24 | 
 25 | import androidx.test.core.app.ApplicationProvider;
 26 | import pub.devrel.easypermissions.testhelper.ActivityController;
 27 | import pub.devrel.easypermissions.testhelper.FragmentController;
 28 | import pub.devrel.easypermissions.testhelper.TestActivity;
 29 | import pub.devrel.easypermissions.testhelper.TestAppCompatActivity;
 30 | import pub.devrel.easypermissions.testhelper.TestFragment;
 31 | import pub.devrel.easypermissions.testhelper.TestSupportFragmentActivity;
 32 | 
 33 | import static com.google.common.truth.Truth.assertThat;
 34 | import static junit.framework.Assert.fail;
 35 | import static org.mockito.ArgumentMatchers.any;
 36 | import static org.mockito.ArgumentMatchers.anyInt;
 37 | import static org.mockito.Mockito.never;
 38 | import static org.mockito.Mockito.times;
 39 | import static org.mockito.Mockito.verify;
 40 | import static org.mockito.Mockito.when;
 41 | import static org.robolectric.Shadows.shadowOf;
 42 | 
 43 | /**
 44 |  * Basic Robolectric tests for {@link pub.devrel.easypermissions.EasyPermissions}.
 45 |  */
 46 | @RunWith(RobolectricTestRunner.class)
 47 | @Config(sdk = 23)
 48 | public class EasyPermissionsTest {
 49 | 
 50 |     private static final String RATIONALE = "RATIONALE";
 51 |     private static final String POSITIVE = "POSITIVE";
 52 |     private static final String NEGATIVE = "NEGATIVE";
 53 |     private static final String[] ONE_PERM = new String[]{Manifest.permission.READ_SMS};
 54 |     private static final String[] ALL_PERMS = new String[]{
 55 |             Manifest.permission.READ_SMS, Manifest.permission.ACCESS_FINE_LOCATION};
 56 |     private static final int[] SMS_DENIED_RESULT = new int[]{
 57 |             PackageManager.PERMISSION_DENIED, PackageManager.PERMISSION_GRANTED};
 58 | 
 59 |     private ShadowApplication shadowApp;
 60 |     private Application app;
 61 |     private TestActivity spyActivity;
 62 |     private TestSupportFragmentActivity spySupportFragmentActivity;
 63 |     private TestAppCompatActivity spyAppCompatActivity;
 64 |     private TestFragment spyFragment;
 65 |     private FragmentController<TestFragment> fragmentController;
 66 |     private ActivityController<TestActivity> activityController;
 67 |     private ActivityController<TestSupportFragmentActivity> supportFragmentActivityController;
 68 |     private ActivityController<TestAppCompatActivity> appCompatActivityController;
 69 |     @Captor
 70 |     private ArgumentCaptor<Integer> integerCaptor;
 71 |     @Captor
 72 |     private ArgumentCaptor<ArrayList<String>> listCaptor;
 73 | 
 74 |     @Before
 75 |     public void setUp() {
 76 |         MockitoAnnotations.initMocks(this);
 77 |         app = ApplicationProvider.getApplicationContext();
 78 |         shadowApp = shadowOf(app);
 79 | 
 80 |         activityController = new ActivityController<>(TestActivity.class);
 81 |         supportFragmentActivityController = new ActivityController<>(TestSupportFragmentActivity.class);
 82 |         appCompatActivityController = new ActivityController<>(TestAppCompatActivity.class);
 83 |         fragmentController = new FragmentController<>(TestFragment.class);
 84 | 
 85 |         spyActivity = Mockito.spy(activityController.resume());
 86 |         spySupportFragmentActivity = Mockito.spy(supportFragmentActivityController.resume());
 87 |         spyAppCompatActivity = Mockito.spy(appCompatActivityController.resume());
 88 |         spyFragment = Mockito.spy(fragmentController.resume());
 89 |     }
 90 | 
 91 |     // ------ General tests ------
 92 | 
 93 |     @Test
 94 |     public void shouldNotHavePermissions_whenNoPermissionsGranted() {
 95 |         assertThat(EasyPermissions.hasPermissions(app, ALL_PERMS)).isFalse();
 96 |     }
 97 | 
 98 |     @Test
 99 |     public void shouldNotHavePermissions_whenNotAllPermissionsGranted() {
100 |         shadowApp.grantPermissions(ONE_PERM);
101 |         assertThat(EasyPermissions.hasPermissions(app, ALL_PERMS)).isFalse();
102 |     }
103 | 
104 |     @Test
105 |     public void shouldHavePermissions_whenAllPermissionsGranted() {
106 |         shadowApp.grantPermissions(ALL_PERMS);
107 |         assertThat(EasyPermissions.hasPermissions(app, ALL_PERMS)).isTrue();
108 |     }
109 | 
110 |     @SuppressWarnings("ConstantConditions")
111 |     @Test
112 |     public void shouldThrowException_whenHasPermissionsWithNullContext() {
113 |         try {
114 |             EasyPermissions.hasPermissions(null, ALL_PERMS);
115 |             fail("IllegalStateException expected because of null context.");
116 |         } catch (IllegalArgumentException e) {
117 |             assertThat(e).hasMessageThat()
118 |                     .isEqualTo("Can't check permissions for null context");
119 |         }
120 |     }
121 | 
122 |     // ------ From Activity ------
123 | 
124 |     @Test
125 |     public void shouldCorrectlyCallback_whenOnRequestPermissionResultCalledFromActivity() {
126 |         EasyPermissions.onRequestPermissionsResult(TestActivity.REQUEST_CODE, ALL_PERMS, SMS_DENIED_RESULT, spyActivity);
127 | 
128 |         verify(spyActivity, times(1))
129 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
130 |         assertThat(integerCaptor.getValue()).isEqualTo(TestActivity.REQUEST_CODE);
131 |         assertThat(listCaptor.getValue())
132 |                 .containsAllIn(new ArrayList<>(Collections.singletonList(Manifest.permission.ACCESS_FINE_LOCATION)));
133 | 
134 |         verify(spyActivity, times(1))
135 |                 .onPermissionsDenied(integerCaptor.capture(), listCaptor.capture());
136 |         assertThat(integerCaptor.getValue()).isEqualTo(TestActivity.REQUEST_CODE);
137 |         assertThat(listCaptor.getValue())
138 |                 .containsAllIn(new ArrayList<>(Collections.singletonList(Manifest.permission.READ_SMS)));
139 | 
140 |         verify(spyActivity, never()).afterPermissionGranted();
141 |     }
142 | 
143 |     @Test
144 |     public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermissionsFromActivity() {
145 |         grantPermissions(ALL_PERMS);
146 | 
147 |         EasyPermissions.requestPermissions(spyActivity, RATIONALE, TestActivity.REQUEST_CODE, ALL_PERMS);
148 | 
149 |         verify(spyActivity, times(1))
150 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
151 |         verify(spyActivity, never()).requestPermissions(any(String[].class), anyInt());
152 |         assertThat(integerCaptor.getValue()).isEqualTo(TestActivity.REQUEST_CODE);
153 |         assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
154 |     }
155 | 
156 |     @Test
157 |     public void shouldCallbackAfterPermissionGranted_whenRequestAlreadyGrantedPermissionsFromActivity() {
158 |         grantPermissions(ALL_PERMS);
159 | 
160 |         EasyPermissions.requestPermissions(spyActivity, RATIONALE, TestActivity.REQUEST_CODE, ALL_PERMS);
161 | 
162 |         // Called 2 times because this is a spy and library implementation invokes super classes annotated methods as well
163 |         verify(spyActivity, times(2)).afterPermissionGranted();
164 |     }
165 | 
166 |     @Test
167 |     public void shouldNotCallbackAfterPermissionGranted_whenRequestNotGrantedPermissionsFromActivity() {
168 |         grantPermissions(ONE_PERM);
169 | 
170 |         EasyPermissions.requestPermissions(spyActivity, RATIONALE, TestActivity.REQUEST_CODE, ALL_PERMS);
171 | 
172 |         verify(spyActivity, never()).afterPermissionGranted();
173 |     }
174 | 
175 |     @Test
176 |     public void shouldRequestPermissions_whenMissingPermissionAndNotShowRationaleFromActivity() {
177 |         grantPermissions(ONE_PERM);
178 |         showRationale(false, ALL_PERMS);
179 | 
180 |         EasyPermissions.requestPermissions(spyActivity, RATIONALE, TestActivity.REQUEST_CODE, ALL_PERMS);
181 | 
182 |         verify(spyActivity, times(1))
183 |                 .requestPermissions(ALL_PERMS, TestActivity.REQUEST_CODE);
184 |     }
185 | 
186 |     @Test
187 |     public void shouldShowCorrectDialog_whenMissingPermissionsAndShowRationaleFromActivity() {
188 |         grantPermissions(ONE_PERM);
189 |         showRationale(true, ALL_PERMS);
190 | 
191 |         EasyPermissions.requestPermissions(spyActivity, RATIONALE, TestActivity.REQUEST_CODE, ALL_PERMS);
192 | 
193 |         Fragment dialogFragment = spyActivity.getFragmentManager()
194 |                 .findFragmentByTag(RationaleDialogFragment.TAG);
195 |         assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
196 | 
197 |         Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
198 |         assertThatHasExpectedRationale(dialog, RATIONALE);
199 |     }
200 | 
201 |     @Test
202 |     public void shouldShowCorrectDialogUsingRequest_whenMissingPermissionsAndShowRationaleFromActivity() {
203 |         grantPermissions(ONE_PERM);
204 |         showRationale(true, ALL_PERMS);
205 | 
206 |         PermissionRequest request = new PermissionRequest.Builder(spyActivity, TestActivity.REQUEST_CODE, ALL_PERMS)
207 |                 .setPositiveButtonText(android.R.string.ok)
208 |                 .setNegativeButtonText(android.R.string.cancel)
209 |                 .setRationale(android.R.string.unknownName)
210 |                 .setTheme(R.style.Theme_AppCompat)
211 |                 .build();
212 |         EasyPermissions.requestPermissions(request);
213 | 
214 |         Fragment dialogFragment = spyActivity.getFragmentManager()
215 |                 .findFragmentByTag(RationaleDialogFragment.TAG);
216 |         assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
217 | 
218 |         Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
219 |         assertThatHasExpectedButtonsAndRationale(dialog, android.R.string.unknownName,
220 |                 android.R.string.ok, android.R.string.cancel);
221 |     }
222 | 
223 |     @Test
224 |     public void shouldHaveSomePermissionDenied_whenShowRationaleFromActivity() {
225 |         showRationale(true, ALL_PERMS);
226 | 
227 |         assertThat(EasyPermissions.somePermissionDenied(spyActivity, ALL_PERMS)).isTrue();
228 |     }
229 | 
230 |     @Test
231 |     public void shouldNotHaveSomePermissionDenied_whenNotShowRationaleFromActivity() {
232 |         showRationale(false, ALL_PERMS);
233 | 
234 |         assertThat(EasyPermissions.somePermissionDenied(spyActivity, ALL_PERMS)).isFalse();
235 |     }
236 | 
237 |     @Test
238 |     public void shouldHaveSomePermissionPermanentlyDenied_whenNotShowRationaleFromActivity() {
239 |         showRationale(false, ALL_PERMS);
240 | 
241 |         assertThat(EasyPermissions.somePermissionPermanentlyDenied(spyActivity, Arrays.asList(ALL_PERMS))).isTrue();
242 |     }
243 | 
244 |     @Test
245 |     public void shouldNotHaveSomePermissionPermanentlyDenied_whenShowRationaleFromActivity() {
246 |         showRationale(true, ALL_PERMS);
247 | 
248 |         assertThat(EasyPermissions.somePermissionPermanentlyDenied(spyActivity, Arrays.asList(ALL_PERMS))).isFalse();
249 |     }
250 | 
251 |     @Test
252 |     public void shouldHavePermissionPermanentlyDenied_whenNotShowRationaleFromActivity() {
253 |         showRationale(false, Manifest.permission.READ_SMS);
254 | 
255 |         assertThat(EasyPermissions.permissionPermanentlyDenied(spyActivity, Manifest.permission.READ_SMS)).isTrue();
256 |     }
257 | 
258 |     @Test
259 |     public void shouldNotHavePermissionPermanentlyDenied_whenShowRationaleFromActivity() {
260 |         showRationale(true, Manifest.permission.READ_SMS);
261 | 
262 |         assertThat(EasyPermissions.permissionPermanentlyDenied(spyActivity, Manifest.permission.READ_SMS)).isFalse();
263 |     }
264 | 
265 |     @Test
266 |     public void shouldCorrectlyCallback_whenOnRequestPermissionResultCalledFromAppCompatActivity() {
267 |         EasyPermissions.onRequestPermissionsResult(TestAppCompatActivity.REQUEST_CODE, ALL_PERMS, SMS_DENIED_RESULT, spyAppCompatActivity);
268 | 
269 |         verify(spyAppCompatActivity, times(1))
270 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
271 |         assertThat(integerCaptor.getValue()).isEqualTo(TestAppCompatActivity.REQUEST_CODE);
272 |         assertThat(listCaptor.getValue())
273 |                 .containsAllIn(new ArrayList<>(Collections.singletonList(Manifest.permission.ACCESS_FINE_LOCATION)));
274 | 
275 |         verify(spyAppCompatActivity, times(1))
276 |                 .onPermissionsDenied(integerCaptor.capture(), listCaptor.capture());
277 |         assertThat(integerCaptor.getValue()).isEqualTo(TestAppCompatActivity.REQUEST_CODE);
278 |         assertThat(listCaptor.getValue())
279 |                 .containsAllIn(new ArrayList<>(Collections.singletonList(Manifest.permission.READ_SMS)));
280 | 
281 |         verify(spyAppCompatActivity, never()).afterPermissionGranted();
282 |     }
283 | 
284 |     @Test
285 |     public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermissionsFromAppCompatActivity() {
286 |         grantPermissions(ALL_PERMS);
287 | 
288 |         EasyPermissions.requestPermissions(spyAppCompatActivity, RATIONALE, TestAppCompatActivity.REQUEST_CODE, ALL_PERMS);
289 | 
290 |         verify(spyAppCompatActivity, times(1))
291 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
292 |         verify(spyAppCompatActivity, never()).requestPermissions(any(String[].class), anyInt());
293 |         assertThat(integerCaptor.getValue()).isEqualTo(TestAppCompatActivity.REQUEST_CODE);
294 |         assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
295 |     }
296 | 
297 |     @Test
298 |     public void shouldCallbackAfterPermissionGranted_whenRequestAlreadyGrantedPermissionsFromAppCompatActivity() {
299 |         grantPermissions(ALL_PERMS);
300 | 
301 |         EasyPermissions.requestPermissions(spyAppCompatActivity, RATIONALE, TestAppCompatActivity.REQUEST_CODE, ALL_PERMS);
302 | 
303 |         // Called 2 times because this is a spy and library implementation invokes super classes annotated methods as well
304 |         verify(spyAppCompatActivity, times(2)).afterPermissionGranted();
305 |     }
306 | 
307 |     @Test
308 |     public void shouldNotCallbackAfterPermissionGranted_whenRequestNotGrantedPermissionsFromAppCompatActivity() {
309 |         grantPermissions(ONE_PERM);
310 | 
311 |         EasyPermissions.requestPermissions(spyAppCompatActivity, RATIONALE, TestAppCompatActivity.REQUEST_CODE, ALL_PERMS);
312 | 
313 |         verify(spyAppCompatActivity, never()).afterPermissionGranted();
314 |     }
315 | 
316 |     @Test
317 |     public void shouldRequestPermissions_whenMissingPermissionAndNotShowRationaleFromAppCompatActivity() {
318 |         grantPermissions(ONE_PERM);
319 |         showRationale(false, ALL_PERMS);
320 | 
321 |         EasyPermissions.requestPermissions(spyAppCompatActivity, RATIONALE, TestAppCompatActivity.REQUEST_CODE, ALL_PERMS);
322 | 
323 |         verify(spyAppCompatActivity, times(1))
324 |                 .requestPermissions(ALL_PERMS, TestAppCompatActivity.REQUEST_CODE);
325 |     }
326 | 
327 |     @Test
328 |     public void shouldShowCorrectDialog_whenMissingPermissionsAndShowRationaleFromAppCompatActivity() {
329 |         grantPermissions(ONE_PERM);
330 |         showRationale(true, ALL_PERMS);
331 | 
332 |         EasyPermissions.requestPermissions(spyAppCompatActivity, RATIONALE, TestAppCompatActivity.REQUEST_CODE, ALL_PERMS);
333 | 
334 |         androidx.fragment.app.Fragment dialogFragment = spyAppCompatActivity.getSupportFragmentManager()
335 |                 .findFragmentByTag(RationaleDialogFragmentCompat.TAG);
336 |         assertThat(dialogFragment).isInstanceOf(RationaleDialogFragmentCompat.class);
337 | 
338 |         Dialog dialog = ((RationaleDialogFragmentCompat) dialogFragment).getDialog();
339 |         assertThatHasExpectedRationale(dialog, RATIONALE);
340 |     }
341 | 
342 |     @Test
343 |     public void shouldShowCorrectDialog_whenMissingPermissionsAndShowRationaleFromSupportFragmentActivity() {
344 |         grantPermissions(ONE_PERM);
345 |         showRationale(true, ALL_PERMS);
346 | 
347 |         EasyPermissions.requestPermissions(spySupportFragmentActivity, RATIONALE, TestSupportFragmentActivity.REQUEST_CODE, ALL_PERMS);
348 | 
349 |         Fragment dialogFragment = spySupportFragmentActivity.getFragmentManager()
350 |                 .findFragmentByTag(RationaleDialogFragment.TAG);
351 |         assertThat(dialogFragment).isInstanceOf(RationaleDialogFragment.class);
352 | 
353 |         Dialog dialog = ((RationaleDialogFragment) dialogFragment).getDialog();
354 |         assertThatHasExpectedRationale(dialog, RATIONALE);
355 |     }
356 | 
357 |     @Test
358 |     public void shouldShowCorrectDialogUsingRequest_whenMissingPermissionsAndShowRationaleFromAppCompatActivity() {
359 |         grantPermissions(ONE_PERM);
360 |         showRationale(true, ALL_PERMS);
361 | 
362 |         PermissionRequest request = new PermissionRequest.Builder(spyAppCompatActivity, TestAppCompatActivity.REQUEST_CODE, ALL_PERMS)
363 |                 .setPositiveButtonText(android.R.string.ok)
364 |                 .setNegativeButtonText(android.R.string.cancel)
365 |                 .setRationale(android.R.string.unknownName)
366 |                 .setTheme(R.style.Theme_AppCompat)
367 |                 .build();
368 |         EasyPermissions.requestPermissions(request);
369 | 
370 |         androidx.fragment.app.Fragment dialogFragment = spyAppCompatActivity.getSupportFragmentManager()
371 |                 .findFragmentByTag(RationaleDialogFragmentCompat.TAG);
372 |         assertThat(dialogFragment).isInstanceOf(RationaleDialogFragmentCompat.class);
373 | 
374 |         Dialog dialog = ((RationaleDialogFragmentCompat) dialogFragment).getDialog();
375 |         assertThatHasExpectedButtonsAndRationale(dialog, android.R.string.unknownName,
376 |                 android.R.string.ok, android.R.string.cancel);
377 |     }
378 | 
379 |     @Test
380 |     public void shouldHaveSomePermissionDenied_whenShowRationaleFromAppCompatActivity() {
381 |         showRationale(true, ALL_PERMS);
382 | 
383 |         assertThat(EasyPermissions.somePermissionDenied(spyAppCompatActivity, ALL_PERMS)).isTrue();
384 |     }
385 | 
386 |     @Test
387 |     public void shouldNotHaveSomePermissionDenied_whenNotShowRationaleFromAppCompatActivity() {
388 |         showRationale(false, ALL_PERMS);
389 | 
390 |         assertThat(EasyPermissions.somePermissionDenied(spyAppCompatActivity, ALL_PERMS)).isFalse();
391 |     }
392 | 
393 |     @Test
394 |     public void shouldHaveSomePermissionPermanentlyDenied_whenNotShowRationaleFromAppCompatActivity() {
395 |         showRationale(false, ALL_PERMS);
396 | 
397 |         assertThat(EasyPermissions.somePermissionPermanentlyDenied(spyAppCompatActivity, Arrays.asList(ALL_PERMS))).isTrue();
398 |     }
399 | 
400 |     @Test
401 |     public void shouldNotHaveSomePermissionPermanentlyDenied_whenShowRationaleFromAppCompatActivity() {
402 |         showRationale(true, ALL_PERMS);
403 | 
404 |         assertThat(EasyPermissions.somePermissionPermanentlyDenied(spyAppCompatActivity, Arrays.asList(ALL_PERMS))).isFalse();
405 |     }
406 | 
407 |     @Test
408 |     public void shouldHavePermissionPermanentlyDenied_whenNotShowRationaleFromAppCompatActivity() {
409 |         showRationale(false, Manifest.permission.READ_SMS);
410 | 
411 |         assertThat(EasyPermissions.permissionPermanentlyDenied(spyAppCompatActivity, Manifest.permission.READ_SMS)).isTrue();
412 |     }
413 | 
414 |     @Test
415 |     public void shouldNotHavePermissionPermanentlyDenied_whenShowRationaleFromAppCompatActivity() {
416 |         showRationale(true, Manifest.permission.READ_SMS);
417 | 
418 |         assertThat(EasyPermissions.permissionPermanentlyDenied(spyAppCompatActivity, Manifest.permission.READ_SMS)).isFalse();
419 |     }
420 | 
421 |     @Test
422 |     public void shouldCorrectlyCallback_whenOnRequestPermissionResultCalledFromFragment() {
423 |         EasyPermissions.onRequestPermissionsResult(TestFragment.REQUEST_CODE, ALL_PERMS, SMS_DENIED_RESULT,
424 |                 spyFragment);
425 | 
426 |         verify(spyFragment, times(1))
427 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
428 |         assertThat(integerCaptor.getValue()).isEqualTo(TestFragment.REQUEST_CODE);
429 |         assertThat(listCaptor.getValue())
430 |                 .containsAllIn(new ArrayList<>(Collections.singletonList(Manifest.permission.ACCESS_FINE_LOCATION)));
431 | 
432 |         verify(spyFragment, times(1))
433 |                 .onPermissionsDenied(integerCaptor.capture(), listCaptor.capture());
434 |         assertThat(integerCaptor.getValue()).isEqualTo(TestFragment.REQUEST_CODE);
435 |         assertThat(listCaptor.getValue())
436 |                 .containsAllIn(new ArrayList<>(Collections.singletonList(Manifest.permission.READ_SMS)));
437 | 
438 |         verify(spyFragment, never()).afterPermissionGranted();
439 |     }
440 | 
441 |     @Test
442 |     public void shouldCallbackOnPermissionGranted_whenRequestAlreadyGrantedPermissionsFromFragment() {
443 |         grantPermissions(ALL_PERMS);
444 | 
445 |         EasyPermissions.requestPermissions(spyFragment, RATIONALE,
446 |                 TestFragment.REQUEST_CODE, ALL_PERMS);
447 | 
448 |         verify(spyFragment, times(1))
449 |                 .onPermissionsGranted(integerCaptor.capture(), listCaptor.capture());
450 |         verify(spyFragment, never()).requestPermissions(any(String[].class), anyInt());
451 |         assertThat(integerCaptor.getValue()).isEqualTo(TestFragment.REQUEST_CODE);
452 |         assertThat(listCaptor.getValue()).containsAllIn(ALL_PERMS);
453 |     }
454 | 
455 |     @Test
456 |     public void shouldCallbackAfterPermissionGranted_whenRequestAlreadyGrantedPermissionsFragment() {
457 |         grantPermissions(ALL_PERMS);
458 | 
459 |         EasyPermissions.requestPermissions(spyFragment, RATIONALE, TestFragment.REQUEST_CODE, ALL_PERMS);
460 | 
461 |         // Called 2 times because this is a spy and library implementation invokes super classes annotated methods as well
462 |         verify(spyFragment, times(2)).afterPermissionGranted();
463 |     }
464 | 
465 |     @Test
466 |     public void shouldNotCallbackAfterPermissionGranted_whenRequestNotGrantedPermissionsFromFragment() {
467 |         grantPermissions(ONE_PERM);
468 | 
469 |         EasyPermissions.requestPermissions(spyFragment, RATIONALE, TestFragment.REQUEST_CODE, ALL_PERMS);
470 | 
471 |         verify(spyFragment, never()).afterPermissionGranted();
472 |     }
473 | 
474 |     @Test
475 |     public void shouldRequestPermissions_whenMissingPermissionsAndNotShowRationaleFromFragment() {
476 |         grantPermissions(ONE_PERM);
477 |         showRationale(false, ALL_PERMS);
478 | 
479 |         EasyPermissions.requestPermissions(spyFragment, RATIONALE, TestFragment.REQUEST_CODE, ALL_PERMS);
480 | 
481 |         verify(spyFragment, times(1))
482 |                 .requestPermissions(ALL_PERMS, TestFragment.REQUEST_CODE);
483 |     }
484 | 
485 |     @Test
486 |     public void shouldShowCorrectDialog_whenMissingPermissionsAndShowRationaleFromFragment() {
487 |         grantPermissions(ONE_PERM);
488 |         showRationale(true, ALL_PERMS);
489 | 
490 |         EasyPermissions.requestPermissions(spyFragment, RATIONALE, TestFragment.REQUEST_CODE, ALL_PERMS);
491 | 
492 |         androidx.fragment.app.Fragment dialogFragment = spyFragment.getChildFragmentManager()
493 |                 .findFragmentByTag(RationaleDialogFragmentCompat.TAG);
494 |         assertThat(dialogFragment).isInstanceOf(RationaleDialogFragmentCompat.class);
495 | 
496 |         Dialog dialog = ((RationaleDialogFragmentCompat) dialogFragment).getDialog();
497 |         assertThatHasExpectedRationale(dialog, RATIONALE);
498 |     }
499 | 
500 |     @Test
501 |     public void shouldShowCorrectDialogUsingRequest_whenMissingPermissionsAndShowRationaleFromFragment() {
502 |         grantPermissions(ONE_PERM);
503 |         showRationale(true, ALL_PERMS);
504 | 
505 |         PermissionRequest request = new PermissionRequest.Builder(spyFragment, TestFragment.REQUEST_CODE, ALL_PERMS)
506 |                 .setPositiveButtonText(POSITIVE)
507 |                 .setNegativeButtonText(NEGATIVE)
508 |                 .setRationale(RATIONALE)
509 |                 .setTheme(R.style.Theme_AppCompat)
510 |                 .build();
511 |         EasyPermissions.requestPermissions(request);
512 | 
513 |         androidx.fragment.app.Fragment dialogFragment = spyFragment.getChildFragmentManager()
514 |                 .findFragmentByTag(RationaleDialogFragmentCompat.TAG);
515 |         assertThat(dialogFragment).isInstanceOf(RationaleDialogFragmentCompat.class);
516 | 
517 |         Dialog dialog = ((RationaleDialogFragmentCompat) dialogFragment).getDialog();
518 |         assertThatHasExpectedButtonsAndRationale(dialog, RATIONALE, POSITIVE, NEGATIVE);
519 |     }
520 | 
521 |     @Test
522 |     public void shouldHaveSomePermissionDenied_whenShowRationaleFromFragment() {
523 |         showRationale(true, ALL_PERMS);
524 | 
525 |         assertThat(EasyPermissions.somePermissionDenied(spyFragment, ALL_PERMS)).isTrue();
526 |     }
527 | 
528 |     @Test
529 |     public void shouldNotHaveSomePermissionDenied_whenNotShowRationaleFromFragment() {
530 |         showRationale(false, ALL_PERMS);
531 | 
532 |         assertThat(EasyPermissions.somePermissionDenied(spyFragment, ALL_PERMS)).isFalse();
533 |     }
534 | 
535 |     @Test
536 |     public void shouldHaveSomePermissionPermanentlyDenied_whenNotShowRationaleFromFragment() {
537 |         showRationale(false, ALL_PERMS);
538 | 
539 |         assertThat(EasyPermissions.somePermissionPermanentlyDenied(spyFragment, Arrays.asList(ALL_PERMS))).isTrue();
540 |     }
541 | 
542 |     @Test
543 |     public void shouldNotHaveSomePermissionPermanentlyDenied_whenShowRationaleFromFragment() {
544 |         showRationale(true, ALL_PERMS);
545 | 
546 |         assertThat(EasyPermissions.somePermissionPermanentlyDenied(spyFragment, Arrays.asList(ALL_PERMS))).isFalse();
547 |     }
548 | 
549 | 
550 |     @Test
551 |     public void shouldHavePermissionPermanentlyDenied_whenNotShowRationaleFromFragment() {
552 |         showRationale(false, Manifest.permission.READ_SMS);
553 | 
554 |         assertThat(EasyPermissions.permissionPermanentlyDenied(spyFragment, Manifest.permission.READ_SMS)).isTrue();
555 |     }
556 | 
557 |     @Test
558 |     public void shouldNotHavePermissionPermanentlyDenied_whenShowRationaleFromFragment() {
559 |         showRationale(true, Manifest.permission.READ_SMS);
560 | 
561 |         assertThat(EasyPermissions.permissionPermanentlyDenied(spyFragment, Manifest.permission.READ_SMS)).isFalse();
562 |     }
563 | 
564 |     private void assertThatHasExpectedButtonsAndRationale(Dialog dialog, int rationale,
565 |                                                           int positive, int negative) {
566 |         TextView dialogMessage = dialog.findViewById(android.R.id.message);
567 |         assertThat(dialogMessage.getText().toString()).isEqualTo(app.getString(rationale));
568 |         TextView positiveMessage = dialog.findViewById(android.R.id.button1);
569 |         assertThat(positiveMessage.getText().toString()).isEqualTo(app.getString(positive));
570 |         TextView negativeMessage = dialog.findViewById(android.R.id.button2);
571 |         assertThat(negativeMessage.getText().toString()).isEqualTo(app.getString(negative));
572 |     }
573 | 
574 |     private void assertThatHasExpectedButtonsAndRationale(Dialog dialog, String rationale,
575 |                                                           int positive, int negative) {
576 |         TextView dialogMessage = dialog.findViewById(android.R.id.message);
577 |         assertThat(dialogMessage.getText().toString()).isEqualTo(rationale);
578 |         TextView positiveMessage = dialog.findViewById(android.R.id.button1);
579 |         assertThat(positiveMessage.getText().toString()).isEqualTo(app.getString(positive));
580 |         TextView negativeMessage = dialog.findViewById(android.R.id.button2);
581 |         assertThat(negativeMessage.getText().toString()).isEqualTo(app.getString(negative));
582 |     }
583 | 
584 |     private void assertThatHasExpectedButtonsAndRationale(Dialog dialog, String rationale,
585 |                                                           String positive, String negative) {
586 |         TextView dialogMessage = dialog.findViewById(android.R.id.message);
587 |         assertThat(dialogMessage.getText().toString()).isEqualTo(rationale);
588 |         TextView positiveMessage = dialog.findViewById(android.R.id.button1);
589 |         assertThat(positiveMessage.getText().toString()).isEqualTo(positive);
590 |         TextView negativeMessage = dialog.findViewById(android.R.id.button2);
591 |         assertThat(negativeMessage.getText().toString()).isEqualTo(negative);
592 |     }
593 | 
594 |     private void assertThatHasExpectedRationale(Dialog dialog, String rationale) {
595 |         TextView dialogMessage = dialog.findViewById(android.R.id.message);
596 |         assertThat(dialogMessage.getText().toString()).isEqualTo(rationale);
597 |     }
598 | 
599 |     private void grantPermissions(String[] perms) {
600 |         shadowApp.grantPermissions(perms);
601 |     }
602 | 
603 |     private void showRationale(boolean show, String... perms) {
604 |         for (String perm : perms) {
605 |             when(spyActivity.shouldShowRequestPermissionRationale(perm)).thenReturn(show);
606 |             when(spySupportFragmentActivity.shouldShowRequestPermissionRationale(perm)).thenReturn(show);
607 |             when(spyAppCompatActivity.shouldShowRequestPermissionRationale(perm)).thenReturn(show);
608 |             when(spyFragment.shouldShowRequestPermissionRationale(perm)).thenReturn(show);
609 |         }
610 |     }
611 | }
612 | 


--------------------------------------------------------------------------------