@shortkitsdk/react-native 0.2.0 → 0.2.2

package/android/src/main/java/com/shortkit/reactnative/ShortKitWidgetNativeView.kt

@@ -0,0 +1,133 @@
+package com.shortkit.reactnative
+
+import android.content.Context
+import android.widget.FrameLayout
+import com.shortkit.sdk.config.PlayerClickAction
+import com.shortkit.sdk.config.VideoOverlayMode
+import com.shortkit.sdk.config.WidgetConfig
+import com.shortkit.sdk.model.ContentItem
+import com.shortkit.sdk.widget.ShortKitWidgetView
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Fabric native view wrapping [ShortKitWidgetView] for use as a
+ * horizontal video carousel in React Native.
+ */
+class ShortKitWidgetNativeView(context: Context) : FrameLayout(context) {
+
+    private var widgetView: ShortKitWidgetView? = null
+    private var configJson: String? = null
+    private var itemsJson: String? = null
+
+    var config: String?
+        get() = configJson
+        set(value) {
+            if (value == configJson) return
+            configJson = value
+            rebuildIfNeeded()
+        }
+
+    var items: String?
+        get() = itemsJson
+        set(value) {
+            if (value == itemsJson) return
+            itemsJson = value
+            applyItems()
+        }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        rebuildIfNeeded()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+    }
+
+    private fun rebuildIfNeeded() {
+        if (widgetView != null) return
+
+        val sdk = ShortKitModule.shared?.sdk ?: return
+        val widgetConfig = parseWidgetConfig(configJson)
+
+        val view = ShortKitWidgetView(context).apply {
+            layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        }
+        view.initialize(sdk, widgetConfig)
+        addView(view)
+        widgetView = view
+
+        applyItems()
+    }
+
+    private fun applyItems() {
+        val json = itemsJson ?: return
+        val view = widgetView ?: return
+        val contentItems = parseContentItems(json) ?: return
+        view.configure(contentItems)
+    }
+
+    private fun parseWidgetConfig(json: String?): WidgetConfig {
+        if (json.isNullOrEmpty()) return WidgetConfig()
+        return try {
+            val obj = JSONObject(json)
+            WidgetConfig(
+                cardCount = obj.optInt("cardCount", 3),
+                cardSpacing = obj.optDouble("cardSpacing", 8.0).toFloat(),
+                cornerRadius = obj.optDouble("cornerRadius", 12.0).toFloat(),
+                autoplay = obj.optBoolean("autoplay", true),
+                muteOnStart = obj.optBoolean("muteOnStart", true),
+                loop = obj.optBoolean("loop", true),
+                rotationInterval = obj.optLong("rotationInterval", 10_000L),
+                clickAction = when (obj.optString("clickAction", "feed")) {
+                    "feed" -> PlayerClickAction.FEED
+                    "mute" -> PlayerClickAction.MUTE
+                    "none" -> PlayerClickAction.NONE
+                    else -> PlayerClickAction.FEED
+                },
+                cardOverlay = parseOverlay(obj),
+            )
+        } catch (_: Exception) {
+            WidgetConfig()
+        }
+    }
+
+    private fun parseOverlay(obj: JSONObject): VideoOverlayMode {
+        val overlay = obj.opt("overlay") ?: return VideoOverlayMode.None
+        if (overlay is JSONObject && overlay.optString("type") == "custom") {
+            return VideoOverlayMode.Custom {
+                ShortKitOverlayBridge(context)
+            }
+        }
+        return VideoOverlayMode.None
+    }
+
+    private fun parseContentItems(json: String): List<ContentItem>? {
+        return try {
+            val arr = JSONArray(json)
+            val items = mutableListOf<ContentItem>()
+            for (i in 0 until arr.length()) {
+                val obj = arr.getJSONObject(i)
+                items.add(
+                    ContentItem(
+                        id = obj.getString("id"),
+                        title = obj.getString("title"),
+                        description = obj.optString("description", null),
+                        duration = obj.getDouble("duration"),
+                        streamingUrl = obj.getString("streamingUrl"),
+                        thumbnailUrl = obj.getString("thumbnailUrl"),
+                        captionTracks = emptyList(),
+                        customMetadata = null,
+                        author = obj.optString("author", null),
+                        articleUrl = obj.optString("articleUrl", null),
+                        commentCount = if (obj.has("commentCount")) obj.getInt("commentCount") else null,
+                    )
+                )
+            }
+            items
+        } catch (_: Exception) {
+            null
+        }
+    }
+}

