com.google.firebase.auth.GetTokenResult Java Examples

@Nullable
public static String getCurrentAuthToken(@Nullable InternalAuthProvider authProvider) {
  try {
    String token = null;

    if (authProvider != null) {
      Task<GetTokenResult> pendingResult = authProvider.getAccessToken(false);
      GetTokenResult result =
          Tasks.await(pendingResult, MAXIMUM_TOKEN_WAIT_TIME_MS, TimeUnit.MILLISECONDS);
      token = result.getToken();
    }

    if (!TextUtils.isEmpty(token)) {
      return token;
    } else {
      Log.w(TAG, "no auth token for request");
    }
  } catch (ExecutionException | InterruptedException | TimeoutException e) {
    Log.e(TAG, "error getting token " + e);
  }
  return null;
}
 

public Observable<String> getUserToken(FirebaseUser firebaseUser) {
    return Observable.create(subscriber -> {
        Task<GetTokenResult> task = firebaseUser.getToken(true);

        task.addOnCompleteListener(resultTask -> {
            if (task.isSuccessful()) {
                String token = task.getResult().getToken();
                subscriber.onNext(token);
                subscriber.onCompleted();
            } else {
                Exception e = task.getException();
                subscriber.onError(e);
            }
        });
    });
}
 

/**
 * @param user
 * @param forceRefresh
 * @return
 */
@CheckReturnValue
@NonNull
public static Single<String> getToken(@NonNull final FirebaseUser user,
                                      final boolean forceRefresh) {
    return RxTask.single(new Callable<Task<GetTokenResult>>() {
        @Override
        public Task<GetTokenResult> call() throws Exception {
            return user.getToken(forceRefresh);
        }
    })
    .map(new Function<GetTokenResult, String>() {
        @Override
        public String apply(@NonNull GetTokenResult getTokenResult) throws Exception {
            return getTokenResult.getToken();
        }
    });
}
 

@Override
public synchronized Task<String> getToken() {
  boolean doForceRefresh = forceRefresh;
  forceRefresh = false;
  Task<GetTokenResult> res = authProvider.getAccessToken(doForceRefresh);

  // Take note of the current value of the tokenCounter so that this method can fail (with a
  // FirebaseFirestoreException) if there is a token change while the request is outstanding.
  final int savedCounter = tokenCounter;
  return res.continueWithTask(
      Executors.DIRECT_EXECUTOR,
      task -> {
        synchronized (this) {
          // Cancel the request since the token changed while the request was outstanding so the
          // response is potentially for a previous user (which user, we can't be sure).
          if (savedCounter != tokenCounter) {
            Logger.debug(LOG_TAG, "getToken aborted due to token change");
            return getToken();
          }

          if (task.isSuccessful()) {
            return Tasks.forResult(task.getResult().getToken());
          } else {
            return Tasks.forException(task.getException());
          }
        }
      });
}
 

@Override
    public void onSwipeMenuClosed(Conversation conversation, int position) {
//        Log.i(TAG, "onSwipeMenuClosed: conversation: " + conversation.toString() + " position: " + position);

        String conversationId = conversation.getConversationId();
        boolean isSupportConversation = conversationId.startsWith("support-group");

        // retrieve the firebase user token
        GetTokenResult task = FirebaseAuth.getInstance().getCurrentUser().getIdToken(false).getResult();
        String token = task.getToken();

        // create the header parameters
        Map<String, String> headerParams = new HashMap<>();
        headerParams.put("Accept", "application/json");
        headerParams.put("Content-Type", "application/json");
        headerParams.put("Authorization", "Bearer " + token);

        if (!isSupportConversation) {
            // is not support group
            deleteConversation(conversationId, headerParams);
        } else {
            // is support group
            closeSupportGroup(conversationId, headerParams);
        }

        // NOTE: dismiss is not necessary because the view disappears when the conversation is removed
//        // dismiss the swipe menu
//        conversationsListAdapter.dismissSwipeMenu(recyclerViewConversations, position);
//        conversationsListAdapter.notifyItemChanged(position);
    }
 

private void updateUI(FirebaseUser user) {
    hideProgressDialog();
    if (user != null) {
        mStatusTextView.setText(getString(R.string.google_status_fmt, user.getEmail()));
        mDetailTextView.setText(getString(R.string.firebase_status_fmt, user.getUid()));

        findViewById(R.id.sign_in_button).setVisibility(View.GONE);
        findViewById(R.id.sign_out_and_disconnect).setVisibility(View.VISIBLE);
        user.getToken(true).addOnSuccessListener(new OnSuccessListener<GetTokenResult>() {
            @Override
            public void onSuccess(GetTokenResult getTokenResult) {
                makeEndpointsRequest(getTokenResult.getToken());
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                alert("Failed to get token from Firebase.");
            }
        });
    } else {
        mStatusTextView.setText(R.string.signed_out);
        mDetailTextView.setText(null);
        mResponseTextView.setText("");

        findViewById(R.id.sign_in_button).setVisibility(View.VISIBLE);
        findViewById(R.id.sign_out_and_disconnect).setVisibility(View.GONE);
    }
}
 

