react-native-meshstream 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.0.2
+
+- Upgrade the public iOS dependency to MeshStreamKit 1.0.7 (iOS 15+).
+- Upgrade the public Android dependency to meshstream-android-sdk 1.0.6.
+- Use the public sdk.meshstream.net Maven endpoint in the example and installation guides.
+
+## 1.0.1
+
+- Pin the public Android and iOS native dependencies to 1.0.4.
+- Add `MeshStream.getSdkVersion()` to read the loaded native SDK version before creating a client.
+- Add `MeshStream.getVersion()` with the React Native package version, native SDK version, and current platform.
+- Display both versions in the example and resolve its SDK from the installed npm package.
+- Update the example for the local Android NDK and current Xcode/iOS scene lifecycle.
+
 ## 1.0.0
 
 - Unified Android and iOS React Native bridges over the respective native MeshStream SDKs.

package/MeshStreamP2P.podspec

@@ -1,17 +1,17 @@
 Pod::Spec.new do |s|
   s.name         = 'MeshStreamP2P'
-  s.version      = '1.0.0'
+  s.version      = '1.0.2'
   s.summary      = 'MeshStream P2P playback URL bridge for React Native.'
   s.homepage     = 'https://github.com/Mesh-Stream/meshstream-p2p-react-native-sdk'
   s.license      = { :type => 'Apache-2.0' }
   s.author       = { 'MeshStream' => 'support@meshstream.net' }
-  s.platforms    = { :ios => '13.0' }
+  s.platforms    = { :ios => '15.0' }
   s.source       = { :git => 'https://github.com/Mesh-Stream/meshstream-p2p-react-native-sdk.git', :tag => s.version.to_s }
   s.source_files = 'ios/**/*.{h,m}'
   s.public_header_files = 'ios/MeshStreamP2P.h'
   s.private_header_files = 'ios/MeshStreamP2PValidation.h'
   s.dependency 'React-Core'
-  s.dependency 'MeshStreamKit', '= 1.0.2'
+  s.dependency 'MeshStreamKit', '= 1.0.7'
   s.frameworks = 'Foundation', 'Network', 'Security'
 
   s.test_spec 'Validation' do |test_spec|

package/README.md

@@ -9,7 +9,7 @@ React Native binding for MeshStream P2P playback acceleration. It creates a CDN-
 ## Requirements
 
 - React Native `0.72+`
-- Android API 24+ (Android 7.0+) or iOS 13+
+- Android API 24+ (Android 7.0+) or iOS 15+
 - MeshStream SDK key enabled for the target platform
 
 ## Install
@@ -25,13 +25,13 @@ repositories {
     google()
     mavenCentral()
     maven {
-        url = uri("https://pub-61830e1369904d19af505ff74fd55ba4.r2.dev/maven")
+        url = uri("https://sdk.meshstream.net/maven")
         content { includeGroup("io.meshstream") }
     }
 }
 ```
 
-For iOS, the bridge resolves the public `MeshStreamKit 1.0.2` CocoaPod. After installation, run `pod install --repo-update` from the app's `ios` directory and rebuild the native app. Do not add a local `MeshStreamKit` pod path or embed its XCFramework yourself.
+For iOS, the bridge resolves the public `MeshStreamKit 1.0.7` CocoaPod. After installation, run `pod install --repo-update` from the app's `ios` directory and rebuild the native app. Do not add a local `MeshStreamKit` pod path or embed its XCFramework yourself.
 
 ## Basic usage
 
@@ -102,6 +102,16 @@ const diagnostics = await session.getDiagnostics();
 subscription.remove();
 ```
 
+### Version information
+
+Read version information before creating a client when attaching diagnostics to a support request. The React Native package and the native engine are versioned independently, so record both fields.
+
+```ts
+const sdkVersion = await MeshStream.getSdkVersion();
+const version = await MeshStream.getVersion();
+// { packageVersion: '1.0.2', nativeSdkVersion: '1.0.6', platform: 'android' }
+```
+
 Available event types: `peerCountChanged`, `playbackPrepared`, `p2pReady`, `p2pUnavailable`, `statistics`, `cdnFallback`, `trackerError`, and `peerConnectError`.
 
 ## Supported media
