@leonsilicon/react-native-wishlist 0.0.0

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

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MGDIImpl.hpp"
+
+using namespace facebook;
+
+namespace Wishlist {
+
+class Orchestrator : public jni::HybridClass<Orchestrator> {
+ public:
+  Orchestrator(
+      jni::alias_ref<Orchestrator::javaobject> jThis,
+      const std::string &wishlistId,
+      int viewportCarerRef);
+
+  static constexpr auto kJavaDescriptor = "Lcom/wishlist/Orchestrator;";
+
+  static void registerNatives();
+
+ private:
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis,
+      std::string wishlistId,
+      int viewportCarerRef);
+
+  void renderAsync(
+      float width,
+      float height,
+      float initialContentSize,
+      int originItem,
+      int templatesRef,
+      jni::alias_ref<jni::JList<jni::JString>> names,
+      std::string inflatorId);
+
+  void didScrollAsync(
+      float width,
+      float height,
+      float contentOffset,
+      std::string inflatorId);
+
+  void handleVSync();
+
+  void didUpdateContentOffset();
+
+  void scrollToItem(int index);
+
+  void didPushChildren(std::vector<Item> items);
+
+  class Adapter final : public MGViewportCarerListener,
+                        public MGVSyncRequester {
+   public:
+    Adapter(
+        std::function<void()> onRequestVSync,
+        std::function<void(std::vector<Item> items)> didPushChildren);
+
+   private:
+    void didPushChildren(std::vector<Item> newWindow) override;
+    void requestVSync() override;
+
+    std::function<void()> onRequestVSync_;
+    std::function<void(std::vector<Item> items)> didPushChildren_;
+  };
+
+  friend HybridBase;
+
+  jni::global_ref<Orchestrator::javaobject> javaPart_;
+  bool alreadyRendered_;
+  std::shared_ptr<MGDIImpl> di_;
+  std::shared_ptr<Adapter> adapter_;
+  float width_;
+  float height_;
+  std::string inflatorId_;
+  std::vector<Item> items_;
+  int pendingScrollToItem_;
+};
+
+} // namespace Wishlist

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

@@ -0,0 +1,20 @@
+#include "UISchedulerAndroid.h"
+
+#include <fbjni/NativeRunnable.h>
+
+namespace Wishlist {
+
+using namespace facebook::jni;
+
+void UISchedulerAndroid::scheduleOnUI(std::function<void()> &&f) {
+  // TODO: Our thread should have access to JVM by default.
+  ThreadScope::WithClassLoader([&] {
+    static const auto cls = javaClassStatic();
+    static const auto method =
+        cls->getStaticMethod<void(JRunnable::javaobject)>("scheduleOnUI");
+    auto jrunnable = JNativeRunnable::newObjectCxxArgs(std::move(f));
+    method(cls, jrunnable.get());
+  });
+}
+
+}; // namespace Wishlist

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

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MGUIScheduler.hpp"
+
+namespace Wishlist {
+
+using namespace facebook::jni;
+
+class UISchedulerAndroid final : public JavaClass<UISchedulerAndroid>,
+                                 public MGUIScheduler {
+ public:
+  static auto constexpr kJavaDescriptor = "Lcom/wishlist/UIScheduler;";
+
+  void scheduleOnUI(std::function<void()> &&f) override;
+};
+
+}; // namespace Wishlist

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

