@onekeyfe/react-native-pager-view 1.1.35

package/android/src/main/java/com/reactnativepagerview/NestedScrollableHost.kt

@@ -0,0 +1,148 @@
+package com.reactnativepagerview
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.Choreographer
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import android.widget.FrameLayout
+import androidx.viewpager2.widget.ViewPager2
+import androidx.viewpager2.widget.ViewPager2.ORIENTATION_HORIZONTAL
+import com.facebook.react.uimanager.events.NativeGestureUtil
+import kotlin.math.absoluteValue
+import kotlin.math.sign
+
+/**
+ * Layout to wrap a scrollable component inside a ViewPager2. Provided as a solution to the problem
+ * where pages of ViewPager2 have nested scrollable elements that scroll in the same direction as
+ * ViewPager2. The scrollable element needs to be the immediate and only child of this host layout.
+ *
+ * Supports multiple levels of nested PagerViews by re-asserting
+ * requestDisallowInterceptTouchEvent after child dispatch.
+ */
+class NestedScrollableHost : FrameLayout {
+  constructor(context: Context) : super(context)
+  constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
+  public var initialIndex: Int? = null
+  public var didSetInitialIndex = false
+  public var pendingRefreshFrameCallback: Choreographer.FrameCallback? = null
+  private var touchSlop = 0
+  private var initialX = 0f
+  private var initialY = 0f
+  private var nativeGestureStarted: Boolean = false
+  private val parentViewPager: ViewPager2?
+    get() {
+      var v: View? = parent as? View
+      while (v != null && v !is ViewPager2) {
+        v = v.parent as? View
+      }
+      return v as? ViewPager2
+    }
+
+  private val child: View? get() = if (childCount > 0) getChildAt(0) else null
+
+  init {
+    touchSlop = ViewConfiguration.get(context).scaledTouchSlop
+  }
+
+  private fun canChildScroll(orientation: Int, delta: Float): Boolean {
+    val direction = -delta.sign.toInt()
+    return when (orientation) {
+      0 -> child?.canScrollHorizontally(direction) ?: false
+      1 -> child?.canScrollVertically(direction) ?: false
+      else -> throw IllegalArgumentException()
+    }
+  }
+
+  override fun dispatchTouchEvent(e: MotionEvent): Boolean {
+    val handled = super.dispatchTouchEvent(e)
+
+    // After the full child dispatch cycle, a deeply-nested NestedScrollableHost may
+    // have called requestDisallowInterceptTouchEvent(false) which propagates all the
+    // way up, overriding our earlier requestDisallowInterceptTouchEvent(true).
+    // Re-assert here if our own ViewPager2 can still scroll in the gesture direction.
+    if (e.action == MotionEvent.ACTION_MOVE) {
+      val orientation = parentViewPager?.orientation ?: return handled
+      val dx = e.x - initialX
+      val dy = e.y - initialY
+      val isVpHorizontal = orientation == ORIENTATION_HORIZONTAL
+      val scaledDx = dx.absoluteValue * if (isVpHorizontal) .5f else 1f
+      val scaledDy = dy.absoluteValue * if (isVpHorizontal) 1f else .5f
+
+      if (scaledDx > touchSlop || scaledDy > touchSlop) {
+        if (isVpHorizontal != (scaledDy > scaledDx)) {
+          // Parallel gesture — re-assert if our VP can scroll
+          if (canChildScroll(orientation, if (isVpHorizontal) dx else dy)) {
+            parent.requestDisallowInterceptTouchEvent(true)
+          }
+        }
+      }
+    }
+
+    return handled
+  }
+
+  override fun onInterceptTouchEvent(e: MotionEvent): Boolean {
+    handleInterceptTouchEvent(e)
+    return super.onInterceptTouchEvent(e)
+  }
+
+  private fun handleInterceptTouchEvent(e: MotionEvent) {
+    val orientation = parentViewPager?.orientation
+
+    if (e.action == MotionEvent.ACTION_DOWN) {
+      initialX = e.x
+      initialY = e.y
+      if (orientation != null) {
+        parent.requestDisallowInterceptTouchEvent(true)
+      }
+    } else if (e.action == MotionEvent.ACTION_MOVE) {
+      val dx = e.x - initialX
+      val dy = e.y - initialY
+      val isVpHorizontal = orientation == ORIENTATION_HORIZONTAL
+
+      // assuming ViewPager2 touch-slop is 2x touch-slop of child
+      val scaledDx = dx.absoluteValue * if (isVpHorizontal) .5f else 1f
+      val scaledDy = dy.absoluteValue * if (isVpHorizontal) 1f else .5f
+
+      if (scaledDx > touchSlop || scaledDy > touchSlop) {
+        NativeGestureUtil.notifyNativeGestureStarted(this, e)
+        nativeGestureStarted = true
+
+        if (orientation == null) return
+        if (isVpHorizontal == (scaledDy > scaledDx)) {
+          // Gesture is perpendicular, allow all parents to intercept
+          parent.requestDisallowInterceptTouchEvent(false)
+        } else {
+          // Gesture is parallel, query child if movement in that direction is possible
+          if (canChildScroll(orientation, if (isVpHorizontal) dx else dy)) {
+            // Child can scroll, disallow all parents to intercept
+            parent.requestDisallowInterceptTouchEvent(true)
+          } else {
+            // Child cannot scroll, allow all parents to intercept
+            parent.requestDisallowInterceptTouchEvent(false)
+          }
+        }
+      }
+    }
+  }
+
+  override fun onTouchEvent(e: MotionEvent): Boolean {
+    if (e.actionMasked == MotionEvent.ACTION_UP) {
+      if (nativeGestureStarted) {
+        NativeGestureUtil.notifyNativeGestureEnded(this, e)
+        nativeGestureStarted = false
+      }
+    }
+    return super.onTouchEvent(e)
+  }
+
+  override fun onDetachedFromWindow() {
+    pendingRefreshFrameCallback?.let { callback ->
+      Choreographer.getInstance().removeFrameCallback(callback)
+      pendingRefreshFrameCallback = null
+    }
+    super.onDetachedFromWindow()
+  }
+}

