add framework file

frameworks/FirebaseInstanceID.framework/Headers/FIRInstanceID.h

+#import <Foundation/Foundation.h>
+
+/**
+ *  @memberof FIRInstanceID
+ *
+ *  The scope to be used when fetching/deleting a token for Firebase Messaging.
+ */
+FOUNDATION_EXPORT NSString * __nonnull const kFIRInstanceIDScopeFirebaseMessaging;
+
+/**
+ *  Called when the system determines that tokens need to be refreshed.
+ *  This method is also called if Instance ID has been reset in which
+ *  case, tokens and FCM topic subscriptions also need to be refreshed.
+ *
+ *  Instance ID service will throttle the refresh event across all devices
+ *  to control the rate of token updates on application servers.
+ */
+FOUNDATION_EXPORT NSString * __nonnull const kFIRInstanceIDTokenRefreshNotification;
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the InstanceID token returns. If
+ *  the call fails we return the appropriate `error code` as described below.
+ *
+ *  @param token The valid token as returned by InstanceID backend.
+ *
+ *  @param error The error describing why generating a new token
+ *               failed. See the error codes below for a more detailed
+ *               description.
+ */
+typedef void(^FIRInstanceIDTokenHandler)( NSString * __nullable token, NSError * __nullable error);
+
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the InstanceID `deleteToken` returns. If
+ *  the call fails we return the appropriate `error code` as described below
+ *
+ *  @param error The error describing why deleting the token failed.
+ *               See the error codes below for a more detailed description.
+ */
+typedef void(^FIRInstanceIDDeleteTokenHandler)(NSError * __nullable error);
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the app identity is created. If the
+ *  identity wasn't created for some reason we return the appropriate error code.
+ *
+ *  @param identity A valid identity for the app instance, nil if there was an error
+ *                  while creating an identity.
+ *  @param error    The error if fetching the identity fails else nil.
+ */
+typedef void(^FIRInstanceIDHandler)(NSString * __nullable identity, NSError * __nullable error);
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the app identity and all the tokens associated
+ *  with it are deleted. Returns a valid error object in case of failure else nil.
+ *
+ *  @param error The error if deleting the identity and all the tokens associated with
+ *               it fails else nil.
+ */
+typedef void(^FIRInstanceIDDeleteHandler)(NSError * __nullable error);
+
+/**
+ * @enum FIRInstanceIDError
+ */
+typedef NS_ENUM(NSUInteger, FIRInstanceIDError) {
+  // Http related errors.
+
+  /// Unknown error.
+  FIRInstanceIDErrorUnknown = 0,
+
+  /// Auth Error -- GCM couldn't validate request from this client.
+  FIRInstanceIDErrorAuthentication = 1,
+
+  /// NoAccess -- InstanceID service cannot be accessed.
+  FIRInstanceIDErrorNoAccess = 2,
+
+  /// Timeout -- Request to InstanceID backend timed out.
+  FIRInstanceIDErrorTimeout = 3,
+
+  /// Network -- No network available to reach the servers.
+  FIRInstanceIDErrorNetwork = 4,
+
+  /// OperationInProgress -- Another similar operation in progress,
+  /// bailing this one.
+  FIRInstanceIDErrorOperationInProgress = 5,
+
+  /// InvalidRequest -- Some parameters of the request were invalid.
+  FIRInstanceIDErrorInvalidRequest = 7,
+};
+
+/**
+ *  The APNS token type for the app. If the token type is set to `UNKNOWN`
+ *  InstanceID will implicitly try to figure out what the actual token type
+ *  is from the provisioning profile.
+ */
+typedef NS_ENUM(NSInteger, FIRInstanceIDAPNSTokenType) {
+  /// Unknown token type.
+  FIRInstanceIDAPNSTokenTypeUnknown,
+  /// Sandbox token type.
+  FIRInstanceIDAPNSTokenTypeSandbox,
+  /// Production token type.
+  FIRInstanceIDAPNSTokenTypeProd,
+};
+
+/**
+ *  Instance ID provides a unique identifier for each app instance and a mechanism
+ *  to authenticate and authorize actions (for example, sending a GCM message).
+ *
+ *  Instance ID is long lived but, may be reset if the device is not used for
+ *  a long time or the Instance ID service detects a problem.
+ *  If Instance ID is reset, the app will be notified with a `com.firebase.iid.token-refresh`
+ *  notification.
+ *
+ *  If the Instance ID has become invalid, the app can request a new one and
+ *  send it to the app server.
+ *  To prove ownership of Instance ID and to allow servers to access data or
+ *  services associated with the app, call
+ *  `[FIRInstanceID tokenWithAuthorizedEntity:scope:options:handler]`.
+ */
+@interface FIRInstanceID : NSObject
+
+/**
+ *  FIRInstanceID.
+ *
+ *  @return A shared instance of FIRInstanceID.
+ */
++ (nonnull instancetype)instanceID NS_SWIFT_NAME(instanceID());
+
+/**
+ *  Unavailable. Use +instanceID instead.
+ */
+- (nonnull instancetype)init __attribute__((unavailable("Use +instanceID instead.")));
+
+/**
+ *  Set APNS token for the application. This APNS token will be used to register
+ *  with Firebase Messaging using `token` or
+ *  `tokenWithAuthorizedEntity:scope:options:handler`. If the token type is set to
+ *  `FIRInstanceIDAPNSTokenTypeUnknown` InstanceID will read the provisioning profile
+ *  to find out the token type.
+ *
+ *  @param token The APNS token for the application.
+ *  @param type  The APNS token type for the above token.
+ */
+- (void)setAPNSToken:(nonnull NSData *)token
+                type:(FIRInstanceIDAPNSTokenType)type;
+
+#pragma mark - Tokens
+
+/**
+ *  Returns a Firebase Messaging scoped token for the firebase app.
+ *
+ *  @return Null Returns null if the device has not yet been registerd with
+ *          Firebase Message else returns a valid token.
+ */
+- (nullable NSString *)token;
+
+/**
+ *  Returns a token that authorizes an Entity (example: cloud service) to perform
+ *  an action on behalf of the application identified by Instance ID.
+ *
+ *  This is similar to an OAuth2 token except, it applies to the
+ *  application instance instead of a user.
+ *
+ *  This is an asynchronous call. If the token fetching fails for some reason
+ *  we invoke the completion callback with nil `token` and the appropriate
+ *  error.
+ *
+ *  Note, you can only have one `token` or `deleteToken` call for a given
+ *  authorizedEntity and scope at any point of time. Making another such call with the
+ *  same authorizedEntity and scope before the last one finishes will result in an
+ *  error with code `OperationInProgress`.
+ *
+ *  @see FIRInstanceID deleteTokenWithAuthorizedEntity:scope:handler:
+ *
+ *  @param authorizedEntity Entity authorized by the token.
+ *  @param scope            Action authorized for authorizedEntity.
+ *  @param options          The extra options to be sent with your token request. The
+ *                          value for the `apns_token` should be the NSData object
+ *                          passed to UIApplication's
+ *                          `didRegisterForRemoteNotificationsWithDeviceToken` method.
+ *                          All other keys and values in the options dict need to be
+ *                          instances of NSString or else they will be discarded. Bundle
+ *                          keys starting with 'GCM.' and 'GOOGLE.' are reserved.
+ *  @param handler          The callback handler which is invoked when the token is
+ *                          successfully fetched. In case of success a valid `token` and
+ *                          `nil` error are returned. In case of any error the `token`
+ *                          is nil and a valid `error` is returned. The valid error
+ *                          codes have been documented above.
+ */
+- (void)tokenWithAuthorizedEntity:(nonnull NSString *)authorizedEntity
+                            scope:(nonnull NSString *)scope
+                          options:(nullable NSDictionary *)options
+                          handler:(nonnull FIRInstanceIDTokenHandler)handler;
+
+/**
+ *  Revokes access to a scope (action) for an entity previously
+ *  authorized by `[FIRInstanceID tokenWithAuthorizedEntity:scope:options:handler]`.
+ *
+ *  This is an asynchronous call. Call this on the main thread since InstanceID lib
+ *  is not thread safe. In case token deletion fails for some reason we invoke the
+ *  `handler` callback passed in with the appropriate error code.
+ *
+ *  Note, you can only have one `token` or `deleteToken` call for a given
+ *  authorizedEntity and scope at a point of time. Making another such call with the
+ *  same authorizedEntity and scope before the last one finishes will result in an error
+ *  with code `OperationInProgress`.
+ *
+ *  @param authorizedEntity Entity that must no longer have access.
+ *  @param scope            Action that entity is no longer authorized to perform.
+ *  @param handler          The handler that is invoked once the unsubscribe call ends.
+ *                          In case of error an appropriate error object is returned
+ *                          else error is nil.
+ */
+- (void)deleteTokenWithAuthorizedEntity:(nonnull NSString *)authorizedEntity
+                                  scope:(nonnull NSString *)scope
+                                handler:(nonnull FIRInstanceIDDeleteTokenHandler)handler;
+
+#pragma mark - Identity
+
+/**
+ *  Asynchronously fetch a stable identifier that uniquely identifies the app
+ *  instance. If the identifier has been revoked or has expired, this method will
+ *  return a new identifier.
+ *
+ *
+ *  @param handler The handler to invoke once the identifier has been fetched.
+ *                 In case of error an appropriate error object is returned else
+ *                 a valid identifier is returned and a valid identifier for the
+ *                 application instance.
+ */
+- (void)getIDWithHandler:(nonnull FIRInstanceIDHandler)handler;
+
+/**
+ *  Resets Instance ID and revokes all tokens.
+ */
+- (void)deleteIDWithHandler:(nonnull FIRInstanceIDDeleteHandler)handler;
+
+@end

