Add public api to register global listener

AEPCore/Sources/core/MobileCore.swift

@@ -101,6 +101,16 @@ public final class MobileCore: NSObject {
         EventHub.shared.dispatch(event: event)
     }
 
+    /// Registers an `EventListener` which will be invoked whenever a event with matched type and source is dispatched
+    /// - Parameters:
+    ///   - type: An `String` indicates the event type the current listener is listening for
+    ///   - source: An `String` indicates the event source the current listener is listening for
+    ///   - listener: An `EventResponseListener` which will be invoked whenever the `EventHub` receives a event with matched typd and source
+    @objc(registerEventListenerWithType:source:listener:)
+    public static func registerEventListener(type: String, source: String, listener: @escaping EventListener) {
+        EventHub.shared.registerEventListener(type: type, source: source, listener: listener)
+    }
+
     /// Submits a generic event containing the provided IDFA with event type `generic.identity`.
     /// - Parameter identifier: the advertising identifier string.
     @objc(setAdvertisingIdentifier:)

AEPCore/Sources/eventhub/AEPError.swift

@@ -20,5 +20,9 @@ import Foundation
     case callbackTimeout = 1
     case callbackNil = 2
     case none = 3
+    case serverError = 4
+    case networkError = 5
+    case invalidRequest = 6
+    case invalidResponse = 7
     case errorExtensionNotInitialized = 11
 }

AEPCore/Sources/eventhub/EventHub.swift

@@ -148,6 +148,23 @@ final class EventHub {
         responseEventListeners.append(responseListenerContainer!)
     }
 
+    /// Registers an `EventListener` which will be invoked whenever a event with matched type and source is dispatched
+    /// - Parameters:
+    ///   - type: An `String` indicates the event type the current listener is listening for
+    ///   - source: An `String` indicates the event source the current listener is listening for
+    ///   - listener: An `EventResponseListener` which will be invoked whenever the `EventHub` receives a event with matched typd and source
+    func registerEventListener(type: String, source: String, listener: @escaping EventListener) {
+
+        eventHubQueue.async {
+            // use the event hub placeholder extension to hold all the listeners register from the public API
+            guard let eventHubExtension = self.registeredExtensions.first(where: { $1.sharedStateName == EventHubConstants.NAME })?.value else {
+                Log.warning(label: self.LOG_TAG, "Error registering event listener")
+                return
+            }
+            eventHubExtension.registerListener(type: type, source: source, listener: listener)
+        }
+    }
+
     /// Creates a new `SharedState` for the extension with provided data, versioned at `event`
     /// If `event` is nil, one of two behaviors will be observed:
     /// 1. If this extension has not previously published a shared state, shared state will be versioned at 0

AEPCore/Sources/eventhub/EventSource.swift

