CNLive Android Team / CNStreamDemo · Files

package com.cnlive.demo.stream;

import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.opengl.GLSurfaceView;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
import android.support.v4.app.ActivityCompat;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.CheckBox;
import android.widget.Chronometer;
import android.widget.CompoundButton;
import android.widget.TextView;
import android.widget.Toast;

import com.cnlive.libs.stream.Streamer;
import com.cnlive.libs.stream.base.IStreamer;
import com.cnlive.libs.stream.model.ActivityConfig;

import static com.cnlive.libs.stream.base.IStreamer.ENCODE_METHOD_HARDWARE;
import static com.cnlive.libs.stream.base.IStreamer.VIDEO_RESOLUTION_360P;
import static com.cnlive.libs.stream.model.Filters.BEAUTY_DISABLE;
import static com.cnlive.libs.stream.model.Filters.BEAUTY_ILLUSION;
import static com.cnlive.libs.stream.model.Filters.BEAUTY_SMOOTH;
import static com.cnlive.libs.stream.model.Filters.BEAUTY_SOFT;
import static com.cnlive.libs.stream.model.Filters.DENOISE;
import static com.cnlive.libs.stream.model.Filters.SKIN_WHITEN;

/**
 * Created by Administrator on 2016/8/29.
 * StreamActivity 本 Activity主要展示的是推流SDK的具体用法，包括视讯云的逻辑和推流的设置，如果只想了解视讯云的逻辑，请参考CNStreamActivity
 */
public class StreamActivity extends Activity {
    private static final String TAG = "StreamActivity";

    private GLSurfaceView mCameraPreviewView;
    private CameraHintView mCameraHintView;
    private Chronometer mChronometer;
    private View mDeleteView;
    private View mSwitchCameraView;
    private View mFlashView;
    private TextView mShootingText;
    private CheckBox mWaterMarkCheckBox;
    private CheckBox mBeautyCheckBox;
    private CheckBox mAudioPreviewCheckBox;
    private CheckBox mBgmCheckBox;
    private CheckBox mMuteCheckBox;
    private CheckBox mAudioOnlyCheckBox;
    private CheckBox mFrontMirrorCheckBox;

    private ButtonObserver mObserverButton;
    private CheckBoxObserver mCheckBoxObserver;

    private Streamer mStreamer;
    private Handler mMainHandler;

    private boolean mIsLandscape;
    private boolean mRecording = false;
    private boolean isFlashOpened = false;
    private String mBgmPath = "/sdcard/test.mp3";
    private String mLogoPath = "file:///sdcard/cnlive_logo.png";

    private String activityId;
    private String channelId;

    private int isHorizontalScreen = 0;

    private final static int PERMISSION_REQUEST_CAMERA_AUDIOREC = 1;
    private static final String START_STRING = "开始直播";
    private static final String STOP_STRING = "停止直播";

    public static final String ACTIVITYID = "activityId";
    public static final String CHANNELID = "channelId";
    public final static String LANDSCAPE = "landscape";

    public static void startActivity(Context context,
                                     String activityID,
                                     String channelID,
                                     boolean isLandscape) {
        Intent intent = new Intent(context, StreamActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.putExtra(ACTIVITYID, activityID);
        intent.putExtra(CHANNELID, channelID);
        intent.putExtra(LANDSCAPE, isLandscape);
        context.startActivity(intent);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);

        setContentView(R.layout.activity_stream);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        initView();

        mMainHandler = new Handler();
        Bundle bundle = getIntent().getExtras();
        activityId = bundle.getString(ACTIVITYID);
        channelId = bundle.getString(CHANNELID);
        mIsLandscape = bundle.getBoolean(LANDSCAPE, false);
        initStreamer();

    }

