vibes-react-native 5.0.0 → 5.0.1-rc2

package/vendor/VibesPush/Sources/AppObserver.swift

@@ -0,0 +1,137 @@
+import UIKit
+
+extension String {
+    func toDictionary() -> [String: Any]? {
+        if let data = data(using: .utf8) {
+            do {
+                return try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
+            } catch {
+                Vibes.shared.configuration.logger?.log(error: error)
+            }
+        }
+        return nil
+    }
+}
+
+/// Observes app lifecycle events and tracks events.
+class AppObserver: NSObject {
+    /// A list of the events that should be tracked
+    private let trackedEventTypes: [TrackedEventType]
+
+    /// The event tracker that should be used to track events (usally a Vibes
+    /// instance)
+    weak var eventTracker: EventTracker?
+
+    /// The user info and date of the last notification that was received.[
+    var lastNotification: (userInfo: [AnyHashable: Any], timestamp: Date)? {
+        didSet  {
+            if let userInfo = lastNotification?.userInfo, shouldTrackPushReceive() {
+                trackPushReceive(with: userInfo)
+            }
+        }
+    }
+
+    /// The threshold of time between receiving a notification and the app
+    /// becoming active that we should consider a "clickthru"
+    private let clickthruThreshold: TimeInterval // seconds
+
+    /// Initialize this object.
+    ///
+    /// - parameters:
+    ///   - trackedEventTypes: the type of events that should be tracked
+    ///     (default: all)
+    ///   - clickthruThreshold - the threshold of time between receiving a
+    ///     notification and the app becoming active that we should consider
+    ///     a "clickthru" (default: 1 second)
+    init(trackedEventTypes: [TrackedEventType] = TrackedEventType.all, clickthruThreshold: TimeInterval = 1) {
+        self.clickthruThreshold = clickthruThreshold
+        self.trackedEventTypes = trackedEventTypes
+
+        super.init()
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(applicationDidBecomeActive(_:)),
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+    }
+
+    /// Run on deallocation.
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    /// Tracks when the application became active. If there's a push
+    /// notification, this fires after it is received by the AppDelegate.
+    ///
+    /// - parameters:
+    ///   - the notification fired by iOS
+    @objc func applicationDidBecomeActive(_ notification: Notification) {
+        if trackedEventTypes.contains(.launch) {
+            trackLaunch()
+        }
+
+        if let (userInfo, _) = lastNotification, shouldTrackClickThru() {
+            trackClickthru(with: userInfo)
+        }
+        lastNotification = nil
+    }
+
+    /// Determines if a clickthru should be tracked, based on the user vibes configuration
+    private func shouldTrackClickThru() -> Bool {
+        return trackedEventTypes.contains(.clickthru)
+    }
+
+    /// Determines if a .pushReceive should be tracked, based on the user vibes configuration
+    private func shouldTrackPushReceive() -> Bool {
+        return trackedEventTypes.contains(.pushReceive)
+    }
+
+    /// Tracks a launch event.
+    private func trackLaunch() {
+        let event = Event(eventType: .launch, properties: [:])
+        eventTracker?.track(event: event)
+    }
+
+    func eventProps(with userInfo: [AnyHashable: Any]) ->  [AnyHashable: Any] {
+        var properties: [AnyHashable: Any] = [:]
+
+        if let messageUniqueId = userInfo["message_uid"] as? String {
+            properties["message_uid"] = messageUniqueId
+        }
+
+        if let clientAppData = userInfo["client_app_data"] as? [AnyHashable: Any] {
+            if let activityType = clientAppData["activity_type"] as? String {
+                properties["activity_type"] = activityType
+            }
+
+            if let activityUid = clientAppData["activity_uid"] as? String {
+                properties["activity_uid"] = activityUid
+            }
+        }
+        
+        return properties
+
+    }
+    
+    /// Tracks a clickthru event.
+    ///
+    /// - parameters:
+    ///   - userInfo: the details from the push notification to track
+    private func trackClickthru(with userInfo: [AnyHashable: Any]) {
+        var properties: [AnyHashable: Any] = eventProps(with: userInfo)
+        let event = Event(eventType: .clickthru, properties: properties)
+        eventTracker?.track(event: event)
+    }
+
+    /// Tracks a push_receive event.
+    ///
+    /// - parameters:
+    ///   - userInfo: the details from the push notification to track
+    private func trackPushReceive(with userInfo: [AnyHashable: Any]) {
+        var properties: [AnyHashable: Any] = eventProps(with: userInfo)
+        let event = Event(eventType: .pushReceive, properties: properties)
+        eventTracker?.track(event: event)
+    }
+}

