@runanywhere/core 0.16.0

package/cpp/bridges/DeviceBridge.cpp

@@ -0,0 +1,257 @@
+/**
+ * @file DeviceBridge.cpp
+ * @brief C++ bridge for device operations.
+ *
+ * Mirrors Swift's CppBridge+Device.swift pattern.
+ * Registers callbacks with rac_device_manager and delegates to platform.
+ */
+
+#include "DeviceBridge.hpp"
+#include "rac_error.h"
+#include <cstring>
+
+// Platform-specific logging
+#if defined(ANDROID) || defined(__ANDROID__)
+#include <android/log.h>
+#define LOG_TAG "DeviceBridge"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+#include <cstdio>
+#define LOGI(...) printf("[DeviceBridge] "); printf(__VA_ARGS__); printf("\n")
+#define LOGD(...) printf("[DeviceBridge DEBUG] "); printf(__VA_ARGS__); printf("\n")
+#define LOGE(...) printf("[DeviceBridge ERROR] "); printf(__VA_ARGS__); printf("\n")
+#endif
+
+namespace runanywhere {
+namespace bridges {
+
+// =============================================================================
+// Static storage for callbacks (needed for C function pointers)
+// =============================================================================
+
+static DevicePlatformCallbacks* g_deviceCallbacks = nullptr;
+
+// =============================================================================
+// C Callback Implementations (called by RACommons)
+// =============================================================================
+
+static void deviceGetInfoCallback(rac_device_registration_info_t* outInfo, void* userData) {
+    if (!outInfo || !g_deviceCallbacks || !g_deviceCallbacks->getDeviceInfo) {
+        LOGE("getDeviceInfo callback not available");
+        return;
+    }
+
+    DeviceInfo info = g_deviceCallbacks->getDeviceInfo();
+
+    // Note: We need to use static storage for strings since RACommons
+    // only keeps pointers. In a real implementation, these would need
+    // to be managed carefully for lifetime.
+    static std::string s_deviceId, s_deviceModel, s_deviceName, s_platform;
+    static std::string s_osVersion, s_formFactor, s_architecture, s_chipName;
+    static std::string s_gpuFamily, s_batteryState, s_deviceType, s_osName;
+    static std::string s_deviceFingerprint;
+
+    s_deviceId = info.deviceId;
+    s_deviceModel = info.deviceModel;
+    s_deviceName = info.deviceName;
+    s_platform = info.platform;
+    s_osVersion = info.osVersion;
+    s_formFactor = info.formFactor;
+    s_architecture = info.architecture;
+    s_chipName = info.chipName;
+    s_gpuFamily = info.gpuFamily;
+    s_batteryState = info.batteryState;
+    s_deviceType = info.formFactor; // Use formFactor as device_type
+    s_osName = info.osName.empty() ? info.platform : info.osName;
+    s_deviceFingerprint = info.deviceId;
+
+    // Fill out the struct - matches Swift's implementation
+    outInfo->device_id = s_deviceId.c_str();
+    outInfo->device_model = s_deviceModel.c_str();
+    outInfo->device_name = s_deviceName.c_str();
+    outInfo->platform = s_platform.c_str();
+    outInfo->os_version = s_osVersion.c_str();
+    outInfo->form_factor = s_formFactor.c_str();
+    outInfo->architecture = s_architecture.c_str();
+    outInfo->chip_name = s_chipName.c_str();
+    outInfo->total_memory = info.totalMemory;
+    outInfo->available_memory = info.availableMemory;
+    outInfo->has_neural_engine = info.hasNeuralEngine ? RAC_TRUE : RAC_FALSE;
+    outInfo->neural_engine_cores = info.neuralEngineCores;
+    outInfo->gpu_family = s_gpuFamily.c_str();
+    outInfo->battery_level = info.batteryLevel;
+    outInfo->battery_state = s_batteryState.empty() ? nullptr : s_batteryState.c_str();
+    outInfo->is_low_power_mode = info.isLowPowerMode ? RAC_TRUE : RAC_FALSE;
+    outInfo->core_count = info.coreCount;
+    outInfo->performance_cores = info.performanceCores;
+    outInfo->efficiency_cores = info.efficiencyCores;
+    outInfo->device_fingerprint = s_deviceFingerprint.c_str();
+
+    // Legacy fields
+    outInfo->device_type = s_deviceType.c_str();
+    outInfo->os_name = s_osName.c_str();
+    outInfo->processor_count = info.coreCount;
+    outInfo->is_simulator = info.isSimulator ? RAC_TRUE : RAC_FALSE;
+
+    LOGD("Device info populated: model=%s, platform=%s", s_deviceModel.c_str(), s_platform.c_str());
+}
+
+static const char* deviceGetIdCallback(void* userData) {
+    if (!g_deviceCallbacks || !g_deviceCallbacks->getDeviceId) {
+        LOGE("getDeviceId callback not available");
+        return nullptr;
+    }
+
+    static std::string s_deviceId;
+    s_deviceId = g_deviceCallbacks->getDeviceId();
+    return s_deviceId.c_str();
+}
+
+static rac_bool_t deviceIsRegisteredCallback(void* userData) {
+    if (!g_deviceCallbacks || !g_deviceCallbacks->isRegistered) {
+        return RAC_FALSE;
+    }
+    return g_deviceCallbacks->isRegistered() ? RAC_TRUE : RAC_FALSE;
+}
+
+static void deviceSetRegisteredCallback(rac_bool_t registered, void* userData) {
+    if (!g_deviceCallbacks || !g_deviceCallbacks->setRegistered) {
+        LOGE("setRegistered callback not available");
+        return;
+    }
+    g_deviceCallbacks->setRegistered(registered == RAC_TRUE);
+    LOGI("Device registration status set: %s", registered == RAC_TRUE ? "true" : "false");
+}
+
+static rac_result_t deviceHttpPostCallback(
+    const char* endpoint,
+    const char* jsonBody,
+    rac_bool_t requiresAuth,
+    rac_device_http_response_t* outResponse,
+    void* userData
+) {
+    if (!endpoint || !jsonBody || !outResponse) {
+        return RAC_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!g_deviceCallbacks || !g_deviceCallbacks->httpPost) {
+        LOGE("httpPost callback not available");
+        outResponse->result = RAC_ERROR_NOT_SUPPORTED;
+        return RAC_ERROR_NOT_SUPPORTED;
+    }
+
+    LOGI("Making HTTP POST to: %s", endpoint);
+
+    auto [success, statusCode, responseBody, errorMessage] =
+        g_deviceCallbacks->httpPost(endpoint, jsonBody, requiresAuth == RAC_TRUE);
+
+    // Store response strings statically for lifetime
+    static std::string s_responseBody, s_errorMessage;
+    s_responseBody = responseBody;
+    s_errorMessage = errorMessage;
+
+    if (success) {
+        outResponse->result = RAC_SUCCESS;
+        outResponse->status_code = statusCode;
+        outResponse->response_body = s_responseBody.empty() ? nullptr : s_responseBody.c_str();
+        outResponse->error_message = nullptr;
+        LOGI("HTTP POST succeeded with status %d", statusCode);
+        return RAC_SUCCESS;
+    } else {
+        outResponse->result = RAC_ERROR_NETWORK_ERROR;
+        outResponse->status_code = statusCode;
+        outResponse->response_body = nullptr;
+        outResponse->error_message = s_errorMessage.empty() ? nullptr : s_errorMessage.c_str();
+        LOGE("HTTP POST failed: %s", s_errorMessage.c_str());
+        return RAC_ERROR_NETWORK_ERROR;
+    }
+}
+
+// =============================================================================
+// DeviceBridge Implementation
+// =============================================================================
+
+DeviceBridge& DeviceBridge::shared() {
+    static DeviceBridge instance;
+    return instance;
+}
+
+void DeviceBridge::setPlatformCallbacks(const DevicePlatformCallbacks& callbacks) {
+    platformCallbacks_ = callbacks;
+
+    // Store in global for C callbacks
+    static DevicePlatformCallbacks storedCallbacks;
+    storedCallbacks = callbacks;
+    g_deviceCallbacks = &storedCallbacks;
+
+    LOGI("Device platform callbacks set");
+}
+
+rac_result_t DeviceBridge::registerCallbacks() {
+    if (callbacksRegistered_) {
+        LOGD("Device callbacks already registered");
+        return RAC_SUCCESS;
+    }
+
+    // Reset callbacks struct
+    memset(&racCallbacks_, 0, sizeof(racCallbacks_));
+
+    // Set callback function pointers
+    racCallbacks_.get_device_info = deviceGetInfoCallback;
+    racCallbacks_.get_device_id = deviceGetIdCallback;
+    racCallbacks_.is_registered = deviceIsRegisteredCallback;
+    racCallbacks_.set_registered = deviceSetRegisteredCallback;
+    racCallbacks_.http_post = deviceHttpPostCallback;
+    racCallbacks_.user_data = nullptr;
+
+    // Register with RACommons
+    rac_result_t result = rac_device_manager_set_callbacks(&racCallbacks_);
+
+    if (result == RAC_SUCCESS) {
+        callbacksRegistered_ = true;
+        LOGI("Device manager callbacks registered with RACommons");
+    } else {
+        LOGE("Failed to register device manager callbacks: %d", result);
+    }
+
+    return result;
+}
+
+rac_result_t DeviceBridge::registerIfNeeded(rac_environment_t environment, const std::string& buildToken) {
+    if (!callbacksRegistered_) {
+        LOGE("Device callbacks not registered - call registerCallbacks() first");
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+
+    LOGI("Registering device if needed (env=%d)...", static_cast<int>(environment));
+
+    const char* tokenPtr = buildToken.empty() ? nullptr : buildToken.c_str();
+    rac_result_t result = rac_device_manager_register_if_needed(environment, tokenPtr);
+
+    if (result == RAC_SUCCESS) {
+        LOGI("Device registration completed successfully");
+    } else {
+        LOGE("Device registration failed: %d", result);
+    }
+
+    return result;
+}
+
+bool DeviceBridge::isRegistered() const {
+    return rac_device_manager_is_registered() == RAC_TRUE;
+}
+
+void DeviceBridge::clearRegistration() {
+    rac_device_manager_clear_registration();
+    LOGI("Device registration cleared");
+}
+
+std::string DeviceBridge::getDeviceId() const {
+    const char* id = rac_device_manager_get_device_id();
+    return id ? std::string(id) : "";
+}
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/DeviceBridge.hpp

@@ -0,0 +1,155 @@
+/**
+ * @file DeviceBridge.hpp
+ * @brief C++ bridge for device operations.
+ *
+ * Mirrors Swift's CppBridge+Device.swift pattern.
+ * Registers callbacks with rac_device_manager and delegates to platform.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Foundation/Bridge/Extensions/CppBridge+Device.swift
+ */
+
+#pragma once
+
+#include <string>
+#include <functional>
+
+#include "rac_types.h"
+#include "rac_device_manager.h"
+#include "rac_environment.h"
+
+namespace runanywhere {
+namespace bridges {
+
+/**
+ * Device info structure
+ */
+struct DeviceInfo {
+    std::string deviceId;
+    std::string deviceModel;
+    std::string deviceName;
+    std::string platform;
+    std::string osName;
+    std::string osVersion;
+    std::string formFactor;
+    std::string architecture;
+    std::string chipName;
+    int64_t totalMemory = 0;
+    int64_t availableMemory = 0;
+    bool hasNeuralEngine = false;
+    int32_t neuralEngineCores = 0;
+    std::string gpuFamily;
+    float batteryLevel = -1.0f;
+    std::string batteryState;
+    bool isLowPowerMode = false;
+    int32_t coreCount = 0;
+    int32_t performanceCores = 0;
+    int32_t efficiencyCores = 0;
+    bool isSimulator = false;
+    std::string sdkVersion;
+};
+
+/**
+ * Device registration result
+ */
+struct DeviceRegistrationResult {
+    bool success = false;
+    std::string deviceId;
+    std::string error;
+};
+
+/**
+ * Platform callbacks for device operations
+ */
+struct DevicePlatformCallbacks {
+    // Get device hardware/OS info
+    std::function<DeviceInfo()> getDeviceInfo;
+
+    // Get persistent device ID (from keychain/keystore)
+    std::function<std::string()> getDeviceId;
+
+    // Check if device is registered (from UserDefaults/SharedPrefs)
+    std::function<bool()> isRegistered;
+
+    // Set registration status
+    std::function<void(bool)> setRegistered;
+
+    // Make HTTP POST for device registration
+    // Returns: (success, statusCode, responseBody, errorMessage)
+    std::function<std::tuple<bool, int, std::string, std::string>(
+        const std::string& endpoint,
+        const std::string& jsonBody,
+        bool requiresAuth
+    )> httpPost;
+};
+
+/**
+ * DeviceBridge - Device registration and info via rac_device_manager_* API
+ *
+ * Mirrors Swift's CppBridge.Device pattern:
+ * - Platform provides callbacks
+ * - C++ handles business logic via RACommons
+ */
+class DeviceBridge {
+public:
+    /**
+     * Get shared instance
+     */
+    static DeviceBridge& shared();
+
+    /**
+     * Set platform callbacks
+     * Must be called during SDK initialization BEFORE registerCallbacks()
+     */
+    void setPlatformCallbacks(const DevicePlatformCallbacks& callbacks);
+
+    /**
+     * Register callbacks with RACommons device manager
+     * Must be called during SDK initialization after setPlatformCallbacks()
+     */
+    rac_result_t registerCallbacks();
+
+    /**
+     * Register device with backend if not already registered
+     * Delegates to rac_device_manager_register_if_needed()
+     *
+     * @param environment SDK environment
+     * @param buildToken Optional build token for development mode
+     * @return RAC_SUCCESS if registered or already registered
+     */
+    rac_result_t registerIfNeeded(rac_environment_t environment, const std::string& buildToken = "");
+
+    /**
+     * Check if device is registered
+     */
+    bool isRegistered() const;
+
+    /**
+     * Clear device registration status
+     */
+    void clearRegistration();
+
+    /**
+     * Get the device ID
+     */
+    std::string getDeviceId() const;
+
+    /**
+     * Check if callbacks are registered
+     */
+    bool isCallbacksRegistered() const { return callbacksRegistered_; }
+
+private:
+    DeviceBridge() = default;
+    ~DeviceBridge() = default;
+    DeviceBridge(const DeviceBridge&) = delete;
+    DeviceBridge& operator=(const DeviceBridge&) = delete;
+
+    bool callbacksRegistered_ = false;
+    DevicePlatformCallbacks platformCallbacks_{};
+
+    // Callbacks struct for RACommons (must persist)
+    rac_device_callbacks_t racCallbacks_{};
+};
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/DownloadBridge.cpp

@@ -0,0 +1,299 @@
+/**
+ * @file DownloadBridge.cpp
+ * @brief C++ bridge for download operations.
+ *
+ * Mirrors Swift's CppBridge+Download.swift pattern.
+ */
+
+#include "DownloadBridge.hpp"
+#include <cstdlib>
+#include <cstring>
+
+// Platform-specific logging
+#if defined(ANDROID) || defined(__ANDROID__)
+#include <android/log.h>
+#define LOG_TAG "DownloadBridge"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+#include <cstdio>
+#define LOGI(...) printf("[DownloadBridge] "); printf(__VA_ARGS__); printf("\n")
+#define LOGD(...) printf("[DownloadBridge DEBUG] "); printf(__VA_ARGS__); printf("\n")
+#define LOGE(...) printf("[DownloadBridge ERROR] "); printf(__VA_ARGS__); printf("\n")
+#endif
+
+namespace runanywhere {
+namespace bridges {
+
+DownloadBridge& DownloadBridge::shared() {
+    static DownloadBridge instance;
+    return instance;
+}
+
+DownloadBridge::~DownloadBridge() {
+    shutdown();
+}
+
+rac_result_t DownloadBridge::initialize(const DownloadConfig* config) {
+    if (handle_) {
+        LOGD("Download manager already initialized");
+        return RAC_SUCCESS;
+    }
+
+    // Setup config if provided
+    const rac_download_config_t* racConfig = nullptr;
+    rac_download_config_t configStruct = RAC_DOWNLOAD_CONFIG_DEFAULT;
+
+    if (config) {
+        configStruct.max_concurrent_downloads = config->maxConcurrentDownloads;
+        configStruct.request_timeout_seconds = config->requestTimeoutSeconds;
+        configStruct.max_retry_attempts = config->maxRetryAttempts;
+        configStruct.retry_delay_seconds = config->retryDelaySeconds;
+        configStruct.allow_cellular = config->allowCellular ? RAC_TRUE : RAC_FALSE;
+        configStruct.allow_constrained_network = config->allowConstrainedNetwork ? RAC_TRUE : RAC_FALSE;
+        racConfig = &configStruct;
+    }
+
+    // Create manager
+    rac_result_t result = rac_download_manager_create(racConfig, &handle_);
+
+    if (result == RAC_SUCCESS) {
+        LOGI("Download manager created successfully");
+    } else {
+        LOGE("Failed to create download manager: %d", result);
+        handle_ = nullptr;
+    }
+
+    return result;
+}
+
+void DownloadBridge::shutdown() {
+    if (handle_) {
+        rac_download_manager_destroy(handle_);
+        handle_ = nullptr;
+        progressCallbacks_.clear();
+        LOGI("Download manager destroyed");
+    }
+}
+
+std::string DownloadBridge::startDownload(
+    const std::string& modelId,
+    const std::string& url,
+    const std::string& destinationPath,
+    bool requiresExtraction,
+    std::function<void(const DownloadProgress&)> progressHandler
+) {
+    if (!handle_) {
+        LOGE("Download manager not initialized");
+        return "";
+    }
+
+    char* taskIdPtr = nullptr;
+
+    rac_result_t result = rac_download_manager_start(
+        handle_,
+        modelId.c_str(),
+        url.c_str(),
+        destinationPath.c_str(),
+        requiresExtraction ? RAC_TRUE : RAC_FALSE,
+        nullptr,  // Progress callback - we poll instead
+        nullptr,  // Complete callback - we poll instead
+        nullptr,  // User data
+        &taskIdPtr
+    );
+
+    if (result != RAC_SUCCESS || !taskIdPtr) {
+        LOGE("Failed to start download: %d", result);
+        return "";
+    }
+
+    std::string taskId(taskIdPtr);
+    free(taskIdPtr);
+
+    // Store progress callback
+    if (progressHandler) {
+        progressCallbacks_[taskId] = progressHandler;
+    }
+
+    LOGI("Started download task: %s for model: %s", taskId.c_str(), modelId.c_str());
+    return taskId;
+}
+
+rac_result_t DownloadBridge::cancelDownload(const std::string& taskId) {
+    if (!handle_) {
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+
+    rac_result_t result = rac_download_manager_cancel(handle_, taskId.c_str());
+
+    if (result == RAC_SUCCESS) {
+        progressCallbacks_.erase(taskId);
+        LOGI("Cancelled download task: %s", taskId.c_str());
+    } else {
+        LOGE("Failed to cancel download %s: %d", taskId.c_str(), result);
+    }
+
+    return result;
+}
+
+rac_result_t DownloadBridge::pauseAll() {
+    if (!handle_) {
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+
+    rac_result_t result = rac_download_manager_pause_all(handle_);
+
+    if (result == RAC_SUCCESS) {
+        LOGI("Paused all downloads");
+    } else {
+        LOGE("Failed to pause downloads: %d", result);
+    }
+
+    return result;
+}
+
+rac_result_t DownloadBridge::resumeAll() {
+    if (!handle_) {
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+
+    rac_result_t result = rac_download_manager_resume_all(handle_);
+
+    if (result == RAC_SUCCESS) {
+        LOGI("Resumed all downloads");
+    } else {
+        LOGE("Failed to resume downloads: %d", result);
+    }
+
+    return result;
+}
+
+DownloadProgress DownloadBridge::fromRac(const rac_download_progress_t& cProgress) {
+    DownloadProgress progress;
+    progress.stage = static_cast<DownloadStage>(cProgress.stage);
+    progress.bytesDownloaded = cProgress.bytes_downloaded;
+    progress.totalBytes = cProgress.total_bytes;
+    progress.stageProgress = cProgress.stage_progress;
+    progress.overallProgress = cProgress.overall_progress;
+    progress.state = static_cast<DownloadState>(cProgress.state);
+    progress.speed = cProgress.speed;
+    progress.estimatedTimeRemaining = cProgress.estimated_time_remaining;
+    progress.retryAttempt = cProgress.retry_attempt;
+    progress.errorCode = cProgress.error_code;
+    progress.errorMessage = cProgress.error_message ? cProgress.error_message : "";
+    return progress;
+}
+
+std::optional<DownloadProgress> DownloadBridge::getProgress(const std::string& taskId) {
+    if (!handle_) {
+        return std::nullopt;
+    }
+
+    rac_download_progress_t cProgress = RAC_DOWNLOAD_PROGRESS_DEFAULT;
+    rac_result_t result = rac_download_manager_get_progress(handle_, taskId.c_str(), &cProgress);
+
+    if (result != RAC_SUCCESS) {
+        return std::nullopt;
+    }
+
+    return fromRac(cProgress);
+}
+
+std::vector<std::string> DownloadBridge::getActiveTasks() {
+    std::vector<std::string> tasks;
+
+    if (!handle_) {
+        return tasks;
+    }
+
+    char** taskIdsPtr = nullptr;
+    size_t count = 0;
+
+    rac_result_t result = rac_download_manager_get_active_tasks(handle_, &taskIdsPtr, &count);
+
+    if (result != RAC_SUCCESS || !taskIdsPtr) {
+        return tasks;
+    }
+
+    for (size_t i = 0; i < count; i++) {
+        if (taskIdsPtr[i]) {
+            tasks.push_back(taskIdsPtr[i]);
+        }
+    }
+
+    rac_download_task_ids_free(taskIdsPtr, count);
+
+    return tasks;
+}
+
+bool DownloadBridge::isHealthy() {
+    if (!handle_) {
+        return false;
+    }
+
+    rac_bool_t healthy = RAC_FALSE;
+    rac_result_t result = rac_download_manager_is_healthy(handle_, &healthy);
+
+    return result == RAC_SUCCESS && healthy == RAC_TRUE;
+}
+
+void DownloadBridge::updateProgress(const std::string& taskId, int64_t bytesDownloaded, int64_t totalBytes) {
+    if (!handle_) {
+        return;
+    }
+
+    rac_download_manager_update_progress(handle_, taskId.c_str(), bytesDownloaded, totalBytes);
+
+    // Notify callback
+    auto it = progressCallbacks_.find(taskId);
+    if (it != progressCallbacks_.end()) {
+        auto progress = getProgress(taskId);
+        if (progress) {
+            it->second(*progress);
+        }
+    }
+}
+
+void DownloadBridge::markComplete(const std::string& taskId, const std::string& downloadedPath) {
+    if (!handle_) {
+        return;
+    }
+
+    rac_download_manager_mark_complete(handle_, taskId.c_str(), downloadedPath.c_str());
+
+    // Notify final progress
+    auto it = progressCallbacks_.find(taskId);
+    if (it != progressCallbacks_.end()) {
+        auto progress = getProgress(taskId);
+        if (progress) {
+            it->second(*progress);
+        }
+        progressCallbacks_.erase(it);
+    }
+
+    LOGI("Download completed: %s", taskId.c_str());
+}
+
+void DownloadBridge::markFailed(const std::string& taskId, rac_result_t errorCode, const std::string& errorMessage) {
+    if (!handle_) {
+        return;
+    }
+
+    rac_download_manager_mark_failed(handle_, taskId.c_str(), errorCode, errorMessage.c_str());
+
+    // Notify final progress
+    auto it = progressCallbacks_.find(taskId);
+    if (it != progressCallbacks_.end()) {
+        auto progress = getProgress(taskId);
+        if (progress) {
+            it->second(*progress);
+        }
+        progressCallbacks_.erase(it);
+    }
+
+    LOGE("Download failed: %s - %s", taskId.c_str(), errorMessage.c_str());
+}
+
+} // namespace bridges
+} // namespace runanywhere