@runanywhere/core 0.16.0

package/cpp/bridges/DownloadBridge.hpp

@@ -0,0 +1,197 @@
+/**
+ * @file DownloadBridge.hpp
+ * @brief C++ bridge for download operations.
+ *
+ * Mirrors Swift's CppBridge+Download.swift pattern:
+ * - Handle-based API via rac_download_manager_*
+ * - Platform provides HTTP download implementation
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Foundation/Bridge/Extensions/CppBridge+Download.swift
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <unordered_map>
+#include <cstdint>
+
+#include "rac_types.h"
+#include "rac_download.h"
+
+namespace runanywhere {
+namespace bridges {
+
+/**
+ * Download stage enum matching RAC
+ */
+enum class DownloadStage {
+    Downloading = 0,
+    Extracting = 1,
+    Validating = 2,
+    Completed = 3
+};
+
+/**
+ * Download state enum matching RAC
+ */
+enum class DownloadState {
+    Pending = 0,
+    Downloading = 1,
+    Extracting = 2,
+    Retrying = 3,
+    Completed = 4,
+    Failed = 5,
+    Cancelled = 6
+};
+
+/**
+ * Download progress info
+ */
+struct DownloadProgress {
+    DownloadStage stage = DownloadStage::Downloading;
+    int64_t bytesDownloaded = 0;
+    int64_t totalBytes = 0;
+    double stageProgress = 0.0;
+    double overallProgress = 0.0;
+    DownloadState state = DownloadState::Pending;
+    double speed = 0.0;  // bytes per second
+    double estimatedTimeRemaining = -1.0;  // seconds
+    int32_t retryAttempt = 0;
+    rac_result_t errorCode = RAC_SUCCESS;
+    std::string errorMessage;
+};
+
+/**
+ * Download configuration
+ */
+struct DownloadConfig {
+    int32_t maxConcurrentDownloads = 1;
+    int32_t requestTimeoutSeconds = 60;
+    int32_t maxRetryAttempts = 3;
+    int32_t retryDelaySeconds = 5;
+    bool allowCellular = true;
+    bool allowConstrainedNetwork = false;
+};
+
+/**
+ * DownloadBridge - Download orchestration via rac_download_manager_* API
+ *
+ * Mirrors Swift's CppBridge.Download pattern:
+ * - Handle-based API
+ * - Progress callbacks stored and invoked
+ * - Platform provides actual HTTP downloads
+ */
+class DownloadBridge {
+public:
+    /**
+     * Get shared instance
+     */
+    static DownloadBridge& shared();
+
+    /**
+     * Initialize the download manager
+     * @param config Optional configuration
+     */
+    rac_result_t initialize(const DownloadConfig* config = nullptr);
+
+    /**
+     * Shutdown and cleanup
+     */
+    void shutdown();
+
+    /**
+     * Check if initialized
+     */
+    bool isInitialized() const { return handle_ != nullptr; }
+
+    // =========================================================================
+    // Download Operations
+    // =========================================================================
+
+    /**
+     * Start a download task
+     *
+     * @param modelId Model identifier
+     * @param url Download URL
+     * @param destinationPath Where to save the file
+     * @param requiresExtraction Whether to extract archive after download
+     * @param progressHandler Callback for progress updates
+     * @return Task ID for tracking, empty on error
+     */
+    std::string startDownload(
+        const std::string& modelId,
+        const std::string& url,
+        const std::string& destinationPath,
+        bool requiresExtraction,
+        std::function<void(const DownloadProgress&)> progressHandler
+    );
+
+    /**
+     * Cancel a download task
+     */
+    rac_result_t cancelDownload(const std::string& taskId);
+
+    /**
+     * Pause all active downloads
+     */
+    rac_result_t pauseAll();
+
+    /**
+     * Resume all paused downloads
+     */
+    rac_result_t resumeAll();
+
+    // =========================================================================
+    // Progress Tracking
+    // =========================================================================
+
+    /**
+     * Get progress for a task
+     */
+    std::optional<DownloadProgress> getProgress(const std::string& taskId);
+
+    /**
+     * Get list of active task IDs
+     */
+    std::vector<std::string> getActiveTasks();
+
+    /**
+     * Check if download service is healthy
+     */
+    bool isHealthy();
+
+    // =========================================================================
+    // Progress Updates (called by platform HTTP layer)
+    // =========================================================================
+
+    /**
+     * Update download progress (called by platform)
+     */
+    void updateProgress(const std::string& taskId, int64_t bytesDownloaded, int64_t totalBytes);
+
+    /**
+     * Mark download as complete (called by platform)
+     */
+    void markComplete(const std::string& taskId, const std::string& downloadedPath);
+
+    /**
+     * Mark download as failed (called by platform)
+     */
+    void markFailed(const std::string& taskId, rac_result_t errorCode, const std::string& errorMessage);
+
+private:
+    DownloadBridge() = default;
+    ~DownloadBridge();
+    DownloadBridge(const DownloadBridge&) = delete;
+    DownloadBridge& operator=(const DownloadBridge&) = delete;
+
+    static DownloadProgress fromRac(const rac_download_progress_t& cProgress);
+
+    rac_download_manager_handle_t handle_ = nullptr;
+    std::unordered_map<std::string, std::function<void(const DownloadProgress&)>> progressCallbacks_;
+};
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/EventBridge.cpp

