@leonsilicon/react-native-wishlist 0.0.0

package/android/src/main/java/com/wishlist/TemplateInterceptor.kt

@@ -0,0 +1,29 @@
+package com.wishlist
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.views.view.ReactViewGroup
+
+class TemplateInterceptor(reactContext: Context) :
+    ReactViewGroup(reactContext), ViewGroup.OnHierarchyChangeListener {
+  private var wishlist: Wishlist? = null
+
+  init {
+    setOnHierarchyChangeListener(this)
+  }
+
+  override fun onChildViewAdded(parent: View, child: View) {
+    if (child is Wishlist) {
+      wishlist = child
+    } else if (child is TemplateContainer && wishlist != null) {
+      child.wishlist = wishlist
+    }
+  }
+
+  override fun onChildViewRemoved(parent: View, child: View) {
+    if (child is Wishlist) {
+      wishlist = null
+    }
+  }
+}

package/android/src/main/java/com/wishlist/TemplateInterceptorViewManager.kt

@@ -0,0 +1,23 @@
+package com.wishlist
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.viewmanagers.MGTemplateInterceptorManagerDelegate
+import com.facebook.react.viewmanagers.MGTemplateInterceptorManagerInterface
+
+@ReactModule(name = TemplateInterceptorViewManager.REACT_CLASS)
+class TemplateInterceptorViewManager :
+    ViewGroupManager<TemplateInterceptor>(),
+    MGTemplateInterceptorManagerInterface<TemplateInterceptor> {
+  companion object {
+    const val REACT_CLASS = "MGTemplateInterceptor"
+  }
+
+  override fun getName() = REACT_CLASS
+
+  override fun createViewInstance(reactContext: ThemedReactContext) =
+      TemplateInterceptor(reactContext)
+
+  override fun getDelegate() = MGTemplateInterceptorManagerDelegate(this)
+}

package/android/src/main/java/com/wishlist/UIScheduler.kt

@@ -0,0 +1,15 @@
+package com.wishlist
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.UiThreadUtil
+
+@DoNotStrip
+class UIScheduler {
+  companion object {
+    @DoNotStrip
+    @JvmStatic
+    fun scheduleOnUI(runnable: Runnable) {
+      UiThreadUtil.runOnUiThread(runnable)
+    }
+  }
+}

package/android/src/main/java/com/wishlist/Wishlist.kt

