@react-native-kakao/share 1.0.4 → 1.2.0

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

@@ -15,112 +15,199 @@ import net.mjstudio.rnkakao.core.util.rejectWith
 import net.mjstudio.rnkakao.core.util.toStringMap
 
 class RNCKakaoShareModule internal constructor(context: ReactApplicationContext) :
-    KakaoShareSpec(context) {
-
+  KakaoShareSpec(context) {
     override fun getName(): String {
-        return NAME
+      return NAME
     }
 
     @ReactMethod
     override fun shareCustom(
-        templateId: Double,
-        useWebBrowserIfKakaoTalkNotAvailable: Boolean,
-        templateArgs: ReadableMap?,
-        serverCallbackArgs: ReadableMap?,
-        promise: Promise,
+      templateId: Double,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      templateArgs: ReadableMap?,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    ) = onMain {
+      runShare(
+        templateId = templateId,
+        useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+        templateArgs = templateArgs,
+        serverCallbackArgs = serverCallbackArgs,
+        promise = promise,
+      )
+    }
+
+    @ReactMethod
+    override fun shareFeedTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    ) = onMain {
+      runShare(
+        defaultTemplate = RNCKakaoShareTemplates.createFeedTemplate(value),
+        useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+        serverCallbackArgs = serverCallbackArgs,
+        promise = promise,
+      )
+    }
+
+    @ReactMethod
+    override fun shareListTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    ) = onMain {
+      runShare(
+        defaultTemplate = RNCKakaoShareTemplates.createListTemplate(value),
+        useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+        serverCallbackArgs = serverCallbackArgs,
+        promise = promise,
+      )
+    }
+
+    @ReactMethod
+    override fun shareLocationTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    ) = onMain {
+      runShare(
+        defaultTemplate = RNCKakaoShareTemplates.createLocationTemplate(value),
+        useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+        serverCallbackArgs = serverCallbackArgs,
+        promise = promise,
+      )
+    }
+
+    @ReactMethod
+    override fun shareCommerceTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    ) = onMain {
+      runShare(
+        defaultTemplate = RNCKakaoShareTemplates.createCommerceTemplate(value),
+        useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+        serverCallbackArgs = serverCallbackArgs,
+        promise = promise,
+      )
+    }
+
+    @ReactMethod
+    override fun shareTextTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
     ) = onMain {
-        runShare(
-            templateId = templateId,
-            useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
-            templateArgs = templateArgs,
-            serverCallbackArgs = serverCallbackArgs,
-            promise = promise,
-        )
+      runShare(
+        defaultTemplate = RNCKakaoShareTemplates.createTextTemplate(value),
+        useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+        serverCallbackArgs = serverCallbackArgs,
+        promise = promise,
+      )
     }
 
