vibes-react-native 1.1.5 → 1.1.6

package/android/src/main/java/com/vibes/push/rn/plugin/notifications/VibesPushReceiver.java

@@ -0,0 +1,62 @@
+package com.vibes.push.rn.plugin.notifications;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.ReactContext;
+import com.vibes.push.rn.plugin.VibesModule;
+import com.vibes.push.rn.plugin.PushEvtEmitter;
+import com.vibes.vibes.PushPayloadParser;
+import com.vibes.vibes.Vibes;
+import com.vibes.vibes.VibesReceiver;
+
+import static com.vibes.push.rn.plugin.VibesModule.TAG;
+
+public class VibesPushReceiver extends VibesReceiver {
+
+  @Override
+  protected void onPushOpened(Context context, PushPayloadParser pushModel) {
+    super.onPushOpened(context, pushModel);
+    Log.d(TAG, "Push message tapped. Emitting event");
+    emitPayload(context, pushModel);
+  }
+
+  public static void emitPayload(Context context, PushPayloadParser pushModel) {
+    // We need to run this on the main thread, as the React code assumes that is
+    // true.
+    // Namely, DevServerHelper constructs a Handler() without a Looper, which
+    // triggers:
+    // "Can't create handler inside thread that has not called Looper.prepare()"
+    Handler handler = new Handler(Looper.getMainLooper());
+    handler.post(new Runnable() {
+      public void run() {
+        // Construct and load our normal React JS code bundle
+        final ReactInstanceManager mReactInstanceManager = ((ReactApplication) context.getApplicationContext())
+            .getReactNativeHost().getReactInstanceManager();
+        ReactContext context = mReactInstanceManager.getCurrentReactContext();
+        // If it's constructed, send a notification
+        if (context != null) {
+          PushEvtEmitter pushEmitter = new PushEvtEmitter(context);
+          pushEmitter.notifyPushOpened(pushModel);
+        } else {
+          // Otherwise wait for construction, then send the notification
+          mReactInstanceManager.addReactInstanceEventListener(new ReactInstanceManager.ReactInstanceEventListener() {
+            public void onReactContextInitialized(ReactContext context) {
+              PushEvtEmitter pushEmitter = new PushEvtEmitter(context);
+              pushEmitter.notifyPushOpened(pushModel);
+              mReactInstanceManager.removeReactInstanceEventListener(this);
+            }
+          });
+          if (!mReactInstanceManager.hasStartedCreatingInitialContext()) {
+            // Construct it in the background
+            mReactInstanceManager.createReactContextInBackground();
+          }
+        }
+      }
+    });
+  }
+}

package/ios/Configuration.swift

@@ -0,0 +1,68 @@
+//
+//  Configuration.swift
+//  Vibes
+//
+//  Created by DHwty on 22/04/2022.
+//  Copyright © 2022 Facebook. All rights reserved.
+//
+
+import Foundation
+
+/// Keys found in <Configuration>.plist file i.e in UAT.plist and Production.plist
+///
+/// - appBuildNumber: The app build number
+/// - appVersionNumber: The app version number
+/// - vibesAppURL: Vibes app url
+/// - vibesAppId: Vibes app id
+/// - vibesAppEnv: Vibes app env: UAT or PROD
+/// - logseneToken: Logsene token
+public enum ConfigKey {
+  case appBuildNumber
+  case appVersionNumber
+  case vibesApiURL
+  case vibesAppId
+  case vibesAppEnv
+  case logseneToken
+
+  /// Actual string vakue for this enum as used in plist file
+  ///
+  /// - Returns: The string value
+  func value() -> String {
+      switch self {
+        case .appBuildNumber:
+          return "CFBundleShortVersionString"
+        case .appVersionNumber:
+          return "CFBundleVersion"
+        case .vibesApiURL:
+          return "VibesApiURL"
+        case .vibesAppEnv:
+        return "VibesAppEnv"
+        case .vibesAppId:
+          return "VibesAppId"
+        case .logseneToken:
+          return "LogseneToken"
+      }
+  }
+}
+
+/// This struct will load the plist file for current build
+public struct Configuration {
+    
+  fileprivate static var infoDict: [String: Any]  {
+    get {
+      if let dict = Bundle.main.infoDictionary {
+        return dict
+      } else {
+        fatalError("Plist file not found")
+      }
+    }
+  }
+  
+  /// Get the config value of a certain config key from current configuration
+  ///
+  /// - Parameter key: The key to get value for
+  /// - Returns: The value or nil if not found
+  public static func configValue(_ key: ConfigKey) -> String? {
+    return infoDict[key.value()] as? String
+  }
+}