@@ -0,0 +1,135 @@
+package com.wishlist
+
+import android.content.Context
+import android.view.View
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.views.scroll.ReactScrollView
+
+private const val VIEWPORT_CARER_KEY = 1
+private const val CONTENT_OFFSET_KEY = 2
+
+class Wishlist(reactContext: Context) : ReactScrollView(reactContext) {
+  var inflatorId: String? = null
+  var wishlistId: String? = null
+  var initialIndex: Int = 0
+  private var orchestrator: Orchestrator? = null
+  private var templatesRef: Int? = null
+  private var names: List<String>? = null
+  private var didInitialScroll = false
+  private val initialContentSize = 100000f
+  private var pendingScrollOffset = Int.MIN_VALUE
+  private var ignoreScrollEvents = false
+
+  init {
+    clipChildren = true
+    clipToPadding = true
+  }
+
+  fun setTemplates(templatesRef: Int, names: List<String>) {
+    this.templatesRef = templatesRef
+    this.names = names
+    renderIfReady()
+  }
+
+  private fun renderIfReady() {
+    val templatesRef = this.templatesRef
+    val inflatorId = this.inflatorId
+    val names = this.names
+    if (names == null || templatesRef == null || inflatorId == null || width == 0 || height == 0) {
+      return
+    }
+
+    var orchestrator = this.orchestrator
+    if (orchestrator == null) {
+      val viewportCarer = stateWrapper?.stateDataMapBuffer?.getInt(VIEWPORT_CARER_KEY) ?: return
+      orchestrator = Orchestrator(this, wishlistId!!, viewportCarer)
+      this.orchestrator = orchestrator
+    }
+
+    orchestrator.renderAsync(
+        PixelUtil.toDIPFromPixel(width.toFloat()),
+        PixelUtil.toDIPFromPixel(height.toFloat()),
+        initialContentSize,
+        initialIndex,
+        templatesRef,
+        names,
+        inflatorId)
+  }
+
+  private fun initialScrollIfReady() {
+    if (didInitialScroll) {
+      return
+    }
+    val contentView = getChildAt(0)
+    if (contentView == null || contentView.height == 0) {
+      return
+    }
+    scrollTo(0, PixelUtil.toPixelFromDIP(initialContentSize / 2).toInt())
+    didInitialScroll = true
+  }
+
+  override fun onLayoutChange(
+      v: View,
+      left: Int,
+      top: Int,
+      right: Int,
+      bottom: Int,
+      oldLeft: Int,
+      oldTop: Int,
+      oldRight: Int,
+      oldBottom: Int
+  ) {
+    super.onLayoutChange(v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom)
+    initialScrollIfReady()
+    maybeScrollToOffsetForContentChange()
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    super.onLayout(changed, l, t, r, b)
+
+    renderIfReady()
+    initialScrollIfReady()
+    maybeScrollToOffsetForContentChange()
+  }
+
+  override fun onScrollChanged(x: Int, y: Int, oldX: Int, oldY: Int) {
+    super.onScrollChanged(x, y, oldX, oldY)
+
+    if (ignoreScrollEvents) {
+      return
+    }
+
+    orchestrator?.didScrollAsync(
+        PixelUtil.toDIPFromPixel(width.toFloat()),
+        PixelUtil.toDIPFromPixel(height.toFloat()),
+        PixelUtil.toDIPFromPixel(y.toFloat()),
+        inflatorId!!)
+  }
+
+  fun scrollToItem(index: Int, animated: Boolean) {
+    orchestrator?.scrollToItem(index)
+  }
+
+  fun scrollToOffsetForContentChange(offset: Float) {
+    // State is updated before content view is laid out so update the
+    // scroll position in layout handler.
+    pendingScrollOffset = PixelUtil.toPixelFromDIP(offset).toInt()
+  }
+
+  private fun maybeScrollToOffsetForContentChange() {
+    if (pendingScrollOffset == Int.MIN_VALUE) {
+      return
+    }
+    val contentView = getChildAt(0)
+    if (contentView == null ||
+        contentView.height == 0 ||
+        pendingScrollOffset > contentView.height) {
+      return
+    }
+    ignoreScrollEvents = true
+    scrollTo(0, pendingScrollOffset)
+    orchestrator?.didUpdateContentOffset()
+    ignoreScrollEvents = false
+    pendingScrollOffset = Int.MIN_VALUE
+  }
+}

package/android/src/main/java/com/wishlist/WishlistManagerModule.kt

@@ -0,0 +1,51 @@
+package com.wishlist
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.fabric.FabricUIManager
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+
+@ReactModule(name = WishlistManagerModule.NAME)
+class WishlistManagerModule(reactContext: ReactApplicationContext) :
+    NativeWishlistManagerSpec(reactContext) {
+  companion object {
+    const val NAME = "WishlistManager"
+
+    init {
+      WishlistSoLoader.staticInit()
+    }
+  }
+
+  @field:DoNotStrip private val mHybridData = initHybrid()
+
+  override fun getName() = NAME
+
+  @OptIn(FrameworkAPI::class)
+  override fun install(): Boolean = installInternal()
+
+  @FrameworkAPI
+  private fun installInternal(): Boolean {
+    val ctx = reactApplicationContext
+    val contextHolder = ctx.javaScriptContextHolder ?: return false
+    val callInvoker = ctx.jsCallInvokerHolder as? CallInvokerHolderImpl ?: return false
+    val fabricUIManager =
+        UIManagerHelper.getUIManager(ctx, UIManagerType.FABRIC) as? FabricUIManager
+            ?: return false
+    nativeInstall(contextHolder.get(), callInvoker, fabricUIManager)
+    return true
+  }
+
+  private external fun initHybrid(): HybridData
+
+  @FrameworkAPI
+  private external fun nativeInstall(
+      jsiRuntimeRef: Long,
+      jsCallInvokerHolder: CallInvokerHolderImpl,
+      fabricUIManager: FabricUIManager
+  )
+}

package/android/src/main/java/com/wishlist/WishlistPackage.kt