package/android/src/main/java/com/reactnativepagerview/PagerViewViewManager.kt

@@ -0,0 +1,222 @@
+package com.reactnativepagerview
+
+import android.view.View
+import android.view.ViewGroup
+import androidx.viewpager2.widget.ViewPager2
+import androidx.viewpager2.widget.ViewPager2.OnPageChangeCallback
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.*
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNCViewPagerManagerDelegate
+import com.facebook.react.viewmanagers.RNCViewPagerManagerInterface
+import com.facebook.soloader.SoLoader
+import com.reactnativepagerview.event.PageScrollEvent
+import com.reactnativepagerview.event.PageScrollStateChangedEvent
+import com.reactnativepagerview.event.PageSelectedEvent
+import com.reactnativepagerview.PagerViewViewManagerImpl.reduceDragSensitivity
+
+@ReactModule(name = PagerViewViewManagerImpl.NAME)
+class PagerViewViewManager : ViewGroupManager<NestedScrollableHost>(), RNCViewPagerManagerInterface<NestedScrollableHost> {
+    companion object {
+        init {
+            if (BuildConfig.CODEGEN_MODULE_REGISTRATION != null) {
+                SoLoader.loadLibrary(BuildConfig.CODEGEN_MODULE_REGISTRATION)
+            }
+        }
+    }
+
+    private val mDelegate: ViewManagerDelegate<NestedScrollableHost> = RNCViewPagerManagerDelegate(this)
+
+    override fun getDelegate() = mDelegate
+
+    override fun getName(): String {
+        return PagerViewViewManagerImpl.NAME
+    }
+
+    override fun receiveCommand(root: NestedScrollableHost, commandId: String, args: ReadableArray?) {
+        mDelegate.receiveCommand(root, commandId, args)
+    }
+
+    public override fun createViewInstance(reactContext: ThemedReactContext): NestedScrollableHost {
+        val host = NestedScrollableHost(reactContext)
+        host.id = View.generateViewId()
+        host.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+        host.isSaveEnabled = false
+        val vp = ViewPager2(reactContext)
+        vp.adapter = ViewPagerAdapter()
+        //https://github.com/callstack/react-native-viewpager/issues/183
+        vp.isSaveEnabled = false
+
+        vp.post {
+            vp.registerOnPageChangeCallback(object : OnPageChangeCallback() {
+                override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
+                    super.onPageScrolled(position, positionOffset, positionOffsetPixels)
+                    UIManagerHelper.getEventDispatcherForReactTag(reactContext, host.id)?.dispatchEvent(
+                            PageScrollEvent(host.id, position, positionOffset)
+                    )
+                }
+
+                override fun onPageSelected(position: Int) {
+                    super.onPageSelected(position)
+                    UIManagerHelper.getEventDispatcherForReactTag(reactContext, host.id)?.dispatchEvent(
+                            PageSelectedEvent(host.id, position)
+                    )
+                }
+
+                override fun onPageScrollStateChanged(state: Int) {
+                    super.onPageScrollStateChanged(state)
+                    val pageScrollState: String = when (state) {
+                        ViewPager2.SCROLL_STATE_IDLE -> "idle"
+                        ViewPager2.SCROLL_STATE_DRAGGING -> "dragging"
+                        ViewPager2.SCROLL_STATE_SETTLING -> "settling"
+                        else -> throw IllegalStateException("Unsupported pageScrollState")
+                    }
+                    UIManagerHelper.getEventDispatcherForReactTag(reactContext, host.id)?.dispatchEvent(
+                            PageScrollStateChangedEvent(host.id, pageScrollState)
+                    )
+                }
+            })
+            UIManagerHelper.getEventDispatcherForReactTag(reactContext, host.id)?.dispatchEvent(
+                    PageSelectedEvent(host.id, vp.currentItem)
+            )
+        }
+        host.addView(vp)
+        return host
+    }
+
+    override fun addView(host: NestedScrollableHost, child: View, index: Int) {
+        PagerViewViewManagerImpl.addView(host, child, index)
+    }
+
+    override fun getChildCount(parent: NestedScrollableHost) = PagerViewViewManagerImpl.getChildCount(parent)
+
+    override fun getChildAt(parent: NestedScrollableHost, index: Int): View {
+        return PagerViewViewManagerImpl.getChildAt(parent, index)
+    }
+
+    override fun removeView(parent: NestedScrollableHost, view: View) {
+        PagerViewViewManagerImpl.removeView(parent, view)
+    }
+
+    override fun removeAllViews(parent: NestedScrollableHost) {
+        PagerViewViewManagerImpl.removeAllViews(parent)
+    }
+
+    override fun removeViewAt(parent: NestedScrollableHost, index: Int) {
+        PagerViewViewManagerImpl.removeViewAt(parent, index)
+    }
+
+    override fun needsCustomLayoutForChildren(): Boolean {
+        return PagerViewViewManagerImpl.needsCustomLayoutForChildren()
+    }
+
+    @ReactProp(name = "scrollEnabled", defaultBoolean = true)
+    override fun setScrollEnabled(view: NestedScrollableHost?, value: Boolean) {
+        if (view != null) {
+            PagerViewViewManagerImpl.setScrollEnabled(view, value)
+        }
+    }
+
+    @ReactProp(name = "layoutDirection")
+    override fun setLayoutDirection(view: NestedScrollableHost?, value: String?) {
+        if (view != null && value != null) {
+            PagerViewViewManagerImpl.setLayoutDirection(view, value)
+        }
+    }
+
+    @ReactProp(name = "initialPage", defaultInt = 0)
+    override fun setInitialPage(view: NestedScrollableHost?, value: Int) {
+        if (view != null) {
+            PagerViewViewManagerImpl.setInitialPage(view, value)
+        }
+    }
+
+    @ReactProp(name = "orientation")
+    override fun setOrientation(view: NestedScrollableHost?, value: String?) {
+        if (view != null && value != null) {
+            PagerViewViewManagerImpl.setOrientation(view, value)
+        }
+    }
+
+    @ReactProp(name = "offscreenPageLimit", defaultInt = ViewPager2.OFFSCREEN_PAGE_LIMIT_DEFAULT)
+    override fun setOffscreenPageLimit(view: NestedScrollableHost?, value: Int) {
+        if (view != null) {
+            PagerViewViewManagerImpl.setOffscreenPageLimit(view, value)
+        }
+    }
+
+    @ReactProp(name = "pageMargin", defaultInt = 0)
+    override fun setPageMargin(view: NestedScrollableHost?, value: Int) {
+        if (view != null) {
+            PagerViewViewManagerImpl.setPageMargin(view, value)
+        }
+    }
+
+    @ReactProp(name = "overScrollMode")
+    override fun setOverScrollMode(view: NestedScrollableHost?, value: String?) {
+        if (view != null && value != null) {
+            PagerViewViewManagerImpl.setOverScrollMode(view, value)
+        }
+    }
+
+    @ReactProp(name = "overdrag")
+    override fun setOverdrag(view: NestedScrollableHost?, value: Boolean) {
+        return
+    }
+
+    @ReactProp(name = "keyboardDismissMode")
+    override fun setKeyboardDismissMode(view: NestedScrollableHost?, value: String?) {
+        return
+    }
+
+    @ReactProp(name = "scrollSensitivity", defaultInt = 2)
+    override fun setScrollSensitivity(host: NestedScrollableHost, value: Int) {
+        val view = PagerViewViewManagerImpl.getViewPager(host)
+        view.reduceDragSensitivity(value)
+    }
+
+    @ReactProp(name = "nestedScrollEnabled", defaultBoolean = false)
+    override fun setNestedScrollEnabled(view: NestedScrollableHost?, value: Boolean) {
+        // No-op on Android: NestedScrollableHost already handles nested scroll
+        // coordination natively. Prop registration is required for Fabric codegen
+        // completeness (JS prop must reach native layer without error).
+    }
+
+    fun goTo(root: NestedScrollableHost?, selectedPage: Int, scrollWithAnimation: Boolean) {
+        if (root == null) {
+            return
+        }
+        val view = PagerViewViewManagerImpl.getViewPager(root)
+        Assertions.assertNotNull(view)
+        val childCount = view.adapter?.itemCount
+        val canScroll = childCount != null && childCount > 0 && selectedPage >= 0 && selectedPage < childCount
+        if (canScroll) {
+            PagerViewViewManagerImpl.setCurrentItem(view, selectedPage, scrollWithAnimation)
+        }
+    }
+
+    override fun setPage(view: NestedScrollableHost?, selectedPage: Int) {
+        goTo(view, selectedPage, true)
+    }
+
+    override fun setPageWithoutAnimation(view: NestedScrollableHost?, selectedPage: Int) {
+        goTo(view, selectedPage, false)
+    }
+
+    override fun setScrollEnabledImperatively(view: NestedScrollableHost?, scrollEnabled: Boolean) {
+        if (view != null) {
+            PagerViewViewManagerImpl.setScrollEnabled(view, scrollEnabled)
+        }
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Map<String, String>> {
+        return MapBuilder.of(
+                PageScrollEvent.EVENT_NAME, MapBuilder.of("registrationName", "onPageScroll"),
+                PageScrollStateChangedEvent.EVENT_NAME, MapBuilder.of("registrationName", "onPageScrollStateChanged"),
+                PageSelectedEvent.EVENT_NAME, MapBuilder.of("registrationName", "onPageSelected"))
+    }
+}

