Implement main App Check classes for iOS (#1149)

AlmostMatt · web-flow · commit e47a26e19e75 · 2022-12-01T14:21:34.000-05:00
Implement main app check logic for iOS. Add app check integration test cases to set factory and get token.
diff --git a/app/src/app_ios.h b/app/src/app_ios.h
@@ -18,6 +18,7 @@
 #define FIREBASE_APP_SRC_APP_IOS_H_
 #include "FIRApp.h"
 #include "FIRConfiguration.h"
+#include "app/src/include/firebase/app.h"
 #include "app/src/util_ios.h"
 
 namespace firebase {
@@ -27,6 +28,18 @@ OBJ_C_PTR_WRAPPER_NAMED(AppInternal, FIRApp);
 
 void SetFirConfigurationLoggerLevel(FIRLoggerLevel level);
 
+// Allows lookup of App by name for apps which are not yet fully initialized.
+// These Apps should have a name and options, but will not yet have an
+// associated AppInternal. This is used by AppCheck to use the App during
+// initialization of AppCheck while the internal FIRApp is being configured.
+App* FindPartialAppByName(const char* name);
+
+// Enables lookup by name for a partially initialized App.
+void AddPartialApp(App*);
+
+// Disables lookup by name for a partially initialized App.
+void RemovePartialApp(App*);
+
 }  // namespace internal
 
 }  // namespace firebase
diff --git a/app/src/app_ios.mm b/app/src/app_ios.mm
@@ -253,13 +253,22 @@ static void PlatformOptionsToAppOptions(FIROptions* platform_options, AppOptions
     return app;
   }
   LogDebug("Creating Firebase App %s for %s", name, kFirebaseVersionString);
+  app = new App();
+  app->options_ = options;
+  app->name_ = name;
+
+  // Add the app to a temporary map in case app check initialization
+  // needs to reference the app before it is fully initialized.
+  internal::AddPartialApp(app);
   FIRApp* platform_app = CreateOrGetPlatformApp(options, name);
+  // Once the app is initialized, the entry in the temporary map is not needed.
+  internal::RemovePartialApp(app);
   if (platform_app) {
-    app = new App();
-    app->options_ = options;
-    app->name_ = name;
     app->internal_ = new internal::AppInternal(platform_app);
     app_common::AddApp(app, &app->init_results_);
+  } else {
+    delete app;
+    app = nullptr;
   }
   return app;
 }
@@ -286,7 +295,15 @@ static void PlatformOptionsToAppOptions(FIROptions* platform_options, AppOptions
   return GetPlatformApp().isDataCollectionDefaultEnabled ? true : false;
 }
 
-FIRApp* App::GetPlatformApp() const { return internal_->get(); }
+FIRApp* App::GetPlatformApp() const {
+  if (internal_) {
+    return internal_->get();
+  } else {
+    // AppCheck initialization can depend on the FIRApp associated with an App
+    // before internal_ has been created.
+    return GetPlatformAppByName(name_.c_str());
+  }
+}
 
 namespace internal {
 
@@ -304,6 +321,46 @@ void SetFirConfigurationLoggerLevel(FIRLoggerLevel level) {
     g_delayed_fir_configuration_logger_level_set = true;
   }
 }
-}  // namespace internal
 
+// Guards g_partial_apps.
+static Mutex* g_partial_apps_mutex = new Mutex();
+// Stores partially initialized apps, indexed by app name
+static std::map<std::string, App*>* g_partial_apps;
+
+App* FindPartialAppByName(const char* name) {
+  assert(name);
+  MutexLock lock(*g_partial_apps_mutex);
+  if (g_partial_apps) {
+    auto it = g_partial_apps->find(std::string(name));
+    if (it == g_partial_apps->end()) {
+      return nullptr;
+    }
+    return it->second;
+  }
+  return nullptr;
+}
+
+void AddPartialApp(App* app) {
+  MutexLock lock(*g_partial_apps_mutex);
+  if (!g_partial_apps) {
+    g_partial_apps = new std::map<std::string, App*>();
+  }
+  (*g_partial_apps)[std::string(app->name())] = app;
+}
+
+void RemovePartialApp(App* app) {
+  MutexLock lock(*g_partial_apps_mutex);
+  if (g_partial_apps) {
+    auto it = g_partial_apps->find(std::string(app->name()));
+    if (it != g_partial_apps->end()) {
+      g_partial_apps->erase(it);
+      if (g_partial_apps->empty()) {
+        delete g_partial_apps;
+        g_partial_apps = nullptr;
+      }
+    }
+  }
+}
+
+}  // namespace internal
 }  // namespace firebase