package/android/src/main/java/com/shortkit/reactnative/ShortKitWidgetViewManager.kt

@@ -0,0 +1,30 @@
+package com.shortkit.reactnative
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+@ReactModule(name = ShortKitWidgetViewManager.REACT_CLASS)
+class ShortKitWidgetViewManager : SimpleViewManager<ShortKitWidgetNativeView>() {
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): ShortKitWidgetNativeView {
+        return ShortKitWidgetNativeView(context)
+    }
+
+    @ReactProp(name = "config")
+    fun setConfig(view: ShortKitWidgetNativeView, config: String?) {
+        view.config = config
+    }
+
+    @ReactProp(name = "items")
+    fun setItems(view: ShortKitWidgetNativeView, items: String?) {
+        view.items = items
+    }
+
+    companion object {
+        const val REACT_CLASS = "ShortKitWidgetView"
+    }
+}

package/ios/ShortKitBridge.swift

@@ -23,6 +23,7 @@ import ShortKit
     @objc public init(
         apiKey: String,
         config configJSON: String,
+        embedId: String?,
         clientAppName: String?,
         clientAppVersion: String?,
         customDimensions customDimensionsJSON: String?,
@@ -37,6 +38,7 @@ import ShortKit
         let sdk = ShortKit(
             apiKey: apiKey,
             config: feedConfig,
+            embedId: embedId,
             clientAppName: clientAppName,
             clientAppVersion: clientAppVersion,
             customDimensions: dimensions
@@ -46,6 +48,7 @@ import ShortKit
         ShortKitBridge.shared = self
 
         subscribeToPublishers(sdk.player)
+        sdk.delegate = self
     }
 
     // MARK: - Teardown
@@ -140,6 +143,35 @@ import ShortKit
         shortKit?.player.setMaxBitrate(Int(bitrate))
     }
 
+    // MARK: - Custom Feed
+
+    @objc public func setFeedItems(_ json: String) {
+        guard let items = Self.parseCustomFeedItems(json) else { return }
+        Task { @MainActor in
+            self.shortKit?.setFeedItems(items)
+        }
+    }
+
+    @objc public func appendFeedItems(_ json: String) {
+        guard let items = Self.parseCustomFeedItems(json) else { return }
+        Task { @MainActor in
+            self.shortKit?.appendFeedItems(items)
+        }
+    }
+
+    @objc public func fetchContent(_ limit: Int, completion: @escaping (String) -> Void) {
+        Task {
+            do {
+                let items = try await self.shortKit?.fetchContent(limit: limit) ?? []
+                let data = try JSONEncoder().encode(items)
+                let json = String(data: data, encoding: .utf8) ?? "[]"
+                completion(json)
+            } catch {
+                completion("[]")
+            }
+        }
+    }
+
     // MARK: - Combine Subscriptions
 
     private func subscribeToPublishers(_ player: ShortKitPlayer) {
@@ -277,6 +309,14 @@ import ShortKit
                 self?.emit("onPrefetchedAheadCountChanged", body: ["count": count])
             }
             .store(in: &cancellables)
+
+        // Remaining content count
+        player.remainingContentCount
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] count in
+                self?.emit("onRemainingContentCountChanged", body: ["count": count])
+            }
+            .store(in: &cancellables)
     }
 
     // MARK: - Event Emission Helpers
@@ -307,6 +347,20 @@ import ShortKit
         emitOnMain(name, body: body)
     }
 