    private void initView() {
        mCameraHintView = (CameraHintView) findViewById(R.id.camera_hint);
        mCameraPreviewView = (GLSurfaceView) findViewById(R.id.camera_preview);
        mChronometer = (Chronometer) findViewById(R.id.chronometer);

        mObserverButton = new ButtonObserver();
        //开始/结束推流按钮
        mShootingText = (TextView) findViewById(R.id.click_to_shoot);
        mShootingText.setOnClickListener(mObserverButton);
        //返回按钮
        mDeleteView = findViewById(R.id.backoff);
        mDeleteView.setOnClickListener(mObserverButton);
        //转换摄像头
        mSwitchCameraView = findViewById(R.id.switch_cam);
        mSwitchCameraView.setOnClickListener(mObserverButton);
        //闪光灯
        mFlashView = findViewById(R.id.flash);
        mFlashView.setOnClickListener(mObserverButton);
        mCheckBoxObserver = new CheckBoxObserver();
        //美艳
        mBeautyCheckBox = (CheckBox) findViewById(R.id.click_to_switch_beauty);
        mBeautyCheckBox.setOnCheckedChangeListener(mCheckBoxObserver);
        //背景音乐
        mBgmCheckBox = (CheckBox) findViewById(R.id.bgm);
        mBgmCheckBox.setOnCheckedChangeListener(mCheckBoxObserver);
        //耳返
        mAudioPreviewCheckBox = (CheckBox) findViewById(R.id.ear_mirror);
        mAudioPreviewCheckBox.setOnCheckedChangeListener(mCheckBoxObserver);
        //静音
        mMuteCheckBox = (CheckBox) findViewById(R.id.mute);
        mMuteCheckBox.setOnCheckedChangeListener(mCheckBoxObserver);
        //水印
        mWaterMarkCheckBox = (CheckBox) findViewById(R.id.watermark);
        mWaterMarkCheckBox.setOnCheckedChangeListener(mCheckBoxObserver);
        //前置摄像头镜像
        mFrontMirrorCheckBox = (CheckBox) findViewById(R.id.front_camera_mirror);
        mFrontMirrorCheckBox.setOnCheckedChangeListener(mCheckBoxObserver);
        //纯音频推流
        mAudioOnlyCheckBox = (CheckBox) findViewById(R.id.audio_only);
        mAudioOnlyCheckBox.setOnCheckedChangeListener(mCheckBoxObserver);
    }

