react-native-platform-components 1.4.0 → 1.5.0

package/android/src/main/java/com/platformcomponents/PCFloatingToolbarView.kt

@@ -3,7 +3,12 @@ package com.platformcomponents
 import android.content.Context
 import android.content.res.ColorStateList
 import android.graphics.Color
+import android.view.View
+import android.view.ViewTreeObserver
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
 import androidx.core.content.res.ResourcesCompat
+import com.facebook.react.uimanager.util.ReactFindViewUtil
 import com.google.android.material.R as MaterialR
 import com.google.android.material.color.MaterialColors
 import com.google.android.material.floatingtoolbar.FloatingToolbarLayout
@@ -40,6 +45,27 @@ class PCFloatingToolbarView(context: Context) :
     applyColors()
   }
 
+  // --- Linked scroll view ---
+  var scrollViewNativeID: String = ""
+  var hideOnScroll: Boolean = false
+  private var watchedScrollView: View? = null
+  private var watchedObserver: ViewTreeObserver? = null
+  private var lastScrollY = 0
+  private var scrollHidden = false
+  private val scrollViewFinder = object : ReactFindViewUtil.OnViewFoundListener {
+    override fun getNativeId(): String = scrollViewNativeID
+    override fun onViewFound(view: View) = watch(view)
+  }
+  // A tree observer rather than the view's own scroll listener, which a
+  // TabBar linked to the same ScrollView would replace
+  private val scrollListener = ViewTreeObserver.OnScrollChangedListener {
+    val view = watchedScrollView ?: return@OnScrollChangedListener
+    val scrollY = view.scrollY
+    val dy = scrollY - lastScrollY
+    lastScrollY = scrollY
+    onContentScrolled(scrollY, dy)
+  }
+
   init {
     clipChildren = false
     clipToPadding = false
@@ -87,13 +113,119 @@ class PCFloatingToolbarView(context: Context) :
     }
   }
 
+  // ---- Hide on scroll ----
+  // Material's HideViewOnScrollBehavior only works in a CoordinatorLayout,
+  // which a React Native screen doesn't have. The toolbar does its motion
+  // itself, as TabBar does: it slides past its edge of the linked ScrollView
+  // (175 ms out, 225 ms back) while the content scrolls down, and returns as
+  // it scrolls up or reaches the top. The host view moves, so React Native's
+  // touch targeting follows it and the content underneath takes the touches.
+
+  fun applyScrollViewNativeID(value: String) {
+    if (scrollViewNativeID == value) return
+    scrollViewNativeID = value
+    findScrollView()
+  }
+
+  fun applyHideOnScroll(value: Boolean) {
+    if (hideOnScroll == value) return
+    hideOnScroll = value
+    if (!value) setScrollHidden(false)
+  }
+
+  /** The ScrollView with scrollViewNativeID, now or once it mounts. */
+  private fun findScrollView() {
+    unwatch()
+    ReactFindViewUtil.removeViewListener(scrollViewFinder)
+    if (scrollViewNativeID.isEmpty() || !isAttachedToWindow) return
+    val found = ReactFindViewUtil.findView(rootView, scrollViewNativeID)
+    if (found != null) watch(found) else ReactFindViewUtil.addViewListener(scrollViewFinder)
+  }
+
+  private fun watch(view: View) {
+    ReactFindViewUtil.removeViewListener(scrollViewFinder)
+    unwatch()
+    watchedScrollView = view
+    lastScrollY = view.scrollY
+    watchedObserver = view.viewTreeObserver.also { it.addOnScrollChangedListener(scrollListener) }
+  }
+
+  private fun unwatch() {
+    watchedObserver?.takeIf { it.isAlive }?.removeOnScrollChangedListener(scrollListener)
+    watchedObserver = null
+    watchedScrollView = null
+    if (scrollHidden) {
+      scrollHidden = false
+      animate().cancel()
+      translationX = 0f
+      translationY = 0f
+    }
+  }
+
+  private fun onContentScrolled(scrollY: Int, dy: Int) {
+    if (!hideOnScroll || dy == 0) return
+    // Back at the top the toolbar always shows
+    setScrollHidden(scrollY > 0 && dy > 0)
+  }
+
+  private fun setScrollHidden(hide: Boolean) {
+    if (scrollHidden == hide) return
+    scrollHidden = hide
+    val (dx, dy) = if (hide) hiddenTranslation() else 0f to 0f
+    animate().cancel()
+    animate()
+      .translationX(dx)
+      .translationY(dy)
+      .setDuration(if (hide) 175L else 225L)
+      .setInterpolator(if (hide) AccelerateInterpolator() else DecelerateInterpolator())
+      .start()
+  }
+
+  /**
+   * How far to move to get past the linked edge: top or bottom for a
+   * horizontal toolbar, left or right for a vertical one, from the toolbar to
+   * that edge of the ScrollView plus the elevation shadow, and at least the
+   * toolbar's own size.
+   */
+  private fun hiddenTranslation(): Pair<Float, Float> {
+    val scrollView = watchedScrollView ?: return 0f to 0f
+    val here = IntArray(2).also { getLocationInWindow(it) }
+    val there = IntArray(2).also { scrollView.getLocationInWindow(it) }
+    // Where the toolbar sits without the translation it may have
+    val left = here[0] - translationX
+    val top = here[1] - translationY
+    val right = left + width
+    val bottom = top + height
+    val scrollLeft = there[0].toFloat()
+    val scrollTop = there[1].toFloat()
+    val scrollRight = scrollLeft + scrollView.width
+    val scrollBottom = scrollTop + scrollView.height
+    val shadow = elevation
+    return if (width >= height) {
+      if (top + bottom < scrollTop + scrollBottom) {
+        0f to minOf(scrollTop - bottom - shadow, -height.toFloat())
+      } else {
+        0f to maxOf(scrollBottom - top + shadow, height.toFloat())
+      }
+    } else {
+      if (left + right < scrollLeft + scrollRight) {
+        minOf(scrollLeft - right - shadow, -width.toFloat()) to 0f
+      } else {
+        maxOf(scrollRight - left + shadow, width.toFloat()) to 0f
+      }
+    }
+  }
+
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
     PCNativeTheme.addListener(nativeThemeListener)
     PCNativeTheme.attach(context)
