react-native-meshstream 0.0.0-stage → 1.0.2

package/ios/MeshStreamP2P.m

@@ -0,0 +1,362 @@
+#import "MeshStreamP2P.h"
+#import "MeshStreamP2PValidation.h"
+#import <React/RCTBridgeModule.h>
+#import <MeshStreamKit/MeshStreamKit.h>
+
+static NSString * const MeshStreamEventName = @"MeshStreamP2P:event";
+
+static NSString *MeshStreamReasonName(P2PUnavailableReason reason) {
+    switch (reason) {
+        case P2PUnavailableReasonOK: return @"OK";
+        case P2PUnavailableReasonNoPeers: return @"NO_PEERS";
+        case P2PUnavailableReasonTrackerError: return @"TRACKER_ERROR";
+        case P2PUnavailableReasonAuthFailed: return @"AUTH_FAILED";
+        case P2PUnavailableReasonAccountDisabled: return @"ACCOUNT_DISABLED";
+        case P2PUnavailableReasonAppDisabled: return @"APP_DISABLED";
+        case P2PUnavailableReasonAppNotFound: return @"APP_NOT_FOUND";
+        case P2PUnavailableReasonKeyDisabled: return @"KEY_DISABLED";
+        case P2PUnavailableReasonPlatformDisabled: return @"PLATFORM_DISABLED";
+        case P2PUnavailableReasonOriginDenied: return @"ORIGIN_DENIED";
+        case P2PUnavailableReasonPackageDenied: return @"PACKAGE_DENIED";
+        case P2PUnavailableReasonBundleDenied: return @"BUNDLE_DENIED";
+        case P2PUnavailableReasonSigningCertDenied: return @"SIGNING_CERT_DENIED";
+        case P2PUnavailableReasonTeamDenied: return @"TEAM_DENIED";
+        case P2PUnavailableReasonConfigUnavailable: return @"CONFIG_UNAVAILABLE";
+        case P2PUnavailableReasonInitializationFailed: return @"INITIALIZATION_FAILED";
+        case P2PUnavailableReasonUnsupported: return @"UNSUPPORTED";
+        case P2PUnavailableReasonDisabled: return @"DISABLED";
+        case P2PUnavailableReasonKeyP2PDisabled: return @"KEY_P2P_DISABLED";
+        case P2PUnavailableReasonQuotaExhausted: return @"QUOTA_EXHAUSTED";
+        case P2PUnavailableReasonQuotaDisabled: return @"QUOTA_DISABLED";
+    }
+    return @"INITIALIZATION_FAILED";
+}
+
+static NSDictionary *MeshStreamStatusMap(P2PSdkStatus *status) {
+    NSMutableDictionary *result = [@{
+        @"accountEnabled": @(status.accountEnabled),
+        @"applicationEnabled": @(status.applicationEnabled),
+        @"keyEnabled": @(status.keyEnabled),
+        @"platformEnabled": @(status.platformEnabled),
+        @"effectiveP2pEnabled": @(status.effectiveP2PEnabled),
+        @"reason": MeshStreamReasonName(status.reason),
+    } mutableCopy];
+    if (status.configVersion != nil) result[@"configVersion"] = status.configVersion;
+    if (status.edgeRegion != nil) result[@"edgeRegion"] = status.edgeRegion;
+    if (status.quotaStatus != nil) result[@"quotaStatus"] = status.quotaStatus;
+    return result;
+}
+
+static NSDictionary *MeshStreamStatsMap(P2PStats *stats) {
+    double downloadTotal = (double)(stats.httpDownloaded + stats.p2pDownloaded);
+    double segmentDownloadTotal = (double)(stats.p2pSegmentDownloadSuccesses + stats.p2pSegmentDownloadFailures);
+    double segmentUploadTotal = (double)(stats.p2pSegmentUploadSuccesses + stats.p2pSegmentUploadFailures);
+    return @{
+        @"httpDownloaded": @((double)stats.httpDownloaded),
+        @"p2pDownloaded": @((double)stats.p2pDownloaded),
+        @"p2pUploaded": @((double)stats.p2pUploaded),
+        @"httpSegmentDownloadSuccesses": @((double)stats.httpSegmentDownloadSuccesses),
+        @"httpSegmentDownloadFailures": @((double)stats.httpSegmentDownloadFailures),
+        @"p2pSegmentDownloadSuccesses": @((double)stats.p2pSegmentDownloadSuccesses),
+        @"p2pSegmentDownloadFailures": @((double)stats.p2pSegmentDownloadFailures),
+        @"p2pSegmentUploadSuccesses": @((double)stats.p2pSegmentUploadSuccesses),
+        @"p2pSegmentUploadFailures": @((double)stats.p2pSegmentUploadFailures),
+        @"connectedPeers": @(stats.connectedPeers),
+        @"peerConnectErrors": @((double)stats.peerConnectErrors),
+        @"trackerErrors": @((double)stats.trackerErrors),
+        @"downloadOffloadRatio": @(downloadTotal == 0 ? 0 : stats.p2pDownloaded / downloadTotal),
+        @"p2pSegmentDownloadSuccessRatio": @(segmentDownloadTotal == 0 ? 0 : stats.p2pSegmentDownloadSuccesses / segmentDownloadTotal),
+        @"p2pSegmentUploadSuccessRatio": @(segmentUploadTotal == 0 ? 0 : stats.p2pSegmentUploadSuccesses / segmentUploadTotal),
+    };
+}
+
+static NSDictionary *MeshStreamDiagnosticsMap(P2PDiagnostics *diagnostics) {
+    NSMutableDictionary *result = [@{
+        @"fallbackCount": @((double)diagnostics.fallbackCount),
+        @"iceAttempts": @((double)diagnostics.iceAttempts),
+        @"iceSuccesses": @((double)diagnostics.iceSuccesses),
+        @"iceFailures": @((double)diagnostics.iceFailures),
+        @"iceDurationMs": @((double)diagnostics.iceDurationMs),
+    } mutableCopy];
+    if (diagnostics.firstPeerConnectMs > 0) result[@"firstPeerConnectMs"] = @((double)diagnostics.firstPeerConnectMs);
+    if (diagnostics.coldStartP2PDownloaded > 0 || diagnostics.coldStartHTTPDownloaded > 0) {
+        result[@"coldStart"] = @{
+            @"p2pDownloaded": @((double)diagnostics.coldStartP2PDownloaded),
+            @"httpDownloaded": @((double)diagnostics.coldStartHTTPDownloaded),
+        };
+    }
+    if (diagnostics.lastTrackerError != nil) result[@"lastTrackerError"] = diagnostics.lastTrackerError;
+    if (diagnostics.lastPeerError != nil) result[@"lastPeerError"] = diagnostics.lastPeerError;
+    if (diagnostics.lastErrorAtMs > 0) result[@"lastErrorAtMs"] = @((double)diagnostics.lastErrorAtMs);
+    return result;
+}
+
+@interface MeshStreamBridgeClient : NSObject
+@property(nonatomic, strong) P2PClient *client;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, PlaybackSession *> *sessions;
+@end
+
+@implementation MeshStreamBridgeClient
+@end
+
+@interface MeshStreamSessionRoute : NSObject
+@property(nonatomic, copy) NSString *clientId;
+@property(nonatomic, copy) NSString *sessionId;
+@end
+
+@implementation MeshStreamSessionRoute
+@end
+
+@interface MeshStreamP2P () <P2PEventListener>
+@property(nonatomic, strong) NSMutableDictionary<NSString *, MeshStreamBridgeClient *> *clients;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, MeshStreamSessionRoute *> *sessionRoutes;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, NSMutableArray<NSDictionary *> *> *pendingEvents;
+@end
+
+@implementation MeshStreamP2P
+
+RCT_EXPORT_MODULE(MeshStreamP2P)
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+- (instancetype)init {
+    if ((self = [super init])) {
+        _clients = [NSMutableDictionary dictionary];
+        _sessionRoutes = [NSMutableDictionary dictionary];
+        _pendingEvents = [NSMutableDictionary dictionary];
+    }
+    return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents { return @[MeshStreamEventName]; }
+
+RCT_REMAP_METHOD(getSdkVersion,
+                 getSdkVersionWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject) {
+    resolve([P2PSDK getSdkVersion] ?: @"unknown");
+}
+
+RCT_REMAP_METHOD(createClient,
+                 createClientWithConfig:(NSDictionary *)config
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject) {
+    NSString *key = MeshStreamTrimmedString(config[@"key"]) ?: @"";
+    if (key.length == 0) {
+        reject(@"MESHSTREAM_CREATE_CLIENT_FAILED", @"key must not be empty", nil);
+        return;
+    }
+    P2PConfig *nativeConfig = [[P2PConfig alloc] initWithKey:key];
+    if ([config[@"p2pEnabled"] isKindOfClass:NSNumber.class]) nativeConfig.p2pEnabled = [config[@"p2pEnabled"] boolValue];
+    NSError *error = nil;
+    P2PClient *client = [P2PSDK clientWithConfig:nativeConfig error:&error];
+    if (client == nil) {
+        reject(@"MESHSTREAM_CREATE_CLIENT_FAILED", error.localizedDescription ?: @"Unable to create MeshStream client.", error);
+        return;
+    }
+    MeshStreamBridgeClient *bridgeClient = [MeshStreamBridgeClient new];
+    bridgeClient.client = client;
+    bridgeClient.sessions = [NSMutableDictionary dictionary];
+    [client addEventListener:self];
+    NSString *clientId = NSUUID.UUID.UUIDString;
+    @synchronized (self.clients) { self.clients[clientId] = bridgeClient; }
+    resolve(@{ @"clientId": clientId, @"status": MeshStreamStatusMap(client.sdkStatus) });
+}
+
+RCT_EXPORT_METHOD(createPlaybackSession:(NSString *)clientId
+                  options:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    MeshStreamBridgeClient *bridgeClient = [self bridgeClient:clientId];
+    NSURL *url = MeshStreamHTTPURLFromValue(options[@"url"]);
+    if (bridgeClient == nil || url == nil) {
+        reject(@"MESHSTREAM_CREATE_SESSION_FAILED", bridgeClient == nil ? @"Unknown or closed MeshStream client." : @"options.url must be a valid URL.", nil);
+        return;
+    }
+    P2PPlaybackOptions *nativeOptions = [P2PPlaybackOptions new];
+    nativeOptions.contentId = MeshStreamTrimmedString(options[@"contentId"]);
+    nativeOptions.mimeType = MeshStreamTrimmedString(options[@"mimeType"]);
+    nativeOptions.originHeaders = MeshStreamStringHeaders(options[@"originHeaders"]);
+    NSError *error = nil;
+    PlaybackSession *session = [bridgeClient.client createPlaybackSessionWithURL:url options:nativeOptions error:&error];
+    if (session == nil) {
+        reject(@"MESHSTREAM_CREATE_SESSION_FAILED", error.localizedDescription ?: @"Unable to create MeshStream playback session.", error);
+        return;
+    }
+    NSString *sessionId = NSUUID.UUID.UUIDString;
+    @synchronized (bridgeClient.sessions) { bridgeClient.sessions[sessionId] = session; }
+    MeshStreamSessionRoute *route = [MeshStreamSessionRoute new];
+    route.clientId = clientId;
+    route.sessionId = sessionId;
+    @synchronized (self.sessionRoutes) { self.sessionRoutes[session.sessionId] = route; }
+    [self flushPendingEventsForNativeSessionId:session.sessionId clientId:clientId sessionId:sessionId];
+    NSMutableDictionary *result = [@{
+        @"clientId": clientId,
+        @"sessionId": sessionId,
+        @"playbackUrl": session.playbackUrl.absoluteString,
+        @"playbackMode": session.playbackMode == P2PPlaybackModeNativeP2P ? @"NATIVE_P2P" : @"NATIVE_CDN",
+    } mutableCopy];
+    if (session.playbackMode == P2PPlaybackModeNativeCDN) result[@"fallbackReason"] = MeshStreamReasonName(session.fallbackReason);
+    resolve(result);
+}
+
+RCT_EXPORT_METHOD(preload:(NSString *)clientId sessionId:(NSString *)sessionId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    PlaybackSession *session = [self sessionForClient:clientId sessionId:sessionId reject:reject];
+    if (session != nil) resolve(@([session preload]));
+}
+
+RCT_EXPORT_METHOD(setP2pEnabled:(NSString *)clientId sessionId:(NSString *)sessionId enabled:(BOOL)enabled resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    PlaybackSession *session = [self sessionForClient:clientId sessionId:sessionId reject:reject];
+    if (session != nil) { [session setP2PEnabled:enabled]; resolve(nil); }
+}
+
+RCT_EXPORT_METHOD(updateBufferedDurationMs:(NSString *)clientId sessionId:(NSString *)sessionId durationMs:(double)durationMs resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    PlaybackSession *session = [self sessionForClient:clientId sessionId:sessionId reject:reject];
+    if (session != nil) { [session updateBufferedDurationMs:(int64_t)MAX(0, durationMs)]; resolve(nil); }
+}
+
+RCT_EXPORT_METHOD(updateCurrentPositionMs:(NSString *)clientId sessionId:(NSString *)sessionId positionMs:(double)positionMs resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    PlaybackSession *session = [self sessionForClient:clientId sessionId:sessionId reject:reject];
+    if (session != nil) { [session updateCurrentPositionMs:(int64_t)MAX(0, positionMs)]; resolve(nil); }
+}
+
+RCT_EXPORT_METHOD(getStats:(NSString *)clientId sessionId:(NSString *)sessionId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    PlaybackSession *session = [self sessionForClient:clientId sessionId:sessionId reject:reject];
+    if (session != nil) resolve(MeshStreamStatsMap(session.statistics));
+}
+
+RCT_EXPORT_METHOD(getDiagnostics:(NSString *)clientId sessionId:(NSString *)sessionId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    PlaybackSession *session = [self sessionForClient:clientId sessionId:sessionId reject:reject];
+    if (session != nil) resolve(MeshStreamDiagnosticsMap(session.diagnostics));
+}
+
+RCT_EXPORT_METHOD(getStatus:(NSString *)clientId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    MeshStreamBridgeClient *bridgeClient = [self bridgeClient:clientId];
+    if (bridgeClient == nil) { reject(@"MESHSTREAM_STATUS_FAILED", @"Unknown or closed MeshStream client.", nil); return; }
+    resolve(MeshStreamStatusMap(bridgeClient.client.sdkStatus));
+}
+
+RCT_EXPORT_METHOD(closeSession:(NSString *)clientId sessionId:(NSString *)sessionId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    MeshStreamBridgeClient *bridgeClient = [self bridgeClient:clientId];
+    if (bridgeClient == nil) { reject(@"MESHSTREAM_CLOSE_SESSION_FAILED", @"Unknown or closed MeshStream client.", nil); return; }
+    PlaybackSession *session;
+    @synchronized (bridgeClient.sessions) { session = bridgeClient.sessions[sessionId]; [bridgeClient.sessions removeObjectForKey:sessionId]; }
+    if (session != nil) {
+        [self removeSessionRouteForNativeSessionId:session.sessionId];
+        [self removePendingEventsForNativeSessionId:session.sessionId];
+    }
+    [session close];
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(closeClient:(NSString *)clientId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    MeshStreamBridgeClient *bridgeClient;
+    @synchronized (self.clients) { bridgeClient = self.clients[clientId]; [self.clients removeObjectForKey:clientId]; }
+    if (bridgeClient != nil) {
+        [bridgeClient.client removeEventListener:self];
+        NSArray<PlaybackSession *> *sessions;
+        @synchronized (bridgeClient.sessions) { sessions = bridgeClient.sessions.allValues; [bridgeClient.sessions removeAllObjects]; }
+        for (PlaybackSession *session in sessions) {
+            [self removeSessionRouteForNativeSessionId:session.sessionId];
+            [self removePendingEventsForNativeSessionId:session.sessionId];
+            [session close];
+        }
+        [bridgeClient.client close];
+        bridgeClient.client = nil;
+    }
+    resolve(nil);
+}
+
+- (MeshStreamBridgeClient *)bridgeClient:(NSString *)clientId {
+    @synchronized (self.clients) { return self.clients[clientId]; }
+}
+
+- (PlaybackSession *)sessionForClient:(NSString *)clientId sessionId:(NSString *)sessionId reject:(RCTPromiseRejectBlock)reject {
+    MeshStreamBridgeClient *bridgeClient = [self bridgeClient:clientId];
+    if (bridgeClient == nil) {
+        reject(@"MESHSTREAM_SESSION_OPERATION_FAILED", @"Unknown or closed MeshStream client.", nil);
+        return nil;
+    }
+    PlaybackSession *session;
+    @synchronized (bridgeClient.sessions) { session = bridgeClient.sessions[sessionId]; }
+    if (session == nil) reject(@"MESHSTREAM_SESSION_OPERATION_FAILED", @"Unknown or closed MeshStream playback session.", nil);
+    return session;
+}
+
+- (void)emitForNativeSessionId:(NSString *)nativeSessionId type:(NSString *)type extras:(NSDictionary *)extras {
+    MeshStreamSessionRoute *route;
+    @synchronized (self.sessionRoutes) { route = self.sessionRoutes[nativeSessionId]; }
+    if (route == nil) {
+        [self bufferPendingEventForNativeSessionId:nativeSessionId type:type extras:extras];
+        return;
+    }
+    [self sendSessionEventForClientId:route.clientId sessionId:route.sessionId type:type extras:extras];
+}
+
+- (void)sendSessionEventForClientId:(NSString *)clientId sessionId:(NSString *)sessionId type:(NSString *)type extras:(NSDictionary *)extras {
+    NSMutableDictionary *event = [@{ @"type": type, @"clientId": clientId, @"sessionId": sessionId } mutableCopy];
+    [event addEntriesFromDictionary:extras ?: @{}];
+    [self sendEventWithName:MeshStreamEventName body:event];
+}
+
+- (void)bufferPendingEventForNativeSessionId:(NSString *)nativeSessionId type:(NSString *)type extras:(NSDictionary *)extras {
+    if (nativeSessionId.length == 0) return;
+    @synchronized (self.pendingEvents) {
+        NSMutableArray<NSDictionary *> *events = self.pendingEvents[nativeSessionId];
+        if (events == nil) {
+            if (self.pendingEvents.count >= 64) return;
+            events = [NSMutableArray array];
+            self.pendingEvents[nativeSessionId] = events;
+        }
+        if (events.count < 8) [events addObject:@{ @"type": type, @"extras": extras ?: @{} }];
+    }
+}
+
+- (void)flushPendingEventsForNativeSessionId:(NSString *)nativeSessionId clientId:(NSString *)clientId sessionId:(NSString *)sessionId {
+    NSArray<NSDictionary *> *events;
+    @synchronized (self.pendingEvents) {
+        events = [self.pendingEvents[nativeSessionId] copy] ?: @[];
+        [self.pendingEvents removeObjectForKey:nativeSessionId];
+    }
+    for (NSDictionary *event in events) {
+        [self sendSessionEventForClientId:clientId sessionId:sessionId type:event[@"type"] extras:event[@"extras"]];
+    }
+}
+
+- (void)removePendingEventsForNativeSessionId:(NSString *)nativeSessionId {
+    @synchronized (self.pendingEvents) { [self.pendingEvents removeObjectForKey:nativeSessionId]; }
+}
+
+- (void)removeSessionRouteForNativeSessionId:(NSString *)nativeSessionId {
+    @synchronized (self.sessionRoutes) { [self.sessionRoutes removeObjectForKey:nativeSessionId]; }
+}
+
+- (void)onPlaybackPreparedWithSessionId:(NSString *)sessionId playbackUrl:(NSURL *)playbackUrl { [self emitForNativeSessionId:sessionId type:@"playbackPrepared" extras:@{ @"playbackUrl": playbackUrl.absoluteString ?: @"" }]; }
+- (void)onStatisticsWithSessionId:(NSString *)sessionId stats:(P2PStats *)stats { [self emitForNativeSessionId:sessionId type:@"statistics" extras:@{ @"statistics": MeshStreamStatsMap(stats) }]; }
+- (void)onPeerCountChangedWithSessionId:(NSString *)sessionId peerCount:(NSInteger)peerCount { [self emitForNativeSessionId:sessionId type:@"peerCountChanged" extras:@{ @"peerCount": @(peerCount) }]; }
+- (void)onP2PReadyWithSessionId:(NSString *)sessionId { [self emitForNativeSessionId:sessionId type:@"p2pReady" extras:nil]; }
+- (void)onP2PUnavailableWithSessionId:(NSString *)sessionId reason:(P2PUnavailableReason)reason { [self emitForNativeSessionId:sessionId type:@"p2pUnavailable" extras:@{ @"reason": MeshStreamReasonName(reason) }]; }
+- (void)onCdnFallbackWithSessionId:(NSString *)sessionId bytes:(int64_t)bytes { [self emitForNativeSessionId:sessionId type:@"cdnFallback" extras:@{ @"bytes": @((double)bytes) }]; }
+- (void)onTrackerErrorWithSessionId:(NSString *)sessionId totalErrors:(int64_t)totalErrors { [self emitForNativeSessionId:sessionId type:@"trackerError" extras:@{ @"totalErrors": @((double)totalErrors) }]; }
+- (void)onPeerConnectErrorWithSessionId:(NSString *)sessionId totalErrors:(int64_t)totalErrors { [self emitForNativeSessionId:sessionId type:@"peerConnectError" extras:@{ @"totalErrors": @((double)totalErrors) }]; }
+
+- (void)invalidate {
+    NSArray<NSString *> *clientIds;
+    @synchronized (self.clients) { clientIds = self.clients.allKeys; }
+    for (NSString *clientId in clientIds) {
+        MeshStreamBridgeClient *bridgeClient = [self bridgeClient:clientId];
+        [bridgeClient.client removeEventListener:self];
+        for (PlaybackSession *session in bridgeClient.sessions.allValues) {
+            [self removeSessionRouteForNativeSessionId:session.sessionId];
+            [session close];
+        }
+        [bridgeClient.sessions removeAllObjects];
+        [bridgeClient.client close];
+        bridgeClient.client = nil;
+    }
+    @synchronized (self.clients) { [self.clients removeAllObjects]; }
+    @synchronized (self.sessionRoutes) { [self.sessionRoutes removeAllObjects]; }
+    @synchronized (self.pendingEvents) { [self.pendingEvents removeAllObjects]; }
+    [super invalidate];
+}
+
+@end

package/ios/MeshStreamP2PValidation.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+FOUNDATION_EXPORT NSString * _Nullable MeshStreamTrimmedString(id _Nullable value);
+FOUNDATION_EXPORT NSURL * _Nullable MeshStreamHTTPURLFromValue(id _Nullable value);
+FOUNDATION_EXPORT NSDictionary<NSString *, NSString *> *MeshStreamStringHeaders(id _Nullable value);
+
+NS_ASSUME_NONNULL_END

package/ios/MeshStreamP2PValidation.m

@@ -0,0 +1,23 @@
+#import "MeshStreamP2PValidation.h"
+
+NSString *MeshStreamTrimmedString(id value) {
+    if (![value isKindOfClass:NSString.class]) return nil;
+    return [(NSString *)value stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceAndNewlineCharacterSet];
+}
+
+NSURL *MeshStreamHTTPURLFromValue(id value) {
+    NSString *text = MeshStreamTrimmedString(value);
+    NSURL *url = text.length > 0 ? [NSURL URLWithString:text] : nil;
+    NSString *scheme = url.scheme.lowercaseString;
+    if (!([scheme isEqualToString:@"http"] || [scheme isEqualToString:@"https"]) || url.host.length == 0) return nil;
+    return url;
+}
+
+NSDictionary<NSString *, NSString *> *MeshStreamStringHeaders(id value) {
+    if (![value isKindOfClass:NSDictionary.class]) return @{};
+    NSMutableDictionary<NSString *, NSString *> *headers = [NSMutableDictionary dictionary];
+    [(NSDictionary *)value enumerateKeysAndObjectsUsingBlock:^(id key, id item, BOOL *stop) {
+        if ([key isKindOfClass:NSString.class] && [item isKindOfClass:NSString.class]) headers[key] = item;
+    }];
+    return headers;
+}

package/lib/typescript/NativeMeshStreamP2P.d.ts

@@ -0,0 +1,20 @@
+import type { MeshStreamConfig, MeshStreamDiagnostics, MeshStreamSessionInfo, MeshStreamStats, MeshStreamStatus, PlaybackSessionOptions } from './types';
+interface NativeMeshStreamP2P {
+    getSdkVersion(): Promise<string>;
+    createClient(config: MeshStreamConfig): Promise<{
+        clientId: string;
+        status: MeshStreamStatus;
+    }>;
+    createPlaybackSession(clientId: string, options: PlaybackSessionOptions): Promise<MeshStreamSessionInfo>;
+    preload(clientId: string, sessionId: string): Promise<boolean>;
+    setP2pEnabled(clientId: string, sessionId: string, enabled: boolean): Promise<void>;
+    updateBufferedDurationMs(clientId: string, sessionId: string, durationMs: number): Promise<void>;
+    updateCurrentPositionMs(clientId: string, sessionId: string, positionMs: number): Promise<void>;
+    getStats(clientId: string, sessionId: string): Promise<MeshStreamStats>;
+    getDiagnostics(clientId: string, sessionId: string): Promise<MeshStreamDiagnostics>;
+    getStatus(clientId: string): Promise<MeshStreamStatus>;
+    closeSession(clientId: string, sessionId: string): Promise<void>;
+    closeClient(clientId: string): Promise<void>;
+}
+export declare function requireNativeModule(): NativeMeshStreamP2P;
+export {};

package/lib/typescript/NativeMeshStreamP2P.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireNativeModule = requireNativeModule;
+const react_native_1 = require("react-native");
+const nativeModule = react_native_1.NativeModules.MeshStreamP2P;
+function requireNativeModule() {
+    if (!nativeModule) {
+        throw new Error('MeshStreamP2P is not linked. Rebuild the iOS or Android app after installing react-native-meshstream.');
+    }
+    return nativeModule;
+}

package/lib/typescript/index.d.ts

@@ -0,0 +1,46 @@
+import { type EmitterSubscription } from 'react-native';
+import type { MeshStreamConfig, MeshStreamDiagnostics, MeshStreamEvent, MeshStreamEventName, MeshStreamSessionInfo, MeshStreamStats, MeshStreamStatus, MeshStreamVersionInfo, PlaybackSessionOptions } from './types';
+export * from './types';
+export declare class MeshStreamPlaybackSession {
+    readonly clientId: string;
+    readonly sessionId: string;
+    readonly playbackUrl: string;
+    readonly playbackMode: MeshStreamSessionInfo['playbackMode'];
+    readonly fallbackReason?: MeshStreamSessionInfo['fallbackReason'];
+    private readonly isClientClosed;
+    private closed;
+    private closing?;
+    constructor(info: MeshStreamSessionInfo, isClientClosed?: () => boolean);
+    preload(): Promise<boolean>;
+    setP2pEnabled(enabled: boolean): Promise<void>;
+    updateBufferedDurationMs(durationMs: number): Promise<void>;
+    updateCurrentPositionMs(positionMs: number): Promise<void>;
+    getStats(): Promise<MeshStreamStats>;
+    getDiagnostics(): Promise<MeshStreamDiagnostics>;
+    close(): Promise<void>;
+    private withOpen;
+}
+export declare class MeshStreamClient {
+    readonly clientId: string;
+    private closed;
+    private closing?;
+    constructor(clientId: string);
+    createPlaybackSession(options: PlaybackSessionOptions): Promise<MeshStreamPlaybackSession>;
+    getStatus(): Promise<MeshStreamStatus>;
+    close(): Promise<void>;
+    private withOpen;
+}
+export declare const MeshStream: {
+    /** Returns the version of the native MeshStream SDK loaded by this application. */
+    getSdkVersion(): Promise<string>;
+    /** Returns the React Native package version and the loaded native engine version. */
+    getVersion(): Promise<MeshStreamVersionInfo>;
+    create(config: MeshStreamConfig): Promise<MeshStreamClient>;
+    addEventListener(listener: (event: MeshStreamEvent) => void): EmitterSubscription;
+};
+/** Filtered event subscription for a particular client or playback session. */
+export declare function addMeshStreamEventListener(listener: (event: MeshStreamEvent) => void, filter?: {
+    clientId?: string;
+    sessionId?: string;
+    type?: MeshStreamEventName;
+}): EmitterSubscription;

package/lib/typescript/index.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshStream = exports.MeshStreamClient = exports.MeshStreamPlaybackSession = void 0;
+exports.addMeshStreamEventListener = addMeshStreamEventListener;
+const react_native_1 = require("react-native");
+const NativeMeshStreamP2P_1 = require("./NativeMeshStreamP2P");
+const version_1 = require("./version");
+__exportStar(require("./types"), exports);
+const EVENT_NAME = 'MeshStreamP2P:event';
+function assertNonEmpty(value, field) {
+    if (!value?.trim())
+        throw new Error(`${field} must not be empty.`);
+}
+function assertNonNegative(value, field) {
+    if (!Number.isFinite(value) || value < 0)
+        throw new Error(`${field} must be a finite non-negative number.`);
+}
+class MeshStreamPlaybackSession {
+    constructor(info, isClientClosed = () => false) {
+        this.closed = false;
+        this.clientId = info.clientId;
+        this.sessionId = info.sessionId;
+        this.playbackUrl = info.playbackUrl;
+        this.playbackMode = info.playbackMode;
+        this.fallbackReason = info.fallbackReason;
+        this.isClientClosed = isClientClosed;
+    }
+    async preload() {
+        return this.withOpen(() => (0, NativeMeshStreamP2P_1.requireNativeModule)().preload(this.clientId, this.sessionId));
+    }
+    async setP2pEnabled(enabled) {
+        return this.withOpen(() => (0, NativeMeshStreamP2P_1.requireNativeModule)().setP2pEnabled(this.clientId, this.sessionId, enabled));
+    }
+    async updateBufferedDurationMs(durationMs) {
+        assertNonNegative(durationMs, 'durationMs');
+        return this.withOpen(() => (0, NativeMeshStreamP2P_1.requireNativeModule)().updateBufferedDurationMs(this.clientId, this.sessionId, durationMs));
+    }
+    async updateCurrentPositionMs(positionMs) {
+        assertNonNegative(positionMs, 'positionMs');
+        return this.withOpen(() => (0, NativeMeshStreamP2P_1.requireNativeModule)().updateCurrentPositionMs(this.clientId, this.sessionId, positionMs));
+    }
+    async getStats() {
+        return this.withOpen(() => (0, NativeMeshStreamP2P_1.requireNativeModule)().getStats(this.clientId, this.sessionId));
+    }
+    async getDiagnostics() {
+        return this.withOpen(() => (0, NativeMeshStreamP2P_1.requireNativeModule)().getDiagnostics(this.clientId, this.sessionId));
+    }
+    async close() {
+        if (this.closed)
+            return;
+        if (this.isClientClosed()) {
+            return;
+        }
+        if (!this.closing) {
+            this.closing = (0, NativeMeshStreamP2P_1.requireNativeModule)()
+                .closeSession(this.clientId, this.sessionId)
+                .then(() => { this.closed = true; })
+                .finally(() => { this.closing = undefined; });
+        }
+        return this.closing;
+    }
+    async withOpen(operation) {
+        if (this.closed || this.closing || this.isClientClosed()) {
+            throw new Error('Playback session is closed.');
+        }
+        return operation();
+    }
+}
+exports.MeshStreamPlaybackSession = MeshStreamPlaybackSession;
+class MeshStreamClient {
+    constructor(clientId) {
+        this.closed = false;
+        this.clientId = clientId;
+    }
+    async createPlaybackSession(options) {
+        assertNonEmpty(options.url, 'options.url');
+        return this.withOpen(async () => {
+            const info = await (0, NativeMeshStreamP2P_1.requireNativeModule)().createPlaybackSession(this.clientId, options);
+            if (this.closed || this.closing)
+                throw new Error('MeshStream client is closed.');
+            return new MeshStreamPlaybackSession(info, () => this.closed || this.closing !== undefined);
+        });
+    }
+    async getStatus() {
+        return this.withOpen(() => (0, NativeMeshStreamP2P_1.requireNativeModule)().getStatus(this.clientId));
+    }
+    async close() {
+        if (this.closed)
+            return;
+        if (!this.closing) {
+            this.closing = (0, NativeMeshStreamP2P_1.requireNativeModule)()
+                .closeClient(this.clientId)
+                .then(() => { this.closed = true; })
+                .finally(() => { this.closing = undefined; });
+        }
+        return this.closing;
+    }
+    async withOpen(operation) {
+        if (this.closed || this.closing)
+            throw new Error('MeshStream client is closed.');
+        return operation();
+    }
+}
+exports.MeshStreamClient = MeshStreamClient;
+exports.MeshStream = {
+    /** Returns the version of the native MeshStream SDK loaded by this application. */
+    async getSdkVersion() {
+        return (0, NativeMeshStreamP2P_1.requireNativeModule)().getSdkVersion();
+    },
+    /** Returns the React Native package version and the loaded native engine version. */
+    async getVersion() {
+        const platform = react_native_1.Platform.OS;
+        if (platform !== 'android' && platform !== 'ios') {
+            throw new Error(`react-native-meshstream does not support ${platform}.`);
+        }
+        return {
+            packageVersion: version_1.MESHSTREAM_REACT_NATIVE_VERSION,
+            nativeSdkVersion: await exports.MeshStream.getSdkVersion(),
+            platform,
+        };
+    },
+    async create(config) {
+        assertNonEmpty(config.key, 'config.key');
+        const result = await (0, NativeMeshStreamP2P_1.requireNativeModule)().createClient(config);
+        return new MeshStreamClient(result.clientId);
+    },
+    addEventListener(listener) {
+        return react_native_1.DeviceEventEmitter.addListener(EVENT_NAME, listener);
+    },
+};
+/** Filtered event subscription for a particular client or playback session. */
+function addMeshStreamEventListener(listener, filter) {
+    return exports.MeshStream.addEventListener((event) => {
+        if (filter?.clientId && event.clientId !== filter.clientId)
+            return;
+        if (filter?.sessionId && event.sessionId !== filter.sessionId)
+            return;
+        if (filter?.type && event.type !== filter.type)
+            return;
+        listener(event);
+    });
+}