Push Notifications

Firebase configuration

info

See Firebase Documentation

In order to enable MeetingDoctors Chat notifications, there are two posibilities:

1. If you have your own Firebase app declared, you must provide us Sender ID and Server Key from your Firebase workspace.
2. If you don't have a Firebase and don't want to create it, we can provide one. For Android we need your App Package, and for iOS we need .p8 Certificate file, Team ID, and the certificate key. Once Firebase app are created, we'll provide you google-services.json and GoogleService-info.plist files to add to your apps.

Push notifications

MeetingDoctors framework uses push notifications to communicate users' pending messages, these notifications are served by Firebase SDK.

As soon as the on-screen chat presentation starts, if permissions to send notifications have not yet been needed by the host application, the system security dialog is displayed. When the user grants the necessary permissions to send push notifications, it is mandatory to intervene system remote notification calls to notify MeetingDoctors with the new device token. To do so, we require to implement the following methods in your AppDelegate:

caution

The method must be invoked after call MeetingDoctors.authenticate() method

extension ApplicationDelegate: MessagingDelegate {
    // Refresh_token
    public func messaging(_: Messaging, didReceiveRegistrationToken fcmToken: String) {
        print("[ApplicationDelegate] Firebase registration token: \(fcmToken)")
        // Note: This callback is fired at each app startup and whenever a new token is generated.
        MeetingDoctors.registerFirebaseForNotifications(token: fcmToken) { result in
            switch result {
            case .success:
                print("[ApplicationDelegate] Token registered correctly")
            case let .failure(error):
                print("[ApplicationDelegate] Error registering token: \(error)")
            }
        }
    }
}

Now, the app can receive chat notifications. After that you must pass notifications to library methods to process the Push Notification info:

func userNotificationCenter(_ userNotificationCenter: UNUserNotificationCenter,
                                       willPresent notification: UNNotification,
                                       withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        MeetingDoctors.userNotificationCenter(userNotificationCenter, willPresent: notification) { result in
            NSLog("[MeetingDoctorsApplicationPlugin] Case 2")
            switch result {
            case let .success(value):
                completionHandler(value)
            case .failure:
                completionHandler([.alert, .badge, .sound])
            }
        }
    }

func userNotificationCenter(_ userNotificationCenter: UNUserNotificationCenter,
                                       didReceive response: UNNotificationResponse,
                                       withCompletionHandler completionHandler: @escaping () -> Void) {
        MeetingDoctors.userNotificationCenter(userNotificationCenter, didReceive: response) { result in
            NSLog("[MeetingDoctorsApplicationPlugin] Case 3")
            switch result {
            case .success:
                completionHandler()
            case let .failure(error):
                if let launchScreen: LaunchScreenViewController = UIApplication.shared.keyWindow?.rootViewController as? LaunchScreenViewController {
                        let deeplink = MeetingDoctorsDeeplinkOption.from(userInfo: response.notification.request.content.userInfo)
                        _ = launchScreen.deeplink(deeplink, animated: false)
                        completionHandler()
                    } else {
                        completionHandler()
                    }
            }
        }
    }

If you have Firebase notifications by certificates instead Key Authorization (.p8), you must add the next piece of code:

func application(_ application: UIApplication, 
    didReceiveRemoteNotification userInfo: [AnyHashable : Any], 
    fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        MeetingDoctors.didReceiveRemoteNotification(application, with: userInfo) { result in
            switch result {
            case let .success(value):
                completionHandler(value)
            case let .failure(error):
                completionHandler(.failed)
            }
        }
}

caution

• It is necessary that the host application has the necessary permissions and entitlements to receive push notifications.

• It is essential to provide an Authorization key to the administrator of your MeetingDoctors account so that notifications are received correctly.

• It is highly recommended to implement background fetch result and modify your app capabilities to include 'fetch' and 'remote-notification' entitlements.

<key>UIBackgroundModes</key>
<array>
    <string>fetch</string>
    <string>remote-notification</string>
</array>

Get Pending Messages Count

Once the authentication process is over, we can then request the pending messages to be read by the user using the following method:

func unreadMessageCount(with filter: MeetingDoctorsFilterType, completion: @escaping (Swift.Result<Int, Error>) -> Void) {

So, once we get the result, we can update application badge icon:

let filter = MeetingDoctorsFilter.default // returns unread messages from all categories
MeetingDoctors.unreadMessageCount(with: filter) { result in
    switch result {
    case let .success(value):
        // Handle success
    case let .failure(error):
        // Handle error
    }
}