package/ios/Notifications.swift

@@ -0,0 +1,72 @@
+//
+//  Notifications.swift
+//  Vibes
+//
+//  Created by DHwty on 22/04/2022.
+//  Copyright © 2022 Facebook. All rights reserved.
+//
+
+import Foundation
+import UserNotifications
+
+@objc(Notifications)
+@available(iOS 10.0, *)
+class Notifications: NSObject {
+  let current = UNUserNotificationCenter.current()
+  
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  @objc(isPushEnabled:reject:)
+  func isPushEnabled(resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) -> Void{
+    current.getNotificationSettings { (settings) in
+        if settings.authorizationStatus == .notDetermined {
+          resolve("Notifications not determined")
+        } else if settings.authorizationStatus == .denied {
+          resolve("Notifications denied")
+        } else if settings.authorizationStatus == .authorized {
+          resolve(true)
+        }
+    }
+  }
+
+  @objc(getDeviceId:reject:)
+  func getDeviceId(resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) -> Void{
+    let deviceID = getDeviceId()
+    resolve(deviceID)
+  }
+  
+  private func getDeviceId (_ tries: Int = 0) -> String? {
+    if let deviceID = UserDefaults.standard.vibesDeviceId {
+      return deviceID
+    } else {
+      if tries == 5 {
+        print("Error: Unable to get a string after 25secs delay")
+        return nil
+      }
+      sleep(5)
+      return getDeviceId(tries + 1)
+    }
+  }
+
+  @objc(getEnvironment:reject:)
+  func getEnvironment(resolve: @escaping RCTPromiseResolveBlock,
+                      rejecter reject: @escaping RCTPromiseRejectBlock) -> Void{
+    let env = Configuration.configValue(.vibesAppEnv)
+    resolve(env)
+  }
+}
+
+// MARK: - UserDefaults helpers
+extension UserDefaults {
+  
+  /// The vibes device id, if stored in this UserDefaults, else nil
+  public var vibesDeviceId: String? {
+    return self.string(forKey: "vibesDeviceId")
+  }
+  
+}

package/ios/Vibes-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/Vibes.m

