one 2.6.17 → 2.6.19

package/One.podspec

@@ -47,6 +47,8 @@ Pod::Spec.new do |s|
   s.prefix_header_contents = "#ifdef __OBJC__\n#import <React/RCTView.h>\n#import <UserNotifications/UserNotifications.h>\n#import <Social/Social.h>\n#endif\n#ifdef __cplusplus\n#include \"One-Swift-Cxx-Bridge.hpp\"\n#endif"
 
   s.dependency 'RNWorklets'
+  # webp encoding has no system encoder on ios; expo-image-manipulator uses the same coder.
+  s.dependency 'SDWebImageWebPCoder'
 
   install_modules_dependencies(s)
 end

package/android/src/main/java/com/margelo/nitro/one/HybridOneDevice.kt

@@ -1,16 +1,23 @@
 package com.margelo.nitro.one
 
 import android.app.UiModeManager
+import android.content.BroadcastReceiver
 import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
 import android.content.res.Configuration
 import android.os.Build
 import android.os.LocaleList
 import android.provider.Settings
+import android.text.TextUtils
+import android.text.format.DateFormat
+import android.view.View
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 import java.util.Calendar
 import java.util.Currency
 import java.util.Locale
+import java.text.DecimalFormatSymbols
 import java.util.TimeZone
 
 // device snapshot matching the ios shape: model, system, idiom,
@@ -58,6 +65,117 @@ class HybridOneDevice : HybridOneDeviceSpec() {
         )
     }
 
+    private val listeners = mutableMapOf<Int, () -> Unit>()
+    private var nextListenerId = 0
+    private var receiver: BroadcastReceiver? = null
+
+    override fun getLocales(): Array<LocaleInfo> =
+        preferredLocales().map { localeInfo(it) }.toTypedArray()
+
+    override fun getCalendars(): Array<CalendarInfo> {
+        val locale = Locale.getDefault()
+        val calendar = Calendar.getInstance(locale)
+        return arrayOf(
+            CalendarInfo(
+                calendar = unicodeCalendar(locale),
+                timeZone = TimeZone.getDefault().id,
+                uses24hourClock = DateFormat.is24HourFormat(context()),
+                firstWeekday = calendar.firstDayOfWeek.toDouble()
+            )
+        )
+    }
+
+    // the first listener registers the receiver and the last removal
+    // unregisters it, so a locale change can never race the subscription.
+    @Synchronized
+    override fun addLocalizationListener(listener: () -> Unit): () -> Unit {
+        val id = nextListenerId++
+        listeners[id] = listener
+        if (receiver == null) {
+            val next = object : BroadcastReceiver() {
+                override fun onReceive(context: Context?, intent: Intent?) = emit()
+            }
+            val filter = IntentFilter().apply {
+                addAction(Intent.ACTION_LOCALE_CHANGED)
+                addAction(Intent.ACTION_TIMEZONE_CHANGED)
+            }
+            // both actions are protected system broadcasts, so no exported
+            // flag is needed and no other app can send them.
+            context().registerReceiver(next, filter)
+            receiver = next
+        }
+        return { removeListener(id) }
+    }
+
+    private fun emit() {
+        val current = synchronized(this) { listeners.values.toList() }
+        current.forEach { it() }
+    }
+
+    @Synchronized
+    private fun removeListener(id: Int) {
+        listeners.remove(id)
+        if (listeners.isEmpty()) {
+            receiver?.let { context().unregisterReceiver(it) }
+            receiver = null
+        }
+    }
+
+    private fun preferredLocales(): List<Locale> {
+        if (Build.VERSION.SDK_INT >= 24) {
+            val list = LocaleList.getDefault()
+            if (!list.isEmpty) return (0 until list.size()).map { list[it] }
+        }
+        return listOf(Locale.getDefault())
+    }
+
+    private fun localeInfo(locale: Locale): LocaleInfo {
+        val symbols = DecimalFormatSymbols(locale)
+        val currency = try {
+            Currency.getInstance(locale)
+        } catch (_: Exception) {
+            null
+        }
+        val region = locale.country.takeIf { it.isNotEmpty() }
+        return LocaleInfo(
+            languageTag = locale.toLanguageTag(),
+            languageCode = locale.language.takeIf { it.isNotEmpty() },
+            languageScriptCode = locale.script.takeIf { it.isNotEmpty() },
+            regionCode = region,
+            languageRegionCode = region,
+            currencyCode = currency?.currencyCode,
+            currencySymbol = currency?.getSymbol(locale),
+            languageCurrencyCode = currency?.currencyCode,
+            languageCurrencySymbol = currency?.getSymbol(locale),
+            decimalSeparator = symbols.decimalSeparator.toString(),
+            digitGroupingSeparator = symbols.groupingSeparator.toString(),
+            textDirection =
+                if (TextUtils.getLayoutDirectionFromLocale(locale) == View.LAYOUT_DIRECTION_RTL) {
+                    "rtl"
+                } else {
+                    "ltr"
+                },
+            measurementSystem = when (region) {
+                "US" -> "us"
+                "GB" -> "uk"
+                null -> null
+                else -> "metric"
+            },
+            temperatureUnit = when (region) {
+                null -> null
+                in FAHRENHEIT_REGIONS -> "fahrenheit"
+                else -> "celsius"
+            }
+        )
+    }
+
+    // java calendar type to the unicode calendar type expo reports.
+    private fun unicodeCalendar(locale: Locale): String =
+        when (val type = calendarType(locale)) {
+            "gregorian" -> "gregory"
+            else -> type
+        }
+
     private fun idiom(context: Context): String {
         val uiMode = context.getSystemService(Context.UI_MODE_SERVICE) as? UiModeManager
         if (uiMode?.currentModeType == Configuration.UI_MODE_TYPE_TELEVISION) return "tv"
@@ -103,3 +221,9 @@ class HybridOneDevice : HybridOneDeviceSpec() {
             hardware in setOf("goldfish", "ranchu", "vbox86")
     }
 }
