@abdurrahman-dev/react-native-ivs-broadcast 0.1.0

package/lib/index.js

@@ -0,0 +1,234 @@
+"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 });
+const react_native_1 = require("react-native");
+const { IVSBroadcastModule } = react_native_1.NativeModules;
+if (!IVSBroadcastModule) {
+    throw new Error("IVSBroadcastModule native module is not available. Make sure you have properly linked the module.");
+}
+const eventEmitter = new react_native_1.NativeEventEmitter(IVSBroadcastModule);
+class IVSBroadcast {
+    constructor() {
+        this.listeners = new Map();
+    }
+    /**
+     * Yeni bir broadcast session oluşturur
+     */
+    async createSession(config) {
+        if (!config.rtmpUrl) {
+            throw new Error("RTMP URL is required");
+        }
+        try {
+            const sessionId = await IVSBroadcastModule.createSession(config);
+            return { sessionId };
+        }
+        catch (error) {
+            throw new Error(`Failed to create session: ${error.message}`);
+        }
+    }
+    /**
+     * Broadcast'i başlatır
+     */
+    async startBroadcast(sessionId) {
+        try {
+            await IVSBroadcastModule.startBroadcast(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to start broadcast: ${error.message}`);
+        }
+    }
+    /**
+     * Broadcast'i durdurur
+     */
+    async stopBroadcast(sessionId) {
+        try {
+            await IVSBroadcastModule.stopBroadcast(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to stop broadcast: ${error.message}`);
+        }
+    }
+    /**
+     * Broadcast'i duraklatır
+     */
+    async pauseBroadcast(sessionId) {
+        try {
+            await IVSBroadcastModule.pauseBroadcast(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to pause broadcast: ${error.message}`);
+        }
+    }
+    /**
+     * Duraklatılmış broadcast'i devam ettirir
+     */
+    async resumeBroadcast(sessionId) {
+        try {
+            await IVSBroadcastModule.resumeBroadcast(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to resume broadcast: ${error.message}`);
+        }
+    }
+    /**
+     * Broadcast session'ı yok eder
+     */
+    async destroySession(sessionId) {
+        try {
+            await IVSBroadcastModule.destroySession(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to destroy session: ${error.message}`);
+        }
+    }
+    /**
+     * Broadcast durumunu alır
+     */
+    async getState(sessionId) {
+        try {
+            return await IVSBroadcastModule.getState(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get state: ${error.message}`);
+        }
+    }
+    /**
+     * Kamera pozisyonunu değiştirir
+     */
+    async switchCamera(sessionId) {
+        try {
+            await IVSBroadcastModule.switchCamera(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to switch camera: ${error.message}`);
+        }
+    }
+    /**
+     * Kamera pozisyonunu ayarlar
+     */
+    async setCameraPosition(sessionId, position) {
+        try {
+            await IVSBroadcastModule.setCameraPosition(sessionId, position);
+        }
+        catch (error) {
+            throw new Error(`Failed to set camera position: ${error.message}`);
+        }
+    }
+    /**
+     * Mikrofonu açıp kapatır
+     */
+    async setMuted(sessionId, muted) {
+        try {
+            await IVSBroadcastModule.setMuted(sessionId, muted);
+        }
+        catch (error) {
+            throw new Error(`Failed to set muted state: ${error.message}`);
+        }
+    }
+    /**
+     * Mikrofon durumunu alır
+     */
+    async isMuted(sessionId) {
+        try {
+            return await IVSBroadcastModule.isMuted(sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get muted state: ${error.message}`);
+        }
+    }
+    /**
+     * Video konfigürasyonunu günceller
+     */
+    async updateVideoConfig(sessionId, config) {
+        try {
+            await IVSBroadcastModule.updateVideoConfig(sessionId, config);
+        }
+        catch (error) {
+            throw new Error(`Failed to update video config: ${error.message}`);
+        }
+    }
+    /**
+     * Audio konfigürasyonunu günceller
+     */
+    async updateAudioConfig(sessionId, config) {
+        try {
+            await IVSBroadcastModule.updateAudioConfig(sessionId, config);
+        }
+        catch (error) {
+            throw new Error(`Failed to update audio config: ${error.message}`);
+        }
+    }
+    addListener(eventType, callback) {
+        if (!this.listeners.has(eventType)) {
+            this.listeners.set(eventType, []);
+        }
+        this.listeners.get(eventType).push(callback);
+        const subscription = eventEmitter.addListener(eventType, (data) => {
+            const callbacks = this.listeners.get(eventType);
+            if (callbacks) {
+                callbacks.forEach((cb) => cb(data));
+            }
+        });
+        // Cleanup fonksiyonunu döndür
+        return () => {
+            subscription.remove();
+            const callbacks = this.listeners.get(eventType);
+            if (callbacks) {
+                const index = callbacks.indexOf(callback);
+                if (index > -1) {
+                    callbacks.splice(index, 1);
+                }
+            }
+        };
+    }
+    /**
+     * Event listener'ı kaldırır
+     */
+    removeListener(eventType, callback) {
+        const callbacks = this.listeners.get(eventType);
+        if (callbacks) {
+            if (callback) {
+                const index = callbacks.indexOf(callback);
+                if (index > -1) {
+                    callbacks.splice(index, 1);
+                }
+            }
+            else {
+                this.listeners.delete(eventType);
+            }
+        }
+        eventEmitter.removeAllListeners(eventType);
+    }
+    /**
+     * Tüm listener'ları temizler
+     */
+    removeAllListeners(eventType) {
+        if (eventType) {
+            this.listeners.delete(eventType);
+            eventEmitter.removeAllListeners(eventType);
+        }
+        else {
+            this.listeners.clear();
+            // Tüm event type'ları için listener'ları temizle
+            this.listeners.forEach((_, type) => {
+                eventEmitter.removeAllListeners(type);
+            });
+            this.listeners.clear();
+        }
+    }
+}
+exports.default = new IVSBroadcast();
+__exportStar(require("./types"), exports);

