@byteplus/react-native-live-push 1.0.0

package/lib/typescript/android/index.d.ts

@@ -0,0 +1,44 @@
+import { NativeProxyService, NativeView } from '@vcloud-lux/hybrid-runtime';
+import type { SurfaceHolder } from '../codegen/android/index';
+export declare class AndroidSurfaceView extends NativeView {
+    getHolder(): Promise<SurfaceHolder>;
+}
+declare class ApplicationContext {
+}
+declare class ReactApplicationContext {
+}
+declare class ScreenIntent {
+}
+export declare class NativeVariables {
+    static getApplicationContext(): Promise<ApplicationContext>;
+    static getReactApplicationContext(): Promise<ReactApplicationContext>;
+    static getScreenIntent(): Promise<ScreenIntent>;
+}
+export declare class VeLivePlayerConfiguration extends NativeProxyService {
+    enableStatisticsCallback?: boolean;
+    enableLiveDNS?: boolean;
+    enableSei?: boolean;
+    enableHardwareDecode?: boolean;
+    networkTimeoutMs?: number;
+    retryIntervalTimeMs?: number;
+    retryMaxCount?: number;
+    statisticsCallbackInterval?: number;
+}
+export declare class Env {
+    static init(cfg: any): void;
+    static openAppLog(cfg: any): void;
+    static getApplicationContext(): ApplicationContext;
+}
+declare class ConfigBuilder {
+    setApplicationContext(appContext: ApplicationContext): ConfigBuilder;
+    setAppID(appId: string): ConfigBuilder;
+    setAppName(appId: string): ConfigBuilder;
+    setAppVersion(appVer: string): ConfigBuilder;
+    setAppChannel(appVer: string): ConfigBuilder;
+    setLicenseUri(appVer: string): ConfigBuilder;
+    build(): any;
+}
+export declare class Config {
+    static Builder: typeof ConfigBuilder;
+}
+export {};

package/lib/typescript/codegen/android/api.d.ts