-    //    @ReactMethod
-    //    fun shareFeed(serverCallbackArgs: ReadableMap?, promise: Promise) {
-    //        val context = currentActivity
-    //        if (context == null) {
-    //            promise.rejectWith(ActivityNotFoundException())
-    //            return
-    //        }
-    //        ShareClient.instance.shareDefault(context, serverCallbackArgs = serverCallbackArgs) {
-    //
-    //        }
-    //    }
+    @ReactMethod
+    override fun shareCalendarTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    ) = onMain {
+      runShare(
+        defaultTemplate = RNCKakaoShareTemplates.createCalendarTemplate(value),
+        useWebBrowserIfKakaoTalkNotAvailable = useWebBrowserIfKakaoTalkNotAvailable,
+        serverCallbackArgs = serverCallbackArgs,
+        promise = promise,
+      )
+    }
 
     private fun runShare(
-        templateId: Double? = null,
-        defaultTemplate: DefaultTemplate? = null,
-        useWebBrowserIfKakaoTalkNotAvailable: Boolean,
-        templateArgs: ReadableMap?,
-        serverCallbackArgs: ReadableMap?,
-        promise: Promise,
+      templateId: Double? = null,
+      defaultTemplate: DefaultTemplate? = null,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      templateArgs: ReadableMap? = null,
+      serverCallbackArgs: ReadableMap? = null,
+      promise: Promise,
     ) {
-        val context = currentActivity
-        if (context == null) {
-            promise.rejectWith(ActivityNotFoundException())
-            return
-        }
+      val context = currentActivity
+      if (context == null) {
+        promise.rejectWith(ActivityNotFoundException())
+        return
+      }
 
-        if (ShareClient.instance.isKakaoTalkSharingAvailable(context)) {
-            val callback = { sharingResult: SharingResult?, error: Throwable? ->
-                if (error != null) {
-                    promise.rejectWith(error)
-                } else if (sharingResult != null) {
-                    context.startActivity(sharingResult.intent)
-                    promise.resolve(42)
-                }
-            }
+      val callback = { sharingResult: SharingResult?, error: Throwable? ->
+        if (error != null) {
+          promise.rejectWith(error)
+        } else if (sharingResult != null) {
+          context.startActivity(sharingResult.intent)
+          promise.resolve(42)
+        } else {
+          promise.resolve(42)
+        }
+      }
 
-            if (templateId != null) {
-                ShareClient.instance.shareCustom(
-                    context,
-                    templateId.toLong(),
-                    templateArgs = templateArgs?.toStringMap(),
-                    serverCallbackArgs = serverCallbackArgs?.toStringMap(),
-                    callback = callback,
-                )
-            } else if (defaultTemplate != null) {
-                ShareClient.instance.shareDefault(
-                    context,
-                    defaultTemplate,
-                    serverCallbackArgs = serverCallbackArgs?.toStringMap(),
-                    callback = callback,
-                )
-            }
-        } else if (useWebBrowserIfKakaoTalkNotAvailable) {
-            val sharerUrl = if (templateId != null) WebSharerClient.instance.makeCustomUrl(
-                templateId.toLong(),
-                templateArgs = templateArgs?.toStringMap(),
-                serverCallbackArgs = serverCallbackArgs?.toStringMap()
-            ) else if (defaultTemplate != null) WebSharerClient.instance.makeDefaultUrl(
-                defaultTemplate, serverCallbackArgs = serverCallbackArgs?.toStringMap()
-            ) else run {
-                promise.rejectWith("one of templateId or template shouldn't be null")
-                return
-            }
-            try {
-                KakaoCustomTabsClient.openWithDefault(context, sharerUrl)
-                promise.resolve(42)
-                return
-            } catch (_: UnsupportedOperationException) {
-            }
-            try {
-                KakaoCustomTabsClient.open(context, sharerUrl)
-                promise.resolve(42)
-                return
-            } catch (_: ActivityNotFoundException) {
+      if (ShareClient.instance.isKakaoTalkSharingAvailable(context)) {
+        if (templateId != null) {
+          ShareClient.instance.shareCustom(
+            context,
+            templateId.toLong(),
+            templateArgs = templateArgs?.toStringMap(),
+            serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+            callback = callback,
+          )
+        } else if (defaultTemplate != null) {
+          ShareClient.instance.shareDefault(
+            context,
+            defaultTemplate,
+            serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+            callback = callback,
+          )
+        }
+      } else if (useWebBrowserIfKakaoTalkNotAvailable) {
+        val sharerUrl =
+          if (templateId != null) {
+            WebSharerClient.instance.makeCustomUrl(
+              templateId.toLong(),
+              templateArgs = templateArgs?.toStringMap(),
+              serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+            )
+          } else if (defaultTemplate != null) {
+            WebSharerClient.instance.makeDefaultUrl(
+              defaultTemplate,
+              serverCallbackArgs = serverCallbackArgs?.toStringMap(),
+            )
+          } else {
+            run {
+              promise.rejectWith("one of templateId or template shouldn't be null")
+              return
             }
-
-            promise.rejectWith("web url open failed $sharerUrl")
-        } else {
-            promise.rejectWith("kakaotalk not available")
+          }
+        try {
+          KakaoCustomTabsClient.openWithDefault(context, sharerUrl)
+          promise.resolve(42)
+          return
+        } catch (_: UnsupportedOperationException) {
         }
+        try {
+          KakaoCustomTabsClient.open(context, sharerUrl)
+          promise.resolve(42)
+          return
+        } catch (_: ActivityNotFoundException) {
+        }
+
+        promise.rejectWith("web url open failed $sharerUrl")
+      } else {
+        promise.rejectWith("kakaotalk not available")
+      }
     }
 
     companion object {
-        const val NAME = "RNCKakaoShare"
+      const val NAME = "RNCKakaoShare"
     }
-}
+  }

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

@@ -1,14 +1,17 @@
 package net.mjstudio.rnkakao.share
 
 import com.facebook.react.TurboReactPackage
