@usercentrics/react-native-sdk 2.0.4-rc1 → 2.3.0

package/android/src/main/java/com/usercentrics/reactnativeusercentrics/extensions/FirstLayerOptionsExtensions.kt

@@ -0,0 +1,161 @@
+package com.usercentrics.reactnativeusercentrics.extensions
+
+import android.content.res.AssetManager
+import android.graphics.Color
+import androidx.annotation.ColorInt
+import com.facebook.react.bridge.ReadableMap
+import com.usercentrics.sdk.*
+
+internal fun String.usercentricsLayoutFromEnumString(): UsercentricsLayout {
+    return when (this) {
+        "FULL" -> UsercentricsLayout.Full
+        "SHEET" -> UsercentricsLayout.Sheet
+        "POPUP_BOTTOM" -> UsercentricsLayout.Popup(PopupPosition.BOTTOM)
+        "POPUP_CENTER" -> UsercentricsLayout.Popup(PopupPosition.CENTER)
+        else -> throw IllegalArgumentException("Invalid layout: $this")
+    }
+}
+
+internal fun ReadableMap.bannerSettingsFromMap(assetManager: AssetManager): BannerSettings {
+    val customFont = getMap("font")
+    val customLogo = getMap("logo")
+
+    return BannerSettings(
+        customFont?.bannerFontFromMap(assetManager),
+        customLogo?.bannerLogoFromMap()
+    )
+}
+
+internal fun ReadableMap.bannerLogoFromMap(): UsercentricsImage? {
+    val logoPath = getString("logoPath") ?: return null
+    return UsercentricsImage.ImageUrl(logoPath)
+}
+
+internal fun ReadableMap.firstLayerStyleSettingsFromMap(assetManager: AssetManager): FirstLayerStyleSettings {
+    return FirstLayerStyleSettings(
+        headerImage = getMap("headerImage")?.headerImageFromMap(),
+        title = getMap("title")?.titleFromMap(assetManager),
+        message = getMap("message")?.messageFromMap(assetManager),
+        buttonLayout = getMap("buttonLayout")?.buttonLayoutFromMap(assetManager),
+        backgroundColor = getString("backgroundColorHex")?.deserializeColor(),
+        overlayColor = getString("overlayColorHex")?.deserializeColor(),
+        cornerRadius = getIntOrNull("cornerRadius")
+    )
+}
+
+internal fun ReadableMap.headerImageFromMap(): HeaderImageSettings? {
+    val isHidden = getBooleanOrNull("isHidden") ?: false
+    if (isHidden) {
+        return HeaderImageSettings.Hidden
+    }
+
+    val image = getMap("image")?.bannerLogoFromMap() ?: return null
+
+    val isExtended = getBooleanOrNull("isExtended") ?: false
+    return if (isExtended) {
+        HeaderImageSettings.ExtendedLogoSettings(image)
+    } else {
+        HeaderImageSettings.LogoSettings(
+            image = image,
+            alignment = getString("alignment")?.sectionAlignmentFromMap(),
+            heightInDp = getDoubleOrNull("height")?.toFloat()
+        )
+    }
+}
+
+internal fun ReadableMap.titleFromMap(assetManager: AssetManager): TitleSettings {
+    return TitleSettings(
+        alignment = getString("alignment")?.sectionAlignmentFromMap(),
+        textColor = getString("textColorHex")?.deserializeColor(),
+        font = assetManager.createFontFromName(getString("fontName")),
+        textSizeInSp = getDoubleOrNull("textSize")?.toFloat()
+    )
+}
+
+internal fun ReadableMap.messageFromMap(assetManager: AssetManager): MessageSettings {
+    return MessageSettings(
+        font = assetManager.createFontFromName(getString("fontName")),
+        textSizeInSp = getDoubleOrNull("textSize")?.toFloat(),
+        textColor = getString("textColorHex")?.deserializeColor(),
+        alignment = getString("alignment")?.sectionAlignmentFromMap(),
+        linkTextColor = getString("linkTextColorHex")?.deserializeColor(),
+        underlineLink = getBooleanOrNull("linkTextUnderline")
+    )
+}
+
+internal fun String.sectionAlignmentFromMap(): SectionAlignment {
+    return SectionAlignment.valueOf(this)
+}
+
+internal fun ReadableMap.buttonLayoutFromMap(
+    assetManager: AssetManager
+): ButtonLayout? {
+    val layout = getString("layout")
+    val buttons: List<List<ButtonSettings>> = getArray("buttons")?.let { buttonsArray ->
+        val buttonsList: MutableList<List<ButtonSettings>> = mutableListOf()
+
+        for (rowIndex in 0 until buttonsArray.size()) {
+            val listRow = mutableListOf<ButtonSettings>()
+            val row = buttonsArray.getArray(rowIndex)
+            for (rowElement in 0 until row.size()) {
+                val element = row.getMap(rowElement)
+                listRow.add(element.buttonSettingsFromMap(assetManager))
+            }
+            buttonsList.add(listRow)
+        }
+
+        return@let buttonsList.toList()
+    } ?: listOf()
+
+    when (layout) {
+        "ROW" -> {
+            return ButtonLayout.Row(
+                buttons.flatten()
+            )
+        }
+        "COLUMN" -> {
+            return ButtonLayout.Column(
+                buttons.flatten()
+            )
+        }
+        "GRID" -> {
+            return ButtonLayout.Grid(
+                buttons
+            )
+        }
+    }
+
+    return null
+}
+
+internal fun ReadableMap.buttonSettingsFromMap(
+    assetManager: AssetManager
+): ButtonSettings {
+  return ButtonSettings(
+        type = getString("buttonType")!!.deserializeButtonType(),
+        isAllCaps = getBooleanOrNull("isAllCaps"),
+        font = assetManager.createFontFromName(getString("fontName")),
+        textColor = getString("textColorHex")?.deserializeColor(),
+        backgroundColor = getString("backgroundColorHex")?.deserializeColor(),
+        cornerRadius = getIntOrNull("cornerRadius"),
+        textSizeInSp = getDoubleOrNull("textSize")?.toFloat()
+    )
+}
+
+internal fun String.deserializeButtonType(): ButtonType {
+    return ButtonType.valueOf(this)
+}
+
+@ColorInt
+internal fun String.deserializeColor(): Int? {
+    val colorString: String =
+        if (!this.startsWith("#")) {
+            "#$this"
+        } else {
+            this
+        }
+
+    return runCatching {
+        Color.parseColor(colorString)
+    }.getOrNull()
+}