    private void initStreamer() {
        //初始化推流SDK
        mStreamer = new Streamer(this);
        //设置预览编码帧率
        mStreamer.setPreviewFps(15);
        //设置推流编码帧率
        mStreamer.setTargetFps(15);
        //设置初始、最大、最小视频码率
        mStreamer.setVideoKBitrate(800 * 3 / 4, 800, 800 / 4);
        //设置音频编码码率
        mStreamer.setAudioBitrate(48);
        //分别设置预览和推流分辨率
        mStreamer.setPreviewResolution(VIDEO_RESOLUTION_360P);
        mStreamer.setTargetResolution(VIDEO_RESOLUTION_360P);
        //设置编码模式（硬编/软编/软编兼容）
        mStreamer.setEncodeMethod(ENCODE_METHOD_HARDWARE);

        //设置横竖屏方向
        mStreamer.setRotateDegrees(mIsLandscape ? 90 : 0);//设置屏幕旋转角度
        if (mIsLandscape) {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);//横屏
            isHorizontalScreen = 1;
        } else {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);//竖屏
            isHorizontalScreen = 0;
        }
        //设置预览View
        mStreamer.setDisplayPreview(mCameraPreviewView);

        // 开启推流统计功能
        mStreamer.setEnableStreamStatModule(true);
        //设置前置摄像头镜像 默认不开启
        mStreamer.setFrontCameraMirror(mFrontMirrorCheckBox.isChecked());
        //静音 默认不开启
        mStreamer.setMuteAudio(mMuteCheckBox.isChecked());
        //耳返 默认不开启
        mStreamer.setEnableAudioPreview(mAudioPreviewCheckBox.isChecked());
        //设置Info回调，可以收到相关通知信息
        mStreamer.setOnInfoListener(mOnInfoListener);
        //设置错误回调，收到该回调后，一般是发生了严重错误，比如网络断开等
        mStreamer.setOnErrorListener(mOnErrorListener);
        //设置美颜滤镜
        mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), DENOISE.getFilter());
        mStreamer.setEnableImgBufBeauty(true);

        //手动变焦
        mStreamer.setCameraCapture(mStreamer.getCameraCapture());
        mCameraPreviewView.setOnTouchListener(mStreamer.cameraTouchHelper);
        mStreamer.setCameraHintView(mCameraHintView);
        mStreamer.setEnableTouchFocus(true);
        mStreamer.setEnableZoom(true);
    }

    @Override
    public void onResume() {
        super.onResume();
        startCameraPreviewWithPermCheck();
        mStreamer.resume();
        if (mStreamer.isRecording() && !mAudioOnlyCheckBox.isChecked()) {
            mStreamer.setAudioOnly(false);
        }
        if (mWaterMarkCheckBox.isChecked()) {
            showWaterMark();
        }
    }

    public void onPause() {
        super.onPause();
        mStreamer.pause();
        mStreamer.stopCameraPreview();
        if (mStreamer.isRecording() && !mAudioOnlyCheckBox.isChecked()) {
            mStreamer.setAudioOnly(true);
        }
        hideWaterMark();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (mMainHandler != null) {
            mMainHandler.removeCallbacksAndMessages(null);
            mMainHandler = null;
        }
        mStreamer.release();
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_BACK:
                onBackoffClick();
                break;
            default:
                break;
        }
        return true;
    }

    // 开始推流
    private void startStream() {
        mStreamer.startStream(activityConfig);
        mShootingText.setText(STOP_STRING);
        mShootingText.postInvalidate();
        mRecording = true;
    }

    // 结束推流
    private void stopStream() {

        mStreamer.stopStream();
        mChronometer.stop();
        mShootingText.setText(START_STRING);
        mShootingText.postInvalidate();
        mRecording = false;
    }

    private class ButtonObserver implements View.OnClickListener {
        @Override
        public void onClick(View view) {
            switch (view.getId()) {
                case R.id.switch_cam:
                    onSwitchCamera();
                    break;
                case R.id.backoff:
                    onBackoffClick();
                    break;
                case R.id.flash:
                    onFlashClick();
                    break;
                case R.id.click_to_shoot:
                    onShootClick();
                    break;
                default:
                    break;
            }
        }
    }

    private class CheckBoxObserver implements CompoundButton.OnCheckedChangeListener {

        @Override
        public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
            switch (buttonView.getId()) {
                case R.id.click_to_switch_beauty:
                    onBeautyChecked(isChecked);
                    break;
                case R.id.bgm:
                    onBgmChecked(isChecked);
                    break;
                case R.id.ear_mirror:
                    onAudioPreviewChecked(isChecked);
                    break;
                case R.id.mute:
                    onMuteChecked(isChecked);
                    break;
                case R.id.watermark:
                    onWaterMarkChecked(isChecked);
                    break;
                case R.id.front_camera_mirror:
                    onFrontMirrorChecked(isChecked);
                    break;
                case R.id.audio_only:
                    onAudioOnlyChecked(isChecked);
                    break;
                default:
                    break;
            }
        }

    }

    //转换摄像头
    private void onSwitchCamera() {
        mStreamer.switchCamera();
        mCameraHintView.hideAll();
    }

    //闪光灯
    private void onFlashClick() {
        if (isFlashOpened) {
            mStreamer.toggleTorch(false);
            isFlashOpened = false;
        } else {
            mStreamer.toggleTorch(true);
            isFlashOpened = true;
        }
    }

    private void onBackoffClick() {
        new AlertDialog.Builder(StreamActivity.this).setCancelable(true)
                .setTitle("结束直播?")
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface arg0, int arg1) {

                    }
                })
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface arg0, int arg1) {
                        mChronometer.stop();
                        mRecording = false;
                        mStreamer.stopStream();
                        StreamActivity.this.finish();
                    }
                }).show();
    }

    private void onShootClick() {
        if (mRecording) {
            stopStream();
        } else {
            startStream();
        }
    }

    private void onBeautyChecked(boolean isChecked) {
        if (isChecked) {
            if (mStreamer.getVideoEncodeMethod() ==
                    IStreamer.ENCODE_METHOD_SOFTWARE_COMPAT) {
                mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(),
                        DENOISE.getFilter());
                mStreamer.setEnableImgBufBeauty(true);
            } else {
                showChooseFilter();
            }
        } else {
            mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), BEAUTY_DISABLE.getFilter());
            mStreamer.setEnableImgBufBeauty(false);
        }
    }

    //背景音乐
    private void onBgmChecked(boolean isChecked) {
        if (isChecked) {
            mStreamer.startBgm(mBgmPath, true);
        } else {
            mStreamer.stopBgm();
        }
    }

    private void onAudioPreviewChecked(boolean isChecked) {
        mStreamer.setEnableAudioPreview(isChecked);
    }

    private void onMuteChecked(boolean isChecked) {
        mStreamer.setMuteAudio(isChecked);
    }

    private void onWaterMarkChecked(boolean isChecked) {
        if (isChecked)
            showWaterMark();
        else
            hideWaterMark();
    }

    private void onFrontMirrorChecked(boolean isChecked) {
        mStreamer.setFrontCameraMirror(isChecked);
    }

    private void onAudioOnlyChecked(boolean isChecked) {
        mStreamer.setAudioOnly(isChecked);
    }

    //显示水印
    private void showWaterMark() {
        if (!mIsLandscape) {
            /**
             * 设置并显示logo水印
             *
             * @param path  logo图片文件的路径
             * @param x     logo的显示位置，0-1之间，相对于视频
             * @param y     logo的显示位置，0-1之间，相对于视频
             * @param w     logo的显示宽度，0-1之间，相对于视频，为0时会根据h及logo图片的比例自适应
             * @param h     logo的显示高度，0-1之间，相对于视频，为0时会根据w及logo图片的比例自适应
             * @param alpha logo的透明度，0-1之间
             */
            mStreamer.showWaterMarkLogo(mLogoPath, 0.08f, 0.04f, 0.20f, 0, 0.8f);

            /**
             * 在推流视频中显示时间水印
             *
             * @param x     时间戳的显示位置，0-1之间，相对于视频
             * @param y     时间戳的显示位置，0-1之间，相对于视频
             * @param w     时间戳的显示宽度，0-1之间，相对于视频，高度会自适应
             * @param color 时间戳的颜色
             * @param alpha 时间戳的显示透明度，0-1之间
             */
            mStreamer.showWaterMarkTime(0.03f, 0.01f, 0.35f, Color.RED, 1.0f);
        } else {
            mStreamer.showWaterMarkLogo(mLogoPath, 0.05f, 0.09f, 0, 0.08f, 0.8f);
            mStreamer.showWaterMarkTime(0.01f, 0.03f, 0.22f, Color.RED, 1.0f);
        }
    }

    //隐藏水印
    private void hideWaterMark() {
        mStreamer.hideWaterMarkLogo();
        mStreamer.hideWaterMarkTime();
    }

    //摄像头权限检测
    private void startCameraPreviewWithPermCheck() {
        int cameraPerm = ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA);
        int audioPerm = ActivityCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO);
        if (cameraPerm != PackageManager.PERMISSION_GRANTED ||
                audioPerm != PackageManager.PERMISSION_GRANTED) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                Log.e(TAG, "No CAMERA or AudioRecord permission, please check");
                Toast.makeText(this, "No CAMERA or AudioRecord permission, please check",
                        Toast.LENGTH_LONG).show();
            } else {
                String[] permissions = {Manifest.permission.CAMERA,
                        Manifest.permission.RECORD_AUDIO,
                        Manifest.permission.READ_EXTERNAL_STORAGE};
                ActivityCompat.requestPermissions(this, permissions,
                        PERMISSION_REQUEST_CAMERA_AUDIOREC);
            }
        } else {
            mStreamer.startCameraPreview();
        }
    }

    //选择美颜滤镜
    private void showChooseFilter() {
        AlertDialog alertDialog;
        alertDialog = new AlertDialog.Builder(this)
                .setTitle("请选择美颜滤镜")
                .setSingleChoiceItems(
                        /**
                         * BEAUTY_DISABLE	禁用美颜	无
                         * DENOISE	        自然	美白（中）+磨皮（低）+红润（低）
                         * SKIN_WHITEN	    白肤	美白（强）+磨皮（中）+红润（低）
                         * BEAUTY_ILLUSION	柔肤	美白（中）+磨皮（中）+红润（低）
                         * BEAUTY_SMOOTH	粉嫩	美白（中）+磨皮（强）+红润（中）
                         * BEAUTY_SOFT	    嫩肤	美白（中）+磨皮（中）+红润（强）
                         */
                        new String[]{"BEAUTY_SOFT", "SKIN_WHITEN", "BEAUTY_ILLUSION", "DENOISE",
                                "BEAUTY_SMOOTH"}, -1,
                        new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                switch (which) {
                                    case 0:
                                        mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), BEAUTY_SOFT.getFilter());
                                        break;
                                    case 1:
                                        mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), SKIN_WHITEN.getFilter());
                                        break;
                                    case 2:
                                        mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), BEAUTY_ILLUSION.getFilter());
                                        break;
                                    case 3:
                                        mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), DENOISE.getFilter());
                                        break;
                                    case 4:
                                        mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), BEAUTY_SMOOTH.getFilter());
                                        break;
                                }
                                dialog.dismiss();
                            }
                        })
                .create();
        alertDialog.setCancelable(false);
        alertDialog.show();
    }

    private IStreamer.OnInfoListener mOnInfoListener = new IStreamer.OnInfoListener() {
        @Override
        public void onInfo(int what, int msg1, int msg2) {
            switch (what) {
                case IStreamer.cnstream_camera_init_done:
                    //初始化完毕
                    Log.d(TAG, "cnstream_camera_init_done");
                    break;
                case IStreamer.cnstream_open_stream_succ:
                    //推流成功
                    Log.d(TAG, "cnstream_open_stream_success");
                    break;
                case IStreamer.cnstream_frame_send_slow:
                    //网络状态不佳，数据发送可能有延迟  发送当前帧的时长
                    Log.d(TAG, "cnstream_frame_send_slow");
                    Toast.makeText(StreamActivity.this, "Network not good!", Toast.LENGTH_SHORT).show();
                    break;
                case IStreamer.cnstream_est_bw_raise:
                    //码率上调了	码率上调的目标值 单位bps
                    Log.d(TAG, "BW raise to" + msg1 / 1000 + "kbps");
                    break;
                case IStreamer.cnstream_est_bw_drop:
                    //码率下调了	码率下调到的值 单位bps
                    Log.d(TAG, "BW drop to" + msg1 / 1000 + "kbps");
                    break;
                default:
                    Log.d(TAG, "OnInfo: " + what + " msg1 " + msg1 + " msg2 " + msg2);
                    break;
            }
        }
    };

    private IStreamer.OnErrorListener mOnErrorListener = new IStreamer.OnErrorListener() {
        @Override
        public void onError(int what, int msg1, int msg2) {

            if (what < 0) {
                mRecording = false;
                mShootingText.setText("开始直播");
                mShootingText.postInvalidate();
            }

            Toast.makeText(StreamActivity.this, TAG + "   " + what, Toast.LENGTH_SHORT).show();
            switch (what) {
                case IStreamer.cnstream_error_start_stream_server:
                    //开始直播时请求服务器失败
                    break;
                case IStreamer.cnstream_error_start_stream_network:
                    //开始直播时网络连接失败
                    break;
                case IStreamer.cnstream_error_start_stream_other:
                    //开始直播活动失败
                    break;
                case IStreamer.cnstream_error_create_stream_server:
                    //创建直播活动请求服务器失败
                    break;
                case IStreamer.cnstream_error_create_stream_network:
                    //创建直播活动时网络连接失败
                    break;
                case IStreamer.cnstream_error_create_stream_other:
                    //创建直播活动时失败
                    break;
                case IStreamer.cnstream_record_error:
                    //直播录制失败
                    break;
                case IStreamer.cnstream_error_stop_stream:
                    //停止直播活动失败
                    break;
                case IStreamer.cnstream_socket_disconnect:
                    //推流Socket异常断开
                    break;
                case IStreamer.cnstream_init_error_instop:
                    //初始化失败 正在停止推流
                    break;
                case IStreamer.cnstream_error_dns_parse_failed:
                    //url域名解析失败
                    Log.d(TAG, "cnstream_error_dns_parse_failed");
                    break;
                case IStreamer.cnstream_error_connect_failed:
                    //网络连接失败，无法建立连接
                    Log.d(TAG, "cnstream_error_connect_failed");
                    break;
                case IStreamer.cnstream_error_publish_failed:
                    //跟RTMP服务器完成握手后,向{streamname}推流失败)
                    Log.d(TAG, "cnstream_error_publish_failed");
                    break;
                case IStreamer.cnstream_error_connect_breaked:
                    //网络连接断开
                    Log.d(TAG, "cnstream_error_connect_breaked");
                    break;
                case IStreamer.cnstream_error_av_async:
                    //音视频采集pts差值超过5s	音视频采集pts具体差值，单位ms
                    Log.d(TAG, "cnstream_error_av_async " + msg1 + " ms");
                    break;
                case IStreamer.cnstream_video_encoder_error_unsupported:
                    //编码器初始化失败
                    Log.d(TAG, "cnstream_video_encoder_error_unsupported");
                    break;
                case IStreamer.cnstream_video_encoder_error_unknown:
                    //视频编码失败
                    Log.d(TAG, "cnstream_video_encoder_error_unknown");
                    break;
                case IStreamer.cnstream_audio_encoder_error_unsupported:
                    //音频初始化失败
                    Log.d(TAG, "cnstream_audio_encoder_error_unsupported");
                    break;
                case IStreamer.cnstream_audio_encoder_error_unknown:
                    //音频编码失败
                    Log.d(TAG, "cnstream_audio_encoder_error_unknown");
                    break;
                case IStreamer.cnstream_audio_recorder_error_start_failed:
                    //录音开启失败
                    Log.d(TAG, "cnstream_audio_recorder_error_start_failed");
                    break;
                case IStreamer.cnstream_audio_recorder_error_unknown:
                    //录音开启未知错误
                    Log.d(TAG, "cnstream_audio_recorder_error_unknown");
                    break;
                case IStreamer.cnstream_camera_error_unknown:
                    //摄像头未知错误
                    Log.d(TAG, "cnstream_camera_error_unknown");
                    break;
                case IStreamer.cnstream_camera_error_start_failed:
                    //打开摄像头失败
                    Log.d(TAG, "cnstream_camera_error_start_failed");
                    break;
                case IStreamer.cnstream_camera_error_server_died:
                    //系统Camera服务进程退出
                    Log.d(TAG, "cnstream_camera_error_server_died");
                    break;
                default:
                    Log.d(TAG, "what= " + what + " msg1= " + msg1 + " msg2= " + msg2);
                    break;
            }
        }
    };

    //设置推流参数（注意：必传参数为activityId、channelId）
    ActivityConfig activityConfig = new ActivityConfig() {
        @Override
        public String getActivityID() {
            //活动ID，确保SP下的唯一性(即appId唯一) ，不能含下划线，不支持转义字符和urlencode会处理的特殊字符，如下！ # $ % & ‘ （ ）* + , . / : ; = ? @ [ / ]
            return activityId;
        }

        @Override
        public String getActivityName() {
            //活动名称
            return "";
        }

        @Override
        public int getActivityStatus() {
            //活动状态，0：未开始 ／1：已开始 ／2：已结束 ／3 已下线，默认为0
            return 0;
        }

        @Override
        public int getIsHorizontalScreen() {
            //屏幕方向，0：垂直即竖屏 ／1：水平即横屏 ，默认为1
            return isHorizontalScreen;
        }

        @Override
        public String getChannelID() {
            //播放通道；PGC业务：平台分配／ UGC业务：主播ID生成，确保SP下的唯一性，不能含下划线，不支持转义字符和urlencode会处理的特殊字符，如下！ # $ % & ‘ （ ）* + , . / : ; = ? @ [ / ]
            return channelId;
        }

        @Override
        public String getCoverImgUrl() {
            //活动封面
            return "";
        }

        @Override
        public String getActivityCategory() {
            //活动分类ID
            return "";
        }

        @Override
        public String getExtensions() {
            //扩展字段，参数格式为Map对象的Json字符串（主播昵称、头像、）
            return "";
        }

        @Override
        public String getUuid() {
            return "";
        }

        @Override
        public String getCallbackAcitvityStatushttpPostUrl() {
            //回调通知活动状态（错误，结束、心跳异常等状态），详情见回调接口说明
            return "";
        }
    };
}