react-native-reanimated 3.8.0 → 3.9.0-layout-animation-experimental

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/SharedTransitionManager.java

@@ -8,8 +8,12 @@ import android.view.ViewParent;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.ViewGroupManager;
 import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.uimanager.events.EventDispatcherListener;
 import com.facebook.react.views.view.ReactViewGroup;
 import com.swmansion.reanimated.Utils;
 import java.util.ArrayList;
@@ -19,6 +23,8 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
 import javax.annotation.Nullable;
 
 public class SharedTransitionManager {
@@ -29,6 +35,7 @@ public class SharedTransitionManager {
   private final Map<Integer, Integer> mSharedTransitionInParentIndex = new HashMap<>();
   private final Map<Integer, Snapshot> mSnapshotRegistry = new HashMap<>();
   private final Map<Integer, View> mCurrentSharedTransitionViews = new HashMap<>();
+  private final Map<Integer, SortedSet<Integer>> mSharedViewChildrenIndices = new HashMap<>();
   private View mTransitionContainer;
   private final List<View> mRemovedSharedViews = new ArrayList<>();
   private final Set<Integer> mViewTagsToHide = new HashSet<>();
@@ -38,6 +45,25 @@ public class SharedTransitionManager {
   private final List<SharedElement> mSharedElementsWithProgress = new ArrayList<>();
   private final List<SharedElement> mSharedElementsWithAnimation = new ArrayList<>();
   private final Set<View> mReattachedViews = new HashSet<>();
+  private boolean mIsTransitionPrepared = false;
+  private final Set<Integer> mTagsToCleanup = new HashSet<>();
+
+  class TopWillAppearListener implements EventDispatcherListener {
+    private final EventDispatcher mEventDispatcher;
+
+    public TopWillAppearListener(EventDispatcher eventDispatcher) {
+      mEventDispatcher = eventDispatcher;
+    }
+
+    @Override
+    public void onEventDispatch(Event event) {
+      if (event.getEventName().equals("topWillAppear")) {
+        tryStartSharedTransitionForViews(mAddedSharedViews, true);
+        mAddedSharedViews.clear();
+        mEventDispatcher.removeListener(this);
+      }
+    }
+  }
 
   public SharedTransitionManager(AnimationsManager animationsManager) {
     mAnimationsManager = animationsManager;
@@ -56,13 +82,22 @@ public class SharedTransitionManager {
     return mCurrentSharedTransitionViews.get(tag);
   }
 
-  protected void screenDidLayout() {
-    tryStartSharedTransitionForViews(mAddedSharedViews, true);
-    mAddedSharedViews.clear();
+  protected void screenDidLayout(View view) {
+    if (mAddedSharedViews.isEmpty()) {
+      return;
+    }
+    EventDispatcher eventDispatcher =
+        UIManagerHelper.getEventDispatcherForReactTag(
+            (ReactContext) view.getContext(), view.getId());
+    if (eventDispatcher != null) {
+      eventDispatcher.addListener(new TopWillAppearListener(eventDispatcher));
+    }
   }
 
   protected void viewDidLayout(View view) {
-    maybeRestartAnimationWithNewLayout(view);
+    // this was causing problems when I moved the start of transition to the willAppear event
+    // handler
+    //    maybeRestartAnimationWithNewLayout(view);
   }
 
   protected void onViewsRemoval(int[] tagsToDelete) {
@@ -72,11 +107,11 @@ public class SharedTransitionManager {
     visitTreeForTags(tagsToDelete, new SnapshotTreeVisitor());
     if (mRemovedSharedViews.size() > 0) {
       // this happens when navigation goes back
-      boolean animationStarted = tryStartSharedTransitionForViews(mRemovedSharedViews, false);
-      if (!animationStarted) {
+      mIsTransitionPrepared = prepareSharedTransition(mRemovedSharedViews, false);
+      if (!mIsTransitionPrepared) {
         mRemovedSharedViews.clear();
       }
-      visitTreeForTags(tagsToDelete, new ConfigCleanerTreeVisitor());
+      visitTreeForTags(tagsToDelete, new PrepareConfigCleanupTreeVisitor());
     }
   }
 
@@ -141,8 +176,7 @@ public class SharedTransitionManager {
         sharedElementsToRestart, LayoutAnimations.Types.SHARED_ELEMENT_TRANSITION);
   }
 
-  private boolean tryStartSharedTransitionForViews(
-      List<View> sharedViews, boolean withNewElements) {
+  protected boolean prepareSharedTransition(List<View> sharedViews, boolean withNewElements) {
     if (sharedViews.isEmpty()) {
       return false;
     }
@@ -155,11 +189,43 @@ public class SharedTransitionManager {
     setupTransitionContainer();
     reparentSharedViewsForCurrentTransition(sharedElements);
     orderByAnimationTypes(sharedElements);
+    return true;
+  }
+
+  protected void onScreenWillDisappear() {
+    if (!mIsTransitionPrepared) {
+      return;
+    }
+    mIsTransitionPrepared = false;
+    for (SharedElement sharedElement : mSharedElementsWithAnimation) {
+      sharedElement.targetViewSnapshot = new Snapshot(sharedElement.targetView);
+    }
+    for (SharedElement sharedElement : mSharedElementsWithProgress) {
+      sharedElement.targetViewSnapshot = new Snapshot(sharedElement.targetView);
+    }
+
+    startPreparedTransitions();
+
+    for (Integer tag : mTagsToCleanup) {
+      mNativeMethodsHolder.clearAnimationConfig(tag);
+    }
+    mTagsToCleanup.clear();
+  }
+
+  private boolean tryStartSharedTransitionForViews(
+      List<View> sharedViews, boolean withNewElements) {
+    if (!prepareSharedTransition(sharedViews, withNewElements)) {
+      return false;
+    }
+    startPreparedTransitions();
+    return true;
+  }
+
+  private void startPreparedTransitions() {
     startSharedTransition(
         mSharedElementsWithAnimation, LayoutAnimations.Types.SHARED_ELEMENT_TRANSITION);
     startSharedTransition(
         mSharedElementsWithProgress, LayoutAnimations.Types.SHARED_ELEMENT_TRANSITION_PROGRESS);
-    return true;
   }
 
   private void sortViewsByTags(List<View> views) {
@@ -334,14 +400,27 @@ public class SharedTransitionManager {
     for (SharedElement sharedElement : sharedElements) {
       View viewSource = sharedElement.sourceView;
       if (!mSharedTransitionParent.containsKey(viewSource.getId())) {
+        ViewGroup parent = (ViewGroup) viewSource.getParent();
+        int parentTag = parent.getId();
+        int childIndex = parent.indexOfChild(viewSource);
         mSharedTransitionParent.put(viewSource.getId(), (View) viewSource.getParent());
-        mSharedTransitionInParentIndex.put(
-            viewSource.getId(), ((ViewGroup) viewSource.getParent()).indexOfChild(viewSource));
-        ((ViewGroup) viewSource.getParent()).removeView(viewSource);
-        ((ViewGroup) mTransitionContainer).addView(viewSource);
-        mReattachedViews.add(viewSource);
+        mSharedTransitionInParentIndex.put(viewSource.getId(), childIndex);
+        SortedSet<Integer> childrenIndicesSet = mSharedViewChildrenIndices.get(parentTag);
+        if (childrenIndicesSet == null) {
+          mSharedViewChildrenIndices.put(
+              parentTag, new TreeSet<>(Collections.singleton(childIndex)));
+        } else {
+          childrenIndicesSet.add(childIndex);
+        }
       }
     }
+
+    for (SharedElement sharedElement : sharedElements) {
+      View viewSource = sharedElement.sourceView;
+      ((ViewGroup) viewSource.getParent()).removeView(viewSource);
+      ((ViewGroup) mTransitionContainer).addView(viewSource);
+      mReattachedViews.add(viewSource);
+    }
   }
 
   private void startSharedTransition(List<SharedElement> sharedElements, int type) {
@@ -388,6 +467,15 @@ public class SharedTransitionManager {
       View parentView = mSharedTransitionParent.get(viewTag);
       int childIndex = mSharedTransitionInParentIndex.get(viewTag);
       ViewGroup parentViewGroup = ((ViewGroup) parentView);
+      int parentTag = parentViewGroup.getId();
+      SortedSet<Integer> childIndicesSet = mSharedViewChildrenIndices.get(parentTag);
+      // here we calculate how many children with smaller indices have not been reinserted yet
+      int childIndexOffset = childIndicesSet.headSet(childIndex).size();
+      childIndicesSet.remove(childIndex);
+      if (childIndicesSet.isEmpty()) {
+        mSharedViewChildrenIndices.remove(parentTag);
+      }
+      childIndex -= childIndexOffset;
       if (childIndex <= parentViewGroup.getChildCount()) {
         parentViewGroup.addView(view, childIndex);
       } else {
@@ -498,9 +586,9 @@ public class SharedTransitionManager {
     }
   }
 
-  class ConfigCleanerTreeVisitor implements TreeVisitor {
+  class PrepareConfigCleanupTreeVisitor implements TreeVisitor {
     public void run(View view) {
-      mNativeMethodsHolder.clearAnimationConfig(view.getId());
+      mTagsToCleanup.add(view.getId());
     }
   }
 

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensor.java

@@ -17,6 +17,7 @@ public class ReanimatedSensor {
   Sensor sensor;
   ReanimatedSensorType sensorType;
   int interval;
+  private static final int DEFAULT_INTERVAL = 8;
 
   ReanimatedSensor(
       WeakReference<ReactApplicationContext> reactContext,
@@ -30,7 +31,7 @@ public class ReanimatedSensor {
         (SensorManager) reactContext.get().getSystemService(reactContext.get().SENSOR_SERVICE);
     this.sensorType = sensorType;
     if (interval == -1) {
-      this.interval = SensorManager.SENSOR_DELAY_UI;
+      this.interval = DEFAULT_INTERVAL;
     } else {
       this.interval = interval;
     }

package/android/src/paper/java/com/swmansion/reanimated/NativeReanimatedModuleSpec.java

@@ -0,0 +1,37 @@
+/**
+ * This code was copied from android/build/generated/source/codegen/java/com/swmansion/reanimated/NativeReanimatedModuleSpec.java
+ * which was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.swmansion.reanimated;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeReanimatedModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "ReanimatedModule";
+
+  public NativeReanimatedModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean installTurboModule(String valueUnpackerCode);
+}

package/android/src/{main/java/com/swmansion/reanimated → reactNativeVersionPatch/ReanimatedUIManager/73/com/swmansion}/ReanimatedModule.java

@@ -3,7 +3,6 @@ package com.swmansion.reanimated;
 import android.util.Log;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.NativeViewHierarchyManager;
@@ -14,7 +13,7 @@ import java.util.ArrayList;
 import javax.annotation.Nullable;
 
 @ReactModule(name = ReanimatedModule.NAME)
-public class ReanimatedModule extends ReactContextBaseJavaModule
+public class ReanimatedModule extends NativeReanimatedModuleSpec
     implements LifecycleEventListener, UIManagerModuleListener {
 
   public static final String NAME = "ReanimatedModule";
@@ -91,17 +90,19 @@ public class ReanimatedModule extends ReactContextBaseJavaModule
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
-  public void installTurboModule(String valueUnpackerCode) {
+  public boolean installTurboModule(String valueUnpackerCode) {
     // When debugging in chrome the JS context is not available.
     // https://github.com/facebook/react-native/blob/v0.67.0-rc.6/ReactAndroid/src/main/java/com/facebook/react/modules/blob/BlobCollector.java#L25
     Utils.isChromeDebugger = getReactApplicationContext().getJavaScriptContextHolder().get() == 0;
 
     if (!Utils.isChromeDebugger) {
       this.getNodesManager().initWithContext(getReactApplicationContext(), valueUnpackerCode);
+      return true;
     } else {
       Log.w(
           "[REANIMATED]",
           "Unable to create Reanimated Native Module. You can ignore this message if you are using Chrome Debugger now.");
+      return false;
     }
   }
 

package/android/src/reactNativeVersionPatch/ReanimatedUIManager/{70 → 73}/com/swmansion/reanimated/layoutReanimation/ReanimatedUIManager.java

@@ -9,25 +9,8 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
-import com.facebook.react.uimanager.events.EventDispatcher;
 import java.util.List;
 
-class ReaUiImplementationProvider extends UIImplementationProvider {
-
-  @Override
-  UIImplementation createUIImplementation(
-      ReactApplicationContext reactContext,
-      ViewManagerRegistry viewManagerRegistry,
-      EventDispatcher eventDispatcher,
-      int minTimeLeftInFrameForNonBatchedOperationMs) {
-    return new com.facebook.react.uimanager.ReanimatedUIImplementation(
-        reactContext,
-        viewManagerRegistry,
-        eventDispatcher,
-        minTimeLeftInFrameForNonBatchedOperationMs);
-  }
-}
-
 @ReactModule(name = UIManagerModule.NAME)
 public class ReanimatedUIManager extends UIManagerModule {
 
@@ -35,11 +18,7 @@ public class ReanimatedUIManager extends UIManagerModule {
       ReactApplicationContext reactContext,
       List<ViewManager> viewManagersList,
       int minTimeLeftInFrameForNonBatchedOperationMs) {
-    super(
-        reactContext,
-        viewManagersList,
-        new ReaUiImplementationProvider(),
-        minTimeLeftInFrameForNonBatchedOperationMs);
+    super(reactContext, viewManagersList, minTimeLeftInFrameForNonBatchedOperationMs);
   }
 
   public void onBatchComplete() {

package/android/src/reactNativeVersionPatch/ReanimatedUIManager/latest/com/swmansion/reanimated/ReanimatedModule.java

@@ -0,0 +1,176 @@
+package com.swmansion.reanimated;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.bridge.UIManagerListener;
+import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.UIManagerModuleListener;
+import java.util.ArrayList;
+import javax.annotation.Nullable;
+
+@ReactModule(name = ReanimatedModule.NAME)
+public class ReanimatedModule extends NativeReanimatedModuleSpec
+    implements LifecycleEventListener, UIManagerModuleListener,
+               UIManagerListener {
+  public static final String NAME = "ReanimatedModule";
+
+  public void didDispatchMountItems(@NonNull UIManager uiManager) {
+    // Keep: Required for UIManagerListener
+  }
+
+  public void didMountItems(@NonNull UIManager uiManager) {
+    // Keep: Required for UIManagerListener
+  }
+
+  public void didScheduleMountItems(@NonNull UIManager uiManager) {
+    // Keep: Required for UIManagerListener
+  }
+
+  public void willDispatchViewUpdates(@NonNull UIManager uiManager) {
+    // This method is called for the interface of UIManagerListener on Fabric.
+    // The below function with the same name won't be called.
+    if (mOperations.isEmpty()) {
+      return;
+    }
+    final ArrayList<UIThreadOperation> operations = mOperations;
+    mOperations = new ArrayList<>();
+    if (uiManager instanceof FabricUIManager) {
+      ((FabricUIManager)uiManager).addUIBlock(uiBlockViewResolver -> {
+        NodesManager nodesManager = getNodesManager();
+        for (UIThreadOperation operation : operations) {
+          operation.execute(nodesManager);
+        }
+      });
+    } else {
+      throw new RuntimeException(
+          "[Reanimated] Failed to obtain instance of FabricUIManager.");
+    }
+  }
+
+  public void willMountItems(@NonNull UIManager uiManager) {}
+
+  private interface UIThreadOperation {
+    void execute(NodesManager nodesManager);
+  }
+
+  private ArrayList<UIThreadOperation> mOperations = new ArrayList<>();
+  private @Nullable NodesManager mNodesManager;
+
+  public ReanimatedModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public void initialize() {
+    ReactApplicationContext reactCtx = getReactApplicationContext();
+
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      UIManager uiManager = reactCtx.getFabricUIManager();
+      if (uiManager instanceof FabricUIManager) {
+        ((FabricUIManager)uiManager).addUIManagerEventListener(this);
+      } else {
+        throw new RuntimeException(
+            "[Reanimated] Failed to obtain instance of FabricUIManager.");
+      }
+    } else {
+      UIManagerModule uiManager =
+          reactCtx.getNativeModule(UIManagerModule.class);
+      uiManager.addUIManagerListener(this);
+    }
+    reactCtx.addLifecycleEventListener(this);
+  }
+
+  @Override
+  public void onHostPause() {
+    if (mNodesManager != null) {
+      mNodesManager.onHostPause();
+    }
+  }
+
+  @Override
+  public void onHostResume() {
+    if (mNodesManager != null) {
+      mNodesManager.onHostResume();
+    }
+  }
+
+  @Override
+  public void onHostDestroy() {
+    // do nothing
+  }
+
+  @Override
+  public void willDispatchViewUpdates(final UIManagerModule uiManager) {
+    // This method is called for the interface of UIManagerModuleListener on
+    // Paper. The below function with the same name won't be called.
+    if (mOperations.isEmpty()) {
+      return;
+    }
+    final ArrayList<UIThreadOperation> operations = mOperations;
+    mOperations = new ArrayList<>();
+    uiManager.addUIBlock(nativeViewHierarchyManager -> {
+      NodesManager nodesManager = getNodesManager();
+      for (UIThreadOperation operation : operations) {
+        operation.execute(nodesManager);
+      }
+    });
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  /*package*/
+  public NodesManager getNodesManager() {
+    if (mNodesManager == null) {
+      mNodesManager = new NodesManager(getReactApplicationContext());
+    }
+
+    return mNodesManager;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean installTurboModule(String valueUnpackerCode) {
+    // When debugging in chrome the JS context is not available.
+    // https://github.com/facebook/react-native/blob/v0.67.0-rc.6/ReactAndroid/src/main/java/com/facebook/react/modules/blob/BlobCollector.java#L25
+    Utils.isChromeDebugger =
+        getReactApplicationContext().getJavaScriptContextHolder().get() == 0;
+
+    if (!Utils.isChromeDebugger) {
+      this.getNodesManager().initWithContext(
+          getReactApplicationContext(), valueUnpackerCode);
+      return true;
+    } else {
+      Log.w(
+          "[REANIMATED]",
+          "Unable to create Reanimated Native Module. You can ignore this message if you are using Chrome Debugger now.");
+      return false;
+    }
+  }
+
+  @ReactMethod
+  public void addListener(String eventName) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @Override
+  public void invalidate() {
+    super.invalidate();
+
+    if (mNodesManager != null) {
+      mNodesManager.invalidate();
+    }
+  }
+}

package/android/src/reactNativeVersionPatch/ReanimatedUIManager/latest/com/swmansion/reanimated/layoutReanimation/ReanimatedUIManager.java

@@ -90,32 +90,6 @@ public class ReanimatedUIManager extends UIManagerModule {
     super.setChildren(viewTag, childrenTags);
   }
 
-  /**
-   * Replaces the View specified by oldTag with the View specified by newTag within oldTag's parent.
-   * This resolves to a simple {@link #manageChildren} call, but React doesn't have enough info in
-   * JS to formulate it itself.
-   *
-   * @deprecated This method will not be available in Fabric UIManager class.
-   */
-  @ReactMethod
-  @Deprecated
-  public void replaceExistingNonRootView(int oldTag, int newTag) {
-    super.replaceExistingNonRootView(oldTag, newTag);
-  }
-
-  /**
-   * Method which takes a container tag and then releases all subviews for that container upon
-   * receipt.
-   *
-   * @param containerTag the tag of the container for which the subviews must be removed
-   * @deprecated This method will not be available in Fabric UIManager class.
-   */
-  @ReactMethod
-  @Deprecated
-  public void removeSubviewsFromContainerWithID(int containerTag) {
-    super.removeSubviewsFromContainerWithID(containerTag);
-  }
-
   /**
    * Determines the location on screen, width, and height of the given view and returns the values
    * via an async callback.

package/android/src/{fabric/java → reactNativeVersionPatch/RuntimeExecutor/73}/com/swmansion/reanimated/NativeProxy.java

@@ -69,36 +69,48 @@ public class NativeProxy extends NativeProxyCommon {
     public static NativeMethodsHolder createNativeMethodsHolder(LayoutAnimations layoutAnimations) {
         return new NativeMethodsHolder() {
             @Override
-            public void startAnimation(int tag, int type, HashMap<String, Object> values) {}
+            public void startAnimation(int tag, int type, HashMap<String, Object> values) {
+                // NOT IMPLEMENTED
+            }
 
             @Override
             public boolean isLayoutAnimationEnabled() {
+                // NOT IMPLEMENTED
                 return false;
             }
 
             @Override
             public int findPrecedingViewTagForTransition(int tag) {
+                // NOT IMPLEMENTED
                 return -1;
             }
 
             @Override
             public boolean shouldAnimateExiting(int tag, boolean shouldAnimate) {
+                // NOT IMPLEMENTED
                 return false;
             }
 
             @Override
             public boolean hasAnimation(int tag, int type) {
+                // NOT IMPLEMENTED
                 return false;
             }
 
             @Override
-            public void clearAnimationConfig(int tag) {}
+            public void clearAnimationConfig(int tag) {
+                // NOT IMPLEMENTED
+            }
 
             @Override
-            public void cancelAnimation(int tag) {}
+            public void cancelAnimation(int tag) {
+                // NOT IMPLEMENTED
+            }
 
             @Override
-            public void checkDuplicateSharedTag(int viewTag, int screenTag) {}
+            public void checkDuplicateSharedTag(int viewTag, int screenTag) {
+                // NOT IMPLEMENTED
+            }
         };
     }
 }