@@ -0,0 +1,91 @@
+#include "WishlistManagerModule.hpp"
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/FabricUIManagerBinding.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
+#include "MGUIManagerHolder.h"
+#include "WishlistJsRuntime.h"
+
+using namespace facebook;
+using namespace facebook::react;
+
+namespace Wishlist {
+
+local_ref<WishlistManagerModule::jhybriddata> WishlistManagerModule::initHybrid(
+    alias_ref<jclass>) {
+  return makeCxxInstance();
+}
+
+WishlistManagerModule::WishlistManagerModule() {}
+
+WishlistManagerModule::~WishlistManagerModule() {
+  scheduler_->removeEventListener(eventListener_);
+}
+
+void WishlistManagerModule::nativeInstall(
+    jlong jsiRuntimeRef,
+    alias_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder,
+    alias_ref<JFabricUIManager::javaobject> fabricUIManager) {
+  auto jsiRuntime{reinterpret_cast<jsi::Runtime *>(jsiRuntimeRef)};
+  auto const &jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+  scheduler_ = fabricUIManager->getBinding()->getScheduler();
+
+  eventListener_ =
+      std::make_shared<EventListener>([this](const RawEvent &event) -> bool {
+        auto shadowNodeFamily = event.shadowNodeFamily.lock();
+        if (shadowNodeFamily == nullptr) {
+          return event.eventTarget != nullptr;
+        }
+
+        int tag = shadowNodeFamily->getTag();
+        if (tag >= 0) {
+          return shadowNodeFamily->getInstanceHandle() == nullptr;
+        }
+
+        auto eventPayload = event.eventPayload;
+        std::string type = event.type;
+        WishlistJsRuntime::getInstance().accessRuntime(
+            [this, type = std::move(type), tag, eventPayload](
+                jsi::Runtime &rt) {
+              try {
+                auto handleEvent =
+                    rt.global()
+                        .getPropertyAsObject(rt, "global")
+                        .getPropertyAsFunction(rt, "handleEvent");
+                jsi::Value payload = eventPayload
+                    ? eventPayload->asJSIValue(rt)
+                    : jsi::Value::null();
+                handleEvent.call(rt, type, tag, payload);
+              } catch (std::exception &error) {
+                if (errorHandler_) {
+                  errorHandler_->reportError(error.what());
+                }
+              }
+            });
+
+        return true;
+      });
+  scheduler_->addEventListener(eventListener_);
+
+  wishlistQueue_ = std::make_shared<WishlistDispatchQueue>();
+
+  WishlistJsRuntime::getInstance().initialize(
+      jsiRuntime,
+      [=](std::function<void()> &&f) {
+        jsCallInvoker->invokeAsync(std::move(f));
+      },
+      [=](std::function<void()> &&f) {
+        wishlistQueue_->dispatch(std::move(f));
+      });
+
+  MGUIManagerHolder::getInstance().setUIManager(scheduler_->getUIManager());
+}
+
+void WishlistManagerModule::registerNatives() {
+  registerHybrid(
+      {makeNativeMethod("initHybrid", WishlistManagerModule::initHybrid),
+       makeNativeMethod(
+           "nativeInstall", WishlistManagerModule::nativeInstall)});
+}
+
+} // namespace Wishlist

package/android/src/main/jni/WishlistManagerModule.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <react/fabric/JFabricUIManager.h>
+#include <react/renderer/core/EventListener.h>
+#include <react/renderer/scheduler/Scheduler.h>
+#include "ErrorHandlerAndroid.h"
+#include "WishlistJsRuntime.h"
+
+using namespace facebook::react;
+using namespace facebook::jni;
+
+namespace Wishlist {
+
+class WishlistManagerModule : public HybridClass<WishlistManagerModule> {
+ public:
+  WishlistManagerModule();
+  ~WishlistManagerModule();
+
+  static constexpr auto kJavaDescriptor =
+      "Lcom/wishlist/WishlistManagerModule;";
+
+  static void registerNatives();
+
+ private:
+  static local_ref<jhybriddata> initHybrid(alias_ref<jclass>);
+
+  void nativeInstall(
+      jlong jsiRuntimeRef,
+      alias_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder,
+      alias_ref<JFabricUIManager::javaobject> fabricUIManager);
+
+ private:
+  friend HybridBase;
+
+  std::shared_ptr<WishlistDispatchQueue> wishlistQueue_;
+  std::shared_ptr<Scheduler> scheduler_;
+  std::shared_ptr<EventListener> eventListener_;
+  std::shared_ptr<ErrorHandlerAndroid> errorHandler_;
+};
+
+} // namespace Wishlist

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

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+#include "MGContentContainerComponentDescriptor.h"
+#include "MGTemplateContainerComponentDescriptor.h"
+#include "MGWishlistComponentDescriptor.h"
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> wishlist_ModuleProvider(
+    const std::string &moduleName,
+    const JavaTurboModule::InitParams &params);
+
+} // namespace react
+} // namespace facebook

