@onekeyfe/react-native-native-list 3.0.105

package/android/src/main/java/com/onekey/nativelist/NativeListAdapter.kt

@@ -0,0 +1,165 @@
+package com.margelo.nitro.nativelist
+
+import android.view.ViewGroup
+import androidx.recyclerview.widget.AsyncDifferConfig
+import androidx.recyclerview.widget.AsyncListDiffer
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListUpdateCallback
+import androidx.recyclerview.widget.RecyclerView
+import com.facebook.react.uimanager.ThemedReactContext
+import org.json.JSONObject
+import java.util.Collections
+import java.util.WeakHashMap
+
+internal class NativeListAdapter(
+  private val context: ThemedReactContext,
+) : RecyclerView.Adapter<NativeListViewHolder>() {
+  private var suppressDifferUpdates = false
+  private var reorderItems: MutableList<NativeListItem>? = null
+  private val differ = AsyncListDiffer(
+    object : ListUpdateCallback {
+      override fun onInserted(position: Int, count: Int) {
+        if (!suppressDifferUpdates) notifyItemRangeInserted(position, count)
+      }
+
+      override fun onRemoved(position: Int, count: Int) {
+        if (!suppressDifferUpdates) notifyItemRangeRemoved(position, count)
+      }
+
+      override fun onMoved(fromPosition: Int, toPosition: Int) {
+        if (!suppressDifferUpdates) notifyItemMoved(fromPosition, toPosition)
+      }
+
+      override fun onChanged(position: Int, count: Int, payload: Any?) {
+        if (!suppressDifferUpdates) notifyItemRangeChanged(position, count, payload)
+      }
+    },
+    AsyncDifferConfig.Builder(DIFF).build(),
+  )
+  val currentList: List<NativeListItem>
+    get() = differ.currentList
+  private val createdRows = Collections.newSetFromMap(
+    WeakHashMap<NativeListRowView, Boolean>(),
+  )
+  var theme: JSONObject? = null
+  var layout: String = "linear"
+  var orientation: String = "vertical"
+  var selectedKeys: Set<String> = emptySet()
+  var checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String = { _, _, fallback -> fallback }
+  var onRowPress: ((NativeListItem, NativeListActionOrigin) -> Unit)? = null
+  var onAction: ((NativeListItem, String, NativeSelectionTarget?, NativeListActionOrigin?) -> Unit)? = null
+  var onBindingInvalidated: ((NativeListRowView, Long) -> Unit)? = null
+
+  override fun getItemCount(): Int = reorderItems?.size ?: differ.currentList.size
+
+  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): NativeListViewHolder {
+    val view = NativeListRowView(context)
+    view.layoutParams = ViewGroup.LayoutParams(
+      ViewGroup.LayoutParams.MATCH_PARENT,
+      ViewGroup.LayoutParams.WRAP_CONTENT,
+    )
+    view.onRowPress = { item, origin -> onRowPress?.invoke(item, origin) }
+    view.onAction = { item, actionKey, target, origin ->
+      onAction?.invoke(item, actionKey, target, origin)
+    }
+    view.onBindingInvalidated = { row, epoch -> onBindingInvalidated?.invoke(row, epoch) }
+    createdRows.add(view)
+    return NativeListViewHolder(view)
+  }
+
+  override fun onBindViewHolder(holder: NativeListViewHolder, position: Int) {
+    val item = itemAt(position) ?: return
+    holder.rowView.bind(
+      item,
+      theme,
+      layout,
+      orientation,
+      position,
+      selectedKeys.contains(item.key),
+      checkboxState,
+    )
+  }
+
+  override fun onBindViewHolder(
+    holder: NativeListViewHolder,
+    position: Int,
+    payloads: MutableList<Any>,
+  ) {
+    if (payloads.contains(SELECTION_PAYLOAD)) {
+      val item = itemAt(position) ?: return
+      holder.rowView.bindSelection(
+        item,
+        theme,
+        layout,
+        position,
+        selectedKeys.contains(item.key),
+        checkboxState,
+      )
+      return
+    }
+    onBindViewHolder(holder, position)
+  }
+
+  override fun onViewRecycled(holder: NativeListViewHolder) {
+    holder.rowView.recycle()
+    super.onViewRecycled(holder)
+  }
+
+  fun itemAt(position: Int): NativeListItem? =
+    reorderItems?.getOrNull(position) ?: differ.currentList.getOrNull(position)
+
+  fun positionOfKey(key: String): Int =
+    (reorderItems ?: differ.currentList).indexOfFirst { it.key == key }
+
+  fun submitList(items: List<NativeListItem>, commitCallback: (() -> Unit)? = null) {
+    if (reorderItems != null) {
+      reorderItems = null
+      notifyDataSetChanged()
+    }
+    differ.submitList(items.toList()) { commitCallback?.invoke() }
+  }
+
+  fun moveReordered(from: Int, to: Int): List<NativeListItem>? {
+    val items = reorderItems ?: differ.currentList.toMutableList().also { reorderItems = it }
+    if (from !in items.indices || to !in items.indices) return null
+    val moved = items.removeAt(from)
+    items.add(to, moved)
+    notifyItemMoved(from, to)
+    return items
+  }
+
+  fun commitReordered(items: List<NativeListItem>, commitCallback: () -> Unit) {
+    val committed = items.toList()
+    suppressDifferUpdates = true
+    differ.submitList(committed) {
+      reorderItems = null
+      suppressDifferUpdates = false
+      commitCallback()
+    }
+  }
+
+  fun cancelReorder() {
+    if (reorderItems == null) return
+    reorderItems = null
+    notifyDataSetChanged()
+  }
+
+  fun dispose() {
+    reorderItems = null
+    suppressDifferUpdates = false
+    createdRows.forEach(NativeListRowView::dispose)
+    createdRows.clear()
+  }
+
+  companion object {
+    private val DIFF = object : DiffUtil.ItemCallback<NativeListItem>() {
+      override fun areItemsTheSame(oldItem: NativeListItem, newItem: NativeListItem): Boolean =
+        oldItem.key == newItem.key && oldItem.type == newItem.type
+
+      override fun areContentsTheSame(oldItem: NativeListItem, newItem: NativeListItem): Boolean =
+        oldItem.revision == newItem.revision && oldItem.content == newItem.content
+    }
+  }
+}
+
+internal const val SELECTION_PAYLOAD = "selection"