package/vendor/VibesPush/Sources/AuthTokenBehavior.swift

@@ -0,0 +1,17 @@
+import Foundation
+/// A behavior for adding the necessary authentication token for requests to the
+/// Vibes API.
+struct AuthTokenBehavior: HTTPBehavior {
+  /// An authentication token to send in an request header.
+  let token: String?
+
+  /// Modifies the request by adding an `Authorization` header.
+  ///
+  /// - parameters:
+  ///   - request: the request to modify
+  func modifyRequest(request: inout URLRequest) {
+    if let token = self.token {
+        request.setValue("MobileAppToken \(token)", forHTTPHeaderField: "Authorization")
+    }
+  }
+}

package/vendor/VibesPush/Sources/CombinedLogger.swift

@@ -0,0 +1,53 @@
+//
+//  CombinedLogger.swift
+//  VibesPush-iOS
+//
+//  Created by Moin' Victor on 20/08/2020.
+//  Copyright © 2020 Vibes. All rights reserved.
+//
+
+import Foundation
+
+/// A Logger that writes to the `ConsoleLogger` if enabled, as well as to any custom Logger provider to `VibesConfigration` during init.
+@objc public class CombinedLogger: NSObject, VibesLogger {
+    /// The custom logger  provided in  `VibesConfigration` during init.
+    public var customLogger: VibesLogger?
+
+    /// The console logger to use
+    public var consoleLogger: ConsoleLogger? {
+        return VibesConfiguration.consoleLogger
+    }
+
+    /// Initialize this object.
+    ///
+    /// - Parameters:
+    ///   - customLogger: The custom logger provided in  `VibesConfigration` during init.
+    init(customLogger: VibesLogger?) {
+        super.init()
+        self.customLogger = customLogger
+    }
+
+    /// Logs a message to the console if the `logObject.level` matches or is above the configured log `level`
+    ///
+    /// - Parameters:
+    ///   - logObject: The Log object with  log `level` and specified log `message`.
+    public func log(_ logObject: LogObject) {
+        consoleLogger?.log(logObject)
+        customLogger?.log(logObject)
+    }
+
+    public func log(request: URLRequest) {
+        consoleLogger?.log(request: request)
+        customLogger?.log(request: request)
+    }
+
+    public func log(response: URLResponse, data: Data?) {
+        consoleLogger?.log(response: response, data: data)
+        customLogger?.log(response: response, data: data)
+    }
+
+    public func log(error: Error) {
+        consoleLogger?.log(error: error)
+        customLogger?.log(error: error)
+    }
+}

package/vendor/VibesPush/Sources/ConsoleLogger.swift

@@ -0,0 +1,97 @@
+import Foundation
+
+/// A simple Logger that writes to the Xcode console.
+@objc public class ConsoleLogger: NSObject, VibesLogger {
+    /// Prefix for logging SDK initialization
+    static let versionInfoLogPrefix = "Initializing Vibes SDK v"
+
+    /// The level for this logger
+    private var level: LogLevel
+
+    /// Initialize this object.
+    ///
+    /// - Parameters:
+    ///   - level: the level for this logger
+    init(level: LogLevel = .verbose) {
+        self.level = level
+        super.init()
+    }
+
+    /// Logs a message to the console if the `logObject.level` matches or is above the configured log `level`
+    ///
+    /// - Parameters:
+    ///   - logObject: The Log object with  log `level` and specified log `message`.
+    public func log(_ logObject: LogObject) {
+        if logObject.level.rawValue >= level.rawValue {
+            printLogMessage(logObject.level, message: logObject.message)
+        }
+    }
+
+    /// Logs an HTTP request to the console.
+    ///
+    /// - Parameters:
+    ///   - request: the HTTP request to log
+    public func log(request: URLRequest) {
+        switch level {
+        case .verbose:
+            log(LogObject(.verbose, message: "Request: \(request.toString())"))
+        default:
+            break
+        }
+    }
+
+    /// Logs an HTTP response with its accompanying data to the console.
+    ///
+    /// - Parameters:
+    ///   - response: the HTTP response to log
+    ///   - data: the data received, if any
+    public func log(response: URLResponse, data: Data? = nil) {
+        guard let response = response as? HTTPURLResponse else { return }
+
+        switch level {
+        case .verbose:
+            log(LogObject(.verbose, message: "Response: \(response.responseCodeDescription)"))
+            log(data: data)
+        default:
+            break
+        }
+    }
+
+    /// Logs an error the console.
+    ///
+    /// - Parameters:
+    ///   - error: the error that occurred
+    public func log(error: Error) {
+        log(LogObject(.error, message: "Error: \(error.localizedDescription)"))
+    }
+
+    /// Logs data to the console, if it exists.
+    ///
+    /// - parameters:
+    ///   - data: the Data of the HTTP response
+    private func log(data: Data?) {
+        guard let data = data else { return }
+
+        do {
+            let json = try JSONSerialization.jsonObject(with: data, options: .mutableContainers)
+            let pretty = try JSONSerialization.data(withJSONObject: json, options: .prettyPrinted)
+
+            if let string = NSString(data: pretty, encoding: String.Encoding.utf8.rawValue) {
+                log(LogObject(.verbose, message: "JSON: \(string)"))
+            }
+        } catch {
+            if let string = NSString(data: data, encoding: String.Encoding.utf8.rawValue) {
+                log(LogObject(.verbose, message: "Data: \(string)"))
+            }
+        }
+    }
+
+    /// Prints out the log message with template `[TIMESTAMP] VibesPush/[logLevel]: <MSG>`
+    ///
+    /// - Parameters:
+    ///   - msgLogLevel: The log level for the message
+    ///   - message: The message to print on the log
+    func printLogMessage(_ msgLogLevel: LogLevel = .verbose, message: String) {
+        print("\(Date.logPrefix) VibesPush/\(msgLogLevel.logPrefix): \(message)")
+    }
+}