@@ -0,0 +1,372 @@
+import { int, long, Matrix, ByteBuffer, Runnable, float, String, View, Bitmap, Intent, EGLContext, Context, LiveSdkSetting } from './types';
+import { VeLiveVideoBufferType, VeLivePixelFormat, VeLiveVideoRotation, VeLiveVideoEffectLicenseConfiguration, VeLivePusherRenderMode, VeLiveVideoMirrorType, VeLiveVideoCaptureType, VeLiveAudioCaptureType, VeLiveVideoEncoderConfiguration, VeLiveAudioEncoderConfiguration, VeLiveFileRecorderConfiguration, VeLiveOrientation, VeLivePusherLogLevel, VeLivePusherLogConfig, VeLiveAudioMixType, VeLiveStreamMixDescription, VeLiveAudioSampleRate, VeLiveAudioChannel, VeLiveAudioBufferType, VeLiveVideoCaptureConfiguration, VeLiveAudioCaptureConfiguration } from './keytype';
+import { VeLiveVideoEffectCallback, VeLiveVideoEffectHandleCallback, VeLivePusherObserver, VeLivePusherStatisticsObserver, VeLiveFileRecordingListener, VeLiveVideoFrameFilter, VeLiveAudioFrameFilter, VeLiveVideoFrameListener, VeLiveAudioFrameListener, VeLiveSnapshotListener, VeLiveMediaPlayerListener, VeLiveMediaPlayerFrameListener } from './callback';
+export declare class VeLiveVideoFrame {
+    width: number;
+    height: number;
+    ptsUs: number;
+    textureId: number;
+    data: any;
+    static new_VeLiveVideoFrame(): VeLiveVideoFrame;
+    static new_VeLiveVideoFrame_int$int$long$int$boolean$Matrix(width: int, height: int, pts: long, texId: int, isOes: boolean, matrix: Matrix): VeLiveVideoFrame;
+    static new_VeLiveVideoFrame_int$int$long$ByteBuffer(width: int, height: int, pts: long, byteBuffer: ByteBuffer): VeLiveVideoFrame;
+    static new_VeLiveVideoFrame_int$int$long$byte(width: int, height: int, pts: long, data: ArrayBuffer): VeLiveVideoFrame;
+    
+    retain(): void;
+    
+    release(): void;
+    
+    getBufferType(): VeLiveVideoBufferType;
+    
+    setBufferType(bufferType: VeLiveVideoBufferType): VeLiveVideoFrame;
+    
+    getPixelFormat(): VeLivePixelFormat;
+    
+    setPixelFormat(pixelFormat: VeLivePixelFormat): VeLiveVideoFrame;
+    
+    getRotation(): VeLiveVideoRotation;
+    
+    setRotation(rotation: VeLiveVideoRotation): VeLiveVideoFrame;
+    
+    getWidth(): int;
+    
+    getHeight(): int;
+    
+    getRotatedWidth(): int;
+    
+    getRotatedHeight(): int;
+    
+    getPts(): long;
+    
+    getTextureId(): int;
+    
+    getTextureMatrix(): Matrix;
+    
+    getBuffer(): ByteBuffer;
+    
+    getData(): ArrayBuffer;
+    
+    getReleaseCallback(): Runnable;
+    
+    setReleaseCallback(releaseCallback: Runnable): VeLiveVideoFrame;
+}
+export declare class VeLiveCameraDevice {
+    
+    CAMERA_DEVICE_CODE_OK: int;
+    
+    CAMERA_DEVICE_CODE_NOT_LIVE: int;
+    
+    CAMERA_DEVICE_CODE_NOT_SUPPORT: int;
+    
+    CAMERA_DEVICE_CODE_PARAM_ILLEGAL: int;
+    
+    CAMERA_DEVICE_CODE_ERROR_BASE: int;
+    
+    setParameter(parameter: Parameter): int;
+    
+    getParameter(): Parameter;
+    
+    getRealFpsRange(): int[];
+    
+    enableTorch(enable: boolean): int;
+    
+    setZoomRatio(ratio: float): int;
+    
+    getCurrentZoomRatio(): float;
+    
+    getMaxZoomRatio(): float;
+    
+    getMinZoomRatio(): float;
+    
+    isAutoFocusEnabled(): boolean;
+    
+    enableAutoFocus(enable: boolean): int;
+    
+    setFocusPosition(viewW: int, viewH: int, x: int, y: int): int;
+    
+    isExposurePositionSupported(): boolean;
+    
+    setExposurePosition(viewW: int, viewH: int, x: int, y: int): int;
+    
+    getMinExposureCompensation(): float;
+    
+    getMaxExposureCompensation(): float;
+    
+    setExposureCompensation(value: float): int;
+}
+export declare class VeLiveVideoEffectManager {
+    
+    setupWithConfig(config: VeLiveVideoEffectLicenseConfiguration): int;
+    
+    updateLicense(callback: VeLiveVideoEffectCallback): void;
+    
+    setEnable(enable: boolean, callback: VeLiveVideoEffectCallback): void;
+    
+    setAlgorithmModelPath(path: String): int;
+    
+    setComposeNodes(nodes: String[]): int;
+    
+    appendComposeNodes(nodes: String[]): int;
+    
+    removeComposeNodes(nodes: String[]): int;
+    
+    updateComposerNodeIntensity(node: String, key: String, intensity: float): int;
+    
+    setFilter(path: String): int;
+    
+    updateFilterIntensity(intensity: float): int;
+    
+    setSticker(path: String): int;
+    
+    setAdvancedFeature(callback: VeLiveVideoEffectHandleCallback, isGLThread: boolean, isAsync: boolean): int;
+}
+export declare class WrappedI420BufferFrame {
+    constructor(width: int, height: int, pts: long, rotation: VeLiveVideoRotation);
+    getDataY(): ByteBuffer;
+    getDataU(): ByteBuffer;
+    getDataV(): ByteBuffer;
+}
+export declare class VeLivePusher {
+    
+    static getVersion(): String;
+    
+    static setLogLevel(logLevel: VeLivePusherLogLevel): void;
+    
+    static setLogConfig(config: VeLivePusherLogConfig): void;
+    
+    static setEGLVersion(version: int): void;
+    
+    static setEGLContext(context: EGLContext): void;
+    
+    static getEGLContext(): EGLContext;
+    
+    release(): void;
+    
+    setObserver(observer: VeLivePusherObserver): void;
+    
+    setStatisticsObserver(observer: VeLivePusherStatisticsObserver, interval: int): void;
+    
+    setRenderView(view: View): Promise<void>;
+    
+    setRenderFillMode(mode: VeLivePusherRenderMode): void;
+    
+    setVideoMirror(type: VeLiveVideoMirrorType, mirror: boolean): void;
+    
+    startVideoCapture(type: VeLiveVideoCaptureType): void;
+    
+    stopVideoCapture(): void;
+    
+    startAudioCapture(type: VeLiveAudioCaptureType): void;
+    
+    stopAudioCapture(): void;
+    
+    switchVideoCapture(type: VeLiveVideoCaptureType): void;
+    
+    switchAudioCapture(type: VeLiveAudioCaptureType): void;
+    
+    getCurrentVideoCaptureType(): VeLiveVideoCaptureType;
+    
+    getCurrentAudioCaptureType(): VeLiveAudioCaptureType;
+    
+    updateCustomImage(image: Bitmap): Promise<void>;
+    
+    getCameraDevice(): VeLiveCameraDevice;
+    
+    setVideoEncoderConfiguration(config: VeLiveVideoEncoderConfiguration): void;
+    
+    getVideoEncoderConfiguration(): VeLiveVideoEncoderConfiguration;
+    
+    setAudioEncoderConfiguration(config: VeLiveAudioEncoderConfiguration): void;
+    
+    getAudioEncoderConfiguration(): VeLiveAudioEncoderConfiguration;
+    
+    startPush(url: String): void;
+    
+    startPushWithUrls(urls: String[]): void;
+    
+    stopPush(): void;
+    
+    isPushing(): boolean;
+    
+    setWatermark(image: Bitmap, x: float, y: float, scale: float): Promise<int>;
+    
+    startFileRecording(path: String, config: VeLiveFileRecorderConfiguration, listener: VeLiveFileRecordingListener): void;
+    
+    stopFileRecording(): void;
+    
+    setProperty(key: String, value: Object): int;
+    
+    pushExternalVideoFrame(frame: VeLiveVideoFrame): int;
+    
+    pushExternalAudioFrame(frame: VeLiveAudioFrame): int;
+    
+    setOrientation(orientation: VeLiveOrientation): void;
+    
+    sendSeiMessage(key: String, value: Object, repeat: int, isKeyFrame: boolean, allowsCovered: boolean): int;
+    
+    setMute(mute: boolean): void;
+    
+    isMute(): boolean;
+    
+    getVideoEffectManager(): VeLiveVideoEffectManager;
+    
+    setVideoFrameFilter(filter: VeLiveVideoFrameFilter): void;
+    
+    getAudioDevice(): VeLiveAudioDevice;
+    
+    setAudioFrameFilter(filter: VeLiveAudioFrameFilter): void;
+    
+    createPlayer(): VeLiveMediaPlayer;
+    
+    getMixerManager(): VeLiveMixerManager;
+    
+    startScreenRecording(enableAppAudio: boolean, screenIntent: Intent): void;
+    
+    stopScreenRecording(): void;
+    
+    isScreenRecording(): boolean;
+    
+    addVideoFrameListener(listener: VeLiveVideoFrameListener): int;
+    
+    removeVideoFrameListener(listener: VeLiveVideoFrameListener): int;
+    
+    addAudioFrameListener(listener: VeLiveAudioFrameListener): int;
+    
+    removeAudioFrameListener(listener: VeLiveAudioFrameListener): int;
+    
+    snapshot(listener: VeLiveSnapshotListener): void;
+}
+export declare class Parameter {
+    static readonly WIDTH: String;
+    static readonly HEIGHT: String;
+    static readonly FPS: String;
+    static readonly ZOOM: String;
+    static readonly FOCUS_MODE: String;
+    static readonly FOCUS_MODE_AUTO: String;
+    static readonly CURRENT_ISO: String;
+    setInt(key: String, value: int): int;
+    getInt(key: String): int;
+    setFloat(key: String, value: float): int;
+    getFloat(key: String): float;
+}
+export declare class VeLiveMixerManager {
+    
+    addVideoStream(): int;
+    
+    addAudioStream(): int;
+    
+    addAudioStream_VeLiveAudioMixType(type: VeLiveAudioMixType): int;
+    
+    getOriginVideoStream(): int;
+    
+    getOriginAudioStream(): int;
+    
+    getOriginScreenStream(): int;
+    
+    getOriginSystemAudioStream(): int;
+    
+    sendCustomVideoFrame(frame: VeLiveVideoFrame, streamId: int): void;
+    
+    sendCustomAudioFrame(frame: VeLiveAudioFrame, streamId: int): void;
+    
+    updateStreamMixDescription(mixDescription: VeLiveStreamMixDescription): void;
+    
+    removeVideoStream(streamId: int): void;
+    
+    removeAudioStream(streamId: int): void;
+}
+export declare class VeLiveMediaPlayer {
+    
+    release(): void;
+    
+    setListener(listener: VeLiveMediaPlayerListener): void;
+    
+    prepare(url: String): int;
+    
+    start(): int;
+    
+    stop(): int;
+    
+    pause(): void;
+    
+    resume(): void;
+    
+    getDuration(): long;
+    
+    seek(posMs: long): int;
+    
+    enableMixer(enable: boolean): void;
+    
+    enableAutoEq(sourceLufs: float, targetLufs: float): void;
+    
+    setRenderView(view: View): void;
+    
+    setFrameListener(listener: VeLiveMediaPlayerFrameListener): void;
+    
+    setBGMVolume(volume: float): void;
+    
+    setVoiceVolume(volume: float): void;
+    
+    enableBGMLoop(loop: boolean): void;
+}
+export declare class VeLiveAudioFrame {
+    bufferType: any;
+    sampleRate: any;
+    channels: any;
+    ptsUs: any;
+    buffer: any;
+    samplesPerChannel: any;
+    static new_VeLiveAudioFrame_VeLiveAudioSampleRate$VeLiveAudioChannel$long$ByteBuffer(sampleRate: VeLiveAudioSampleRate, channel: VeLiveAudioChannel, pts: long, buffer: ByteBuffer): VeLiveAudioFrame;
+    
+    getBufferType(): VeLiveAudioBufferType;
+    
+    getSampleRate(): VeLiveAudioSampleRate;
+    
+    getChannels(): VeLiveAudioChannel;
+    
+    getSamplesPerChannel(): int;
+    
+    getPts(): long;
+    
+    getBuffer(): ByteBuffer;
+}
+export declare class VeLiveAudioDevice {
+    
+    setVoiceLoudness(level: float): void;
+    
+    getVoiceLoudness(): float;
+    
+    isSupportHardwareEcho(): boolean;
+    
+    enableEcho(enable: boolean): void;
+    
+    isEnableEcho(): boolean;
+}
+export declare class VeLivePusherConfiguration {
+    
+    setReconnectIntervalSeconds(interval: int): VeLivePusherConfiguration;
+    
+    getReconnectIntervalSeconds(): int;
+    
+    setReconnectCount(maxCount: int): VeLivePusherConfiguration;
+    
+    getReconnectCount(): int;
+    
+    setVideoCaptureConfig(config: VeLiveVideoCaptureConfiguration): VeLivePusherConfiguration;
+    
+    getVideoCaptureConfig(): VeLiveVideoCaptureConfiguration;
+    
+    setAudioCaptureConfig(config: VeLiveAudioCaptureConfiguration): VeLivePusherConfiguration;
+    
+    getAudioCaptureConfig(): VeLiveAudioCaptureConfiguration;
+    
+    setContext(context: Context): VeLivePusherConfiguration;
+    
+    getContext(): Context;
+    
+    setExtraParameters(params: String): VeLivePusherConfiguration;
+    
+    getExtraParams(): LiveSdkSetting;
+    
+    build(): VeLivePusher;
+}