package/android/src/main/java/com/usercentrics/reactnativeusercentrics/extensions/TCFDataExtensions.kt

@@ -93,5 +93,6 @@ private fun TCFVendor.serialize(): WritableMap {
 //        "deviceStorage" to deviceStorage.serialize(),
         "usesCookies" to usesCookies,
         "cookieRefresh" to cookieRefresh,
+        "dataSharedOutsideEU" to dataSharedOutsideEU
     ).toWritableMap()
 }

package/android/src/main/java/com/usercentrics/reactnativeusercentrics/extensions/UsercentricsReadyStatusExtensions.kt

@@ -6,7 +6,7 @@ import com.usercentrics.sdk.UsercentricsReadyStatus
 
 internal fun UsercentricsReadyStatus.toWritableMap(): WritableMap {
     return Arguments.createMap().apply {
-        putBoolean("shouldShowCMP", shouldShowCMP)
+        putBoolean("shouldCollectConsent", shouldCollectConsent)
         putArray("consents", consents.toWritableArray())
     }
 }

package/android/src/main/java/com/usercentrics/reactnativeusercentrics/extensions/UsercentricsServiceConsentExtensions.kt

@@ -1,8 +1,10 @@
 package com.usercentrics.reactnativeusercentrics.extensions
 
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
+import com.usercentrics.sdk.UsercentricsConsentHistoryEntry
 import com.usercentrics.sdk.UsercentricsServiceConsent
 
 internal fun List<UsercentricsServiceConsent>.toWritableArray(): WritableArray {
@@ -28,6 +30,25 @@ internal fun UsercentricsServiceConsent.toWritableMap(): WritableMap {
         }
         putString("version", version)
         putString("dataProcessor", dataProcessor)
+        putBoolean("isEssential", isEssential)
+        putArray("history", history.toWritableArray())
+    }
+}
+
+private fun List<UsercentricsConsentHistoryEntry>.toWritableArray(): ReadableArray? {
+    map {
+        Arguments.createMap().apply {
+            putBoolean("status", it.status)
+            putInt("type", it.type.ordinal)
+            putInt("timestampInMillis", it.timestampInMillis.toInt())
+        }
+    }.apply {
+        val array = Arguments.createArray()
+        forEach {
+            array.pushMap(it)
+        }
+
+        return array
     }
 }
 

