@cetapod/react-native-smb 1.0.0

package/cpp/shared/connection/SmbConnectionPool.cpp

@@ -0,0 +1,316 @@
+#include "SmbConnectionPool.hpp"
+
+#include <stdexcept>
+#include <utility>
+
+#include "../util/SmbLog.hpp"
+
+namespace react_native_smb {
+
+namespace {
+const char* acquireModeName(AcquireMode mode) {
+    return mode == AcquireMode::Interactive ? "interactive" : "metadata";
+}
+}  // namespace
+
+SmbConnectionPool::SmbConnectionPool(size_t maxConnections) : maxConnections_(maxConnections) {
+    slots_.reserve(maxConnections);
+    slots_.emplace_back(0);
+}
+
+SmbConnectionPool::~SmbConnectionPool() {
+    for (auto& slot : slots_) {
+        if (slot.manager()) slot.manager()->disconnect();
+    }
+}
+
+PoolSlot& SmbConnectionPool::primarySlot() { return slots_[0]; }
+
+const PoolSlot& SmbConnectionPool::primarySlot() const { return slots_[0]; }
+
+bool SmbConnectionPool::slotNeedsActivate(const PoolSlot& slot) const {
+    const auto* mgr = slot.manager();
+    if (!mgr) return true;
+    return !mgr->isInitialized() && !serverUrl_.empty() && credentials_ != nullptr;
+}
+
+size_t SmbConnectionPool::findIdleSlot(AcquireMode mode) const {
+    if (mode == AcquireMode::Interactive) {
+        if (slots_[0].isIdle()) return 0;
+        for (size_t i = 1; i < slots_.size(); ++i) {
+            if (slots_[i].isIdle()) return i;
+        }
+        return SIZE_MAX;
+    }
+    for (size_t i = 1; i < slots_.size(); ++i) {
+        if (slots_[i].isIdle()) return i;
+    }
+    return SIZE_MAX;
+}
+
+size_t SmbConnectionPool::maybeGrowSlot() {
+    if (slots_.size() >= maxConnections_) return SIZE_MAX;
+    const size_t idx = slots_.size();
+    slots_.emplace_back(idx);
+    return idx;
+}
+
+void SmbConnectionPool::tryAssignNext() {
+    std::vector<PoolSlotInfo> snap;
+    bool assigned = false;
+    for (;;) {
+        ContextRequestPtr req;
+        size_t slotIdx = SIZE_MAX;
+        bool needsActivate = false;
+        PoolConnectParams params;
+        std::string taskId;
+
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            queue_.removeCancelledFromHead();
+            req = queue_.takeNext();
+            if (!req) break;
+
+            slotIdx = findIdleSlot(req->mode);
+            if (slotIdx == SIZE_MAX && req->mode == AcquireMode::Metadata) slotIdx = maybeGrowSlot();
+            if (slotIdx == SIZE_MAX) {
+                queue_.requeueFront(std::move(req));
+                break;
+            }
+
+            PoolSlot& slot = slots_[slotIdx];
+            if (!slot.accepts(req->mode)) {
+                queue_.requeueFront(std::move(req));
+                break;
+            }
+
+            slot.markActivating();
+            params.serverUrl = serverUrl_;
+            params.shareName = shareName_;
+            params.credentials = credentials_;
+            needsActivate = slotNeedsActivate(slot);
+            taskId = req->taskId;
+
+            lock.unlock();
+
+            bool ok = true;
+            try {
+                if (needsActivate)
+                    slot.activate(params, taskId);
+                else
+                    slot.ensureShare(shareName_, taskId);
+            } catch (...) {
+                ok = false;
+            }
+
+            lock.lock();
+
+            if (!ok) {
+                SMB_LOG("Pool assign failed slot=%zu kind=%s taskId=%s", slotIdx, operationName(req->kind), req->taskId.c_str());
+                slot.resetBroken();
+                req->fulfilled.store(true, std::memory_order_release);
+                try {
+                    req->promise.set_value(PoolContextHandle{});
+                } catch (...) {
+                }
+                assignCv_.notify_all();
+                break;
+            }
+
+            slot.assign(req->id, req->taskId, req->kind);
+            SMB_LOG("Pool assign slot=%zu kind=%s taskId=%s mode=%s", slotIdx, operationName(req->kind), req->taskId.c_str(),
+                    acquireModeName(req->mode));
+            PoolContextHandle handle(this, slotIdx, slot.manager());
+            req->fulfilled.store(true, std::memory_order_release);
+            try {
+                req->promise.set_value(std::move(handle));
+            } catch (...) {
+                slot.release();
+                req->fulfilled.store(false, std::memory_order_release);
+                break;
+            }
+            assigned = true;
+        }
+    }
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (assigned) {
+            snap.reserve(slots_.size());
+            for (const auto& slot : slots_) snap.push_back(slot.snapshot(slots_.size()));
+        }
+        assignCv_.notify_all();
+    }
+    if (assigned) {
+        for (auto& [id, fn] : observers_) {
+            try {
+                if (fn) fn(snap);
+            } catch (...) {
+            }
+        }
+    }
+}
+
+PoolContextHandle SmbConnectionPool::requestContext(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId) {
+    ContextRequestPtr req;
+    std::future<PoolContextHandle> fut;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        req = queue_.enqueue(mode, kind, taskId);
+        fut = req->promise.get_future();
+    }
+    tryAssignNext();
+
+    std::unique_lock<std::mutex> lock(mutex_);
+    assignCv_.wait(lock, [&] {
+        return req->fulfilled.load(std::memory_order_acquire) || req->cancelled.load(std::memory_order_acquire);
+    });
+
+    if (req->cancelled.load(std::memory_order_acquire)) {
+        SMB_LOG("Pool requestContext cancelled kind=%s taskId=%s", operationName(kind), taskId.c_str());
+        throw std::runtime_error("context request cancelled");
+    }
+
+    PoolContextHandle handle = fut.get();
+    if (!handle.valid()) {
+        SMB_LOG("Pool requestContext failed kind=%s taskId=%s", operationName(kind), taskId.c_str());
+        throw std::runtime_error("context request failed");
+    }
+    return handle;
+}
+
+void SmbConnectionPool::releaseContext(const PoolContextHandle& handle) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (handle.valid()) {
+            SMB_LOG("Pool release slot=%zu", handle.slotIndex());
+            slots_[handle.slotIndex()].release();
+        }
+    }
+    tryAssignNext();
+}
+
+void SmbConnectionPool::cancelRequestsForTask(const std::string& taskId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    queue_.cancelForTask(taskId);
+    assignCv_.notify_all();
+}
+
+size_t SmbConnectionPool::addObserver(const PoolObserver& observer) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const size_t id = nextObserverId_++;
+    observers_.emplace(id, observer);
+    return id;
+}
+
+void SmbConnectionPool::removeObserver(size_t id) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    observers_.erase(id);
+}
+
+std::vector<PoolSlotInfo> SmbConnectionPool::getPoolStatus() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    std::vector<PoolSlotInfo> out;
+    out.reserve(slots_.size());
+    for (const auto& slot : slots_) out.push_back(slot.snapshot(slots_.size()));
+    return out;
+}
+
+void SmbConnectionPool::initialize(const std::string& url, const SmbCredentials& credentials, const std::string& taskId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    serverUrl_ = url;
+    credentials_ = std::make_shared<SmbCredentials>(credentials);
+    shareName_.clear();
+    primarySlot().manager()->initialize(url, credentials, taskId);
+    for (size_t i = 1; i < slots_.size(); ++i) {
+        if (slots_[i].isIdle() && slots_[i].manager()) slots_[i].manager()->disconnect();
+    }
+}
+
+void SmbConnectionPool::connect(const std::string& url, const SmbCredentials& credentials, const std::string& taskId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    serverUrl_ = url;
+    credentials_ = std::make_shared<SmbCredentials>(credentials);
+    shareName_.clear();
+    if (url.size() > 6 && url.substr(0, 6) == "smb://") {
+        std::string remaining = url.substr(6);
+        const size_t slash = remaining.find('/');
+        if (slash != std::string::npos) shareName_ = remaining.substr(slash + 1);
+    }
+    primarySlot().manager()->connect(url, credentials, taskId);
+    for (size_t i = 1; i < slots_.size(); ++i) {
+        if (slots_[i].isIdle() && slots_[i].manager()) slots_[i].manager()->disconnect();
+    }
+}
+
+void SmbConnectionPool::connectShare(const std::string& share, const std::string& taskId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    shareName_ = share;
+    primarySlot().manager()->connectShare(share, taskId);
+    for (size_t i = 1; i < slots_.size(); ++i) {
+        if (slots_[i].isIdle() && slots_[i].manager()) slots_[i].manager()->disconnect();
+    }
+}
+
+void SmbConnectionPool::disconnect(const std::string& taskId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    serverUrl_.clear();
+    shareName_.clear();
+    credentials_.reset();
+    for (auto& slot : slots_) {
+        if (slot.isIdle() && slot.manager()) slot.manager()->disconnect(taskId);
+    }
+}
+
+void SmbConnectionPool::resetPool() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    for (auto& slot : slots_) {
+        if (slot.manager()) {
+            try {
+                slot.manager()->disconnect();
+            } catch (...) {
+            }
+        }
+    }
+    if (slots_.size() > 1) slots_.erase(slots_.begin() + 1, slots_.end());
+    slots_[0].resetBroken();
+    serverUrl_.clear();
+    shareName_.clear();
+    credentials_.reset();
+}
+
+std::vector<SmbShareList> SmbConnectionPool::listShares(const std::string& taskId) {
+    auto handle = requestContext(AcquireMode::Interactive, SmbOperatorKind::ListShares, taskId);
+    return handle.manager().listShares(taskId);
+}
+
+bool SmbConnectionPool::isConnected() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return primarySlot().manager() && primarySlot().manager()->isConnected();
+}
+
+bool SmbConnectionPool::isInitialized() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return primarySlot().manager() && primarySlot().manager()->isInitialized();
+}
+
+std::string SmbConnectionPool::getCurrentUrl() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return primarySlot().manager() ? primarySlot().manager()->getCurrentUrl() : std::string();
+}
+
+std::string SmbConnectionPool::getServerName() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return primarySlot().manager() ? primarySlot().manager()->getServerName() : std::string();
+}
+
+std::string SmbConnectionPool::getShareName() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return shareName_;
+}
+
+std::shared_ptr<SmbCredentials> SmbConnectionPool::getCredentials() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return credentials_;
+}
+
+}  // namespace react_native_smb

