Adds a method to prefetch AuthorizationServiceConfiguration (#289)

michaelrhughes · Kadi Kraman · commit 44a47c524dd2 · 2019-05-30T16:38:32.000+01:00
* Add method to warm up the chrome custom tab on android * Fix linting * Fix linting #2 * Refactor/Rename to prefetchOnce which prefetches the AuthorizationServiceConfig and reusing it * Delete unnecessary chrome custom tab warmUp code, there is no difference * Fix: Forgot to call countDown on fetchConfLatch when serviceConfiguration was provided * Fix: Call CountDown method of latch when not entering either condition clause * Fix typo... * Fix: Call CountDown method of latch when not entering either condition clause, got lost somewhere * Remove unnecessary compiler options in build.gradle and make linting happy * Renamed prefetchOnce to prefetchConfiguration and updated README * Added in proper handling of headers * Fixed lint errors * Added in warming and prefetching of chrome custom tabs. * Addressed code review comments * Moved prefetch chrome option to be an argumnt in the config variable * More fixes to lint styling
diff --git a/README.md b/README.md
@@ -81,6 +81,25 @@ const config = {
 const result = await authorize(config);
 ```
 
+### `prefetchConfiguration`
+
+ANDROID This will prefetch the authorization service configuration. Invoking this function is optional
+and will speed up calls to authorize. This is only supported on Android.
+
+```js
+import { prefetchConfiguration } from 'react-native-app-auth';
+
+const config = {
+  warmAndPrefetchChrome: true,
+  issuer: '<YOUR_ISSUER_URL>',
+  clientId: '<YOUR_CLIENT_ID>',
+  redirectUrl: '<YOUR_REDIRECT_URL>',
+  scopes: ['<YOUR_SCOPES_ARRAY>'],
+};
+
+prefetchConfiguration(config);
+```
+
 #### config
 
 This is your configuration object for the client. The config is passed into each of the methods
diff --git a/android/src/main/java/com/rnappauth/RNAppAuthModule.java b/android/src/main/java/com/rnappauth/RNAppAuthModule.java
@@ -2,10 +2,16 @@
 
 import android.app.Activity;
 import android.app.PendingIntent;
+import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.net.Uri;
+import android.os.Bundle;
 import android.support.annotation.Nullable;
+import android.support.customtabs.CustomTabsCallback;
+import android.support.customtabs.CustomTabsClient;
+import android.support.customtabs.CustomTabsServiceConnection;
+import android.util.Log;
 
 import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -37,11 +43,16 @@
 import net.openid.appauth.connectivity.ConnectionBuilder;
 import net.openid.appauth.connectivity.DefaultConnectionBuilder;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.CountDownLatch;
 
 public class RNAppAuthModule extends ReactContextBaseJavaModule implements ActivityEventListener {
 
+    public static final String CUSTOM_TAB_PACKAGE_NAME = "com.android.chrome";
+
     private final ReactApplicationContext reactContext;
     private Promise promise;
     private Boolean dangerouslyAllowInsecureHttpRequests;
@@ -50,13 +61,76 @@ public class RNAppAuthModule extends ReactContextBaseJavaModule implements Activ
     private Map<String, String> tokenRequestHeaders = null;
     private Map<String, String> additionalParametersMap;
     private String clientSecret;
+    private final AtomicReference<AuthorizationServiceConfiguration> mServiceConfiguration = new AtomicReference<>();
+    private boolean isPrefetched = false;
 
     public RNAppAuthModule(ReactApplicationContext reactContext) {
         super(reactContext);
         this.reactContext = reactContext;
         reactContext.addActivityEventListener(this);
     }
 
+    @ReactMethod
+    public void prefetchConfiguration(
+        final Boolean warmAndPrefetchChrome,
+        final String issuer,
+        final String redirectUrl,
+        final String clientId,
+        final ReadableArray scopes,
+        final ReadableMap serviceConfiguration,
+        final Boolean dangerouslyAllowInsecureHttpRequests,
+        final ReadableMap headers,
+        final Promise promise
+    ) {
+        if (warmAndPrefetchChrome) {
+            warmChromeCustomTab(reactContext, issuer);
+        }
+
+        this.parseHeaderMap(headers);
+        final ConnectionBuilder builder = createConnectionBuilder(dangerouslyAllowInsecureHttpRequests, this.authorizationRequestHeaders);
+        final CountDownLatch fetchConfigurationLatch = new CountDownLatch(1);
+
+        if(!isPrefetched) {
+            if (serviceConfiguration != null && mServiceConfiguration.get() == null) {
+                try {
+                    mServiceConfiguration.set(createAuthorizationServiceConfiguration(serviceConfiguration));
+                    isPrefetched = true;
+                    fetchConfigurationLatch.countDown();
+                } catch (Exception e) {
+                    promise.reject("RNAppAuth Error", "Failed to convert serviceConfiguration", e);
+                }
+            } else if (mServiceConfiguration.get() == null) {
+                final Uri issuerUri = Uri.parse(issuer);
+                AuthorizationServiceConfiguration.fetchFromUrl(
+                        buildConfigurationUriFromIssuer(issuerUri),
+                        new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() {
+                            public void onFetchConfigurationCompleted(
+                                    @Nullable AuthorizationServiceConfiguration fetchedConfiguration,
+                                    @Nullable AuthorizationException ex) {
+                                if (ex != null) {
+                                    promise.reject("RNAppAuth Error", "Failed to fetch configuration", ex);
+                                    return;
+                                }
+                                mServiceConfiguration.set(fetchedConfiguration);
+                                isPrefetched = true;
+                                fetchConfigurationLatch.countDown();
+                            }
+                        },
+                        builder
+                );
+            }
+        } else {
+            fetchConfigurationLatch.countDown();
+        }
+
+        try {
+            fetchConfigurationLatch.await();
+            promise.resolve(isPrefetched);
+        } catch (Exception e) {
+            promise.reject("RNAppAuth Error", "Failed to await fetch configuration", e);
+        }
+    }
+
     @ReactMethod
     public void authorize(
             String issuer,
@@ -89,10 +163,11 @@ public void authorize(
         this.clientAuthMethod = clientAuthMethod;
 
         // when serviceConfiguration is provided, we don't need to hit up the OpenID well-known id endpoint
-        if (serviceConfiguration != null) {
+        if (serviceConfiguration != null || mServiceConfiguration.get() != null) {
             try {
+                final AuthorizationServiceConfiguration serviceConfig = mServiceConfiguration.get() != null ? mServiceConfiguration.get() : createAuthorizationServiceConfiguration(serviceConfiguration);
                 authorizeWithConfiguration(
-                        createAuthorizationServiceConfiguration(serviceConfiguration),
+                        serviceConfig,
                         appAuthConfiguration,
                         clientId,
                         scopes,
@@ -116,6 +191,8 @@ public void onFetchConfigurationCompleted(
                                 return;
                             }
 
+                            mServiceConfiguration.set(fetchedConfiguration);
+
                             authorizeWithConfiguration(
                                     fetchedConfiguration,
                                     appAuthConfiguration,
@@ -165,10 +242,11 @@ public void refresh(
         this.additionalParametersMap = additionalParametersMap;
 
         // when serviceConfiguration is provided, we don't need to hit up the OpenID well-known id endpoint
-        if (serviceConfiguration != null) {
+        if (serviceConfiguration != null || mServiceConfiguration.get() != null) {
             try {
+                final AuthorizationServiceConfiguration serviceConfig = mServiceConfiguration.get() != null ? mServiceConfiguration.get() : createAuthorizationServiceConfiguration(serviceConfiguration);
                 refreshWithConfiguration(
-                        createAuthorizationServiceConfiguration(serviceConfiguration),
+                        serviceConfig,
                         appAuthConfiguration,
                         refreshToken,
                         clientId,
@@ -184,7 +262,6 @@ public void refresh(
             }
         } else {
             final Uri issuerUri = Uri.parse(issuer);
-            // @TODO: Refactor to avoid hitting IDP endpoint on refresh, reuse fetchedConfiguration if possible.
             AuthorizationServiceConfiguration.fetchFromUrl(
                     buildConfigurationUriFromIssuer(issuerUri),
                     new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() {
@@ -196,6 +273,8 @@ public void onFetchConfigurationCompleted(
                                 return;
                             }
 
+                            mServiceConfiguration.set(fetchedConfiguration);
+
                             refreshWithConfiguration(
                                     fetchedConfiguration,
                                     appAuthConfiguration,
@@ -498,6 +577,21 @@ private AuthorizationServiceConfiguration createAuthorizationServiceConfiguratio
         );
     }
 
+    private void warmChromeCustomTab(Context context, final String issuer) {
+        CustomTabsServiceConnection connection = new CustomTabsServiceConnection() {
+            @Override
+            public void onCustomTabsServiceConnected(ComponentName name, CustomTabsClient client) {
+                client.warmup(0);
+                client.newSession(new CustomTabsCallback()).mayLaunchUrl(Uri.parse(issuer), null, Collections.<Bundle>emptyList());
+            }
+
+            @Override
+            public void onServiceDisconnected(ComponentName name) {
+
+            }
+        };
+        CustomTabsClient.bindCustomTabsService(context, CUSTOM_TAB_PACKAGE_NAME, connection);
+    }
 
     @Override
     public void onNewIntent(Intent intent) {
diff --git a/index.d.ts b/index.d.ts
@@ -70,6 +70,8 @@ export interface RefreshConfiguration {
   refreshToken: string;
 }
 
+export function prefetchConfiguration(config: AuthConfiguration): Promise<void>;
+
 export function authorize(config: AuthConfiguration): Promise<AuthorizeResult>;
 
 export function refresh(
diff --git a/index.js b/index.js
@@ -48,6 +48,37 @@ const validateHeaders = headers => {
   });
 };
 
+export const prefetchConfiguration = async ({
+  warmAndPrefetchChrome,
+  issuer,
+  redirectUrl,
+  clientId,
+  scopes,
+  serviceConfiguration,
+  dangerouslyAllowInsecureHttpRequests = false,
+  customHeaders,
+}) => {
+  if (Platform.OS === 'android') {
+    validateIssuerOrServiceConfigurationEndpoints(issuer, serviceConfiguration);
+    validateClientId(clientId);
+    validateRedirectUrl(redirectUrl);
+    validateHeaders(customHeaders);
+
+    const nativeMethodArguments = [
+      warmAndPrefetchChrome,
+      issuer,
+      redirectUrl,
+      clientId,
+      scopes,
+      serviceConfiguration,
+      dangerouslyAllowInsecureHttpRequests,
+      customHeaders,
+    ];
+
+    RNAppAuth.prefetchConfiguration(...nativeMethodArguments);
+  }
+};
+
 export const authorize = ({
   issuer,
   redirectUrl,

Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,8 @@ export interface RefreshConfiguration {`
`70`	`70`	`refreshToken: string;`
`71`	`71`	`}`
`72`	`72`
	`73`	`+export function prefetchConfiguration(config: AuthConfiguration): Promise<void>;`
	`74`	`+`
`73`	`75`	`export function authorize(config: AuthConfiguration): Promise<AuthorizeResult>;`
`74`	`76`
`75`	`77`	`export function refresh(`