package/ios/Extensions/BannerSettings+Dict.swift

@@ -0,0 +1,227 @@
+import Foundation
+import UsercentricsUI
+
+extension BannerSettings {
+    init?(from dictionary: NSDictionary?) {
+        guard let dictionary = dictionary else { return nil }
+
+        self.init(font: BannerFontHolder(from: dictionary["font"] as? NSDictionary)?.font,
+                  logo: UIImage(from: dictionary["logo"] as? NSDictionary))
+    }
+}
+
+struct BannerFontHolder {
+    public let font: BannerFont
+
+    public let regularFont: UIFont
+    public let boldFont: UIFont
+
+    init?(from dictionary: NSDictionary?) {
+        guard let dictionary = dictionary,
+              let regularFontName: String = dictionary["regularFont"] as? String,
+              let boldFontName: String = dictionary["boldFont"] as? String,
+              let fontSize: CGFloat = dictionary["fontSize"] as? CGFloat,
+              let regularFont = UIFont(name: regularFontName, size: fontSize),
+              let boldFont = UIFont(name: boldFontName, size: fontSize)
+        else { return nil }
+
+        self.regularFont = regularFont
+        self.boldFont = boldFont
+        self.font = .init(regularFont: regularFont, boldFont: boldFont)
+    }
+}
+
+extension UIFont {
+    static func initialize(from fontName: String?, fontSizeValue: CGFloat?, fallbackFont: UIFont?) -> UIFont? {
+        let fontSize = fontSizeValue ?? UIFont.systemFontSize
+
+        // System font with custom size
+        if fontName == nil, fontSizeValue != nil {
+            return fallbackFont?.withSize(fontSize) ?? UIFont.systemFont(ofSize: fontSize)
+        }
+
+        if let fontName = fontName {
+            return UIFont(name: fontName, size: fontSize)
+        }
+
+        return fallbackFont?.withSize(fontSize)
+    }
+}
+
+extension FirstLayerStyleSettings {
+    init?(from dictionary: NSDictionary?, bannerFontHolder: BannerFontHolder?) {
+        guard let dictionary = dictionary else { return nil }
+
+        self.init(headerImage: HeaderImageSettings.from(dictionary: dictionary["headerImage"] as? NSDictionary),
+                  title: TitleSettings(from: dictionary["title"] as? NSDictionary, fallbackFont: bannerFontHolder?.boldFont),
+                  message: MessageSettings(from: dictionary["message"] as? NSDictionary, fallbackFont: bannerFontHolder?.regularFont),
+                  buttonLayout: ButtonLayout.from(dictionary: dictionary["buttonLayout"] as? NSDictionary, fallbackFont: bannerFontHolder?.boldFont),
+                  backgroundColor: UIColor(unsafeHex: dictionary["backgroundColorHex"] as? String),
+                  cornerRadius: dictionary["cornerRadius"] as? CGFloat,
+                  overlayColor: UIColor(unsafeHex: dictionary["overlayColorHex"] as? String))
+    }
+}
+
+
+extension HeaderImageSettings {
+    static func from(dictionary: NSDictionary?) -> HeaderImageSettings? {
+        guard let dictionary = dictionary else { return nil }
+
+        if let isHidden = dictionary["isHidden"] as? Bool, isHidden {
+            return .hidden
+        }
+
+        let logoDict = dictionary["image"] as? NSDictionary
+        let logo = UIImage(from: logoDict)
+
+        if let isExtended = dictionary["isExtended"] as? Bool, isExtended {
+            return .extended(image: logo)
+        }
+
+        let logoUrlString = logoDict?["logoUrl"] as? String
+
+        return .logo(settings: LogoSettings(image: logo,
+                                            url: URL(string: logoUrlString ?? ""),
+                                            position: SectionPosition.from(enumString: dictionary["alignment"] as? String),
+                                            height: dictionary["height"] as? CGFloat))
+    }
+}
+
+extension TitleSettings {
+    init?(from dictionary: NSDictionary?, fallbackFont: UIFont? = nil) {
+        guard let dictionary = dictionary else { return nil }
+
+        let fontName: String? = dictionary["fontName"] as? String
+        let fontSize: CGFloat? = dictionary["textSize"] as? CGFloat
+
+        self.init(font: UIFont.initialize(from: fontName, fontSizeValue: fontSize, fallbackFont: fallbackFont),
+                  textColor: UIColor(unsafeHex: dictionary["textColorHex"] as? String ?? ""),
+                  textAlignment: NSTextAlignment.from(enumString: dictionary["textAlignment"] as? String))
+    }
+}
+
+
+extension MessageSettings {
+    init?(from dictionary: NSDictionary?, fallbackFont: UIFont? = nil) {
+        guard let dictionary = dictionary else { return nil }
+
+        let fontName: String? = dictionary["fontName"] as? String
+        let textSize: CGFloat? = dictionary["textSize"] as? CGFloat
+
+        self.init(font: UIFont.initialize(from: fontName, fontSizeValue: textSize, fallbackFont: fallbackFont),
+                  textColor: UIColor(unsafeHex: dictionary["textColorHex"] as? String ?? ""),
+                  textAlignment: NSTextAlignment.from(enumString: dictionary["textAlignment"] as? String),
+                  linkTextColor: UIColor(unsafeHex: dictionary["linkTextColorHex"] as? String ?? ""),
+                  linkTextUnderline: dictionary["linkTextUnderline"] as? Bool ?? true)
+    }
+}
+
+extension ButtonLayout {
+    static func from(dictionary: NSDictionary?, fallbackFont: UIFont? = nil) -> ButtonLayout? {
+        guard let dictionary = dictionary else { return nil }
+
+        let layoutDict = dictionary["layout"] as? String
+        let buttons = (dictionary["buttons"] as? [[NSDictionary]]) ?? []
+
+        switch layoutDict {
+            case "ROW":
+                return .row(buttons: buttons.flatMap { $0 }.compactMap { ButtonSettings(from: $0, fallbackFont: fallbackFont) })
+            case "COLUMN":
+                return .column(buttons: buttons.flatMap { $0 }.compactMap { ButtonSettings(from: $0, fallbackFont: fallbackFont) })
+            case "GRID":
+                let gridButtons = buttons.map { $0.compactMap { button in ButtonSettings(from: button, fallbackFont: fallbackFont) }}
+                return .grid(buttons: gridButtons)
+            default:
+                break
+        }
+        
+        return nil
+    }
+}
+
+extension ButtonSettings {
+    init?(from dictionary: NSDictionary?, fallbackFont: UIFont? = nil) {
+        guard
+            let dictionary = dictionary,
+            let buttonTypeDict = dictionary["buttonType"] as? String,
+            let buttonType = ButtonType.from(enumString: buttonTypeDict)
+        else { return nil }
+
+        let fontName: String? = dictionary["fontName"] as? String
+        let textSize: CGFloat? = dictionary["textSize"] as? CGFloat
+
+        self.init(type: buttonType,
+                  font: UIFont.initialize(from: fontName, fontSizeValue: textSize, fallbackFont: fallbackFont),
+                  textColor: UIColor(unsafeHex: dictionary["textColorHex"] as? String),
+                  backgroundColor: UIColor(unsafeHex: dictionary["backgroundColorHex"] as? String),
+                  cornerRadius: dictionary["cornerRadius"] as? CGFloat)
+    }
+}
+
+extension ButtonType {
+    static func from(enumString: String) -> ButtonType? {
+        switch enumString {
+            case "ACCEPT_ALL":
+                return .acceptAll
+            case "DENY_ALL":
+                return .denyAll
+            case "MORE":
+                return .more
+            case "SAVE":
+                return .save
+            default:
+                return nil
+        }
+    }
+}
+
+extension UsercentricsLayout {
+    static func from(enumString: String) -> UsercentricsLayout? {
+        switch enumString {
+            case "FULL":
+                return .full
+            case "SHEET":
+                return .sheet
+            case "POPUP_CENTER":
+                return .popup(position: .center)
+            case "POPUP_BOTTOM":
+                return .popup(position: .bottom)
+            default:
+                return nil
+        }
+    }
+}
+
+extension SectionPosition {
+    static func from(enumString: String?) -> SectionPosition? {
+        guard let enumString = enumString else { return nil }
+
+        switch enumString {
+            case "CENTER":
+                return .center
+            case "END":
+                return .right
+            case "START":
+                return .left
+            default:
+                return nil
+        }
+    }
+}
+
+extension NSTextAlignment {
+    static func from(enumString: String?) -> NSTextAlignment? {
+        guard let enumString = enumString else { return nil }
+
+        switch enumString {
+            case "CENTER":
+                return .center
+            case "RIGHT":
+                return .right
+            case "LEFT":
+                return .left
+            default:
+                return nil
+        }
+    }
+}