package/cpp/ContentContainer/MGContentContainerComponentDescriptor.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <iostream>
+#include "MGContentContainerShadowNode.h"
+
+namespace facebook {
+namespace react {
+
+class MGContentContainerComponentDescriptor
+    : public ConcreteComponentDescriptor<MGContentContainerShadowNode> {
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  std::shared_ptr<ShadowNode> cloneShadowNode(
+      const ShadowNode &sourceShadowNode,
+      const ShadowNodeFragment &fragment) const override {
+    // React holds on to old shadow nodes so we need to make sure to get the
+    // latest state when cloning those to get the children that were set by
+    // Wishlist.
+    auto &mostRecentStateData = static_cast<ConcreteState const *>(
+                                    sourceShadowNode.getMostRecentState().get())
+                                    ->getData();
+    auto wishlistChildren = mostRecentStateData.wishlistChildren;
+    auto children =
+        wishlistChildren
+            ? std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
+                  *wishlistChildren)
+            : fragment.children;
+    auto shadowNode = std::make_shared<MGContentContainerShadowNode>(
+        sourceShadowNode,
+        ShadowNodeFragment{fragment.props, children, fragment.state});
+
+    adopt(*shadowNode);
+    return shadowNode;
+  }
+};
+
+} // namespace react
+} // namespace facebook

package/cpp/ContentContainer/MGContentContainerShadowNode.cpp

@@ -0,0 +1,21 @@
+#include "MGContentContainerShadowNode.h"
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/wishlist/Props.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+extern const char MGContentContainerComponentName[] = "MGContentContainer";
+
+void MGContentContainerShadowNode::setWishlistChildren(
+    const std::shared_ptr<WishlistChildrenList> &wishlistChildren) {
+  auto state = getStateData();
+  if (state.wishlistChildren != wishlistChildren) {
+    state.wishlistChildren = wishlistChildren;
+    setStateData(std::move(state));
+  }
+}
+
+} // namespace react
+} // namespace facebook

package/cpp/ContentContainer/MGContentContainerShadowNode.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/wishlist/Props.h>
+#include "MGContentContainerState.h"
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT extern const char MGContentContainerComponentName[];
+
+/*
+ * `ShadowNode` for <MGContentContainer> component.
+ */
+class JSI_EXPORT MGContentContainerShadowNode final
+    : public ConcreteViewShadowNode<
+          MGContentContainerComponentName,
+          MGContentContainerProps,
+          ViewEventEmitter,
+          MGContentContainerState> {
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+ public:
+  void setWishlistChildren(
+      const std::shared_ptr<WishlistChildrenList> &wishlistChildren);
+};
+
+} // namespace react
+} // namespace facebook

package/cpp/ContentContainer/MGContentContainerState.cpp

@@ -0,0 +1,31 @@
+#include "MGContentContainerState.h"
+
+namespace facebook {
+namespace react {
+
+MGContentContainerState::MGContentContainerState()
+    : wishlistChildren(nullptr) {}
+
+MGContentContainerState::MGContentContainerState(
+    const std::shared_ptr<WishlistChildrenList> &wishlistChildren)
+    : wishlistChildren(wishlistChildren) {}
+
+#ifdef ANDROID
+
+MGContentContainerState::MGContentContainerState(
+    MGContentContainerState const &previousState,
+    folly::dynamic /*data*/)
+    : wishlistChildren(previousState.wishlistChildren) {}
+
+folly::dynamic MGContentContainerState::getDynamic() const {
+  return folly::dynamic::object;
+}
+
+MapBuffer MGContentContainerState::getMapBuffer() const {
+  return MapBufferBuilder::EMPTY();
+}
+
+#endif
+
+} // namespace react
+} // namespace facebook