package/cpp/shared/connection/SmbConnectionPool.hpp

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include "../core/SmbEnums.hpp"
+#include "ContextRequestQueue.hpp"
+#include "PoolContextHandle.hpp"
+#include "PoolSlot.hpp"
+#include "PoolTypes.hpp"
+#include "SmbConnection.hpp"
+
+namespace react_native_smb {
+
+/**
+ * Pool layout (maxConnections = N):
+ *
+ *   slot[0]       — Interactive-only
+ *   slot[1..N-1]  — General (any AcquireMode; Interactive may overflow here)
+ *
+ *   Op::requestContext → Interactive-first FIFO queue → exclusive slot assignment
+ */
+class SmbConnectionPool {
+   public:
+    using PoolObserver = std::function<void(const std::vector<PoolSlotInfo>&)>;
+
+    explicit SmbConnectionPool(size_t maxConnections = 4);
+    ~SmbConnectionPool();
+
+    // [connection control]
+    void initialize(const std::string& url, const SmbCredentials& credentials, const std::string& taskId = "");
+    void connect(const std::string& url, const SmbCredentials& credentials, const std::string& taskId = "");
+    void connectShare(const std::string& share, const std::string& taskId = "");
+    void disconnect(const std::string& taskId = "");
+    void resetPool();
+    std::vector<SmbShareList> listShares(const std::string& taskId = "");
+
+    // [context]
+    PoolContextHandle requestContext(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId = "");
+    void releaseContext(const PoolContextHandle& handle);
+    void cancelRequestsForTask(const std::string& taskId);
+
+    // [getter]
+    std::string getCurrentUrl() const;
+    std::string getServerName() const;
+    std::string getShareName() const;
+    std::shared_ptr<SmbCredentials> getCredentials() const;
+    std::vector<PoolSlotInfo> getPoolStatus() const;
+
+    // [is…]
+    bool isConnected() const;
+    bool isInitialized() const;
+
+    // [observer]
+    size_t addObserver(const PoolObserver& observer);
+    void removeObserver(size_t id);
+
+   private:
+    void tryAssignNext();
+    size_t findIdleSlot(AcquireMode mode) const;
+    size_t maybeGrowSlot();
+    bool slotNeedsActivate(const PoolSlot& slot) const;
+    PoolSlot& primarySlot();
+    const PoolSlot& primarySlot() const;
+    mutable std::mutex mutex_;
+    std::condition_variable assignCv_;
+    std::vector<PoolSlot> slots_;
+    size_t maxConnections_{4};
+    ContextRequestQueue queue_;
+
+    std::string serverUrl_;
+    std::string shareName_;
+    std::shared_ptr<SmbCredentials> credentials_;
+
+    std::map<size_t, PoolObserver> observers_;
+    size_t nextObserverId_{1};
+};
+
+}  // namespace react_native_smb

