Merge remote-tracking branch 'origin/new-fluent-api'

# Conflicts:
#	gradle/wrapper/gradle-wrapper.properties

Author: Rafael Dominiquini

.travis.yml

@@ -4,6 +4,7 @@ android:
   components:
     - tools
     - build-tools-23.0.2
+    - platform-tools
     - android-23
     - extra-android-support
     - extra-google-m2repository

README.md

@@ -18,7 +18,7 @@ Screenshots
 Usage
 -----
 
-To start using the library you just need to initialize Dexter with a ``Context``, preferably your ``Application`` as it won't be destroyed during your app lifetime:
+To start using the library you just need to initialize Dexter with an ``Activity``. Remember to stop Dexter during the ``onDestroy`` stage to avoid memory leaks.
 
 ```java
 public MyApplication extends Application {
@@ -27,6 +27,11 @@ public MyApplication extends Application {
 		Dexter.initialize(context);
 	}
 }
+
+@Override protected void onDestroy() {
+  Dexter.stop();
+  super.onDestroy();
+}
 ```
 
 Once the library is initialized you can start checking permissions at will. You have two options, you can either check for a single permission or check for multiple permissions at once.

dexter/src/main/AndroidManifest.xml

@@ -22,7 +22,7 @@
     <activity
         android:name=".DexterActivity"
         android:theme="@style/Theme.Transparent"
-        android:launchMode="singleTask"
+        android:launchMode="singleInstance"
         />
   </application>
 

dexter/src/main/java/com/karumi/dexter/AndroidPermissionService.java

@@ -19,6 +19,7 @@
 import android.app.Activity;
 import android.content.Context;
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 import android.support.v4.app.ActivityCompat;
 import android.support.v4.content.ContextCompat;
 