diff --git a/app_check/integration_test/src/integration_test.cc b/app_check/integration_test/src/integration_test.cc
@@ -334,6 +334,52 @@ TEST_F(FirebaseAppCheckTest, TestInitializeAndTerminate) {
   InitializeApp();
 }
 
+TEST_F(FirebaseAppCheckTest, TestGetTokenForcingRefresh) {
+  InitializeAppCheckWithDebug();
+  InitializeApp();
+  ::firebase::app_check::AppCheck* app_check =
+      ::firebase::app_check::AppCheck::GetInstance(app_);
+  ASSERT_NE(app_check, nullptr);
+  firebase::Future<::firebase::app_check::AppCheckToken> future =
+      app_check->GetAppCheckToken(true);
+  EXPECT_TRUE(WaitForCompletion(future, "GetToken #1"));
+  ::firebase::app_check::AppCheckToken token = *future.result();
+  EXPECT_NE(token.token, "");
+  EXPECT_NE(token.expire_time_millis, 0);
+
+  // 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);
+
+  // GetToken with force_refresh=true will return a new token.
+  firebase::Future<::firebase::app_check::AppCheckToken> future3 =
+      app_check->GetAppCheckToken(true);
+  EXPECT_TRUE(WaitForCompletion(future3, "GetToken #3"));
+  EXPECT_NE(future.result()->expire_time_millis,
+            future3.result()->expire_time_millis);
+}
+
+TEST_F(FirebaseAppCheckTest, TestGetTokenLastResult) {
+  InitializeAppCheckWithDebug();
+  InitializeApp();
+  ::firebase::app_check::AppCheck* app_check =
+      ::firebase::app_check::AppCheck::GetInstance(app_);
+  ASSERT_NE(app_check, nullptr);
+  firebase::Future<::firebase::app_check::AppCheckToken> future =
+      app_check->GetAppCheckToken(true);
+  EXPECT_TRUE(WaitForCompletion(future, "GetToken #1"));
+
+  firebase::Future<::firebase::app_check::AppCheckToken> future2 =
+      app_check->GetAppCheckTokenLastResult();
+  EXPECT_TRUE(WaitForCompletion(future2, "GetTokenLastResult"));
+  ::firebase::app_check::AppCheckToken token = *future2.result();
+  EXPECT_EQ(future.result()->expire_time_millis,
+            future2.result()->expire_time_millis);
+}
+
 TEST_F(FirebaseAppCheckTest, TestSignIn) {
   InitializeAppCheckWithDebug();
   InitializeApp();
diff --git a/app_check/src/ios/app_check_ios.h b/app_check/src/ios/app_check_ios.h
@@ -15,15 +15,25 @@
 #ifndef FIREBASE_APP_CHECK_SRC_IOS_APP_CHECK_IOS_H_
 #define FIREBASE_APP_CHECK_SRC_IOS_APP_CHECK_IOS_H_
 
+#include "app/memory/unique_ptr.h"
 #include "app/src/future_manager.h"
 #include "app/src/include/firebase/app.h"
 #include "app/src/include/firebase/future.h"
+#include "app/src/util_ios.h"
 #include "app_check/src/include/firebase/app_check.h"
 
+#ifdef __OBJC__
+#import "FIRAppCheck.h"
+#endif  // __OBJC__
+
 namespace firebase {
 namespace app_check {
 namespace internal {
 
+// This defines the class FIRAppCheckPointer, which is a C++-compatible
+// wrapper around the FIRAppCheck Obj-C class.
+OBJ_C_PTR_WRAPPER(FIRAppCheck);
+
 class AppCheckInternal {
  public:
   explicit AppCheckInternal(::firebase::App* app);
@@ -49,6 +59,12 @@ class AppCheckInternal {
   ReferenceCountedFutureImpl* future();
 
  private:
+#ifdef __OBJC__
+  FIRAppCheck* impl() const { return impl_->get(); }
+#endif  // __OBJC__
+
+  UniquePtr<FIRAppCheckPointer> impl_;
+
   ::firebase::App* app_;
 
   FutureManager future_manager_;
diff --git a/app_check/src/ios/app_check_ios.mm b/app_check/src/ios/app_check_ios.mm
@@ -14,19 +14,90 @@
 
 #include "app_check/src/ios/app_check_ios.h"
 
+#import "FIRApp.h"
+#import "FIRAppCheckProvider.h"
+#import "FIRAppCheckProviderFactory.h"
 #import "FIRAppCheckToken.h"
 
+#include "app/src/app_common.h"
+#include "app/src/app_ios.h"
+#include "app/src/util_ios.h"
 #include "app_check/src/common/common.h"
+#include "app_check/src/ios/util_ios.h"
 #include "firebase/app_check.h"
 
+// Defines an iOS AppCheckProvider that wraps a given C++ Provider.
+@interface CppAppCheckProvider : NSObject <FIRAppCheckProvider>
+
+@property(nonatomic, nullable) firebase::app_check::AppCheckProvider* cppProvider;
+
+- (id)initWithProvider:(firebase::app_check::AppCheckProvider* _Nonnull)provider;
+
+@end
+
+@implementation CppAppCheckProvider
+
+- (id)initWithProvider:(firebase::app_check::AppCheckProvider* _Nonnull)provider {
+  self = [super init];
+  if (self) {
+    self.cppProvider = provider;
+  }
+  return self;
+}
+
+- (void)getTokenWithCompletion:(nonnull void (^)(FIRAppCheckToken* _Nullable,
+                                                 NSError* _Nullable))handler {
+  auto token_callback{[handler](firebase::app_check::AppCheckToken token, int error_code,
+                                const std::string& error_message) {
+    NSError* ios_error = firebase::app_check::internal::AppCheckErrorToNSError(
+        static_cast<firebase::app_check::AppCheckError>(error_code), error_message);
+    FIRAppCheckToken* ios_token =
+        firebase::app_check::internal::AppCheckTokenToFIRAppCheckToken(token);
+    handler(ios_token, ios_error);
+  }};
+  _cppProvider->GetToken(token_callback);
+}
+
+@end
+
+// Defines an iOS AppCheckProviderFactory that wraps a given C++ Factory.
+@interface CppAppCheckProviderFactory : NSObject <FIRAppCheckProviderFactory>
+
+@property(nonatomic, nullable) firebase::app_check::AppCheckProviderFactory* cppProviderFactory;
+
+- (id)initWithProviderFactory:(firebase::app_check::AppCheckProviderFactory* _Nonnull)factory;
+
+@end
+
+@implementation CppAppCheckProviderFactory
+
+- (id)initWithProviderFactory:(firebase::app_check::AppCheckProviderFactory* _Nonnull)factory {
+  self = [super init];
+  if (self) {
+    self.cppProviderFactory = factory;
+  }
+  return self;
+}
+
+- (nullable id<FIRAppCheckProvider>)createProviderWithApp:(FIRApp*)app {
+  std::string app_name = firebase::util::NSStringToString(app.name);
+  firebase::App* cpp_app = firebase::app_common::FindAppByName(app_name.c_str());
+  if (cpp_app == nullptr) {
+    cpp_app = firebase::internal::FindPartialAppByName(app_name.c_str());
+  }
+  firebase::app_check::AppCheckProvider* cppProvider = _cppProviderFactory->CreateProvider(cpp_app);
+  return [[CppAppCheckProvider alloc] initWithProvider:cppProvider];
+}
+
+@end
+
 namespace firebase {
 namespace app_check {
 namespace internal {
 
-static AppCheckProviderFactory* g_provider_factory = nullptr;
-
 AppCheckInternal::AppCheckInternal(App* app) : app_(app) {
   future_manager().AllocFutureApi(this, kAppCheckFnCount);
+  impl_ = MakeUnique<FIRAppCheckPointer>([FIRAppCheck appCheck]);
 }
 
 AppCheckInternal::~AppCheckInternal() {
@@ -41,15 +112,43 @@
 }
 
 void AppCheckInternal::SetAppCheckProviderFactory(AppCheckProviderFactory* factory) {
-  g_provider_factory = factory;
+  CppAppCheckProviderFactory* ios_factory =
+      [[CppAppCheckProviderFactory alloc] initWithProviderFactory:factory];
+  [FIRAppCheck setAppCheckProviderFactory:ios_factory];
 }
 
-void AppCheckInternal::SetTokenAutoRefreshEnabled(bool is_token_auto_refresh_enabled) {}
+void AppCheckInternal::SetTokenAutoRefreshEnabled(bool is_token_auto_refresh_enabled) {
+  impl().isTokenAutoRefreshEnabled = is_token_auto_refresh_enabled;
+}
 
 Future<AppCheckToken> AppCheckInternal::GetAppCheckToken(bool force_refresh) {
-  auto handle = future()->SafeAlloc<AppCheckToken>(kAppCheckFnGetAppCheckToken);
-  AppCheckToken token;
-  future()->CompleteWithResult(handle, 0, token);
+  SafeFutureHandle<AppCheckToken> handle =
+      future()->SafeAlloc<AppCheckToken>(kAppCheckFnGetAppCheckToken);
+
+  // __block allows handle to be referenced inside the objective C completion.
+  __block SafeFutureHandle<AppCheckToken>* handle_in_block = &handle;
+  [impl()
+      tokenForcingRefresh:force_refresh
+               completion:^(FIRAppCheckToken* _Nullable token, NSError* _Nullable error) {
+                 AppCheckToken cpp_token = AppCheckTokenFromFIRAppCheckToken(token);
+                 if (error != nil) {
+                   NSLog(@"Unable to retrieve App Check token: %@", error);
+                   int error_code = firebase::app_check::internal::AppCheckErrorFromNSError(error);
+                   std::string error_message = util::NSStringToString(error.localizedDescription);
+
+                   future()->CompleteWithResult(*handle_in_block, error_code, error_message.c_str(),
+                                                cpp_token);
+                   return;
+                 }
+                 if (token == nil) {
+                   NSLog(@"App Check token is nil.");
+                   future()->CompleteWithResult(*handle_in_block, kAppCheckErrorUnknown,
+                                                "AppCheck GetToken returned an empty token.",
+                                                cpp_token);
+                   return;
+                 }
+                 future()->CompleteWithResult(*handle_in_block, kAppCheckErrorNone, cpp_token);
+               }];
   return MakeFuture(future(), handle);
 }
 
diff --git a/app_check/src/ios/util_ios.h b/app_check/src/ios/util_ios.h
@@ -17,17 +17,24 @@
 #ifndef FIREBASE_APP_CHECK_SRC_IOS_UTIL_IOS_H_
 #define FIREBASE_APP_CHECK_SRC_IOS_UTIL_IOS_H_
 
+#include <string>
+
 #import "FIRAppCheckToken.h"
 #include "firebase/app_check.h"
 
 namespace firebase {
 namespace app_check {
 namespace internal {
 
-AppCheckError AppCheckErrorFromNSError(NSError *_Nullable error);
+AppCheckError AppCheckErrorFromNSError(NSError* _Nullable error);
+
+NSError* AppCheckErrorToNSError(AppCheckError cpp_error,
+                                const std::string& error_message);
 
 AppCheckToken AppCheckTokenFromFIRAppCheckToken(
-    FIRAppCheckToken *_Nullable token);
+    FIRAppCheckToken* _Nullable token);
+
+FIRAppCheckToken* AppCheckTokenToFIRAppCheckToken(AppCheckToken cpp_token);
 
 }  // namespace internal
 }  // namespace app_check
diff --git a/app_check/src/ios/util_ios.mm b/app_check/src/ios/util_ios.mm