@@ -0,0 +1,47 @@
+package com.wishlist
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.ModuleSpec
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.module.annotations.ReactModuleList
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+@ReactModuleList(nativeModules = [WishlistManagerModule::class])
+class WishlistPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == WishlistManagerModule.NAME) {
+      WishlistManagerModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getViewManagers(reactContext: ReactApplicationContext): List<ModuleSpec> {
+    return listOf(
+        ModuleSpec.viewManagerSpec { WishlistViewManager() },
+        ModuleSpec.viewManagerSpec { TemplateContainerViewManager() },
+        ModuleSpec.viewManagerSpec { TemplateInterceptorViewManager() },
+        ModuleSpec.viewManagerSpec { ContentContainerViewManager() })
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val reactModule =
+          WishlistManagerModule::class.java.getAnnotation(ReactModule::class.java)
+              ?: throw IllegalStateException("WishlistManagerModule must have @ReactModule")
+
+      mapOf(
+          WishlistManagerModule.NAME to
+              ReactModuleInfo(
+                  reactModule.name,
+                  WishlistManagerModule::class.java.name,
+                  reactModule.canOverrideExistingModule,
+                  reactModule.needsEagerInit,
+                  reactModule.isCxxModule,
+                  true))
+    }
+  }
+}

package/android/src/main/java/com/wishlist/WishlistSoLoader.kt

@@ -0,0 +1,17 @@
+package com.wishlist
+
+import com.facebook.soloader.SoLoader
+
+class WishlistSoLoader {
+  companion object {
+    @Volatile private var didInit = false
+
+    fun staticInit() {
+      if (didInit) {
+        return
+      }
+      SoLoader.loadLibrary("react_codegen_wishlist")
+      didInit = true
+    }
+  }
+}

package/android/src/main/java/com/wishlist/WishlistViewManager.kt

@@ -0,0 +1,69 @@
+package com.wishlist
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.MGWishlistManagerDelegate
+import com.facebook.react.viewmanagers.MGWishlistManagerInterface
+
+private const val CONTENT_OFFSET_KEY = 2
+
+@ReactModule(name = WishlistViewManager.REACT_CLASS)
+class WishlistViewManager : ViewGroupManager<Wishlist>(), MGWishlistManagerInterface<Wishlist> {
+  companion object {
+    const val REACT_CLASS = "MGWishlist"
+  }
+
+  private val mDelegate = MGWishlistManagerDelegate(this)
+
+  override fun getName() = REACT_CLASS
+
+  override fun createViewInstance(reactContext: ThemedReactContext) = Wishlist(reactContext)
+
+  override fun getDelegate() = mDelegate
+
+  override fun updateState(
+      view: Wishlist,
+      props: ReactStylesDiffMap?,
+      stateWrapper: StateWrapper?
+  ): Any? {
+    if (stateWrapper != null) {
+      view.setStateWrapper(stateWrapper)
+    }
+    val stateData = stateWrapper?.stateDataMapBuffer
+    if (stateData != null && stateData.contains(CONTENT_OFFSET_KEY)) {
+      view.scrollToOffsetForContentChange(stateData.getDouble(CONTENT_OFFSET_KEY).toFloat())
+    }
+    return null
+  }
+
+  @ReactProp(name = "inflatorId")
+  override fun setInflatorId(view: Wishlist, value: String?) {
+    view.inflatorId = value
+  }
+
+  @ReactProp(name = "initialIndex")
+  override fun setInitialIndex(view: Wishlist, value: Int) {
+    view.initialIndex = value
+  }
+
+  override fun scrollToItem(view: Wishlist, index: Int, animated: Boolean) {
+    view.scrollToItem(index, animated)
+  }
+
+  override fun receiveCommand(root: Wishlist, commandId: String, args: ReadableArray?) {
+    mDelegate.receiveCommand(root, commandId, args)
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    val map: MutableMap<String, Any> = mutableMapOf()
+    map["topStartReached"] = MapBuilder.of("registrationName", "onStartReached")
+    map["topEndReached"] = MapBuilder.of("registrationName", "onEndReached")
+    return map
+  }
+}

package/android/src/main/jni/ErrorHandlerAndroid.cpp