package/lib/types.d.ts

@@ -0,0 +1,55 @@
+export interface IVSBroadcastConfig {
+    rtmpUrl: string;
+    streamKey?: string;
+    videoConfig?: VideoConfig;
+    audioConfig?: AudioConfig;
+}
+export interface VideoConfig {
+    width?: number;
+    height?: number;
+    bitrate?: number;
+    fps?: number;
+    targetFps?: number;
+    keyframeInterval?: number;
+    encoder?: 'hardware' | 'software';
+}
+export interface AudioConfig {
+    bitrate?: number;
+    sampleRate?: number;
+    channels?: number;
+}
+export interface IVSBroadcastSession {
+    sessionId: string;
+}
+export interface BroadcastState {
+    isBroadcasting: boolean;
+    isPaused: boolean;
+    error?: string;
+}
+export interface CameraPosition {
+    position: 'front' | 'back';
+}
+export interface PreviewViewProps {
+    style?: any;
+}
+export type BroadcastEventType = 'onStateChanged' | 'onError' | 'onNetworkHealth' | 'onAudioStats' | 'onVideoStats';
+export interface BroadcastEvent {
+    type: BroadcastEventType;
+    data?: any;
+}
+export interface NetworkHealth {
+    networkQuality: 'excellent' | 'good' | 'fair' | 'poor';
+    uplinkBandwidth?: number;
+    rtt?: number;
+}
+export interface AudioStats {
+    bitrate: number;
+    sampleRate: number;
+    channels: number;
+}
+export interface VideoStats {
+    bitrate: number;
+    fps: number;
+    width: number;
+    height: number;
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "@abdurrahman-dev/react-native-ivs-broadcast",
+    "version": "0.1.0",
+    "description": "React Native bridge for Amazon IVS Broadcast SDK (Android 1.37.1, iOS 1.37.0)",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "prepare": "npm run build",
+        "lint": "eslint . --ext .ts,.tsx"
+    },
+    "keywords": [
+        "react-native",
+        "amazon-ivs",
+        "ivs-broadcast",
+        "video-streaming",
+        "broadcast",
+        "aws"
+    ],
+    "author": "",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/abdurrahman-dev/react-native-ivs-broadcast.git"
+    },
+    "bugs": {
+        "url": "https://github.com/abdurrahman-dev/react-native-ivs-broadcast/issues"
+    },
+    "homepage": "https://github.com/abdurrahman-dev/react-native-ivs-broadcast#readme",
+    "peerDependencies": {
+        "react-native": ">=0.60.0"
+    },
+    "react-native": {
+        "android": {
+            "sourceDir": "./android",
+            "packageImportPath": "import com.reactnativeivsbroadcast.IVSBroadcastPackage;"
+        },
+        "ios": {
+            "podspecPath": "./ios/IVSBroadcast.podspec"
+        }
+    },
+    "devDependencies": {
+        "@types/react-native": "^0.70.0",
+        "@typescript-eslint/eslint-plugin": "^5.0.0",
+        "@typescript-eslint/parser": "^5.0.0",
+        "eslint": "^8.0.0",
+        "typescript": "^4.9.0"
+    },
+    "files": [
+        "android/",
+        "ios/",
+        "lib/",
+        "src/",
+        "README.md",
+        "LICENSE"
+    ]
+}

