@depup/react-native-worklets 0.12.2-depup.0 → 0.13.0-depup.0

package/Common/cpp/worklets/SharedItems/Synchronizable.cpp

@@ -1,59 +0,0 @@
-#include <react/debug/react_native_assert.h>
-#include <worklets/SharedItems/Synchronizable.h>
-
-#include <memory>
-#include <utility>
-
-namespace worklets {
-
-std::shared_ptr<Serializable> Synchronizable::getDirty() {
-  return value_;
-}
-
-std::shared_ptr<Serializable> Synchronizable::getBlocking() {
-  getBlockingBefore();
-  auto value = value_;
-  getBlockingAfter();
-  return value;
-}
-
-// TODO: Shared pointer members (unless they're atomic) can't be assigned
-// in a non thread-safe manner, therefore `setDirty` has little sense now.
-// void Synchronizable::setDirty(const std::shared_ptr<Serializable> &value) {
-//   setDirtyBefore();
-//   value_ = value;
-//   setDirtyAfter();
-// }
-
-void Synchronizable::setBlocking(const std::shared_ptr<Serializable> &value) {
-  setBlockingBefore();
-  value_ = value;
-  setBlockingAfter();
-}
-
-jsi::Value Synchronizable::toJSValue(jsi::Runtime &rt) {
-  auto synchronizableUnpacker = getSynchronizableUnpacker(rt);
-  auto ref = SerializableJSRef::newNativeStateObject(rt, this->shared_from_this());
-  return synchronizableUnpacker.call(rt, std::move(ref));
-}
-
-Synchronizable::Synchronizable(const std::shared_ptr<Serializable> &value)
-    : Serializable(ValueType::SynchronizableType), value_(value) {}
-
-jsi::Function getSynchronizableUnpacker(jsi::Runtime &rt) {
-  auto synchronizableUnpacker = rt.global().getProperty(rt, "__synchronizableUnpacker");
-  react_native_assert(synchronizableUnpacker.isObject() && "synchronizableUnpacker not found");
-  return synchronizableUnpacker.asObject(rt).asFunction(rt);
-}
-
-std::shared_ptr<Synchronizable> extractSynchronizableOrThrow(jsi::Runtime &rt, const jsi::Value &value) {
-  auto serializable =
-      extractSerializableOrThrow(rt, value, "[Worklets] Expecting the object to be of type SerializableJSRef.");
-
-  auto synchronizable = std::dynamic_pointer_cast<Synchronizable>(serializable);
-  react_native_assert(synchronizable != nullptr && "[Worklets] Expected the object to be a Synchronizable.");
-
-  return synchronizable;
-}
-
-} // namespace worklets

package/android/src/main/cpp/worklets/android/JWorkletRuntimeWrapper.cpp

@@ -1,51 +0,0 @@
-#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
-
-#include <jsi/JSIDynamic.h>
-#include <jsi/jsi.h>
-#include <worklets/android/JWorkletRuntimeWrapper.h>
-
-#include <utility>
-#include <vector>
-
-namespace worklets {
-
-using namespace facebook::jni;
-
-local_ref<JWorkletRuntimeWrapper::JavaPart> JWorkletRuntimeWrapper::makeJWorkletRuntimeWrapper(
-    std::shared_ptr<WorkletRuntime> workletRuntime) {
-  return JWorkletRuntimeWrapper::newObjectCxxArgs(std::move(workletRuntime));
-}
-
-JWorkletRuntimeWrapper::JWorkletRuntimeWrapper(std::shared_ptr<WorkletRuntime> workletRuntime)
-    : workletRuntime_(std::move(workletRuntime)) {}
-
-void JWorkletRuntimeWrapper::cxxEmitDeviceEvent(
-    jni::alias_ref<WritableNativeArray::javaobject> params // NOLINT //(performance-unnecessary-value-param
-) {
-  workletRuntime_->schedule([params = params->cthis()->consume()](jsi::Runtime &rt) {
-    facebook::jsi::Value emitter = rt.global().getProperty(rt, "__rctDeviceEventEmitter");
-    if (!emitter.isUndefined()) {
-      facebook::jsi::Object emitterObject = emitter.asObject(rt);
-      facebook::jsi::Function emitFunction = emitterObject.getPropertyAsFunction(rt, "emit");
-      std::vector<jsi::Value> jsArgs;
-      for (auto &param : params) {
-        jsArgs.push_back(jsi::valueFromDynamic(rt, param));
-      }
-
-      emitFunction.callWithThis(rt, emitterObject, static_cast<const jsi::Value *>(jsArgs.data()), jsArgs.size());
-    }
-  });
-}
-
-int JWorkletRuntimeWrapper::cxxGetRuntimeId() {
-  return static_cast<int>(workletRuntime_->getRuntimeId());
-}
-
-void JWorkletRuntimeWrapper::registerNatives() {
-  registerHybrid(
-      {makeNativeMethod("cxxEmitDeviceEvent", JWorkletRuntimeWrapper::cxxEmitDeviceEvent),
-       makeNativeMethod("cxxGetRuntimeId", JWorkletRuntimeWrapper::cxxGetRuntimeId)});
-}
-} // namespace worklets
-
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED

