Add FIRAppCheckTokenProtocol for use in FIRAppCheckProtocol (#13035)

Author: andrewheard

FirebaseAppCheck.podspec

@@ -45,7 +45,7 @@ Pod::Spec.new do |s|
   s.tvos.weak_framework = 'DeviceCheck'
 
   s.dependency 'AppCheckCore', '~> 10.19'
-  s.dependency 'FirebaseAppCheckInterop', '~> 10.17'
+  s.dependency 'FirebaseAppCheckInterop', '~> 10.28'
   s.dependency 'FirebaseCore', '~> 10.18'
   s.dependency 'PromisesObjC', '~> 2.1'
   s.dependency 'GoogleUtilities/Environment', '~> 7.13'

FirebaseAppCheck/Interop/Public/FirebaseAppCheckInterop/FIRAppCheckInterop.h

@@ -23,7 +23,7 @@ NS_ASSUME_NONNULL_BEGIN
 NS_SWIFT_NAME(AppCheckTokenHandlerInterop)
 typedef void (^FIRAppCheckTokenHandlerInterop)(id<FIRAppCheckTokenResultInterop> tokenResult);
 
-NS_SWIFT_NAME(AppCheckInterop) @protocol FIRAppCheckInterop
+NS_SWIFT_NAME(AppCheckInterop) @protocol FIRAppCheckInterop<NSObject>
 
 /// Retrieve a cached or generate a new FAA Token. If forcingRefresh == YES always generates a new
 /// token and updates the cache.

FirebaseAppCheck/Interop/Public/FirebaseAppCheckInterop/FIRAppCheckProtocol.h

@@ -16,7 +16,7 @@
 
 #import <Foundation/Foundation.h>
 
-@class FIRAppCheckToken;
+@protocol FIRAppCheckTokenProtocol;
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -38,8 +38,8 @@ NS_SWIFT_NAME(AppCheckProtocol)
 /// @param handler The completion handler. Includes the app check token if the request succeeds,
 /// or an error if the request fails.
 - (void)tokenForcingRefresh:(BOOL)forcingRefresh
-                 completion:
-                     (void (^)(FIRAppCheckToken *_Nullable token, NSError *_Nullable error))handler
+                 completion:(void (^)(id<FIRAppCheckTokenProtocol> _Nullable token,
+                                      NSError *_Nullable error))handler
     NS_SWIFT_NAME(token(forcingRefresh:completion:));
 
 /// Requests a limited-use Firebase App Check token. This method should be used only if you need to
@@ -50,7 +50,7 @@ NS_SWIFT_NAME(AppCheckProtocol)
 /// Protection](https://firebase.google.com/docs/app-check/custom-resource-backend#replay-protection).
 /// This method does not affect the token generation behavior of the
 /// ``tokenForcingRefresh()`` method.
-- (void)limitedUseTokenWithCompletion:(void (^)(FIRAppCheckToken *_Nullable token,
+- (void)limitedUseTokenWithCompletion:(void (^)(id<FIRAppCheckTokenProtocol> _Nullable token,
                                                 NSError *_Nullable error))handler;
 
 @end

FirebaseAppCheck/Interop/Public/FirebaseAppCheckInterop/FIRAppCheckTokenProtocol.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+NS_ASSUME_NONNULL_BEGIN
+
+NS_SWIFT_NAME(AppCheckTokenProtocol)
+@protocol FIRAppCheckTokenProtocol <NSObject>
+
+/// A Firebase App Check token.
+@property(nonatomic, readonly) NSString *token;
+
+/// The App Check token's expiration date in the device's local time.
+@property(nonatomic, readonly) NSDate *expirationDate;
+
+@end
+NS_ASSUME_NONNULL_END

FirebaseAppCheck/Interop/Public/FirebaseAppCheckInterop/FirebaseAppCheckInterop.h

@@ -16,4 +16,5 @@
 
 #import "FIRAppCheckInterop.h"
 #import "FIRAppCheckProtocol.h"
+#import "FIRAppCheckTokenProtocol.h"
 #import "FIRAppCheckTokenResultInterop.h"

FirebaseAppCheck/Sources/Public/FirebaseAppCheck/FIRAppCheck.h

@@ -74,6 +74,36 @@ NS_SWIFT_NAME(AppCheck)
 /// set explicitly, the value will be persisted and used as a default value on next app launches.
 @property(nonatomic, assign) BOOL isTokenAutoRefreshEnabled;
 
+/// Requests Firebase app check token. This method should *only* be used if you need to authorize
+/// requests to a non-Firebase backend. Requests to Firebase backend are authorized automatically if
+/// configured.
+///
+/// If your non-Firebase backend exposes sensitive or expensive endpoints that have low traffic
+/// volume, consider protecting it with [Replay
+/// Protection](https://firebase.google.com/docs/app-check/custom-resource-backend#replay-protection).
+/// In this case, use the ``limitedUseToken(completion:)`` instead to obtain a limited-use token.
+/// @param forcingRefresh If `YES`,  a new Firebase app check token is requested and the token
+/// cache is ignored. If `NO`, the cached token is used if it exists and has not expired yet. In
+/// most cases, `NO` should be used. `YES` should only be used if the server explicitly returns an
+/// error, indicating a revoked token.
+/// @param handler The completion handler. Includes the app check token if the request succeeds,
+/// or an error if the request fails.
+- (void)tokenForcingRefresh:(BOOL)forcingRefresh
+                 completion:
+                     (void (^)(FIRAppCheckToken *_Nullable token, NSError *_Nullable error))handler
+    NS_SWIFT_NAME(token(forcingRefresh:completion:));
+
+/// Requests a limited-use Firebase App Check token. This method should be used only if you need to
+/// authorize requests to a non-Firebase backend.
+///
+/// Returns limited-use tokens that are intended for use with your non-Firebase backend endpoints
+/// that are protected with [Replay
+/// Protection](https://firebase.google.com/docs/app-check/custom-resource-backend#replay-protection).
+/// This method does not affect the token generation behavior of the
+/// ``tokenForcingRefresh()`` method.
+- (void)limitedUseTokenWithCompletion:(void (^)(FIRAppCheckToken *_Nullable token,
+                                                NSError *_Nullable error))handler;
+
 @end
 
 NS_ASSUME_NONNULL_END

FirebaseAppCheck/Sources/Public/FirebaseAppCheck/FIRAppCheckToken.h

@@ -16,11 +16,13 @@
 
 #import <Foundation/Foundation.h>
 
+#import <FirebaseAppCheckInterop/FirebaseAppCheckInterop.h>
+
 NS_ASSUME_NONNULL_BEGIN
 
 /// An object representing a Firebase App Check token.
 NS_SWIFT_NAME(AppCheckToken)
-@interface FIRAppCheckToken : NSObject
+@interface FIRAppCheckToken : NSObject <FIRAppCheckTokenProtocol>
 
 /// A Firebase App Check token.
 @property(nonatomic, readonly) NSString *token;

FirebaseAppCheck/Tests/Interop/ObjC/FIRAppCheckInteropAPITests.m

@@ -0,0 +1,53 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#import <Foundation/Foundation.h>
+
+#import <FirebaseAppCheckInterop/FirebaseAppCheckInterop.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FIRAppCheckInteropAPITests : NSObject
+@end
+
+@implementation FIRAppCheckInteropAPITests
+
+- (void)usage {
+  id<FIRAppCheckInterop> appCheckInterop;
+
+  [appCheckInterop getTokenForcingRefresh:NO
+                               completion:^(id<FIRAppCheckTokenResultInterop> tokenResult) {
+                                 NSString *__unused token = tokenResult.token;
+                                 NSError *__unused _Nullable error = tokenResult.error;
+                               }];
+
+  NSString *__unused tokenDidChangeNotificationName =
+      [appCheckInterop tokenDidChangeNotificationName];
+
+  NSString *__unused notificationTokenKey = [appCheckInterop notificationTokenKey];
+
+  NSString *__unused notificationAppNameKey = [appCheckInterop notificationAppNameKey];
+
+  if ([appCheckInterop respondsToSelector:@selector(getLimitedUseTokenWithCompletion:)]) {
+    [appCheckInterop
+        getLimitedUseTokenWithCompletion:^(id<FIRAppCheckTokenResultInterop> tokenResult) {
+          NSString *__unused token = tokenResult.token;
+          NSError *__unused _Nullable error = tokenResult.error;
+        }];
+  }
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

FirebaseAppCheck/Tests/Interop/ObjC/FIRAppCheckProtocolAPITests.m

@@ -0,0 +1,51 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#import <Foundation/Foundation.h>
+
+#import <FirebaseAppCheckInterop/FirebaseAppCheckInterop.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FIRAppCheckProtocolAPITests : NSObject
+@end
+
+@implementation FIRAppCheckProtocolAPITests
+
+- (void)usage {
+  id<FIRAppCheckProtocol> appCheck;
+
+  [appCheck tokenForcingRefresh:NO
+                     completion:^(id<FIRAppCheckTokenProtocol> _Nullable token,
+                                  NSError *_Nullable error) {
+                       if (token) {
+                         NSString *__unused tokenValue = token.token;
+                         NSDate *__unused expirationDate = token.expirationDate;
+                       }
+                     }];
+
+  if ([appCheck respondsToSelector:@selector(limitedUseTokenWithCompletion:)]) {
+    [appCheck limitedUseTokenWithCompletion:^(id<FIRAppCheckTokenProtocol> _Nullable token,
+                                              NSError *_Nullable error) {
+      if (token) {
+        NSString *__unused tokenValue = token.token;
+        NSDate *__unused expirationDate = token.expirationDate;
+      }
+    }];
+  }
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

FirebaseAppCheck/Tests/Interop/Swift/AppCheckInteropAPITests.swift

@@ -0,0 +1,64 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// MARK: This file is used to evaluate the AppCheckInterop API in Swift.
+
+import Foundation
+
+// MARK: Do not import `FirebaseAppCheck`, this file is for `FirebaseAppCheckInterop` only.
+
+import FirebaseAppCheckInterop
+
+final class AppCheckInteropAPITests {
+  let appCheckInterop: AppCheckInterop! = nil
+
+  func usage() {
+    let _: Void = appCheckInterop.getToken(forcingRefresh: false) { result in
+      let _: FIRAppCheckTokenResultInterop = result
+      let _: String = result.token
+      if let error = result.error {
+        let _: String = error.localizedDescription
+      }
+    }
+
+    let _: String = appCheckInterop.tokenDidChangeNotificationName()
+
+    let _: String = appCheckInterop.notificationTokenKey()
+
+    let _: String = appCheckInterop.notificationAppNameKey()
+
+    guard let getLimitedUseToken: (@escaping AppCheckTokenHandlerInterop) -> Void =
+      appCheckInterop.getLimitedUseToken else { return }
+    let _: Void = getLimitedUseToken { result in
+      let _: FIRAppCheckTokenResultInterop = result
+      let _: String = result.token
+      if let error = result.error {
+        let _: String = error.localizedDescription
+      }
+    }
+  }
+
+  @available(iOS 13, macOS 10.15, macCatalyst 13, tvOS 13, *)
+  func usage_async() async {
+    let result: FIRAppCheckTokenResultInterop =
+      await appCheckInterop.getToken(forcingRefresh: false)
+    let _: String = result.token
+    if let error = result.error {
+      let _: String = error.localizedDescription
+    }
+
+    // The following fails to compile with "Command SwiftCompile failed with a nonzero exit code".
+    // let _ = await appCheckInterop.getLimitedUseToken?()
+  }
+}