@@ -0,0 +1,16 @@
+#include "ErrorHandlerAndroid.h"
+
+#include <fbjni/fbjni.h>
+#include <react/jni/JReactCxxErrorHandler.h>
+
+namespace Wishlist {
+
+using namespace facebook;
+
+void ErrorHandlerAndroid::reportError(const std::string &message) {
+  // TODO: Our thread should have access to JVM by default.
+  jni::ThreadScope::WithClassLoader(
+      [&] { react::JReactCxxErrorHandler::handleError(message); });
+}
+
+}; // namespace Wishlist

package/android/src/main/jni/ErrorHandlerAndroid.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+#include "MGErrorHandler.h"
+
+namespace Wishlist {
+
+class ErrorHandlerAndroid final : public MGErrorHandler {
+ public:
+  void reportError(const std::string &message) override;
+};
+
+} // namespace Wishlist

package/android/src/main/jni/JNIStateRegistry.cpp

@@ -0,0 +1,22 @@
+#include "JNIStateRegistry.h"
+
+namespace Wishlist {
+
+JNIStateRegistry &JNIStateRegistry::getInstance() {
+  static JNIStateRegistry instance;
+  return instance;
+}
+
+JNIStateRegistry::JNIStateRegistry() : idGenerator_(0) {}
+
+void *JNIStateRegistry::getValue(int id) {
+  return values_[id];
+}
+
+int JNIStateRegistry::addValue(void *value) {
+  int id = idGenerator_++;
+  values_[id] = value;
+  return id;
+}
+
+}; // namespace Wishlist

package/android/src/main/jni/JNIStateRegistry.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <unordered_map>
+
+namespace Wishlist {
+
+class JNIStateRegistry {
+ public:
+  static JNIStateRegistry &getInstance();
+
+  void *getValue(int id);
+  int addValue(void *value);
+
+ private:
+  JNIStateRegistry();
+  JNIStateRegistry(const JNIStateRegistry &) = delete;
+  JNIStateRegistry &operator=(const JNIStateRegistry &) = delete;
+
+  std::unordered_map<int, void *> values_;
+  int idGenerator_;
+};
+
+} // namespace Wishlist

package/android/src/main/jni/OnLoad.cpp

@@ -0,0 +1,12 @@
+#include <fbjni/fbjni.h>
+#include "Orchestrator.hpp"
+#include "WishlistManagerModule.hpp"
+
+using namespace Wishlist;
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(vm, [] {
+    WishlistManagerModule::registerNatives();
+    Orchestrator::registerNatives();
+  });
+}

package/android/src/main/jni/Orchestrator.cpp

