App Check Desktop - GetToken and Listeners support (#1184)

* App Check Desktop - GetToken and Listeners support

* Formatting

* Update app_check_desktop.cc

* Update app_check_desktop.cc

* Cache the Provider

* Update app_check_desktop.cc

* Update app_check_desktop.cc

Author: a-maurice

app_check/integration_test/src/integration_test.cc

@@ -370,13 +370,18 @@ TEST_F(FirebaseAppCheckTest, TestGetTokenForcingRefresh) {
   EXPECT_NE(token.token, "");
   EXPECT_NE(token.expire_time_millis, 0);
 
+  // Wait a bit to make sure the expire time would be different
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
   // GetToken with force_refresh=false will return the same token.
   firebase::Future<::firebase::app_check::AppCheckToken> future2 =
       app_check->GetAppCheckToken(false);
   EXPECT_TRUE(WaitForCompletion(future2, "GetToken #2"));
   EXPECT_EQ(future.result()->expire_time_millis,
             future2.result()->expire_time_millis);
 
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
   // GetToken with force_refresh=true will return a new token.
   firebase::Future<::firebase::app_check::AppCheckToken> future3 =
       app_check->GetAppCheckToken(true);
@@ -452,7 +457,7 @@ TEST_F(FirebaseAppCheckTest, TestSignIn) {
 TEST_F(FirebaseAppCheckTest, TestDebugProviderValidToken) {
   firebase::app_check::DebugAppCheckProviderFactory* factory =
       firebase::app_check::DebugAppCheckProviderFactory::GetInstance();
-#if FIREBASE_PLATFORM_IOS
+#if FIREBASE_PLATFORM_IOS || FIREBASE_PLATFORM_DESKTOP
   ASSERT_NE(factory, nullptr);
   InitializeApp();
   firebase::app_check::AppCheckProvider* provider =

app_check/src/desktop/app_check_desktop.cc

@@ -14,6 +14,9 @@
 
 #include "app_check/src/desktop/app_check_desktop.h"
 
+#include <ctime>
+#include <string>
+
 #include "app_check/src/common/common.h"
 
 namespace firebase {
@@ -22,13 +25,16 @@ namespace internal {
 
 static AppCheckProviderFactory* g_provider_factory = nullptr;
 
-AppCheckInternal::AppCheckInternal(App* app) : app_(app) {
+AppCheckInternal::AppCheckInternal(App* app)
+    : app_(app), cached_token_(), cached_provider_() {
   future_manager().AllocFutureApi(this, kAppCheckFnCount);
 }
 
 AppCheckInternal::~AppCheckInternal() {
   future_manager().ReleaseFutureApi(this);
   app_ = nullptr;
+  // Clear the cached token by setting the expiration
+  cached_token_.expire_time_millis = 0;
 }
 
 ::firebase::App* AppCheckInternal::app() const { return app_; }
@@ -37,6 +43,29 @@ ReferenceCountedFutureImpl* AppCheckInternal::future() {
   return future_manager().GetFutureApi(this);
 }
 
+bool AppCheckInternal::HasValidCacheToken() const {
+  // Get the current time, in milliseconds
+  int64_t current_time = std::time(nullptr) * 1000;
+  // TODO(amaurice): Add some additional time to the check
+  return cached_token_.expire_time_millis > current_time;
+}
+
+void AppCheckInternal::UpdateCachedToken(AppCheckToken token) {
+  cached_token_ = token;
+  // Call the token listeners
+  for (AppCheckListener* listener : token_listeners_) {
+    listener->OnAppCheckTokenChanged(token);
+  }
+}
+
+AppCheckProvider* AppCheckInternal::GetProvider() {
+  if (!cached_provider_ && g_provider_factory && app_) {
+    cached_provider_ = g_provider_factory->CreateProvider(app_);
+  }
+  return cached_provider_;
+}
+
+// static
 void AppCheckInternal::SetAppCheckProviderFactory(
     AppCheckProviderFactory* factory) {
   g_provider_factory = factory;
@@ -47,8 +76,30 @@ void AppCheckInternal::SetTokenAutoRefreshEnabled(
 
 Future<AppCheckToken> AppCheckInternal::GetAppCheckToken(bool force_refresh) {
   auto handle = future()->SafeAlloc<AppCheckToken>(kAppCheckFnGetAppCheckToken);
-  AppCheckToken token;
-  future()->CompleteWithResult(handle, 0, token);
+  if (!force_refresh && HasValidCacheToken()) {
+    // If the cached token is valid, and not told to refresh, return the cache
+    future()->CompleteWithResult(handle, 0, cached_token_);
+  } else {
+    // Get a new token, and pass the result into the future.
+    AppCheckProvider* provider = GetProvider();
+    if (provider != nullptr) {
+      auto token_callback{
+          [this, handle](firebase::app_check::AppCheckToken token,
+                         int error_code, const std::string& error_message) {
+            if (error_code == firebase::app_check::kAppCheckErrorNone) {
+              UpdateCachedToken(token);
+              future()->CompleteWithResult(handle, 0, token);
+            } else {
+              future()->Complete(handle, error_code, error_message.c_str());
+            }
+          }};
+      provider->GetToken(token_callback);
+    } else {
+      future()->Complete(
+          handle, firebase::app_check::kAppCheckErrorInvalidConfiguration,
+          "No AppCheckProvider installed.");
+    }
+  }
   return MakeFuture(future(), handle);
 }
 
@@ -57,9 +108,23 @@ Future<AppCheckToken> AppCheckInternal::GetAppCheckTokenLastResult() {
       future()->LastResult(kAppCheckFnGetAppCheckToken));
 }
 
-void AppCheckInternal::AddAppCheckListener(AppCheckListener* listener) {}
+void AppCheckInternal::AddAppCheckListener(AppCheckListener* listener) {
+  if (listener) {
+    token_listeners_.push_back(listener);
 
-void AppCheckInternal::RemoveAppCheckListener(AppCheckListener* listener) {}
+    // Following the Android pattern, if there is a cached token, call the
+    // listener. Note that the iOS implementation does not do this.
+    if (HasValidCacheToken()) {
+      listener->OnAppCheckTokenChanged(cached_token_);
+    }
+  }
+}
+
+void AppCheckInternal::RemoveAppCheckListener(AppCheckListener* listener) {
+  if (listener) {
+    token_listeners_.remove(listener);
+  }
+}
 
 }  // namespace internal
 }  // namespace app_check

app_check/src/desktop/app_check_desktop.h

@@ -15,6 +15,8 @@
 #ifndef FIREBASE_APP_CHECK_SRC_DESKTOP_APP_CHECK_DESKTOP_H_
 #define FIREBASE_APP_CHECK_SRC_DESKTOP_APP_CHECK_DESKTOP_H_
 
+#include <list>
+
 #include "app/src/future_manager.h"
 #include "app/src/include/firebase/app.h"
 #include "app/src/include/firebase/future.h"
@@ -49,9 +51,25 @@ class AppCheckInternal {
   ReferenceCountedFutureImpl* future();
 
  private:
+  // Is the cached token valid
+  bool HasValidCacheToken() const;
+
+  // Update the cached Token, and call the listeners
+  void UpdateCachedToken(AppCheckToken token);
+
+  // Get the Provider associated with the stored App used to create this.
+  AppCheckProvider* GetProvider();
+
   ::firebase::App* app_;
 
   FutureManager future_manager_;
+
+  // Cached provider for the App. Use GetProvider instead of this.
+  AppCheckProvider* cached_provider_;
+  // Cached token, can be expired.
+  AppCheckToken cached_token_;
+  // List of registered listeners for Token changes.
+  std::list<AppCheckListener*> token_listeners_;
 };
 
 }  // namespace internal