@@ -114,13 +124,13 @@ The package is a unified JavaScript layer, not an Android SDK repackaged for Rea
 
 ### Versioning
 
-- `react-native-meshstream` follows its own React Native package version. This release is `1.0.0`.
-- The Android bridge keeps its independent native dependency: `io.meshstream:meshstream-android-sdk:1.0.2`.
-- The iOS bridge keeps its independent native dependency: `MeshStreamKit >= 1.0.0`.
+- `react-native-meshstream` follows its own React Native package version. This release is `1.0.2`.
+- The Android bridge keeps its independent native dependency: `io.meshstream:meshstream-android-sdk:1.0.6`.
+- The iOS bridge keeps its independent native dependency: `MeshStreamKit 1.0.7`.
 
 Updating the React Native package does not implicitly upgrade either native SDK.
 
-- Android resolves `io.meshstream:meshstream-android-sdk:1.0.2` from the MeshStream Maven repository.
-- iOS resolves the public `MeshStreamKit 1.0.2` CocoaPod.
+- Android resolves `io.meshstream:meshstream-android-sdk:1.0.6` from the MeshStream Maven repository.
+- iOS resolves the public `MeshStreamKit 1.0.7` CocoaPod.
 
 Both bridges maintain client/session isolation. Closing a client only closes its own sessions and never interrupts another React Native player in the same process.

package/README.zh-CN.md

@@ -9,7 +9,7 @@
 ## 环境要求
 
 - React Native `0.72+`
-- Android API 24+（Android 7.0+）或 iOS 13+
+- Android API 24+（Android 7.0+）或 iOS 15+
 - 已启用对应目标平台的 MeshStream SDK Key
 
 ## 安装
@@ -25,13 +25,13 @@ repositories {
     google()
     mavenCentral()
     maven {
-        url = uri("https://pub-61830e1369904d19af505ff74fd55ba4.r2.dev/maven")
+        url = uri("https://sdk.meshstream.net/maven")
         content { includeGroup("io.meshstream") }
     }
 }
 ```
 
-接入 iOS 时，bridge 会解析公开的 `MeshStreamKit 1.0.2` CocoaPod。安装 npm 包后，请在应用的 `ios` 目录执行 `pod install --repo-update` 并重新编译原生工程；不要添加本地 `MeshStreamKit` Pod 路径，也不需要手动嵌入 XCFramework。
+接入 iOS 时，bridge 会解析公开的 `MeshStreamKit 1.0.7` CocoaPod。安装 npm 包后，请在应用的 `ios` 目录执行 `pod install --repo-update` 并重新编译原生工程；不要添加本地 `MeshStreamKit` Pod 路径，也不需要手动嵌入 XCFramework。
 
 ## 基础接入
 
@@ -102,6 +102,16 @@ const diagnostics = await session.getDiagnostics();
 subscription.remove();
 ```
 
+### 版本信息
+
+创建客户端前即可读取版本信息。提交工单或诊断日志时，应同时记录 React Native 包版本和原生内核版本；两者独立发布。
+
+```ts
+const sdkVersion = await MeshStream.getSdkVersion();
+const version = await MeshStream.getVersion();
+// { packageVersion: '1.0.2', nativeSdkVersion: '1.0.6', platform: 'android' }
+```
+
 事件类型包括：`peerCountChanged`、`playbackPrepared`、`p2pReady`、`p2pUnavailable`、`statistics`、`cdnFallback`、`trackerError`、`peerConnectError`。
 
 ## 支持的媒体格式
@@ -114,13 +124,13 @@ subscription.remove();
 
 ### 版本说明
 
