/**
  * 初始化 SDK 环境
  * 必须在 Application 中调用此方法进行环境的初始化，否则在创建 MediaStreamingManager 的时候会抛异常
  *
  * @param context Application 上下文
  * @param userId 用户唯一标识符，用于区分不同的用户
  */
public static void init(Context context, String userId)

/**
  * 初始化 SDK 环境
  * 必须在 Application 中调用此方法进行环境的初始化，否则在创建 MediaStreamingManager 的时候会抛异常
  *
  * @param context Application 上下文
  */
@Deprecated
public static void init(Context context)

/**
  * 检查当前鉴权状态
  *
  * @param callback 鉴权结果回调
  */
public static void checkAuthentication(PLAuthenticationResultCallback callback)

/**
  * 回调当前的鉴权状态
  *
  * @param result 鉴权状态。包括：UnCheck(-1)、UnAuthorized(0)、Authorized(1)
  */
void onAuthorizationResult(int result);

/**
  * 设置 SDK 日志等级
  *
  * @param level 日志等级。包括：VERBOSE、DEBUG、INFO、WARN、ERROR 以及 ASSERT
  */
public static void setLogLevel(int level)

/**
  * 开启本地日志的保存，默认为关闭状态
  */
public static void setLogfileEnabled(boolean enabled);

/**
  * 设置日志保存的最大文件个数，默认为 3
  */
public static void setLogFileMaxCount(int maxCount);

/**
 * 获取当前的日志存储目录
 *
 * @return 日志存储目录
 */
public static String getLogFilePath();

/**
  * 上报本地日志，上报结果会通过 FileLogHelper.LogReportCallback 返回
  */
public static void reportLogFiles(FileLogHelper.LogReportCallback callback);

/**
  * 更新 UserID
  *
  * @param userId 用户唯一标识符，用于区分不同的用户
  */
public static void updateUid(String uid)

mCameraStreamingSetting.setCameraId(Camera.CameraInfo.CAMERA_FACING_FRONT); // 前置摄像头
mCameraStreamingSetting.setCameraId(Camera.CameraInfo.CAMERA_FACING_BACK); // 后置摄像头

mCameraStreamingSetting.setContinuousFocusModeEnabled(false);

- CameraStreamingSetting.FOCUS_MODE_CONTINUOUS_PICTURE // 自动对焦（Picture）
- CameraStreamingSetting.FOCUS_MODE_CONTINUOUS_VIDEO   // 自动对焦（Video）
- CameraStreamingSetting.FOCUS_MODE_AUTO               // 手动对焦

mCameraStreamingSetting.setFocusMode(CameraStreamingSetting.FOCUS_MODE_CONTINUOUS_PICTURE);
mCameraStreamingSetting.setFocusMode(CameraStreamingSetting.FOCUS_MODE_CONTINUOUS_VIDEO);
mCameraStreamingSetting.setFocusMode(CameraStreamingSetting.FOCUS_MODE_AUTO);

mCameraStreamingSetting.setResetTouchFocusDelayInMs(3000); // 单位毫秒

CameraStreamingSetting setting = new CameraStreamingSetting();
setting.setRecordingHint(false);

boolean isMirror = xxx; // false as default
mCameraStreamingSetting.setFrontCameraMirror(isMirror);

mMicrophoneStreamingSetting.setSampleRate(16000);

mMicrophoneStreamingSetting.setChannelConfig(AudioFormat.CHANNEL_IN_STEREO);

mMicrophoneStreamingSetting.setBluetoothSCOEnabled(true);

mMicrophoneStreamingSetting.setAECEnabled(true);

mStreamingProfile.setVideoQuality(StreamingProfile.VIDEO_QUALITY_MEDIUM1);

mStreamingProfile.setAudioQuality(StreamingProfile.AUDIO_QUALITY_HIGH1);

// audio sample rate is 44100, audio bitrate is 48 * 1024 bps
StreamingProfile.AudioProfile aProfile = new StreamingProfile.AudioProfile(44100, 48 * 1024);

// fps is 20, video bitrate is 1000 * 1024 bps, maxKeyFrameInterval is 60, profile is HIGH
StreamingProfile.VideoProfile vProfile = new StreamingProfile.VideoProfile(20, 1000 * 1024, 60, StreamingProfile.H264Profile.HIGH);

StreamingProfile.AVProfile avProfile = new StreamingProfile.AVProfile(vProfile, aProfile);

mStreamingProfile.setAVProfile(avProfile)