package/cpp/shared/core/CancellationToken.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+
+namespace react_native_smb {
+
+// A cheap, copyable cancellation flag shared by a task and all its operators.
+// The task owns the root token; cancel() trips it; operators poll cancelled()
+// inside their work loops. Copying shares the same underlying atomic<bool>.
+class CancellationToken {
+   public:
+    CancellationToken() = default;
+
+    void cancel() { flag_->store(true, std::memory_order_relaxed); }
+    bool cancelled() const { return flag_->load(std::memory_order_relaxed); }
+
+   private:
+    std::shared_ptr<std::atomic<bool>> flag_ = std::make_shared<std::atomic<bool>>(false);
+};
+
+}  // namespace react_native_smb

package/cpp/shared/core/OperatorContext.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <cstddef>
+
+#include "CancellationToken.hpp"
+
+namespace react_native_smb {
+
+class SmbTask;
+class SmbConnectionPool;
+
+// Everything an operator needs, injected by OperatorBase::start() before run().
+//   - task     : back-pointer to report status/progress and spawn() more work
+//   - pool     : connection pool; op calls requestContext() when it needs a slot
+//   - cancel   : shared token the operator polls in its loop
+//   - opIndex  : this operator's stable index for per-op aggregation
+struct OperatorContext {
+    SmbTask* task{nullptr};            // non-owning
+    SmbConnectionPool* pool{nullptr};  // non-owning
+    CancellationToken cancel;          // shared with the task
+    size_t opIndex{0};
+};
+
+}  // namespace react_native_smb