-import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.NativeModule
-import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 import java.util.HashMap
 
 class RNCKakaoSharePackage : TurboReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? {
     return if (name == RNCKakaoShareModule.NAME) {
       RNCKakaoShareModule(reactContext)
     } else {
@@ -20,15 +23,16 @@ class RNCKakaoSharePackage : TurboReactPackage() {
     return ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
       val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-      moduleInfos[RNCKakaoShareModule.NAME] = ReactModuleInfo(
-        RNCKakaoShareModule.NAME,
-        RNCKakaoShareModule.NAME,
-        false,  // canOverrideExistingModule
-        false,  // needsEagerInit
-        true,  // hasConstants
-        false,  // isCxxModule
-        isTurboModule // isTurboModule
-      )
+      moduleInfos[RNCKakaoShareModule.NAME] =
+        ReactModuleInfo(
+          RNCKakaoShareModule.NAME,
+          RNCKakaoShareModule.NAME,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          true, // hasConstants
+          false, // isCxxModule
+          isTurboModule, // isTurboModule
+        )
       moduleInfos
     }
   }

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

@@ -1,11 +1,140 @@
 package net.mjstudio.rnkakao.share
 
-object RNCKakaoShareTemplates { //    fun createFeed() {
-    //        return FeedTemplate(
-    //            content = Content(),
-    //            itemContent = ItemContent(),
-    //            social = Social(),
-    //
-    //            )
-    //    }
-}
+import com.facebook.react.bridge.ReadableMap
+import com.kakao.sdk.template.model.Button
+import com.kakao.sdk.template.model.CalendarTemplate
+import com.kakao.sdk.template.model.Commerce
+import com.kakao.sdk.template.model.CommerceTemplate
+import com.kakao.sdk.template.model.Content
+import com.kakao.sdk.template.model.FeedTemplate
+import com.kakao.sdk.template.model.IdType.CALENDAR
+import com.kakao.sdk.template.model.IdType.EVENT
+import com.kakao.sdk.template.model.ItemContent
+import com.kakao.sdk.template.model.ItemInfo
+import com.kakao.sdk.template.model.Link
+import com.kakao.sdk.template.model.ListTemplate
+import com.kakao.sdk.template.model.LocationTemplate
+import com.kakao.sdk.template.model.Social
+import com.kakao.sdk.template.model.TextTemplate
+import net.mjstudio.rnkakao.core.util.filterIsReadableMap
+import net.mjstudio.rnkakao.core.util.getIntElseNull
+import net.mjstudio.rnkakao.core.util.toStringMap
+
+object RNCKakaoShareTemplates {
+  private fun ReadableMap.toLink() =
+    Link(
+      webUrl = getString("webUrl"),
+      mobileWebUrl = getString("mobileWebUrl"),
+      androidExecutionParams = getMap("androidExecutionParams")?.toStringMap(),
+      iosExecutionParams = getMap("iosExecutionParams")?.toStringMap(),
+    )
+
+  private fun ReadableMap.toContent() =
+    Content(
+      title = getString("title"),
+      imageUrl = getString("imageUrl"),
+      link = getMap("link")?.toLink() ?: Link(),
+      description = getString("description"),
+      imageWidth = getIntElseNull("imageWidth"),
+      imageHeight = getIntElseNull("imageHeight"),
+    )
+
+  private fun ReadableMap.toItemInfo() =
+    ItemInfo(
+      item = getString("item") ?: "",
+      itemOp = getString("itemOp") ?: "",
+    )
+
+  private fun ReadableMap.toItemContent() =
+    ItemContent(
+      profileText = getString("profileText"),
+      profileImageUrl = getString("profileImageUrl"),
+      titleImageText = getString("titleImageText"),
+      titleImageUrl = getString("titleImageUrl"),
+      titleImageCategory = getString("titleImageCategory"),
+      items = getArray("items")?.filterIsReadableMap()?.map { it.toItemInfo() },
+      sum = getString("sum"),
+      sumOp = getString("sumOp"),
+    )
+
+  private fun ReadableMap.toSocial() =
+    Social(
+      likeCount = getIntElseNull("likeCount"),
+      commentCount = getIntElseNull("commentCount"),
+      sharedCount = getIntElseNull("sharedCount"),
+      viewCount = getIntElseNull("viewCount"),
+      subscriberCount = getIntElseNull("subscriberCount"),
+    )
+
+  private fun ReadableMap.toButton() =
+    Button(
+      title = getString("title") ?: "",
+      link = getMap("link")?.toLink() ?: Link(),
+    )
+
+  private fun ReadableMap.toCommerce() =
+    Commerce(
+      regularPrice = getIntElseNull("regularPrice") ?: 0,
+      discountPrice = getIntElseNull("discountPrice"),
+      fixedDiscountPrice = getIntElseNull("fixedDiscountPrice"),
+      discountRate = getIntElseNull("discountRate"),
+      productName = getString("productName"),
+      currencyUnit = getString("currencyUnit"),
+      currencyUnitPosition = getIntElseNull("currencyUnitPosition"),
+    )
+
+  fun createFeedTemplate(map: ReadableMap) =
+    FeedTemplate(
+      content = map.getMap("content")!!.toContent(),
+      itemContent = map.getMap("itemContent")?.toItemContent(),
+      social = map.getMap("social")?.toSocial(),
+      buttons = map.getArray("buttons")?.filterIsReadableMap()?.map { it.toButton() },
+      buttonTitle = map.getString("buttonTitle"),
+    )
+
+  fun createListTemplate(map: ReadableMap): ListTemplate {
+    return ListTemplate(
+      headerTitle = map.getString("headerTitle") ?: "",
+      headerLink = map.getMap("headerLink")?.toLink() ?: Link(),
+      contents =
+        map.getArray("contents")?.filterIsReadableMap()?.map { it.toContent() }
+          ?: listOf(),
+      buttons = map.getArray("buttons")?.filterIsReadableMap()?.map { it.toButton() },
+      buttonTitle = map.getString("buttonTitle"),
+    )
+  }
+
+  fun createLocationTemplate(map: ReadableMap) =
+    LocationTemplate(
+      address = map.getString("address") ?: "",
+      content = map.getMap("content")!!.toContent(),
+      addressTitle = map.getString("addressTitle"),
+      social = map.getMap("social")?.toSocial(),
+      buttons = map.getArray("buttons")?.filterIsReadableMap()?.map { it.toButton() },
+      buttonTitle = map.getString("buttonTitle"),
+    )
+
+  fun createCommerceTemplate(map: ReadableMap) =
+    CommerceTemplate(
+      content = map.getMap("content")!!.toContent(),
+      commerce = map.getMap("commerce")!!.toCommerce(),
+      buttons = map.getArray("buttons")?.filterIsReadableMap()?.map { it.toButton() },
+      buttonTitle = map.getString("buttonTitle"),
+    )
+
+  fun createTextTemplate(map: ReadableMap) =
+    TextTemplate(
+      text = map.getString("text") ?: "",
+      link = map.getMap("link")?.toLink() ?: Link(),
+      buttons = map.getArray("buttons")?.filterIsReadableMap()?.map { it.toButton() },
+      buttonTitle = map.getString("buttonTitle"),
+    )
+
+  fun createCalendarTemplate(map: ReadableMap) =
+    CalendarTemplate(
+      id = map.getString("id")!!,
+      idType = if (map.getString("id") == "event") EVENT else CALENDAR,
+      content = map.getMap("content")!!.toContent(),
+      buttons = map.getArray("buttons")?.filterIsReadableMap()?.map { it.toButton() },
+    )
+}

package/android/src/oldarch/KakaoShareSpec.kt

@@ -6,12 +6,54 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReadableMap
 
 abstract class KakaoShareSpec internal constructor(context: ReactApplicationContext) :
-    ReactContextBaseJavaModule(context) {
+  ReactContextBaseJavaModule(context) {
     abstract fun shareCustom(
-        templateId: Double,
-        useWebBrowserIfKakaoTalkNotAvailable: Boolean,
-        templateArgs: ReadableMap?,
-        serverCallbackArgs: ReadableMap?,
-        promise: Promise,
+      templateId: Double,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      templateArgs: ReadableMap?,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
     )
-}
+
+    abstract fun shareFeedTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    )
+
+    abstract fun shareListTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    )
+
+    abstract fun shareLocationTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    )
+
+    abstract fun shareCommerceTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    )
+
+    abstract fun shareTextTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    )
+
+    abstract fun shareCalendarTemplate(
+      value: ReadableMap,
+      useWebBrowserIfKakaoTalkNotAvailable: Boolean,
+      serverCallbackArgs: ReadableMap?,
+      promise: Promise,
+    )
+  }