package/src/index.ts

@@ -0,0 +1,273 @@
+import { NativeModules, NativeEventEmitter, Platform } from "react-native";
+import type {
+  IVSBroadcastConfig,
+  IVSBroadcastSession,
+  BroadcastState,
+  CameraPosition,
+  BroadcastEvent,
+  NetworkHealth,
+  AudioStats,
+  VideoStats,
+  VideoConfig,
+  AudioConfig,
+} from "./types";
+
+const { IVSBroadcastModule } = NativeModules;
+
+if (!IVSBroadcastModule) {
+  throw new Error(
+    "IVSBroadcastModule native module is not available. Make sure you have properly linked the module."
+  );
+}
+
+const eventEmitter = new NativeEventEmitter(IVSBroadcastModule);
+
+class IVSBroadcast {
+  private listeners: Map<string, Array<(data: any) => void>> = new Map();
+
+  /**
+   * Yeni bir broadcast session oluşturur
+   */
+  async createSession(
+    config: IVSBroadcastConfig
+  ): Promise<IVSBroadcastSession> {
+    if (!config.rtmpUrl) {
+      throw new Error("RTMP URL is required");
+    }
+
+    try {
+      const sessionId = await IVSBroadcastModule.createSession(config);
+      return { sessionId };
+    } catch (error: any) {
+      throw new Error(`Failed to create session: ${error.message}`);
+    }
+  }
+
+  /**
+   * Broadcast'i başlatır
+   */
+  async startBroadcast(sessionId: string): Promise<void> {
+    try {
+      await IVSBroadcastModule.startBroadcast(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to start broadcast: ${error.message}`);
+    }
+  }
+
+  /**
+   * Broadcast'i durdurur
+   */
+  async stopBroadcast(sessionId: string): Promise<void> {
+    try {
+      await IVSBroadcastModule.stopBroadcast(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to stop broadcast: ${error.message}`);
+    }
+  }
+
+  /**
+   * Broadcast'i duraklatır
+   */
+  async pauseBroadcast(sessionId: string): Promise<void> {
+    try {
+      await IVSBroadcastModule.pauseBroadcast(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to pause broadcast: ${error.message}`);
+    }
+  }
+
+  /**
+   * Duraklatılmış broadcast'i devam ettirir
+   */
+  async resumeBroadcast(sessionId: string): Promise<void> {
+    try {
+      await IVSBroadcastModule.resumeBroadcast(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to resume broadcast: ${error.message}`);
+    }
+  }
+
+  /**
+   * Broadcast session'ı yok eder
+   */
+  async destroySession(sessionId: string): Promise<void> {
+    try {
+      await IVSBroadcastModule.destroySession(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to destroy session: ${error.message}`);
+    }
+  }
+
+  /**
+   * Broadcast durumunu alır
+   */
+  async getState(sessionId: string): Promise<BroadcastState> {
+    try {
+      return await IVSBroadcastModule.getState(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to get state: ${error.message}`);
+    }
+  }
+
+  /**
+   * Kamera pozisyonunu değiştirir
+   */
+  async switchCamera(sessionId: string): Promise<void> {
+    try {
+      await IVSBroadcastModule.switchCamera(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to switch camera: ${error.message}`);
+    }
+  }
+
+  /**
+   * Kamera pozisyonunu ayarlar
+   */
+  async setCameraPosition(
+    sessionId: string,
+    position: "front" | "back"
+  ): Promise<void> {
+    try {
+      await IVSBroadcastModule.setCameraPosition(sessionId, position);
+    } catch (error: any) {
+      throw new Error(`Failed to set camera position: ${error.message}`);
+    }
+  }
+
+  /**
+   * Mikrofonu açıp kapatır
+   */
+  async setMuted(sessionId: string, muted: boolean): Promise<void> {
+    try {
+      await IVSBroadcastModule.setMuted(sessionId, muted);
+    } catch (error: any) {
+      throw new Error(`Failed to set muted state: ${error.message}`);
+    }
+  }
+
+  /**
+   * Mikrofon durumunu alır
+   */
+  async isMuted(sessionId: string): Promise<boolean> {
+    try {
+      return await IVSBroadcastModule.isMuted(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to get muted state: ${error.message}`);
+    }
+  }
+
+  /**
+   * Video konfigürasyonunu günceller
+   */
+  async updateVideoConfig(
+    sessionId: string,
+    config: VideoConfig
+  ): Promise<void> {
+    try {
+      await IVSBroadcastModule.updateVideoConfig(sessionId, config);
+    } catch (error: any) {
+      throw new Error(`Failed to update video config: ${error.message}`);
+    }
+  }
+
+  /**
+   * Audio konfigürasyonunu günceller
+   */
+  async updateAudioConfig(
+    sessionId: string,
+    config: AudioConfig
+  ): Promise<void> {
+    try {
+      await IVSBroadcastModule.updateAudioConfig(sessionId, config);
+    } catch (error: any) {
+      throw new Error(`Failed to update audio config: ${error.message}`);
+    }
+  }
+
+  /**
+   * Event listener ekler
+   */
+  addListener(
+    eventType: "onStateChanged",
+    callback: (state: BroadcastState) => void
+  ): void;
+  addListener(
+    eventType: "onError",
+    callback: (error: { message: string; code?: string }) => void
+  ): void;
+  addListener(
+    eventType: "onNetworkHealth",
+    callback: (health: NetworkHealth) => void
+  ): void;
+  addListener(
+    eventType: "onAudioStats",
+    callback: (stats: AudioStats) => void
+  ): void;
+  addListener(
+    eventType: "onVideoStats",
+    callback: (stats: VideoStats) => void
+  ): void;
+  addListener(eventType: string, callback: (data: any) => void): () => void {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, []);
+    }
+    this.listeners.get(eventType)!.push(callback);
+
+    const subscription = eventEmitter.addListener(eventType, (data) => {
+      const callbacks = this.listeners.get(eventType);
+      if (callbacks) {
+        callbacks.forEach((cb) => cb(data));
+      }
+    });
+
+    // Cleanup fonksiyonunu döndür
+    return () => {
+      subscription.remove();
+      const callbacks = this.listeners.get(eventType);
+      if (callbacks) {
+        const index = callbacks.indexOf(callback);
+        if (index > -1) {
+          callbacks.splice(index, 1);
+        }
+      }
+    };
+  }
+
+  /**
+   * Event listener'ı kaldırır
+   */
+  removeListener(eventType: string, callback?: (data: any) => void): void {
+    const callbacks = this.listeners.get(eventType);
+    if (callbacks) {
+      if (callback) {
+        const index = callbacks.indexOf(callback);
+        if (index > -1) {
+          callbacks.splice(index, 1);
+        }
+      } else {
+        this.listeners.delete(eventType);
+      }
+    }
+    eventEmitter.removeAllListeners(eventType);
+  }
+
+  /**
+   * Tüm listener'ları temizler
+   */
+  removeAllListeners(eventType?: string): void {
+    if (eventType) {
+      this.listeners.delete(eventType);
+      eventEmitter.removeAllListeners(eventType);
+    } else {
+      this.listeners.clear();
+      // Tüm event type'ları için listener'ları temizle
+      this.listeners.forEach((_, type) => {
+        eventEmitter.removeAllListeners(type);
+      });
+      this.listeners.clear();
+    }
+  }
+}
+
+export default new IVSBroadcast();
+export * from "./types";