package/cpp/ContentContainer/MGContentContainerState.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <memory>
+#include <vector>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook {
+namespace react {
+
+using WishlistChildrenList = std::vector<std::shared_ptr<const ShadowNode>>;
+
+/*
+ * State for <MGContentContainer> component.
+ */
+class JSI_EXPORT MGContentContainerState final {
+ public:
+  std::shared_ptr<WishlistChildrenList> wishlistChildren;
+
+  MGContentContainerState();
+  MGContentContainerState(
+      const std::shared_ptr<WishlistChildrenList> &wishlistChildren);
+
+#ifdef ANDROID
+  MGContentContainerState(
+      MGContentContainerState const &previousState,
+      folly::dynamic data);
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const;
+#endif
+};
+
+} // namespace react
+} // namespace facebook

package/cpp/DataBinding/MGBindingProvider.hpp

@@ -0,0 +1,21 @@
+//
+//  MGBindingProvider.hpp
+//  MGWishList
+//
+//  Created by Szymon on 13/01/2023.
+//
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <stdio.h>
+
+namespace Wishlist {
+
+using namespace facebook;
+
+struct MGBindingProvider {
+  virtual jsi::Value getBinding(jsi::Runtime &rt) = 0;
+};
+
+}; // namespace Wishlist

package/cpp/DataBinding/MGDataBinding.hpp

@@ -0,0 +1,23 @@
+//
+//  MGDataBinding.hpp
+//  MGWishList
+//
+//  Created by Szymon on 13/01/2023.
+//
+
+#pragma once
+
+#include <stdio.h>
+#include <memory>
+#include <set>
+#include <string>
+
+namespace Wishlist {
+
+struct MGDataBinding {
+  virtual std::set<int> applyChangesAndGetDirtyIndices(
+      std::pair<int, int> windowIndexRange) = 0;
+  virtual ~MGDataBinding() {}
+};
+
+}; // namespace Wishlist

package/cpp/DataBinding/MGDataBindingImpl.cpp

@@ -0,0 +1,112 @@
+//
+//  MGDataBindingImpl.cpp
+//  MGWishList
+//
+//  Created by Szymon on 16/01/2023.
+//
+
+#include "MGDataBindingImpl.hpp"
+#include "WishlistJsRuntime.h"
+
+namespace Wishlist {
+
+using namespace facebook;
+
+MGDataBindingImpl::MGDataBindingImpl(
+    const std::string &wishlistId,
+    const std::weak_ptr<MGDI> &di)
+    : di(di), _wishlistId(wishlistId) {
+  registerBindings();
+}
+
+std::set<int> MGDataBindingImpl::applyChangesAndGetDirtyIndices(
+    std::pair<int, int> windowIndexRange) {
+  std::shared_ptr retainedDI = di.lock();
+  if (retainedDI == nullptr) {
+    return {};
+  }
+
+  auto &rt = WishlistJsRuntime::getInstance().getRuntime();
+  jsi::Object global = rt.global().getPropertyAsObject(rt, "global");
+  if (!global.hasProperty(rt, "wishlists")) {
+    global.setProperty(rt, "wishlists", jsi::Object(rt));
+  }
+
+  jsi::Object wishlists = global.getPropertyAsObject(rt, "wishlists");
+  jsi::Object obj = wishlists.getPropertyAsObject(rt, _wishlistId.c_str());
+  jsi::Value val = obj.getProperty(rt, "listener");
+  if (val.isObject()) {
+    jsi::Function f = val.getObject(rt).getFunction(rt);
+    try {
+      jsi::Array dirtyIndices = f.call(
+                                     rt,
+                                     jsi::Value(rt, windowIndexRange.first),
+                                     jsi::Value(rt, windowIndexRange.second))
+                                    .asObject(rt)
+                                    .asArray(rt);
+      std::set<int> res;
+      for (int i = 0; i < dirtyIndices.size(rt); ++i) {
+        int dirtyIndex = (int)dirtyIndices.getValueAtIndex(rt, i).asNumber();
+        res.insert(dirtyIndex);
+      }
+      return res;
+    } catch (std::exception &error) {
+      di.lock()->getErrorHandler()->reportError(error.what());
+      return {};
+    }
+  }
+  return {};
+}
+
+void MGDataBindingImpl::registerBindings() {
+  WishlistJsRuntime::getInstance().accessRuntime([=](jsi::Runtime &rt) {
+    jsi::Object global = rt.global().getPropertyAsObject(rt, "global");
+    if (!global.hasProperty(rt, "wishlists")) {
+      global.setProperty(rt, "wishlists", jsi::Object(rt));
+    }
+
+    jsi::Object wishlists = global.getPropertyAsObject(rt, "wishlists");
+
+    jsi::Object binding(rt);
+    if (wishlists.getProperty(rt, _wishlistId.c_str()).isObject()) {
+      binding = wishlists.getProperty(rt, _wishlistId.c_str()).asObject(rt);
+    }
+    std::weak_ptr<MGDI> weakDi = di;
+    binding.setProperty(
+        rt,
+        "scheduleSyncUp",
+        jsi::Function::createFromHostFunction(
+            rt,
+            jsi::PropNameID::forAscii(rt, "scheduleSyncUp"),
+            1,
+            [=](jsi::Runtime &rt,
+                const jsi::Value &thisValue,
+                const jsi::Value *args,
+                size_t count) -> jsi::Value {
+              std::shared_ptr<MGDI> retainedDI = weakDi.lock();
+              if (retainedDI == nullptr) {
+                return jsi::Value::undefined();
+              }
+              std::shared_ptr<MGVSyncRequester> vsr =
+                  retainedDI->getVSyncRequester();
+              vsr->requestVSync();
+              return jsi::Value::undefined();
+            }));
+
+    wishlists.setProperty(rt, _wishlistId.c_str(), binding);
+  });
+}
+
+void MGDataBindingImpl::unregisterBindings() {
+  WishlistJsRuntime::getInstance().accessRuntime([=](jsi::Runtime &rt) {
+    jsi::Object global = rt.global().getPropertyAsObject(rt, "global");
+    jsi::Object wishlists = global.getPropertyAsObject(rt, "wishlists");
+    wishlists.setProperty(rt, _wishlistId.c_str(), jsi::Value::undefined());
+  });
+}
+
+MGDataBindingImpl::~MGDataBindingImpl() {
+  unregisterBindings();
+}
+
+}; // namespace Wishlist