+    if (watchedScrollView == null) findScrollView()
   }
 
   override fun onDetachedFromWindow() {
+    ReactFindViewUtil.removeViewListener(scrollViewFinder)
+    unwatch()
     PCNativeTheme.removeListener(nativeThemeListener)
     super.onDetachedFromWindow()
   }

package/android/src/main/java/com/platformcomponents/PCFloatingToolbarViewManager.kt

@@ -37,6 +37,14 @@ class PCFloatingToolbarViewManager :
     view.applyColor(value)
   }
 
+  override fun setScrollViewNativeID(view: PCFloatingToolbarView, value: String?) {
+    view.applyScrollViewNativeID(value ?: "")
+  }
+
+  override fun setHideOnScroll(view: PCFloatingToolbarView, value: Boolean) {
+    view.applyHideOnScroll(value)
+  }
+
   override fun setIos(view: PCFloatingToolbarView, value: ReadableMap?) {
     // iOS props are ignored on Android
   }

package/android/src/main/java/com/platformcomponents/PCHaptics.kt

@@ -0,0 +1,46 @@
+package com.platformcomponents
+
+import android.os.Build
+import android.view.HapticFeedbackConstants
+import android.view.View
+
+/**
+ * The shared `haptics` prop: `View.performHapticFeedback` with the matching
+ * `HapticFeedbackConstants`, played when a control reports the user's action.
+ * The system touch-feedback setting applies (no ignore flags are passed).
+ */
+object PCHaptics {
+  /**
+   * Applies a `haptics` value to [view]: "none" turns off the haptics the view
+   * plays itself (such as a long press), anything else turns them back on.
+   * Returns the value for the view to keep ("" when unset).
+   */
+  fun configure(view: View, value: String?): String {
+    val kind = value ?: ""
+    view.isHapticFeedbackEnabled = kind != "none"
+    return kind
+  }
+
+  /** Plays [kind] on [view]; "" and "none" play nothing. */
+  fun perform(view: View, kind: String) {
+    val constant = constantFor(kind) ?: return
+    view.performHapticFeedback(constant)
+  }
+
+  /** The feedback constant for a `haptics` value, with fallbacks below the API level that added it. */
+  fun constantFor(kind: String): Int? = when (kind) {
+    "selection" ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) HapticFeedbackConstants.SEGMENT_TICK
+      else HapticFeedbackConstants.CLOCK_TICK
+    "light" -> HapticFeedbackConstants.CONTEXT_CLICK
+    "medium" -> HapticFeedbackConstants.VIRTUAL_KEY
+    "heavy" -> HapticFeedbackConstants.LONG_PRESS
+    "success" ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) HapticFeedbackConstants.CONFIRM
+      else HapticFeedbackConstants.VIRTUAL_KEY
+    "warning", "error" ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) HapticFeedbackConstants.REJECT
+      else HapticFeedbackConstants.LONG_PRESS
+    else -> null
+  }
+}

