expo-sms 11.0.0 → 11.2.0

package/CHANGELOG.md

@@ -10,6 +10,18 @@
 
 ### 💡 Others
 
+## 11.2.0 — 2023-02-03
+
+### 💡 Others
+
+- On Android bump `compileSdkVersion` and `targetSdkVersion` to `33`. ([#20721](https://github.com/expo/expo/pull/20721) by [@lukmccall](https://github.com/lukmccall))
+
+## 11.1.0 — 2022-12-30
+
+### 🎉 New features
+
+- Migrated to Expo Modules API. ([#19996](https://github.com/expo/expo/pull/19996) and ([#19967](https://github.com/expo/expo/pull/19967) by [@alanhughes](https://github.com/alanjhughes))
+
 ## 11.0.0 — 2022-10-25
 
 ### 🛠 Breaking changes

package/README.md

@@ -4,7 +4,7 @@ Provides access to the system's UI/app for sending SMS messages.
 
 # API documentation
 
-- [Documentation for the main branch](https://github.com/expo/expo/blob/main/docs/pages/versions/unversioned/sdk/sms.md)
+- [Documentation for the main branch](https://github.com/expo/expo/blob/main/docs/pages/versions/unversioned/sdk/sms.mdx)
 - [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/sms/)
 
 # Installation in managed Expo projects

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '11.0.0'
+version = '11.2.0'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -59,7 +59,7 @@ afterEvaluate {
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 31)
+  compileSdkVersion safeExtGet("compileSdkVersion", 33)
 
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_11
@@ -72,9 +72,9 @@ android {
 
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 31)
+    targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 28
-    versionName "11.0.0"
+    versionName "11.2.0"
   }
   lintOptions {
     abortOnError false

package/android/src/main/java/expo/modules/sms/SMSExceptions.kt

@@ -0,0 +1,9 @@
+package expo.modules.sms
+
+import expo.modules.kotlin.exception.CodedException
+
+internal class MissingSMSAppException :
+  CodedException("No messaging application available")
+
+internal class MissingCurrentActivityException :
+  CodedException("Activity which was provided during module initialization is no longer available")

package/android/src/main/java/expo/modules/sms/SMSModule.kt

@@ -2,75 +2,60 @@ package expo.modules.sms
 
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
 import android.net.Uri
 import android.provider.Telephony
-import android.content.pm.PackageManager
-import android.os.Bundle
-
-import java.util.ArrayList
-
-import expo.modules.core.ExportedModule
+import androidx.core.os.bundleOf
 import expo.modules.core.interfaces.LifecycleEventListener
-import expo.modules.core.ModuleRegistry
-import expo.modules.core.Promise
 import expo.modules.core.interfaces.services.UIManager
-import expo.modules.core.interfaces.ExpoMethod
-import expo.modules.core.interfaces.ActivityProvider
-
-private const val TAG = "ExpoSMS"
-private const val ERROR_TAG = "E_SMS"
-private const val OPTIONS_ATTACHMENTS_KEY = "attachments"
-
-class SMSModule(context: Context, private val smsPackage: String? = null) : ExportedModule(context), LifecycleEventListener {
-  private lateinit var mModuleRegistry: ModuleRegistry
-  private var mPendingPromise: Promise? = null
-  private var mSMSComposerOpened = false
-
-  override fun getName(): String {
-    return TAG
-  }
-
-  override fun onCreate(moduleRegistry: ModuleRegistry) {
-    mModuleRegistry = moduleRegistry
-    mModuleRegistry.getModule(UIManager::class.java)?.registerLifecycleEventListener(this)
-  }
-
-  override fun onDestroy() {
-    // Unregister from old UIManager
-    mModuleRegistry.getModule(UIManager::class.java)?.unregisterLifecycleEventListener(this)
-  }
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class SMSModule : Module(), LifecycleEventListener {
+  private var pendingPromise: Promise? = null
+  private var smsComposerOpened = false
+
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+  private val currentActivity
+    get() = appContext.activityProvider?.currentActivity
+      ?: throw MissingCurrentActivityException()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoSMS")
+
+    OnCreate {
+      val uiManager = appContext.legacyModule<UIManager>()
+      uiManager?.registerLifecycleEventListener(this@SMSModule)
+    }
 
-  private fun getAttachment(attachment: Map<String?, String?>?, key: String): String? {
-    return attachment?.get(key)
-  }
+    AsyncFunction("sendSMSAsync") { addresses: List<String>, message: String, options: SMSOptions, promise: Promise ->
+      sendSMSAsync(addresses, message, options, promise)
+    }
 
-  @ExpoMethod
-  fun sendSMSAsync(
-    addresses: ArrayList<String>,
-    message: String,
-    options: Map<String?, Any?>?,
-    promise: Promise
-  ) {
-    if (mPendingPromise != null) {
-      promise.reject(
-        ERROR_TAG + "_SENDING_IN_PROGRESS",
-        "Different SMS sending in progress. Await the old request and then try again."
-      )
-      return
+    AsyncFunction("isAvailableAsync") {
+      return@AsyncFunction context.packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)
     }
 
-    val attachments = options?.get(OPTIONS_ATTACHMENTS_KEY) as? List<*>
+    OnDestroy {
+      val uiManager = appContext.legacyModule<UIManager>()
+      uiManager?.unregisterLifecycleEventListener(this@SMSModule)
+    }
+  }
 
+  private fun sendSMSAsync(addresses: List<String>, message: String, options: SMSOptions, promise: Promise) {
     // ACTION_SEND causes a weird flicker on Android 10 devices if the messaging app is not already
     // open in the background, but it seems to be the only intent type that works for including
     // attachments, so we use it if there are attachments and fall back to ACTION_SENDTO otherwise.
-    val smsIntent = if (attachments?.isNotEmpty() == true) {
+    val smsIntent = if (options.attachments.isNotEmpty()) {
       Intent(Intent.ACTION_SEND).apply {
         type = "text/plain"
         putExtra("address", addresses.joinToString(separator = ";"))
-        val attachment = attachments[0] as? Map<String?, String?>
-        putExtra(Intent.EXTRA_STREAM, Uri.parse(getAttachment(attachment, "uri")))
-        type = getAttachment(attachment, "mimeType")
+        val attachment = options.attachments[0]
+        putExtra(Intent.EXTRA_STREAM, Uri.parse(attachment.uri))
+        type = attachment.mimeType
         addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
       }
     } else {
@@ -79,49 +64,34 @@ class SMSModule(context: Context, private val smsPackage: String? = null) : Expo
       }
     }
 
-    val defaultSMSPackage: String?
-    if (smsPackage != null) {
-      defaultSMSPackage = smsPackage
-    } else {
-      defaultSMSPackage = Telephony.Sms.getDefaultSmsPackage(context)
-    }
+    val defaultSMSPackage = Telephony.Sms.getDefaultSmsPackage(context)
+    defaultSMSPackage?.let {
+      smsIntent.setPackage(it)
+    } ?: throw MissingSMSAppException()
 
-    if (defaultSMSPackage != null) {
-      smsIntent.setPackage(defaultSMSPackage)
-    } else {
-      promise.reject(ERROR_TAG + "_NO_SMS_APP", "No messaging application available")
-      return
+    smsIntent.apply {
+      putExtra("exit_on_sent", true)
+      putExtra("compose_mode", true)
+      putExtra("sms_body", message)
     }
-    smsIntent.putExtra("exit_on_sent", true)
-    smsIntent.putExtra("compose_mode", true)
-    smsIntent.putExtra("sms_body", message)
-    mPendingPromise = promise
-    val activityProvider = mModuleRegistry.getModule(
-      ActivityProvider::class.java
-    )
-    activityProvider.currentActivity.startActivity(smsIntent)
-    mSMSComposerOpened = true
-  }
 
-  @ExpoMethod
-  fun isAvailableAsync(promise: Promise) {
-    promise.resolve(context.packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY))
+    pendingPromise = promise
+    currentActivity.startActivity(smsIntent)
+    smsComposerOpened = true
   }
 
   override fun onHostResume() {
-    val promise = mPendingPromise
-    if (mSMSComposerOpened && promise != null) {
+    val promise = pendingPromise
+    if (smsComposerOpened && promise != null) {
       // the only way to check the status of the message is to query the device's SMS database
       // but this requires READ_SMS permission, which Google is heavily restricting beginning Jan 2019
       // so we just resolve with an unknown value
       promise.resolve(
-        Bundle().apply {
-          putString("result", "unknown")
-        }
+        bundleOf(Pair("result", "unknown"))
       )
-      mPendingPromise = null
+      pendingPromise = null
     }
-    mSMSComposerOpened = false
+    smsComposerOpened = false
   }
 
   override fun onHostPause() = Unit

package/android/src/main/java/expo/modules/sms/SMSOptions.kt

@@ -0,0 +1,14 @@
+package expo.modules.sms
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class SMSOptions(
+  @Field val attachments: List<SMSAttachment> = emptyList()
+) : Record
+
+data class SMSAttachment(
+  @Field val uri: String,
+  @Field val mimeType: String,
+  @Field val filename: String,
+) : Record

package/build/ExpoSMS.d.ts

@@ -1,3 +1,3 @@
-declare const _default: import("expo-modules-core").ProxyNativeModule;
+declare const _default: any;
 export default _default;
 //# sourceMappingURL=ExpoSMS.d.ts.map

package/build/ExpoSMS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoSMS.d.ts","sourceRoot":"","sources":["../src/ExpoSMS.ts"],"names":[],"mappings":";AACA,wBAA0C"}
+{"version":3,"file":"ExpoSMS.d.ts","sourceRoot":"","sources":["../src/ExpoSMS.ts"],"names":[],"mappings":";AACA,wBAA8C"}

package/build/ExpoSMS.js

@@ -1,3 +1,3 @@
-import { NativeModulesProxy } from 'expo-modules-core';
-export default NativeModulesProxy.ExpoSMS;
+import { requireNativeModule } from 'expo-modules-core';
+export default requireNativeModule('ExpoSMS');
 //# sourceMappingURL=ExpoSMS.js.map

package/build/ExpoSMS.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoSMS.js","sourceRoot":"","sources":["../src/ExpoSMS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,eAAe,kBAAkB,CAAC,OAAO,CAAC","sourcesContent":["import { NativeModulesProxy } from 'expo-modules-core';\nexport default NativeModulesProxy.ExpoSMS;\n"]}
+{"version":3,"file":"ExpoSMS.js","sourceRoot":"","sources":["../src/ExpoSMS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,eAAe,mBAAmB,CAAC,SAAS,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\nexport default requireNativeModule('ExpoSMS');\n"]}

package/build/SMS.d.ts

@@ -14,7 +14,7 @@ export { SMSAttachment, SMSResponse, SMSOptions };
  * - If the status of the SMS message cannot be determined: `{ result: 'unknown' }`.
  *
  * Android does not provide information about the status of the SMS message, so on Android devices
- * the Promise will always resolve with { result: 'unknown' }.
+ * the Promise will always resolve with `{ result: 'unknown' }`.
  *
  * > Note: The only feedback collected by this module is whether any message has been sent. That
  * means we do not check actual content of message nor recipients list.

package/build/SMS.js

@@ -29,7 +29,7 @@ function processAttachments(attachments) {
  * - If the status of the SMS message cannot be determined: `{ result: 'unknown' }`.
  *
  * Android does not provide information about the status of the SMS message, so on Android devices
- * the Promise will always resolve with { result: 'unknown' }.
+ * the Promise will always resolve with `{ result: 'unknown' }`.
  *
  * > Note: The only feedback collected by this module is whether any message has been sent. That
  * means we do not check actual content of message nor recipients list.

package/build/SMS.js.map

@@ -1 +1 @@
-{"version":3,"file":"SMS.js","sourceRoot":"","sources":["../src/SMS.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,OAAO,MAAM,WAAW,CAAC;AAKhC,SAAS,kBAAkB,CACzB,WAAwD;IAExD,IAAI,CAAC,WAAW,EAAE;QAChB,OAAO,IAAI,CAAC;KACb;IACD,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACvE,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;QACvD,IAAI,OAAO,EAAE;YACX,OAAO,CAAC,IAAI,CAAC,0EAA0E,CAAC,CAAC;SAC1F;QACD,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KACvC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,cAAc;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,SAA4B,EAC5B,OAAe,EACf,OAAoB;IAEpB,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE;QACzB,MAAM,IAAI,mBAAmB,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;KAC3D;IACD,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC1E,cAAc,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QACjC,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,SAAS,EAAE;YAC7C,MAAM,IAAI,SAAS,CAAC,2BAA2B,CAAC,CAAC;SAClD;IACH,CAAC,CAAC,CAAC;IACH,MAAM,YAAY,GAAG;QACnB,GAAG,OAAO;KACG,CAAC;IAChB,IAAI,OAAO,EAAE,WAAW,EAAE;QACxB,YAAY,CAAC,WAAW,GAAG,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,SAAS,CAAC;KAClF;IACD,OAAO,OAAO,CAAC,YAAY,CAAC,cAAc,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;AACrE,CAAC;AAED,cAAc;AACd;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,OAAO,OAAO,CAAC,gBAAgB,EAAE,CAAC;AACpC,CAAC","sourcesContent":["/* eslint-disable no-unused-expressions */\nimport { UnavailabilityError, Platform } from 'expo-modules-core';\n\nimport ExpoSMS from './ExpoSMS';\nimport { SMSAttachment, SMSResponse, SMSOptions } from './SMS.types';\n\nexport { SMSAttachment, SMSResponse, SMSOptions };\n\nfunction processAttachments(\n  attachments: SMSAttachment | SMSAttachment[] | undefined\n): SMSAttachment[] | null {\n  if (!attachments) {\n    return null;\n  }\n  attachments = Array.isArray(attachments) ? attachments : [attachments];\n  if (Platform.OS === 'android' && attachments.length > 1) {\n    if (__DEV__) {\n      console.warn('Android only supports a single attachment. The first array item is used.');\n    }\n    attachments = attachments.slice(0, 1);\n  }\n  return attachments;\n}\n\n// @needsAudit\n/**\n * Opens the default UI/app for sending SMS messages with prefilled addresses and message.\n *\n * @param addresses An array of addresses (phone numbers) or single address passed as strings. Those\n * would appear as recipients of the prepared message.\n * @param message Message to be sent.\n * @param options A `SMSOptions` object defining additional SMS configuration options.\n *\n * @return Returns a Promise that fulfils with the SMS action is invoked by the user, with corresponding result:\n * - If the user cancelled the SMS sending process: `{ result: 'cancelled' }`.\n * - If the user has sent/scheduled message for sending: `{ result: 'sent' }`.\n * - If the status of the SMS message cannot be determined: `{ result: 'unknown' }`.\n *\n * Android does not provide information about the status of the SMS message, so on Android devices\n * the Promise will always resolve with { result: 'unknown' }.\n *\n * > Note: The only feedback collected by this module is whether any message has been sent. That\n * means we do not check actual content of message nor recipients list.\n *\n * @example\n * ```ts\n * const { result } = await SMS.sendSMSAsync(\n *   ['0123456789', '9876543210'],\n *   'My sample HelloWorld message',\n *   {\n *     attachments: {\n *       uri: 'path/myfile.png',\n *       mimeType: 'image/png',\n *       filename: 'myfile.png',\n *     },\n *   }\n * );\n * ```\n */\nexport async function sendSMSAsync(\n  addresses: string | string[],\n  message: string,\n  options?: SMSOptions\n): Promise<SMSResponse> {\n  if (!ExpoSMS.sendSMSAsync) {\n    throw new UnavailabilityError('expo-sms', 'sendSMSAsync');\n  }\n  const finalAddresses = Array.isArray(addresses) ? addresses : [addresses];\n  finalAddresses.forEach((address) => {\n    if (address === null || address === undefined) {\n      throw new TypeError('undefined or null address');\n    }\n  });\n  const finalOptions = {\n    ...options,\n  } as SMSOptions;\n  if (options?.attachments) {\n    finalOptions.attachments = processAttachments(options?.attachments) || undefined;\n  }\n  return ExpoSMS.sendSMSAsync(finalAddresses, message, finalOptions);\n}\n\n// @needsAudit\n/**\n * Determines whether SMS is available. Always returns `false` in the iOS simulator, and in browser.\n *\n * @return Returns a promise that fulfils with a `boolean`, indicating whether SMS is available on this device.\n *\n * @example\n * ```ts\n * const isAvailable = await SMS.isAvailableAsync();\n * if (isAvailable) {\n *   // do your SMS stuff here\n * } else {\n *   // misfortune... there's no SMS available on this device\n * }\n * ```\n */\nexport async function isAvailableAsync(): Promise<boolean> {\n  return ExpoSMS.isAvailableAsync();\n}\n"]}
+{"version":3,"file":"SMS.js","sourceRoot":"","sources":["../src/SMS.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,OAAO,MAAM,WAAW,CAAC;AAKhC,SAAS,kBAAkB,CACzB,WAAwD;IAExD,IAAI,CAAC,WAAW,EAAE;QAChB,OAAO,IAAI,CAAC;KACb;IACD,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACvE,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;QACvD,IAAI,OAAO,EAAE;YACX,OAAO,CAAC,IAAI,CAAC,0EAA0E,CAAC,CAAC;SAC1F;QACD,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KACvC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,cAAc;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,SAA4B,EAC5B,OAAe,EACf,OAAoB;IAEpB,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE;QACzB,MAAM,IAAI,mBAAmB,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;KAC3D;IACD,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC1E,cAAc,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QACjC,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,SAAS,EAAE;YAC7C,MAAM,IAAI,SAAS,CAAC,2BAA2B,CAAC,CAAC;SAClD;IACH,CAAC,CAAC,CAAC;IACH,MAAM,YAAY,GAAG;QACnB,GAAG,OAAO;KACG,CAAC;IAChB,IAAI,OAAO,EAAE,WAAW,EAAE;QACxB,YAAY,CAAC,WAAW,GAAG,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,SAAS,CAAC;KAClF;IACD,OAAO,OAAO,CAAC,YAAY,CAAC,cAAc,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;AACrE,CAAC;AAED,cAAc;AACd;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,OAAO,OAAO,CAAC,gBAAgB,EAAE,CAAC;AACpC,CAAC","sourcesContent":["/* eslint-disable no-unused-expressions */\nimport { UnavailabilityError, Platform } from 'expo-modules-core';\n\nimport ExpoSMS from './ExpoSMS';\nimport { SMSAttachment, SMSResponse, SMSOptions } from './SMS.types';\n\nexport { SMSAttachment, SMSResponse, SMSOptions };\n\nfunction processAttachments(\n  attachments: SMSAttachment | SMSAttachment[] | undefined\n): SMSAttachment[] | null {\n  if (!attachments) {\n    return null;\n  }\n  attachments = Array.isArray(attachments) ? attachments : [attachments];\n  if (Platform.OS === 'android' && attachments.length > 1) {\n    if (__DEV__) {\n      console.warn('Android only supports a single attachment. The first array item is used.');\n    }\n    attachments = attachments.slice(0, 1);\n  }\n  return attachments;\n}\n\n// @needsAudit\n/**\n * Opens the default UI/app for sending SMS messages with prefilled addresses and message.\n *\n * @param addresses An array of addresses (phone numbers) or single address passed as strings. Those\n * would appear as recipients of the prepared message.\n * @param message Message to be sent.\n * @param options A `SMSOptions` object defining additional SMS configuration options.\n *\n * @return Returns a Promise that fulfils with the SMS action is invoked by the user, with corresponding result:\n * - If the user cancelled the SMS sending process: `{ result: 'cancelled' }`.\n * - If the user has sent/scheduled message for sending: `{ result: 'sent' }`.\n * - If the status of the SMS message cannot be determined: `{ result: 'unknown' }`.\n *\n * Android does not provide information about the status of the SMS message, so on Android devices\n * the Promise will always resolve with `{ result: 'unknown' }`.\n *\n * > Note: The only feedback collected by this module is whether any message has been sent. That\n * means we do not check actual content of message nor recipients list.\n *\n * @example\n * ```ts\n * const { result } = await SMS.sendSMSAsync(\n *   ['0123456789', '9876543210'],\n *   'My sample HelloWorld message',\n *   {\n *     attachments: {\n *       uri: 'path/myfile.png',\n *       mimeType: 'image/png',\n *       filename: 'myfile.png',\n *     },\n *   }\n * );\n * ```\n */\nexport async function sendSMSAsync(\n  addresses: string | string[],\n  message: string,\n  options?: SMSOptions\n): Promise<SMSResponse> {\n  if (!ExpoSMS.sendSMSAsync) {\n    throw new UnavailabilityError('expo-sms', 'sendSMSAsync');\n  }\n  const finalAddresses = Array.isArray(addresses) ? addresses : [addresses];\n  finalAddresses.forEach((address) => {\n    if (address === null || address === undefined) {\n      throw new TypeError('undefined or null address');\n    }\n  });\n  const finalOptions = {\n    ...options,\n  } as SMSOptions;\n  if (options?.attachments) {\n    finalOptions.attachments = processAttachments(options?.attachments) || undefined;\n  }\n  return ExpoSMS.sendSMSAsync(finalAddresses, message, finalOptions);\n}\n\n// @needsAudit\n/**\n * Determines whether SMS is available. Always returns `false` in the iOS simulator, and in browser.\n *\n * @return Returns a promise that fulfils with a `boolean`, indicating whether SMS is available on this device.\n *\n * @example\n * ```ts\n * const isAvailable = await SMS.isAvailableAsync();\n * if (isAvailable) {\n *   // do your SMS stuff here\n * } else {\n *   // misfortune... there's no SMS available on this device\n * }\n * ```\n */\nexport async function isAvailableAsync(): Promise<boolean> {\n  return ExpoSMS.isAvailableAsync();\n}\n"]}

package/build/SMS.types.d.ts

@@ -1,4 +1,4 @@
-export declare type SMSResponse = {
+export type SMSResponse = {
     /**
      * Status of SMS action invoked by the user.
      */
@@ -7,7 +7,7 @@ export declare type SMSResponse = {
 /**
  * An object that is used to describe an attachment that is included with a SMS message.
  */
-export declare type SMSAttachment = {
+export type SMSAttachment = {
     /**
      * The content URI of the attachment. The URI needs be a content URI so that it can be accessed by
      * other applications outside of Expo. See [FileSystem.getContentUriAsync](./filesystem/#filesystemgetcontenturiasyncfileuri)).
@@ -22,7 +22,7 @@ export declare type SMSAttachment = {
      */
     filename: string;
 };
-export declare type SMSOptions = {
+export type SMSOptions = {
     attachments?: SMSAttachment | SMSAttachment[] | undefined;
 };
 //# sourceMappingURL=SMS.types.d.ts.map

package/build/SMS.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SMS.types.d.ts","sourceRoot":"","sources":["../src/SMS.types.ts"],"names":[],"mappings":"AACA,oBAAY,WAAW,GAAG;IACxB;;OAEG;IACH,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,CAAC;CAC1C,CAAC;AAGF;;GAEG;AACH,oBAAY,aAAa,GAAG;IAC1B;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAGF,oBAAY,UAAU,GAAG;IACvB,WAAW,CAAC,EAAE,aAAa,GAAG,aAAa,EAAE,GAAG,SAAS,CAAC;CAC3D,CAAC"}
+{"version":3,"file":"SMS.types.d.ts","sourceRoot":"","sources":["../src/SMS.types.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,WAAW,GAAG;IACxB;;OAEG;IACH,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,CAAC;CAC1C,CAAC;AAGF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAGF,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,CAAC,EAAE,aAAa,GAAG,aAAa,EAAE,GAAG,SAAS,CAAC;CAC3D,CAAC"}

package/expo-module.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "expo-sms",
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": ["ExpoSMSModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.sms.SMSModule"]
+  }
+}

package/ios/{EXSMS.podspec → ExpoSMS.podspec}

@@ -3,7 +3,7 @@ require 'json'
 package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
 
 Pod::Spec.new do |s|
-  s.name           = 'EXSMS'
+  s.name           = 'ExpoSMS'
   s.version        = package['version']
   s.summary        = package['description']
   s.description    = package['description']
@@ -11,15 +11,16 @@ Pod::Spec.new do |s|
   s.author         = package['author']
   s.homepage       = package['homepage']
   s.platform       = :ios, '13.0'
+  s.swift_version  = '5.4'
   s.source         = { git: 'https://github.com/expo/expo.git' }
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
 
   if !$ExpoUseSources&.include?(package['name']) && ENV['EXPO_USE_SOURCE'].to_i == 0 && File.exist?("#{s.name}.xcframework") && Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.10.0')
-    s.source_files = "#{s.name}/**/*.h"
+    s.source_files = "**/*.h"
     s.vendored_frameworks = "#{s.name}.xcframework"
   else
-    s.source_files = "#{s.name}/**/*.{h,m}"
+    s.source_files = "**/*.{h,m,swift}"
   end
 end

package/ios/ExpoSMSModule.swift

@@ -0,0 +1,93 @@
+import ExpoModulesCore
+import MessageUI
+import CoreServices
+import MobileCoreServices
+import UniformTypeIdentifiers
+
+struct ExpoSMSContext {
+  let promise: Promise
+  let smsDelegate: SMSDelegate
+}
+
+public class ExpoSMSModule: Module, SMSResultHandler {
+  private var smsContext: ExpoSMSContext?
+  private lazy var utils = appContext?.utilities
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoSMS")
+
+    AsyncFunction("isAvailableAsync") {
+      return MFMessageComposeViewController.canSendText()
+    }
+
+    AsyncFunction("sendSMSAsync") { (addresses: [String], message: String, options: SMSOptions, promise: Promise) in
+      try sendSMSAsync(addresses: addresses, message: message, options: options, promise: promise)
+    }.runOnQueue(.main)
+  }
+
+  private func sendSMSAsync(addresses: [String], message: String, options: SMSOptions, promise: Promise) throws {
+    if !MFMessageComposeViewController.canSendText() {
+      throw SMSUnavailableException()
+    }
+
+    if smsContext != nil {
+      throw SMSPendingException()
+    }
+
+    let smsDelegate = SMSDelegate(handler: self)
+    let context = ExpoSMSContext(promise: promise, smsDelegate: smsDelegate)
+
+    let messageComposeViewController = MFMessageComposeViewController()
+    messageComposeViewController.messageComposeDelegate = context.smsDelegate
+    messageComposeViewController.recipients = addresses
+    messageComposeViewController.body = message
+
+    for attachment in options.attachments {
+      let utiRef = UTTypeCreatePreferredIdentifierForTag(
+        kUTTagClassMIMEType, attachment.mimeType as CFString, nil)
+
+      if utiRef == nil {
+        throw SMSMimeTypeException(attachment.mimeType)
+      }
+
+      guard let url = URL(string: attachment.uri) else {
+        throw SMSUriException(attachment.uri)
+      }
+
+      do {
+        let data = try Data(contentsOf: url, options: .mappedIfSafe)
+        let attached = messageComposeViewController.addAttachmentData(
+          data,
+          typeIdentifier: attachment.mimeType,
+          filename: attachment.filename)
+        if !attached {
+          throw SMSFileException(attachment.uri)
+        }
+      } catch {
+        context.promise.reject(error)
+        return
+      }
+    }
+
+    smsContext = context
+    utils?.currentViewController()?.present(messageComposeViewController, animated: true, completion: nil)
+  }
+
+  func onSuccess(_ data: [String: String]) {
+    guard let promise = smsContext?.promise else {
+      log.error("SMS context has been lost")
+      return
+    }
+    smsContext = nil
+    promise.resolve(data)
+  }
+
+  func onFailure(_ error: String) {
+    guard let promise = smsContext?.promise else {
+      log.error("SMS context has been lost")
+      return
+    }
+    smsContext = nil
+    promise.reject(SMSSendingException(error))
+  }
+}

package/ios/SMSDelegate.swift

@@ -0,0 +1,37 @@
+import MessageUI
+
+protocol SMSResultHandler {
+  func onSuccess(_ data: [String: String])
+  func onFailure(_ error: String)
+}
+
+class SMSDelegate: NSObject, MFMessageComposeViewControllerDelegate {
+  private let handler: SMSResultHandler
+
+  init(handler: SMSResultHandler) {
+    self.handler = handler
+  }
+
+  func messageComposeViewController(
+    _ controller: MFMessageComposeViewController,
+    didFinishWith result: MessageComposeResult
+  ) {
+    controller.dismiss(animated: true) {
+      switch result {
+      case .sent, .cancelled:
+        self.handler.onSuccess([
+          "result": result == .sent ? "sent" : "cancelled"
+        ])
+      case .failed:
+        self.handler.onFailure(
+          """
+          User's attempt to save or send an SMS was unsuccessful.
+          This can occur when the device loses connection to WiFi or Cellular
+          """
+        )
+      default:
+        self.handler.onFailure("SMS message sending failed with unknown error")
+      }
+    }
+  }
+}

package/ios/SMSExceptions.swift

@@ -0,0 +1,37 @@
+import ExpoModulesCore
+
+internal class SMSUnavailableException: Exception {
+  override var reason: String {
+    "SMS service is not available"
+  }
+}
+
+internal class SMSPendingException: Exception {
+  override var reason: String {
+    "SMS sending in progress, await the old request and then try again"
+  }
+}
+
+internal class SMSSendingException: GenericException<String> {
+  override var reason: String {
+    param
+  }
+}
+
+internal class SMSFileException: GenericException<String> {
+  override var reason: String {
+    "Failed to attach file: \(param)"
+  }
+}
+
+internal class SMSMimeTypeException: GenericException<String> {
+  override var reason: String {
+    "Failed to find UTI for mimeType: \(param)"
+  }
+}
+
+internal class SMSUriException: GenericException<String> {
+  override var reason: String {
+    "Invalid file uri: \(param)"
+  }
+}

package/ios/SMSOptions.swift

@@ -0,0 +1,11 @@
+import ExpoModulesCore
+
+struct SMSOptions: Record {
+  @Field var attachments: [SMSAttachment]
+}
+
+struct SMSAttachment: Record {
+  @Field var uri: String
+  @Field var mimeType: String
+  @Field var filename: String
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-sms",
-  "version": "11.0.0",
+  "version": "11.2.0",
   "description": "Provides access to the system's UI/app for sending SMS messages.",
   "main": "build/SMS.js",
   "types": "build/SMS.d.ts",
@@ -40,5 +40,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "eab2b09c735fb0fc2bf734a3f29a6593adba3838"
+  "gitHead": "1815e2eaad8c753588c7b1eb74420174a28e01f4"
 }

package/src/ExpoSMS.ts

@@ -1,2 +1,2 @@
-import { NativeModulesProxy } from 'expo-modules-core';
-export default NativeModulesProxy.ExpoSMS;
+import { requireNativeModule } from 'expo-modules-core';
+export default requireNativeModule('ExpoSMS');

package/src/SMS.ts

@@ -37,7 +37,7 @@ function processAttachments(
  * - If the status of the SMS message cannot be determined: `{ result: 'unknown' }`.
  *
  * Android does not provide information about the status of the SMS message, so on Android devices
- * the Promise will always resolve with { result: 'unknown' }.
+ * the Promise will always resolve with `{ result: 'unknown' }`.
  *
  * > Note: The only feedback collected by this module is whether any message has been sent. That
  * means we do not check actual content of message nor recipients list.

package/android/src/main/java/expo/modules/sms/SMSPackage.kt

@@ -1,11 +0,0 @@
-package expo.modules.sms
-
-import android.content.Context
-import expo.modules.core.BasePackage
-import expo.modules.core.ExportedModule
-
-class SMSPackage : BasePackage() {
-  override fun createExportedModules(reactContext: Context): List<ExportedModule> {
-    return listOf(SMSModule(reactContext))
-  }
-}

package/ios/EXSMS/EXSMSModule.h

@@ -1,7 +0,0 @@
-//  Copyright © 2018 650 Industries. All rights reserved.
-
-#import <ExpoModulesCore/EXExportedModule.h>
-#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
-
-@interface EXSMSModule : EXExportedModule <EXModuleRegistryConsumer>
-@end

package/ios/EXSMS/EXSMSModule.m

@@ -1,132 +0,0 @@
-// Copyright © 2018 650 Industries. All rights reserved.
-
-#import <MessageUI/MessageUI.h>
-#import <EXSMS/EXSMSModule.h>
-#import <ExpoModulesCore/EXUtilities.h>
-#if SD_MAC
-#import <CoreServices/CoreServices.h>
-#else
-#import <MobileCoreServices/MobileCoreServices.h>
-#endif
-
-@interface EXSMSModule () <MFMessageComposeViewControllerDelegate>
-
-@property (nonatomic, weak) id<EXUtilitiesInterface> utils;
-@property (nonatomic, strong) EXPromiseResolveBlock resolve;
-@property (nonatomic, strong) EXPromiseRejectBlock reject;
-
-@end
-
-@implementation EXSMSModule
-
-EX_EXPORT_MODULE(ExpoSMS);
-
-- (dispatch_queue_t)methodQueue
-{
-  // Everything in this module uses `MFMessageComposeViewController` which is a subclass of UIViewController,
-  // so everything should be called from main thread.
-  return dispatch_get_main_queue();
-}
-
-- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
-{
-  _utils = [moduleRegistry getModuleImplementingProtocol:@protocol(EXUtilitiesInterface)];
-}
-
-EX_EXPORT_METHOD_AS(isAvailableAsync,
-                    isAvailable:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  resolve(@([MFMessageComposeViewController canSendText]));
-}
-
-EX_EXPORT_METHOD_AS(sendSMSAsync,
-                    sendSMS:(NSArray<NSString *> *)addresses
-                    message:(NSString *)message
-                    options:(NSDictionary *)options
-                    resolver:(EXPromiseResolveBlock)resolve
-                    rejecter:(EXPromiseRejectBlock)reject)
-{
-  if (![MFMessageComposeViewController canSendText]) {
-    reject(@"E_SMS_UNAVAILABLE", @"SMS service not available", nil);
-    return;
-  }
-  
-  if (_resolve != nil || _reject != nil) {
-    reject(@"E_SMS_SENDING_IN_PROGRESS", @"Different SMS sending in progress. Await the old request and then try again.", nil);
-    return;
-  }
-  
-  _resolve = resolve;
-  _reject = reject;
-
-  MFMessageComposeViewController *messageComposeViewController = [[MFMessageComposeViewController alloc] init];
-  messageComposeViewController.messageComposeDelegate = self;
-  messageComposeViewController.recipients = addresses;
-  messageComposeViewController.body = message;
-  
-  if (options) {
-    if (options[@"attachments"]) {
-      NSArray *attachments = (NSArray *) [options objectForKey:@"attachments"];
-      for (NSDictionary* attachment in attachments) {
-        NSString *mimeType = attachment[@"mimeType"];
-        CFStringRef mimeTypeRef = (__bridge CFStringRef)mimeType;
-        CFStringRef utiRef = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, mimeTypeRef, NULL);
-        if (utiRef == NULL) {
-          reject(@"E_SMS_ATTACHMENT", [NSString stringWithFormat:@"Failed to find UTI for mimeType: %@", mimeType], nil);
-          _resolve = nil;
-          _reject = nil;
-          return;
-        }
-        NSString *typeIdentifier = (__bridge_transfer NSString *)utiRef;
-        NSString *uri = attachment[@"uri"];
-        NSString *filename = attachment[@"filename"];
-        NSError *error;
-        NSData *attachmentData = [NSData dataWithContentsOfURL:[NSURL URLWithString:uri] options:(NSDataReadingOptions)0 error:&error];
-        bool attached = [messageComposeViewController addAttachmentData:attachmentData typeIdentifier:typeIdentifier filename:filename];
-        if (!attached) {
-          reject(@"E_SMS_ATTACHMENT", [NSString stringWithFormat:@"Failed to attach file: %@", uri], nil);
-          _resolve = nil;
-          _reject = nil;
-          return;
-        }
-      }
-    }
-  }
-
-  [self.utils.currentViewController presentViewController:messageComposeViewController animated:YES completion:nil];
-}
-
-- (void)messageComposeViewController:(MFMessageComposeViewController *)controller
-                 didFinishWithResult:(MessageComposeResult)result
-{
-  NSDictionary *resolveData;
-  NSString *rejectMessage;
-  switch (result) {
-    case MessageComposeResultCancelled:
-      resolveData = @{@"result": @"cancelled"};
-      break;
-    case MessageComposeResultSent:
-      resolveData = @{@"result": @"sent"};
-      break;
-    case MessageComposeResultFailed:
-      rejectMessage = @"User's attempt to save or send an SMS was unsuccessful. This can occur when the device loses connection to Wifi or Cellular.";
-      break;
-    default:
-      rejectMessage = @"SMS message sending failed with unknown error";
-      break;
-  }
-  EX_WEAKIFY(self);
-  [controller dismissViewControllerAnimated:YES completion:^{
-    EX_ENSURE_STRONGIFY(self);
-    if (rejectMessage) {
-      self->_reject(@"E_SMS_SENDING_FAILED", rejectMessage, nil);
-    } else {
-      self->_resolve(resolveData);
-    }
-    self->_reject = nil;
-    self->_resolve = nil;
-  }];
-}
-    
-@end

package/unimodule.json

@@ -1,4 +0,0 @@
-{
-  "name": "expo-sms",
-  "platforms": ["ios", "android"]
-}