package/cpp/DataBinding/MGDataBindingImpl.hpp

@@ -0,0 +1,35 @@
+//
+//  MGDataBindingImpl.hpp
+//  MGWishList
+//
+//  Created by Szymon on 16/01/2023.
+//
+
+#pragma once
+
+#include <stdio.h>
+#include <memory>
+#include <set>
+#include "MGDI.hpp"
+#include "MGDataBinding.hpp"
+
+namespace Wishlist {
+
+struct MGDataBindingImpl : MGDataBinding {
+  std::weak_ptr<MGDI> di;
+  std::string _wishlistId;
+
+  MGDataBindingImpl(
+      const std::string &wishlistId,
+      const std::weak_ptr<MGDI> &di);
+
+  virtual std::set<int> applyChangesAndGetDirtyIndices(
+      std::pair<int, int> windowIndexRange);
+
+  void registerBindings();
+  void unregisterBindings();
+
+  virtual ~MGDataBindingImpl();
+};
+
+}; // namespace Wishlist

package/cpp/DependencyInjection/MGDI.hpp

@@ -0,0 +1,33 @@
+//
+//  MGDI.hpp
+//  MGWishList
+//
+//  Created by Szymon on 13/01/2023.
+//
+
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <stdio.h>
+
+#include "MGBindingProvider.hpp"
+#include "MGDataBinding.hpp"
+#include "MGErrorHandler.h"
+#include "MGUIScheduler.hpp"
+#include "MGVSyncRequester.hpp"
+#include "MGViewportCarer.hpp"
+#include "MGViewportCarerListener.hpp"
+
+namespace Wishlist {
+
+struct MGDI {
+  virtual std::shared_ptr<MGDataBinding> getDataBinding() = 0;
+  virtual std::shared_ptr<MGVSyncRequester> getVSyncRequester() = 0;
+  virtual std::shared_ptr<MGViewportCarer> getViewportCarer() = 0;
+  virtual std::shared_ptr<MGUIScheduler> getUIScheduler() = 0;
+  virtual std::shared_ptr<MGErrorHandler> getErrorHandler() = 0;
+
+  virtual ~MGDI() {}
+};
+
+}; // namespace Wishlist