+    // MARK: - Carousel Overlay Lifecycle Events
+
+    /// Emit carousel overlay lifecycle events with an ImageCarouselItem.
+    public func emitCarouselOverlayEvent(_ name: String, item: ImageCarouselItem) {
+        guard let data = try? JSONEncoder().encode(item),
+              let json = String(data: data, encoding: .utf8) else { return }
+        emitOnMain(name, body: ["item": json])
+    }
+
+    /// Emit a raw carousel overlay event with an arbitrary body.
+    public func emitCarouselOverlayEvent(_ name: String, body: [String: Any]) {
+        emitOnMain(name, body: body)
+    }
+
     // MARK: - Content Item Serialization
 
     /// Serialize a ContentItem to a JSON string for bridge transport.
@@ -329,6 +383,10 @@ import ShortKit
             "thumbnailUrl": item.thumbnailUrl,
         ]
 
+        if let playbackId = item.playbackId {
+            dict["playbackId"] = playbackId
+        }
+
         if let description = item.description {
             dict["description"] = description
         }
@@ -410,13 +468,19 @@ import ShortKit
         let muteOnStart = obj["muteOnStart"] as? Bool ?? true
         let videoOverlay = parseVideoOverlay(obj["overlay"] as? String)
 
+        let feedSourceStr = obj["feedSource"] as? String ?? "algorithmic"
+        let feedSource: FeedSource = feedSourceStr == "custom" ? .custom : .algorithmic
+
+        let carouselOverlay = parseCarouselOverlay(obj["carouselOverlay"] as? String)
+
         return FeedConfig(
             feedHeight: feedHeight,
             videoOverlay: videoOverlay,
-            carouselOverlay: .none,
+            carouselOverlay: carouselOverlay,
             surveyOverlay: .none,
             adOverlay: .none,
-            muteOnStart: muteOnStart
+            muteOnStart: muteOnStart,
+            feedSource: feedSource
         )
     }
 
@@ -451,6 +515,35 @@ import ShortKit
         return .none
     }
 
+    /// Parse a double-stringified carousel overlay JSON into a `CarouselOverlayMode`.
+    ///
+    /// Examples:
+    /// - `"\"none\""` → `.none`
+    /// - `"{\"type\":\"custom\"}"` → `.custom { ShortKitCarouselOverlayBridge() }`
+    private static func parseCarouselOverlay(_ json: String?) -> CarouselOverlayMode {
+        guard let json,
+              let data = json.data(using: .utf8),
+              let parsed = try? JSONSerialization.jsonObject(with: data) else {
+            return .none
+        }
+
+        if let str = parsed as? String, str == "none" {
+            return .none
+        }
+
+        if let obj = parsed as? [String: Any],
+           let type = obj["type"] as? String,
+           type == "custom" {
+            return .custom { @Sendable in
+                let overlay = ShortKitCarouselOverlayBridge()
+                overlay.bridge = ShortKitBridge.shared
+                return overlay
+            }
+        }
+
+        return .none
+    }
+
     /// Parse a double-stringified feedHeight JSON.
     /// e.g. `"{\"type\":\"fullscreen\"}"` or `"{\"type\":\"percentage\",\"value\":0.8}"`
     private static func parseFeedHeight(_ json: String?) -> FeedHeight {
@@ -472,6 +565,34 @@ import ShortKit
         }
     }
 
+    /// Parse a JSON string of CustomFeedItem[] from the JS bridge.
+    private static func parseCustomFeedItems(_ json: String) -> [CustomFeedItem]? {
+        guard let data = json.data(using: .utf8),
+              let arr = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else {
+            return nil
+        }
+
+        var result: [CustomFeedItem] = []
+        for obj in arr {
+            guard let type = obj["type"] as? String else { continue }
+            switch type {
+            case "video":
+                guard let playbackId = obj["playbackId"] as? String else { continue }
+                result.append(.video(playbackId: playbackId))
+            case "imageCarousel":
+                guard let itemData = obj["item"],
+                      let itemJSON = try? JSONSerialization.data(withJSONObject: itemData),
+                      let carouselItem = try? JSONDecoder().decode(ImageCarouselItem.self, from: itemJSON) else {
+                    continue
+                }
+                result.append(.imageCarousel(carouselItem))
+            default:
+                continue
+            }
+        }
+        return result.isEmpty ? nil : result
+    }
+
     /// Parse optional custom dimensions JSON string into dictionary.
     private static func parseCustomDimensions(_ json: String?) -> [String: String]? {
         guard let json,
@@ -482,3 +603,14 @@ import ShortKit
         return dict
     }
 }