-- `react-native-meshstream` 使用独立的 React Native 包版本；当前首发版本为 `1.0.0`。
-- Android 桥接使用独立的原生依赖：`io.meshstream:meshstream-android-sdk:1.0.2`。
-- iOS 桥接使用独立的原生依赖：`MeshStreamKit >= 1.0.0`。
+- `react-native-meshstream` 使用独立的 React Native 包版本；当前版本为 `1.0.2`。
+- Android 桥接使用独立的原生依赖：`io.meshstream:meshstream-android-sdk:1.0.6`。
+- iOS 桥接使用独立的原生依赖：`MeshStreamKit 1.0.7`。
 
 升级 React Native 包不会隐式升级任一原生 SDK。
 
-- Android 从 MeshStream Maven 仓库解析 `io.meshstream:meshstream-android-sdk:1.0.2`。
-- iOS 通过 CocoaPods 解析公开的 `MeshStreamKit 1.0.2`。
+- Android 从 MeshStream Maven 仓库解析 `io.meshstream:meshstream-android-sdk:1.0.6`。
+- iOS 通过 CocoaPods 解析公开的 `MeshStreamKit 1.0.7`。
 
 两个 bridge 都保证 client/session 隔离。关闭某一个 client 只会关闭其所属会话，不会中断同一进程中的其他 React Native 播放器。

package/android/build.gradle