StreamingProfile.AudioProfile aProfile = new StreamingProfile.AudioProfile(44100, 48 * 1024);
StreamingProfile.VideoProfile vProfile = new StreamingProfile.VideoProfile(20, 1000 * 1024, 60);
StreamingProfile.AVProfile avProfile = new StreamingProfile.AVProfile(vProfile, aProfile);

mStreamingProfile.setAVProfile(avProfile)
                .setVideoQuality(StreamingProfile.VIDEO_QUALITY_MEDIUM1) // |30|512|90|
                .setAudioQuality(StreamingProfile.AUDIO_QUALITY_HIGH1);  // |96|44100|

public static DnsManager getMyDnsManager() {
    IResolver[] resolvers = new IResolver[2];
    // 配置自定义 DNS 服务器地址
    String[] udpDnsServers = new String[]{"223.5.5.5"};
    resolvers[0] = new DnsUdpResolver(udpDnsServers, Record.TYPE_A, DNS_DEFAULT_TIMEOUT);
    // 配置 HTTPDNS 地址
    String[] httpDnsServers = new String[]{"https://223.6.6.6/dns-query"};
    resolvers[1] = new DohResolver(httpDnsServers, Record.TYPE_A, DNS_DEFAULT_TIMEOUT);
    return new DnsManager(NetworkInfo.normal, resolvers);
}

StreamingProfile mProfile = new StreamingProfile();
mStreamingProfile.setDnsManager(getMyDnsManager()); // 设置自定义 DnsManager

mStreamingProfile.setEncoderRCMode(StreamingProfile.EncoderRCModes.QUALITY_PRIORITY);

mStreamingProfile#setStreamStatusConfig(new StreamingProfile.StreamStatusConfig(3)); // 单位为秒

mProfile.setEncodingOrientation(StreamingProfile.ENCODING_ORIENTATION.PORT);
mMediaStreamingManager.setStreamingProfile(mProfile); // notify MediaStreamingManager that StreamingProfile had been changed.

setRequestedOrientation(isEncOrientationPort ? ActivityInfo.SCREEN_ORIENTATION_PORTRAIT : ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
mMediaStreamingManager.notifyActivityOrientationChanged();

android:configChanges="orientation|screenSize"

/**
 * adaptive bitrate adjust mode
 */
public enum BitrateAdjustMode {
    Auto,   // SDK 自适应码率调节
    Manual, // 用户自己实现码率调节, 范围：10kbps~10Mbps
    Disable // 关闭码率调节
}

mProfile.setBitrateAdjustMode(StreamingProfile.BitrateAdjustMode.Auto);

/**
 * Sets the range value of video adaptive bitrate.
 *
 * @param minBitrate min bitrate, unit: bps
 * @param maxBitrate max bitrate, unit: bps
 * */
public StreamingProfile setVideoAdaptiveBitrateRange(int minBitrate, int maxBitrate)

/**
 * filter mode for libyuv
 */
public enum YuvFilterMode {
    None,        // Point sample; Fastest.
    Linear,      // Filter horizontally only.
    Bilinear,    // Faster than box, but lower quality scaling down.
    Box          // Highest quality.
}

/**
 * Sets the YUV filter mode
 * @param mode the {@link YuvFilterMode}, default: {@link YuvFilterMode#None}
 * @return this
 */
public StreamingProfile setYuvFilterMode(YuvFilterMode mode)

 /**
  * 开启/关闭 SRT 协议传输
  *
  * @param enabled 开启/关闭 (true / false)
  * @return this
  */
public StreamingProfile setSrtEnabled(boolean enabled)

srt://pili-publish.qnsdk.com?streamid=#!::h=sdk-live/xxx,m=publish

/**
 * 视频编码格式
 */
public enum PLVideoEncodeType {
    H264,  // H.264 编码格式
    HEVC   // H.265 编码格式
}

/**
 * 设置视频编码格式
 *
 * @param videoEncodeType 视频编码格式
 * @return this
 */
public StreamingProfile setVideoEncodeType(PLVideoEncodeType videoEncodeType)

private StreamingStateChangedListener mStreamingStateChangedListener = new StreamingStateChangedListener() {
  @Override
  public void onStateChanged(StreamingState streamingState, final Object extra) {
      case VIDEO_ENCODER_READY:
        // 编码器初始化完成，编码类型为 ((PLVideoEncodeType) extra).name())
        break;
    });
  }
};