package/vendor/VibesPush/Sources/Credential.swift

@@ -0,0 +1,41 @@
+/// A value object to represent the credentials needed to interact with the
+/// Vibes API.
+public struct VibesCredential {
+  /// A unique identifier for the device, provided by Vibes when registering.
+  public let deviceId: String
+
+  /// A unique, transient token for the device. The combination of `deviceId`
+  /// and `authToken` is used to authenticate most calls in the `VibesAPI`.
+  public let authToken: String
+}
+
+extension VibesCredential: JSONDecodable {
+  init?(json: VibesJSONDictionary) {
+    guard let device = json["device"] as? VibesJSONDictionary,
+      let deviceId = device["vibes_device_id"] as? String,
+      let authToken = json["auth_token"] as? String else { return nil }
+
+    self.deviceId = deviceId
+    self.authToken = authToken
+  }
+}
+
+extension VibesCredential: Equatable {
+  public static func == (lhs: VibesCredential, rhs: VibesCredential) -> Bool {
+    return lhs.deviceId == rhs.deviceId && lhs.authToken == rhs.authToken
+  }
+}
+
+extension VibesCredential: LocalObjectType {
+  public var attributes: [String: Any] {
+    return ["id": deviceId, "token": authToken]
+  }
+
+  public init?(attributes: [String: Any]) {
+    guard let id = attributes["id"] as? String,
+      let token = attributes["token"] as? String else { return nil }
+
+    self.deviceId = id
+    self.authToken = token
+  }
+}

package/vendor/VibesPush/Sources/CredentialManager.swift

@@ -0,0 +1,24 @@
+/// Handles storing credentials, keeping track of the current Credential, etc.
+class CredentialManager {
+  /// An object for storing data in some kind of local storage.
+  private let storage: LocalStorageType
+
+  /// The currently-active Credential
+  var currentCredential: VibesCredential? {
+    get {
+      return storage.get(LocalStorageKeys.currentCredential)
+    }
+
+    set {
+      storage.set(newValue, for: LocalStorageKeys.currentCredential)
+    }
+  }
+
+  /// Initialize this object.
+  ///
+  /// - parameters:
+  ///   - storage: an object that allows storing data locally
+  init(storage: LocalStorageType) {
+    self.storage = storage
+  }
+}

package/vendor/VibesPush/Sources/Date+iso8601.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+public extension Formatter {
+    /// A date formatter for generating ISO8601-compatible timestamp strings.
+    static let iso8601: DateFormatter = {
+        let formatter = DateFormatter()
+
+        formatter.calendar = Calendar(identifier: .iso8601)
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ"
+
+        return formatter
+    }()
+}
+
+public extension Date {
+    /// An ISO8601-compatible timestamp string for this Date object.
+    var iso8601: String {
+        return Formatter.iso8601.string(from: self)
+    }
+
+    var iso8601WithUpdatingTimezone: String {
+        let formatter = Formatter.iso8601
+        formatter.timeZone = TimeZone.autoupdatingCurrent
+        return formatter.string(from: self)
+    }
+}
+
+public extension String {
+    var iso8601: Date? {
+        return Formatter.iso8601.date(from: self)
+    }
+}

