Add implementation for FirebaseAppCheck class (#674)

* Add support for GetAppCheckToken

* Rename set callback function

* Add logic for listening to token changes

* Use the callback queue for C# calls

* Update based on feedback

* Add more comments around the callbacks

Author: a-maurice

app_check/src/AppCheckToken.cs

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+using System;
+
 namespace Firebase.AppCheck {
 
 /// @brief Token used by the Firebase App Check service.
@@ -27,7 +29,25 @@ public struct AppCheckToken {
   public string Token { get; set; }
 
   /// The time at which the token will expire.
-  public System.DateTime ExpireTime { get; set; }
+  public DateTime ExpireTime { get; set; }
+
+  internal static readonly DateTime s_unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+  // Construct an AppCheckToken given the swig generated class for one.
+  internal static AppCheckToken FromAppCheckTokenInternal(AppCheckTokenInternal tokenInternal) {
+    return new AppCheckToken {
+      Token = tokenInternal.token,
+      ExpireTime = s_unixEpoch.AddMilliseconds((double)tokenInternal.expire_time_millis)
+    };
+  }
+
+  // Get the expire time in milliseconds since Epoch, which is used by C++.
+  internal long ExpireTimeMs {
+    get {
+      TimeSpan ts = ExpireTime - s_unixEpoch;
+      return (long)ts.TotalMilliseconds;
+    }
+  }
 }
 
 }

app_check/src/FirebaseAppCheck.cs

@@ -24,12 +24,21 @@ public sealed class FirebaseAppCheck {
   // The C++ object that this wraps.
   private AppCheckInternal appCheckInternal;
 
-  private static Dictionary<FirebaseApp, FirebaseAppCheck> appCheckMap =
-    new Dictionary<FirebaseApp, FirebaseAppCheck>();
+  // Use the FirebaseApp's name instead of the App itself, to not
+  // keep it alive unnecessarily.
+  private static Dictionary<string, FirebaseAppCheck> appCheckMap =
+    new Dictionary<string, FirebaseAppCheck>();
   // The user provided Factory.
   private static IAppCheckProviderFactory appCheckFactory;
-  private static Dictionary<FirebaseApp, IAppCheckProvider> providerMap =
-    new Dictionary<FirebaseApp, IAppCheckProvider>();
+  private static Dictionary<string, IAppCheckProvider> providerMap =
+    new Dictionary<string, IAppCheckProvider>();
+
+  // Function for C++ to call when it needs to fetch a Token.
+  private static AppCheckUtil.GetTokenFromCSharpDelegate getTokenDelegate =
+    new AppCheckUtil.GetTokenFromCSharpDelegate(GetTokenFromCSharpMethod);
+  // Function for C++ to call when the Token changes.
+  private static AppCheckUtil.TokenChangedDelegate tokenChangedDelegate =
+    new AppCheckUtil.TokenChangedDelegate(TokenChangedMethod);
 
   // Make the constructor private, since users aren't meant to make it.
   private FirebaseAppCheck(AppCheckInternal internalObject) {
@@ -55,11 +64,10 @@ public static FirebaseAppCheck DefaultInstance {
   /// {@link FirebaseApp} instance.
   public static FirebaseAppCheck GetInstance(FirebaseApp app) {
     FirebaseAppCheck result;
-    if (!appCheckMap.TryGetValue(app, out result)) {
+    if (!appCheckMap.TryGetValue(app.Name, out result)) {
       AppCheckInternal internalObject = AppCheckInternal.GetInstance(app);
       result = new FirebaseAppCheck(internalObject);
-      appCheckMap[app] = result;
-      // TODO(amaurice): Logic to remove from map when App is destroyed?
+      appCheckMap[app.Name] = result;
     }
     return result;
   }
@@ -79,8 +87,20 @@ public static FirebaseAppCheck GetInstance(FirebaseApp app) {
   ///
   /// This method should be called before initializing the Firebase App.
   public static void SetAppCheckProviderFactory(IAppCheckProviderFactory factory) {
+    if (appCheckFactory == factory) return;
+
     appCheckFactory = factory;
-    // TODO(amaurice): Clear the provider map when the factory changes?
+    // Clear out the Providers that were previously made. When future calls to
+    // GetToken fails to find a provider in the map, it will use the new factory
+    // to create a new provider.
+    providerMap.Clear();
+
+    // Register the callback for C++ SDK to use that will reach this factory.
+    if (factory == null) {
+      AppCheckUtil.SetGetTokenCallback(null);
+    } else {
+      AppCheckUtil.SetGetTokenCallback(getTokenDelegate);
+    }
   }
 
   /// Sets the {@code isTokenAutoRefreshEnabled} flag.
@@ -95,11 +115,93 @@ public void SetTokenAutoRefreshEnabled(bool isTokenAutoRefreshEnabled) {
   public System.Threading.Tasks.Task<AppCheckToken>
       GetAppCheckTokenAsync(bool forceRefresh) {
     ThrowIfNull();
-    throw new NotImplementedException();
+    return appCheckInternal.GetAppCheckTokenAsync(forceRefresh).ContinueWith(task => {
+      if (task.IsFaulted) {
+        throw task.Exception;
+      }
+      AppCheckTokenInternal tokenInternal = task.Result;
+      return AppCheckToken.FromAppCheckTokenInternal(tokenInternal);
+    });
   }
 
   /// Called on the client when an AppCheckToken is created or changed.
-  public System.EventHandler<TokenChangedEventArgs> TokenChanged;
+  private event EventHandler<TokenChangedEventArgs> TokenChangedImpl;
+  public event EventHandler<TokenChangedEventArgs> TokenChanged {
+    add {
+      ThrowIfNull();
+      // If this is the first listener, hook into C++.
+      if (TokenChangedImpl == null ||
+          TokenChangedImpl.GetInvocationList().Length == 0) {
+        AppCheckUtil.SetTokenChangedCallback(appCheckInternal, tokenChangedDelegate);
+      }
+
+      TokenChangedImpl += value;
+    }
+    remove {
+      ThrowIfNull();
+      TokenChangedImpl -= value;
+
+      // If that was the last listener, remove the C++ hooks.
+      if (TokenChangedImpl == null ||
+          TokenChangedImpl.GetInvocationList().Length == 0) {
+        AppCheckUtil.SetTokenChangedCallback(appCheckInternal, null);
+      }
+    }
+  }
+
+  internal void OnTokenChanged(AppCheckToken token) {
+    EventHandler<TokenChangedEventArgs> handler = TokenChangedImpl;
+    if (handler != null) {
+      handler(this, new TokenChangedEventArgs() { Token = token });
+    }
+  }
+
+  [MonoPInvokeCallback(typeof(AppCheckUtil.GetTokenFromCSharpDelegate))]
+  private static void GetTokenFromCSharpMethod(string appName, int key) {
+    if (appCheckFactory == null) {
+      AppCheckUtil.FinishGetTokenCallback(key, "", 0,
+        (int)AppCheckError.InvalidConfiguration,
+        "Missing IAppCheckProviderFactory.");
+    }
+    FirebaseApp app = FirebaseApp.GetInstance(appName);
+    if (app == null) {
+      AppCheckUtil.FinishGetTokenCallback(key, "", 0,
+        (int)AppCheckError.Unknown,
+        "Unable to find App with name: " + appName);
+    }
+    IAppCheckProvider provider;
+    if (!providerMap.TryGetValue(app.Name, out provider)) {
+      provider = appCheckFactory.CreateProvider(app);
+      if (provider == null) {
+        AppCheckUtil.FinishGetTokenCallback(key, "", 0,
+          (int)AppCheckError.InvalidConfiguration,
+          "Failed to create IAppCheckProvider for App: " + appName);
+      }
+      providerMap[app.Name] = provider;
+    }
+    provider.GetTokenAsync().ContinueWith(task => {
+      if (task.IsFaulted) {
+        AppCheckUtil.FinishGetTokenCallback(key, "", 0,
+          (int)AppCheckError.Unknown,
+          "Provider returned an Exception: " + task.Exception);
+      } else {
+        AppCheckToken token = task.Result;
+        AppCheckUtil.FinishGetTokenCallback(key, token.Token,
+          token.ExpireTimeMs, 0, "");
+      }
+    });
+  }
+
+  [MonoPInvokeCallback(typeof(AppCheckUtil.TokenChangedDelegate))]
+  private static void TokenChangedMethod(string appName, System.IntPtr tokenCPtr) {
+    AppCheckTokenInternal tokenInternal = new AppCheckTokenInternal(tokenCPtr, false);
+    AppCheckToken token = AppCheckToken.FromAppCheckTokenInternal(tokenInternal);
+
+    FirebaseAppCheck appCheck;
+    if (appCheckMap.TryGetValue(appName, out appCheck)) {
+      appCheck.OnTokenChanged(token);
+    }
+  }
 }
 
 }