@react-native-kakao/share 3.1.0-next.0 → 3.1.0-next.1

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 3.1.0-next.1
+
+### Minor Changes
+
+- d117308: Add local image uploads on Android, iOS, and web with image metadata and secure URL options.
+- 483fd00: Add URL scrap messages to My Chatroom and friends on Android, iOS, and web.
+- bf027c0: Add URL-scraped message sharing with custom template arguments and native browser fallback on Android, iOS, and web.
+- ff35f20: Expose native URL builders for default, custom, and scraped-page sharing without launching a sharing interface. Report unsupported URL building explicitly on web.
+  
+  Encode Android template execution-parameter keys and values before the SDK serializes them, preserving special characters across sharing URLs, sharing, and message sending.
+- 1efca29: Expose Kakao Talk sharing availability and Kakao Navi installation checks on Android and iOS, with explicit false results on web.
+- ceafbcf: Add optional friend message results with successful recipients and failure details on Android, iOS, and web.
+- 314d493: Expose validated share target picker settings across native and web share templates.
+- 18df9b3: Expose native sharing template warnings and argument diagnostics without opening a sharing interface. Normalize missing diagnostic maps to empty objects and reject the unsupported API explicitly on web.
+
+### Patch Changes
+
+- 61c270a: Remove unused React Native module dependencies so Channel, Social, and Share can each be installed with Core alone. Declare Share's Android Talk SDK dependency directly.
+- Updated dependencies [d5c5fb8]
+- Updated dependencies [3027207]
+- Updated dependencies [dfd32ca]
+- Updated dependencies [2b223bf]
+- Updated dependencies [67cd4e2]
+- Updated dependencies [d81f9b7]
+  - @react-native-kakao/core@3.1.0-next.1
+
 ## 3.1.0-next.0
 
 ### Minor Changes

package/RNCKakaoShare.podspec

@@ -28,7 +28,6 @@ Pod::Spec.new do |s|
   end
 
   s.dependency          'RNCKakaoCore'
-  s.dependency          'RNCKakaoSocial'
 
   # Kakao dependencies
   RNCKakaoSPM.dependency(s, sdk_version, %w[KakaoSDKCommon KakaoSDKAuth KakaoSDKUser KakaoSDKTemplate KakaoSDKTalk KakaoSDKShare])

package/android/build.gradle

@@ -1,7 +1,6 @@
 apply from: file('./../../core/android/package-json.gradle')
 def Versions = project.ext.RNCKakaoSdkVersions
 Project coreProject = project.ext.getWorkspaceProject("core")
-Project socialProject = project.ext.getWorkspaceProject("social")
 
 project.ext.applyPlugins()
 
@@ -40,6 +39,6 @@ dependencies {
     implementation "com.facebook.react:react-android"
 
     api coreProject
-    api socialProject
     implementation "com.kakao.sdk:v2-share:${Versions.share}"
+    implementation "com.kakao.sdk:v2-talk:${Versions.talk}"
 }

package/android/src/main/java/net/mjstudio/rnkakao/share/RNCKakaoShareModule.kt

@@ -1,6 +1,8 @@
 package net.mjstudio.rnkakao.share
 
 import android.content.ActivityNotFoundException
+import android.net.Uri
+import android.util.Base64
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
@@ -9,6 +11,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.kakao.sdk.common.util.KakaoCustomTabsClient
 import com.kakao.sdk.share.ShareClient
 import com.kakao.sdk.share.WebSharerClient
+import com.kakao.sdk.share.model.ShareType
 import com.kakao.sdk.share.model.SharingResult
 import com.kakao.sdk.talk.TalkApiClient
 import com.kakao.sdk.talk.model.MessageSendResult
@@ -23,10 +26,221 @@ import net.mjstudio.rnkakao.core.util.onMain
 import net.mjstudio.rnkakao.core.util.pushStringList
 import net.mjstudio.rnkakao.core.util.rejectWith
 import net.mjstudio.rnkakao.core.util.toStringMap