package/vendor/VibesPush/Sources/Date+logPrefix.swift

@@ -0,0 +1,20 @@
+//
+//  Date+logPrefix.swift
+//  VibesPush
+//
+//  Created by Moin' Victor on 25/08/2020.
+//  Copyright © 2020 Vibes. All rights reserved.
+//
+
+import Foundation
+
+// MARK: - Date + log prefix
+
+extension Date {
+    public static var logPrefix: String {
+        let dateFormatter = DateFormatter()
+        dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
+        let nowString = dateFormatter.string(from: Date())
+        return "[\(nowString)]"
+    }
+}

package/vendor/VibesPush/Sources/DeviceToken.swift

@@ -0,0 +1,15 @@
+/// A small data object to hold a push token received from Apple. This provides
+/// a convenient place to add our JSON encoding code.
+struct DeviceToken {
+  let token: String
+}
+
+extension DeviceToken: JSONEncodable {
+  func encodeJSON() -> VibesJSONDictionary {
+    return [
+      "device": [
+        "push_token": token,
+      ] as AnyObject,
+    ]
+  }
+}

package/vendor/VibesPush/Sources/DeviceType.swift

@@ -0,0 +1,143 @@
+import UIKit
+
+/// A protocol that indicates the required interface for being considered a
+/// `Device` in the Vibes system.
+protocol DeviceType: JSONEncodable {
+    /// The operating system of this device, e.g. iOS
+    var systemName: String { get }
+
+    /// The operating system version of this device, e.g. "10.3.1"
+    var systemVersion: String { get }
+
+    /// The hardware make of this device, e.g. "Apple"
+    var hardwareMake: String { get }
+
+    /// The hardware model of this device, e.g. "iPhone9,1"
+    var hardwareModel: String { get }
+
+    /// The locale for this device, e.g. "en_US"
+    var localeIdentifier: String { get }
+
+    /// The timezone for this device, e.g. "America/Chicago"
+    var timeZoneIdentifier: String { get }
+
+    /// The version of the Vibes SDK installed on this device, e.g. "1.0.1"
+    var sdkVersion: String { get }
+
+    /// The version of the app installed on this device, e.g. "2.0.0"
+    var appVersion: String { get }
+
+    /// A unique advertising identifier for this device, e.g.
+    /// "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"
+    var advertisingIdentifier: String? { get }
+
+    /// User location if provided
+    var location: (lat: Double, long: Double)? { get }
+}
+
+/// A simple data object to allow us to send serialized Device information to
+/// Vibes.
+struct Device {
+
+    /// A unique advertising identifier for this device, e.g.
+    /// "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"
+    let advertisingIdentifier: String?
+
+    /// User location :-(
+    var location: (lat: Double, long: Double)?
+
+    /// Initialize this object.
+    ///
+    /// - parameters:
+    ///   - advertisingIdentifier: AdSupport.AdvertisingIdentifier, A unique advertising
+    ///     identifier for this device
+    init(advertisingIdentifier: String?, location: (lat: Double, long: Double)? = nil) {
+        // check if Ad tracking has been limited by the app's user.
+        // https://developer.apple.com/documentation/adsupport/asidentifiermanager
+        // Sad day: elvis operator '?:' doesn't work in swift.
+        if advertisingIdentifier == "00000000-0000-0000-0000-000000000000" || advertisingIdentifier == "" {
+            self.advertisingIdentifier = nil
+        } else {
+            self.advertisingIdentifier = advertisingIdentifier
+        }
+        if let location = location {
+            self.location = location
+        }
+    }
+}
+
+extension Device: DeviceType {
+
+    var systemName: String {
+        return "iOS"
+    }
+
+    var systemVersion: String {
+        return UIDevice.current.systemVersion
+    }
+
+    var identifierForVendor: UUID? {
+        return UIDevice.current.identifierForVendor
+    }
+
+    var localeIdentifier: String {
+        return Locale.current.identifier
+    }
+
+    var timeZoneIdentifier: String {
+        return NSTimeZone.local.identifier
+    }
+
+    var hardwareMake: String {
+        return "Apple"
+    }
+
+    var hardwareModel: String {
+        var systemInfo = utsname()
+        uname(&systemInfo)
+
+        let modelCode = withUnsafePointer(to: &systemInfo.machine) {
+            $0.withMemoryRebound(to: CChar.self, capacity: 1) { ptr in
+                String.init(validatingUTF8: ptr)
+            }
+        }
+
+        return modelCode ?? "Unknown"
+    }
+
+    var sdkVersion: String {
+        return Vibes.SDK_VERSION
+    }
+
+    var appVersion: String {
+        return Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "Unknown"
+    }
+}
+
+extension DeviceType {
+    func encodeJSON() -> VibesJSONDictionary {
+        var locationDictionary: VibesJSONDictionary?
+        if let loc = location {
+            locationDictionary = [
+                "latitude": loc.lat as AnyObject,
+                "longitude": loc.long as AnyObject,
+            ]
+        }
+        let dictionary: VibesJSONDictionary = [
+            "device": [
+                "os": systemName,
+                "os_version": systemVersion,
+                "sdk_version": sdkVersion,
+                "app_version": appVersion,
+                "hardware_make": hardwareMake,
+                "hardware_model": hardwareModel,
+                "advertising_id": advertisingIdentifier as Any,
+                "locale": localeIdentifier,
+                "timezone": timeZoneIdentifier,
+                "location": locationDictionary as AnyObject,
+                ] as AnyObject,
+            ]
+
+        return dictionary
+    }
+}

