Examples with SignInStateChangeListener com.amazonaws.mobile.auth.core.SignInStateChangeListener used on opensource projects

Example 1 with SignInStateChangeListener

use of com.amazonaws.mobile.auth.core.SignInStateChangeListener in project aws-sdk-android by aws-amplify.

the class OAuth2Utils method _initialize.

protected Runnable _initialize(final Context context, final AWSConfiguration awsConfiguration, final Callback<UserStateDetails> callback) {
    return new Runnable() {

        public void run() {
            synchronized (initLockObject) {
                if (AWSMobileClient.this.awsConfiguration != null) {
                    callback.onResult(getUserStateDetails(true));
                    return;
                }
                // Default value
                mIsPersistenceEnabled = true;
                // appropriately.
                try {
                    if (awsConfiguration.optJsonObject(AUTH_KEY) != null && awsConfiguration.optJsonObject(AUTH_KEY).has("Persistence")) {
                        mIsPersistenceEnabled = awsConfiguration.optJsonObject(AUTH_KEY).getBoolean("Persistence");
                    }
                } catch (final Exception ex) {
                    // If reading from awsconfiguration.json fails, invoke callback.
                    callback.onError(new RuntimeException("Failed to initialize AWSMobileClient; please check your awsconfiguration.json", ex));
                    return;
                }
                userAgentOverride = awsConfiguration.getUserAgentOverride();
                mContext = context.getApplicationContext();
                mStore = new AWSMobileClientStore(AWSMobileClient.this);
                final IdentityManager identityManager = new IdentityManager(mContext);
                identityManager.enableFederation(false);
                identityManager.setConfiguration(awsConfiguration);
                identityManager.setPersistenceEnabled(mIsPersistenceEnabled);
                IdentityManager.setDefaultIdentityManager(identityManager);
                registerConfigSignInProviders(awsConfiguration);
                identityManager.addSignInStateChangeListener(new SignInStateChangeListener() {

                    @Override
                    public void onUserSignedIn() {
                        Log.d(TAG, "onUserSignedIn: Updating user state from drop-in UI");
                        signInState = SignInState.DONE;
                        com.amazonaws.mobile.auth.core.IdentityProvider currentIdentityProvider = identityManager.getCurrentIdentityProvider();
                        String token = currentIdentityProvider.getToken();
                        String providerKey = currentIdentityProvider.getCognitoLoginKey();
                        federatedSignInWithoutAssigningState(providerKey, token, new Callback<UserStateDetails>() {

                            @Override
                            public void onResult(UserStateDetails result) {
                                Log.d(TAG, "onResult: showSignIn federated");
                                setUserState(getUserStateDetails(false));
                                getSignInUILatch().countDown();
                            }

                            @Override
                            public void onError(Exception e) {
                                Log.w(TAG, "onError: User sign-in had errors from drop-in UI", e);
                                setUserState(getUserStateDetails(false));
                                getSignInUILatch().countDown();
                            }
                        });
                    }

                    @Override
                    public void onUserSignedOut() {
                        Log.d(TAG, "onUserSignedOut: Updating user state from drop-in UI");
                        setUserState(getUserStateDetails(false));
                        showSignInWaitLatch.countDown();
                    }
                });
                if (awsConfiguration.optJsonObject("CredentialsProvider") != null && awsConfiguration.optJsonObject("CredentialsProvider").optJSONObject("CognitoIdentity") != null) {
                    try {
                        JSONObject identityPoolJSON = awsConfiguration.optJsonObject("CredentialsProvider").getJSONObject("CognitoIdentity").getJSONObject(awsConfiguration.getConfiguration());
                        final String poolId = identityPoolJSON.getString("PoolId");
                        final String regionStr = identityPoolJSON.getString("Region");
                        final ClientConfiguration clientConfig = new ClientConfiguration();
                        clientConfig.setUserAgent(DEFAULT_USER_AGENT + " " + awsConfiguration.getUserAgent());
                        if (userAgentOverride != null) {
                            clientConfig.setUserAgentOverride(userAgentOverride);
                        }
                        AmazonCognitoIdentityClient cibClient = new AmazonCognitoIdentityClient(new AnonymousAWSCredentials(), clientConfig);
                        cibClient.setRegion(Region.getRegion(regionStr));
                        provider = new AWSMobileClientCognitoIdentityProvider(null, poolId, cibClient);
                        cognitoIdentity = new CognitoCachingCredentialsProvider(mContext, provider, Regions.fromName(regionStr));
                        cognitoIdentity.setPersistenceEnabled(mIsPersistenceEnabled);
                        if (userAgentOverride != null) {
                            cognitoIdentity.setUserAgentOverride(userAgentOverride);
                        }
                    } catch (Exception e) {
                        callback.onError(new RuntimeException("Failed to initialize Cognito Identity; please check your awsconfiguration.json", e));
                        return;
                    }
                }
                final JSONObject userPoolJSON = awsConfiguration.optJsonObject("CognitoUserPool");
                if (userPoolJSON != null) {
                    try {
                        mUserPoolPoolId = userPoolJSON.getString("PoolId");
                        final String clientId = userPoolJSON.getString("AppClientId");
                        final String clientSecret = userPoolJSON.optString("AppClientSecret");
                        final String pinpointEndpointId = CognitoPinpointSharedContext.getPinpointEndpoint(context, userPoolJSON.optString("PinpointAppId"));
                        final String cognitoUserPoolCustomEndpoint = userPoolJSON.optString(COGNITO_USERPOOL_CUSTOM_ENDPOINT);
                        final ClientConfiguration clientConfig = new ClientConfiguration();
                        clientConfig.setUserAgent(DEFAULT_USER_AGENT + " " + awsConfiguration.getUserAgent());
                        if (userAgentOverride != null) {
                            clientConfig.setUserAgentOverride(userAgentOverride);
                        }
                        userpoolLL = new AmazonCognitoIdentityProviderClient(new AnonymousAWSCredentials(), clientConfig);
                        userpoolLL.setRegion(com.amazonaws.regions.Region.getRegion(Regions.fromName(userPoolJSON.getString("Region"))));
                        userpoolsLoginKey = String.format("cognito-idp.%s.amazonaws.com/%s", userPoolJSON.getString("Region"), userPoolJSON.getString("PoolId"));
                        userpool = new CognitoUserPool(mContext, mUserPoolPoolId, clientId, clientSecret, userpoolLL, pinpointEndpointId, cognitoUserPoolCustomEndpoint);
                        userpool.setPersistenceEnabled(mIsPersistenceEnabled);
                        mDeviceOperations = new DeviceOperations(AWSMobileClient.this, userpoolLL);
                    } catch (Exception e) {
                        callback.onError(new RuntimeException("Failed to initialize Cognito Userpool; please check your awsconfiguration.json", e));
                        return;
                    }
                }
                JSONObject hostedUIJSON = getHostedUIJSON(awsConfiguration);
                if (hostedUIJSON != null) {
                    try {
                        // Pre-warm the Custom Tabs based on
                        if (hostedUIJSON.has("TokenURI")) {
                            Log.d(TAG, "initialize: OAuth2 client detected");
                            mOAuth2Client = new OAuth2Client(mContext, AWSMobileClient.this);
                            mOAuth2Client.setPersistenceEnabled(mIsPersistenceEnabled);
                            mOAuth2Client.setUserAgentOverride(userAgentOverride);
                        } else {
                            _initializeHostedUI(hostedUIJSON);
                        }
                    } catch (Exception e) {
                        callback.onError(new RuntimeException("Failed to initialize OAuth, please check your awsconfiguration.json", e));
                    }
                }
                if (cognitoIdentity == null && userpool == null) {
                    callback.onError(new RuntimeException("Neither Cognito Identity or Cognito UserPool was used." + " At least one must be present to use AWSMobileClient."));
                    return;
                }
                AWSMobileClient.this.awsConfiguration = awsConfiguration;
                final UserStateDetails userStateDetails = getUserStateDetails(true);
                callback.onResult(userStateDetails);
                setUserState(userStateDetails);
            }
        }
    };
}