+
+// MARK: - ShortKitDelegate
+
+extension ShortKitBridge: ShortKitDelegate {
+    public func shortKit(_ shortKit: ShortKit, didTapContent contentId: String, at index: Int) {
+        emitOnMain("onContentTapped", body: [
+            "contentId": contentId,
+            "index": index
+        ])
+    }
+}

package/ios/ShortKitCarouselOverlayBridge.swift

@@ -0,0 +1,54 @@
+import UIKit
+import ShortKit
+
+/// A transparent UIView that conforms to `CarouselOverlay` and bridges
+/// carousel overlay lifecycle calls to JS events via `ShortKitBridge`.
+///
+/// The actual carousel overlay UI is rendered by React Native on the JS side
+/// through the `CarouselOverlayManager` component. This view simply relays
+/// the SDK lifecycle events so the JS carousel overlay knows when to
+/// configure, activate, reset, etc.
+@objc public class ShortKitCarouselOverlayBridge: UIView, @unchecked Sendable, CarouselOverlay {
+
+    // MARK: - Bridge Reference
+
+    /// Weak reference to the bridge, set by the factory closure in `parseFeedConfig`.
+    weak var bridge: ShortKitBridge?
+
+    // MARK: - State
+
+    /// Stores the last configured ImageCarouselItem so we can pass it with
+    /// lifecycle events that don't receive the item as a parameter.
+    private var currentItem: ImageCarouselItem?
+
+    // MARK: - Init
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .clear
+        isUserInteractionEnabled = true
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) is not supported")
+    }
+
+    // MARK: - CarouselOverlay
+
+    public func configure(with item: ImageCarouselItem) {
+        currentItem = item
+        bridge?.emitCarouselOverlayEvent("onCarouselOverlayConfigure", item: item)
+    }
+
+    public func resetState() {
+        bridge?.emitCarouselOverlayEvent("onCarouselOverlayReset", body: [:])
+    }
+
+    public func fadeOutForTransition() {
+        bridge?.emitCarouselOverlayEvent("onCarouselOverlayFadeOut", body: [:])
+    }
+
+    public func restoreFromTransition() {
+        bridge?.emitCarouselOverlayEvent("onCarouselOverlayRestore", body: [:])
+    }
+}

package/ios/ShortKitFeedView.swift

@@ -27,10 +27,14 @@ import ShortKit
     // MARK: - Scroll Tracking
 
     private var scrollObservation: NSKeyValueObservation?
-    /// Overlay for the currently active cell (nativeID="overlay-current").
+    /// Video overlay for the currently active cell (nativeID="overlay-current").
     private weak var currentOverlayView: UIView?
-    /// Overlay for the upcoming cell (nativeID="overlay-next").
+    /// Video overlay for the upcoming cell (nativeID="overlay-next").
     private weak var nextOverlayView: UIView?
+    /// Carousel overlay for the currently active cell (nativeID="carousel-overlay-current").
+    private weak var currentCarouselOverlayView: UIView?
+    /// Carousel overlay for the upcoming cell (nativeID="carousel-overlay-next").
+    private weak var nextCarouselOverlayView: UIView?
     /// The page index used for overlay transform calculations.
     private var currentPage: Int = 0
     /// Deferred page update to avoid flashing stale metadata.
@@ -94,8 +98,12 @@ import ShortKit
         scrollObservation = nil
         currentOverlayView?.transform = .identity
         nextOverlayView?.transform = .identity
+        currentCarouselOverlayView?.transform = .identity
+        nextCarouselOverlayView?.transform = .identity
         currentOverlayView = nil
         nextOverlayView = nil
+        currentCarouselOverlayView = nil
+        nextCarouselOverlayView = nil
 
         guard let feedVC = feedViewController else { return }
 