package/ios/RNCKakaoShare.mm

@@ -1,6 +1,21 @@
 #import "RNCKakaoShare.h"
 #import "RNCKakaoShare-Swift.h"
 
+#define RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(name, type_name)                                   \
+  RCT_EXPORT_METHOD(name                                                                           \
+                    : (NSDictionary*)value useWebBrowserIfKakaoTalkNotAvailable                    \
+                    : (BOOL)useWebBrowserIfKakaoTalkNotAvailable serverCallbackArgs                \
+                    : (NSDictionary*)serverCallbackArgs resolve                                    \
+                    : (RCTPromiseResolveBlock)resolve reject                                       \
+                    : (RCTPromiseRejectBlock)reject) {                                             \
+    [[self manager] shareDefaultTemplate:value                                                     \
+                                        type:@ #type_name                                          \
+        useWebBrowserIfKakaoTalkNotAvailable:useWebBrowserIfKakaoTalkNotAvailable                  \
+                          serverCallbackArgs:serverCallbackArgs                                    \
+                                     resolve:resolve                                               \
+                                      reject:reject];                                              \
+  }
+
 @implementation RNCKakaoShare
 
 - (RNCKakaoShareManager*)manager {
@@ -24,6 +39,13 @@ RCT_EXPORT_METHOD(shareCustom
                                     reject:reject];
 }
 
+RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(shareFeedTemplate, feed)
+RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(shareListTemplate, list)
+RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(shareLocationTemplate, location)
+RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(shareCommerceTemplate, commerce)
+RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(shareTextTemplate, text)
+RNC_KAKAO_SHARE_EXPORT_DEFAULT_TEMPLATE(shareCalendarTemplate, calendar)
+
 // Don't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule: