@webority-technologies/mobile-core 0.0.6 → 0.0.7

package/android/build.gradle

@@ -0,0 +1,65 @@
+buildscript {
+    ext.safeExtGet = { prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        gradlePluginPortal()
+    }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet("kotlinVersion", "2.1.20")}")
+    }
+}
+
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+
+android {
+    namespace "com.webority.mobilecore.smsretriever"
+
+    buildToolsVersion safeExtGet("buildToolsVersion", "36.0.0")
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+
+    buildFeatures {
+        buildConfig true
+    }
+    defaultConfig {
+        buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString())
+        minSdkVersion safeExtGet("minSdkVersion", 24)
+        targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+    lintOptions {
+        abortOnError false
+    }
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ["src/newarch"]
+            } else {
+                java.srcDirs += ["src/oldarch"]
+            }
+        }
+    }
+}
+
+repositories {
+    maven {
+        url("$rootDir/../node_modules/react-native/android")
+    }
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation "com.facebook.react:react-native:+"
+    implementation "com.google.android.gms:play-services-auth-api-phone:18.3.0"
+}

package/android/src/newarch/java/com/webority/mobilecore/smsretriever/AppSignatureHelper.kt

@@ -0,0 +1,57 @@
+package com.webority.mobilecore.smsretriever
+
+import android.content.pm.PackageManager
+import android.util.Base64
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import java.security.MessageDigest
+
+/**
+ * The 11-character app-signature hash the SMS Retriever API matches against
+ * an incoming message — the backend appends this same hash so Play Services
+ * knows which app to hand the SMS to, with no SMS permission granted.
+ * Algorithm is Google's own (SHA-256 of "<packageName> <signature>", first 9
+ * bytes, base64 NO_PADDING/NO_WRAP, first 11 chars) — not our own scheme.
+ */
+class AppSignatureHelper(private val context: ReactApplicationContext) {
+  companion object {
+    private const val HASH_TYPE = "SHA-256"
+    private const val NUM_HASHED_BYTES = 9
+    private const val NUM_BASE64_CHAR = 11
+    private const val TAG = "AppSignatureHelper"
+  }
+
+  fun getAppSignatures(): List<String> {
+    val appCodes = mutableListOf<String>()
+    try {
+      val packageName = context.packageName
+      val packageManager = context.packageManager
+      @Suppress("DEPRECATION")
+      val signatures = packageManager.getPackageInfo(
+        packageName,
+        PackageManager.GET_SIGNATURES
+      ).signatures
+
+      for (signature in signatures ?: emptyArray()) {
+        hash(packageName, signature.toCharsString())?.let { appCodes.add(it) }
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error getting app signature", e)
+    }
+    return appCodes
+  }
+
+  private fun hash(packageName: String, signature: String): String? {
+    val appInfo = "$packageName $signature"
+    return try {
+      val digest = MessageDigest.getInstance(HASH_TYPE)
+      digest.update(appInfo.toByteArray())
+      val truncated = digest.digest().copyOfRange(0, NUM_HASHED_BYTES)
+      Base64.encodeToString(truncated, Base64.NO_PADDING or Base64.NO_WRAP)
+        .substring(0, NUM_BASE64_CHAR)
+    } catch (e: Exception) {
+      Log.e(TAG, "Hash generation failed", e)
+      null
+    }
+  }
+}

package/android/src/newarch/java/com/webority/mobilecore/smsretriever/SmsRetrieverModule.kt

@@ -0,0 +1,20 @@
+package com.webority.mobilecore.smsretriever
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+
+class SmsRetrieverModule(reactContext: ReactApplicationContext) :
+  NativeSmsRetrieverSpec(reactContext) {
+
+  companion object {
+    const val NAME = "WeborityMobileCoreSmsRetriever"
+  }
+
+  private val impl = SmsRetrieverModuleImpl(reactContext)
+
+  override fun startSMSListener() = impl.startSMSListener()
+
+  override fun stopSMSListener() = impl.stopSMSListener()
+
+  override fun getAppHash(promise: Promise) = impl.getAppHash(promise)
+}

package/android/src/newarch/java/com/webority/mobilecore/smsretriever/SmsRetrieverModuleImpl.kt

@@ -0,0 +1,146 @@
+package com.webority.mobilecore.smsretriever
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.gms.auth.api.phone.SmsRetriever
+import com.google.android.gms.auth.api.phone.SmsRetrieverClient
+import com.google.android.gms.common.api.CommonStatusCodes
+import com.google.android.gms.common.api.Status
+
+private enum class SmsErrorType { TIMEOUT, SERVICE_UNAVAILABLE, UNKNOWN_ERROR }
+
+/**
+ * Wraps the Play Services SMS Retriever API. Emits the raw SMS text on
+ * success — OTP extraction is a JS-side concern (see smsRetriever/index.ts),
+ * since the expected format varies per backend and this module's only job
+ * is retrieving the message with no SMS permission required.
+ */
+class SmsRetrieverModuleImpl(private val reactContext: ReactApplicationContext) {
+  companion object {
+    const val NAME = "WeborityMobileCoreSmsRetriever"
+    private const val TAG = "SmsRetrieverModuleImpl"
+    private const val OTP_EVENT = "WeborityMobileCoreSmsRetrieved"
+    private const val ERROR_EVENT = "WeborityMobileCoreSmsRetrieverError"
+  }
+
+  private var isRegistered = false
+  private var isListening = false
+
+  private val receiver = object : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+      if (SmsRetriever.SMS_RETRIEVED_ACTION != intent.action) {
+        return
+      }
+      val status = intent.extras?.getParcelable<Status>(SmsRetriever.EXTRA_STATUS)
+      if (status == null) {
+        emitError(SmsErrorType.UNKNOWN_ERROR, "Invalid SMS status")
+        return
+      }
+      when (status.statusCode) {
+        CommonStatusCodes.SUCCESS -> {
+          val message = intent.extras?.getString(SmsRetriever.EXTRA_SMS_MESSAGE)
+          if (message.isNullOrBlank()) {
+            emitError(SmsErrorType.UNKNOWN_ERROR, "Empty SMS message")
+          } else {
+            emitMessage(message)
+          }
+        }
+        CommonStatusCodes.TIMEOUT ->
+          emitError(SmsErrorType.TIMEOUT, "SMS retrieval timeout")
+        else ->
+          emitError(SmsErrorType.SERVICE_UNAVAILABLE, "SMS Retriever status ${status.statusCode}")
+      }
+    }
+  }
+
+  private fun emitMessage(message: String) {
+    isListening = false
+    val payload = Arguments.createMap().apply { putString("message", message) }
+    reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(OTP_EVENT, payload)
+  }
+
+  private fun emitError(type: SmsErrorType, message: String) {
+    Log.w(TAG, "$type: $message")
+    isListening = false
+    val payload = Arguments.createMap().apply {
+      putString("type", type.name)
+      putString("message", message)
+    }
+    reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(ERROR_EVENT, payload)
+  }
+
+  fun startSMSListener() {
+    if (isListening) {
+      return
+    }
+    try {
+      val client: SmsRetrieverClient = SmsRetriever.getClient(reactContext)
+      client.startSmsRetriever()
+        .addOnSuccessListener {
+          registerReceiver()
+          isListening = true
+        }
+        .addOnFailureListener { exception ->
+          emitError(SmsErrorType.SERVICE_UNAVAILABLE, exception.message ?: "startSmsRetriever failed")
+        }
+    } catch (e: Exception) {
+      emitError(SmsErrorType.UNKNOWN_ERROR, e.message ?: "startSMSListener threw")
+    }
+  }
+
+  private fun registerReceiver() {
+    if (isRegistered) {
+      return
+    }
+    try {
+      val filter = IntentFilter(SmsRetriever.SMS_RETRIEVED_ACTION)
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        ContextCompat.registerReceiver(reactContext, receiver, filter, ContextCompat.RECEIVER_EXPORTED)
+      } else {
+        ContextCompat.registerReceiver(reactContext, receiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
+      }
+      isRegistered = true
+    } catch (e: Exception) {
+      emitError(SmsErrorType.UNKNOWN_ERROR, e.message ?: "Failed to register SMS receiver")
+    }
+  }
+
+  fun stopSMSListener() {
+    if (!isRegistered) {
+      isListening = false
+      return
+    }
+    try {
+      reactContext.unregisterReceiver(receiver)
+    } catch (e: IllegalArgumentException) {
+      // Already unregistered — not an error, the OS may have torn it down first.
+    } finally {
+      isRegistered = false
+      isListening = false
+    }
+  }
+
+  fun getAppHash(promise: Promise) {
+    try {
+      val hash = AppSignatureHelper(reactContext).getAppSignatures().firstOrNull()
+      if (hash == null) {
+        promise.reject("NO_SIGNATURES", "No app signatures found")
+      } else {
+        promise.resolve(hash)
+      }
+    } catch (e: Exception) {
+      promise.reject("HASH_ERROR", "Failed to get app hash: ${e.message}")
+    }
+  }
+}