package/ios/Extensions/ReadyStatus+Dict.swift

@@ -4,7 +4,7 @@ import Usercentrics
 public extension UsercentricsReadyStatus {
     func toDictionary() -> NSDictionary {
         return [
-            "shouldShowCMP": self.shouldShowCMP,
+            "shouldCollectConsent": self.shouldCollectConsent,
             "consents": self.consents.toListOfDictionary()
         ]
     }

package/ios/Extensions/TCFData+Dict.swift

@@ -102,7 +102,8 @@ extension TCFVendor {
             "usesNonCookieAccess" : usesNonCookieAccess,
             "deviceStorageDisclosureUrl" : deviceStorageDisclosureUrl  as Any,
             "usesCookies" : usesCookies,
-            "cookieRefresh" : cookieRefresh?.boolValue as Any ,
+            "cookieRefresh" : cookieRefresh?.boolValue as Any,
+            "dataSharedOutsideEU": dataSharedOutsideEU?.boolValue as Any
         ]
     }
 }

package/ios/Extensions/UIColor+Extensions.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+extension UIColor {
+    convenience init?(unsafeHex: String?) {
+        guard let unsafeHex = unsafeHex else { return nil }
+        if unsafeHex.hasPrefix("#") {
+            self.init(hex: unsafeHex)
+        } else {
+            self.init(hex: "#\(unsafeHex)")
+        }
+    }
+
+    convenience init?(hex: String) {
+        let r, g, b, a: CGFloat
+
+        if hex.hasPrefix("#") {
+            let start = hex.index(hex.startIndex, offsetBy: 1)
+            let hexColor = String(hex[start...])
+
+            if hexColor.count == 8 {
+                let scanner = Scanner(string: hexColor)
+                var hexNumber: UInt64 = 0
+
+                if scanner.scanHexInt64(&hexNumber) {
+                    r = CGFloat((hexNumber & 0xff000000) >> 24) / 255
+                    g = CGFloat((hexNumber & 0x00ff0000) >> 16) / 255
+                    b = CGFloat((hexNumber & 0x0000ff00) >> 8) / 255
+                    a = CGFloat(hexNumber & 0x000000ff) / 255
+
+                    self.init(red: r, green: g, blue: b, alpha: a)
+                    return
+                }
+            }
+
+            if hexColor.count == 6 {
+                let scanner = Scanner(string: hexColor)
+                var hexNumber: UInt64 = 0
+
+                if scanner.scanHexInt64(&hexNumber) {
+                    r = CGFloat((hexNumber & 0xff0000) >> 16) / 255
+                    g = CGFloat((hexNumber & 0x00ff00) >> 8) / 255
+                    b = CGFloat(hexNumber & 0x0000ff) / 255
+
+                    self.init(red: r, green: g, blue: b, alpha: 1.0)
+                    return
+                }
+            }
+        }
+
+        return nil
+    }
+}

