Java AuthorizationResponse类代码示例

import net.openid.appauth.AuthorizationResponse; //导入依赖的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.AuthorizationResponse; //导入依赖的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.AuthorizationResponse; //导入依赖的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.AuthorizationResponse; //导入依赖的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.AuthorizationResponse; //导入依赖的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.AuthorizationResponse; //导入依赖的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.AuthorizationResponse; //导入依赖的package包/类
private void startCodeExchange() {
    Log.i(TAG, "Starting code exchange");

    loginListener.onEvent(AuthRepo.this, AUTH_CODE_EXCHANGE_START);

    AuthorizationResponse resp = authState.getLastAuthorizationResponse();
    authService.performTokenRequest(
            resp.createTokenExchangeRequest(), this::onTokenRequestCompleted);
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
private void exchangeAuthorizationCode(AuthorizationResponse authorizationResponse) {
    HashMap<String, String> additionalParams = new HashMap<>();
    if (getClientSecretFromIntent(getIntent()) != null) {
        additionalParams.put("client_secret", getClientSecretFromIntent(getIntent()));
    }
    performTokenRequest(authorizationResponse.createTokenExchangeRequest(additionalParams));
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
@AnyThread
@NonNull
public AuthState updateAfterAuthorization(
        @Nullable AuthorizationResponse response,
        @Nullable AuthorizationException ex) {
    AuthState current = getCurrent();
    current.update(response, ex);
    return replace(current);
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
@Override
protected void onStart() {
    super.onStart();

    if (mExecutor.isShutdown()) {
        mExecutor = Executors.newSingleThreadExecutor();
    }

    if (mStateManager.getCurrent().isAuthorized()) {
        displayAuthorized();
        return;
    }

    // the stored AuthState is incomplete, so check if we are currently receiving the result of
    // the authorization flow from the browser.
    AuthorizationResponse response = AuthorizationResponse.fromIntent(getIntent());
    AuthorizationException ex = AuthorizationException.fromIntent(getIntent());

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

    if (response != null && response.authorizationCode != null) {
        // authorization code exchange is required
        mStateManager.updateAfterAuthorization(response, ex);
        exchangeAuthorizationCode(response);
    } else if (ex != null) {
        displayNotAuthorized("Authorization flow failed: " + ex.getMessage());
    } else {
        displayNotAuthorized("No authorization state retained - reauthorization required");
    }
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
@MainThread
private void exchangeAuthorizationCode(AuthorizationResponse authorizationResponse) {
    displayLoading("Exchanging authorization code");
    performTokenRequest(
            authorizationResponse.createTokenExchangeRequest(),
            this::handleCodeExchangeResponse);
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
public void handleAuthorizationResponse(Intent intent) {
    AuthorizationResponse resp = AuthorizationResponse.fromIntent(intent);
    AuthorizationException ex = AuthorizationException.fromIntent(intent);
    if (resp != null) {
        getAccessToken(resp);
    } else {
        DebugLog.logException(ex);
        sendAuthFailure();
    }
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
/**
 * Performs Authorization code exchange
 */
private void exchangeAuthorizationCode(AuthorizationResponse authorizationResponse) {
    performTokenRequest(authorizationResponse.createTokenExchangeRequest());
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
@WorkerThread
private void exchangeAuthorizationCode(AuthorizationResponse response) {
    log("Received authorization code. Exchanging it for tokens now...");
    performTokenRequest(response.createTokenExchangeRequest(), this::handleCodeExchangeResponse);
}
 

import net.openid.appauth.AuthorizationResponse; //导入依赖的package包/类
private void exchangeAuthorizationCode(AuthorizationResponse authorizationResponse) {
    performTokenRequest(authorizationResponse.createTokenExchangeRequest());
}