package/vendor/VibesPush/Sources/Dictionary+merged.swift

@@ -0,0 +1,11 @@
+extension Dictionary {
+  /// Merges a dictionary into this one.
+  ///
+  /// - parameters:
+  ///   - dictionary: the Dictionary to merge in
+  func merged(with dictionary: [Key: Value]) -> [Key: Value] {
+    var copy = self
+    dictionary.forEach { copy.updateValue($1, forKey: $0) }
+    return copy
+  }
+}

package/vendor/VibesPush/Sources/Event.swift

@@ -0,0 +1,83 @@
+import Foundation
+
+/// A data object to represent an Event to send to Vibes.
+struct Event {
+    /// The type of the event
+    fileprivate let eventType: TrackedEventType
+
+    /// Event unique id (string representation)
+    let uuid: String
+
+    /// The time the Event occurred
+    let timestamp: Date
+
+    /// A set of arbitrary key/values to send along with the event
+    let properties: [AnyHashable: Any]
+
+    /// A convenience property for retrieving the type of the event as a String.
+    var type: String {
+        return eventType.name()
+    }
+
+    /// Checks if this event of of type `launch`
+    var isLaunchEvent: Bool {
+        return self.type == TrackedEventType.launch.name()
+    }
+
+    /// Initialize this object.
+    ///
+    /// - parameters:
+    ///   - eventType: the type of the event
+    ///   - properties: a set of arbitrary key/values to send along with the event
+    ///   - timestamp: the time the Event occurred
+    init(eventType: TrackedEventType, properties: [AnyHashable: Any], timestamp: Date = Date()) {
+        uuid = UUID().uuidString
+        self.eventType = eventType
+        self.properties = properties
+        self.timestamp = timestamp
+    }
+}
+
+extension Event: Equatable {
+    static func == (lhs: Event, rhs: Event) -> Bool {
+        return lhs.uuid == rhs.uuid &&
+            lhs.type == rhs.type &&
+            lhs.timestamp == rhs.timestamp
+    }
+}
+
+extension Event: JSONEncodable {
+    func encodeJSON() -> VibesJSONDictionary {
+        return [
+            "uuid": uuid,
+            "type": type,
+            "timestamp": timestamp.iso8601,
+            "attributes": properties,
+        ] as VibesJSONDictionary
+    }
+}
+
+extension Event: LocalObjectType {
+    var attributes: [String: Any] {
+        return [
+            "uuid": uuid,
+            "type": type,
+            "timestamp": timestamp,
+            "properties": properties,
+        ]
+    }
+
+    init?(attributes: [String: Any]) {
+        guard let uuid = attributes["uuid"] as? String,
+            let timestamp = attributes["timestamp"] as? Date,
+            let properties = attributes["properties"] as? [AnyHashable: Any],
+            let type = attributes["type"] as? String else {
+            return nil
+        }
+
+        self.uuid = uuid
+        self.properties = properties
+        self.timestamp = timestamp
+        eventType = TrackedEventType.convert(rawValue: type)
+    }
+}