@@ -19,5 +19,5 @@ android {
 dependencies {
   implementation 'com.facebook.react:react-android'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
-  implementation 'io.meshstream:meshstream-android-sdk:1.0.2'
+  implementation 'io.meshstream:meshstream-android-sdk:1.0.6'
 }

package/android/src/main/java/net/meshstream/reactnative/MeshStreamP2PModule.kt

@@ -33,6 +33,7 @@ class MeshStreamP2PModule(
     private data class BridgeClient(
         val client: P2pClient,
         val sessions: ConcurrentHashMap<String, PlaybackSession> = ConcurrentHashMap(),
+        val nativeSessionIds: ConcurrentHashMap<Long, String> = ConcurrentHashMap(),
         val pendingEvents: ConcurrentHashMap<Long, MutableList<PendingEvent>> = ConcurrentHashMap(),
     )
 
@@ -45,6 +46,15 @@ class MeshStreamP2PModule(
 
     override fun getName(): String = MODULE_NAME
 
+    @ReactMethod
+    fun getSdkVersion(promise: Promise) {
+        try {
+            promise.resolve(P2pSdk.getSdkVersion())
+        } catch (error: Throwable) {
+            promise.reject("MESHSTREAM_VERSION_FAILED", error.message, error)
+        }
+    }
+
     @ReactMethod
     fun createClient(config: ReadableMap, promise: Promise) {
         try {
@@ -84,6 +94,7 @@ class MeshStreamP2PModule(
             )
             val sessionId = UUID.randomUUID().toString()
             bridgeClient.sessions[sessionId] = session
+            bridgeClient.nativeSessionIds[session.sessionId] = sessionId
             flushPendingEvents(clientId, sessionId, session, bridgeClient)
             promise.resolve(session.toWritableMap(clientId, sessionId))
         } catch (error: Throwable) {
@@ -141,6 +152,7 @@ class MeshStreamP2PModule(
         try {
             val bridgeClient = clients.requireClient(clientId)
             bridgeClient.sessions.remove(sessionId)?.let { session ->
+                bridgeClient.nativeSessionIds.remove(session.sessionId, sessionId)
                 bridgeClient.pendingEvents.remove(session.sessionId)
                 session.close()
             }
@@ -156,6 +168,7 @@ class MeshStreamP2PModule(
             clients.remove(clientId)?.let { bridgeClient ->
                 bridgeClient.sessions.values.forEach { it.close() }
                 bridgeClient.sessions.clear()
+                bridgeClient.nativeSessionIds.clear()
                 bridgeClient.pendingEvents.clear()
                 bridgeClient.client.close()
             }
@@ -168,6 +181,7 @@ class MeshStreamP2PModule(
     override fun invalidate() {
         clients.values.forEach { bridgeClient ->
             bridgeClient.sessions.values.forEach { it.close() }
+            bridgeClient.nativeSessionIds.clear()
             bridgeClient.pendingEvents.clear()
             bridgeClient.client.close()
         }
@@ -184,8 +198,7 @@ class MeshStreamP2PModule(
     }
 
     private fun createEventListener(clientId: String, bridgeClient: BridgeClient) = object : P2pEventListener {
-        private fun sessionId(nativeSessionId: Long): String? = bridgeClient.sessions.entries
-            .firstOrNull { it.value.sessionId == nativeSessionId }?.key
+        private fun sessionId(nativeSessionId: Long): String? = bridgeClient.nativeSessionIds[nativeSessionId]
 
         private fun emit(nativeSessionId: Long, type: String, extras: WritableMap.() -> Unit = {}) {
             val jsSessionId = sessionId(nativeSessionId)

package/ios/MeshStreamP2P.m

@@ -99,8 +99,17 @@ static NSDictionary *MeshStreamDiagnosticsMap(P2PDiagnostics *diagnostics) {
 @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
 
@@ -113,6 +122,7 @@ RCT_EXPORT_MODULE(MeshStreamP2P)
 - (instancetype)init {
     if ((self = [super init])) {
         _clients = [NSMutableDictionary dictionary];
+        _sessionRoutes = [NSMutableDictionary dictionary];
         _pendingEvents = [NSMutableDictionary dictionary];
     }
     return self;
@@ -120,6 +130,12 @@ RCT_EXPORT_MODULE(MeshStreamP2P)
 
 - (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
@@ -168,6 +184,10 @@ RCT_EXPORT_METHOD(createPlaybackSession:(NSString *)clientId
     }
     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,
@@ -220,7 +240,10 @@ RCT_EXPORT_METHOD(closeSession:(NSString *)clientId sessionId:(NSString *)sessio
     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 removePendingEventsForNativeSessionId:session.sessionId];
+    if (session != nil) {
+        [self removeSessionRouteForNativeSessionId:session.sessionId];
+        [self removePendingEventsForNativeSessionId:session.sessionId];
+    }
     [session close];
     resolve(nil);
 }
@@ -233,6 +256,7 @@ RCT_EXPORT_METHOD(closeClient:(NSString *)clientId resolver:(RCTPromiseResolveBl
         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];
         }
@@ -259,22 +283,13 @@ RCT_EXPORT_METHOD(closeClient:(NSString *)clientId resolver:(RCTPromiseResolveBl
 }
 
 - (void)emitForNativeSessionId:(NSString *)nativeSessionId type:(NSString *)type extras:(NSDictionary *)extras {
-    __block NSString *clientId;
-    __block NSString *sessionId;
-    @synchronized (self.clients) {
-        [self.clients enumerateKeysAndObjectsUsingBlock:^(NSString *key, MeshStreamBridgeClient *bridgeClient, BOOL *stop) {
-            @synchronized (bridgeClient.sessions) {
-                [bridgeClient.sessions enumerateKeysAndObjectsUsingBlock:^(NSString *jsId, PlaybackSession *session, BOOL *sessionStop) {
-                    if ([session.sessionId isEqualToString:nativeSessionId]) { clientId = key; sessionId = jsId; *stop = YES; *sessionStop = YES; }
-                }];
-            }
-        }];
-    }
-    if (clientId == nil || sessionId == nil) {
+    MeshStreamSessionRoute *route;
+    @synchronized (self.sessionRoutes) { route = self.sessionRoutes[nativeSessionId]; }
+    if (route == nil) {
         [self bufferPendingEventForNativeSessionId:nativeSessionId type:type extras:extras];
         return;
     }
-    [self sendSessionEventForClientId:clientId sessionId:sessionId type:type extras:extras];
+    [self sendSessionEventForClientId:route.clientId sessionId:route.sessionId type:type extras:extras];
 }
 
 - (void)sendSessionEventForClientId:(NSString *)clientId sessionId:(NSString *)sessionId type:(NSString *)type extras:(NSDictionary *)extras {
@@ -311,6 +326,10 @@ RCT_EXPORT_METHOD(closeClient:(NSString *)clientId resolver:(RCTPromiseResolveBl
     @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) }]; }
@@ -326,12 +345,16 @@ RCT_EXPORT_METHOD(closeClient:(NSString *)clientId resolver:(RCTPromiseResolveBl
     for (NSString *clientId in clientIds) {
         MeshStreamBridgeClient *bridgeClient = [self bridgeClient:clientId];
         [bridgeClient.client removeEventListener:self];
-        for (PlaybackSession *session in bridgeClient.sessions.allValues) [session close];
+        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];
 }

package/lib/typescript/NativeMeshStreamP2P.d.ts

@@ -1,5 +1,6 @@
 import type { MeshStreamConfig, MeshStreamDiagnostics, MeshStreamSessionInfo, MeshStreamStats, MeshStreamStatus, PlaybackSessionOptions } from './types';
 interface NativeMeshStreamP2P {
+    getSdkVersion(): Promise<string>;
     createClient(config: MeshStreamConfig): Promise<{
         clientId: string;
         status: MeshStreamStatus;

package/lib/typescript/index.d.ts

@@ -1,5 +1,5 @@
 import { type EmitterSubscription } from 'react-native';
-import type { MeshStreamConfig, MeshStreamDiagnostics, MeshStreamEvent, MeshStreamEventName, MeshStreamSessionInfo, MeshStreamStats, MeshStreamStatus, PlaybackSessionOptions } from './types';
+import type { MeshStreamConfig, MeshStreamDiagnostics, MeshStreamEvent, MeshStreamEventName, MeshStreamSessionInfo, MeshStreamStats, MeshStreamStatus, MeshStreamVersionInfo, PlaybackSessionOptions } from './types';
 export * from './types';
 export declare class MeshStreamPlaybackSession {
     readonly clientId: string;
@@ -7,9 +7,10 @@ export declare class MeshStreamPlaybackSession {
     readonly playbackUrl: string;
     readonly playbackMode: MeshStreamSessionInfo['playbackMode'];
     readonly fallbackReason?: MeshStreamSessionInfo['fallbackReason'];
+    private readonly isClientClosed;
     private closed;
     private closing?;
-    constructor(info: MeshStreamSessionInfo);
+    constructor(info: MeshStreamSessionInfo, isClientClosed?: () => boolean);
     preload(): Promise<boolean>;
     setP2pEnabled(enabled: boolean): Promise<void>;
     updateBufferedDurationMs(durationMs: number): Promise<void>;
@@ -30,6 +31,10 @@ export declare class MeshStreamClient {
     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;
 };

package/lib/typescript/index.js

@@ -18,6 +18,7 @@ exports.MeshStream = exports.MeshStreamClient = exports.MeshStreamPlaybackSessio
 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) {
@@ -29,13 +30,14 @@ function assertNonNegative(value, field) {
         throw new Error(`${field} must be a finite non-negative number.`);
 }
 class MeshStreamPlaybackSession {
-    constructor(info) {
+    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));
@@ -60,6 +62,9 @@ class MeshStreamPlaybackSession {
     async close() {
         if (this.closed)
             return;
+        if (this.isClientClosed()) {
+            return;
+        }
         if (!this.closing) {
             this.closing = (0, NativeMeshStreamP2P_1.requireNativeModule)()
                 .closeSession(this.clientId, this.sessionId)
@@ -69,8 +74,9 @@ class MeshStreamPlaybackSession {
         return this.closing;
     }
     async withOpen(operation) {
-        if (this.closed || this.closing)
+        if (this.closed || this.closing || this.isClientClosed()) {
             throw new Error('Playback session is closed.');
+        }
         return operation();
     }
 }
@@ -82,7 +88,12 @@ class MeshStreamClient {
     }
     async createPlaybackSession(options) {
         assertNonEmpty(options.url, 'options.url');
-        return this.withOpen(async () => new MeshStreamPlaybackSession(await (0, NativeMeshStreamP2P_1.requireNativeModule)().createPlaybackSession(this.clientId, options)));
+        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));
@@ -106,6 +117,22 @@ class MeshStreamClient {
 }
 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);

package/lib/typescript/types.d.ts

@@ -4,6 +4,15 @@ export interface MeshStreamConfig {
     key: string;
     p2pEnabled?: boolean;
 }
+/** Versions of the JavaScript wrapper and native engine used by this application. */
+export interface MeshStreamVersionInfo {
+    /** Version of the installed react-native-meshstream package. */
+    packageVersion: string;
+    /** Version of the Android or Apple MeshStream engine loaded by the bridge. */
+    nativeSdkVersion: string;
+    /** Native platform that supplied nativeSdkVersion. */
+    platform: 'android' | 'ios';
+}
 export interface PlaybackSessionOptions {
     url: string;
     contentId?: string;

package/lib/typescript/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Public npm package version. Keep this value aligned with package.json for each release.
+ * It is deliberately separate from the Android/iOS engine version.
+ */
+export declare const MESHSTREAM_REACT_NATIVE_VERSION = "1.0.2";

package/lib/typescript/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESHSTREAM_REACT_NATIVE_VERSION = void 0;
+/**
+ * Public npm package version. Keep this value aligned with package.json for each release.
+ * It is deliberately separate from the Android/iOS engine version.
+ */
+exports.MESHSTREAM_REACT_NATIVE_VERSION = '1.0.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-meshstream",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MeshStream P2P playback URL SDK for React Native",
   "main": "lib/typescript/index.js",
   "module": "lib/typescript/index.js",
@@ -22,10 +22,13 @@
   "scripts": {
     "build": "tsc --project tsconfig.json",
     "typecheck": "tsc --project tsconfig.json --noEmit",
+    "verify:version": "node scripts/verify-package-version.mjs",
     "test:ios": "node --test tests/node/ios-regression-guards.test.mjs",
     "verify:ios": "npm run test:ios && node scripts/verify-ios-package.mjs && node scripts/verify-ios-xctest.mjs",
     "verify:ios:public": "npm run test:ios && node scripts/verify-ios-package.mjs && node scripts/verify-ios-xctest.mjs --repo-update",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "prepack": "npm run verify:version",
+    "test": "npm run build && node --test tests/node/*.test.mjs"
   },
   "keywords": [
     "react-native",

package/src/NativeMeshStreamP2P.ts

@@ -10,6 +10,7 @@ import type {
 } 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>;

package/src/index.ts

@@ -1,6 +1,7 @@
-import { DeviceEventEmitter, type EmitterSubscription } from 'react-native';
+import { DeviceEventEmitter, Platform, type EmitterSubscription } from 'react-native';
 
 import { requireNativeModule } from './NativeMeshStreamP2P';
+import { MESHSTREAM_REACT_NATIVE_VERSION } from './version';
 import type {
   MeshStreamConfig,
   MeshStreamDiagnostics,
@@ -9,6 +10,7 @@ import type {
   MeshStreamSessionInfo,
   MeshStreamStats,
   MeshStreamStatus,
+  MeshStreamVersionInfo,
   PlaybackSessionOptions,
 } from './types';
 
@@ -30,15 +32,17 @@ export class MeshStreamPlaybackSession {
   readonly playbackUrl: string;
   readonly playbackMode: MeshStreamSessionInfo['playbackMode'];
   readonly fallbackReason?: MeshStreamSessionInfo['fallbackReason'];
+  private readonly isClientClosed: () => boolean;
   private closed = false;
   private closing?: Promise<void>;
 
-  constructor(info: MeshStreamSessionInfo) {
+  constructor(info: MeshStreamSessionInfo, isClientClosed: () => boolean = () => 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(): Promise<boolean> {
@@ -69,6 +73,9 @@ export class MeshStreamPlaybackSession {
 
   async close(): Promise<void> {
     if (this.closed) return;
+    if (this.isClientClosed()) {
+      return;
+    }
     if (!this.closing) {
       this.closing = requireNativeModule()
         .closeSession(this.clientId, this.sessionId)
@@ -79,7 +86,9 @@ export class MeshStreamPlaybackSession {
   }
 
   private async withOpen<T>(operation: () => Promise<T>): Promise<T> {
-    if (this.closed || this.closing) throw new Error('Playback session is closed.');
+    if (this.closed || this.closing || this.isClientClosed()) {
+      throw new Error('Playback session is closed.');
+    }
     return operation();
   }
 }
@@ -95,9 +104,11 @@ export class MeshStreamClient {
 
   async createPlaybackSession(options: PlaybackSessionOptions): Promise<MeshStreamPlaybackSession> {
     assertNonEmpty(options.url, 'options.url');
-    return this.withOpen(async () => new MeshStreamPlaybackSession(
-      await requireNativeModule().createPlaybackSession(this.clientId, options),
-    ));
+    return this.withOpen(async () => {
+      const info = await 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(): Promise<MeshStreamStatus> {
@@ -122,6 +133,24 @@ export class MeshStreamClient {
 }
 
 export const MeshStream = {
+  /** Returns the version of the native MeshStream SDK loaded by this application. */
+  async getSdkVersion(): Promise<string> {
+    return requireNativeModule().getSdkVersion();
+  },
+
+  /** Returns the React Native package version and the loaded native engine version. */
+  async getVersion(): Promise<MeshStreamVersionInfo> {
+    const platform = Platform.OS;
+    if (platform !== 'android' && platform !== 'ios') {
+      throw new Error(`react-native-meshstream does not support ${platform}.`);
+    }
+    return {
+      packageVersion: MESHSTREAM_REACT_NATIVE_VERSION,
+      nativeSdkVersion: await MeshStream.getSdkVersion(),
+      platform,
+    };
+  },
+
   async create(config: MeshStreamConfig): Promise<MeshStreamClient> {
     assertNonEmpty(config.key, 'config.key');
     const result = await requireNativeModule().createClient(config);

package/src/types.ts

@@ -6,6 +6,16 @@ export interface MeshStreamConfig {
   p2pEnabled?: boolean;
 }
 
+/** Versions of the JavaScript wrapper and native engine used by this application. */
+export interface MeshStreamVersionInfo {
+  /** Version of the installed react-native-meshstream package. */
+  packageVersion: string;
+  /** Version of the Android or Apple MeshStream engine loaded by the bridge. */
+  nativeSdkVersion: string;
+  /** Native platform that supplied nativeSdkVersion. */
+  platform: 'android' | 'ios';
+}
+
 export interface PlaybackSessionOptions {
   url: string;
   contentId?: string;

package/src/version.ts

@@ -0,0 +1,5 @@
+/**
+ * Public npm package version. Keep this value aligned with package.json for each release.
+ * It is deliberately separate from the Android/iOS engine version.
+ */
+export const MESHSTREAM_REACT_NATIVE_VERSION = '1.0.2';

package/tests/ios/MeshStreamP2PValidationTests.m

@@ -1,4 +1,5 @@
 #import <XCTest/XCTest.h>
+#import <MeshStreamKit/MeshStreamKit.h>
 
 #import "../../ios/MeshStreamP2PValidation.h"
 
@@ -7,6 +8,10 @@
 
 @implementation MeshStreamP2PValidationTests
 
+- (void)testNativeVersionIsAvailableBeforeCreatingClient {
+    XCTAssertEqualObjects([P2PSDK getSdkVersion], @"1.0.6");
+}
+
 - (void)testTrimsURLsAndFiltersNonStringHeaders {
     XCTAssertEqualObjects(
         MeshStreamTrimmedString(@"  content-42\n"),