package/cpp/shared/core/SmbEnums.hpp

@@ -0,0 +1,126 @@
+#pragma once
+
+namespace react_native_smb {
+
+// One operator class per kind. The enum is the single source of truth for the
+// human-readable operation name (operationName) and whether byte-progress is
+// meaningful (isDeterminate).
+enum class SmbOperatorKind {
+    // Connection Management
+    Initialize,
+    Connect,
+    ConnectShare,
+    Disconnect,
+    ListShares,
+    // Listing & Info
+    ListDirectory,
+    GetPathInfo,
+    GetSecurityDescriptor,
+    // File Transfers
+    DownloadFile,
+    UploadFile,
+    // Mutating File Operations
+    CreateDirectory,
+    DeleteItem,
+    MoveItem,
+    RenameItem,
+    CopyItem,
+    DuplicateItem,
+};
+
+// Task lifecycle status. Index order matters: statusName[] mirrors it.
+enum class SmbTaskStatus {
+    Idle,
+    Pending,
+    Running,
+    Success,
+    Error,
+    Cancelled,
+};
+
+// Single source of truth: operation string is derived from the enum, never
+// typed by hand. HybridSMB passes no literal operation string.
+constexpr const char* operationName(SmbOperatorKind k) {
+    switch (k) {
+        case SmbOperatorKind::Initialize:
+            return "initialize";
+        case SmbOperatorKind::Connect:
+            return "connect";
+        case SmbOperatorKind::ConnectShare:
+            return "connectShare";
+        case SmbOperatorKind::Disconnect:
+            return "disconnect";
+        case SmbOperatorKind::ListShares:
+            return "listShares";
+        case SmbOperatorKind::ListDirectory:
+            return "listDirectory";
+        case SmbOperatorKind::GetPathInfo:
+            return "getPathInfo";
+        case SmbOperatorKind::GetSecurityDescriptor:
+            return "getSecurityDescriptor";
+        case SmbOperatorKind::DownloadFile:
+            return "downloadFile";
+        case SmbOperatorKind::UploadFile:
+            return "uploadFile";
+        case SmbOperatorKind::CreateDirectory:
+            return "createDirectory";
+        case SmbOperatorKind::DeleteItem:
+            return "deleteItem";
+        case SmbOperatorKind::MoveItem:
+            return "moveItem";
+        case SmbOperatorKind::RenameItem:
+            return "renameItem";
+        case SmbOperatorKind::CopyItem:
+            return "copyItem";
+        case SmbOperatorKind::DuplicateItem:
+            return "duplicateItem";
+    }
+    return "unknown";
+}
+
+// Transfers carry meaningful byte progress; metadata ops do not. The UI uses
+// this to choose a determinate bar vs. an indeterminate spinner.
+constexpr bool isDeterminate(SmbOperatorKind k) {
+    switch (k) {
+        case SmbOperatorKind::DownloadFile:
+        case SmbOperatorKind::UploadFile:
+        case SmbOperatorKind::CopyItem:
+        case SmbOperatorKind::DuplicateItem:
+            return true;
+        default:
+            return false;
+    }
+}
+
+constexpr bool isTransferKind(SmbOperatorKind k) {
+    switch (k) {
+        case SmbOperatorKind::DownloadFile:
+        case SmbOperatorKind::UploadFile:
+        case SmbOperatorKind::CopyItem:
+        case SmbOperatorKind::DuplicateItem:
+            return true;
+        default:
+            return false;
+    }
+}
+
+// Lowercase status name for the JS bridge. Index mirrors SmbTaskStatus.
+constexpr const char* statusName(SmbTaskStatus s) {
+    switch (s) {
+        case SmbTaskStatus::Idle:
+            return "idle";
+        case SmbTaskStatus::Pending:
+            return "pending";
+        case SmbTaskStatus::Running:
+            return "running";
+        case SmbTaskStatus::Success:
+            return "success";
+        case SmbTaskStatus::Error:
+            return "error";
+        case SmbTaskStatus::Cancelled:
+            return "cancelled";
+    }
+    return "unknown";
+}
+
+}  // namespace react_native_smb