package/android/src/main/java/com/reactnativepagerview/PagerViewViewManagerImpl.kt

@@ -0,0 +1,228 @@
+package com.reactnativepagerview
+
+import android.view.View
+import android.view.ViewGroup
+import androidx.viewpager2.widget.ViewPager2
+import com.facebook.react.uimanager.PixelUtil
+import android.view.Choreographer
+import android.util.Log
+import androidx.recyclerview.widget.RecyclerView
+import java.util.WeakHashMap
+
+object PagerViewViewManagerImpl {
+    private const val TAG = "PagerView"
+    const val NAME = "RNCViewPager"
+
+    fun getViewPager(view: NestedScrollableHost): ViewPager2 {
+        if (view.getChildAt(0) is ViewPager2) {
+            return view.getChildAt(0) as ViewPager2
+        } else {
+            throw ClassNotFoundException("Could not retrieve ViewPager2 instance")
+        }
+    }
+
+    fun setCurrentItem(view: ViewPager2, selectedTab: Int, scrollSmooth: Boolean) {
+        refreshViewChildrenLayout(view)
+        view.setCurrentItem(selectedTab, scrollSmooth)
+    }
+
+    private val originalTouchSlopMap = WeakHashMap<ViewPager2, Int>()
+
+    fun ViewPager2.reduceDragSensitivity(value: Int) {
+        try {
+            val recyclerViewField = ViewPager2::class.java.getDeclaredField("mRecyclerView")
+            recyclerViewField.isAccessible = true
+            val recyclerView = recyclerViewField.get(this) as? RecyclerView ?: return
+            val touchSlopField = RecyclerView::class.java.getDeclaredField("mTouchSlop")
+            touchSlopField.isAccessible = true
+            // Store original value per instance to prevent accumulation on re-renders
+            val baseSlop = originalTouchSlopMap[this] ?: (touchSlopField.get(recyclerView) as Int).also {
+                originalTouchSlopMap[this] = it
+            }
+            touchSlopField.set(recyclerView, baseSlop * value)
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to adjust drag sensitivity", e)
+        }
+    }
+
+    fun addView(host: NestedScrollableHost, child: View?, index: Int) {
+        if (child == null) {
+            return
+        }
+        val parent = getViewPager(host)
+
+        (parent.adapter as ViewPagerAdapter?)?.addChild(child, index);
+
+        if (parent.currentItem == index) {
+            // Solves https://github.com/callstack/react-native-pager-view/issues/219
+            // Required so ViewPager actually displays first dynamically added child
+            // (otherwise a white screen is shown until the next user interaction).
+            // https://github.com/facebook/react-native/issues/17968#issuecomment-697136929
+            refreshViewChildrenLayout(parent)
+        }
+
+        if (!host.didSetInitialIndex && host.initialIndex == index) {
+            host.didSetInitialIndex = true
+            setCurrentItem(parent, index, false)
+        }
+    }
+
+    fun getChildCount(parent: NestedScrollableHost) = getViewPager(parent).adapter?.itemCount ?: 0
+
+    fun getChildAt(parent: NestedScrollableHost, index: Int): View {
+        val view = getViewPager(parent)
+        return (view.adapter as ViewPagerAdapter?)!!.getChildAt(index)
+    }
+
+    fun removeView(parent: NestedScrollableHost, view: View) {
+        val pager = getViewPager(parent)
+        (pager.adapter as ViewPagerAdapter?)?.removeChild(view)
+
+        // Required so ViewPager actually animates the removed view right away (otherwise
+        // a white screen is shown until the next user interaction).
+        // https://github.com/facebook/react-native/issues/17968#issuecomment-697136929
+        refreshViewChildrenLayout(pager)
+    }
+
+    fun removeAllViews(parent: NestedScrollableHost) {
+        clearPendingRefreshViewChildrenLayout(parent)
+        val pager = getViewPager(parent)
+        pager.isUserInputEnabled = false
+        val adapter = pager.adapter as ViewPagerAdapter?
+        adapter?.removeAll()
+    }
+
+    fun removeViewAt(parent: NestedScrollableHost, index: Int) {
+        val pager = getViewPager(parent)
+        val adapter = pager.adapter as ViewPagerAdapter?
+
+        val child = adapter?.getChildAt(index)
+
+        if (child != null && child.parent != null) {
+            (child.parent as? ViewGroup)?.removeView(child)
+        }
+
+        adapter?.removeChildAt(index)
+
+        debouncedRefreshViewChildrenLayout(parent)
+    }
+
+    fun needsCustomLayoutForChildren(): Boolean {
+        return true
+    }
+
+    fun setScrollEnabled(host: NestedScrollableHost, value: Boolean) {
+        getViewPager(host).isUserInputEnabled = value
+    }
+
+    fun setLayoutDirection(host: NestedScrollableHost, value: String) {
+        val view = getViewPager(host)
+        when (value) {
+            "rtl" -> {
+                view.layoutDirection = View.LAYOUT_DIRECTION_RTL
+            }
+            else -> {
+                view.layoutDirection = View.LAYOUT_DIRECTION_LTR
+            }
+        }
+    }
+
+    fun setInitialPage(host: NestedScrollableHost, value: Int) {
+        val view = getViewPager(host)
+        //https://github.com/callstack/react-native-pager-view/issues/456
+        //Initial index should be set only once.
+        if (host.initialIndex === null) {
+            host.initialIndex = value
+            view.post {
+                host.didSetInitialIndex = true
+            }
+        }
+    }
+
+    fun setOrientation(host: NestedScrollableHost, value: String) {
+        getViewPager(host).orientation = if (value == "vertical") ViewPager2.ORIENTATION_VERTICAL else ViewPager2.ORIENTATION_HORIZONTAL
+    }
+
+    fun setOffscreenPageLimit(host: NestedScrollableHost, value: Int) {
+        getViewPager(host).offscreenPageLimit = value
+    }
+
+    fun setOverScrollMode(host: NestedScrollableHost, value: String) {
+        val child = getViewPager(host).getChildAt(0)
+        when (value) {
+            "never" -> {
+                child.overScrollMode = ViewPager2.OVER_SCROLL_NEVER
+            }
+            "always" -> {
+                child.overScrollMode = ViewPager2.OVER_SCROLL_ALWAYS
+            }
+            else -> {
+                child.overScrollMode = ViewPager2.OVER_SCROLL_IF_CONTENT_SCROLLS
+            }
+        }
+    }
+
+    fun setPageMargin(host: NestedScrollableHost, margin: Int) {
+        val pager = getViewPager(host)
+        val pageMargin = PixelUtil.toPixelFromDIP(margin.toDouble()).toInt()
+        /**
+         * Don't use MarginPageTransformer to be able to support negative margins
+         */
+        pager.setPageTransformer { page, position ->
+            val offset = pageMargin * position
+            if (pager.orientation == ViewPager2.ORIENTATION_HORIZONTAL) {
+                val isRTL = pager.layoutDirection == View.LAYOUT_DIRECTION_RTL
+                page.translationX = if (isRTL) -offset else offset
+            } else {
+                page.translationY = offset
+            }
+        }
+    }
+
+    private fun refreshViewChildrenLayout(view: View) {
+        view.post {
+            val adapter = (view as? ViewPager2)?.adapter as? ViewPagerAdapter
+            if (adapter == null || adapter.itemCount == 0) {
+                return@post
+            }
+            if (!view.isAttachedToWindow) {
+                return@post
+            }
+            try {
+                view.measure(
+                    View.MeasureSpec.makeMeasureSpec(view.width, View.MeasureSpec.EXACTLY),
+                    View.MeasureSpec.makeMeasureSpec(view.height, View.MeasureSpec.EXACTLY))
+                view.layout(view.left, view.top, view.right, view.bottom)
+            } catch (e: NullPointerException) {
+                // Race condition: ViewHolder detached between post and layout execution.
+                // Safe to ignore as RecyclerView will re-layout on next frame.
+            }
+        }
+    }
+
+    private fun clearPendingRefreshViewChildrenLayout(host: NestedScrollableHost) {
+        host.pendingRefreshFrameCallback?.let { callback ->
+            Choreographer.getInstance().removeFrameCallback(callback)
+            host.pendingRefreshFrameCallback = null
+        }
+    }
+
+    private fun debouncedRefreshViewChildrenLayout(host: NestedScrollableHost) {
+        clearPendingRefreshViewChildrenLayout(host)
+        val view = getViewPager(host)
+
+        // Fixes https://github.com/callstack/react-native-pager-view/issues/946
+        val adapter = (view as? ViewPager2)?.adapter as? ViewPagerAdapter
+        if (adapter == null || adapter.itemCount == 0) {
+            // Do not call refreshViewChildrenLayout on pager unmount
+            return
+        }
+
+        val callback = Choreographer.FrameCallback {
+            refreshViewChildrenLayout(view)
+            host.pendingRefreshFrameCallback = null
+        }
+        host.pendingRefreshFrameCallback = callback
+        Choreographer.getInstance().postFrameCallback(callback)
+    }
+}

package/android/src/main/java/com/reactnativepagerview/PagerViewViewPackage.kt

@@ -0,0 +1,17 @@
+package com.reactnativepagerview
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class PagerViewPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return emptyList()
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(PagerViewViewManager())
+    }
+}