import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
private void startServiceConfig() {
    Log.i(TAG, "Starting service config");

    String discoveryEndpoint = app.getString(R.string.discovery_endpoint);
    if (discoveryEndpoint.trim().length() == 0 || !URLUtil.isValidUrl(discoveryEndpoint)) {
        Log.i(TAG, "Using static service config");
        AuthorizationServiceConfiguration serviceConfig =
                new AuthorizationServiceConfiguration(
                        Uri.parse(app.getString(R.string.authorization_endpoint)),
                        Uri.parse(app.getString(R.string.token_endpoint)));
        authState = new AuthState(serviceConfig);
        userInfoUrl = app.getString(R.string.user_info_endpoint);

        finishServiceConfig();
    } else {
        Log.i(TAG, "Using discovery service config");
        Uri discoveryUri = Uri.parse(discoveryEndpoint);
        loginListener.onEvent(AuthRepo.this, AUTH_SERVICE_DISCOVERY_START);

        AuthorizationServiceConfiguration.fetchFromUrl(discoveryUri, this::finishServiceDiscovery);
    }
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
/**
 * Sends authorization request to authorization endpoint
 *
 * @param view: UIButton 'Get Tokens'
 */
public void sendAuthorizationRequest(View view) {
    final AuthorizationServiceConfiguration.RetrieveConfigurationCallback retrieveCallback =
            new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() {
                @Override
                public void onFetchConfigurationCompleted(
                        @Nullable AuthorizationServiceConfiguration authorizationServiceConfiguration,
                        @Nullable AuthorizationException e) {
                    if(e != null) {
                        Log.w(TAG, "Failed to retrieve configuration for " + configuration.kIssuer, e);
                    } else {
                        Log.d(TAG, "Configuration retrieved for " + configuration.kIssuer + ", proceeding");
                        makeAuthRequest(authorizationServiceConfiguration);
                    }
                }
            };
    String discoveryEndpoint = configuration.kIssuer + "/.well-known/openid-configuration";
    AuthorizationServiceConfiguration.fetchFromUrl(Uri.parse(discoveryEndpoint), retrieveCallback);
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
@Override
public void onClick(View view) {
  AuthorizationServiceConfiguration serviceConfiguration = new AuthorizationServiceConfiguration(
      Uri.parse("https://accounts.google.com/o/oauth2/v2/auth") /* auth endpoint */,
      Uri.parse("https://www.googleapis.com/oauth2/v4/token") /* token endpoint */
  );

  String clientId = "511828570984-fuprh0cm7665emlne3rnf9pk34kkn86s.apps.googleusercontent.com";
  Uri redirectUri = Uri.parse("com.google.codelabs.appauth:/oauth2callback");
  AuthorizationRequest.Builder builder = new AuthorizationRequest.Builder(
      serviceConfiguration,
      clientId,
      AuthorizationRequest.RESPONSE_TYPE_CODE,
      redirectUri
  );
  builder.setScopes("profile");
  AuthorizationRequest request = builder.build();

  AuthorizationService authorizationService = new AuthorizationService(view.getContext());

  String action = "com.google.codelabs.appauth.HANDLE_AUTHORIZATION_RESPONSE";
  Intent postAuthorizationIntent = new Intent(action);
  PendingIntent pendingIntent = PendingIntent.getActivity(view.getContext(), request.hashCode(), postAuthorizationIntent, 0);
  authorizationService.performAuthorizationRequest(request, pendingIntent);
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
private void makeAuthRequest(
        @NonNull AuthorizationServiceConfiguration serviceConfig,
        @NonNull IdentityProvider idp) {

    AuthorizationRequest authRequest = new AuthorizationRequest.Builder(
            serviceConfig,
            idp.getClientId(),
            ResponseTypeValues.CODE,
            idp.getRedirectUri())
            .setScope(idp.getScope())
            .build();

    Log.d(TAG, "Making auth request to " + idp.name);
    mAuthService.performAuthorizationRequest(
            authRequest,
            TokenActivity.createPostAuthorizationIntent(
                    this,
                    authRequest,
                    serviceConfig.discoveryDoc,
                    idp.getClientSecret()),
            mAuthService.createCustomTabsIntentBuilder()
                    .setToolbarColor(getCustomTabColor())
                    .build());
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
public void requestAuthorization(View view) {

        final AuthorizationServiceConfiguration.RetrieveConfigurationCallback retrieveCallback =
                new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() {

                    @Override
                    public void onFetchConfigurationCompleted(
                            @Nullable AuthorizationServiceConfiguration serviceConfiguration,
                            @Nullable AuthorizationException ex) {
                        if (ex != null) {
                            Log.w(TAG, "Failed to retrieve configuration for " + OIDC_ISSUER, ex);
                        } else {
                            Log.d(TAG, "configuration retrieved for " + OIDC_ISSUER
                                    + ", proceeding");
                            authorize(serviceConfiguration);
                        }
                    }
                };

        String discoveryEndpoint = OIDC_ISSUER + "/.well-known/openid-configuration";

        AuthorizationServiceConfiguration.fetchFromUrl(Uri.parse(discoveryEndpoint), retrieveCallback);
    }
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
public void makeAuthRequest() {
	AuthorizationServiceConfiguration.fetchFromIssuer(
			ISSUER_URI,
			(@Nullable AuthorizationServiceConfiguration serviceConfiguration,
						@Nullable AuthorizationException ex) -> {
					if (ex != null) {
						DebugLog.logException(ex);
						service.dispose();
						LocalBroadcastManager.getInstance(context).unregisterReceiver(googleAuthReceiver);
						onAuthenticationError(getFragment().getString(R.string.es_msg_google_signin_failed));
					} else {
						// service configuration retrieved, proceed to authorization...'
						sendAuthRequest(serviceConfiguration);
					}
			});
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
private void sendAuthRequest(AuthorizationServiceConfiguration serviceConfiguration) {
	Options options = GlobalObjectRegistry.getObject(Options.class);
	String clientId = options.getGoogleClientId();
	String authRedirect = String.format("%s:/oauth2redirect", context.getPackageName());

	Uri redirectUri = Uri.parse(authRedirect);

	AuthorizationRequest request = new AuthorizationRequest.Builder(
			serviceConfiguration,
			clientId,
			ResponseTypeValues.CODE,
			redirectUri)
			.setScopes(authMode.getPermissions())
			.build();

	PendingIntent pendingIntent = GoogleResponseHandler.createPostAuthorizationIntent(context, request);
	service.performAuthorizationRequest(request, pendingIntent);
	service.dispose();
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
/**
 * Makes authentication request to endpoints in discovery document
 *
 * @param authorizationServiceConfiguration: AppAuth authorizationService detail
 */
private void makeAuthRequest(
        @NonNull AuthorizationServiceConfiguration authorizationServiceConfiguration
        ) {
    AuthorizationRequest authorizationRequest = new AuthorizationRequest.Builder(
            authorizationServiceConfiguration,
            configuration.kClientID,
            AuthorizationRequest.RESPONSE_TYPE_CODE,
            Uri.parse(configuration.kRedirectURI)).setScope(SCOPE).build();
    Log.d(TAG, "Making auth request to " + authorizationServiceConfiguration.authorizationEndpoint);
    mAuthService.performAuthorizationRequest(
            authorizationRequest,
            createPostAuthorizationIntent(
                    this.getApplicationContext(),
                    authorizationRequest,
                    authorizationServiceConfiguration.discoveryDoc
                    ));

}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
public void openPostLogoutRedirectUri(String clientId, String postLogoutRedirectUri, PendingIntent postLogoutIntent) throws JSONException {
    final AuthorizationServiceConfiguration configuration = state.getAuthorizationServiceConfiguration();
    final JSONObject discoveryDoc = configuration.discoveryDoc.docJson;
    final Uri endSessionEndpoint = Uri.parse(discoveryDoc.getString("end_session_endpoint"));

    final Map<String, String> additionalParameters = new HashMap<>();
    additionalParameters.put("post_logout_redirect_uri", postLogoutRedirectUri);
    additionalParameters.put("id_token_hint", state.getIdToken());

    final AuthorizationServiceConfiguration logoutConfiguration =
            new AuthorizationServiceConfiguration(endSessionEndpoint, configuration.tokenEndpoint, null);

    final AuthorizationRequest request = new AuthorizationRequest.Builder(
            logoutConfiguration,
            clientId,
            "none",
            Uri.parse(postLogoutRedirectUri))
            .setAdditionalParameters(additionalParameters)
            .build();

    CustomTabsIntent customTabsIntent = service.createCustomTabsIntentBuilder(request.toUri()).build();
    service.performAuthorizationRequest(request, postLogoutIntent, postLogoutIntent, customTabsIntent);
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
@WorkerThread
private void loadAndSetConfiguration() {
    runOnUiThread(this::disableLoginButton);

    final Uri issuerUri = Uri.parse(staticConfiguration.getIssuer());

    AuthorizationServiceConfiguration.fetchFromIssuer(
            issuerUri,
            (configuration, ex) -> {
                if (ex != null) {
                    runOnUiThread(() -> log(String.format("An error occurred while fetching the configuration. Error details: %s", ex.getMessage())));
                } else {
                    this.configuration.set(configuration);
                    runOnUiThread(() -> {
                        try {
                            log(String.format("Received the following configuration: %s", configuration.toJson().toString(2)));
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }
                    });
                }
                runOnUiThread(this::enableLoginButton);
            });
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
private AuthManager(Context context){
	mSharedPrefRep = new SharedPreferencesRepository(context);
       setAuthData();
	mAuthConfig = new AuthorizationServiceConfiguration(
			Uri.parse(mAuth.getAuthorizationEndpointUri()),
			Uri.parse(mAuth.getTokenEndpointUri()),
			null);
	mAuthState = mSharedPrefRep.getAuthState();

	mAuthService = new AuthorizationService(context);
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
private void finishServiceDiscovery(AuthorizationServiceConfiguration config,
        AuthorizationException ex) {
    if (config == null) {
        failLogin(new AuthException("Failed to retrieve authorization service discovery document"));
        return;
    }

    authState = new AuthState(config);
    AuthorizationServiceDiscovery discovery = config.discoveryDoc;
    userInfoUrl = discovery.getUserinfoEndpoint().toString();

    loginListener.onEvent(AuthRepo.this, AUTH_SERVICE_DISCOVERY_FINISH);

    finishServiceConfig();
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
@Override
public void onClick(View view) {
  AuthorizationServiceConfiguration serviceConfiguration = new AuthorizationServiceConfiguration(
      Uri.parse("https://accounts.google.com/o/oauth2/v2/auth") /* auth endpoint */,
      Uri.parse("https://www.googleapis.com/oauth2/v4/token") /* token endpoint */
  );
  AuthorizationService authorizationService = new AuthorizationService(view.getContext());
  String clientId = "511828570984-fuprh0cm7665emlne3rnf9pk34kkn86s.apps.googleusercontent.com";
  Uri redirectUri = Uri.parse("com.google.codelabs.appauth:/oauth2callback");
  AuthorizationRequest.Builder builder = new AuthorizationRequest.Builder(
      serviceConfiguration,
      clientId,
      AuthorizationRequest.RESPONSE_TYPE_CODE,
      redirectUri
  );
  builder.setScopes("profile");

  if(mMainActivity.getLoginHint() != null){
    Map loginHintMap = new HashMap<String, String>();
    loginHintMap.put(LOGIN_HINT,mMainActivity.getLoginHint());
    builder.setAdditionalParameters(loginHintMap);

    Log.i(LOG_TAG, String.format("login_hint: %s", mMainActivity.getLoginHint()));
  }

  AuthorizationRequest request = builder.build();
  String action = "com.google.codelabs.appauth.HANDLE_AUTHORIZATION_RESPONSE";
  Intent postAuthorizationIntent = new Intent(action);
  PendingIntent pendingIntent = PendingIntent.getActivity(view.getContext(), request.hashCode(), postAuthorizationIntent, 0);
  authorizationService.performAuthorizationRequest(request, pendingIntent);
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
public void retrieveConfig(Context context,
                           RetrieveConfigurationCallback callback) {
    readConfiguration(context);
    if (getDiscoveryEndpoint() != null) {
        AuthorizationServiceConfiguration.fetchFromUrl(mDiscoveryEndpoint, callback);
    } else {
        AuthorizationServiceConfiguration config =
                new AuthorizationServiceConfiguration(mAuthEndpoint, mTokenEndpoint, null);
        callback.onFetchConfigurationCompleted(config, null);
    }
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
private void authorize(AuthorizationServiceConfiguration authServiceConfiguration) {

        // NOTE: Required for PingFederate 8.1 and below for the .setCodeVerifier() option below
        // to generate "plain" code_challenge_method these versions of PingFederate do not support
        // S256 PKCE.
        String codeVerifier = CodeVerifierUtil.generateRandomCodeVerifier();

        // OPTIONAL: Add any additional parameters to the authorization request
        HashMap<String, String> additionalParams = new HashMap<>();
        additionalParams.put("acr_values", "urn:acr:form");

        AuthorizationRequest authRequest = new AuthorizationRequest.Builder(
                authServiceConfiguration,
                OIDC_CLIENT_ID,
                AuthorizationRequest.RESPONSE_TYPE_CODE,
                Uri.parse(OIDC_REDIRECT_URI))
                .setScope(OIDC_SCOPE)
                .setCodeVerifier(codeVerifier, codeVerifier, "plain")
                .setAdditionalParameters(additionalParams)
                .build();

        Log.d(TAG, "Making auth request to " + authServiceConfiguration.authorizationEndpoint);
        mAuthService.performAuthorizationRequest(
                authRequest,
                createPostAuthorizationIntent(
                        this.getApplicationContext(),
                        authRequest,
                        authServiceConfiguration.discoveryDoc));
    }
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
/**
 * Initializes the authorization service configuration if necessary, either from the local
 * static values or by retrieving an OpenID discovery document.
 */
@WorkerThread
private void initializeAppAuth() {
    Log.i(TAG, "Initializing AppAuth");
    recreateAuthorizationService();

    if (mAuthStateManager.getCurrent().getAuthorizationServiceConfiguration() != null) {
        // configuration is already created, skip to client initialization
        Log.i(TAG, "auth config already established");
        initializeClient();
        return;
    }

    // if we are not using discovery, build the authorization service configuration directly
    // from the static configuration values.
    if (mConfiguration.getDiscoveryUri() == null) {
        Log.i(TAG, "Creating auth config from res/raw/auth_config.json");
        AuthorizationServiceConfiguration config = new AuthorizationServiceConfiguration(
                mConfiguration.getAuthEndpointUri(),
                mConfiguration.getTokenEndpointUri(),
                mConfiguration.getRegistrationEndpointUri());

        mAuthStateManager.replace(new AuthState(config));
        initializeClient();
        return;
    }

    // WrongThread inference is incorrect for lambdas
    // noinspection WrongThread
    runOnUiThread(() -> displayLoading("Retrieving discovery document"));
    Log.i(TAG, "Retrieving OpenID discovery doc");
    AuthorizationServiceConfiguration.fetchFromUrl(
            mConfiguration.getDiscoveryUri(),
            this::handleConfigurationRetrievalResult,
            mConfiguration.getConnectionBuilder());
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
@MainThread
private void handleConfigurationRetrievalResult(
        AuthorizationServiceConfiguration config,
        AuthorizationException ex) {
    if (config == null) {
        Log.i(TAG, "Failed to retrieve discovery document", ex);
        displayError("Failed to retrieve discovery document: " + ex.getMessage(), true);
        return;
    }

    Log.i(TAG, "Discovery document retrieved");
    mAuthStateManager.replace(new AuthState(config));
    mExecutor.submit(this::initializeClient);
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
@MainThread
private void displayAuthOptions() {
    findViewById(R.id.auth_container).setVisibility(View.VISIBLE);
    findViewById(R.id.loading_container).setVisibility(View.GONE);
    findViewById(R.id.error_container).setVisibility(View.GONE);

    AuthState state = mAuthStateManager.getCurrent();
    AuthorizationServiceConfiguration config = state.getAuthorizationServiceConfiguration();

    String authEndpointStr;
    if (config.discoveryDoc != null) {
        authEndpointStr = "Discovered auth endpoint: \n";
    } else {
        authEndpointStr = "Static auth endpoint: \n";
    }
    authEndpointStr += config.authorizationEndpoint;
    ((TextView)findViewById(R.id.auth_endpoint)).setText(authEndpointStr);

    String clientIdStr;
    if (state.getLastRegistrationResponse() != null) {
        clientIdStr = "Dynamic client ID: \n";
    } else {
        clientIdStr = "Static client ID: \n";
    }
    clientIdStr += mClientId;
    ((TextView)findViewById(R.id.client_id)).setText(clientIdStr);
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
public void revokeTokens(String clientId) throws JSONException, MalformedURLException {
    final AuthorizationServiceConfiguration configuration = state.getAuthorizationServiceConfiguration();
    final JSONObject discoveryDoc = configuration.discoveryDoc.docJson;
    final URL revocationEndpoint = new URL(discoveryDoc.getString("revocation_endpoint"));

    if (state.getAccessToken() != null) {
        executor.submit(() -> revokeToken(revocationEndpoint, clientId, "access_token", state.getAccessToken()));
    }

    if (state.getRefreshToken() != null) {
        executor.submit(() -> revokeToken(revocationEndpoint, clientId, "refresh_token", state.getRefreshToken()));
    }
}
 

import net.openid.appauth.AuthorizationServiceConfiguration; //导入依赖的package包/类
@Override
public void startAuthentication() {
    LogUtils.logd(TAG, "[startAuthentication]");
    final Context appContext = fromParentContext;

    List<OpenIDIdentityProvider> providers = OpenIDIdentityProvider.getProviders(appContext);

    for (final OpenIDIdentityProvider idp : providers) {
        if(idp.name.equals("Google")){
            Uri issuerUri = Uri.parse("https://accounts.google.com");
            AuthorizationServiceConfiguration.fetchFromIssuer(
                issuerUri,
                new RetrieveConfigurationCallback() {
                    @Override public void onFetchConfigurationCompleted(
                            @Nullable AuthorizationServiceConfiguration serviceConfiguration,
                            @Nullable AuthorizationException ex) {
                        if (ex != null) {
                            LogUtils.logd(TAG, "Failed to retrieve configuration for " + idp.name, ex);
                        } else {
                            if (idp.getClientId() == null) {
                                // Do dynamic client registration if no client_id
                                makeRegistrationRequest(serviceConfiguration, idp);
                            } else {
                                makeAuthRequest(serviceConfiguration, idp, new AuthState());
                            }
                        }
                    }
                });


        }
    }


}