Rename to AuthenticationCallback and onRestore

Author: grantland

Parse/src/main/java/com/parse/ParseAuthenticationCallbacks.java renamed to Parse/src/main/java/com/parse/AuthenticationCallback.java

@@ -13,12 +13,12 @@
 /**
  * Provides a general interface for delegation of third party authentication callbacks.
  */
-public interface ParseAuthenticationCallbacks {
+public interface AuthenticationCallback {
   /**
    * Called when restoring third party authentication credentials that have been serialized,
    * such as session keys, etc.
    * <p />
-   * <strong>Note:</strong> This will be executed in a background thread.
+   * <strong>Note:</strong> This will be executed on a background thread.
    *
    * @param authData
    *          The auth data for the provider. This value may be {@code null} when
@@ -27,13 +27,5 @@ public interface ParseAuthenticationCallbacks {
    * @return {@code true} iff the {@code authData} was successfully synchronized or {@code false}
    *          if user should no longer be associated because of bad {@code authData}.
    */
-  boolean onRestoreAuthentication(Map<String, String> authData);
-
-  /**
-   * Called when deauthenticating (logging out) the user associated with this third party
-   * authentication source.
-   * <p />
-   * <strong>Note:</strong> This will be executed in a background thread.
-   */
-  void onDeauthenticate();
+  boolean onRestore(Map<String, String> authData);
 }

Parse/src/main/java/com/parse/ParseAuthenticationManager.java

@@ -18,32 +18,32 @@
 /** package */ class ParseAuthenticationManager {
 
   private final Object lock = new Object();
-  private final Map<String, ParseAuthenticationCallbacks> callbacks = new HashMap<>();
+  private final Map<String, AuthenticationCallback> callbacks = new HashMap<>();
   private final ParseCurrentUserController controller;
 
   public ParseAuthenticationManager(ParseCurrentUserController controller) {
     this.controller = controller;
   }
 
-  public void register(final String authType, ParseAuthenticationCallbacks callbacks) {
+  public void register(final String authType, AuthenticationCallback callback) {
     if (authType == null) {
       throw new IllegalArgumentException("Invalid authType: " + null);
     }
 
     synchronized (lock) {
       if (this.callbacks.containsKey(authType)) {
-        throw new IllegalStateException("Callbacks already registered for <" + authType + ">: "
+        throw new IllegalStateException("Callback already registered for <" + authType + ">: "
             + this.callbacks.get(authType));
       }
-      this.callbacks.put(authType, callbacks);
+      this.callbacks.put(authType, callback);
     }
 
     if (ParseAnonymousUtils.AUTH_TYPE.equals(authType)) {
       // There's nothing to synchronize
       return;
     }
 
-    // Synchronize the current user with the auth callbacks.
+    // Synchronize the current user with the auth callback.
     controller.getAsync(false).onSuccessTask(new Continuation<ParseUser, Task<Void>>() {
       @Override
       public Task<Void> then(Task<ParseUser> task) throws Exception {
@@ -57,31 +57,31 @@ public Task<Void> then(Task<ParseUser> task) throws Exception {
   }
 
   public Task<Boolean> restoreAuthenticationAsync(String authType, final Map<String, String> authData) {
-    final ParseAuthenticationCallbacks callbacks;
+    final AuthenticationCallback callback;
     synchronized (lock) {
-      callbacks = this.callbacks.get(authType);
+      callback = this.callbacks.get(authType);
     }
-    if (callbacks == null) {
+    if (callback == null) {
       return Task.forResult(true);
     }
     return Task.call(new Callable<Boolean>() {
       @Override
       public Boolean call() throws Exception {
-        return callbacks.onRestoreAuthentication(authData);
+        return callback.onRestore(authData);
       }
     }, ParseExecutors.io());
   }
 
   public Task<Void> deauthenticateAsync(String authType) {
-    final ParseAuthenticationCallbacks callbacks;
+    final AuthenticationCallback callback;
     synchronized (lock) {
-      callbacks = this.callbacks.get(authType);
+      callback = this.callbacks.get(authType);
     }
-    if (callbacks != null) {
+    if (callback != null) {
       return Task.call(new Callable<Void>() {
         @Override
         public Void call() throws Exception {
-          callbacks.onDeauthenticate();
+          callback.onRestore(null);
           return null;
         }
       }, ParseExecutors.io());

Parse/src/main/java/com/parse/ParseUser.java

@@ -1079,18 +1079,19 @@ public ParseUser fetchIfNeeded() throws ParseException {
   //region Third party authentication
 
   /**
-   * Registers third party authentication callbacks.
+   * Registers a third party authentication callback.
    * <p />
    * <strong>Note:</strong> This shouldn't be called directly unless developing a third party authentication
    * library.
    *
-   * @param callbacks The third party authentication callbacks to be registered.
+   * @param authType The name of the third party authentication source.
+   * @param callback The third party authentication callback to be registered.
    *
-   * @see ParseAuthenticationCallbacks
+   * @see AuthenticationCallback
    */
-  public static void registerAuthenticationCallbacks(
-      String authType, ParseAuthenticationCallbacks callbacks) {
-    getAuthenticationManager().register(authType, callbacks);
+  public static void registerAuthenticationCallback(
+      String authType, AuthenticationCallback callback) {
+    getAuthenticationManager().register(authType, callback);
   }
 
   /**
@@ -1103,7 +1104,7 @@ public static void registerAuthenticationCallbacks(
    * @param authData The user credentials of the third party authentication source.
    * @return A {@code Task} is resolved when logging in completes.
    *
-   * @see ParseAuthenticationCallbacks
+   * @see AuthenticationCallback
    */
   public static Task<ParseUser> logInWithInBackground(
       final String authType, final Map<String, String> authData) {
@@ -1214,7 +1215,7 @@ public Task<ParseUser> then(Task<Void> task) throws Exception {
    * @param authType The name of the third party authentication source.
    * @return {@code true} if linked, otherwise {@code false}.
    *
-   * @see ParseAuthenticationCallbacks
+   * @see AuthenticationCallback
    */
   public boolean isLinked(String authType) {
     Map<String, Map<String, String>> authData = getAuthData();
@@ -1314,7 +1315,7 @@ public Task<Void> then(Task<Void> task) throws Exception {
    * @param authData The user credentials of the third party authentication source.
    * @return A {@code Task} is resolved when linking completes.
    *
-   * @see ParseAuthenticationCallbacks
+   * @see AuthenticationCallback
    */
   public Task<Void> linkWithInBackground(
       String authType, Map<String, String> authData) {
@@ -1333,7 +1334,7 @@ public Task<Void> linkWithInBackground(
    * @param authType The name of the third party authentication source.
    * @return A {@code Task} is resolved when unlinking completes.
    *
-   * @see ParseAuthenticationCallbacks
+   * @see AuthenticationCallback
    */
   public Task<Void> unlinkFromInBackground(final String authType) {
     if (authType == null) {

Parse/src/test/java/com/parse/ParseAuthenticationManagerTest.java

@@ -31,21 +31,21 @@ public class ParseAuthenticationManagerTest {
 
   private ParseAuthenticationManager manager;
   private ParseCurrentUserController controller;
-  private ParseAuthenticationCallbacks provider;
+  private AuthenticationCallback provider;
 
   @Before
   public void setUp() {
     controller = mock(ParseCurrentUserController.class);
     manager = new ParseAuthenticationManager(controller);
-    provider = mock(ParseAuthenticationCallbacks.class);
+    provider = mock(AuthenticationCallback.class);
   }
 
   //region testRegister
 
   @Test
   public void testRegisterMultipleShouldThrow() {
     when(controller.getAsync(false)).thenReturn(Task.<ParseUser>forResult(null));
-    ParseAuthenticationCallbacks provider2 = mock(ParseAuthenticationCallbacks.class);
+    AuthenticationCallback provider2 = mock(AuthenticationCallback.class);
 
     manager.register("test_provider", provider);
 
@@ -55,7 +55,7 @@ public void testRegisterMultipleShouldThrow() {
 
   @Test
   public void testRegisterAnonymous() {
-    manager.register("anonymous", mock(ParseAuthenticationCallbacks.class));
+    manager.register("anonymous", mock(AuthenticationCallback.class));
     verifyNoMoreInteractions(controller);
   }
 
@@ -74,14 +74,14 @@ public void testRegister() {
   @Test
   public void testRestoreAuthentication() throws ParseException {
     when(controller.getAsync(false)).thenReturn(Task.<ParseUser>forResult(null));
-    when(provider.onRestoreAuthentication(Matchers.<Map<String, String>>any()))
+    when(provider.onRestore(Matchers.<Map<String, String>>any()))
         .thenReturn(true);
     manager.register("test_provider", provider);
 
     Map<String, String> authData = new HashMap<>();
     ParseTaskUtils.wait(manager.restoreAuthenticationAsync("test_provider", authData));
 
-    verify(provider).onRestoreAuthentication(authData);
+    verify(provider).onRestore(authData);
   }
 
   @Test
@@ -91,6 +91,6 @@ public void testDeauthenticateAsync() throws ParseException {
 
     ParseTaskUtils.wait(manager.deauthenticateAsync("test_provider"));
 
-    verify(provider).onDeauthenticate();
+    verify(provider).onRestore(null);
   }
 }

Parse/src/test/java/com/parse/ParseUserTest.java

@@ -569,10 +569,10 @@ public void testlinkWithInBackgroundWithSaveAsyncSuccess() throws Exception {
     when(currentUserController.getAsync(anyBoolean())).thenReturn(Task.<ParseUser>forResult(null));
     ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController);
     // Register mock callbacks
-    ParseAuthenticationCallbacks callbacks = mock(ParseAuthenticationCallbacks.class);
-    when(callbacks.onRestoreAuthentication(Matchers.<Map<String, String>>any()))
+    AuthenticationCallback callbacks = mock(AuthenticationCallback.class);
+    when(callbacks.onRestore(Matchers.<Map<String, String>>any()))
         .thenReturn(true);
-    ParseUser.registerAuthenticationCallbacks("facebook", callbacks);
+    ParseUser.registerAuthenticationCallback("facebook", callbacks);
 
     ParseUser user = new ParseUser();
     // To make synchronizeAuthData work
@@ -600,7 +600,7 @@ public void testlinkWithInBackgroundWithSaveAsyncSuccess() throws Exception {
     verify(partialMockUser, times(1))
         .saveAsync(eq("sessionTokenAgain"), eq(false), Matchers.<Task<Void>>any());
     // Make sure synchronizeAuthData() is called
-    verify(callbacks, times(1)).onRestoreAuthentication(authData);
+    verify(callbacks, times(1)).onRestore(authData);
   }
 
   @Test
@@ -1289,10 +1289,10 @@ public void testSynchronizeAuthData() throws Exception {
     when(currentUserController.getAsync(anyBoolean())).thenReturn(Task.forResult(currentUser));
     ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController);
     // Register mock callbacks
-    ParseAuthenticationCallbacks callbacks = mock(ParseAuthenticationCallbacks.class);
-    when(callbacks.onRestoreAuthentication(Matchers.<Map<String, String>>any()))
+    AuthenticationCallback callbacks = mock(AuthenticationCallback.class);
+    when(callbacks.onRestore(Matchers.<Map<String, String>>any()))
         .thenReturn(true);
-    ParseUser.registerAuthenticationCallbacks("facebook", callbacks);
+    ParseUser.registerAuthenticationCallback("facebook", callbacks);
 
     // Set user initial state
     String authType = "facebook";
@@ -1307,7 +1307,7 @@ public void testSynchronizeAuthData() throws Exception {
     ParseTaskUtils.wait(user.synchronizeAuthDataAsync(authType));
 
     // Make sure we restore authentication
-    verify(callbacks, times(1)).onRestoreAuthentication(authData);
+    verify(callbacks, times(1)).onRestore(authData);
   }
 
   @Test
@@ -1318,10 +1318,10 @@ public void testSynchronizeAllAuthData() throws Exception {
     when(currentUserController.getAsync(anyBoolean())).thenReturn(Task.forResult(currentUser));
     ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController);
     // Register mock callbacks
-    ParseAuthenticationCallbacks callbacks = mock(ParseAuthenticationCallbacks.class);
-    when(callbacks.onRestoreAuthentication(Matchers.<Map<String, String>>any()))
+    AuthenticationCallback callbacks = mock(AuthenticationCallback.class);
+    when(callbacks.onRestore(Matchers.<Map<String, String>>any()))
         .thenReturn(true);
-    ParseUser.registerAuthenticationCallbacks("facebook", callbacks);
+    ParseUser.registerAuthenticationCallback("facebook", callbacks);
 
     // Set user initial state
     String facebookAuthType = "facebook";
@@ -1336,7 +1336,7 @@ public void testSynchronizeAllAuthData() throws Exception {
     ParseTaskUtils.wait(user.synchronizeAllAuthDataAsync());
 
     // Make sure we restore authentication
-    verify(callbacks, times(1)).onRestoreAuthentication(facebookAuthData);
+    verify(callbacks, times(1)).onRestore(facebookAuthData);
   }
 
   //endregion