package/android/src/main/cpp/worklets/android/JWorkletRuntimeWrapper.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
-
-#include <fbjni/fbjni.h>
-#include <react/jni/ReadableNativeArray.h>
-#include <react/jni/WritableNativeArray.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-
-#include <memory>
-
-namespace worklets {
-
-using namespace facebook;
-using namespace facebook::react;
-using namespace facebook::jni;
-
-/**
- * JNI wrapper around WorkletRuntime to expose its methods to Java.
- */
-class JWorkletRuntimeWrapper : public jni::HybridClass<JWorkletRuntimeWrapper> {
- public:
-  constexpr static const char *const kJavaDescriptor = "Lcom/swmansion/worklets/WorkletRuntimeWrapper;";
-
-  static local_ref<JWorkletRuntimeWrapper::JavaPart> makeJWorkletRuntimeWrapper(
-      std::shared_ptr<WorkletRuntime> workletRuntime);
-
-  static void registerNatives();
-
-  void cxxEmitDeviceEvent(jni::alias_ref<WritableNativeArray::javaobject> params);
-  int cxxGetRuntimeId();
-
- private:
-  friend HybridBase;
-
-  explicit JWorkletRuntimeWrapper(std::shared_ptr<WorkletRuntime> workletRuntime);
-
-  const std::shared_ptr<WorkletRuntime> workletRuntime_;
-};
-
-} // namespace worklets
-
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED

package/android/src/networking/com/swmansion/worklets/WorkletRuntimeWrapper.kt

@@ -1,27 +0,0 @@
-package com.swmansion.worklets
-
-import com.facebook.jni.HybridData
-import com.facebook.jni.annotations.DoNotStrip
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableNativeArray
-
-@DoNotStrip
-@Suppress("KotlinJniMissingFunction")
-class WorkletRuntimeWrapper
-    @DoNotStrip
-    private constructor(
-        @field:DoNotStrip private val mHybridData: HybridData,
-    ) {
-        fun emitDeviceEvent(
-            eventName: String,
-            params: Any?,
-        ) {
-            cxxEmitDeviceEvent(Arguments.fromJavaArgs(arrayOf(eventName, params)))
-        }
-
-        fun getRuntimeId(): Int = cxxGetRuntimeId()
-
-        private external fun cxxEmitDeviceEvent(args: WritableNativeArray)
-
-        private external fun cxxGetRuntimeId(): Int
-    }

package/android/src/networking/com/swmansion/worklets/WorkletsHeaderUtil.kt

@@ -1,30 +0,0 @@
-/**
-* Based on HeaderUtil.kt from React Native
-*/
-
-package com.swmansion.worklets
-
-/**
- * The class purpose is to weaken too strict OkHttp restriction on http headers. See:
- * https://github.com/square/okhttp/issues/2016 Auth headers might have an Authentication
- * information. It is better to get 401 from the server in this case, rather than non descriptive
- * error as 401 could be handled to invalidate the wrong token in the client code.
- */
-internal class WorkletsHeaderUtil {
-    companion object {
-        @JvmStatic
-        fun stripHeaderName(name: String): String {
-            val builder = StringBuilder(name.length)
-            var modified = false
-            for (i in 0 until name.length) {
-                val c = name[i]
-                if (c > '\u0020' && c < '\u007f') {
-                    builder.append(c)
-                } else {
-                    modified = true
-                }
-            }
-            return if (modified) builder.toString() else name
-        }
-    }
-}

package/android/src/networking/com/swmansion/worklets/WorkletsModule.kt