@@ -0,0 +1,167 @@
+#include "Orchestrator.hpp"
+
+#include <fbjni/fbjni.h>
+#include "ErrorHandlerAndroid.h"
+#include "JNIStateRegistry.h"
+#include "MGDataBindingImpl.hpp"
+#include "MGUIManagerHolder.h"
+#include "MGViewportCarerImpl.h"
+#include "UISchedulerAndroid.h"
+#include "WishlistJsRuntime.h"
+
+using namespace facebook;
+
+namespace Wishlist {
+
+static inline std::vector<std::string> jListToVector(
+    alias_ref<jni::JList<jni::JString>> jList) {
+  std::vector<std::string> res;
+  for (const auto &val : *jList) {
+    res.push_back(val->toStdString());
+  }
+  return res;
+}
+
+jni::local_ref<Orchestrator::jhybriddata> Orchestrator::initHybrid(
+    jni::alias_ref<jhybridobject> jThis,
+    std::string wishlistId,
+    int viewportCarerRef) {
+  return makeCxxInstance(jThis, wishlistId, viewportCarerRef);
+}
+
+Orchestrator::Orchestrator(
+    jni::alias_ref<Orchestrator::javaobject> jThis,
+    const std::string &wishlistId,
+    int viewportCarerRef)
+    : javaPart_(jni::make_global(jThis)),
+      alreadyRendered_(false),
+      pendingScrollToItem_(-1) {
+  adapter_ = std::make_shared<Adapter>(
+      [this]() { handleVSync(); },
+      [this](std::vector<Item> items) { didPushChildren(std::move(items)); });
+  auto viewportCarer =
+      *reinterpret_cast<std::shared_ptr<MGViewportCarerImpl> *>(
+          JNIStateRegistry::getInstance().getValue(viewportCarerRef));
+  di_ = std::make_shared<MGDIImpl>();
+  di_->setViewportCarer(viewportCarer);
+  viewportCarer->setDI(di_);
+  viewportCarer->setListener(std::weak_ptr<Adapter>(adapter_));
+  di_->setDataBinding(
+      std::make_shared<MGDataBindingImpl>(wishlistId, di_->getWeak()));
+  di_->setVSyncRequester(adapter_);
+  di_->setUIScheduler(std::make_shared<UISchedulerAndroid>());
+  di_->setErrorHandler(std::make_shared<ErrorHandlerAndroid>());
+}
+
+void Orchestrator::renderAsync(
+    float width,
+    float height,
+    float initialContentSize,
+    int originItem,
+    int templatesRef,
+    jni::alias_ref<jni::JList<jni::JString>> namesList,
+    std::string inflatorId) {
+  auto templates =
+      *reinterpret_cast<std::vector<std::shared_ptr<ShadowNode const>> *>(
+          JNIStateRegistry::getInstance().getValue(templatesRef));
+  if (!alreadyRendered_ && namesList->size() > 0 &&
+      namesList->size() == templates.size()) {
+    alreadyRendered_ = true;
+    width_ = width;
+    height_ = height;
+    inflatorId_ = inflatorId;
+
+    di_->getViewportCarer()->initialRenderAsync(
+        {width, height},
+        initialContentSize,
+        originItem,
+        templates,
+        jListToVector(namesList),
+        inflatorId);
+  } else {
+    width_ = width;
+    height_ = height;
+    inflatorId_ = inflatorId;
+    handleVSync();
+  }
+}
+
+void Orchestrator::didScrollAsync(
+    float width,
+    float height,
+    float contentOffset,
+    std::string inflatorId) {
+  width_ = width;
+  height_ = height;
+  inflatorId_ = inflatorId;
+  di_->getViewportCarer()->didScrollAsync(
+      {width, height}, contentOffset, inflatorId);
+}
+
+void Orchestrator::handleVSync() {
+  di_->getViewportCarer()->didScrollAsync(
+      {width_, height_}, MG_NO_OFFSET, inflatorId_);
+}
+
+void Orchestrator::didUpdateContentOffset() {
+  di_->getViewportCarer()->didUpdateContentOffset();
+}
+
+void Orchestrator::scrollToItem(int index) {
+  float offset = -1;
+  for (auto &item : items_) {
+    if (item.index == index) {
+      offset = item.offset;
+      break;
+    }
+  }
+
+  static const auto scrollToOffset =
+      javaClassStatic()->getMethod<void(float)>("scrollToOffset");
+
+  if (offset == -1) {
+    pendingScrollToItem_ = index;
+    bool isBelow = items_.back().index < index;
+    // TODO: Implement proper animation for items outside the window.
+    if (isBelow) {
+      scrollToOffset(javaPart_, items_.back().offset + 1000);
+    } else {
+      scrollToOffset(javaPart_, items_.front().offset - 1000);
+    }
+  } else {
+    pendingScrollToItem_ = -1;
+    scrollToOffset(javaPart_, offset);
+  }
+}
+
+void Orchestrator::didPushChildren(std::vector<Item> items) {
+  items_ = std::move(items);
+  if (pendingScrollToItem_ != -1) {
+    scrollToItem(pendingScrollToItem_);
+  }
+}
+
+Orchestrator::Adapter::Adapter(
+    std::function<void()> onRequestVSync,
+    std::function<void(std::vector<Item> items)> didPushChildren)
+    : onRequestVSync_(onRequestVSync), didPushChildren_(didPushChildren) {}
+
+void Orchestrator::Adapter::didPushChildren(std::vector<Item> newWindow) {
+  didPushChildren_(std::move(newWindow));
+}
+
+void Orchestrator::Adapter::requestVSync() {
+  onRequestVSync_();
+}
+
+void Orchestrator::registerNatives() {
+  registerHybrid(
+      {makeNativeMethod("initHybrid", Orchestrator::initHybrid),
+       makeNativeMethod("renderAsync", Orchestrator::renderAsync),
+       makeNativeMethod("didScrollAsync", Orchestrator::didScrollAsync),
+       makeNativeMethod(
+           "didUpdateContentOffset", Orchestrator::didUpdateContentOffset),
+       makeNativeMethod("scrollToItem", Orchestrator::scrollToItem)});
+}
+
+} // namespace Wishlist