@@ -0,0 +1,56 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(Vibes, NSObject)
+
+RCT_EXTERN_METHOD(registerDevice: (RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(unregisterDevice: (RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(registerPush: (RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(unregisterPush: (RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(getVibesDeviceInfo: (RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(associatePerson: (NSString *) externalPersonId
+                                    resolver:(RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(updateDevice: (BOOL ) updateCredentials
+                                    lat:(nonnull NSNumber *)lat
+                                    lon:(nonnull NSNumber *)lon
+                                    resolver:(RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(getPerson: (RCTPromiseResolveBlock *)resolve
+                                    rejecter:(RCTPromiseRejectBlock *)reject)
+
+
+RCT_EXTERN_METHOD(fetchInboxMessages: (RCTPromiseResolveBlock *)resolve
+                                        rejecter:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(fetchInboxMessage: (NSString *) messageUID
+                                    resolve:(RCTPromiseResolveBlock *)resolve
+                                    reject:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(markInboxMessageAsRead: (NSString *) messageUID
+                                    resolve:(RCTPromiseResolveBlock *)resolve
+                                    reject:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(expireInboxMessage: (NSString *) messageUID
+                                    resolve:(RCTPromiseResolveBlock *)resolve
+                                    reject:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(onInboxMessageOpen: (NSDictionary *) message
+                                    resolve:(RCTPromiseResolveBlock *)resolve
+                                    reject:(RCTPromiseRejectBlock *)reject)
+
+RCT_EXTERN_METHOD(onInboxMessagesFetched: (RCTPromiseResolveBlock *)resolve
+                                    reject:(RCTPromiseRejectBlock *)reject)
+@end
+

package/ios/Vibes.swift

@@ -0,0 +1,378 @@
+import Foundation
+import UserNotifications
+import VibesPush
+
+@objc(Vibes)
+class Vibes: NSObject, RCTBridgeModule, VibesPush.VibesAPIDelegate {
+    static func moduleName() -> String! {
+        return "Vibes"
+    }
+    
+    public typealias JSONDictionary = [String: Any]
+
+    let userDefaults = UserDefaults.standard
+
+    var vibes: VibesPush.Vibes
+    var registerDeviceResolver: RCTPromiseResolveBlock?
+    var registerDeviceRejecter: RCTPromiseRejectBlock?
+    var unregisterDeviceResolver: RCTPromiseResolveBlock?
+    var unregisterDeviceRejecter: RCTPromiseRejectBlock?
+
+    var registerPushResolver: RCTPromiseResolveBlock?
+    var registerPushRejecter: RCTPromiseRejectBlock?
+    var unregisterPushResolver: RCTPromiseResolveBlock?
+    var unregisterPushRejecter: RCTPromiseRejectBlock?
+    var associatePersonResolver: RCTPromiseResolveBlock?
+    var associatePersonRejecter: RCTPromiseRejectBlock?
+    var updateDeviceResolver: RCTPromiseResolveBlock?
+    var updateDeviceRejecter: RCTPromiseRejectBlock?
+
+    static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    override init() {
+        vibes = VibesClient.standard.vibes
+        super.init()
+
+        vibes.delegate = self
+        vibes.registerDevice()
+    }
+
+    // MARK: - Register device
+
+    @objc
+    /// Register Device
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejecter
+    func registerDevice(_ resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        registerDeviceResolver = resolve
+        registerDeviceRejecter = reject
+        if vibes.isDeviceRegistered(),
+           let registerDeviceResolver = registerDeviceResolver,
+           let deviceId = userDefaults.object(forKey: "vibesDeviceId") {
+            registerDeviceResolver(["device_id": deviceId])
+            return
+        }
+        vibes.registerDevice()
+    }
+
+    @objc
+    /// Un-register Device
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejecter
+    func unregisterDevice(_ resolve: @escaping RCTPromiseResolveBlock,
+                          rejecter reject: @escaping RCTPromiseRejectBlock) {
+        unregisterDeviceResolver = resolve
+        unregisterDeviceRejecter = reject
+        vibes.unregisterDevice()
+    }
+
+    @objc
+    /// Register Push
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejecter
+    func registerPush(_ resolve: @escaping RCTPromiseResolveBlock,
+                      rejecter reject: @escaping RCTPromiseRejectBlock) {
+        registerPushResolver = resolve
+        registerPushRejecter = reject
+        if vibes.isDeviceRegistered() {
+            vibes.registerPush()
+        } else {
+            if let registerPushRejecter = registerPushRejecter {
+                registerPushRejecter("REGISTER_PUSH_ERROR", "Device Not Registered: \(VibesError.noCredentials)", VibesError.noCredentials)
+            }
+        }
+    }
+
+    @objc
+    /// Un-register Push
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejecter
+    func unregisterPush(_ resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        unregisterPushResolver = resolve
+        unregisterPushRejecter = reject
+        if vibes.isDevicePushRegistered() {
+            vibes.unregisterPush()
+        } else {
+            if let unregisterPushRejecter = unregisterPushRejecter {
+                unregisterPushRejecter("UNREGISTER_PUSH_ERROR", "Push Not Registered: \(VibesError.noPushToken)", VibesError.noPushToken)
+            }
+        }
+    }
+
+    @objc
+    /// Associate device to person
+    /// - Parameters:
+    ///   - externalPersonId: External person ID
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejecter
+    func associatePerson(_ externalPersonId: String, resolver resolve: @escaping RCTPromiseResolveBlock,
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+        associatePersonResolver = resolve
+        associatePersonRejecter = reject
+        vibes.associatePerson(externalPersonId: externalPersonId)
+    }
+
+    @objc
+    /// Update device
+    /// - Parameters:
+    ///   - updateCredentials: a boolean indicating if it's a token update or device info update. Specify false if not certain
+    ///   - lat: Latitude
+    ///   - lon: Longitude
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejecter
+    func updateDevice(_ updateCredentials: Bool, lat: NSNumber, lon: NSNumber, resolver resolve: @escaping RCTPromiseResolveBlock,
+                      rejecter reject: @escaping RCTPromiseRejectBlock) {
+        updateDeviceResolver = resolve
+        updateDeviceRejecter = reject
+        vibes.updateDevice(lat: lat, long: lon, updateCredentials: updateCredentials)
+    }
+
+    @objc
+    /// Get Vibes Device Info
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func getVibesDeviceInfo(_ resolve: @escaping RCTPromiseResolveBlock,
+                            rejecter reject: @escaping RCTPromiseRejectBlock) {
+        if let deviceId = userDefaults.object(forKey: "vibesDeviceId") {
+            if let pushToken = vibes.pushToken {
+                resolve(["device_id": deviceId, "push_token": pushToken])
+                return
+            }
+            resolve(["device_id": deviceId])
+        }
+    }
+    
+    @objc
+    /// Get Person Info
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func getPerson(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock ) -> Void {
+        vibes.getPerson { person, error in
+            if let error = error {
+                reject("GET_PERSON_ERROR", error.localizedDescription, error)
+            } else {
+                resolve(["external_person_id": person?.externalPersonId, "person_key": person?.personKey])
+            }
+        }
+    }
+    
+    @objc
+    /// Fetch Inbox Messages
+    ///
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func fetchInboxMessages(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock ) -> Void {
+        vibes.fetchInboxMessages({ messages, error in
+            if let error = error {
+                reject("FETCH_INBOX_MESSAGES_ERROR", error.localizedDescription, error)
+            } else {
+                var msgs: [JSONDictionary] = []
+                for msg in messages {
+                    msgs.append(msg.encodeJSON())
+                }
+                resolve(msgs)
+            }
+        })
+    }
+
+    @objc
+    /// Fetch single Inbox Message
+    ///
+    /// - Parameters:
+    ///   - messageUid: The Message ID
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func fetchInboxMessage(_ messageUid: String,
+                           resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock ) -> Void {
+        vibes.fetchInboxMessage(messageUID: messageUid) {message, error in
+
+            if let error = error {
+                reject("FETCH_INBOX_MESSAGE_ERROR", error.localizedDescription, error)
+            } else {
+                if let message = message {
+                    resolve(message.encodeJSON())
+                } else {
+                    reject("FETCH_INBOX_MESSAGE_ERROR", "message encoding faild", "message encoding faild" as? Error)
+                }
+            }
+        }
+    }
+    
+    @objc
+    /// Mark Inbox Message as Read
+    ///
+    /// - Parameters:
+    ///   - messageUid: The Message ID
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func markInboxMessageAsRead(_ messageUid: String,
+                           resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock ) -> Void {
+        vibes.markInboxMessageAsRead(messageUID: messageUid) {message, error in
+
+            if let error = error {
+                reject("MARK_INBOX_MESSAGE_AS_READ_ERROR", error.localizedDescription, error)
+            } else {
+                if let message = message {
+                    resolve(message.encodeJSON())
+                } else {
+                    reject("MARK_INBOX_MESSAGE_AS_READ_ERROR", "message encoding faild", "message encoding faild" as? Error)
+                }
+            }
+        }
+    }
+    
+    @objc
+    /// Expire Inbox Message
+    ///
+    /// - Parameters:
+    ///   - messageUid: The Message ID
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func expireInboxMessage(_ messageUid: String,
+                           resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock ) -> Void {
+        vibes.expireInboxMessage(messageUID: messageUid) {message, error in
+
+            if let error = error {
+                reject("EXPIRE_INBOX_MESSAGE_ERROR", error.localizedDescription, error)
+            } else {
+                if let message = message {
+                    resolve(message.encodeJSON())
+                } else {
+                    reject("EXPIRE_INBOX_MESSAGE_ERROR", "message encoding faild", "message encoding faild" as? Error)
+                }
+            }
+        }
+    }
+
+    @objc
+    ///  Inbox Message Opened
+    ///
+    /// - Parameters:
+    ///   - message: The Inbox Message
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func onInboxMessageOpen(_ message: VibesJSONDictionary,
+                           resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock ) -> Void {
+        guard let inboxMessage = InboxMessage(attributes: message) else {
+            reject("INBOX_MESSAGE_OPEN_ERROR", "Could not create Inbox Message from payload", nil)
+            return
+        }
+        vibes.onInboxMessageOpen(inboxMessage: inboxMessage)
+        resolve("success")
+    }
+    
+    @objc
+    ///  Inbox Messages Fetched
+    ///
+    /// - Parameters:
+    ///   - resolve: promise resolver
+    ///   - reject: promise rejector
+    func onInboxMessagesFetched(_ resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock ) -> Void {
+        
+        vibes.onInboxMessagesFetched()
+        resolve("Success recording an inbox_fetch event")
+    }
+    
+    func didRegisterDevice(deviceId: String?, error: Error?) {
+        if let error = error {
+            if let registerDeviceRejecter = registerDeviceRejecter {
+                registerDeviceRejecter("REGISTER_DEVICE_ERROR", error.localizedDescription, error)
+            }
+        } else {
+            if let registerDeviceResolver = registerDeviceResolver {
+                userDefaults.set(deviceId, forKey: "vibesDeviceId")
+                registerDeviceResolver(["device_id": deviceId])
+            }
+            NotificationCenter.default.post(name: Notification.Name.vibesDeviceRegistered, object: deviceId)
+        }
+        registerDeviceRejecter = nil
+        registerDeviceResolver = nil
+    }
+
+    func didUnregisterDevice(error: Error?) {
+        if let error = error {
+            if let unregisterDeviceRejecter = unregisterDeviceRejecter {
+                unregisterDeviceRejecter("UNREGISTER_DEVICE_ERROR", error.localizedDescription, error)
+            }
+        } else {
+            if let unregisterDeviceResolver = unregisterDeviceResolver {
+                userDefaults.removeObject(forKey: "vibesDeviceId")
+                unregisterDeviceResolver(["success"])
+            }
+            NotificationCenter.default.post(name: Notification.Name.vibesDeviceUnregistered, object: nil)
+        }
+        unregisterDeviceRejecter = nil
+        unregisterDeviceResolver = nil
+    }
+
+    func didRegisterPush(error: Error?) {
+        if let error = error {
+            if let registerPushRejecter = registerPushRejecter {
+                registerPushRejecter("REGISTER_PUSH_ERROR", error.localizedDescription, error)
+            }
+        } else {
+            if let registerPushResolver = registerPushResolver {
+                registerPushResolver("Successs")
+            }
+            NotificationCenter.default.post(name: Notification.Name.vibesPushRegistered, object: vibes.pushToken)
+        }
+        registerPushRejecter = nil
+        registerPushResolver = nil
+    }
+
+    func didUnregisterPush(error: Error?) {
+        if let error = error {
+            if let unregisterPushRejecter = unregisterPushRejecter {
+                unregisterPushRejecter("UNREGISTER_PUSH_ERROR", error.localizedDescription, error)
+            }
+        } else {
+            if let unregisterPushResolver = unregisterPushResolver {
+                unregisterPushResolver("Successs")
+            }
+            NotificationCenter.default.post(name: Notification.Name.vibesPushUnregistered, object: nil)
+        }
+        unregisterPushRejecter = nil
+        unregisterPushResolver = nil
+    }
+
+    func didAssociatePerson(error: Error?) {
+        if let error = error {
+            if let associatePersonRejecter = associatePersonRejecter {
+                associatePersonRejecter("ASSOCIATE_PERSON_ERROR", error.localizedDescription, error)
+            }
+        } else {
+            if let associatePersonResolver = associatePersonResolver {
+                associatePersonResolver("Successs")
+            }
+            NotificationCenter.default.post(name: Notification.Name.vibesPushDidAssociatePerson, object: nil)
+        }
+        associatePersonRejecter = nil
+        associatePersonResolver = nil
+    }
+}
+
+extension Notification.Name {
+    static let vibesDeviceRegistered = Notification.Name("vibesDeviceRegistered")
+    static let vibesDeviceUnregistered = Notification.Name("vibesDeviceUnregistered")
+    static let vibesPushRegistered = Notification.Name("vibesPushRegistered")
+    static let vibesPushUnregistered = Notification.Name("vibesPushUnregistered")
+    static let vibesPushDidAssociatePerson = Notification.Name("vibesPushDidAssociatePerson")
+}