import net.openid.appauth.AuthorizationException; //导入依赖的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.AuthorizationException; //导入依赖的package包/类
public void notifyUserAgentResponse(Intent data, int returnCode) {
    if (returnCode != app.RC_AUTH) {
        failLogin(new AuthException("User authorization was cancelled"));
        return;
    }

    AuthorizationResponse resp = AuthorizationResponse.fromIntent(data);
    AuthorizationException ex = AuthorizationException.fromIntent(data);
    if (resp == null) {
        failLogin(new AuthException("User authorization failed"));
        return;
    } else {
        authState.update(resp, ex);
        finishUserAuth();
    }
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
public static void performRefreshTokenRequest(final Context context, AuthState authState, AppAuthWebViewData data) {

		AppAuthConfiguration.Builder appAuthConfigBuilder = new AppAuthConfiguration.Builder();
		appAuthConfigBuilder.setConnectionBuilder(AppAuthConnectionBuilderForTesting.INSTANCE);
		AppAuthConfiguration appAuthConfig = appAuthConfigBuilder.build();

		AuthorizationService authService = new AuthorizationService(context, appAuthConfig);

		ClientSecretPost clientSecretPost = new ClientSecretPost(data.getClientSecret());
		final TokenRequest request = authState.createTokenRefreshRequest();

		authService.performTokenRequest(request, clientSecretPost, new AuthorizationService.TokenResponseCallback() {
			@Override public void onTokenRequestCompleted(@Nullable TokenResponse response, @Nullable AuthorizationException ex) {
				if (ex != null) {
					ex.printStackTrace();
					return;
				}
				AppAuthWebView.updateAuthStateFromRefreshToken(context, response, ex);
			}
		});
	}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
@SuppressWarnings("ThrowableResultOfMethodCallIgnored")
private Intent extractResponseData(Uri responseUri) {
	if (responseUri.getQueryParameterNames().contains(AuthorizationException.PARAM_ERROR)) {
		return AuthorizationException.fromOAuthRedirect(responseUri).toIntent();
	} else {
		AuthorizationResponse response = new AuthorizationResponse.Builder(mAuthRequest)
			.fromUri(responseUri)
			.build();

		if (mAuthRequest.state == null &&
			response.state != null ||
			(mAuthRequest.state != null && !mAuthRequest.state.equals(response.state))) {
			Logger.warn("State returned in authorization response (%s) does not match state "
					+ "from request (%s) - discarding response",
				response.state,
				mAuthRequest.state);

			return AuthorizationException.AuthorizationRequestErrors.STATE_MISMATCH.toIntent();
		}

		return response.toIntent();
	}
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
/**
 * Exchanges the code, for the {@link TokenResponse}.
 *
 * @param intent represents the {@link Intent} from the Custom Tabs or the System Browser.
 */
private void handleAuthorizationResponse(@NonNull Intent intent) {
  AuthorizationResponse response = AuthorizationResponse.fromIntent(intent);
  AuthorizationException error = AuthorizationException.fromIntent(intent);
  final AuthState authState = new AuthState(response, error);
  if (response != null) {
    Log.i(LOG_TAG, String.format("Handled Authorization Response %s ", authState.toJsonString()));
    AuthorizationService service = new AuthorizationService(this);
    service.performTokenRequest(response.createTokenExchangeRequest(), new AuthorizationService.TokenResponseCallback() {
      @Override
      public void onTokenRequestCompleted(@Nullable TokenResponse tokenResponse, @Nullable AuthorizationException exception) {
        if (exception != null) {
          Log.w(LOG_TAG, "Token Exchange failed", exception);
        } else {
          if (tokenResponse != null) {
            authState.update(tokenResponse, exception);
            persistAuthState(authState);
            Log.i(LOG_TAG, String.format("Token Response [ Access Token: %s, ID Token: %s ]", tokenResponse.accessToken, tokenResponse.idToken));
          }
        }
      }
    });
  }
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
/**
 * Exchanges the code, for the {@link TokenResponse}.
 *
 * @param intent represents the {@link Intent} from the Custom Tabs or the System Browser.
 */
private void handleAuthorizationResponse(@NonNull Intent intent) {
  AuthorizationResponse response = AuthorizationResponse.fromIntent(intent);
  AuthorizationException error = AuthorizationException.fromIntent(intent);
  final AuthState authState = new AuthState(response, error);

  if (response != null) {
    Log.i(LOG_TAG, String.format("Handled Authorization Response %s ", authState.toJsonString()));
    AuthorizationService service = new AuthorizationService(this);
    service.performTokenRequest(response.createTokenExchangeRequest(), new AuthorizationService.TokenResponseCallback() {
      @Override
      public void onTokenRequestCompleted(@Nullable TokenResponse tokenResponse, @Nullable AuthorizationException exception) {
        if (exception != null) {
          Log.w(LOG_TAG, "Token Exchange failed", exception);
        } else {
          if (tokenResponse != null) {
            authState.update(tokenResponse, exception);
            persistAuthState(authState);
            Log.i(LOG_TAG, String.format("Token Response [ Access Token: %s, ID Token: %s ]", tokenResponse.accessToken, tokenResponse.idToken));
          }
        }
      }
    });
  }
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的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.AuthorizationException; //导入依赖的package包/类
private void performTokenRequest(TokenRequest tokenRequest) {

        mAuthService.performTokenRequest(
                tokenRequest,
                new AuthorizationService.TokenResponseCallback()

                {
                    @Override
                    public void onTokenRequestCompleted (
                            @Nullable TokenResponse tokenResponse,
                            @Nullable AuthorizationException ex){
                        receivedTokenResponse(tokenResponse, ex);
                    }
                }

        );
    }
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
@WorkerThread
private void handleCodeExchangeResponse(
        @Nullable TokenResponse tokenResponse,
        @Nullable AuthorizationException authException) {

    mStateManager.updateAfterTokenResponse(tokenResponse, authException);
    if (!mStateManager.getCurrent().isAuthorized()) {
        final String message = "Authorization Code exchange failed"
                + ((authException != null) ? authException.error : "");

        // WrongThread inference is incorrect for lambdas
        //noinspection WrongThread
        runOnUiThread(() -> displayNotAuthorized(message));
    } else {
        runOnUiThread(this::displayAuthorized);
    }
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的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.AuthorizationException; //导入依赖的package包/类
private void getAccessToken(AuthorizationResponse authorizationResponse) {
    AuthorizationService service = new AuthorizationService(context);
    service.performTokenRequest(
            authorizationResponse.createTokenExchangeRequest(),
            new AuthorizationService.TokenResponseCallback() {
                @Override public void onTokenRequestCompleted(
                        TokenResponse resp, AuthorizationException ex) {
                    if (ex == null && resp != null) {
                        SocialNetworkAccount account = new SocialNetworkAccount(
                                IdentityProvider.GOOGLE, resp.accessToken);
                        sendAuthSuccess(account);
                    } else {
                        DebugLog.logException(ex);
                        sendAuthFailure();
                    }
                }
            });
    service.dispose();
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
@Override
protected Void doInBackground(Void... params) {
    try {
        String token = mAuthState.getAccessToken();
        if (!revoked) {
            mAuthState.performActionWithFreshTokens(mAuthService, new AuthState.AuthStateAction() {
                @Override
                public void execute(String accessToken, String idToken, AuthorizationException ex) {
                    if (ex != null) {
                        Log.d(TAG, "Token refresh failed when fetching user info");
                        return;
                    }
                    performRequest(accessToken);
                }
            });
        } else { performRequest(token); }
    } catch (Exception e) {
        Log.e(TAG, "Failed to establish connection.", e.fillInStackTrace());
    }
    return null;
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
@WorkerThread
private void tryToGetTokens() {
    AuthorizationResponse response = AuthorizationResponse.fromIntent(getIntent());
    AuthorizationException ex = AuthorizationException.fromIntent(getIntent());

    if (response != null || ex != null) {
        stateManager.updateAfterAuthorization(response, ex);
    }

    if (response != null && response.authorizationCode != null) {
        stateManager.updateAfterAuthorization(response, ex);
        exchangeAuthorizationCode(response);
    } else if (ex != null) {
        log("Authorization flow failed: " + ex.getMessage());
        showRestartButton();
    } else {
        log("No authorization state retained - reauthorization required");
        showRestartButton();
    }
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
public void get(URL url, Client.ResponseCallback callback) {
    state.performActionWithFreshTokens(service, new AuthState.AuthStateAction() {
        @Override
        public void execute(@Nullable String accessToken, @Nullable String idToken, @Nullable AuthorizationException ex) {
            executor.submit(() -> {
                if (ex != null) {
                    callback.execute(null, ex);
                } else {
                    try {
                        String response = getRequest(url, accessToken);
                        callback.execute(new JSONObject(response), null);
                    } catch (Exception e) {
                        callback.execute(null, e);
                    }
                }
            });
        }
    });
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
public void put(URL url, JSONObject payload, Client.ResponseCallback callback) {
    state.performActionWithFreshTokens(service, new AuthState.AuthStateAction() {
        @Override
        public void execute(@Nullable String accessToken, @Nullable String idToken, @Nullable AuthorizationException ex) {
            executor.submit(() -> {
                if (ex != null) {
                    callback.execute(null, ex);
                } else {
                    try {
                        String response = putRequest(url, payload, accessToken);
                        callback.execute(new JSONObject(response), null);
                    } catch (Exception e) {
                        callback.execute(null, e);
                    }
                }
            });
        }
    });
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
public void delete(URL url, Client.ResponseCallback callback) {
    state.performActionWithFreshTokens(service, new AuthState.AuthStateAction() {
        @Override
        public void execute(@Nullable String accessToken, @Nullable String idToken, @Nullable AuthorizationException ex) {
            executor.submit(() -> {
                if (ex != null) {
                    callback.execute(null, ex);
                } else {
                    try {
                        deleteRequest(url, accessToken);
                        callback.execute(null, null);
                    } catch (Exception e) {
                        callback.execute(null, e);
                    }
                }
            });
        }
    });
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
@Override
public void run() {

    if(MyApp.Token == null)
        return;

    final AuthManager authManager = AuthManager.getInstance(TokenService.this);

    final AuthState authState = authManager.getAuthState();


    if(authState.getNeedsTokenRefresh()) {
        //Get New Token

        ClientSecretPost clientSecretPost = new ClientSecretPost(authManager.getAuth().getClientSecret());
        final TokenRequest request = authState.createTokenRefreshRequest();
        final AuthorizationService authService = authManager.getAuthService();

        authService.performTokenRequest(request, clientSecretPost, new AuthorizationService.TokenResponseCallback() {
            @Override
            public void onTokenRequestCompleted(@Nullable TokenResponse response, @Nullable AuthorizationException ex) {
                if(ex != null){
                    ex.printStackTrace();
                    return;
                }
                authManager.updateAuthState(response,ex);
                MyApp.Token = authState.getIdToken();
            }
        });

    }

}
 

import net.openid.appauth.AuthorizationException; //导入依赖的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.AuthorizationException; //导入依赖的package包/类
private void onTokenRequestCompleted(TokenResponse resp, AuthorizationException ex) {
    if (resp == null) {
        failLogin(new AuthException(ex.getMessage()));
        return;
    }

    authState.update(resp, ex);
    finishCodeExchange();
}
 

import net.openid.appauth.AuthorizationException; //导入依赖的package包/类
private static void updateAuthStateFromRefreshToken(Context context, TokenResponse response, AuthorizationException ex) {
	AuthState authState = getAuthState(context);
	if (authState != null) {
		authState.update(response, ex);
		PreferenceManager.getDefaultSharedPreferences(context).edit().putString("AuthState", authState.jsonSerializeString()).apply();
		Intent intent = new Intent();
		intent.setAction(BROADCAST_RECEIVER_ACTION);
		intent.putExtra(AUTH_STATE_JSON, authState.jsonSerializeString());
		context.sendBroadcast(intent);
	}
}