+
+// regions that read temperature in fahrenheit. android has no temperature
+// preference, so the region decides, as in expo-localization.
+private val FAHRENHEIT_REGIONS = setOf(
+    "US", "BS", "BZ", "KY", "LR", "GU", "MH", "FM", "PW", "VI", "MP", "AS", "UM"
+)

package/android/src/main/java/com/margelo/nitro/one/HybridOneHaptics.kt

@@ -54,6 +54,37 @@ class HybridOneHaptics : HybridOneHapticsSpec() {
         )
     }
 
+    // expo-haptics performAndroidHapticsAsync: the HapticFeedbackConstants
+    // value itself. constants added after the device's api level are a no-op
+    // rather than a substitute feel the caller did not ask for. no-haptics
+    // (-1) is android's own "play nothing" constant.
+    override fun performAndroidHaptics(type: AndroidHaptic) {
+        val sdk = Build.VERSION.SDK_INT
+        val constant = when (type) {
+            AndroidHaptic.CLOCK_TICK -> HapticFeedbackConstants.CLOCK_TICK
+            AndroidHaptic.CONFIRM -> if (sdk >= 30) HapticFeedbackConstants.CONFIRM else return
+            AndroidHaptic.CONTEXT_CLICK -> HapticFeedbackConstants.CONTEXT_CLICK
+            AndroidHaptic.DRAG_START -> if (sdk >= 34) HapticFeedbackConstants.DRAG_START else return
+            AndroidHaptic.GESTURE_END -> if (sdk >= 30) HapticFeedbackConstants.GESTURE_END else return
+            AndroidHaptic.GESTURE_START -> if (sdk >= 30) HapticFeedbackConstants.GESTURE_START else return
+            AndroidHaptic.KEYBOARD_PRESS -> HapticFeedbackConstants.KEYBOARD_PRESS
+            AndroidHaptic.KEYBOARD_RELEASE -> HapticFeedbackConstants.KEYBOARD_RELEASE
+            AndroidHaptic.KEYBOARD_TAP -> HapticFeedbackConstants.KEYBOARD_TAP
+            AndroidHaptic.LONG_PRESS -> HapticFeedbackConstants.LONG_PRESS
+            AndroidHaptic.NO_HAPTICS -> -1
+            AndroidHaptic.REJECT -> if (sdk >= 30) HapticFeedbackConstants.REJECT else return
+            AndroidHaptic.SEGMENT_FREQUENT_TICK ->
+                if (sdk >= 34) HapticFeedbackConstants.SEGMENT_FREQUENT_TICK else return
+            AndroidHaptic.SEGMENT_TICK -> if (sdk >= 34) HapticFeedbackConstants.SEGMENT_TICK else return
+            AndroidHaptic.TEXT_HANDLE_MOVE -> HapticFeedbackConstants.TEXT_HANDLE_MOVE
+            AndroidHaptic.TOGGLE_OFF -> if (sdk >= 34) HapticFeedbackConstants.TOGGLE_OFF else return
+            AndroidHaptic.TOGGLE_ON -> if (sdk >= 34) HapticFeedbackConstants.TOGGLE_ON else return
+            AndroidHaptic.VIRTUAL_KEY -> HapticFeedbackConstants.VIRTUAL_KEY
+            AndroidHaptic.VIRTUAL_KEY_RELEASE -> HapticFeedbackConstants.VIRTUAL_KEY_RELEASE
+        }
+        perform(constant)
+    }
+
     override fun notification(type: HapticNotification) {
         perform(
             when (type) {

package/android/src/main/java/com/margelo/nitro/one/HybridOneImageManipulator.kt

@@ -5,6 +5,7 @@ import android.graphics.BitmapFactory
 import android.graphics.Matrix
 import android.media.ExifInterface
 import android.net.Uri
+import android.os.Build
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 import java.io.File
@@ -40,10 +41,10 @@ class HybridOneImageManipulator : HybridOneImageManipulatorSpec() {
         if (!source.isFile) throw problem("FILE", "file does not exist")
         val quality = options.quality ?: 0.9
         if (options.format == OneImageFormat.PNG && options.quality != null) {
-            throw problem("INPUT", "quality applies only to JPEG")
+            throw problem("INPUT", "quality applies only to JPEG or WebP")
         }
         if (!quality.isFinite() || quality < 0 || quality > 1) {
-            throw problem("INPUT", "JPEG quality must be between 0 and 1")
+            throw problem("INPUT", "quality must be between 0 and 1")
         }
         var image = BitmapFactory.decodeFile(source.path) ?: throw problem("DECODE", "source is not a supported image")
         fun replace(next: Bitmap) {
@@ -90,14 +91,33 @@ class HybridOneImageManipulator : HybridOneImageManipulatorSpec() {
                     replace(Bitmap.createBitmap(image, 0, 0, image.width, image.height, rotation, true))
                 }
             }
+            options.flip?.let { flip ->
+                val mirror = Matrix()
+                when (flip) {
+                    OneImageFlip.HORIZONTAL -> mirror.preScale(-1f, 1f)
+                    OneImageFlip.VERTICAL -> mirror.preScale(1f, -1f)
+                }
+                replace(Bitmap.createBitmap(image, 0, 0, image.width, image.height, mirror, true))
+            }
             checkOutputSize(image.width, image.height)
             val folder = File(context.cacheDir, "OneImageManipulator")
             if (!folder.isDirectory && !folder.mkdirs()) throw problem("ENCODE", "cannot create output directory")
-            val png = options.format == OneImageFormat.PNG
-            val output = File(folder, "${UUID.randomUUID()}.${if (png) "png" else "jpg"}")
+            val compressFormat = when (options.format) {
+                OneImageFormat.PNG -> Bitmap.CompressFormat.PNG
+                OneImageFormat.JPEG -> Bitmap.CompressFormat.JPEG
+                OneImageFormat.WEBP ->
+                    if (Build.VERSION.SDK_INT >= 30) Bitmap.CompressFormat.WEBP_LOSSY
+                    else @Suppress("DEPRECATION") Bitmap.CompressFormat.WEBP
+            }
+            val ext = when (options.format) {
+                OneImageFormat.PNG -> "png"
+                OneImageFormat.JPEG -> "jpg"
+                OneImageFormat.WEBP -> "webp"
+            }
+            val output = File(folder, "${UUID.randomUUID()}.$ext")
             try {
                 output.outputStream().use { stream ->
-                    if (!image.compress(if (png) Bitmap.CompressFormat.PNG else Bitmap.CompressFormat.JPEG,
+                    if (!image.compress(compressFormat,
                         (quality * 100).roundToInt(), stream)) throw problem("ENCODE", "encoding failed")
                 }
             } catch (error: Exception) { output.delete(); throw error }

package/android/src/main/java/com/margelo/nitro/one/HybridOneKeepAwake.kt

@@ -7,12 +7,13 @@ import com.facebook.react.bridge.LifecycleEventListener
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 
-// screen-on lock matching the ios global: the desired state is held in
-// memory, readable and writable with no activity present, applied to the
-// current window when one exists, and re-applied on resume so activity
-// recreation never silently drops it. no rejection path.
+// screen-on locks keyed by expo activation tags: the screen stays awake
+// while any tag is active. the desired state is held in memory, readable
+// and writable with no activity present, applied to the current window when
+// one exists, and re-applied on resume so activity recreation never
+// silently drops it. no rejection path.
 class HybridOneKeepAwake : HybridOneKeepAwakeSpec(), LifecycleEventListener {
-    @Volatile private var desired = false
+    private val tags = mutableSetOf<String>()
     private val mainHandler = Handler(Looper.getMainLooper())
 
     init {
@@ -26,22 +27,42 @@ class HybridOneKeepAwake : HybridOneKeepAwakeSpec(), LifecycleEventListener {
 
     override fun isEnabled(): Promise<Boolean> {
         val promise = Promise<Boolean>()
-        mainHandler.post { promise.resolve(desired) }
+        mainHandler.post { promise.resolve(tags.isNotEmpty()) }
         return promise
     }
 
     override fun setEnabled(enabled: Boolean): Promise<Unit> {
         val promise = Promise<Unit>()
         mainHandler.post {
-            desired = enabled
-            apply(desired)
+            if (enabled) tags.add(DEFAULT_TAG) else tags.remove(DEFAULT_TAG)
+            apply(tags.isNotEmpty())
+            promise.resolve(Unit)
+        }
+        return promise
+    }
+
+    override fun activate(tag: String): Promise<Unit> {
+        val promise = Promise<Unit>()
+        mainHandler.post {
+            tags.add(tag)
+            apply(true)
+            promise.resolve(Unit)
+        }
+        return promise
+    }
+
+    override fun deactivate(tag: String): Promise<Unit> {
+        val promise = Promise<Unit>()
+        mainHandler.post {
+            tags.remove(tag)
+            apply(tags.isNotEmpty())
             promise.resolve(Unit)
         }
         return promise
     }
 
     override fun onHostResume() {
-        apply(desired)
+        apply(tags.isNotEmpty())
     }
 
     override fun onHostPause() {}
@@ -56,4 +77,8 @@ class HybridOneKeepAwake : HybridOneKeepAwakeSpec(), LifecycleEventListener {
             window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
         }
     }
+
+    companion object {
+        private const val DEFAULT_TAG = "ExpoKeepAwakeDefaultTag"
+    }
 }