@byteplus/react-native-live-pull 1.0.0 → 1.0.3-rc.0

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

@@ -1,13 +1,10 @@
-import { VeLivePlayerConfiguration, VeLivePlayerFillMode, VeLivePlayerStreamData, VeLivePlayerResolution, VeLivePlayerPixelFormat, VeLivePlayerVideoBufferType, VeLivePlayerRotation, VeLivePlayerMirror, VeLivePlayerLogLevel } from './keytype';
-import { VeLivePlayerObserver } from './callback';
-import { ApplicationContext } from '../../platforms/android/extends';
 import * as $p_a from '../android/index';
 import * as $p_i from '../ios/index';
+import { VeLivePlayerResolution, VeLivePlayerFillMode, VeLivePlayerPixelFormat, VeLivePlayerVideoBufferType, VeLivePlayerRotation, VeLivePlayerMirror, VeLivePlayerLogLevel, VeLivePlayerConfiguration, VeLivePlayerStreamData } from './keytype';
+import { VeLivePlayerObserver } from './callback';
+import { Map, type String, List } from './types';
+import { ApplicationContext } from './external';
 
-/** {en}
- * @detail api
- * @brief The live player.
- */
 export declare class VeLivePlayer {
     
     /** {en}
@@ -16,14 +13,16 @@ export declare class VeLivePlayer {
      * @return  <br>
      *     The version number of the Player SDK.
      * @order 4
+     *
      */
     static getVersion(): string;
     
     /** {en}
      * @detail api
      * @brief Sets the level of the output log.
-     * @param logLevel The level of the output log. For details, see {@link #VeLivePlayerLogLevel VeLivePlayerLogLevel}.
+     * @param logLevel The level of the output log. For details, see VeLivePlayerLogLevel{@link #VeLivePlayerLogLevel}.
      * @order 5
+     *
      */
     static setLogLevel(logLevel: VeLivePlayerLogLevel): void;
     
@@ -32,11 +31,10 @@ export declare class VeLivePlayer {
      * @brief Sets the mapping of domain names to server IP addresses.
      * @param hostIpMap The mapping of domain names to server IP addresses. The `Map` object uses the domain name as the key, and the corresponding value is a list of IP addresses for the servers associated with that domain. The value is of the `List` type.
      */
-    static ios_setHttpDNSHostIP(hostIpMap: Object): void;
+    static ios_setHttpDNSHostIP(hostIpMap: $p_i.NSDictionary): void;
     constructor(context: ApplicationContext);
+    constructor();
     protected _instance: any;
-    protected __init(...args: any[]): void;
-    protected __new_instance(...args: any[]): $p_a.VeLivePlayer | $p_i.TVLManager;
     
     /** {en}
      * @platform ios
@@ -54,12 +52,46 @@ export declare class VeLivePlayer {
     get ios_playerView(): $p_i.UIView;
     set ios_playerView(value: $p_i.UIView);
     
+    /** {en}
+     * @platform ios
+     * @detail keytype
+     * @brief The player volume. The default value is `1.0`. The value range is [0.0, 1.0].
+     */
+    get ios_volume(): $p_i.float;
+    set ios_volume(value: $p_i.float);
+    protected __init(...args: any[]): void;
+    protected __new_instance(...args: any[]): any;
+    
+    /** {en}
+     * @detail api
+     * @brief Sets the player volume.
+     * @param volume The volume. The default value is `1.0`. The value range is [0.0, 1.0].
+     * @order 8
+     *
+     */
+    setPlayerVolume(volume: number): void;
+    
+    /** {en}
+     * @detail api
+     * @brief Changes the video resolution.
+     * @notes - Call [setPlayStreamData](#VeLivePlayer-setplaystreamdata) to set multiple resolutions before calling this method.
+     *        - Once the player switches to the new resolution after you call this method, the [onResolutionSwitch](player-android-api-callback#VeLivePlayerObserver-onresolutionswitch) callback is triggered.
+     * @return <br>
+     *     - true: Success;
+     *     - false: Failure.
+     * @order 8
+     * @param resolution The video resolution. For details, refer to VeLivePlayerResolution {@link #VeLivePlayerResolution}.
+     *
+     */
+    switchResolution(resolution: VeLivePlayerResolution): void;
+    
     /** {en}
      * @detail api
      * @brief  Initializes the player and configures whether to turn on SEI messaging, hardware decoding, local DNS prefetch, and other configurations.
      * @notes <br>Call this method to initialize the player before calling [play](#VeLivePlayer-play) .
      * @order 1
      * @param config Player configurations. Refer to VeLivePlayerConfiguration {@link #VeLivePlayerConfiguration} for details.
+     *
      */
     setConfig(config: VeLivePlayerConfiguration): void;
     
@@ -70,6 +102,7 @@ export declare class VeLivePlayer {
      *      Call this method before calling play {@link #play}.
      * @param observer The player observer. See VeLivePlayerObserver {@link #VeLivePlayerObserver} for details.
      * @order 2
+     *
      */
     setObserver(observer: VeLivePlayerObserver): void;
     
@@ -81,6 +114,7 @@ export declare class VeLivePlayer {
      *        - You can call this method during playback to dynamically adjust the fill mode.
      * @order 3
      * @param fillMode The fill mode of SurfaceView. The default value is `VeLivePlayerFillModeAspectFill`. For details, see VeLivePlayerFillMode {@link #VeLivePlayerFillMode}.
+     *
      */
     setRenderFillMode(fillMode: VeLivePlayerFillMode): Promise<void>;
     
@@ -92,8 +126,9 @@ export declare class VeLivePlayer {
      *     If you call both `setSurfaceHolder` and setSurface {@link #setSurface} to set the `Surface` object, the player will prioritize the configurations of `surfaceHolder`.
      * @param surfaceHolder The `SurfaceHolder` object.
      * @order 6
+     *
      */
-    android_setSurfaceHolder(surfaceHolder: any): void;
+    android_setSurfaceHolder(surfaceHolder: $p_a.SurfaceHolder): void;
     
     /** {en}
      * @platform android
@@ -103,8 +138,9 @@ export declare class VeLivePlayer {
      *     If you call both setSurfaceHolder {@link #setSurfaceHolder} and `setSurface` to set the `Surface` object, the player will prioritize the configurations of `surfaceHolder`.
      * @param surface The `Surface` object.
      * @order 7
+     *
      */
-    android_setSurface(surface: any): void;
+    android_setSurface(surface: $p_a.Surface): void;
     
     /** {en}
      * @detail api
@@ -112,6 +148,7 @@ export declare class VeLivePlayer {
      * @notes <br>Call this method before calling play.
      * @order 8
      * @param url The pull stream address.
+     *
      */
     setPlayUrl(url: string): void;
     
@@ -121,6 +158,7 @@ export declare class VeLivePlayer {
      * @notes <br>Call this method before calling play.
      * @order 8
      * @param streamData Configurations for multiple pull stream addresses. For details, see VeLivePlayerStreamData {@link #VeLivePlayerStreamData}.
+     *
      */
     setPlayStreamData(streamData: VeLivePlayerStreamData): void;
     
@@ -130,6 +168,7 @@ export declare class VeLivePlayer {
      * @notes  <br>
      *     After you call this method, the onPlayerStatusUpdate {@link #VeLivePlayerObserver #onPlayerStatusUpdate} callback is triggered both when the player finishes preparing for stream pulling and when the first frame is rendered.
      * @order 8
+     *
      */
     play(): Promise<void>;
     
@@ -139,6 +178,7 @@ export declare class VeLivePlayer {
      * @notes  <br>
      *     When playback is paused after you call this method, the onPlayerStatusUpdate {@link #VeLivePlayerObserver #onPlayerStatusUpdate} callback is triggered.
      * @order 8
+     *
      */
     pause(): Promise<void>;
     
@@ -148,6 +188,7 @@ export declare class VeLivePlayer {
      * @notes  <br>
      *     When playback stops after you call this method, the onPlayerStatusUpdate {@link #VeLivePlayerObserver #onPlayerStatusUpdate} callback is triggered.
      * @order 8
+     *
      */
     stop(): Promise<void>;
     
@@ -155,22 +196,10 @@ export declare class VeLivePlayer {
      * @detail api
      * @brief Stops playback and destroys the player.
      * @order 8
+     *
      */
     destroy(): void;
     
-    /** {en}
-     * @detail api
-     * @brief Changes the video resolution.
-     * @notes - Call [setPlayStreamData](#VeLivePlayer-setplaystreamdata) to set multiple resolutions before calling this method.
-     *        - Once the player switches to the new resolution after you call this method, the [onResolutionSwitch](player-android-api-callback#VeLivePlayerObserver-onresolutionswitch) callback is triggered.
-     * @return <br>
-     *     - true: Success;
-     *     - false: Failure.
-     * @order 8
-     * @param resolution The video resolution. For details, refer to VeLivePlayerResolution {@link #VeLivePlayerResolution}.
-     */
-    switchResolution(resolution: VeLivePlayerResolution): void;
-    
     /** {en}
      * @detail api
      * @brief Checks whether the player is playing.
@@ -178,17 +207,10 @@ export declare class VeLivePlayer {
      *       - true: The player is playing;
      *       - false: The player is not playing.
      * @order 8
+     *
      */
     isPlaying(): boolean;
     
-    /** {en}
-     * @detail api
-     * @brief Sets the player volume.
-     * @param volume The volume. The default value is `1.0`. The value range is [0.0, 1.0].
-     * @order 8
-     */
-    setPlayerVolume(volume: number): void;
-    
     /** {en}
      * @detail api
      * @brief Sets whether to mute playback.
@@ -196,6 +218,7 @@ export declare class VeLivePlayer {
      *              - true: Mute;
      *              - false: Do not mute.
      * @order 9
+     *
      */
     setMute(mute: boolean): void;
     
@@ -206,6 +229,7 @@ export declare class VeLivePlayer {
      *      - true: Muted;
      *      - false: Not muted.
      * @order 10
+     *
      */
     isMute(): boolean;
     
@@ -214,8 +238,9 @@ export declare class VeLivePlayer {
      * @brief Sets the mapping of domain names to server IP addresses.
      * @param hostIpMap The mapping of domain names to server IP addresses. The `Map` object uses the domain name as the key, and the corresponding value is a list of IP addresses for the servers associated with that domain. The value is of the `List` type.
      * @order 11
+     *
      */
-    setUrlHostIP(hostIpMap: Record<string, Array<string>>): void;
+    setUrlHostIP(hostIpMap: Map<String, List<String>>): void;
     
     /** {en}
      * @detail api
@@ -223,6 +248,7 @@ export declare class VeLivePlayer {
      * @param key The parameter name of the advanced setting.
      * @param value The parameter value of the advanced setting.
      * @order 12
+     *
      */
     setProperty(key: string, value: Object): void;
     
@@ -236,6 +262,7 @@ export declare class VeLivePlayer {
      *         - 0: Screenshot capturing is allowed.
      *         - [VeLivePlayerErrorRefused](player-android-api-errorcode#VeLivePlayerErrorCode-veliveplayererrorrefused) : Screenshot capturing is not allowed.
      * @order 13
+     *
      */
     snapshot(): number;
     
@@ -252,13 +279,14 @@ export declare class VeLivePlayer {
      *       - After you call this method, the onRenderVideoFrame {@link #VeLivePlayerObserver #onRenderVideoFrame} callback is triggered once the SDK receives a video frame. The callback contains detailed information about the video frame.
      *       - If you use external rendering, you need to make sure the video and audio are synchronized.
      * @order 14
+     *
      */
     enableVideoFrameObserver(enable: boolean, pixelFormat: VeLivePlayerPixelFormat, bufferType: VeLivePlayerVideoBufferType): void;
     
     /** {en}
      * @detail api
      * @brief Sets the audio frame observer.
-     * @notes
+     * @notes <br>
      *        - You can call this method to subscribe to decoded audio data if you want to use external rendering.
      *        - After you call this method, the [onRenderAudioFrame](player-android-api-callback#VeLivePlayerObserver-onrenderaudioframe) callback is triggered once the SDK receives an audio frame. The callback contains detailed information about the audio frame.
      *        - If you use external rendering, you need to make sure the video and audio are synchronized.
@@ -269,6 +297,7 @@ export declare class VeLivePlayer {
      * @param enableRendering Whether to enable player rendering. The default value is `false`. <br>
      *                         - true: Enable;
      *                         - false: Disable.
+     *
      */
     enableAudioFrameObserver(enable: boolean, enableRendering: boolean): void;
     
@@ -281,6 +310,7 @@ export declare class VeLivePlayer {
      *       - Each time this method is called, the player rotates the video based on the original video.
      *       - When you apply both rotation and mirroring to the video, the player will mirror the video and then rotate it.
      * @order 16
+     *
      */
     setRenderRotation(rotation: VeLivePlayerRotation): Promise<void>;
     
@@ -293,6 +323,7 @@ export declare class VeLivePlayer {
      *       - Each time this method is called, the player applies the mirroring settings to the original video.
      *       - When you apply both rotation and mirroring to the video, the player will mirror the video and then rotate it.
      * @order 17
+     *
      */
     setRenderMirror(mirror: VeLivePlayerMirror): Promise<void>;
     
@@ -300,10 +331,11 @@ export declare class VeLivePlayer {
      * @detail api
      * @brief Enables or disables super resolution. You must first contact the BytePlus [technical support](https://www.byteplus.com/en/support) to activate the feature before using it.
      * @param enable Whether to enable super resolution.
-     * @notes
-     *      - Call this method after receiving the {@link #VeLivePlayerObserver#onFirstVideoFrameRender onFirstVideoFrameRender} callback, or during playback.
-     *      - If the SDK fails to enable super resolution due to device model, video resolution or frame rate, you will receive the {@link #VeLivePlayerObserver#onStreamFailedOpenSuperResolution onStreamFailedOpenSuperResolution} callback.
+     * @notes <br>
+     *      - Call this method after receiving the onFirstVideoFrameRender{@link #VeLivePlayerObserver#onFirstVideoFrameRender} callback, or during playback.
+     *      - If the SDK fails to enable super resolution due to device model, video resolution or frame rate, you will receive the onStreamFailedOpenSuperResolution{@link #VeLivePlayerObserver#onStreamFailedOpenSuperResolution} callback.
      * @order 18
+     *
      */
     setEnableSuperResolution(enable: boolean): void;
     
@@ -313,6 +345,7 @@ export declare class VeLivePlayer {
      * @param enable Set whether to enable video sharpening. The default value is `false`.
      *        - true: Enable;
      *        - false: Disable.
+     *
      */
     android_setEnableSharpen(enable: boolean): void;
     
@@ -321,61 +354,5 @@ export declare class VeLivePlayer {
      * @brief Initializes the specified type of player.
      * @param type The player type. Refer to [VeLivePlayerType](player-sdk-for-ios-api#VeLivePlayerType) for details.
      */
-    ios_initWithType(type: VeLivePlayerType): this;
-    
-    /** {en}
-     * @platform ios
-     * @hidden (iOS)
-     * @param item
-     */
-    ios_prepare(item: $p_i.TVLManager): void;
-}
-
-/** {en}
- * @platform ios
- * @brief Player Type.
- */
-export declare enum VeLivePlayerType {
-    
-    /** {en}
-     * @platform ios
-     * @brief Custom player.
-     */
-    VeLivePlayerTypeOwn = 0,
-    
-    /** {en}
-     * @platform ios
-     * @brief System player.
-     */
-    VeLivePlayerTypeSystem = 1
-}
-export declare class t_VeLivePlayerType {
-    static ts_to_android(value: VeLivePlayerType): never;
-    static android_to_ts(value: unknown): never;
-    static ts_to_ios(value: VeLivePlayerType): $p_i.VeLivePlayerType;
-    static ios_to_ts(value: $p_i.VeLivePlayerType): VeLivePlayerType;
-}
-/**
- * @platform ios
- * 直播特效模型类型
- */
-export declare enum VeLivePlayerEffectType {
-    
-    /** {en}
-     * @platform ios
-     * @hidden (iOS)
-     */
-    VeLivePlayerEffectUnknown = 0,
-    
-    /** {en}
-     * @platform ios
-     * @hidden (iOS)
-     */
-    VeLivePlayerEffectAudioBalance = 1
-}
-export declare class t_VeLivePlayerEffectType {
-    static ts_to_android(value: VeLivePlayerEffectType): never;
-    static android_to_ts(value: unknown): never;
-    static ts_to_ios(value: VeLivePlayerEffectType): $p_i.VeLivePlayerEffectType;
-    static ios_to_ts(value: $p_i.VeLivePlayerEffectType): VeLivePlayerEffectType;
+    ios_initWithType(type: $p_i.VeLivePlayerType): this;
 }

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

@@ -1,13 +1,10 @@
-import { VeLivePlayer } from './api';
-import { VeLivePlayerError } from './errorcode';
-import { VeLivePlayerResolution, VeLivePlayerResolutionSwitchReason, VeLivePlayerStreamType, VeLivePlayerStatus, VeLivePlayerStatistics, VeLivePlayerVideoFrame, VeLivePlayerAudioFrame } from './keytype';
 import * as $p_a from '../android/index';
 import * as $p_i from '../ios/index';
+import { VeLivePlayerResolution, VeLivePlayerResolutionSwitchReason, VeLivePlayerStreamType, VeLivePlayerStatus, VeLivePlayerStatistics, VeLivePlayerVideoFrame, VeLivePlayerAudioFrame } from './keytype';
+import { VeLivePlayer } from './api';
+import { VeLivePlayerError } from './errorcode';
+import { Bitmap } from './types';
 
-/** {en}
- * @detail callback
- * @brief The live player observer.
- */
 export interface VeLivePlayerObserver {
     
     /** {en}
@@ -16,6 +13,7 @@ export interface VeLivePlayerObserver {
      * @param player The player object that triggers the callback function.
      * @param error The error message. Refer to VeLivePlayerError {@link #VeLivePlayerError} for details.
      * @order 1
+     *
      */
     onError?(player: VeLivePlayer, error: VeLivePlayerError): void;
     
@@ -27,6 +25,7 @@ export interface VeLivePlayerObserver {
      *                      - true: The video frame is the first video frame rendered at the beginning of playback;
      *                      - false: The video frame is the first video frame rendered after a retry during playback.
      * @order 2
+     *
      */
     onFirstVideoFrameRender?(player: VeLivePlayer, isFirstFrame: boolean): void;
     
@@ -38,6 +37,7 @@ export interface VeLivePlayerObserver {
      *                      - true: The audio frame is the first audio frame rendered at the beginning of playback;
      *                      - false: The audio frame is the first audio frame rendered after a retry during playback.
      * @order 3
+     *
      */
     onFirstAudioFrameRender?(player: VeLivePlayer, isFirstFrame: boolean): void;
     
@@ -46,6 +46,7 @@ export interface VeLivePlayerObserver {
      * @brief Occurs when a playback stutter starts.
      * @param player The player object that triggers the callback function.
      * @order 4
+     *
      */
     onStallStart?(player: VeLivePlayer): void;
     
@@ -54,6 +55,7 @@ export interface VeLivePlayerObserver {
      * @brief Occurs when a playback stutter stops, that is, when playback resumes after there is enough audio buffer.
      * @param player The player object that triggers the callback function.
      * @order 5
+     *
      */
     onStallEnd?(player: VeLivePlayer): void;
     
@@ -63,6 +65,7 @@ export interface VeLivePlayerObserver {
      * @param player The player object that triggers the callback function.
      * @param stallTime The stutter duration, in milliseconds.
      * @order 6
+     *
      */
     onVideoRenderStall?(player: VeLivePlayer, stallTime: number): void;
     
@@ -72,6 +75,7 @@ export interface VeLivePlayerObserver {
      * @param player The player object that triggers the callback function.
      * @param stallTime The stutter duration, in milliseconds.
      * @order 7
+     *
      */
     onAudioRenderStall?(player: VeLivePlayer, stallTime: number): void;
     
@@ -83,6 +87,7 @@ export interface VeLivePlayerObserver {
      * @param error Whether an error occurred during resolution switching. See VeLivePlayerError {@link #VeLivePlayerError} for details.
      * @param reason The reason for resolution switching. See VeLivePlayerResolutionSwitchReason {@link #VeLivePlayerResolutionSwitchReason} for details.
      * @order 8
+     *
      */
     onResolutionSwitch?(player: VeLivePlayer, resolution: VeLivePlayerResolution, error: VeLivePlayerError, reason: VeLivePlayerResolutionSwitchReason): void;
     
@@ -93,6 +98,7 @@ export interface VeLivePlayerObserver {
      * @param width The updated width of the video, in pixels.
      * @param height The updated height of the video, in pixels.
      * @order 9
+     *
      */
     onVideoSizeChanged?(player: VeLivePlayer, width: number, height: number): void;
     
@@ -102,6 +108,7 @@ export interface VeLivePlayerObserver {
      * @param player The player object that triggers the callback function.
      * @param message The SEI message.
      * @order 10
+     *
      */
     onReceiveSeiMessage?(player: VeLivePlayer, message: string): void;
     
@@ -112,6 +119,7 @@ export interface VeLivePlayerObserver {
      * @param streamType The type of the updated stream. For details, see VeLivePlayerStreamType {@link #VeLivePlayerStreamType}.
      * @param error The reason for the switch. For details, see VeLivePlayerError {@link #VeLivePlayerError}.
      * @order 11
+     *
      */
     onMainBackupSwitch?(player: VeLivePlayer, streamType: VeLivePlayerStreamType, error: VeLivePlayerError): void;
     
@@ -121,6 +129,7 @@ export interface VeLivePlayerObserver {
      * @param player The player object that triggers the callback function.
      * @param status The updated status of the player. See VeLivePlayerStatus {@link #VeLivePlayerStatus} for details.
      * @order 12
+     *
      */
     onPlayerStatusUpdate?(player: VeLivePlayer, status: VeLivePlayerStatus): void;
     
@@ -130,17 +139,19 @@ export interface VeLivePlayerObserver {
      * @param player The player object that triggers the callback function.
      * @param statistics The playback statistics. For details, see VeLivePlayerStatistics {@link #VeLivePlayerStatistics}.
      * @order 13
+     *
      */
     onStatistics?(player: VeLivePlayer, statistics: VeLivePlayerStatistics): void;
     
     /** {en}
      * @detail callback
-     * @brief Occurs when a screenshot is taken after {@link #VeLivePlayer#snapshot snapshot} is called.
+     * @brief Occurs when a screenshot is taken after snapshot{@link #VeLivePlayer#snapshot} is called.
      * @param player The player object that triggers the callback function.
      * @param bitmap The Bitmap object of the screenshot.
      * @order 14
+     *
      */
-    onSnapshotComplete?(player: VeLivePlayer, bitmap: any): void;
+    onSnapshotComplete?(player: VeLivePlayer, bitmap: Bitmap): void;
     
     /** {en}
      * @detail callback
@@ -150,68 +161,71 @@ export interface VeLivePlayerObserver {
      * @order 15
      * @param player The player object that triggers the callback function.
      * @param videoFrame The video frame, including the pixel format, encapsulation format, width and height of the video, and other information. See VeLivePlayerVideoFrame {@link #VeLivePlayerVideoFrame} for details.
+     *
      */
     onRenderVideoFrame?(player: VeLivePlayer, videoFrame: VeLivePlayerVideoFrame): void;
     
     /** {en}
      * @detail callback
-     * @brief Occurs when the player decodes an audio frame. Call {@link #VeLivePlayer#enableAudioFrameObserver enableAudioFrameObserver} to enable audio frame callback.
+     * @brief Occurs when the player decodes an audio frame. Call enableAudioFrameObserver{@link #VeLivePlayer#enableAudioFrameObserver} to enable audio frame callback.
      * @param player The player object that triggers the callback function.
      * @param audioFrame The audio frame. See VeLivePlayerAudioFrame {@link #VeLivePlayerAudioFrame} for details.
      * @notes  <br>
      *      The audio data returned by the callback is of type Float32 and in big-endian byte order.
      * @order 16
+     *
      */
     onRenderAudioFrame?(player: VeLivePlayer, audioFrame: VeLivePlayerAudioFrame): void;
     
     /** {en}
      * @detail callback
-     * @brief Occurs when the SDK fails to enable super resolution after {@link #VeLivePlayer#setEnableSuperResolution setEnableSuperResolution} is called.
+     * @brief Occurs when the SDK fails to enable super resolution after setEnableSuperResolution{@link #VeLivePlayer#setEnableSuperResolution} is called.
      * @order 17
      * @param player The player object that triggers the callback function.
      * @param error The reason of the failure. See [VeLivePlayerErrorCode](player-android-api-errorcode#VeLivePlayerError-VeLivePlayerErrorCode) for details.
+     *
      */
     onStreamFailedOpenSuperResolution?(player: VeLivePlayer, error: VeLivePlayerError): void;
 }
 export declare class android_VeLivePlayerObserver extends $p_a.VeLivePlayerObserver {
     protected _instance: VeLivePlayerObserver;
     constructor(_instance: VeLivePlayerObserver);
-    onError(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerError): void;
-    onFirstVideoFrameRender(arg_0: $p_a.VeLivePlayer, arg_1: boolean): void;
-    onFirstAudioFrameRender(arg_0: $p_a.VeLivePlayer, arg_1: boolean): void;
-    onStallStart(arg_0: $p_a.VeLivePlayer): void;
-    onStallEnd(arg_0: $p_a.VeLivePlayer): void;
-    onVideoRenderStall(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.long): void;
-    onAudioRenderStall(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.long): void;
-    onResolutionSwitch(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerResolution, arg_2: $p_a.VeLivePlayerError, arg_3: $p_a.VeLivePlayerResolutionSwitchReason): void;
-    onVideoSizeChanged(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.int, arg_2: $p_a.int): void;
-    onReceiveSeiMessage(arg_0: $p_a.VeLivePlayer, arg_1: string): void;
-    onMainBackupSwitch(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerStreamType, arg_2: $p_a.VeLivePlayerError): void;
-    onPlayerStatusUpdate(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerStatus): void;
-    onStatistics(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerStatistics): void;
-    onSnapshotComplete(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.Bitmap): void;
-    onRenderVideoFrame(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerVideoFrame): void;
-    onRenderAudioFrame(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerAudioFrame): void;
-    onStreamFailedOpenSuperResolution(arg_0: $p_a.VeLivePlayer, arg_1: $p_a.VeLivePlayerError): void;
+    onError(player: $p_a.VeLivePlayer, error: $p_a.VeLivePlayerError): void;
+    onFirstVideoFrameRender(player: $p_a.VeLivePlayer, isFirstFrame: boolean): void;
+    onFirstAudioFrameRender(player: $p_a.VeLivePlayer, isFirstFrame: boolean): void;
+    onStallStart(player: $p_a.VeLivePlayer): void;
+    onStallEnd(player: $p_a.VeLivePlayer): void;
+    onVideoRenderStall(player: $p_a.VeLivePlayer, stallTime: $p_a.long): void;
+    onAudioRenderStall(player: $p_a.VeLivePlayer, stallTime: $p_a.long): void;
+    onResolutionSwitch(player: $p_a.VeLivePlayer, resolution: $p_a.VeLivePlayerResolution, error: $p_a.VeLivePlayerError, reason: $p_a.VeLivePlayerResolutionSwitchReason): void;
+    onVideoSizeChanged(player: $p_a.VeLivePlayer, width: $p_a.int, height: $p_a.int): void;
+    onReceiveSeiMessage(player: $p_a.VeLivePlayer, message: string): void;
+    onMainBackupSwitch(player: $p_a.VeLivePlayer, streamType: $p_a.VeLivePlayerStreamType, error: $p_a.VeLivePlayerError): void;
+    onPlayerStatusUpdate(player: $p_a.VeLivePlayer, status: $p_a.VeLivePlayerStatus): void;
+    onStatistics(player: $p_a.VeLivePlayer, statistics: $p_a.VeLivePlayerStatistics): void;
+    onSnapshotComplete(player: $p_a.VeLivePlayer, bitmap: $p_a.Bitmap): void;
+    onRenderVideoFrame(player: $p_a.VeLivePlayer, videoFrame: $p_a.VeLivePlayerVideoFrame): void;
+    onRenderAudioFrame(player: $p_a.VeLivePlayer, audioFrame: $p_a.VeLivePlayerAudioFrame): void;
+    onStreamFailedOpenSuperResolution(player: $p_a.VeLivePlayer, error: $p_a.VeLivePlayerError): void;
 }
 export declare class ios_VeLivePlayerObserver extends $p_i.VeLivePlayerObserver {
     protected _instance: VeLivePlayerObserver;
     constructor(_instance: VeLivePlayerObserver);
-    onError(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerError): void;
-    onFirstVideoFrameRender(arg_0: $p_i.TVLManager, arg_1: $p_i.BOOL): void;
-    onFirstAudioFrameRender(arg_0: $p_i.TVLManager, arg_1: $p_i.BOOL): void;
-    onStallStart(arg_0: $p_i.TVLManager): void;
-    onStallEnd(arg_0: $p_i.TVLManager): void;
-    onVideoRenderStall(arg_0: $p_i.TVLManager, arg_1: $p_i.int64_t): void;
-    onAudioRenderStall(arg_0: $p_i.TVLManager, arg_1: $p_i.int64_t): void;
-    onResolutionSwitch(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerResolution, arg_2: $p_i.VeLivePlayerError, arg_3: $p_i.VeLivePlayerResolutionSwitchReason): void;
-    onVideoSizeChanged(arg_0: $p_i.TVLManager, arg_1: $p_i.int, arg_2: $p_i.int): void;
-    onReceiveSeiMessage(arg_0: $p_i.TVLManager, arg_1: $p_i.NSString): void;
-    onMainBackupSwitch(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerStreamType, arg_2: $p_i.VeLivePlayerError): void;
-    onPlayerStatusUpdate(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerStatus): void;
-    onStatistics(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerStatistics): void;
-    onSnapshotComplete(arg_0: $p_i.TVLManager, arg_1: $p_i.UIImage): void;
-    onRenderVideoFrame(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerVideoFrame): void;
-    onRenderAudioFrame(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerAudioFrame): void;
-    onStreamFailedOpenSuperResolution(arg_0: $p_i.TVLManager, arg_1: $p_i.VeLivePlayerError): void;
+    onError$error(player: $p_i.TVLManager, error: $p_i.VeLivePlayerError): void;
+    onFirstVideoFrameRender$isFirstFrame(player: $p_i.TVLManager, isFirstFrame: $p_i.BOOL): void;
+    onFirstAudioFrameRender$isFirstFrame(player: $p_i.TVLManager, isFirstFrame: $p_i.BOOL): void;
+    onStallStart(player: $p_i.TVLManager): void;
+    onStallEnd(player: $p_i.TVLManager): void;
+    onVideoRenderStall$stallTime(player: $p_i.TVLManager, stallTime: $p_i.int64_t): void;
+    onAudioRenderStall$stallTime(player: $p_i.TVLManager, stallTime: $p_i.int64_t): void;
+    onResolutionSwitch$resolution$error$reason(player: $p_i.TVLManager, resolution: $p_i.VeLivePlayerResolution, error: $p_i.VeLivePlayerError, reason: $p_i.VeLivePlayerResolutionSwitchReason): void;
+    onVideoSizeChanged$width$height(player: $p_i.TVLManager, width: $p_i.int, height: $p_i.int): void;
+    onReceiveSeiMessage$message(player: $p_i.TVLManager, message: $p_i.NSString): void;
+    onMainBackupSwitch$streamType$error(player: $p_i.TVLManager, streamType: $p_i.VeLivePlayerStreamType, error: $p_i.VeLivePlayerError): void;
+    onPlayerStatusUpdate$status(player: $p_i.TVLManager, status: $p_i.VeLivePlayerStatus): void;
+    onStatistics$statistics(player: $p_i.TVLManager, statistics: $p_i.VeLivePlayerStatistics): void;
+    onSnapshotComplete$image(player: $p_i.TVLManager, image: $p_i.UIImage): void;
+    onRenderVideoFrame$videoFrame(player: $p_i.TVLManager, videoFrame: $p_i.VeLivePlayerVideoFrame): void;
+    onRenderAudioFrame$audioFrame(player: $p_i.TVLManager, audioFrame: $p_i.VeLivePlayerAudioFrame): void;
+    onStreamFailedOpenSuperResolution$error(player: $p_i.TVLManager, error: $p_i.VeLivePlayerError): void;
 }