import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Deletes the current registration token.
 *
 * @param instanceId The instance ID which generated the registration token.
 * @param senderId   The sender ID to revoke the registration token from.
 * @return A task that can be resolved upon deletion of the token.
 */
private Task<Void> deleteRegistrationToken(final InstanceID instanceId, final String senderId) {
    final TaskCompletionSource<Void> future = new TaskCompletionSource<>();
    new AsyncTask<Object, Integer, String>() {
        @Override
        protected String doInBackground(final Object[] ignored) {

            try {
                instanceId.deleteToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE);
            } catch (final IOException e) {
                Log.e(TAG, "Error deleting GCM registration token", e);
                future.setException(e);
                return null;
            }

            future.setResult(null);
            return null;
        }
    }.execute();

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Gets or creates a registration token.
 *
 * @param instanceId The instance ID which should generate the registration token.
 * @param senderId   The sender ID to generate the registration token for.
 * @return A task that can be resolved upon creating/retrieval of the token.
 */
private Task<String> getRegistrationToken(final InstanceID instanceId, final String senderId) {
    final TaskCompletionSource<String> future = new TaskCompletionSource<>();
    new AsyncTask<Object, Integer, String>() {
        @Override
        protected String doInBackground(final Object[] ignored) {

            final String registrationToken;
            try {
                registrationToken = instanceId.getToken(senderId, GoogleCloudMessaging.INSTANCE_ID_SCOPE);
            } catch (final IOException e) {
                Log.e(TAG, "Error getting GCM registration token", e);
                future.setException(e);
                return null;
            }

            future.setResult(registrationToken);
            return null;
        }
    }.execute();

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
public Task<Map<DatabaseReference, DataSnapshot>> start() {
    // Create a Task<DataSnapshot> to trigger in response to each database listener.
    //
    final ArrayList<Task<DataSnapshot>> tasks = new ArrayList<>(refs.size());
    for (final DatabaseReference ref : refs) {
        final TaskCompletionSource<DataSnapshot> source = new TaskCompletionSource<>();
        final ValueEventListener listener = new MyValueEventListener(ref, source);
        ref.addListenerForSingleValueEvent(listener);
        listeners.put(ref, listener);
        tasks.add(source.getTask());
    }

    // Return a single Task that triggers when all queries are complete.  It contains
    // a map of all original DatabaseReferences originally given here to their resulting
    // DataSnapshot.
    //
    return Tasks.whenAll(tasks).continueWith(new Continuation<Void, Map<DatabaseReference, DataSnapshot>>() {
        @Override
        public Map<DatabaseReference, DataSnapshot> then(@NonNull Task<Void> task) throws Exception {
            task.getResult();
            return new HashMap<>(snaps);
        }
    });
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Subscribes the client to a specific topic.
 * /topics/ prefix is not necessary.
 *
 * @param topic The topic to subscribe to
 *
 * @return A task that can resolved upon subscribing.
 */
public Task<Void> subscribeToTopic(final String topic) {
    final GcmPubSub pubSub = GcmPubSub.getInstance(getContext());
    final String topicKey = String.format("/topics/%s", topic);
    final InstanceID instanceId = InstanceID.getInstance(getContext());

    final TaskCompletionSource<Void> future = new TaskCompletionSource<>();

    getRegistrationToken(instanceId, _info.getSenderId()).addOnCompleteListener(new OnCompleteListener<String>() {
        @Override
        public void onComplete(@NonNull final Task<String> task) {
            if (!task.isSuccessful()) {
                future.setException(task.getException());
            }

            new AsyncTask<Object, Integer, String>() {
                @Override
                protected String doInBackground(final Object[] ignored) {

                    try {
                        pubSub.subscribe(task.getResult(), topicKey, null);
                    } catch (final IOException e) {
                        Log.e(TAG, "Error subscribing to " + topicKey, e);
                        future.setException(e);
                        return null;
                    }

                    future.setResult(null);
                    return null;
                }
            }.execute();
        }
    });

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Subscribes the client to a specific topic.
 * /topics/ prefix is not necessary.
 *
 * @param topic The topic to unsubscribe from
 *
 * @return A task that can resolved upon subscribing.
 */
public Task<Void> unsubscribeFromTopic(final String topic) {
    final GcmPubSub pubSub = GcmPubSub.getInstance(getContext());
    final String topicKey = String.format("/topics/%s", topic);
    final InstanceID instanceId = InstanceID.getInstance(getContext());

    final TaskCompletionSource<Void> future = new TaskCompletionSource<>();

    getRegistrationToken(instanceId, _info.getSenderId()).addOnCompleteListener(new OnCompleteListener<String>() {
        @Override
        public void onComplete(@NonNull final Task<String> task) {
            if (!task.isSuccessful()) {
                future.setException(task.getException());
            }

            new AsyncTask<Object, Integer, String>() {
                @Override
                protected String doInBackground(final Object[] ignored) {

                    try {
                        pubSub.unsubscribe(task.getResult(), topicKey);
                    } catch (final IOException e) {
                        Log.e(TAG, "Error unsubscribing from " + topicKey, e);
                        future.setException(e);
                        return null;
                    }

                    future.setResult(null);
                    return null;
                }
            }.execute();
        }
    });

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Registers the current user using email and password.
 *
 * @param email    email for the given user
 * @param password password for the given user
 * @return A task containing whether or not registration was successful.
 */
public Task<Boolean> register(@NonNull String email, @NonNull String password) {
    final EmailPasswordAuthProvider provider = new EmailPasswordAuthProvider(email, password);

    final TaskCompletionSource<Boolean> future = new TaskCompletionSource<>();
    final String url = String.format(
            "%s/%s",
            getResourcePath(routes.AUTH),
            routes.USERPASS_REGISTER
    );

    final JsonStringRequest request = new JsonStringRequest(
            Request.Method.POST,
            url,
            getAuthRequest(provider.getRegistrationPayload()).toJson(),
            new Response.Listener<String>() {
                @Override
                public void onResponse(final String response) {
                    future.setResult(response != null);
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(final VolleyError error) {
                    Log.e(TAG, "Error while logging in with auth provider", error);
                    future.setException(parseRequestError(error));
                }
            }
    );

    request.setTag(this);
    _queue.add(request);

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Confirm a newly registered email in this context
 *
 * @param token   confirmation token emailed to new user
 * @param tokenId confirmation tokenId emailed to new user
 * @return A task containing whether or not the email was confirmed successfully
 */
public Task<Boolean> emailConfirm(@NonNull final String token, @NonNull final String tokenId) {
    final TaskCompletionSource<Boolean> future = new TaskCompletionSource<>();

    final String url = String.format(
            "%s/%s",
            getResourcePath(routes.AUTH),
            routes.USERPASS_CONFIRM
    );

    final Document params = new Document();

    params.put("token", token);
    params.put("tokenId", tokenId);

    final JsonStringRequest request = new JsonStringRequest(
            Request.Method.POST,
            url,
            params.toJson(),
            new Response.Listener<String>() {
                @Override
                public void onResponse(final String response) {
                    future.setResult(response != null);
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(final VolleyError error) {
                    Log.e(TAG, "Error while confirming email", error);
                    future.setException(parseRequestError(error));
                }
            }
    );

    request.setTag(this);
    _queue.add(request);

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Send a confirmation email for a newly registered user
 *
 * @param email email address of user
 * @return A task containing whether or not the email was sent successfully.
 */
public Task<Boolean> sendEmailConfirm(@NonNull final String email) {
    final TaskCompletionSource<Boolean> future = new TaskCompletionSource<>();

    final String url = String.format(
            "%s/%s",
            getResourcePath(routes.AUTH),
            routes.USERPASS_CONFIRM_SEND
    );

    final JsonStringRequest request = new JsonStringRequest(
            Request.Method.POST,
            url,
            new Document("email", email).toJson(),
            new Response.Listener<String>() {
                @Override
                public void onResponse(final String response) {
                    future.setResult(response != null);
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(final VolleyError error) {
                    Log.e(TAG, "Error while sending confirmation email", error);
                    future.setException(parseRequestError(error));
                }
            }
    );

    request.setTag(this);
    _queue.add(request);

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Send a reset password email to a given email address
 *
 * @param email email address to reset password for
 * @return A task containing whether or not the reset email was sent successfully
 */
public Task<Boolean> sendResetPassword(@NonNull final String email) {
    final TaskCompletionSource<Boolean> future = new TaskCompletionSource<>();

    final String url = String.format(
            "%s/%s",
            getResourcePath(routes.AUTH),
            routes.USERPASS_RESET_SEND
    );

    final JsonStringRequest request = new JsonStringRequest(
            Request.Method.POST,
            url,
            new Document("email", email).toJson(),
            new Response.Listener<String>() {
                @Override
                public void onResponse(final String response) {
                    future.setResult(response != null);
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(final VolleyError error) {
                    Log.e(TAG, "Error while sending reset password email", error);
                    future.setException(parseRequestError(error));
                }
            }
    );

    request.setTag(this);
    _queue.add(request);

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
private Task<String> getLineAccessCode(final Activity activity) {
    final TaskCompletionSource<String> source = new TaskCompletionSource<>();

    // STEP 1: User logins with LINE and get their LINE access token
    LineSdkContext sdkContext = LineSdkContextManager.getSdkContext();
    LineAuthManager authManager = sdkContext.getAuthManager();
    LineLoginFuture loginFuture = authManager.login(activity);
    loginFuture.addFutureListener(new LineLoginFutureListener() {
        @Override
        public void loginComplete(LineLoginFuture future) {
            switch(future.getProgress()) {
                case SUCCESS: //Login successfully
                    String lineAccessToken = future.getAccessToken().accessToken;
                    Log.d(TAG, "LINE Access token = " + lineAccessToken);
                    source.setResult(lineAccessToken);
                    break;
                case CANCELED: // Login canceled by user
                    Exception e = new Exception("User cancelled LINE Login.");
                    source.setException(e);
                    break;
                default: // Error
                    Throwable cause = future.getCause();
                    if (cause instanceof LineSdkLoginException) {
                        LineSdkLoginException loginException = (LineSdkLoginException) cause;
                        Log.e(TAG, loginException.getMessage());
                        source.setException(loginException);
                    } else {
                        source.setException(new Exception("Unknown error occurred in LINE SDK."));
                    }
                    break;
            }
        }
    });

    return source.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
private Task<String> getFirebaseAuthToken(Context context, final String lineAccessToken) {
    final TaskCompletionSource<String> source = new TaskCompletionSource<>();

    // STEP 2: Exchange LINE access token for Firebase Custom Auth token
    HashMap<String, String> validationObject = new HashMap<>();
    validationObject.put("token", lineAccessToken);

    // Exchange LINE Access Token for Firebase Auth Token
    Response.Listener<JSONObject> responseListener = new Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {
            try {
                String firebaseToken = response.getString("firebase_token");
                Log.d(TAG, "Firebase Token = " + firebaseToken);
                source.setResult(firebaseToken);
            } catch (Exception e) {
                source.setException(e);
            }
        }
    };

    Response.ErrorListener errorListener = new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            Log.e(TAG, error.toString());
            source.setException(error);
        }
    };

    JsonObjectRequest fbTokenRequest = new JsonObjectRequest(
            Request.Method.POST, mLineAcessscodeVerificationEndpoint,
            new JSONObject(validationObject),
            responseListener, errorListener);

    NetworkSingleton.getInstance(context).addToRequestQueue(fbTokenRequest);

    return source.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 *
 * @param kakaoAccessToken Access token retrieved after successful Kakao Login
 * @return Task object that will call validation server and retrieve firebase token
 */
private Task<String> getFirebaseJwt(final String kakaoAccessToken) {
    final TaskCompletionSource<String> source = new TaskCompletionSource<>();

    RequestQueue queue = Volley.newRequestQueue(this);
    String url = getResources().getString(R.string.validation_server_domain) + "/verifyToken";
    HashMap<String, String> validationObject = new HashMap<>();
    validationObject.put("token", kakaoAccessToken);

    JsonObjectRequest request = new JsonObjectRequest(Request.Method.POST, url, new JSONObject(validationObject), new Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {
            try {
                String firebaseToken = response.getString("firebase_token");
                source.setResult(firebaseToken);
            } catch (Exception e) {
                source.setException(e);
            }

        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            Log.e(TAG, error.toString());
            source.setException(error);
        }
    }) {
        @Override
        protected Map<String, String> getParams() {
            Map<String, String> params = new HashMap<>();
            params.put("token", kakaoAccessToken);
            return params;
        }
    };

    queue.add(request);
    return source.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
public Task<Status> signOut() {
    final TaskCompletionSource<Status> statusTask = new TaskCompletionSource<>();
    getConnectedApiTask().addOnCompleteListener(new ExceptionForwarder<>(
            statusTask,
            new OnSuccessListener<Bundle>() {
                @Override
                public void onSuccess(Bundle status) {
                    Auth.GoogleSignInApi.signOut(mClient)
                            .setResultCallback(new TaskResultCaptor<>(statusTask));
                }
            }));
    return statusTask.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
public Task<Status> disableAutoSignIn() {
    final TaskCompletionSource<Status> statusTask = new TaskCompletionSource<>();
    getConnectedApiTask().addOnCompleteListener(new ExceptionForwarder<>(
            statusTask,
            new OnSuccessListener<Bundle>() {
                @Override
                public void onSuccess(Bundle status) {
                    Auth.CredentialsApi.disableAutoSignIn(mClient)
                            .setResultCallback(new TaskResultCaptor<>(statusTask));
                }
            }));
    return statusTask.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
public Task<Status> delete(final Credential credential) {
    final TaskCompletionSource<Status> statusTask = new TaskCompletionSource<>();
    getConnectedApiTask().addOnCompleteListener(new ExceptionForwarder<>(
            statusTask,
            new OnSuccessListener<Bundle>() {
                @Override
                public void onSuccess(Bundle status) {
                    Auth.CredentialsApi.delete(mClient, credential)
                            .setResultCallback(new TaskResultCaptor<>(statusTask));
                }
            }));
    return statusTask.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Returns a task that will complete when given file is closed.  Returns immediately if the
 * file is not open.
 *
 * @param filename - the file name in question.
 */
public Task<Result> waitForClosed(String filename) {
  final TaskCompletionSource<Result> taskCompletionSource = new TaskCompletionSource<>();

  final CountDownLatch latch;
  synchronized (this) {
    latch = opened.get(filename);
  }

  if (latch == null) {
    taskCompletionSource.setResult(null);

    return taskCompletionSource.getTask();
  }

  new AsyncTask<Void, Void, Void>() {
    @Override
    protected Void doInBackground(Void... voids) {
      Result result = new CountDownTask(latch).await();
      taskCompletionSource.setResult(result);

      return null;
    }
  }.execute();

  return taskCompletionSource.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
@NonNull
private Task<Void> setIsOpeningTask(String filename) {
  TaskCompletionSource<Void> source = new TaskCompletionSource<>();

  if (isAlreadyOpen(filename)) {
    source.setException(new IllegalStateException(filename + " is already open!"));
  } else if (isAlreadyClosing(filename)) {
    source.setException(new IllegalStateException(filename + " is current closing!"));
  } else {
    setIsOpening(filename);
    source.setResult(null);
  }
  return source.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
@NonNull
private Task<Void> setIsClosingTask(String filename) {
  TaskCompletionSource<Void> source = new TaskCompletionSource<>();

  if (!isAlreadyOpen(filename)) {
    source.setException(new IllegalStateException(filename + " is already closed!"));
  } else if (isAlreadyClosing(filename)) {
    source.setException(new IllegalStateException(filename + " is current closing!"));
  } else {
    setIsClosing(filename);
    source.setResult(null);
  }
  return source.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Logs the current user in using a specific auth provider.
 *
 * @param authProvider The provider that will handle the login.
 * @return A task containing an {@link AuthInfo} session that can be resolved on completion of log in.
 */
public Task<String> logInWithProvider(AuthProvider authProvider) {

    if (isAuthenticated()) {
        Log.d(TAG, "Already logged in. Returning cached token");
        return Tasks.forResult(_auth.getAuthInfo().getUserId());
    }

    final TaskCompletionSource<String> future = new TaskCompletionSource<>();

    final JsonStringRequest request = new JsonStringRequest(
            Request.Method.POST,
            getResourcePath(routes.getAuthProvidersLoginRoute(authProvider.getType())),
            getAuthRequest(authProvider).toJson(),
            new Response.Listener<String>() {
                @Override
                public void onResponse(final String response) {
                    try {
                        _auth = new Auth(
                                StitchClient.this,
                                _objMapper.readValue(response, AuthInfo.class));
                        final RefreshTokenHolder refreshToken =
                                _objMapper.readValue(response, RefreshTokenHolder.class);
                        _preferences.edit().putString(PREF_AUTH_JWT_NAME, response).apply();
                        _preferences.edit().putString(PREF_AUTH_REFRESH_TOKEN_NAME, refreshToken.getToken()).apply();
                        _preferences.edit().putString(PREF_DEVICE_ID_NAME, _auth.getAuthInfo().getDeviceId()).apply();
                        future.setResult(_auth.getAuthInfo().getUserId());
                        onLogin();
                    } catch (final IOException e) {
                        Log.e(TAG, "Error parsing auth response", e);
                        future.setException(new StitchException(e));
                    }
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(final VolleyError error) {
                    Log.e(TAG, "Error while logging in with auth provider", error);
                    future.setException(parseRequestError(error));
                }
            });
    request.setTag(this);
    _queue.add(request);

    return future.getTask();
}
 

import com.google.android.gms.tasks.TaskCompletionSource; //导入依赖的package包/类
/**
 * Reset a given user's password
 *
 * @param token token associated with this user
 * @param tokenId id of the token associated with this user
 * @return A task containing whether or not the reset was successful
 */
public Task<Boolean> resetPassword(@NonNull final String token,
                                   @NonNull final String tokenId,
                                   @NonNull final String password) {
    final TaskCompletionSource<Boolean> future = new TaskCompletionSource<>();

    final String url = String.format(
            "%s/%s",
            getResourcePath(routes.AUTH),
            routes.USERPASS_RESET
    );

    final Document params = new Document();

    params.put(RegistrationFields.TOKEN, token);
    params.put(RegistrationFields.TOKEN_ID, tokenId);
    params.put(RegistrationFields.PASSWORD, password);

    final JsonStringRequest request = new JsonStringRequest(
            Request.Method.POST,
            url,
            params.toJson(),
            new Response.Listener<String>() {
                @Override
                public void onResponse(final String response) {
                    future.setResult(response != null);
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(final VolleyError error) {
                    Log.e(TAG, "Error while reseting password", error);
                    future.setException(parseRequestError(error));
                }
            }
    );

    request.setTag(this);
    _queue.add(request);

    return future.getTask();
}