package/cpp/shared/core/SmbTask.cpp

@@ -0,0 +1,131 @@
+#include "SmbTask.hpp"
+
+#include <NitroModules/Promise.hpp>
+#include <thread>
+
+#include "../connection/SmbConnectionPool.hpp"
+#include "../operators/OperatorBase.hpp"
+#include "../util/SmbErrorMapper.hpp"
+#include "TaskSnapshotCodec.hpp"
+#include "../util/SmbLog.hpp"
+
+namespace react_native_smb {
+
+namespace jsi = facebook::jsi;
+using namespace margelo::nitro;
+
+SmbTask::SmbTask(std::string id, std::unique_ptr<OperatorBase> seedOp, SmbConnectionPool* pool)
+    : HybridObject("SmbTask"),
+      SmbTaskCore(std::move(id), seedOp->kind()),
+      pool_(pool) {
+    ops_.push_back(std::move(seedOp));
+    opProgress_.resize(1);
+    loadHybridMethods();
+}
+
+SmbTask::~SmbTask() = default;
+
+void SmbTask::cancel() {
+    SMB_LOG("Task cancel id=%s", getId().c_str());
+    if (pool_) pool_->cancelRequestsForTask(getId());
+    SmbTaskCore::cancel();
+}
+
+void SmbTask::start() {
+    markRunning();
+    auto fut = completionFuture();
+    {
+        std::lock_guard<std::mutex> lk(stateMutex_);
+        pending_ = 1;
+        launchOp(0);
+    }
+    fut.wait();
+}
+
+void SmbTask::launchOp(size_t opIndex) {
+    auto self = std::static_pointer_cast<SmbTask>(shared());
+    std::thread([self, opIndex] {
+        if (self->cancel_.cancelled()) {
+            self->onOpFinished();
+            return;
+        }
+        OperatorBase* op = nullptr;
+        {
+            std::lock_guard<std::mutex> lk(self->stateMutex_);
+            if (opIndex < self->ops_.size()) op = self->ops_[opIndex].get();
+        }
+        if (!op) {
+            self->onOpFinished();
+            return;
+        }
+        try {
+            op->start(self.get(), self->pool_, self->cancel_, opIndex);
+        } catch (const std::exception& e) {
+            if (!self->cancel_.cancelled()) {
+                const int code = SmbErrorMapper::fromErrnoOrMessage(0, e.what());
+                self->settle(SmbTaskStatus::Error, e.what(), code);
+            }
+        } catch (...) {
+            if (!self->cancel_.cancelled()) {
+                self->settle(SmbTaskStatus::Error, "unknown error", static_cast<int>(SmbErrorCode::Unknown));
+            }
+        }
+        self->onOpFinished();
+    }).detach();
+}
+
+size_t SmbTask::appendOps(std::vector<std::unique_ptr<OperatorBase>>& more) {
+    const size_t first = ops_.size();
+    for (auto& op : more) {
+        ops_.push_back(std::move(op));
+    }
+    opProgress_.resize(ops_.size());
+    return first;
+}
+
+size_t SmbTask::spawn(std::vector<std::unique_ptr<OperatorBase>> moreOps) {
+    if (moreOps.empty()) return ops_.size();
+    const size_t count = moreOps.size();
+    size_t first;
+    {
+        std::lock_guard<std::mutex> lk(stateMutex_);
+        first = appendOps(moreOps);
+        pending_ += count;
+        for (size_t i = 0; i < count; ++i) launchOp(first + i);
+    }
+    return first;
+}
+
+std::unordered_map<std::string, std::string> SmbTask::get() {
+    return TaskSnapshotCodec::encode(getState());
+}
+
+jsi::Value SmbTask::getResultValueRaw(jsi::Runtime& runtime, const jsi::Value& /*thisValue*/, const jsi::Value* /*args*/,
+                                      size_t /*count*/) {
+    return SmbTaskCore::getResultValue(runtime);
+}
+
+std::string SmbTask::subscribeMap(const std::function<void(const std::unordered_map<std::string, std::string>&)>& listener) {
+    return SmbTaskCore::subscribe([listener](const SmbTaskState& s) {
+        if (listener) {
+            try {
+                listener(TaskSnapshotCodec::encode(s));
+            } catch (...) {
+            }
+        }
+    });
+}
+
+void SmbTask::loadHybridMethods() {
+    HybridObject::loadHybridMethods();
+    registerHybrids(this, [](Prototype& prototype) {
+        prototype.registerHybridMethod("id", &SmbTask::getId);
+        prototype.registerHybridMethod("cancel", &SmbTask::cancel);
+        prototype.registerHybridMethod("get", &SmbTask::get);
+        prototype.registerHybridMethod("subscribe", &SmbTask::subscribeMap);
+        prototype.registerHybridMethod("unsubscribe", &SmbTask::unsubscribe);
+        prototype.registerRawHybridMethod("getResultValue", 0, &SmbTask::getResultValueRaw);
+    });
+}
+
+}  // namespace react_native_smb