@@ -150,6 +158,8 @@ import ShortKit
                     let h = self.bounds.height
                     self.currentOverlayView?.transform = .identity
                     self.nextOverlayView?.transform = CGAffineTransform(translationX: 0, y: h)
+                    self.currentCarouselOverlayView?.transform = .identity
+                    self.nextCarouselOverlayView?.transform = CGAffineTransform(translationX: 0, y: h)
                 }
                 pageUpdateWorkItem = workItem
                 DispatchQueue.main.asyncAfter(deadline: .now() + 0.08, execute: workItem)
@@ -168,17 +178,27 @@ import ShortKit
         if currentOverlayView == nil || nextOverlayView == nil {
             findOverlayViews()
         }
+        if currentCarouselOverlayView == nil || nextCarouselOverlayView == nil {
+            findCarouselOverlayViews()
+        }
+
+        let translateY = CGAffineTransform(translationX: 0, y: -delta)
 
-        // Current overlay follows the active cell
-        currentOverlayView?.transform = CGAffineTransform(translationX: 0, y: -delta)
+        // Current overlays follow the active cell
+        currentOverlayView?.transform = translateY
+        currentCarouselOverlayView?.transform = translateY
 
-        // Next overlay: positioned one page ahead in the scroll direction
+        // Next overlays: positioned one page ahead in the scroll direction
         if delta >= 0 {
             // Forward scroll (or idle): next cell is below
-            nextOverlayView?.transform = CGAffineTransform(translationX: 0, y: cellHeight - delta)
+            let nextTransform = CGAffineTransform(translationX: 0, y: cellHeight - delta)
+            nextOverlayView?.transform = nextTransform
+            nextCarouselOverlayView?.transform = nextTransform
         } else {
             // Backward scroll: next cell is above
-            nextOverlayView?.transform = CGAffineTransform(translationX: 0, y: -cellHeight - delta)
+            let nextTransform = CGAffineTransform(translationX: 0, y: -cellHeight - delta)
+            nextOverlayView?.transform = nextTransform
+            nextCarouselOverlayView?.transform = nextTransform
         }
     }
 
@@ -208,6 +228,25 @@ import ShortKit
         }
     }
 
+    /// Find the sibling RN carousel overlay views by nativeID.
+    private func findCarouselOverlayViews() {
+        var ancestor: UIView? = superview
+        while let container = ancestor {
+            for child in container.subviews {
+                guard !self.isDescendant(of: child) else { continue }
+
+                if currentCarouselOverlayView == nil {
+                    currentCarouselOverlayView = findView(withNativeID: "carousel-overlay-current", in: child)
+                }
+                if nextCarouselOverlayView == nil {
+                    nextCarouselOverlayView = findView(withNativeID: "carousel-overlay-next", in: child)
+                }
+            }
+            if currentCarouselOverlayView != nil && nextCarouselOverlayView != nil { return }
+            ancestor = container.superview
+        }
+    }
+
     /// Recursively find a view by its React Native `nativeID` prop.
     /// In Fabric, this is stored on `RCTViewComponentView.nativeId`,
     /// not `accessibilityIdentifier`.

package/ios/ShortKitModule.mm

@@ -11,6 +11,8 @@
 @implementation ShortKitModule {
   ShortKitBridge *_shortKitBridge;
   BOOL _hasListeners;
+  NSString *_pendingFeedItems;
+  NSString *_pendingAppendItems;
 }
 
 RCT_EXPORT_MODULE(ShortKitModule)
@@ -54,6 +56,7 @@ RCT_EXPORT_MODULE(ShortKitModule)
     @"onFeedTransition",
     @"onFormatChange",
     @"onPrefetchedAheadCountChanged",
+    @"onRemainingContentCountChanged",
     @"onError",
     @"onShareTapped",
     @"onSurveyResponse",
@@ -64,6 +67,7 @@ RCT_EXPORT_MODULE(ShortKitModule)
     @"onOverlayRestore",
     @"onOverlayTap",
     @"onOverlayDoubleTap",
+    @"onContentTapped",
   ];
 }
 