private void updateUI(FirebaseUser user) {
    hideProgressDialog();
    if (user != null) {
        mStatusTextView.setText(getString(R.string.facebook_status_fmt, user.getDisplayName()));
        mDetailTextView.setText(getString(R.string.firebase_status_fmt, user.getUid()));

        findViewById(R.id.button_facebook_login).setVisibility(View.GONE);
        findViewById(R.id.button_facebook_signout).setVisibility(View.VISIBLE);
        user.getToken(true).addOnSuccessListener(new OnSuccessListener<GetTokenResult>() {
            @Override
            public void onSuccess(GetTokenResult getTokenResult) {
                makeEndpointsRequest(getTokenResult.getToken());
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                alert("Failed to get token from Firebase.");
            }
        });
    } else {
        mStatusTextView.setText(R.string.signed_out);
        mDetailTextView.setText(null);
        mResponseTextView.setText("");

        findViewById(R.id.button_facebook_login).setVisibility(View.VISIBLE);
        findViewById(R.id.button_facebook_signout).setVisibility(View.GONE);
    }
}
 

@ReactMethod
public void getToken(final Callback callback) {
  FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();

  user.getToken(true)
    .addOnCompleteListener(new OnCompleteListener<GetTokenResult>() {
      @Override
      public void onComplete(@NonNull Task<GetTokenResult> task) {
        if (task.isSuccessful()) {
          String token = task.getResult().getToken();
          WritableMap resp = Arguments.createMap();
          resp.putString("status", "complete");
          resp.putString("token", token);
          callback.invoke(null, resp);
        } else {
          WritableMap err = Arguments.createMap();
          err.putInt("errorCode", ERROR_FETCHING_TOKEN);
          err.putString("errorMessage", task.getException().getMessage());
          callback.invoke(err);
        }
      }
    }).addOnFailureListener(new OnFailureListener() {
          @Override
          public void onFailure(@NonNull Exception ex) {
            userExceptionCallback(ex, callback);
          }
        });
}
 

public void userCallback(FirebaseUser passedUser, final Callback callback) {

        if (passedUser == null) {
          mAuth = FirebaseAuth.getInstance();
          this.user = mAuth.getCurrentUser();
        } else {
          this.user = passedUser;
        }

        this.user.getToken(false).addOnCompleteListener(new OnCompleteListener<GetTokenResult>() {
            @Override
            public void onComplete(@NonNull Task<GetTokenResult> task) {
                WritableMap msgMap = Arguments.createMap();
                WritableMap userMap = getUserMap();
                boolean authenticated = false;
                if (FirestackAuthModule.this.user != null) {
                    final String token = task.getResult().getToken();
                    userMap.putString("token", token);
                    authenticated = true;
                }

                msgMap.putMap("user", userMap);
                msgMap.putBoolean("authenticated", authenticated);
                callback.invoke(null, msgMap);
            }
        }).addOnFailureListener(new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception ex) {
                userExceptionCallback(ex, callback);
              }
            });
    }
 

public void refreshInternalFirebaseToken(final RequestFirebaseIdTokenCallback callback) {
    if (getCurrentFirebaseUser() == null) {
        Log.v(TAG, "Getting Token error. ERROR = Current Firebse User is null");
        SharedHelper.getInstance().saveFirebaseToken(null);
        callback.onError(new IllegalStateException("Current Firebase User is null"));
        return;
    }

    threadPoolExecutor.execute(new Runnable() {
        @Override
        public void run() {
            getCurrentFirebaseUser().getIdToken(false).addOnCompleteListener(new OnCompleteListener<GetTokenResult>() {
                public void onComplete(@NonNull Task<GetTokenResult> task) {
                    if (task.isSuccessful()) {
                        String accessToken = task.getResult().getToken();
                        Log.v(TAG, "Token got successfully. TOKEN = " + accessToken);
                        SharedHelper.getInstance().saveFirebaseToken(accessToken);
                        callback.onSuccess(accessToken);
                    } else {
                        Log.v(TAG, "Getting Token error. ERROR = " + task.getException().getMessage());
                        callback.onError(task.getException());
                    }
                }
            });
        }
    });
}