@@ -1,204 +0,0 @@
-package com.swmansion.worklets
-
-import com.facebook.jni.HybridData
-import com.facebook.proguard.annotations.DoNotStrip
-import com.facebook.react.bridge.Callback
-import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReadableNativeArray
-import com.facebook.react.bridge.ReadableNativeMap
-import com.facebook.react.common.annotations.FrameworkAPI
-import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
-import com.facebook.soloader.SoLoader
-import com.swmansion.worklets.runloop.AnimationFrameCallback
-import com.swmansion.worklets.runloop.AnimationFrameQueue
-
-@Suppress("KotlinJniMissingFunction")
-@ReactModule(name = WorkletsModule.NAME)
-class WorkletsModule(
-    reactContext: ReactApplicationContext,
-) : NativeWorkletsModuleSpec(reactContext),
-    LifecycleEventListener {
-    companion object {
-        const val NAME = "WorkletsModule"
-
-        init {
-            SoLoader.loadLibrary("worklets")
-        }
-    }
-
-    @field:DoNotStrip
-    @Suppress("unused")
-    private var mHybridData: HybridData? = null
-
-    @Suppress("unused")
-    protected fun getHybridData(): HybridData? = mHybridData
-
-    init {
-        reactContext.assertOnJSQueueThread()
-    }
-
-    private val mAndroidUIScheduler = AndroidUIScheduler(reactContext)
-    private val mAnimationFrameQueue = AnimationFrameQueue(reactContext)
-    private val mWorkletsNetworking = WorkletsNetworking()
-    private var mSlowAnimationsEnabled = false
-
-    /**
-     * Invalidating concurrently could be fatal. It shouldn't happen in a normal flow, but it doesn't
-     * cost us much to add synchronization for extra safety.
-     */
-    private val mInvalidationLock = Any()
-    private var mInvalidated = false
-
-    @OptIn(FrameworkAPI::class)
-    private external fun initHybrid(
-        bundleModeEnabled: Boolean,
-        jsContext: Long,
-        jsCallInvokerHolder: CallInvokerHolderImpl,
-        androidUIScheduler: AndroidUIScheduler,
-        scriptBufferWrapper: ScriptBufferWrapper?,
-    ): HybridData
-
-    @OptIn(FrameworkAPI::class)
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun installTurboModule(bundleModeEnabled: Boolean): Boolean {
-        val context = reactApplicationContext
-
-        context.assertOnJSQueueThread()
-
-        val jsContext = checkNotNull(context.javaScriptContextHolder).get()
-        val jsCallInvokerHolder = context.jsCallInvokerHolder as CallInvokerHolderImpl
-
-        val scriptBufferWrapper: ScriptBufferWrapper? =
-            if (bundleModeEnabled) {
-                ScriptBufferWrapper(context.sourceURL, context)
-            } else {
-                null
-            }
-
-        mHybridData =
-            initHybrid(
-                bundleModeEnabled,
-                jsContext,
-                jsCallInvokerHolder,
-                mAndroidUIScheduler,
-                scriptBufferWrapper,
-            )
-        return true
-    }
-
-    @OptIn(FrameworkAPI::class)
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun start(): Boolean {
-        reactApplicationContext.assertOnJSQueueThread()
-        startCpp()
-        return true
-    }
-
-    @DoNotStrip
-    fun abortRequest(
-        runtimeId: Int,
-        requestIdAsDouble: Double,
-    ) {
-        mWorkletsNetworking.jsiAbortRequest(runtimeId, requestIdAsDouble)
-    }
-
-    @DoNotStrip
-    fun clearCookies(callback: Callback) {
-        mWorkletsNetworking.jsiClearCookies(callback)
-    }
-
-    @DoNotStrip
-    fun sendRequest(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        method: String,
-        url: String,
-        requestIdAsDouble: Double,
-        headers: ReadableNativeArray,
-        data: ReadableNativeMap,
-        responseType: String,
-        useIncrementalUpdates: Boolean,
-        timeoutAsDouble: Double,
-        withCredentials: Boolean,
-    ) {
-        mWorkletsNetworking.jsiSendRequest(
-            runtimeWrapper,
-            method,
-            url,
-            requestIdAsDouble,
-            headers,
-            data,
-            responseType,
-            useIncrementalUpdates,
-            timeoutAsDouble,
-            withCredentials,
-        )
-    }
-
-    @DoNotStrip
-    fun requestAnimationFrame(animationFrameCallback: AnimationFrameCallback) {
-        mAnimationFrameQueue.requestAnimationFrame(animationFrameCallback)
-    }
-
-    /** @noinspection unused */
-    @DoNotStrip
-    fun isOnJSQueueThread(): Boolean = reactApplicationContext.isOnJSQueueThread
-
-    fun toggleSlowAnimations() {
-        val animationsDragFactor = 10
-        mSlowAnimationsEnabled = !mSlowAnimationsEnabled
-        mAnimationFrameQueue.enableSlowAnimations(mSlowAnimationsEnabled, animationsDragFactor)
-    }
-
-    @OptIn(FrameworkAPI::class)
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun toggleSlowAnimationsOnUIRuntime(): Boolean {
-        toggleSlowAnimations()
-        return mSlowAnimationsEnabled
-    }
-
-    override fun initialize() {
-        reactApplicationContext.addLifecycleEventListener(this)
-    }
-
-    override fun invalidate() {
-        synchronized(mInvalidationLock) {
-            if (mInvalidated) {
-                return
-            }
-            mInvalidated = true
-            reactApplicationContext.removeLifecycleEventListener(this)
-        }
-        mAnimationFrameQueue.invalidate()
-        if (mHybridData != null && mHybridData!!.isValid) {
-            invalidateCpp()
-        }
-        mAndroidUIScheduler.deactivate()
-    }
-
-    private external fun invalidateCpp()
-
-    private external fun startCpp()
-
-    override fun onHostResume() {
-        synchronized(mInvalidationLock) {
-            if (mInvalidated) {
-                return
-            }
-            mAnimationFrameQueue.resume()
-        }
-    }
-
-    override fun onHostPause() {
-        synchronized(mInvalidationLock) {
-            if (mInvalidated) {
-                return
-            }
-            mAnimationFrameQueue.pause()
-        }
-    }
-
-    override fun onHostDestroy() {}
-}