frameworks/FirebaseInstanceID.framework/Headers/FirebaseInstanceID.h

+#import "FIRInstanceID.h"

frameworks/FirebaseInstanceID.framework/Modules/module.modulemap

+framework module FirebaseInstanceID {
+
+  export *
+
+  umbrella header "FirebaseInstanceID.h"
+
+  header "FIRInstanceID.h"
+}

frameworks/FirebaseMessaging.framework/Headers/FIRMessaging.h

+#import <Foundation/Foundation.h>
+
+/**
+ *  The completion handler invoked once the data connection with FIRMessaging is
+ *  established.  The data connection is used to send a continous stream of
+ *  data and all the FIRMessaging data notifications arrive through this connection.
+ *  Once the connection is established we invoke the callback with `nil` error.
+ *  Correspondingly if we get an error while trying to establish a connection
+ *  we invoke the handler with an appropriate error object and do an
+ *  exponential backoff to try and connect again unless successful.
+ *
+ *  @param error The error object if any describing why the data connection
+ *               to FIRMessaging failed.
+ */
+typedef void(^FIRMessagingConnectCompletion)(NSError * __nullable error);
+
+/**
+ *  Notification sent when the upstream message has been delivered
+ *  successfully to the server. The notification object will be the messageID
+ *  of the successfully delivered message.
+ */
+FOUNDATION_EXPORT NSString * __nonnull const FIRMessagingSendSuccessNotification;
+
+/**
+ *  Notification sent when the upstream message was failed to be sent to the
+ *  server.  The notification object will be the messageID of the failed
+ *  message. The userInfo dictionary will contain the relevant error
+ *  information for the failure.
+ */
+FOUNDATION_EXPORT NSString * __nonnull const FIRMessagingSendErrorNotification;
+
+/**
+ *  Notification sent when the Firebase messaging server deletes pending
+ *  messages due to exceeded storage limits. This may occur, for example, when
+ *  the device cannot be reached for an extended period of time.
+ *
+ *  It is recommended to retrieve any missing messages directly from the
+ *  server.
+ */
+FOUNDATION_EXPORT NSString * __nonnull const FIRMessagingMessagesDeletedNotification;
+
+/**
+ *  @enum FIRMessagingError
+ */
+typedef NS_ENUM(NSUInteger, FIRMessagingError) {
+  // Unknown error.
+  FIRMessagingErrorUnknown = 0,
+
+  // Auth Error -- FIRMessaging couldn't validate request from this client.
+  FIRMessagingErrorAuthentication = 1,
+
+  // NoAccess -- InstanceID service cannot be accessed.
+  FIRMessagingErrorNoAccess = 2,
+
+  // Timeout -- Request to InstanceID backend timed out.
+  FIRMessagingErrorTimeout = 3,
+
+  // Network -- No network available to reach the servers.
+  FIRMessagingErrorNetwork = 4,
+
+  // OperationInProgress -- Another similar operation in progress,
+  // bailing this one.
+  FIRMessagingErrorOperationInProgress = 5,
+
+  // InvalidRequest -- Some parameters of the request were invalid.
+  FIRMessagingErrorInvalidRequest = 7,
+};
+
+/// Status for the downstream message received by the app.
+typedef NS_ENUM(NSInteger, FIRMessagingMessageStatus) {
+  FIRMessagingMessageStatusUnknown,
+  /// New downstream message received by the app.
+  FIRMessagingMessageStatusNew,
+};
+
+/// Information about a downstream message received by the app.
+@interface FIRMessagingMessageInfo : NSObject
+
+@property(nonatomic, readonly, assign) FIRMessagingMessageStatus status;
+
+@end
+
+/**
+ *  Firebase Messaging enables apps to communicate with their app servers
+ *  using simple messages.
+ *
+ *  To send or receive messages, the app must get a
+ *  registration token from GGLInstanceID, which authorizes an
+ *  app server to send messages to an app instance. Pass your sender ID and
+ *  `kGGLInstanceIDScopeFIRMessaging` as parameters to the method.
+ *
+ *  A sender ID is a project number created when you configure your API project.
+ *  It is labeled "Project Number" in the Google Developers Console.
+ *
+ *  In order to receive FIRMessaging messages, declare application:didReceiveRemoteNotification:
+ *
+ *  Client apps can send upstream messages back to the app server using the XMPP-based
+ *  <a href="http://developers.google.com/cloud-messaging/ccs.html">Cloud Connection Server</a>,
+ *
+ */
+@interface FIRMessaging : NSObject
+
+/**
+ *  FIRMessaging
+ *
+ *  @return An instance of FIRMessaging.
+ */
++ (nonnull instancetype)messaging NS_SWIFT_NAME(messaging());
+
+/**
+ *  Unavailable. Use +messaging instead.
+ */
+- (nonnull instancetype)init __attribute__((unavailable("Use +messaging instead.")));
+
+#pragma mark - Connect
+
+/**
+ *  Create a FIRMessaging data connection which will be used to send the data notifications
+ *  send by your server. It will also be used to send ACKS and other messages based
+ *  on the FIRMessaging ACKS and other messages based  on the FIRMessaging protocol.
+ *
+ *  Use the `disconnect` method to disconnect the connection.
+ *
+ *  @see FIRMessagingService disconnect
+ *
+ *  @param handler  The handler to be invoked once the connection is established.
+ *                  If the connection fails we invoke the handler with an
+ *                  appropriate error code letting you know why it failed. At
+ *                  the same time, FIRMessaging performs exponential backoff to retry
+ *                  establishing a connection and invoke the handler when successful.
+ */
+- (void)connectWithCompletion:(nonnull FIRMessagingConnectCompletion)handler;
+
+/**
+ *  Disconnect the current FIRMessaging data connection. This stops any attempts to
+ *  connect to FIRMessaging. Calling this on an already disconnected client is a no-op.
+ *
+ *  Call this before `teardown` when your app is going to the background.
+ *  Since the FIRMessaging connection won't be allowed to live when in background it is
+ *  prudent to close the connection.
+ */
+- (void)disconnect;
+
+#pragma mark - Topics
+
+/**
+ *  Asynchronously subscribes to a topic.
+ *
+ *  @param topic The name of the topic, for example @"sports".
+ */
+- (void)subscribeToTopic:(nonnull NSString *)topic;
+
+/**
+ *  Asynchronously unsubscribe to a topic.
+ *
+ *  @param topic The name of the topic, for example @"sports".
+ */
+- (void)unsubscribeFromTopic:(nonnull NSString *)topic;
+
+#pragma mark - Upstream
+
+/**
+ *  Sends an upstream ("device to cloud") message.
+ *
+ *  The message will be queued if we don't have an active connection.
+ *  You can only use the upstream feature if your GCM implementation
+ *  uses the XMPP-based Cloud Connection Server.
+ *
+ *  @param message      Key/Value pairs to be sent. Values must be String, any
+ *                      other type will be ignored.
+ *  @param to           A string identifying the receiver of the message. For GCM
+ *                      project IDs the value is `SENDER_ID@gcm.googleapis.com`.
+ *  @param messageID    The ID of the message. This is generated by the application. It
+ *                      must be unique for each message generated by this application.
+ *                      It allows error callbacks and debugging, to uniquely identify
+ *                      each message.
+ *  @param ttl          The time to live for the message. In case we aren't able to
+ *                      send the message before the TTL expires we will send you a
+ *                      callback. If 0, we'll attempt to send immediately and return
+ *                      an error if we're not connected.  Otherwise, the message will
+ *                      be queued.  As for server-side messages, we don't return an error
+ *                      if the message has been dropped because of TTL; this can happen
+ *                      on the server side, and it would require extra communication.
+ */
+- (void)sendMessage:(nonnull NSDictionary *)message
+                 to:(nonnull NSString *)receiver
+      withMessageID:(nonnull NSString *)messageID
+         timeToLive:(int64_t)ttl;
+
+#pragma mark - Analytics
+
+/**
+ *  Call this when the app received a downstream message. Used to track message
+ *  delivery and analytics for messages. You don't need to call this if you
+ *  don't set the `FIRMessagingAutoSetupEnabled` flag in your Info.plist. In the
+ *  latter case the library will call this implicitly to track relevant
+ *  messages.
+ *
+ *  @param message The downstream message received by the application.
+ *
+ *  @return Information about the downstream message.
+ */
+- (nonnull FIRMessagingMessageInfo *)appDidReceiveMessage:(nonnull NSDictionary *)message;
+
+@end

frameworks/FirebaseMessaging.framework/Headers/FirebaseMessaging.h

+#import "FIRMessaging.h"

frameworks/FirebaseMessaging.framework/Modules/module.modulemap

+framework module FirebaseMessaging {
+
+  export *
+
+  umbrella header "FirebaseMessaging.h"
+
+  header "FIRMessaging.h"
+
+  link framework "AddressBook"
+  link framework "SystemConfiguration"
+
+  link "sqlite3"
+}