@@ -102,6 +106,7 @@ RCT_EXPORT_MODULE(ShortKitModule)
 
 RCT_EXPORT_METHOD(initialize:(NSString *)apiKey
                   config:(NSString *)config
+                  embedId:(NSString *)embedId
                   clientAppName:(NSString *)clientAppName
                   clientAppVersion:(NSString *)clientAppVersion
                   customDimensions:(NSString *)customDimensions) {
@@ -110,10 +115,21 @@ RCT_EXPORT_METHOD(initialize:(NSString *)apiKey
 
   _shortKitBridge = [[ShortKitBridge alloc] initWithApiKey:apiKey
                                                    config:config
+                                                  embedId:embedId
                                             clientAppName:clientAppName
                                          clientAppVersion:clientAppVersion
                                          customDimensions:customDimensions
                                                  delegate:self];
+
+  // Replay any feed items that arrived before initialization
+  if (_pendingFeedItems) {
+    [_shortKitBridge setFeedItems:_pendingFeedItems];
+    _pendingFeedItems = nil;
+  }
+  if (_pendingAppendItems) {
+    [_shortKitBridge appendFeedItems:_pendingAppendItems];
+    _pendingAppendItems = nil;
+  }
 }
 
 RCT_EXPORT_METHOD(destroy) {
@@ -187,6 +203,32 @@ RCT_EXPORT_METHOD(setMaxBitrate:(double)bitrate) {
   [_shortKitBridge setMaxBitrate:bitrate];
 }
 
+// MARK: - Custom Feed
+
+RCT_EXPORT_METHOD(setFeedItems:(NSString *)items) {
+  if (_shortKitBridge) {
+    [_shortKitBridge setFeedItems:items];
+  } else {
+    _pendingFeedItems = items;
+  }
+}
+
+RCT_EXPORT_METHOD(appendFeedItems:(NSString *)items) {
+  if (_shortKitBridge) {
+    [_shortKitBridge appendFeedItems:items];
+  } else {
+    _pendingAppendItems = items;
+  }
+}
+
+RCT_EXPORT_METHOD(fetchContent:(NSInteger)limit
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  [_shortKitBridge fetchContent:limit completion:^(NSString *json) {
+    resolve(json);
+  }];
+}
+
 // MARK: - New Architecture (TurboModule)
 
 #ifdef RCT_NEW_ARCH_ENABLED

package/ios/ShortKitOverlayBridge.swift

@@ -20,6 +20,11 @@ import ShortKit
     /// events that don't receive the item as a parameter.
     private var currentItem: ContentItem?
 
+    /// Deferred configure emission — cancelled if `activatePlayback()` fires
+    /// on the same run-loop iteration (meaning this was a handleSwipe
+    /// re-configure of the active cell, not a prefetch for the next cell).
+    private var pendingConfigureWorkItem: DispatchWorkItem?
+
     // MARK: - Init
 
     override init(frame: CGRect) {
@@ -66,7 +71,19 @@ import ShortKit
 
     public func configure(with item: ContentItem) {
         currentItem = item
-        bridge?.emitOverlayEvent("onOverlayConfigure", item: item)
+
+        // Defer the configure event by one run-loop tick. If activatePlayback()
+        // fires before then (handleSwipe sequence: configure → reset → activate),
+        // the event is cancelled — preventing nextItem from being overwritten
+        // with the current cell's data.
+        pendingConfigureWorkItem?.cancel()
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self, let item = self.currentItem else { return }
+            self.bridge?.emitOverlayEvent("onOverlayConfigure", item: item)
+            self.pendingConfigureWorkItem = nil
+        }
+        pendingConfigureWorkItem = workItem
+        DispatchQueue.main.async(execute: workItem)
     }
 
     public func resetPlaybackProgress() {
@@ -75,6 +92,11 @@ import ShortKit
     }
 
     public func activatePlayback() {
+        // Cancel the pending configure — it was for the current cell (part of
+        // handleSwipe), not a prefetch for the next cell.
+        pendingConfigureWorkItem?.cancel()
+        pendingConfigureWorkItem = nil
+
         guard let item = currentItem else { return }
         bridge?.emitOverlayEvent("onOverlayActivate", item: item)
     }