public enum WATERMARK_LOCATION {
    NORTH_WEST,
    NORTH_EAST,
    SOUTH_WEST,
    SOUTH_EAST,
}

/**
 * define de relative size of watermark
 */
 public enum WATERMARK_SIZE {
     LARGE,
     MEDIUM,
     SMALL,
 }

WatermarkSetting watermarksetting = new WatermarkSetting(mContext, R.drawable.qiniu_logo, WatermarkSetting.WATERMARK_LOCATION.SOUTH_WEST, WatermarkSetting.WATERMARK_SIZE.MEDIUM, 100); // 100 为 alpha 值

WatermarkSetting watermarksetting = WatermarkSetting(mContext, "watermark resource absolute path", WatermarkSetting.WATERMARK_LOCATION.SOUTH_WEST, WatermarkSetting.WATERMARK_SIZE.MEDIUM, 100) {

- AVCodecType.HW_VIDEO_WITH_HW_AUDIO_CODEC, // 视频硬编，音频硬编
- AVCodecType.SW_VIDEO_WITH_HW_AUDIO_CODEC, // 视频软编，音频硬编
- AVCodecType.SW_VIDEO_WITH_SW_AUDIO_CODEC, // 视频软编，音频软编
- AVCodecType.SW_AUDIO_CODEC,               // 纯音频软编
- AVCodecType.HW_AUDIO_CODEC,               // 纯音频硬编
- AVCodecType.SW_VIDEO_CODEC,               // 纯视频软编
- AVCodecType.HW_VIDEO_CODEC;               // 纯视频硬编

mMediaStreamingManager = new MediaStreamingManager(mContext, mGLSurfaceView, EncodingType.SW_VIDEO_WITH_SW_AUDIO_CODEC);

mMediaStreamingManager.prepare(mCameraStreamingSetting, mMicrophoneStreamingSetting, mWatermarkSetting, mProfile);

mMediaStreamingManager.setStreamingStateListener(this);
mMediaStreamingManager.setStreamingSessionListener(this);
mMediaStreamingManager.setStreamStatusCallback(this);

/**
 * Callback interface for Streaming State.
 * <p>
 *
 * Called on an "arbitrary thread".
 *
 * */
public interface StreamingStateChangedListener {
    /**
     * Invoked if the {@link StreamingState} changed
     *
     * @param status the specified {@link StreamingState}
     * @param extra the extra information
     * */
    void onStateChanged(StreamingState status, Object extra);
}

public enum StreamingState {
    /**
     * The initial state.
     *
     * */
    UNKNOWN,

    /**
     * Preparing the environment for network connection.
     * <p>
     * The first state after calling {@link StreamingManager#startStreaming()}
     *
     * */
    PREPARING,

    /**
     * <ol>
     *     <li>{@link StreamingManager#resume()} done in pure audio streaming</li>
     *     <li>{@link StreamingManager#resume()} done and camera be activated in AV streaming.</li>
     * </ol>
     * */
    READY,

    /**
     * Being connecting.
     *
     * */
    CONNECTING,

    /**
     * The av datas start sending successfully.
     *
     * */
    STREAMING,

    /**
     * Streaming has been finished, and you can {@link StreamingManager#startStreaming()} again.
     *
     * */
    SHUTDOWN,

    /**
     * Connect error.
     *
     * The following is the possible case:
     *
     * <ol>
     *     <li>Stream is invalid</li>
     *     <li>Network is unreachable</li>
     * </ol>
     *
     * */
    IOERROR,

    /**
     * Notify the camera switched.
     * <p>
     * extra will including the info the new camera id.
     *
     * <ol>
     *     <li>Camera.CameraInfo.CAMERA_FACING_FRONT</li>
     *     <li>Camera.CameraInfo.CAMERA_FACING_BACK</li>
     * </ol>
     *
     * <pre>
     *     <code>
     *         Log.i(TAG, "current camera id:" + (Integer)extra);
     *     </code>
     * </pre>
     * */
    CAMERA_SWITCHED,

    /**
     * Notify the torch info after camera be active.
     * <p>
     * extra will including the info if the device support the Torch.
     *
     * <ol>
     *     <li>true, supported</li>
     *     <li>false, unsupported</li>
     * </ol>
     *
     * <pre>
     *     <code>
     *         final boolean isSupportedTorch = (Boolean) extra;
     *     </code>
     * </pre>
     *
     * */
    TORCH_INFO,

    /**
     * Sending buffer is empty.
     *
     * */
    SENDING_BUFFER_EMPTY,

    /**
     * Sending buffer have been full.
     *
     * */
    SENDING_BUFFER_FULL,

    /**
     * Sending buffer have few items witch waiting to be sent.
     *
     * */
    SENDING_BUFFER_HAS_FEW_ITEMS,

    /**
     * Sending buffer have many items witch waiting to be sent.
     *
     * */
    SENDING_BUFFER_HAS_MANY_ITEMS,

    /**
     * The network connection has been broken.
     *
     * */
    DISCONNECTED,

    /**
     * if the device hasn't the supported preview size, then it will select the default preview
     * size which mismatch the specified {@link CameraStreamingSetting.PREVIEW_SIZE_RATIO}.
     *
     * */
    NO_SUPPORTED_PREVIEW_SIZE,

    /**
     * {@link AudioRecord#startRecording()} failed.
     *
     * */
    AUDIO_RECORDING_FAIL,

    /**
     * camera open failed.
     *
     * */
    OPEN_CAMERA_FAIL,

    /**
     * Do not support NV21 preview format.
     *
     * */
    NO_NV21_PREVIEW_FORMAT,
    
    /**
     * start video encoder success
     */
    VIDEO_ENCODER_READY,
    
    /**
     * start video encoder failed
     */
    START_VIDEO_ENCODER_FAIL,

    /**
     * video encoder error happened
     */
    VIDEO_ENCODER_ERROR,

    /**
     * start audio encoder failed
     */
    START_AUDIO_ENCODER_FAIL,

    /**
     * video encoder error happened
     */
    AUDIO_ENCODER_ERROR,

    /**
     * Invalid streaming url.
     *
     * Gets the message after call {@link StreamingManager#setStreamingProfile(StreamingProfile)} if streaming
     * url is invalid. Also gets the url as the extra info.
     * */
    INVALID_STREAMING_URL,

    /**
     * The network had been built successfully.
     *
     * */
    CONNECTED,

    /**
     * Invalid streaming url.
     *
     * Gets the message after call {@link MediaStreamingManager#setStreamingProfile(StreamingProfile)} if streaming
     * url is invalid. Also gets the url as the extra info.
     * */
    UNAUTHORIZED_STREAMING_URL,
}

/**
 * Callback interface for some particular Streaming incidents.
 * <p>
 *
 * Called on an "arbitrary thread".
 *
 * */
public interface StreamingSessionListener {
    /**
     * Invoked when audio recording failed.
     * <p>
     *
     * @param code error code. <b>Unspecified now</b>.
     *
     * @return true means you handled the event; otherwise, given up.
     *
     * */
    boolean onRecordAudioFailedHandled(int code);

    /**
     * Restart streaming notification.
     * <p>
     *
     * When the network-connection is broken, {@link StreamingState#DISCONNECTED} will notified first,
     * and then invoked this method if the environment of restart streaming is ready.
     *
     * <p>
     * SDK won't limit the number of invocation.
     *
     * @param code error code. <b>Unspecified now</b>.
     *
     * @return true means you handled the event; otherwise, given up and then {@link StreamingState#SHUTDOWN}
     *              will be notified.
     *
     * */
    boolean onRestartStreamingHandled(int code);

    /**
     * Invoked after camera object constructed.
     * <p>
     * The supported list exists in following cases:
     * <ol>
     *     <li>If didn't set the
     *     {@link CameraStreamingSetting#setCameraPrvSizeRatio} when
     *     initialize {@link CameraStreamingSetting},
     *     the whole supported list would be passed</li>
     *     <li>If {@link CameraStreamingSetting#setCameraPrvSizeRatio}
     *     was set, the supported preview size which filtered by the specified ratio would be passed</li>
     * </ol>
     *
     * @param list supported camera preview list which sorted from smallest to largest. The list maybe null.
     *
     * @return null means you give up selection and SDK will help you select a proper preview
     *          size; otherwise, the returned size will be effective.
     *
     * */
    Camera.Size onPreviewSizeSelected(List<Camera.Size> list);
    
    /**
     * Custom preview fps, invoked after camera object constructed.
     *
     * @param  supportedPreviewFpsRange
     *         a list of supported preview fps ranges by Camera. This method returns a
     *         list with at least one element. Every element is an int array
     *         of two values - minimum fps and maximum fps.
     * @return -1 means you give up selection and SDK will help you select a proper preview
     *          fps; otherwise, the returned index will be effective.
     */
    int onPreviewFpsSelected(final List<int[]> supportedPreviewFpsRange);
}

@Override
public boolean onRecordAudioFailedHandled(int err) {
    mMediaStreamingManager.updateEncodingType(AVCodecType.SW_VIDEO_CODEC);
    mMediaStreamingManager.startStreaming();
    return true;
}

@Override
public boolean onRestartStreamingHandled(int err) {
    return mMediaStreamingManager.startStreaming();
}

@Override
public Camera.Size onPreviewSizeSelected(List<Camera.Size> list) {
    if (list != null) {
        for (Camera.Size s : list) {
            Log.i(TAG, "w:" + s.width + ", h:" + s.height);
        }
//            return "your choice";
    }
    return null;
}

/**
 * Callback interface used to notify {@link StreamingProfile.StreamStatus}.
 */
public interface StreamStatusCallback {

   /**
    * Called per the {@link StreamingProfile.StreamStatusConfig#getIntervalMs}
    *
    * @param status the new {@link StreamingProfile.StreamStatus}
    *
    * */
    void notifyStreamStatusChanged(final StreamingProfile.StreamStatus status);
}

/**
 * The nested class is for feedbacking the av status in real time.
 *
 * <p>
 * You can set the {@link StreamStatusConfig} to get the preferred callback frequency.
 *
 * */
public static class StreamStatus {
    /**
     * Audio frame per second.
     * */
    public int audioFps;

    /**
     * Video frame per second.
     * */
    public int videoFps;

    /**
     * Audio and video total bits per second.
     * */
    public int totalAVBitrate;  // bps

    /**
     * Audio bits per second.
     * */
    public int audioBitrate;  // bps

    /**
     * Video bits per second.
     * */
    public int videoBitrate;  // bps
  
    /**
     * Number of dropped video frames in callback period.
     * */
    public int droppedVideoFrames;
}

mMediaStreamingManager.resume();

mMediaStreamingManager.startStreaming();

// You should call this after getting {@link STATE#READY}.
mMediaStreamingManager.setFocusAreaIndicator(mRotateLayout,
                    mRotateLayout.findViewById(R.id.focus_indicator));

// You should call this after getting {@link STATE#READY}.
mMediaStreamingManager.doSingleTapUp((int) e.getX(), (int) e.getY());

// mCurrentZoom must be in the range of [0, mMediaStreamingManager.getMaxZoom()]
// You should call this after getting {@link STATE#READY}.
if (mMediaStreamingManager.isZoomSupported()) {
  mMediaStreamingManager.setZoomValue(mCurrentZoom);
}

mMediaStreamingManager.getZoom();

mMediaStreamingManager.turnLightOn();

mMediaStreamingManager.turnLightOff();

mMediaStreamingManager.switchCamera();

mMediaStreamingManager.getPreviewFpsRange();

mMediaStreamingManager.mute(true);

mMediaStreamingManager.mute(false);

mMediaStreamingManager.captureFrame(w, h, new FrameCapturedCallback() {
    @Override
    public void onFrameCaptured(Bitmap bmp) {

    }
}

mMediaStreamingManager.stopStreaming();

mMediaStreamingManager.setNativeLoggingEnabled(false);

mMediaStreamingManager.pause();

mMediaStreamingManager.destroy();

// 注册音频采集数据回调
mMediaStreamingManager.setAudioSourceCallback(AudioSourceCallback callback)；

public interface AudioSourceCallback {
	/**
	 * 回调音频采集 PCM 数据
	 *
	 * @param srcBuffer     音频 PCM数据，该 buffer 是 direct ByteBuffer。
	 * @param size          buffer的大小
	 * @param tsInNanoTime  时间戳，单位：纳秒
	 * @param isEof         采集结束标志
	 */
	void onAudioSourceAvailable(ByteBuffer srcBuffer, int size, long tsInNanoTime, boolean isEof);
}

WatermarkSetting watermarkSetting = new WatermarkSetting(context);
watermarkSetting.setResourceId(R.drawable.qiniu_logo);
watermarkSetting.setAlpha(50);
watermarkSetting.setSize(WatermarkSetting.WATERMARK_SIZE.LARGE);
watermarkSetting.setLocation(WatermarkSetting.WATERMARK_LOCATION.SOUTH_EAST);

mMediaStreamingManager.updateWatermarkSetting(newWatermarkSetting);

/**
  * 发送 SEI 信息
  *
  * @param msg SEI 信息内容
  * @param repeatCount SEI 信息需要发送的次数
  */
public void sendSEIMessage(String msg, int repeatCount);

/**
  * 发送 SEI 信息
  *
  * @param msg SEI 信息内容
  * @param repeatCount SEI 信息需要发送的次数
  * @param timestampNs SEI 信息需要展示的时间
  */
public void sendSEIMessage(String msg, int repeatCount, long timestampNs)

mMediaStreamingManager.setPreviewMirror(boolean mirror)

mMediaStreamingManager.setEncodingMirror(boolean mirror)

        mAudioMixer = mMediaStreamingManager.getAudioMixer();
        mAudioMixer.setOnAudioMixListener(new OnAudioMixListener() {
            @Override
            public void onStatusChanged(MixStatus mixStatus) {
                mMixToggleBtn.post(new Runnable() {
                    @Override
                    public void run() {
                        ...
                    }
                });
            }

            @Override
            public void onProgress(long progress, long duration) {
                // time in Us
            }
        });
        mAudioFile = Cache.getAudioFile(this); // 背景音乐文件路径
        if (mAudioFile != null) {
            try {
                mAudioMixer.setFile(mAudioFile, true); // true/false 是否循环
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        boolean s = mAudioMixer.play();
        text = s ? "mixing play success" : "mixing play failed !!!";

 mMediaStreamingManager.startPlayback();
 mMediaStreamingManager.stopPlayback();

mProfile.setQuicEnable(quicEnable);

mProfile.setSrtEnabled(enabled);

mProfile.setPictureStreamingFilePath(mPicStreamingFilePath);
或
mProfile.setPictureStreamingResourceId(R.drawable.pause_publish);

mMediaStreamingManager.setPictureStreamingFilePath(mPicStreamingFilePath);
或
mMediaStreamingManager.setPictureStreamingResourceId(R.drawable.qiniu_logo);

/**
  * 设置图片推流的帧率
  * 
  * @param fps 帧率，仅支持 0-30 的配置
  */
public void setPictureStreamingFps(float fps)

mProfile.setPictureStreamingFps(10);

/**
  * 切换图片推流。如果当前正在推图片，则停止图片推流，开启音视频推流；反之，则停止音视频推流，开启图片推流
  */
public boolean togglePictureStreaming()

boolean isOK = mMediaStreamingManager.togglePictureStreaming();

public interface StreamingPreviewCallback {
    public boolean onPreviewFrame(byte[] bytes, int width, int height, int rotation, int fmt, long tsInNanoTime);
}

public interface SurfaceTextureCallback {
    void onSurfaceCreated();
    void onSurfaceChanged(int width, int height);
    void onSurfaceDestroyed();
    int onDrawFrame(int texId, int width, int height);
}

<activity
    android:name="com.qiniu.pili.droid.streaming.screen.ScreenCaptureRequestActivity"
    android:theme="@android:style/Theme.Translucent.NoTitleBar" >
</activity>

// 构造 ScreenStreamingManager
ScreenStreamingManager screenStreamingManager = new ScreenStreamingManager();

// 配置相关参数
screenStreamingManager.prepare(context, screenSetting, null, streamingProfile);

// 开始推流
screenStreamingManager.startStreaming();

// 停止推流
screenStreamingManager.stopStreaming();

// 销毁
screenStreamingManager.destroy();

screenStreamingManager.setNotification(customNotificationId, customNotification);

screenStreamingManager.notifyNotification()

// 注册音频采集数据回调
screenStreamingManager.setAudioSourceCallback(AudioSourceCallback callback)；

public interface AudioSourceCallback {
	/**
	 * 回调音频采集 PCM 数据
	 *
	 * @param srcBuffer     音频 PCM数据，该 buffer 是 direct ByteBuffer。
	 * @param size          buffer的大小
	 * @param tsInNanoTime  时间戳，单位：纳秒
	 * @param isEof         采集结束标志
	 */
	void onAudioSourceAvailable(ByteBuffer srcBuffer, int size, long tsInNanoTime, boolean isEof);
}

mStreamingManager.startStreaming();

mStreamingManager.stopStreaming();

/**
  * 发送 SEI 信息
  *
  * @param msg 信息内容
  * @param repeatCount 信息重复次数
  */
public void sendSEIMessage(String msg, int repeatCount)

/**
  * 发送带有时间戳的 SEI 信息
  *
  * @param msg 信息内容
  * @param repeatCount 信息重复次数
  * @param timestampNs 信息显示时间
  */
public void sendSEIMessage(String msg, int repeatCount, long timestampNs)