package/lib/typescript/codegen/android/callback.d.ts

@@ -0,0 +1,91 @@
+import { VeLiveVideoFrame, VeLiveAudioFrame } from './api';
+import { int, String, Bundle, long, Bitmap, float, JSONObject } from './types';
+import { VeLiveVideoFrameSource, VeLiveAudioFrameSource, VeLivePusherStatus, VeLiveFirstFrameType, VeLiveNetworkQuality, VeLiveAudioPowerLevel, VeLivePusherStatistics } from './keytype';
+export declare class VeLiveVideoFrameFilter {
+    
+    onVideoProcess?(srcFrame: VeLiveVideoFrame, dstFrame: VeLiveVideoFrame): int;
+}
+export declare class VeLiveVideoFrameListener {
+    
+    getObservedVideoFrameSource?(): VeLiveVideoFrameSource;
+    
+    onCaptureVideoFrame?(frame: VeLiveVideoFrame): void;
+    
+    onPreEncodeVideoFrame?(frame: VeLiveVideoFrame): void;
+}
+export declare class VeLiveVideoEffectCallback {
+    
+    onResult?(result: int, msg: String): void;
+}
+export declare class VeLiveMediaPlayerListener {
+    
+    onStart?(info: Bundle): void;
+    
+    onProgress?(timeMs: long): void;
+    
+    onStop?(): void;
+    
+    onError?(code: int, msg: String): void;
+}
+export declare class VeLiveAudioFrameListener {
+    
+    getObservedAudioFrameSource?(): VeLiveAudioFrameSource;
+    
+    onCaptureAudioFrame?(frame: VeLiveAudioFrame): void;
+    
+    onPreEncodeAudioFrame?(frame: VeLiveAudioFrame): void;
+}
+export declare class VeLiveMediaPlayerFrameListener {
+    
+    onAudioFrame?(frame: VeLiveAudioFrame): void;
+    
+    onVideoFrame?(frame: VeLiveVideoFrame): void;
+}
+export declare class VeLiveSnapshotListener {
+    
+    onSnapshotComplete?(image: Bitmap): void;
+}
+export declare class VeLiveAudioFrameFilter {
+    
+    onAudioProcess?(srcFrame: VeLiveAudioFrame, dstFrame: VeLiveAudioFrame): int;
+}
+export declare class VeLivePusherObserver {
+    
+    onError?(code: int, subCode: int, msg: String): void;
+    
+    onStatusChange?(status: VeLivePusherStatus): void;
+    
+    onFirstVideoFrame?(type: VeLiveFirstFrameType, timestampMs: long): void;
+    
+    onFirstAudioFrame?(type: VeLiveFirstFrameType, timestampMs: long): void;
+    
+    onCameraOpened?(open: boolean): void;
+    
+    onMicrophoneOpened?(open: boolean): void;
+    
+    onScreenRecording?(open: boolean): void;
+    
+    onNetworkQuality?(quality: VeLiveNetworkQuality): void;
+    
+    onAudioPowerQuality?(level: VeLiveAudioPowerLevel, value: float): void;
+}
+export declare class VeLivePusherStatisticsObserver {
+    
+    onStatistics?(statistics: VeLivePusherStatistics): void;
+    
+    onLogMonitor?(logInfo: JSONObject): void;
+}
+export declare class VeLivePusherDef {
+}
+export declare class VeLiveFileRecordingListener {
+    
+    onFileRecordingStarted?(): void;
+    
+    onFileRecordingStopped?(): void;
+    
+    onFileRecordingError?(errorCode: int, message: String): void;
+}
+export declare class VeLiveVideoEffectHandleCallback {
+    
+    onEffectHandle?(handle: Object): void;
+}

package/lib/typescript/codegen/android/errorcode.d.ts

@@ -0,0 +1,26 @@
+export declare enum VeLivePusherErrorCode {
+    
+    VeLivePusherSuccess = 0,
+    
+    VeLivePusherInvalidLicense = 1,
+    
+    VeLivePusherInvalidParameter = 2,
+    
+    VeLivePusherVideoCaptureError = 3,
+    
+    VeLivePusherAudioCaptureError = 4,
+    
+    VeLivePusherVideoEncoderError = 5,
+    
+    VeLivePusherAudioEncoderError = 6,
+    
+    VeLivePusherTransportError = 7,
+    
+    VeLivePusherVideoEffectError = 8,
+    
+    VeLivePusherAudioDeviceError = 9,
+    
+    VeLivePusherLicenseUnsupportedH265 = 10,
+    
+    VeLivePusherError = 11
+}

package/lib/typescript/codegen/android/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './callback';
+export * from './errorcode';
+export * from './keytype';
+export * from './types';