@@ -22,6 +22,7 @@ public class EventSource: NSObject {
     public static let requestIdentity = "com.adobe.eventSource.requestIdentity"
     public static let requestProfile = "com.adobe.eventSource.requestProfile"
     public static let requestReset = "com.adobe.eventSource.requestReset"
+    public static let notification = "com.adobe.eventSource.notification"
     public static let responseContent = "com.adobe.eventSource.responseContent"
     public static let responseIdentity = "com.adobe.eventSource.responseIdentity"
     public static let responseProfile = "com.adobe.eventSource.responseProfile"

AEPCore/Sources/eventhub/EventType.swift

@@ -34,6 +34,7 @@ public class EventType: NSObject {
     public static let userProfile = "com.adobe.eventType.userProfile"
     public static let places = "com.adobe.eventType.places"
     public static let offerDecisioning = "com.adobe.eventType.offerDecisioning"
+    public static let edge = "com.adobe.eventType.edge"
     public static let genericTrack = "com.adobe.eventType.generic.track"
     public static let genericLifecycle = "com.adobe.eventType.generic.lifecycle"
     public static let genericIdentity = "com.adobe.eventType.generic.identity"

AEPCore/Tests/EventHubTests/EventHubTests.swift

@@ -217,6 +217,42 @@ class EventHubTests: XCTestCase {
         wait(for: [expectation, expectation1], timeout: 1)
     }
 
+    func testEventHubTestTegisterEventListener() {
+        // setup
+        let expectation = XCTestExpectation(description: "Listener is invoked exactly once")
+        expectation.assertForOverFulfill = true
+        let event = Event(name: "Test", type: EventType.analytics, source: EventSource.requestContent, data: nil)
+
+        // test
+        eventHub.registerEventListener(type: EventType.analytics, source: EventSource.requestContent) { event in
+            expectation.fulfill()
+        }
+
+        eventHub.start()
+        eventHub.dispatch(event: event)
+
+        // verify
+        wait(for: [expectation], timeout: 1)
+    }
+
+    func testEventHubTestTegisterEventListenerUnMatchedEvent() {
+        // setup
+        let expectation = XCTestExpectation(description: "Listener is not invoked")
+        expectation.isInverted = true
+        let event = Event(name: "Test", type: "wrong", source: "wrong", data: nil)
+
+        // test
+        eventHub.registerEventListener(type: EventType.analytics, source: EventSource.requestContent) { event in
+            expectation.fulfill()
+        }
+
+        eventHub.start()
+        eventHub.dispatch(event: event)
+
+        // verify
+        wait(for: [expectation], timeout: 0.5)
+    }
+
     func testEventHubTestResponseListener() {
         // setup
         let expectation = XCTestExpectation(description: "Response listener is invoked exactly once")

AEPCore/Tests/MobileCoreTests.swift

@@ -277,6 +277,58 @@ class MobileCoreTests: XCTestCase {
         wait(for: [responseExpectation], timeout: 1.0)
     }
 
+    /// Tests that the event listener only receive the events it is registered for
+    func testRegisterEventListener() {
+        // setup
+        let expectedEvent1 = Event(name: "test", type: EventType.analytics, source: EventSource.requestContent, data: nil)
+        let expectedEvent2 = Event(name: "test", type: EventType.analytics, source: EventSource.requestContent, data: nil)
+        let unexpectedEvent = Event(name: "test", type: "wrong", source: "wrong", data: nil)
+        let responseExpectation = XCTestExpectation(description: "Should receive the event")
+        responseExpectation.expectedFulfillmentCount = 2
+        EventHub.shared.start()
+
+        // test
+        MobileCore.registerEventListener(type: EventType.analytics, source: EventSource.requestContent) { event in
+            responseExpectation.fulfill()
+        }
+        // dispatch the events
+        MobileCore.dispatch(event: expectedEvent1)
+        MobileCore.dispatch(event: unexpectedEvent)
+        MobileCore.dispatch(event: expectedEvent2)
+
+        // verify
+        wait(for: [responseExpectation], timeout: 1.0)
+    }
+
+    /// Tests that the event listeners listening for same events can all receives the events
+    func testRegisterEventListenerMultipleLisenersForSameEvents() {
+        // setup
+        let expectedEvent1 = Event(name: "test", type: EventType.analytics, source: EventSource.requestContent, data: nil)
+        let expectedEvent2 = Event(name: "test", type: EventType.analytics, source: EventSource.requestContent, data: nil)
+        let unexpectedEvent = Event(name: "test", type: "wrong", source: "wrong", data: nil)
+        let responseExpectation1 = XCTestExpectation(description: "Should receive the events")
+        responseExpectation1.expectedFulfillmentCount = 2
+        let responseExpectation2 = XCTestExpectation(description: "Should receive the events")
+        responseExpectation2.expectedFulfillmentCount = 2
+        EventHub.shared.start()
+
+        // test
+        MobileCore.registerEventListener(type: EventType.analytics, source: EventSource.requestContent) { event in
+            responseExpectation1.fulfill()
+        }
+
+        MobileCore.registerEventListener(type: EventType.analytics, source: EventSource.requestContent) { event in
+            responseExpectation2.fulfill()
+        }
+        // dispatch the events
+        MobileCore.dispatch(event: expectedEvent1)
+        MobileCore.dispatch(event: unexpectedEvent)
+        MobileCore.dispatch(event: expectedEvent2)
+
+        // verify
+        wait(for: [responseExpectation1,responseExpectation2], timeout: 1.0)
+    }
+
     // MARK: setWrapperType(...) tests
 
     /// No wrapper tag should be appended when the setWrapperType API is never invoked