package/android/src/newarch/java/com/webority/mobilecore/smsretriever/SmsRetrieverPackage.kt

@@ -0,0 +1,33 @@
+package com.webority.mobilecore.smsretriever
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class SmsRetrieverPackage : TurboReactPackage() {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == SmsRetrieverModule.NAME) {
+      SmsRetrieverModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      mapOf(
+          SmsRetrieverModule.NAME to
+              ReactModuleInfo(
+                  SmsRetrieverModule.NAME,
+                  SmsRetrieverModule.NAME,
+                  false, // canOverrideExistingModule
+                  false, // needsEagerInit
+                  false, // isCxxModule
+                  true // isTurboModule
+                  ))
+    }
+  }
+}

package/lib/commonjs/formatters/dateMath.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.startOfDay = exports.isSameDay = exports.isDateBefore = exports.isDateAfter = exports.formatTimeInZone = exports.formatTimeInWindowsZone = exports.formatTime12h = exports.formatDatePattern = exports.formatDateISO = exports.formatDateDDMMMYYYY = exports.diffMs = exports.addDays = void 0;
-var _windowsIana = require("windows-iana");
+var _windowsToIanaTable = require("./windowsToIanaTable.js");
 const toDate = value => {
   if (value instanceof Date) {
     return Number.isNaN(value.getTime()) ? null : value;
@@ -300,11 +300,11 @@ const formatTimeInZone = (value, ianaTimeZone) => {
  */
 exports.formatTimeInZone = formatTimeInZone;
 const formatTimeInWindowsZone = (value, windowsTimeZoneId) => {
-  const ianaTimeZones = (0, _windowsIana.findIana)(windowsTimeZoneId);
-  if (!ianaTimeZones || ianaTimeZones.length === 0) {
+  const ianaTimeZone = _windowsToIanaTable.WINDOWS_TO_IANA[windowsTimeZoneId];
+  if (!ianaTimeZone) {
     throw new Error(`Mapping for Windows time zone '${windowsTimeZoneId}' not found.`);
   }
-  return formatTimeInZone(value, ianaTimeZones[0]);
+  return formatTimeInZone(value, ianaTimeZone);
 };
 exports.formatTimeInWindowsZone = formatTimeInWindowsZone;
 //# sourceMappingURL=dateMath.js.map

package/lib/commonjs/formatters/windowsToIanaTable.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WINDOWS_TO_IANA = void 0;
+/**
+ * .NET-style Windows time zone ID → IANA time zone name, one entry per
+ * Windows zone, generated from CLDR's `windowsZones.xml` (the same
+ * upstream source the retired `windows-iana` npm package derived its own
+ * table from). Only the `territory="001"` (world-default) row is kept per
+ * Windows zone — `formatTimeInWindowsZone` only ever reads the first IANA
+ * candidate, and CLDR's `001` row is exactly that default candidate, so
+ * per-country territory variants (`US`, `CA`, `ZZ`, …) carry no information
+ * this table's one caller uses.
+ *
+ * Regenerate with `node packages/core/scripts/generate-windows-to-iana-table.mjs
+ * <path-to-windowsZones.xml>` (CLDR: `common/supplemental/windowsZones.xml` in
+ * https://github.com/unicode-org/cldr) whenever CLDR adds/renames a zone —
+ * this is a committed, static table; nothing fetches CLDR at build or test
+ * time.
+ */
+const WINDOWS_TO_IANA = exports.WINDOWS_TO_IANA = {
+  'AUS Central Standard Time': 'Australia/Darwin',
+  'AUS Eastern Standard Time': 'Australia/Sydney',
+  'Afghanistan Standard Time': 'Asia/Kabul',
+  'Alaskan Standard Time': 'America/Anchorage',
+  'Aleutian Standard Time': 'America/Adak',
+  'Altai Standard Time': 'Asia/Barnaul',
+  'Arab Standard Time': 'Asia/Riyadh',
+  'Arabian Standard Time': 'Asia/Dubai',
+  'Arabic Standard Time': 'Asia/Baghdad',
+  'Argentina Standard Time': 'America/Buenos_Aires',
+  'Astrakhan Standard Time': 'Europe/Astrakhan',
+  'Atlantic Standard Time': 'America/Halifax',
+  'Aus Central W. Standard Time': 'Australia/Eucla',
+  'Azerbaijan Standard Time': 'Asia/Baku',
+  'Azores Standard Time': 'Atlantic/Azores',
+  'Bahia Standard Time': 'America/Bahia',
+  'Bangladesh Standard Time': 'Asia/Dhaka',
+  'Belarus Standard Time': 'Europe/Minsk',
+  'Bougainville Standard Time': 'Pacific/Bougainville',
+  'Canada Central Standard Time': 'America/Regina',
+  'Cape Verde Standard Time': 'Atlantic/Cape_Verde',
+  'Caucasus Standard Time': 'Asia/Yerevan',
+  'Cen. Australia Standard Time': 'Australia/Adelaide',
+  'Central America Standard Time': 'America/Guatemala',
+  'Central Asia Standard Time': 'Asia/Almaty',
+  'Central Brazilian Standard Time': 'America/Cuiaba',
+  'Central Europe Standard Time': 'Europe/Budapest',
+  'Central European Standard Time': 'Europe/Warsaw',
+  'Central Pacific Standard Time': 'Pacific/Guadalcanal',
+  'Central Standard Time': 'America/Chicago',
+  'Central Standard Time (Mexico)': 'America/Mexico_City',
+  'Chatham Islands Standard Time': 'Pacific/Chatham',
+  'China Standard Time': 'Asia/Shanghai',
+  'Cuba Standard Time': 'America/Havana',
+  'Dateline Standard Time': 'Etc/GMT+12',
+  'E. Africa Standard Time': 'Africa/Nairobi',
+  'E. Australia Standard Time': 'Australia/Brisbane',
+  'E. Europe Standard Time': 'Europe/Chisinau',
+  'E. South America Standard Time': 'America/Sao_Paulo',
+  'Easter Island Standard Time': 'Pacific/Easter',
+  'Eastern Standard Time': 'America/New_York',
+  'Eastern Standard Time (Mexico)': 'America/Cancun',
+  'Egypt Standard Time': 'Africa/Cairo',
+  'Ekaterinburg Standard Time': 'Asia/Yekaterinburg',
+  'FLE Standard Time': 'Europe/Kiev',
+  'Fiji Standard Time': 'Pacific/Fiji',
+  'GMT Standard Time': 'Europe/London',
+  'GTB Standard Time': 'Europe/Bucharest',
+  'Georgian Standard Time': 'Asia/Tbilisi',
+  'Greenland Standard Time': 'America/Godthab',
+  'Greenwich Standard Time': 'Atlantic/Reykjavik',
+  'Haiti Standard Time': 'America/Port-au-Prince',
+  'Hawaiian Standard Time': 'Pacific/Honolulu',
+  'India Standard Time': 'Asia/Calcutta',
+  'Iran Standard Time': 'Asia/Tehran',
+  'Israel Standard Time': 'Asia/Jerusalem',
+  'Jordan Standard Time': 'Asia/Amman',
+  'Kaliningrad Standard Time': 'Europe/Kaliningrad',
+  'Korea Standard Time': 'Asia/Seoul',
+  'Libya Standard Time': 'Africa/Tripoli',
+  'Line Islands Standard Time': 'Pacific/Kiritimati',
+  'Lord Howe Standard Time': 'Australia/Lord_Howe',
+  'Magadan Standard Time': 'Asia/Magadan',
+  'Magallanes Standard Time': 'America/Punta_Arenas',
+  'Marquesas Standard Time': 'Pacific/Marquesas',
+  'Mauritius Standard Time': 'Indian/Mauritius',
+  'Middle East Standard Time': 'Asia/Beirut',
+  'Montevideo Standard Time': 'America/Montevideo',
+  'Morocco Standard Time': 'Africa/Casablanca',
+  'Mountain Standard Time': 'America/Denver',
+  'Mountain Standard Time (Mexico)': 'America/Chihuahua',
+  'Myanmar Standard Time': 'Asia/Rangoon',
+  'N. Central Asia Standard Time': 'Asia/Novosibirsk',
+  'Namibia Standard Time': 'Africa/Windhoek',
+  'Nepal Standard Time': 'Asia/Katmandu',
+  'New Zealand Standard Time': 'Pacific/Auckland',
+  'Newfoundland Standard Time': 'America/St_Johns',
+  'Norfolk Standard Time': 'Pacific/Norfolk',
+  'North Asia East Standard Time': 'Asia/Irkutsk',
+  'North Asia Standard Time': 'Asia/Krasnoyarsk',
+  'North Korea Standard Time': 'Asia/Pyongyang',
+  'Omsk Standard Time': 'Asia/Omsk',
+  'Pacific SA Standard Time': 'America/Santiago',
+  'Pacific Standard Time': 'America/Los_Angeles',
+  'Pacific Standard Time (Mexico)': 'America/Tijuana',
+  'Pakistan Standard Time': 'Asia/Karachi',
+  'Paraguay Standard Time': 'America/Asuncion',
+  'Qyzylorda Standard Time': 'Asia/Qyzylorda',
+  'Romance Standard Time': 'Europe/Paris',
+  'Russia Time Zone 10': 'Asia/Srednekolymsk',
+  'Russia Time Zone 11': 'Asia/Kamchatka',
+  'Russia Time Zone 3': 'Europe/Samara',
+  'Russian Standard Time': 'Europe/Moscow',
+  'SA Eastern Standard Time': 'America/Cayenne',
+  'SA Pacific Standard Time': 'America/Bogota',
+  'SA Western Standard Time': 'America/La_Paz',
+  'SE Asia Standard Time': 'Asia/Bangkok',
+  'Saint Pierre Standard Time': 'America/Miquelon',
+  'Sakhalin Standard Time': 'Asia/Sakhalin',
+  'Samoa Standard Time': 'Pacific/Apia',
+  'Sao Tome Standard Time': 'Africa/Sao_Tome',
+  'Saratov Standard Time': 'Europe/Saratov',
+  'Singapore Standard Time': 'Asia/Singapore',
+  'South Africa Standard Time': 'Africa/Johannesburg',
+  'South Sudan Standard Time': 'Africa/Juba',
+  'Sri Lanka Standard Time': 'Asia/Colombo',
+  'Sudan Standard Time': 'Africa/Khartoum',
+  'Syria Standard Time': 'Asia/Damascus',
+  'Taipei Standard Time': 'Asia/Taipei',
+  'Tasmania Standard Time': 'Australia/Hobart',
+  'Tocantins Standard Time': 'America/Araguaina',
+  'Tokyo Standard Time': 'Asia/Tokyo',
+  'Tomsk Standard Time': 'Asia/Tomsk',
+  'Tonga Standard Time': 'Pacific/Tongatapu',
+  'Transbaikal Standard Time': 'Asia/Chita',
+  'Turkey Standard Time': 'Europe/Istanbul',
+  'Turks And Caicos Standard Time': 'America/Grand_Turk',
+  'US Eastern Standard Time': 'America/Indianapolis',
+  'US Mountain Standard Time': 'America/Phoenix',
+  UTC: 'Etc/UTC',
+  'UTC+12': 'Etc/GMT-12',
+  'UTC+13': 'Etc/GMT-13',
+  'UTC-02': 'Etc/GMT+2',
+  'UTC-08': 'Etc/GMT+8',
+  'UTC-09': 'Etc/GMT+9',
+  'UTC-11': 'Etc/GMT+11',
+  'Ulaanbaatar Standard Time': 'Asia/Ulaanbaatar',
+  'Venezuela Standard Time': 'America/Caracas',
+  'Vladivostok Standard Time': 'Asia/Vladivostok',
+  'Volgograd Standard Time': 'Europe/Volgograd',
+  'W. Australia Standard Time': 'Australia/Perth',
+  'W. Central Africa Standard Time': 'Africa/Lagos',
+  'W. Europe Standard Time': 'Europe/Berlin',
+  'W. Mongolia Standard Time': 'Asia/Hovd',
+  'West Asia Standard Time': 'Asia/Tashkent',
+  'West Bank Standard Time': 'Asia/Hebron',
+  'West Pacific Standard Time': 'Pacific/Port_Moresby',
+  'Yakutsk Standard Time': 'Asia/Yakutsk',
+  'Yukon Standard Time': 'America/Whitehorse'
+};
+//# sourceMappingURL=windowsToIanaTable.js.map

package/lib/commonjs/geolocation/index.js

@@ -137,7 +137,7 @@ const ensureLocationPermission = async () => {
     return;
   }
   if (status === 'unavailable') {
-    _index.Logger.warn(`${PREFIX} Location permission status is unavailable (react-native-permissions is not ` + 'installed, or this platform has no mapping); attempting the location request anyway.');
+    _index.Logger.warn(`${PREFIX} Location permission status is unavailable (expo-location is not installed, ` + 'or the check failed); attempting the location request anyway.');
     return;
   }
   throw new GeolocationError('permission-denied', `${PREFIX} Location permission is "${status}". Grant it before requesting a position` + (status === 'blocked' ? ', or call Permissions.openSettings() to let the user fix it.' : '.'));