package/android/src/main/java/com/platformcomponents/PCImageLoader.kt

@@ -13,6 +13,8 @@ import android.util.LruCache
 import java.net.HttpURLConnection
 import java.net.URL
 import java.util.concurrent.Executors
+import org.json.JSONArray
+import org.json.JSONObject
 import kotlin.math.roundToInt
 
 /**
@@ -30,6 +32,9 @@ object PCImageLoader {
   private val executor = Executors.newFixedThreadPool(2)
   private val mainHandler = Handler(Looper.getMainLooper())
   private val cache = LruCache<String, Bitmap>(32)
+  private val cacheLock = Any()
+  private var nextGeneration = 0L
+  private val generations = mutableMapOf<String, Long>()
 
   /**
    * Loads [uri] and delivers the bitmap on the main thread. [scale] is the
@@ -38,37 +43,67 @@ object PCImageLoader {
    *
    * Cached images are delivered synchronously.
    */
-  fun load(context: Context, uri: String, scale: Float, callback: (Bitmap?) -> Unit) {
-    val key = "$uri@${scale}x"
-    cache.get(key)?.let {
+  fun load(context: Context, uri: String, scale: Float, request: String = "", callback: (Bitmap?) -> Unit) {
+    val options = try { if (request.isEmpty()) JSONObject() else JSONObject(request) }
+      catch (_: Exception) { callback(null); return }
+    val policy = options.optString("cache", "default")
+    options.remove("cache")
+    val key = JSONArray().put(uri).put(scale.toDouble()).put(options).toString()
+    val cached = if (policy == "reload") null else cache.get(key)
+    cached?.let {
       callback(it)
       return
     }
+    if (policy == "only-if-cached") { callback(null); return }
+    val generation = synchronized(cacheLock) {
+      nextGeneration += 1
+      generations[key] = nextGeneration
+      nextGeneration
+    }
 
     val appContext = context.applicationContext
     executor.execute {
+      var canCache = true
       val bitmap = try {
-        decode(appContext, uri)
+        decode(appContext, uri, options) { canCache = it }
       } catch (e: Exception) {
-        Log.w(TAG, "Failed to load $uri: ${e.message}")
+        // Image URIs may carry credentials or signed query parameters.
+        Log.w(TAG, "Failed to load image (${e.javaClass.simpleName})")
         null
       }
       if (bitmap != null) {
         bitmap.density = (scale.coerceAtLeast(0.01f) * DisplayMetrics.DENSITY_DEFAULT).roundToInt()
-        cache.put(key, bitmap)
+      }
+      synchronized(cacheLock) {
+        if (generations[key] == generation) {
+          if (bitmap != null && canCache) cache.put(key, bitmap) else cache.remove(key)
+          generations.remove(key)
+        }
       }
       mainHandler.post { callback(bitmap) }
     }
   }
 
-  private fun decode(context: Context, uri: String): Bitmap? {
+  private fun decode(context: Context, uri: String, options: JSONObject, cacheable: (Boolean) -> Unit): Bitmap? {
     val parsed = Uri.parse(uri)
     return when (parsed.scheme?.lowercase()) {
       "http", "https" -> {
         val connection = URL(uri).openConnection() as HttpURLConnection
         connection.connectTimeout = TIMEOUT_MS
         connection.readTimeout = TIMEOUT_MS
+        connection.useCaches = false
+        connection.instanceFollowRedirects = options.length() == 0
+        connection.requestMethod = options.optString("method", "GET")
+        options.optJSONObject("headers")?.let { headers ->
+          for (name in headers.keys()) connection.setRequestProperty(name, headers.getString(name))
+        }
         try {
+          if (options.has("body")) {
+            connection.doOutput = true
+            connection.outputStream.use { it.write(options.getString("body").toByteArray(Charsets.UTF_8)) }
+          }
+          if (connection.responseCode !in 200..299) return null
+          cacheable(!connection.getHeaderField("Cache-Control").orEmpty().contains("no-store", ignoreCase = true))
           connection.inputStream.use { BitmapFactory.decodeStream(it) }
         } finally {
           connection.disconnect()

package/android/src/main/java/com/platformcomponents/PCLiquidGlassContainerView.kt

@@ -0,0 +1,32 @@
+package com.platformcomponents
+
+import android.content.Context
+import android.view.ViewGroup
+
+/**
+ * Android implementation of LiquidGlassContainer.
+ *
+ * Glass containers are an iOS 26 feature, so on Android this is a plain
+ * container: React lays out the children, and `spacing` has no effect.
+ */
+class PCLiquidGlassContainerView(context: Context) : ViewGroup(context) {
+
+    init {
+        clipChildren = false
+        clipToPadding = false
+    }
+
+    // ---- Layout ----
+    // Fabric sizes this view and positions its children.
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        setMeasuredDimension(
+            MeasureSpec.getSize(widthMeasureSpec),
+            MeasureSpec.getSize(heightMeasureSpec)
+        )
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        // No-op: Fabric lays out the children
+    }
+}

package/android/src/main/java/com/platformcomponents/PCLiquidGlassContainerViewManager.kt

@@ -0,0 +1,31 @@
+package com.platformcomponents
+
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.PCLiquidGlassContainerManagerDelegate
+import com.facebook.react.viewmanagers.PCLiquidGlassContainerManagerInterface
+
+/**
+ * Android ViewManager for LiquidGlassContainer: a plain container, since
+ * glass containers are iOS 26 only.
+ */
+class PCLiquidGlassContainerViewManager :
+    ViewGroupManager<PCLiquidGlassContainerView>(),
+    PCLiquidGlassContainerManagerInterface<PCLiquidGlassContainerView> {
+
+    private val delegate: ViewManagerDelegate<PCLiquidGlassContainerView> =
+        PCLiquidGlassContainerManagerDelegate(this)
+
+    override fun getName(): String = "PCLiquidGlassContainer"
+
+    override fun getDelegate(): ViewManagerDelegate<PCLiquidGlassContainerView> = delegate
+
+    override fun createViewInstance(reactContext: ThemedReactContext): PCLiquidGlassContainerView {
+        return PCLiquidGlassContainerView(reactContext)
+    }
+
+    override fun setSpacing(view: PCLiquidGlassContainerView, value: Float) {
+        // Glass merging is iOS only
+    }
+}

package/android/src/main/java/com/platformcomponents/PCLiquidGlassView.kt

@@ -24,6 +24,13 @@ class PCLiquidGlassView(context: Context) : FrameLayout(context) {
             updateBackground()
         }
 
+    /** "capsule" rounds to half the shorter side; anything else uses cornerRadius. */
+    var cornerStyle: String = ""
+        set(value) {
+            field = value
+            updateBackground()
+        }
+
     var fallbackBackgroundColor: String? = null
         set(value) {
             field = value
@@ -36,17 +43,22 @@ class PCLiquidGlassView(context: Context) : FrameLayout(context) {
         clipToPadding = false
     }
 
+    private fun cornerRadiusPx(): Float =
+        if (cornerStyle == "capsule") minOf(width, height) / 2f
+        else cornerRadius * resources.displayMetrics.density
+
     private fun updateBackground() {
         val bgColor = fallbackBackgroundColor?.let { ColorParser.parse(it) }
+        val radius = cornerRadiusPx()
 
-        if (cornerRadius > 0 || bgColor != null) {
+        if (radius > 0 || bgColor != null) {
             val drawable = GradientDrawable().apply {
                 shape = GradientDrawable.RECTANGLE
-                cornerRadii = FloatArray(8) { cornerRadius * resources.displayMetrics.density }
+                cornerRadii = FloatArray(8) { radius }
                 setColor(bgColor ?: Color.TRANSPARENT)
             }
             background = drawable
-            clipToOutline = cornerRadius > 0
+            clipToOutline = radius > 0
             outlineProvider = android.view.ViewOutlineProvider.BACKGROUND
         } else {
             background = null
@@ -54,10 +66,24 @@ class PCLiquidGlassView(context: Context) : FrameLayout(context) {
         }
     }
 
-    // ---- Measurement ----
+    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+        super.onSizeChanged(w, h, oldw, oldh)
+        // A capsule follows the size
+        if (cornerStyle == "capsule") updateBackground()
+    }
+
+    // ---- Layout ----
+    // Fabric sizes this view and positions its children; FrameLayout must not
+    // re-measure or re-position them against its own gravity.
 
     override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        // Standard FrameLayout measurement
-        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+        setMeasuredDimension(
+            MeasureSpec.getSize(widthMeasureSpec),
+            MeasureSpec.getSize(heightMeasureSpec)
+        )
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        // No-op: Fabric lays out the children
     }
 }

package/android/src/main/java/com/platformcomponents/PCLiquidGlassViewManager.kt

@@ -37,6 +37,10 @@ class PCLiquidGlassViewManager :
         view.cornerRadius = value
     }
 
+    override fun setCornerStyle(view: PCLiquidGlassView, value: String?) {
+        view.cornerStyle = value ?: ""
+    }
+
     override fun setIos(view: PCLiquidGlassView, value: ReadableMap?) {
         // iOS props are ignored on Android
     }