package/ios/Extensions/UIImage+UsercentricsLogoDict.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+extension UIImage {
+    convenience init?(from dictionary: NSDictionary?) {
+        guard
+            let dictionary = dictionary,
+            let logoName = dictionary["logoName"] as? String
+        else {
+            return nil
+        }
+
+        self.init(named: logoName)
+    }
+}

package/ios/Extensions/UsercentricsCMPData+Dict.swift

@@ -22,7 +22,7 @@ extension UsercentricsSettings {
             "displayOnlyForEU" : self.displayOnlyForEU,
             "urlConsentInfo" : self.urlConsentInfo,
             "updatedAt" : self.updatedAt as Any,
-            "secondLayer" : self.secondLayer?.toDictionary() as Any,
+            "secondLayer" : self.secondLayer.toDictionary() as Any,
             "cookiePolicyUrl": self.cookiePolicyUrl as Any,
             "tcf2": self.tcf2?.toDictionary() as Any,
             "ccpa": self.ccpa?.toDictionary() as Any,

package/ios/Extensions/UsercentricsServiceConsents+Dict.swift

@@ -14,6 +14,8 @@ public extension UsercentricsServiceConsent {
             "status": self.status,
             "version": self.version,
             "dataProcessor": self.dataProcessor,
+            "isEssential": self.isEssential,
+            "history": self.history.toDictionary()
         ]
 
         if let type = self.type?.ordinal {
@@ -23,3 +25,15 @@ public extension UsercentricsServiceConsent {
         return dict
     }
 }
+
+public extension Array where Element == UsercentricsConsentHistoryEntry {
+    func toDictionary() -> [NSDictionary] {
+        self.map {
+            [
+                "status": $0.status,
+                "type": $0.type.ordinal,
+                "timestampInMillis": $0.timestampInMillis
+            ]
+        }
+    }
+}

package/ios/Manager/UsercentricsManager.swift

@@ -8,7 +8,17 @@ public protocol UsercentricsManager {
     func isReady(onSuccess: @escaping ((UsercentricsReadyStatus) -> Void), onFailure: @escaping ((Error) -> Void))
     func restoreUserSession(controllerId: String, onSuccess: @escaping ((UsercentricsReadyStatus) -> Void), onFailure: @escaping ((Error) -> Void))
 
-    func getPredefinedUI(settings: UsercentricsUISettings?, dismissViewHandler: @escaping (UsercentricsConsentUserResponse) -> Void) -> UIViewController
+    func showFirstLayer(bannerSettings: BannerSettings?,
+                        hostView: UIViewController,
+                        layout: UsercentricsLayout,
+                        settings: FirstLayerStyleSettings?,
+                        dismissViewHandler: @escaping (UsercentricsConsentUserResponse) -> Void)
+
+    func showSecondLayer(bannerSettings: BannerSettings?,
+                         hostView: UIViewController,
+                         showCloseButton: Bool,
+                         dismissViewHandler: @escaping (UsercentricsConsentUserResponse) -> Void)
+
     func getTCString() -> String
     func getControllerId() -> String
     func getConsents() -> [UsercentricsServiceConsent]
@@ -59,8 +69,24 @@ final class UsercentricsManagerImplementation: UsercentricsManager {
         UsercentricsCore.reset()
     }
 
-    func getPredefinedUI(settings: UsercentricsUISettings?, dismissViewHandler: @escaping (UsercentricsConsentUserResponse) -> Void) -> UIViewController {
-        return UsercentricsUserInterface.getPredefinedUI(settings: settings, dismissViewHandler: dismissViewHandler)
+    func showFirstLayer(bannerSettings: BannerSettings?,
+                        hostView: UIViewController,
+                        layout: UsercentricsLayout,
+                        settings: FirstLayerStyleSettings?,
+                        dismissViewHandler: @escaping (UsercentricsConsentUserResponse) -> Void) {
+        UsercentricsBanner(bannerSettings: bannerSettings).showFirstLayer(hostView: hostView,
+                                                                          layout: layout,
+                                                                          settings: settings,
+                                                                          completionHandler: dismissViewHandler)
+    }
+
+    func showSecondLayer(bannerSettings: BannerSettings?,
+                         hostView: UIViewController,
+                         showCloseButton: Bool,
+                         dismissViewHandler: @escaping (UsercentricsConsentUserResponse) -> Void) {
+        UsercentricsBanner(bannerSettings: bannerSettings).showSecondLayer(hostView: hostView,
+                                                                           showCloseButton: showCloseButton,
+                                                                           completionHandler: dismissViewHandler)
     }
 
     func restoreUserSession(controllerId: String, onSuccess: @escaping ((UsercentricsReadyStatus) -> Void), onFailure: @escaping ((Error) -> Void)) {

package/ios/RNUsercentricsModule.m

@@ -14,6 +14,14 @@ RCT_EXTERN_METHOD(showCMP:(NSDictionary *)dict
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(showFirstLayer:(NSDictionary *)dict
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(showSecondLayer:(NSDictionary *)dict
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(restoreUserSession:(NSString *)controllerId
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)