+import java.io.File
+import kotlin.concurrent.thread
+
+private const val NO_CUSTOM_TEMPLATE_ID = -1.0
 
 class RNCKakaoShareModule internal constructor(
   context: ReactApplicationContext,
 ) : NativeKakaoShareSpec(context) {
+  @ReactMethod
+  override fun isKakaoTalkSharingAvailable(promise: Promise) =
+    onMain {
+      promise.resolve(ShareClient.instance.isKakaoTalkSharingAvailable(reactApplicationContext))
+    }
+
+  @ReactMethod
+  override fun makeTemplateUrl(
+    templateType: String,
+    templateId: Double,
+    templateJson: ReadableMap,
+    templateArgs: ReadableMap,
+    serverCallbackArgs: ReadableMap,
+    promise: Promise,
+  ) = onMain {
+    runCatching {
+      val args = templateArgs.toStringMap()
+      val callbacks = serverCallbackArgs.toStringMap()
+      val url =
+        when (templateType) {
+          "custom" -> {
+            WebSharerClient.instance.makeCustomUrl(templateId.toLong(), args, callbacks)
+          }
+
+          "scrap" -> {
+            WebSharerClient.instance.makeScrapUrl(
+              requireNotNull(templateJson.getString("requestUrl")) { "requestUrl is required" },
+              templateId.takeUnless { it == NO_CUSTOM_TEMPLATE_ID }?.toLong(),
+              args,
+              callbacks,
+            )
+          }
+
+          else -> {
+            WebSharerClient.instance.makeDefaultUrl(
+              RNCKakaoShareTemplates.createDefaultTemplate(templateJson, templateType),
+              callbacks,
+            )
+          }
+        }
+      url.toString()
+    }.onSuccess { promise.resolve(it) }.onFailure { promise.rejectWith(it) }
+  }
+
+  @ReactMethod
+  override fun getTemplateDiagnostics(
+    templateType: String,
+    templateId: Double,
+    templateJson: ReadableMap,
+    templateArgs: ReadableMap,
+    serverCallbackArgs: ReadableMap,
+    pickerSettings: ReadableMap?,
+    promise: Promise,
+  ) = onMain {
+    runCatching {
+      val requestUrl =
+        if (templateType == "scrap") {
+          requireNotNull(templateJson.getString("requestUrl")) { "requestUrl is required" }
+        } else {
+          null
+        }
+      runShare(
+        templateType = templateType,
+        templateId = templateId.takeUnless { templateType != "custom" && it == NO_CUSTOM_TEMPLATE_ID },
+        defaultTemplate = templateJson,
+        useWebBrowserIfKakaoTalkNotAvailable = false,
+        templateArgs = templateArgs,
+        serverCallbackArgs = serverCallbackArgs,
+        pickerSettings = pickerSettings,
+        promise = promise,
+        requestUrl = requestUrl,
+        diagnosticsOnly = true,
+      )
+    }.onFailure { promise.rejectWith(it) }
+  }
+
+  @ReactMethod
+  override fun uploadImage(
+    imageUri: String,
+    secureResource: Boolean,
+    promise: Promise,
+  ) {
+    thread {
+      var temporaryFile: File? = null
+      try {
+        val maxImageBytes = 5 * 1024 * 1024
+        val imageSizeError = "Image must be no larger than 5 MB"
+
+        fun createTemporaryImageFile(): File =
+          File.createTempFile("kakao-share-image-", ".tmp", reactApplicationContext.cacheDir).also {
+            temporaryFile = it
+          }
+        val uri = Uri.parse(imageUri)
+        val file =
+          when (uri.scheme) {
+            null -> {
+              File(imageUri)
+            }
+
+            "file" -> {
+              File(requireNotNull(uri.path))
+            }
+
+            "content" -> {
+              val copiedFile = createTemporaryImageFile()
+              requireNotNull(reactApplicationContext.contentResolver.openInputStream(uri)).use { input ->
+                copiedFile.outputStream().use { output ->
+                  val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+                  var total = 0
+                  var count = input.read(buffer)
+                  while (count != -1) {
+                    total += count
+                    require(total <= maxImageBytes) { imageSizeError }
+                    output.write(buffer, 0, count)
+                    count = input.read(buffer)
+                  }
+                }
+              }
+              copiedFile
+            }
+
+            "data" -> {
+              require(imageUri.startsWith("data:image/") && imageUri.substringBefore(',').endsWith(";base64")) {
+                "Expected a base64 image data URI"
+              }
+              val maxEncodedImageLength = ((maxImageBytes + 2) / 3) * 4
+              val encodedImage =
+                buildString {
+                  for (index in imageUri.indexOf(',') + 1 until imageUri.length) {
+                    val character = imageUri[index]
+                    if (!character.isWhitespace()) {
+                      require(length < maxEncodedImageLength) { imageSizeError }
+                      append(character)
+                    }
+                  }
+                }
+              val bytes = Base64.decode(encodedImage, Base64.DEFAULT)
+              require(bytes.size <= maxImageBytes) { imageSizeError }
+              val decodedFile = createTemporaryImageFile()
+              decodedFile.writeBytes(bytes)
+              decodedFile
+            }
+
+            else -> {
+              throw IllegalArgumentException("Expected a local file, content, or base64 image data URI")
+            }
+          }
+        require(file.isFile && file.canRead()) { "Image file cannot be read" }
+        require(file.length() <= maxImageBytes) { imageSizeError }
+        ShareClient.instance.uploadImage(file, secureResource) { result, error ->
+          temporaryFile?.delete()
+          if (error != null) {
+            promise.rejectWith(error)
+          } else if (result != null) {
+            val original = result.infos.original
+            promise.resolve(
+              argMap().apply {
+                putMap(
+                  "infos",
+                  argMap().apply {
+                    putMap(
+                      "original",
+                      argMap().apply {
+                        putString("url", original.url)
+                        putString("contentType", original.contentType)
+                        putDouble("length", original.length.toDouble())
+                        putDouble("width", original.width.toDouble())
+                        putDouble("height", original.height.toDouble())
+                      },
+                    )
+                  },
+                )
+              },
+            )
+          } else {
+            promise.rejectWith(RNCKakaoResponseNotFoundException("imageUploadResult"))
+          }
+        }
+      } catch (error: Exception) {
+        temporaryFile?.delete()
+        promise.rejectWith(error)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun shareScrapTemplate(
+    requestUrl: String,
+    useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+    templateId: Double?,
+    templateArgs: ReadableMap?,
+    serverCallbackArgs: ReadableMap?,
+    pickerSettings: ReadableMap?,
+    promise: Promise,
+  ) = onMain {
+    runShare(
+      templateType = "scrap",
+      templateId = templateId,
+      useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+      templateArgs = templateArgs,
+      serverCallbackArgs = serverCallbackArgs,
+      pickerSettings = pickerSettings,
+      requestUrl = requestUrl,
+      promise = promise,
+    )
+  }
+
   @ReactMethod
   override fun scrapImage(
     imageUrl: String,
@@ -73,6 +287,7 @@ class RNCKakaoShareModule internal constructor(
     useWebBrowserIfKakaoTalkNotAvailable: Boolean,
     templateArgs: ReadableMap,
     serverCallbackArgs: ReadableMap,
+    pickerSettings: ReadableMap?,
     promise: Promise,
   ) = onMain {
     if (templateType == "custom") {
@@ -84,8 +299,36 @@ class RNCKakaoShareModule internal constructor(
         useWebBrowserIfKakaoTalkNotAvailable,
         templateArgs,
         serverCallbackArgs,
+        pickerSettings,
         promise,
       )
+    } else if (templateType == "scrap") {
+      val requestUrl = templateJson.toHashMap()["requestUrl"] as? String
+      if (requestUrl == null) {
+        promise.rejectWith(RNCKakaoUnknownException("requestUrl is required for scrap messages"))
+        return@onMain
+      }
+      val customTemplateId = templateId.takeUnless { it == NO_CUSTOM_TEMPLATE_ID }
+      when (sendType) {
+        "send-me" -> {
+          runSendToMe(templateType, customTemplateId, templateArgs = templateArgs, promise = promise, requestUrl = requestUrl)
+        }
+
+        "send-friend" -> {
+          runSendToFriends(
+            templateType,
+            receiverUuids.filterIsInstance<String>(),
+            customTemplateId,
+            templateArgs = templateArgs,
+            promise = promise,
+            requestUrl = requestUrl,
+          )
+        }
+
+        else -> {
+          promise.rejectWith(RNCKakaoUnknownException("Unknown sendType for scrap messages: $sendType"))
+        }
+      }
     } else {
       shareOrSendDefaultTemplate(
         sendType,
@@ -94,6 +337,7 @@ class RNCKakaoShareModule internal constructor(
         receiverUuids = receiverUuids.filterIsInstance<String>(),
         useWebBrowserIfKakaoTalkNotAvailable,
         serverCallbackArgs,
+        pickerSettings,
         promise,
       )
     }
@@ -107,6 +351,7 @@ class RNCKakaoShareModule internal constructor(
     useWebBrowserIfKakaoTalkNotAvailable: Boolean,
     templateArgs: ReadableMap?,
     serverCallbackArgs: ReadableMap?,
+    pickerSettings: ReadableMap?,
     promise: Promise,
   ) = when (sendType) {
     "share" -> {
@@ -117,6 +362,7 @@ class RNCKakaoShareModule internal constructor(
         useWebBrowserIfKakaoTalkNotAvailable,
         templateArgs,
         serverCallbackArgs,
+        pickerSettings,
         promise,
       )
     }
@@ -141,6 +387,7 @@ class RNCKakaoShareModule internal constructor(
     receiverUuids: List<String>,
     useWebBrowserIfKakaoTalkNotAvailable: Boolean,
     serverCallbackArgs: ReadableMap?,
+    pickerSettings: ReadableMap?,
     promise: Promise,
   ) = when (sendType) {
     "share" -> {
@@ -151,6 +398,7 @@ class RNCKakaoShareModule internal constructor(
         useWebBrowserIfKakaoTalkNotAvailable,
         argMap(),
         serverCallbackArgs,
+        pickerSettings,
         promise,
       )
     }
@@ -174,6 +422,7 @@ class RNCKakaoShareModule internal constructor(
     defaultTemplate: ReadableMap? = null,
     templateArgs: ReadableMap? = null,
     promise: Promise,
+    requestUrl: String? = null,
   ) {
     val callback = { e: Throwable? ->
       if (e != null) {
@@ -182,7 +431,9 @@ class RNCKakaoShareModule internal constructor(
         promise.resolve(42)
       }
     }
-    if (templateId != null) {
+    if (requestUrl != null) {
+      TalkApiClient.instance.sendScrapMemo(requestUrl, templateId?.toLong(), templateArgs?.toStringMap(), callback)
+    } else if (templateId != null) {
       TalkApiClient.instance.sendCustomMemo(templateId.toLong(), templateArgs?.toStringMap(), callback)
     } else if (defaultTemplate != null) {
       runCatching {
@@ -203,6 +454,7 @@ class RNCKakaoShareModule internal constructor(
     defaultTemplate: ReadableMap? = null,
     templateArgs: ReadableMap? = null,
     promise: Promise,
+    requestUrl: String? = null,
   ) {
     val callback = { messageSendResult: MessageSendResult?, e: Throwable? ->
       if (e != null) {
@@ -210,10 +462,30 @@ class RNCKakaoShareModule internal constructor(
       } else if (messageSendResult == null) {
         promise.rejectWith(RNCKakaoResponseNotFoundException("messageSendResult"))
       } else {
-        promise.resolve(argArr().pushStringList(messageSendResult.successfulReceiverUuids ?: listOf()))
+        promise.resolve(
+          argMap().apply {
+            putArray("successfulReceiverUuids", argArr().pushStringList(messageSendResult.successfulReceiverUuids ?: listOf()))
+            putArray(
+              "failureInfos",
+              argArr().apply {
+                messageSendResult.failureInfos?.forEach { failure ->
+                  pushMap(
+                    argMap().apply {
+                      putInt("code", failure.code)
+                      putString("msg", failure.msg)
+                      putArray("receiverUuids", argArr().pushStringList(failure.receiverUuids))
+                    },
+                  )
+                }
+              },
+            )
+          },
+        )
       }
     }
-    if (templateId != null) {
+    if (requestUrl != null) {
+      TalkApiClient.instance.sendScrapMessage(receiverUuids, requestUrl, templateId?.toLong(), templateArgs?.toStringMap(), callback)
+    } else if (templateId != null) {
       TalkApiClient.instance.sendCustomMessage(receiverUuids, templateId.toLong(), templateArgs?.toStringMap(), callback)
     } else if (defaultTemplate != null) {
       runCatching {
@@ -235,32 +507,63 @@ class RNCKakaoShareModule internal constructor(
     useWebBrowserIfKakaoTalkNotAvailable: Boolean,
     templateArgs: ReadableMap? = null,
     serverCallbackArgs: ReadableMap? = null,
+    pickerSettings: ReadableMap?,
     promise: Promise,
+    requestUrl: String? = null,
+    diagnosticsOnly: Boolean = false,
   ) {
-    val context = reactApplicationContext.currentActivity
+    val context = if (diagnosticsOnly) reactApplicationContext else reactApplicationContext.currentActivity
     if (context == null) {
       promise.rejectWith(ActivityNotFoundException())
       return
     }
 
+    val result = if (requestUrl != null) null else 42
     val callback = { sharingResult: SharingResult?, error: Throwable? ->
       if (error != null) {
         promise.rejectWith(error)
       } else if (sharingResult != null) {
-        context.startActivity(sharingResult.intent)
-        promise.resolve(42)
+        if (diagnosticsOnly) {
+          promise.resolve(
+            argMap().apply {
+              putMap("warningMsg", argMap().apply { sharingResult.warningMsg.forEach { (key, value) -> putString(key, value) } })
+              putMap("argumentMsg", argMap().apply { sharingResult.argumentMsg.forEach { (key, value) -> putString(key, value) } })
+            },
+          )
+        } else {
+          context.startActivity(sharingResult.intent)
+          promise.resolve(result)
+        }
+      } else if (diagnosticsOnly || requestUrl != null) {
+        promise.rejectWith(RNCKakaoResponseNotFoundException("sharingResult"))
       } else {
-        promise.resolve(42)
+        promise.resolve(result)
       }
     }
 
     if (ShareClient.instance.isKakaoTalkSharingAvailable(context)) {
-      if (templateId != null) {
+      val pickerType = pickerSettings?.takeIf { it.hasKey("type") }?.getString("type")
+      val shareType = ShareType.entries.firstOrNull { it.value == pickerType }
+      val limit = pickerSettings?.takeIf { it.hasKey("limit") }?.getDouble("limit")?.toInt()
+      if (requestUrl != null) {
+        ShareClient.instance.shareScrap(
+          context,
+          requestUrl,
+          templateId = templateId?.toLong(),
+          templateArgs = templateArgs?.toStringMap(),
+          serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+          shareType = shareType,
+          limit = limit,
+          callback = callback,
+        )
+      } else if (templateId != null) {
         ShareClient.instance.shareCustom(
           context,
           templateId.toLong(),
           templateArgs = templateArgs?.toStringMap(),
           serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+          shareType = shareType,
+          limit = limit,
           callback = callback,
         )
       } else if (defaultTemplate != null) {
@@ -269,6 +572,8 @@ class RNCKakaoShareModule internal constructor(
             context,
             RNCKakaoShareTemplates.createDefaultTemplate(defaultTemplate, templateType),
             serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+            shareType = shareType,
+            limit = limit,
             callback = callback,
           )
         }.onFailure {
@@ -278,7 +583,14 @@ class RNCKakaoShareModule internal constructor(
     } else if (useWebBrowserIfKakaoTalkNotAvailable) {
       runCatching {
         val sharerUrl =
-          if (templateId != null) {
+          if (requestUrl != null) {
+            WebSharerClient.instance.makeScrapUrl(
+              requestUrl,
+              templateId = templateId?.toLong(),
+              templateArgs = templateArgs?.toStringMap(),
+              serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+            )
+          } else if (templateId != null) {
             WebSharerClient.instance.makeCustomUrl(
               templateId.toLong(),
               templateArgs = templateArgs?.toStringMap(),
@@ -297,13 +609,13 @@ class RNCKakaoShareModule internal constructor(
           }
         try {
           KakaoCustomTabsClient.openWithDefault(context, sharerUrl)
-          promise.resolve(42)
+          promise.resolve(result)
           return
         } catch (_: UnsupportedOperationException) {
         }
         try {
           KakaoCustomTabsClient.open(context, sharerUrl)
-          promise.resolve(42)
+          promise.resolve(result)
           return
         } catch (_: ActivityNotFoundException) {
         }

package/android/src/main/java/net/mjstudio/rnkakao/share/RNCKakaoShareTemplates.kt

@@ -1,5 +1,6 @@
 package net.mjstudio.rnkakao.share
 
+import android.net.Uri
 import com.facebook.react.bridge.ReadableMap
 import com.kakao.sdk.template.model.Button
 import com.kakao.sdk.template.model.CalendarTemplate
@@ -41,10 +42,12 @@ object RNCKakaoShareTemplates {
     Link(
       webUrl = getString("webUrl"),
       mobileWebUrl = getString("mobileWebUrl"),
-      androidExecutionParams = getMap("androidExecutionParams")?.toStringMap(),
-      iosExecutionParams = getMap("iosExecutionParams")?.toStringMap(),
+      androidExecutionParams = getMap("androidExecutionParams")?.toExecutionParams(),
+      iosExecutionParams = getMap("iosExecutionParams")?.toExecutionParams(),
     )
 
+  private fun ReadableMap.toExecutionParams() = toStringMap().entries.associate { (key, value) -> Uri.encode(key) to Uri.encode(value) }
+
   private fun ReadableMap.toContent() =
     Content(
       title = getString("title"),

package/ios/RNCKakaoShare.mm

@@ -13,6 +13,63 @@
 
 RCT_EXPORT_MODULE()
 
+RCT_EXPORT_METHOD(isKakaoTalkSharingAvailable : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] isKakaoTalkSharingAvailable:resolve];
+}
+
+RCT_EXPORT_METHOD(makeTemplateUrl : (NSString*)templateType templateId : (
+    double)templateId templateJson : (NSDictionary*)templateJson templateArgs : (NSDictionary*)
+                      templateArgs serverCallbackArgs : (NSDictionary*)
+                          serverCallbackArgs resolve : (RCTPromiseResolveBlock)
+                              resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] makeTemplateUrl:templateType
+                       templateId:templateId
+                     templateJson:templateJson
+                     templateArgs:templateArgs
+               serverCallbackArgs:serverCallbackArgs
+                          resolve:resolve
+                           reject:reject];
+}
+
+RCT_EXPORT_METHOD(uploadImage : (NSString*)imageUri secureResource : (BOOL)
+                      secureResource resolve : (RCTPromiseResolveBlock)
+                          resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] uploadImage:imageUri secureResource:secureResource resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(getTemplateDiagnostics : (NSString*)templateType templateId : (
+    double)templateId templateJson : (NSDictionary*)templateJson templateArgs : (NSDictionary*)
+                      templateArgs serverCallbackArgs : (NSDictionary*)
+                          serverCallbackArgs pickerSettings : (NSDictionary*)
+                              pickerSettings resolve : (RCTPromiseResolveBlock)
+                                  resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] getTemplateDiagnostics:templateType
+                              templateId:templateId
+                            templateJson:templateJson
+                            templateArgs:templateArgs
+                      serverCallbackArgs:serverCallbackArgs
+                          pickerSettings:pickerSettings
+                                 resolve:resolve
+                                  reject:reject];
+}
+
+RCT_EXPORT_METHOD(
+    shareScrapTemplate : (NSString*)requestUrl useWebBrowserIfKakaoTalkNotAvailable : (BOOL)
+        useWebBrowserIfKakaoTalkNotAvailable templateId : (NSNumber*)templateId templateArgs : (
+            NSDictionary*)templateArgs serverCallbackArgs : (NSDictionary*)
+            serverCallbackArgs pickerSettings : (NSDictionary*)pickerSettings resolve : (
+                RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] shareScrapTemplate:requestUrl
+      useWebBrowserIfKakaoTalkNotAvailable:useWebBrowserIfKakaoTalkNotAvailable
+                                templateId:templateId
+                              templateArgs:templateArgs
+                        serverCallbackArgs:serverCallbackArgs
+                            pickerSettings:pickerSettings
+                                   resolve:resolve
+                                    reject:reject];
+}
+
 RCT_EXPORT_METHOD(scrapImage : (NSString*)imageUrl secureResource : (BOOL)secureResource resolve : (
     RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
   [[self manager] scrapImage:imageUrl secureResource:secureResource resolve:resolve reject:reject];
@@ -26,11 +83,12 @@ RCT_EXPORT_METHOD(scrapImage : (NSString*)imageUrl secureResource : (BOOL)secure
 // RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(shareCalendarTemplate, calendar)
 
 RCT_EXPORT_METHOD(
-    shareOrSendMeOrSendFriendOrWhatever : (NSString*)sendType templateType : (NSString*)
-        templateType templateId : (double)templateId templateJson : (NSDictionary*)templateJson
-            receiverUuids : (NSArray*)receiverUuids useWebBrowserIfKakaoTalkNotAvailable : (BOOL)
-                useWebBrowserIfKakaoTalkNotAvailable templateArgs : (NSDictionary*)
-                    templateArgs serverCallbackArgs : (NSDictionary*)serverCallbackArgs resolve : (
+    shareOrSendMeOrSendFriendOrWhatever : (NSString*)sendType templateType : (NSString*)templateType
+        templateId : (double)templateId templateJson : (NSDictionary*)templateJson receiverUuids : (
+            NSArray*)receiverUuids useWebBrowserIfKakaoTalkNotAvailable : (BOOL)
+            useWebBrowserIfKakaoTalkNotAvailable templateArgs : (NSDictionary*)
+                templateArgs serverCallbackArgs : (NSDictionary*)
+                    serverCallbackArgs pickerSettings : (NSDictionary*)pickerSettings resolve : (
                         RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
   [[self manager] shareOrSendMeOrSendFriendOrWhatever:sendType
                                          templateType:templateType
@@ -40,6 +98,7 @@ RCT_EXPORT_METHOD(
                  useWebBrowserIfKakaoTalkNotAvailable:useWebBrowserIfKakaoTalkNotAvailable
                                          templateArgs:templateArgs
                                    serverCallbackArgs:serverCallbackArgs
+                                       pickerSettings:pickerSettings
                                               resolve:resolve
                                                reject:reject];
 }