package/android/src/main/java/com/onekey/nativelist/NativeListModels.kt

@@ -0,0 +1,147 @@
+package com.margelo.nitro.nativelist
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal data class NativeListItem(
+  val key: String,
+  val type: String,
+  val sectionKey: String?,
+  val revision: Int,
+  val json: JSONObject,
+) {
+  val content: String = json.toString()
+
+  val isSelectable: Boolean
+    get() = !json.optBoolean("disabled", false) && type in SELECTABLE_TYPES
+
+  val isReorderable: Boolean
+    get() {
+      if (json.optBoolean("disabled", false)) return false
+      if (type == "rail" && json.optBoolean("draggable", false)) return true
+      if (type == "identity" && json.optBoolean("draggable", false)) return true
+      if (type == "walletGroup" && json.optBoolean("draggable", false)) return true
+      val trailing = json.optJSONArray("trailing") ?: return false
+      return (0 until trailing.length()).any { index ->
+        trailing.optJSONObject(index)?.optString("kind") == "drag"
+      }
+    }
+
+  companion object {
+    private val SELECTABLE_TYPES = setOf(
+      "identity",
+      "rail",
+      "activity",
+      "message",
+      "dataRow",
+      "mediaTile",
+      "metricCard",
+    )
+
+    fun parse(json: JSONObject): NativeListItem {
+      val key = json.getString("key")
+      val type = json.getString("type")
+      return NativeListItem(
+        key = key,
+        type = type,
+        sectionKey = json.optString("sectionKey").takeIf { it.isNotEmpty() },
+        revision = json.optInt("revision", 0),
+        json = json,
+      )
+    }
+  }
+}
+
+internal data class NativeListConfig(
+  val generation: Int,
+  val layout: String,
+  val orientation: String,
+  val gridColumns: Int,
+  val stickyHeaders: Boolean,
+  val contentPadding: Int,
+  val contentPaddingHorizontal: Int?,
+  val contentPaddingTop: Int?,
+  val contentPaddingBottom: Int?,
+  val itemSpacing: Int,
+  val selectionMode: String,
+  val rowPressToggles: Boolean,
+  val selectedKeys: LinkedHashSet<String>,
+  val reorderable: Boolean,
+  val pullToRefresh: Boolean,
+  val refreshing: Boolean,
+  val loadMore: Boolean,
+  val endReachedThreshold: Double,
+  val sectionIndexEnabled: Boolean,
+  val sectionIndexHapticsEnabled: Boolean,
+  val theme: JSONObject?,
+  val fixedFooter: NativeListItem?,
+  val items: List<NativeListItem>,
+) {
+  companion object {
+    fun parse(snapshotJson: String): NativeListConfig {
+      val root = JSONObject(snapshotJson)
+      require(root.getInt("schemaVersion") == 1) { "Unsupported schemaVersion" }
+      val layout = root.getJSONObject("layout")
+      val selection = root.optJSONObject("selection")
+      val capabilities = root.optJSONObject("capabilities")
+      val sectionIndex = capabilities?.optJSONObject("sectionIndex")
+      val rowArray = root.getJSONArray("rows")
+      val items = ArrayList<NativeListItem>(rowArray.length())
+      val keys = HashSet<String>(rowArray.length())
+      for (index in 0 until rowArray.length()) {
+        val item = NativeListItem.parse(rowArray.getJSONObject(index))
+        require(keys.add(item.key)) { "Duplicate row key: ${item.key}" }
+        items.add(item)
+      }
+      if (items.isEmpty()) {
+        root.optJSONObject("emptyState")?.let { items.add(NativeListItem.parse(it)) }
+      }
+      val selectedKeys = LinkedHashSet<String>()
+      selection?.optJSONArray("selectedKeys")?.forEachString { selectedKeys.add(it) }
+      require(selectedKeys.all(keys::contains)) { "Selection contains an unknown row key" }
+      val fixedFooter = root.optJSONObject("fixedFooter")?.let(NativeListItem::parse)
+      return NativeListConfig(
+        generation = root.getInt("generation"),
+        layout = layout.getString("kind"),
+        orientation = layout.optString("orientation", "vertical"),
+        gridColumns = layout.optInt("gridColumns", 1).coerceIn(1, 4),
+        stickyHeaders = layout.optBoolean("stickyHeaders", false),
+        contentPadding = layout.optInt("contentPadding", 0).coerceAtLeast(0),
+        contentPaddingHorizontal = layout.optionalNonNegativeInt("contentPaddingHorizontal"),
+        contentPaddingTop = layout.optionalNonNegativeInt("contentPaddingTop"),
+        contentPaddingBottom = layout.optionalNonNegativeInt("contentPaddingBottom"),
+        itemSpacing = layout.optInt("itemSpacing", 0).coerceAtLeast(0),
+        selectionMode = selection?.optString("mode", "none") ?: "none",
+        rowPressToggles = selection?.optBoolean("rowPressToggles", false) ?: false,
+        selectedKeys = selectedKeys,
+        reorderable = capabilities?.optBoolean("reorderable", false) ?: false,
+        pullToRefresh = capabilities?.optBoolean("pullToRefresh", false) ?: false,
+        refreshing = capabilities?.optBoolean("refreshing", false) ?: false,
+        loadMore = capabilities?.optBoolean("loadMore", false) ?: false,
+        endReachedThreshold = capabilities?.optDouble("endReachedThreshold", 0.2) ?: 0.2,
+        sectionIndexEnabled = sectionIndex?.optBoolean("enabled", false) ?: false,
+        sectionIndexHapticsEnabled = sectionIndex?.optBoolean("hapticsEnabled", true) ?: true,
+        theme = root.optJSONObject("theme"),
+        fixedFooter = fixedFooter,
+        items = items,
+      )
+    }
+  }
+}
+
+private fun JSONObject.optionalNonNegativeInt(key: String): Int? =
+  if (has(key) && !isNull(key)) optInt(key).coerceAtLeast(0) else null
+
+internal inline fun JSONArray.forEachString(block: (String) -> Unit) {
+  for (index in 0 until length()) block(getString(index))
+}
+
+internal fun mergeRow(original: JSONObject, changes: JSONObject): JSONObject {
+  val result = JSONObject(original.toString())
+  val keys = changes.keys()
+  while (keys.hasNext()) {
+    val key = keys.next()
+    if (key != "key" && key != "type") result.put(key, changes.get(key))
+  }
+  return result
+}

package/android/src/main/java/com/onekey/nativelist/NativeListPackage.kt

@@ -0,0 +1,25 @@
+package com.margelo.nitro.nativelist
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.nativelist.views.HybridNativeListManager
+
+class NativeListPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider { HashMap() }
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext,
+  ): List<ViewManager<*, *>> = listOf(HybridNativeListManager())
+
+  companion object {
+    init {
+      System.loadLibrary("nativelist")
+    }
+  }
+}