@@ -37,16 +38,24 @@ int checkSelfPermission(@NonNull Context context, @NonNull String permission) {
   /**
    * @see ActivityCompat#requestPermissions
    */
-  void requestPermissions(@NonNull Activity activity, @NonNull String[] permissions,
+  void requestPermissions(@Nullable Activity activity, @NonNull String[] permissions,
       int requestCode) {
+    if (activity == null) {
+      return;
+    }
+
     ActivityCompat.requestPermissions(activity, permissions, requestCode);
   }
 
   /**
    * @see ActivityCompat#shouldShowRequestPermissionRationale
    */
-  boolean shouldShowRequestPermissionRationale(@NonNull Activity activity,
+  boolean shouldShowRequestPermissionRationale(@Nullable Activity activity,
       @NonNull String permission) {
+    if (activity == null) {
+      return false;
+    }
+
     return ActivityCompat.shouldShowRequestPermissionRationale(activity, permission);
   }
 }

dexter/src/main/java/com/karumi/dexter/Dexter.java

@@ -18,34 +18,136 @@
 
 import android.app.Activity;
 import android.content.Context;
+import com.karumi.dexter.listener.EmptyPermissionRequestErrorListener;
+import com.karumi.dexter.listener.PermissionRequestErrorListener;
+import com.karumi.dexter.listener.multi.EmptyMultiplePermissionsListener;
 import com.karumi.dexter.listener.multi.MultiplePermissionsListener;
 import com.karumi.dexter.listener.single.PermissionListener;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 
 /**
  * Class to simplify the management of Android runtime permissions
  * Dexter needs to be initialized before checking for a permission using {@link
- * #initialize(Context)}
+ * #initialize(Activity)}
  */
-public final class Dexter {
+public final class Dexter
+    implements DexterBuilder, DexterBuilder.Permission, DexterBuilder.SinglePermissionListener,
+    DexterBuilder.MultiPermissionListener {
 
   private static DexterInstance instance;
 
+  private Collection<String> permissions;
+  private MultiplePermissionsListener listener = new EmptyMultiplePermissionsListener();
+  private PermissionRequestErrorListener errorListener = new EmptyPermissionRequestErrorListener();
+  private boolean shouldExecuteOnSameThread = false;
+
+  private Dexter(Activity activity) {
+    initialize(activity);
+  }
+
+  public static DexterBuilder.Permission withActivity(Activity activity) {
+    return new Dexter(activity);
+  }
+
+  @Override public DexterBuilder.SinglePermissionListener withPermission(String permission) {
+    permissions = Collections.singletonList(permission);
+    return this;
+  }
+
+  @Override public DexterBuilder.MultiPermissionListener withPermissions(String... permissions) {
+    this.permissions = Arrays.asList(permissions);
+    return this;
+  }
+
+  @Override
+  public DexterBuilder.MultiPermissionListener withPermissions(Collection<String> permissions) {
+    this.permissions = new ArrayList<>(permissions);
+    return this;
+  }
+
+  @Override public void continueRequestingPendingPermissions(PermissionListener listener) {
+    instance.continuePendingRequestIfPossible(listener, ThreadFactory.makeMainThread());
+  }
+
+  @Override public void continueRequestingPendingPermissions(MultiplePermissionsListener listener) {
+    instance.continuePendingRequestsIfPossible(listener, ThreadFactory.makeMainThread());
+  }
+
+  @Override public DexterBuilder withListener(PermissionListener listener) {
+    this.listener = new MultiplePermissionsListenerToPermissionListenerAdapter(listener);
+    return this;
+  }
+
+  @Override public DexterBuilder withListener(MultiplePermissionsListener listener) {
+    this.listener = listener;
+    return this;
+  }
+
+  @Override public DexterBuilder onSameThread() {
+    shouldExecuteOnSameThread = true;
+    return this;
+  }
+
+  @Override public DexterBuilder withErrorListener(PermissionRequestErrorListener errorListener) {
+    this.errorListener = errorListener;
+    return this;
+  }
+
+  @Override public void check() {
+    try {
+      Thread thread = getThread();
+      instance.checkPermissions(listener, permissions, thread);
+    } catch (DexterException e) {
+      errorListener.onError(e.error);
+    }
+  }
+
+  private Thread getThread() {
+    Thread thread;
+
+    if (shouldExecuteOnSameThread) {
+      thread = ThreadFactory.makeSameThread();
+    } else {
+      thread = ThreadFactory.makeMainThread();
+    }
+
+    return thread;
+  }
+
   /**
-   * Initializes the library
+   * Initializes the library.
    *
    * @param context Context used by Dexter. Use your {@link android.app.Application} to make sure
-   * the instance is not cleaned up during your app lifetime
+   * the instance is not cleaned up during your app lifetime.
+   * @deprecated use the initialize overloaded method using an {@link android.app.Activity} instance
+   * as param instead of this one. This method will be removed in the next major release.
    */
-  public static void initialize(Context context) {
+  @Deprecated public static void initialize(Context context) {
     if (instance == null) {
       AndroidPermissionService androidPermissionService = new AndroidPermissionService();
       IntentProvider intentProvider = new IntentProvider();
       instance = new DexterInstance(context, androidPermissionService, intentProvider);
     }
   }
 
+  /**
+   * Initializes the library.
+   *
+   * @param activity context used by Dexter. Remember to invoke {@link com.karumi.dexter.Dexter}
+   * stop method to avoid memory leaks.
+   * @deprecated Use the non static constructor: new Dexter(Activity activity)
+   */
+  @Deprecated public static void initialize(Activity activity) {
+    if (instance == null) {
+      AndroidPermissionService androidPermissionService = new AndroidPermissionService();
+      IntentProvider intentProvider = new IntentProvider();
+      instance = new DexterInstance(activity, androidPermissionService, intentProvider);
+    }
+  }
+
   /**
    * Checks the permission and notifies the listener of its state.
    * It is important to note that permissions still have to be declared in the manifest.
@@ -54,8 +156,10 @@ public static void initialize(Context context) {
    *
    * @param listener The class that will be reported when the state of the permission is ready
    * @param permission One of the values found in {@link android.Manifest.permission}
+   * @deprecated
    */
-  public static void checkPermissionOnSameThread(PermissionListener listener, String permission) {
+  @Deprecated public static void checkPermissionOnSameThread(PermissionListener listener,
+      String permission) {
     checkInstanceNotNull();
     instance.checkPermission(listener, permission, ThreadFactory.makeSameThread());
   }
@@ -68,8 +172,9 @@ public static void checkPermissionOnSameThread(PermissionListener listener, Stri
    *
    * @param listener The class that will be reported when the state of the permission is ready
    * @param permission One of the values found in {@link android.Manifest.permission}
+   * @deprecated
    */
-  public static void checkPermission(PermissionListener listener, String permission) {
+  @Deprecated public static void checkPermission(PermissionListener listener, String permission) {
     checkInstanceNotNull();
     instance.checkPermission(listener, permission, ThreadFactory.makeMainThread());
   }
@@ -82,12 +187,12 @@ public static void checkPermission(PermissionListener listener, String permissio
    *
    * @param listener The class that will be reported when the state of the permissions are ready
    * @param permissions Array of values found in {@link android.Manifest.permission}
+   * @deprecated
    */
-  public static void checkPermissionsOnSameThread(MultiplePermissionsListener listener,
+  @Deprecated public static void checkPermissionsOnSameThread(MultiplePermissionsListener listener,
       String... permissions) {
     checkInstanceNotNull();
-    instance.checkPermissions(listener, Arrays.asList(permissions),
-        ThreadFactory.makeSameThread());
+    instance.checkPermissions(listener, Arrays.asList(permissions), ThreadFactory.makeSameThread());
   }
 
   /**
@@ -98,11 +203,12 @@ public static void checkPermissionsOnSameThread(MultiplePermissionsListener list
    *
    * @param listener The class that will be reported when the state of the permissions are ready
    * @param permissions Array of values found in {@link android.Manifest.permission}
+   * @deprecated
    */
-  public static void checkPermissions(MultiplePermissionsListener listener, String... permissions) {
+  @Deprecated public static void checkPermissions(MultiplePermissionsListener listener,
+      String... permissions) {
     checkInstanceNotNull();
-    instance.checkPermissions(listener, Arrays.asList(permissions),
-        ThreadFactory.makeMainThread());
+    instance.checkPermissions(listener, Arrays.asList(permissions), ThreadFactory.makeMainThread());
   }
 
   /**
@@ -111,8 +217,9 @@ public static void checkPermissions(MultiplePermissionsListener listener, String
    *
    * @param listener The class that will be reported when the state of the permissions are ready
    * @param permissions Collection of values found in {@link android.Manifest.permission}
+   * @deprecated
    */
-  public static void checkPermissions(MultiplePermissionsListener listener,
+  @Deprecated public static void checkPermissions(MultiplePermissionsListener listener,
       Collection<String> permissions) {
     checkInstanceNotNull();
     instance.checkPermissions(listener, permissions, ThreadFactory.makeMainThread());
@@ -122,8 +229,10 @@ public static void checkPermissions(MultiplePermissionsListener listener,
    * Checks is there is any permission request still ongoing.
    * If so, state of permissions must not be checked until it is resolved
    * or it will cause an exception.
+   *
+   * @deprecated
    */
-  public static boolean isRequestOngoing() {
+  @Deprecated public static boolean isRequestOngoing() {
     checkInstanceNotNull();
     return instance.isRequestOngoing();
   }
@@ -132,8 +241,11 @@ public static boolean isRequestOngoing() {
    * Requests pending permissions if there were permissions lost. This method can be used to
    * recover the Dexter state during a configuration change, for example when the device is
    * rotated.
+   *
+   * @deprecated
    */
-  public static void continuePendingRequestsIfPossible(MultiplePermissionsListener listener) {
+  @Deprecated public static void continuePendingRequestsIfPossible(
+      MultiplePermissionsListener listener) {
     checkInstanceNotNull();
     instance.continuePendingRequestsIfPossible(listener, ThreadFactory.makeMainThread());
   }
@@ -142,13 +254,15 @@ public static void continuePendingRequestsIfPossible(MultiplePermissionsListener
    * Requests pending permission if there was a permissions lost. This method can be used to
    * recover the Dexter state during a configuration change, for example when the device is
    * rotated.
+   *
+   * @deprecated
    */
-  public static void continuePendingRequestIfPossible(PermissionListener listener) {
+  @Deprecated public static void continuePendingRequestIfPossible(PermissionListener listener) {
     checkInstanceNotNull();
     instance.continuePendingRequestIfPossible(listener, ThreadFactory.makeMainThread());
   }
 
-  private static void checkInstanceNotNull() {
+  @Deprecated private static void checkInstanceNotNull() {
     if (instance == null) {
       throw new NullPointerException("context == null \n Must call \"initialize\" on Dexter");
     }

dexter/src/main/java/com/karumi/dexter/DexterBuilder.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 Karumi.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package com.karumi.dexter;
+
+import com.karumi.dexter.listener.PermissionRequestErrorListener;
+import com.karumi.dexter.listener.multi.MultiplePermissionsListener;
+import com.karumi.dexter.listener.single.PermissionListener;
+import java.util.Collection;
+
+public interface DexterBuilder {
+
+  DexterBuilder onSameThread();
+
+  DexterBuilder withErrorListener(PermissionRequestErrorListener errorListener);
+
+  void check();
+
+  interface Permission {
+    DexterBuilder.SinglePermissionListener withPermission(String permission);
+
+    DexterBuilder.MultiPermissionListener withPermissions(String... permissions);
+
+    DexterBuilder.MultiPermissionListener withPermissions(Collection<String> permissions);
+
+    void continueRequestingPendingPermissions(PermissionListener listener);
+
+    void continueRequestingPendingPermissions(MultiplePermissionsListener listener);
+  }
+
+  interface SinglePermissionListener {
+    DexterBuilder withListener(PermissionListener listener);
+  }
+
+  interface MultiPermissionListener {
+    DexterBuilder withListener(MultiplePermissionsListener listener);
+  }
+}

dexter/src/main/java/com/karumi/dexter/DexterException.java

@@ -0,0 +1,13 @@
+package com.karumi.dexter;
+
+import com.karumi.dexter.listener.DexterError;
+
+final class DexterException extends IllegalStateException {
+
+  public final DexterError error;
+
+  public DexterException(String detailMessage, DexterError error) {
+    super(detailMessage);
+    this.error = error;
+  }
+}