Handle "Never Ask Again" in permissions and add requestMultiplePermissions

Summary:
In order to get featured in the Google Play Store, we had to handle a few specific cases with permissions based on feedback from the editorial team.

First, which was previously possible with this permissions module was bumping the sdk to version 23.

The second is requesting multiple permissions at one time. In order for the camera + upload to work, we needed to request both camera permissions + media storage in one flow.

The last is handling the case where the user checks the "Never Ask Again" box. This will only appear after a user denies a permission once and is then prompted again. The logic for handling this case is taken from here: http://stackoverflow.com/questions/31928868/how-do-we-distinguish-never-asked-from-stop-asking-in-android-ms-runtime-permis/35495372#35495372

We were also seeing a few crashes similar to #10009 due to `onRequestPermissionsResult` being called before `onResume` (http://stackoverflow.com/questions/35205643/why-is-onresume-called-after-onrequestpermissionsresult), so I delaye
Closes https://github.com/facebook/react-native/pull/10221

Differential Revision: D4232551

fbshipit-source-id: fee698d1c48a2d86623cb87996f3d17f4c10a62e

ReactAndroid/src/main/java/com/facebook/react/modules/permissions/PermissionsModule.java

@@ -21,10 +21,15 @@ import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.PermissionAwareActivity;
 import com.facebook.react.modules.core.PermissionListener;
 
+import java.util.ArrayList;
+
 /**
  * Module that exposes the Android M Permission system to JS.
  */
@@ -34,6 +39,9 @@ public class PermissionsModule extends ReactContextBaseJavaModule implements Per
   private static final String ERROR_INVALID_ACTIVITY = "E_INVALID_ACTIVITY";
   private final SparseArray<Callback> mCallbacks;
   private int mRequestCode = 0;
+  private final String GRANTED = "granted";
+  private final String DENIED = "denied";
+  private final String NEVER_ASK_AGAIN = "never_ask_again";
 
   public PermissionsModule(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -96,7 +104,7 @@ public class PermissionsModule extends ReactContextBaseJavaModule implements Per
       return;
     }
     if (context.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED) {
-      promise.resolve(true);
+      promise.resolve(GRANTED);
       return;
     }
 
@@ -107,9 +115,20 @@ public class PermissionsModule extends ReactContextBaseJavaModule implements Per
         mRequestCode, new Callback() {
           @Override
           public void invoke(Object... args) {
-            promise.resolve(args[0].equals(PackageManager.PERMISSION_GRANTED));
+            int[] results = (int[]) args[0];
+            if (results[0] == PackageManager.PERMISSION_GRANTED) {
+              promise.resolve(GRANTED);
+            } else {
+              PermissionAwareActivity activity = (PermissionAwareActivity) args[1];
+              if (activity.shouldShowRequestPermissionRationale(permission)) {
+                promise.resolve(DENIED);
+              } else {
+                promise.resolve(NEVER_ASK_AGAIN);
+              }
+            }
           }
-        });
+        }
+      );
 
       activity.requestPermissions(new String[]{permission}, mRequestCode, this);
       mRequestCode++;
@@ -118,17 +137,76 @@ public class PermissionsModule extends ReactContextBaseJavaModule implements Per
     }
   }
 
+  @ReactMethod
+  public void requestMultiplePermissions(final ReadableArray permissions, final Promise promise) {
+    final WritableMap grantedPermissions = new WritableNativeMap();
+    final ArrayList<String> permissionsToCheck = new ArrayList<String>();
+    int checkedPermissionsCount = 0;
+
+    Context context = getReactApplicationContext().getBaseContext();
+
+    for (int i = 0; i < permissions.size(); i++) {
+      String perm = permissions.getString(i);
+
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+        grantedPermissions.putString(perm, context.checkPermission(perm, Process.myPid(), Process.myUid()) ==
+        PackageManager.PERMISSION_GRANTED ? GRANTED : DENIED);
+        checkedPermissionsCount++;
+      } else if (context.checkSelfPermission(perm) == PackageManager.PERMISSION_GRANTED) {
+        grantedPermissions.putString(perm, GRANTED);
+        checkedPermissionsCount++;
+      } else {
+        permissionsToCheck.add(perm);
+      }
+    }
+    if (permissions.size() == checkedPermissionsCount) {
+      promise.resolve(grantedPermissions);
+      return;
+    }
+    try {
+
+      PermissionAwareActivity activity = getPermissionAwareActivity();
+
+      mCallbacks.put(
+      mRequestCode, new Callback() {
+        @Override
+        public void invoke(Object... args) {
+          int[] results = (int[]) args[0];
+          PermissionAwareActivity activity = (PermissionAwareActivity) args[1];
+          for (int j = 0; j < permissionsToCheck.size(); j++) {
+            String permission = permissionsToCheck.get(j);
+            if (results[j] == PackageManager.PERMISSION_GRANTED) {
+              grantedPermissions.putString(permission, GRANTED);
+            } else {
+              if (activity.shouldShowRequestPermissionRationale(permission)) {
+                grantedPermissions.putString(permission, DENIED);
+              } else {
+                grantedPermissions.putString(permission, NEVER_ASK_AGAIN);
+              }
+            }
+          }
+          promise.resolve(grantedPermissions);
+        }
+      });
+
+      activity.requestPermissions(permissionsToCheck.toArray(new String[0]), mRequestCode, this);
+      mRequestCode++;
+    } catch (IllegalStateException e) {
+      promise.reject(ERROR_INVALID_ACTIVITY, e);
+    }
+  }
+
   /**
    * Method called by the activity with the result of the permission request.
    */
   @Override
   public boolean onRequestPermissionsResult(
-      int requestCode,
-      String[] permissions,
-      int[] grantResults) {
-    mCallbacks.get(requestCode).invoke(grantResults[0]);
-    mCallbacks.remove(requestCode);
-    return mCallbacks.size() == 0;
+    int requestCode,
+    String[] permissions,
+    int[] grantResults) {
+      mCallbacks.get(requestCode).invoke(grantResults, getPermissionAwareActivity());
+      mCallbacks.remove(requestCode);
+      return mCallbacks.size() == 0;
   }
 
   private PermissionAwareActivity getPermissionAwareActivity() {