package/android/src/networking/com/swmansion/worklets/WorkletsNetworkEventUtil.kt

@@ -1,272 +0,0 @@
-/**
-* Based on NetworkEventUtil.kt from React Native
-*/
-
-@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
-
-package com.swmansion.worklets
-
-import android.os.Bundle
-import android.util.Base64
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.buildReadableArray
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
-import okhttp3.Headers
-import okhttp3.Protocol
-import okhttp3.Request
-import okhttp3.Response
-import java.net.SocketTimeoutException
-
-/**
- * Utility class for reporting network lifecycle events to JavaScript and InspectorNetworkReporter.
- */
-internal object WorkletsNetworkEventUtil {
-    @JvmStatic
-    fun onCreateRequest(
-        devToolsRequestId: String,
-        request: Request,
-    ) {
-        if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
-            val headersMap = okHttpHeadersToMap(request.headers())
-//      InspectorNetworkReporter.reportRequestStart(
-//          devToolsRequestId,
-//          request.url().toString(),
-//          request.method(),
-//          headersMap,
-//          (request.body() as? ProgressRequestBody)?.getBodyPreview()
-//              ?: request.body()?.toString().orEmpty(),
-//          request.body()?.contentLength() ?: 0,
-//      )
-//      InspectorNetworkReporter.reportConnectionTiming(devToolsRequestId, headersMap)
-        }
-    }
-
-    @JvmStatic
-    fun onDataSend(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        progress: Long,
-        total: Long,
-    ) {
-        runtimeWrapper.emitDeviceEvent(
-            "didSendNetworkData",
-            buildReadableArray {
-                add(requestId)
-                add(progress.toInt())
-                add(total.toInt())
-            },
-        )
-    }
-
-    @JvmStatic
-    fun onIncrementalDataReceived(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        devToolsRequestId: String,
-        data: String?,
-        progress: Long,
-        total: Long,
-    ) {
-//    if (ReactNativeFeatureFlags.enableNetworkEventReporting() && data != null) {
-//      InspectorNetworkReporter.reportDataReceived(devToolsRequestId, data)
-//      InspectorNetworkReporter.maybeStoreResponseBodyIncremental(devToolsRequestId, data)
-//    }
-        runtimeWrapper.emitDeviceEvent(
-            "didReceiveNetworkIncrementalData",
-            buildReadableArray {
-                add(requestId)
-                add(data)
-                add(progress.toInt())
-                add(total.toInt())
-            },
-        )
-    }
-
-    @JvmStatic
-    fun onDataReceivedProgress(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        progress: Long,
-        total: Long,
-    ) {
-        runtimeWrapper.emitDeviceEvent(
-            "didReceiveNetworkDataProgress",
-            buildReadableArray {
-                add(requestId)
-                add(progress.toInt())
-                add(total.toInt())
-            },
-        )
-    }
-
-    @JvmStatic
-    fun onDataReceived(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        devToolsRequestId: String,
-        data: String?,
-        responseType: String,
-    ) {
-//    if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
-//      InspectorNetworkReporter.maybeStoreResponseBody(
-//          devToolsRequestId,
-//          data.orEmpty(),
-//          responseType == "base64",
-//      )
-//    }
-        runtimeWrapper.emitDeviceEvent(
-            "didReceiveNetworkData",
-            buildReadableArray {
-                add(requestId)
-                add(data)
-            },
-        )
-    }
-
-    @JvmStatic
-    fun onDataReceived(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        devToolsRequestId: String,
-        data: WritableMap,
-        rawData: ByteArray,
-    ) {
-//    if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
-//      InspectorNetworkReporter.maybeStoreResponseBody(
-//          devToolsRequestId,
-//          Base64.encodeToString(rawData, Base64.NO_WRAP),
-//          true,
-//      )
-//    }
-        runtimeWrapper.emitDeviceEvent(
-            "didReceiveNetworkData",
-            Arguments.createArray().apply {
-                pushInt(requestId)
-                pushMap(data)
-            },
-        )
-    }
-
-    @JvmStatic
-    fun onRequestError(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        devToolsRequestId: String,
-        error: String?,
-        e: Throwable?,
-    ) {
-        runtimeWrapper.emitDeviceEvent(
-            "didCompleteNetworkResponse",
-            buildReadableArray {
-                add(requestId)
-                add(error)
-                if (e?.javaClass == SocketTimeoutException::class.java) {
-                    add(true) // last argument is a time out boolean
-                }
-            },
-        )
-    }
-
-    @JvmStatic
-    fun onRequestSuccess(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        devToolsRequestId: String,
-        encodedDataLength: Long,
-    ) {
-        runtimeWrapper.emitDeviceEvent(
-            "didCompleteNetworkResponse",
-            buildReadableArray {
-                add(requestId)
-                addNull()
-            },
-        )
-    }
-
-    @JvmStatic
-    fun onResponseReceived(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        devToolsRequestId: String,
-        requestUrl: String?,
-        response: Response,
-    ) {
-        val headersMap = okHttpHeadersToMap(response.headers())
-        val headersBundle = Bundle()
-        for ((headerName, headerValue) in headersMap) {
-            headersBundle.putString(headerName, headerValue)
-        }
-
-//    if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
-//      InspectorNetworkReporter.reportResponseStart(
-//          devToolsRequestId,
-//          requestUrl.orEmpty(),
-//          response.code(),
-//          headersMap,
-//          response.body()?.contentLength() ?: 0,
-//      )
-//    }
-        runtimeWrapper.emitDeviceEvent(
-            "didReceiveNetworkResponse",
-            Arguments.createArray().apply {
-                pushInt(requestId)
-                pushInt(response.code())
-                pushMap(Arguments.fromBundle(headersBundle))
-                pushString(requestUrl)
-            },
-        )
-    }
-
-    @Deprecated("Compatibility overload")
-    @JvmStatic
-    fun onResponseReceived(
-        runtimeWrapper: WorkletRuntimeWrapper,
-        requestId: Int,
-        devToolsRequestId: String,
-        statusCode: Int,
-        headers: WritableMap?,
-        url: String?,
-    ) {
-        val headersBuilder = Headers.Builder()
-        headers?.let { map ->
-            val iterator = map.keySetIterator()
-            while (iterator.hasNextKey()) {
-                val key = iterator.nextKey()
-                val value = map.getString(key)
-                if (value != null) {
-                    headersBuilder.add(key, value)
-                }
-            }
-        }
-        onResponseReceived(
-            runtimeWrapper,
-            requestId,
-            devToolsRequestId,
-            url,
-            Response
-                .Builder()
-                .protocol(Protocol.HTTP_1_1)
-                .request(Request.Builder().url(url.orEmpty()).build())
-                .headers(headersBuilder.build())
-                .code(statusCode)
-                .message("")
-                .build(),
-        )
-    }
-
-    private fun okHttpHeadersToMap(headers: Headers): Map<String, String> {
-        val responseHeaders = mutableMapOf<String, String>()
-        for (i in 0 until headers.size()) {
-            val headerName = headers.name(i)
-            // multiple values for the same header
-            if (responseHeaders.containsKey(headerName)) {
-                responseHeaders[headerName] = "${responseHeaders[headerName]}, ${headers.value(i)}"
-            } else {
-                responseHeaders[headerName] = headers.value(i)
-            }
-        }
-        return responseHeaders
-    }
-}