package/src/types.ts

@@ -0,0 +1,72 @@
+export interface IVSBroadcastConfig {
+  rtmpUrl: string;
+  streamKey?: string;
+  videoConfig?: VideoConfig;
+  audioConfig?: AudioConfig;
+}
+
+export interface VideoConfig {
+  width?: number;
+  height?: number;
+  bitrate?: number;
+  fps?: number;
+  targetFps?: number;
+  keyframeInterval?: number;
+  encoder?: 'hardware' | 'software';
+}
+
+export interface AudioConfig {
+  bitrate?: number;
+  sampleRate?: number;
+  channels?: number;
+}
+
+export interface IVSBroadcastSession {
+  sessionId: string;
+}
+
+export interface BroadcastState {
+  isBroadcasting: boolean;
+  isPaused: boolean;
+  error?: string;
+}
+
+export interface CameraPosition {
+  position: 'front' | 'back';
+}
+
+export interface PreviewViewProps {
+  style?: any;
+}
+
+export type BroadcastEventType =
+  | 'onStateChanged'
+  | 'onError'
+  | 'onNetworkHealth'
+  | 'onAudioStats'
+  | 'onVideoStats';
+
+export interface BroadcastEvent {
+  type: BroadcastEventType;
+  data?: any;
+}
+
+export interface NetworkHealth {
+  networkQuality: 'excellent' | 'good' | 'fair' | 'poor';
+  uplinkBandwidth?: number;
+  rtt?: number;
+}
+
+export interface AudioStats {
+  bitrate: number;
+  sampleRate: number;
+  channels: number;
+}
+
+export interface VideoStats {
+  bitrate: number;
+  fps: number;
+  width: number;
+  height: number;
+}
+