@@ -0,0 +1,125 @@
+/**
+ * @file EventBridge.cpp
+ * @brief C++ bridge for event operations.
+ *
+ * Simplified event bridge that manages event callbacks locally.
+ * Does not depend on RACommons event functions (which may not be exported).
+ */
+
+#include "EventBridge.hpp"
+#include <chrono>
+
+// Platform-specific logging
+#if defined(ANDROID) || defined(__ANDROID__)
+#include <android/log.h>
+#define LOG_TAG "EventBridge"
+#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("[EventBridge] "); printf(__VA_ARGS__); printf("\n")
+#define LOGD(...) printf("[EventBridge DEBUG] "); printf(__VA_ARGS__); printf("\n")
+#define LOGE(...) printf("[EventBridge ERROR] "); printf(__VA_ARGS__); printf("\n")
+#endif
+
+namespace runanywhere {
+namespace bridges {
+
+// =============================================================================
+// EventBridge Implementation
+// =============================================================================
+
+EventBridge& EventBridge::shared() {
+    static EventBridge instance;
+    return instance;
+}
+
+EventBridge::~EventBridge() {
+    unregisterFromEvents();
+}
+
+void EventBridge::setEventCallback(EventCallback callback) {
+    eventCallback_ = callback;
+    LOGI("Event callback registered");
+}
+
+void EventBridge::registerForEvents() {
+    if (isRegistered_) {
+        LOGD("Already registered for events");
+        return;
+    }
+
+    isRegistered_ = true;
+    LOGI("Event registration enabled");
+}
+
+void EventBridge::unregisterFromEvents() {
+    if (!isRegistered_) {
+        return;
+    }
+
+    isRegistered_ = false;
+    LOGI("Event registration disabled");
+}
+
+rac_result_t EventBridge::trackEvent(
+    const std::string& type,
+    EventCategory category,
+    EventDestination destination,
+    const std::string& propertiesJson
+) {
+    LOGD("trackEvent: type=%s category=%d", type.c_str(), static_cast<int>(category));
+
+    // If we have a callback registered, forward the event
+    if (eventCallback_) {
+        SDKEvent event;
+        auto now = std::chrono::system_clock::now();
+        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(
+            now.time_since_epoch()).count();
+
+        event.id = std::to_string(millis);
+        event.type = type;
+        event.category = category;
+        event.timestampMs = millis;
+        event.destination = destination;
+        event.propertiesJson = propertiesJson;
+
+        eventCallback_(event);
+    }
+
+    return RAC_SUCCESS;
+}
+
+rac_result_t EventBridge::publishEvent(const SDKEvent& event) {
+    LOGD("publishEvent: type=%s", event.type.c_str());
+
+    // If we have a callback registered, forward the event
+    if (eventCallback_) {
+        eventCallback_(event);
+    }
+
+    return RAC_SUCCESS;
+}
+
+std::string EventBridge::getCategoryName(EventCategory category) {
+    switch (category) {
+        case EventCategory::SDK: return "sdk";
+        case EventCategory::Model: return "model";
+        case EventCategory::LLM: return "llm";
+        case EventCategory::STT: return "stt";
+        case EventCategory::TTS: return "tts";
+        case EventCategory::Voice: return "voice";
+        case EventCategory::Storage: return "storage";
+        case EventCategory::Device: return "device";
+        case EventCategory::Network: return "network";
+        case EventCategory::Error: return "error";
+        case EventCategory::Analytics: return "analytics";
+        case EventCategory::Performance: return "performance";
+        case EventCategory::User: return "user";
+        default: return "unknown";
+    }
+}
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/EventBridge.hpp

@@ -0,0 +1,139 @@
+/**
+ * @file EventBridge.hpp
+ * @brief C++ bridge for event operations.
+ *
+ * Mirrors Swift's event handling pattern:
+ * - Subscribe to events via rac_event_subscribe()
+ * - Forward events to JS layer
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Infrastructure/Events/
+ */
+
+#pragma once
+
+#include <string>
+#include <functional>
+#include <vector>
+#include <cstdint>
+
+#include "rac_types.h"
+
+namespace runanywhere {
+namespace bridges {
+
+/**
+ * Event category enum matching RAC
+ */
+enum class EventCategory {
+    SDK = 0,
+    Model = 1,
+    LLM = 2,
+    STT = 3,
+    TTS = 4,
+    Voice = 5,
+    Storage = 6,
+    Device = 7,
+    Network = 8,
+    Error = 9,
+    Analytics = 10,
+    Performance = 11,
+    User = 12
+};
+
+/**
+ * Event destination enum matching RAC
+ */
+enum class EventDestination {
+    PublicOnly = 0,
+    AnalyticsOnly = 1,
+    All = 2
+};
+
+/**
+ * Event data structure
+ */
+struct SDKEvent {
+    std::string id;
+    std::string type;
+    EventCategory category = EventCategory::SDK;
+    int64_t timestampMs = 0;
+    std::string sessionId;
+    EventDestination destination = EventDestination::All;
+    std::string propertiesJson;
+};
+
+/**
+ * Event callback type
+ */
+using EventCallback = std::function<void(const SDKEvent&)>;
+
+/**
+ * EventBridge - Event subscription and publishing
+ *
+ * Mirrors Swift's EventBridge pattern:
+ * - Subscribe to C++ events
+ * - Forward to JS layer
+ * - Track events via rac_event_track()
+ */
+class EventBridge {
+public:
+    /**
+     * Get shared instance
+     */
+    static EventBridge& shared();
+
+    /**
+     * Register event callback for JS layer
+     * Events will be forwarded to this callback
+     */
+    void setEventCallback(EventCallback callback);
+
+    /**
+     * Register with RACommons to receive events
+     * Must be called during SDK initialization
+     */
+    void registerForEvents();
+
+    /**
+     * Unregister from RACommons events
+     */
+    void unregisterFromEvents();
+
+    /**
+     * Track an event
+     *
+     * @param type Event type string
+     * @param category Event category
+     * @param destination Where to route this event
+     * @param propertiesJson Event properties as JSON
+     */
+    rac_result_t trackEvent(
+        const std::string& type,
+        EventCategory category,
+        EventDestination destination,
+        const std::string& propertiesJson
+    );
+
+    /**
+     * Publish an event
+     */
+    rac_result_t publishEvent(const SDKEvent& event);
+
+    /**
+     * Get category name
+     */
+    static std::string getCategoryName(EventCategory category);
+
+private:
+    EventBridge() = default;
+    ~EventBridge();
+    EventBridge(const EventBridge&) = delete;
+    EventBridge& operator=(const EventBridge&) = delete;
+
+    EventCallback eventCallback_;
+    uint64_t subscriptionId_ = 0;
+    bool isRegistered_ = false;
+};
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/HTTPBridge.cpp

@@ -0,0 +1,96 @@
+/**
+ * @file HTTPBridge.cpp
+ * @brief HTTP bridge implementation
+ *
+ * NOTE: HTTP is handled by the JS layer. This bridge manages configuration.
+ */
+
+#include "HTTPBridge.hpp"
+
+// Platform-specific logging
+#if defined(ANDROID) || defined(__ANDROID__)
+#include <android/log.h>
+#define LOG_TAG "HTTPBridge"
+#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("[HTTPBridge] "); printf(__VA_ARGS__); printf("\n")
+#define LOGD(...) printf("[HTTPBridge DEBUG] "); printf(__VA_ARGS__); printf("\n")
+#define LOGE(...) printf("[HTTPBridge ERROR] "); printf(__VA_ARGS__); printf("\n")
+#endif
+
+namespace runanywhere {
+namespace bridges {
+
+HTTPBridge& HTTPBridge::shared() {
+    static HTTPBridge instance;
+    return instance;
+}
+
+void HTTPBridge::configure(const std::string& baseURL, const std::string& apiKey) {
+    baseURL_ = baseURL;
+    apiKey_ = apiKey;
+    configured_ = true;
+
+    LOGI("HTTP configured: baseURL=%s", baseURL.c_str());
+}
+
+void HTTPBridge::setAuthorizationToken(const std::string& token) {
+    authToken_ = token;
+    LOGD("Authorization token set");
+}
+
+std::optional<std::string> HTTPBridge::getAuthorizationToken() const {
+    return authToken_;
+}
+
+void HTTPBridge::clearAuthorizationToken() {
+    authToken_.reset();
+    LOGD("Authorization token cleared");
+}
+
+void HTTPBridge::setHTTPExecutor(HTTPExecutor executor) {
+    executor_ = executor;
+    LOGI("HTTP executor registered");
+}
+
+std::optional<HTTPResponse> HTTPBridge::execute(
+    const std::string& method,
+    const std::string& endpoint,
+    const std::string& body,
+    bool requiresAuth
+) {
+    if (!executor_) {
+        LOGE("No HTTP executor registered - HTTP requests must go through JS layer");
+        return std::nullopt;
+    }
+
+    std::string url = buildURL(endpoint);
+    LOGD("Executing %s %s", method.c_str(), url.c_str());
+
+    return executor_(method, url, body, requiresAuth);
+}
+
+std::string HTTPBridge::buildURL(const std::string& endpoint) const {
+    if (baseURL_.empty()) {
+        return endpoint;
+    }
+
+    // Ensure proper URL joining
+    std::string url = baseURL_;
+    if (!url.empty() && url.back() == '/') {
+        url.pop_back();
+    }
+
+    if (!endpoint.empty() && endpoint.front() != '/') {
+        url += '/';
+    }
+
+    url += endpoint;
+    return url;
+}
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/HTTPBridge.hpp

@@ -0,0 +1,144 @@
+/**
+ * @file HTTPBridge.hpp
+ * @brief HTTP bridge documentation
+ *
+ * NOTE: HTTP is handled entirely by the JavaScript/platform layer.
+ *
+ * In Swift, HTTPService.swift handles all HTTP requests.
+ * In React Native, the JS layer (HTTPService.ts) handles HTTP.
+ *
+ * C++ does NOT make HTTP requests directly. Instead:
+ * 1. C++ provides JSON building functions (rac_auth_request_to_json, etc.)
+ * 2. JS layer makes the HTTP request
+ * 3. C++ parses the response (rac_auth_response_from_json, etc.)
+ * 4. C++ stores state (rac_state_set_auth, etc.)
+ *
+ * This bridge provides:
+ * - Configuration storage (base URL, API key)
+ * - Authorization header management
+ * - HTTP executor registration (for C++ components that need to make requests)
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Foundation/Bridge/Extensions/CppBridge+HTTP.swift
+ */
+
+#pragma once
+
+#include <string>
+#include <functional>
+#include <optional>
+
+#include "rac_types.h"
+#include "rac_http_client.h"
+
+namespace runanywhere {
+namespace bridges {
+
+/**
+ * HTTP response
+ */
+struct HTTPResponse {
+    int32_t statusCode = 0;
+    std::string body;
+    std::string error;
+    bool success = false;
+};
+
+/**
+ * HTTP executor callback type
+ * Platform provides this to handle HTTP requests
+ */
+using HTTPExecutor = std::function<HTTPResponse(
+    const std::string& method,
+    const std::string& url,
+    const std::string& body,
+    bool requiresAuth
+)>;
+
+/**
+ * HTTPBridge - HTTP configuration and executor registration
+ *
+ * NOTE: Actual HTTP requests are made by the JS layer, not C++.
+ * This bridge handles configuration and provides an executor for
+ * C++ components that need HTTP access.
+ */
+class HTTPBridge {
+public:
+    /**
+     * Get shared instance
+     */
+    static HTTPBridge& shared();
+
+    /**
+     * Configure HTTP with base URL and API key
+     */
+    void configure(const std::string& baseURL, const std::string& apiKey);
+
+    /**
+     * Check if configured
+     */
+    bool isConfigured() const { return configured_; }
+
+    /**
+     * Get base URL
+     */
+    const std::string& getBaseURL() const { return baseURL_; }
+
+    /**
+     * Get API key
+     */
+    const std::string& getAPIKey() const { return apiKey_; }
+
+    /**
+     * Set authorization token
+     */
+    void setAuthorizationToken(const std::string& token);
+
+    /**
+     * Get authorization token
+     */
+    std::optional<std::string> getAuthorizationToken() const;
+
+    /**
+     * Clear authorization token
+     */
+    void clearAuthorizationToken();
+
+    /**
+     * Register HTTP executor (called by platform)
+     *
+     * This allows C++ components to make HTTP requests through the platform.
+     * The platform handles the actual network operations.
+     */
+    void setHTTPExecutor(HTTPExecutor executor);
+
+    /**
+     * Execute HTTP request via registered executor
+     * Returns nullopt if no executor registered
+     */
+    std::optional<HTTPResponse> execute(
+        const std::string& method,
+        const std::string& endpoint,
+        const std::string& body,
+        bool requiresAuth
+    );
+
+    /**
+     * Build full URL from endpoint
+     */
+    std::string buildURL(const std::string& endpoint) const;
+
+private:
+    HTTPBridge() = default;
+    ~HTTPBridge() = default;
+    HTTPBridge(const HTTPBridge&) = delete;
+    HTTPBridge& operator=(const HTTPBridge&) = delete;
+
+    bool configured_ = false;
+    std::string baseURL_;
+    std::string apiKey_;
+    std::optional<std::string> authToken_;
+    HTTPExecutor executor_;
+};
+
+} // namespace bridges
+} // namespace runanywhere