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.Bitmap;
import android.graphics.Color;
import android.hardware.Camera;
import android.opengl.GLSurfaceView;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.support.v4.app.ActivityCompat;
import android.support.v7.widget.AppCompatSeekBar;
import android.support.v7.widget.AppCompatSpinner;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.Chronometer;
import android.widget.CompoundButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.Toast;

import com.cnlive.libs.stream.Streamer;
import com.cnlive.libs.stream.base.ICNAudioEffectFilter;
import com.cnlive.libs.stream.base.IStreamer;
import com.cnlive.libs.stream.base.img.ICNImgFilterBase;
import com.cnlive.libs.stream.filter.CNAudioEffectFilter;
import com.cnlive.libs.stream.filter.CNAudioFilterBase;
import com.cnlive.libs.stream.filter.CNAudioReverbFilter;
import com.cnlive.libs.stream.filter.img.CNImgBeautyProFilter;
import com.cnlive.libs.stream.filter.img.CNNewImgFilterBase;
import com.cnlive.libs.stream.model.ActivityConfig;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

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.*;

/**
 * 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 ImageView mExposureView;
    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 CheckBox mBgImg;
    private Button mAudioMix;
    private Button mBgmFilter;
    private Button mCaptureScreen;

    private VerticalSeekBar mExposureSeekBar;

    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 mAnimatedLogoPath = "assets://cnlive_logo.gif";
    private String mBgImagePath = "assets://bg.jpg";

    private String activityId;
    private String channelId;

    private int isHorizontalScreen = 0;

    private boolean mShowAnimatedLogo;

    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";

    private View mBeautyChooseView;
    private AppCompatSpinner mBeautySpinner;
    private LinearLayout mBeautyGrindLayout;
    private TextView mGrindText;
    private AppCompatSeekBar mGrindSeekBar;
    private LinearLayout mBeautyWhitenLayout;
    private TextView mWhitenText;
    private AppCompatSeekBar mWhitenSeekBar;
    private LinearLayout mBeautyRuddyLayout;
    private TextView mRuddyText;
    private AppCompatSeekBar mRuddySeekBar;

    private AnimatedImageCapture animatedImageCapture;

    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();
        startCameraPreviewWithPermCheck();

    }

    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);
        //亮度
        mExposureView = (ImageView) findViewById(R.id.exposure);
        mExposureView.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);

        //音频滤镜
        mAudioMix = (Button) findViewById(R.id.audio_mix);
        mAudioMix.setOnClickListener(mObserverButton);

        //bgm升降调
        mBgmFilter = (Button) findViewById(R.id.bgm_filter);
        mBgmFilter.setOnClickListener(mObserverButton);

        //截屏
        mCaptureScreen = (Button) findViewById(R.id.click_to_capture_screenshot);
        mCaptureScreen.setOnClickListener(mObserverButton);

        //背景图推流
        mBgImg = (CheckBox) findViewById(R.id.bg_img);
        mBgImg.setOnCheckedChangeListener(mCheckBoxObserver);

        //亮度调节seekbar
        mExposureSeekBar = (VerticalSeekBar) findViewById(R.id.exposure_seekBar);
        mExposureSeekBar.setProgress(50);
        mExposureSeekBar.setSecondaryProgress(50);
        mExposureSeekBar.setOnSeekBarChangeListener(verticalSeekBarlistener);

        mBeautyChooseView = findViewById(R.id.beauty_choose);
        mBeautySpinner = (AppCompatSpinner) findViewById(R.id.beauty_spin);
        mBeautyGrindLayout = (LinearLayout) findViewById(R.id.beauty_grind);
        mGrindText = (TextView) findViewById(R.id.grind_text);
        mGrindSeekBar = (AppCompatSeekBar) findViewById(R.id.grind_seek_bar);
        mBeautyWhitenLayout = (LinearLayout) findViewById(R.id.beauty_whiten);
        mWhitenText = (TextView) findViewById(R.id.whiten_text);
        mWhitenSeekBar = (AppCompatSeekBar) findViewById(R.id.whiten_seek_bar);
        mBeautyRuddyLayout = (LinearLayout) findViewById(R.id.beauty_ruddy);
        mRuddyText = (TextView) findViewById(R.id.ruddy_text);
        mRuddySeekBar = (AppCompatSeekBar) findViewById(R.id.ruddy_seek_bar);
    }

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

//        //设置场景
//        mStreamer.setVideoEncodeScene(IStreamer.ENCODE_SCENE_GAME);

//        //H265
//        mStreamer.setVideoCodecId(IStreamer.CODEC_ID_HEVC);
//        //H264
//        mStreamer.setVideoCodecId(IStreamer.CODEC_ID_AVC);

//        //功耗
//        mStreamer.setVideoEncodeProfile(ENCODE_PROFILE_LOW_POWER);低
//        mStreamer.setVideoEncodeProfile(ENCODE_PROFILE_BALANCE);平衡
//        mStreamer.setVideoEncodeProfile(ENCODE_PROFILE_HIGH_PERFORMANCE);高性能

//        //双声道推流
//        mStreamer.setAudioChannels(2);


        //设置横竖屏方向
        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());
//        //设置自动重连(是否开启重连/重连次数/重连时间间隔)
//        mStreamer.setEnableAutoRestart(true, 3, 3000);
        //设置Info回调，可以收到相关通知信息
        mStreamer.setOnInfoListener(mOnInfoListener);
        //设置错误回调，收到该回调后，一般是发生了严重错误，比如网络断开等
        mStreamer.setOnErrorListener(mOnErrorListener);
        //设置美颜滤镜
        mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), CN_FILTER_BEAUTY_DENOISE.getFilter());
        mStreamer.setEnableImgBufBeauty(true);

        initBeautyUI();

        mStreamer.setFilterOnErrorListener(new ICNImgFilterBase.OnErrorListener() {
            @Override
            public void onError(int i) {
                Toast.makeText(StreamActivity.this, "当前机型不支持该滤镜", Toast.LENGTH_SHORT).show();
                mStreamer.setFilter(CN_FILTER_BEAUTY_DISABLE.getFilter());
            }
        });

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

        animatedImageCapture = new AnimatedImageCapture(this, mStreamer);
    }

    private void initBeautyUI() {
        String[] items = new String[]{"DISABLE", "BEAUTY_SOFT", "SKIN_WHITEN", "BEAUTY_ILLUSION",
                "BEAUTY_DENOISE", "BEAUTY_SMOOTH", "BEAUTY_PRO", "BEAUTY_PRO1", "BEAUTY_PRO2", "BEAUTY_PRO3",
                "BEAUTY_PRO4", "ToneCurve", "复古", "胶片", "Amatorka",
                "ELEGANCE", "1977", "Amaro", "Brannan", "EarlyBird", "Hefe", "Hudson", "ink",
                "Lomo", "LordKelvin", "Nash", "Rise", "Sierra", "Sutro", "Toaster", "Valencia", "Walden", "XproII"};
        ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
                android.R.layout.simple_spinner_item, items);
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        mBeautySpinner.setAdapter(adapter);
        mBeautySpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
            @Override
            public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
                TextView textView = ((TextView) parent.getChildAt(0));
                if (textView != null) {
                    textView.setTextColor(getResources().getColor(R.color.colorAccent));
                }

                if (position == 0) {
                    mStreamer.setFilter(CN_FILTER_BEAUTY_DISABLE.getFilter());
                } else if (position <= 5) {
                    mStreamer.setFilter(position + 15);
                } else if (position == 6) {
                    mStreamer.setFilter(CN_FILTER_BEAUTY_PRO.getFilter());
                } else if (position == 7) {
                    mStreamer.setFilter(CN_FILTER_BEAUTY_PRO1.getFilter());
                } else if (position == 8) {
                    mStreamer.setFilter(CN_FILTER_BEAUTY_PRO2.getFilter());
                } else if (position == 9) {
                    mStreamer.setFilter(CN_FILTER_BEAUTY_PRO3.getFilter());
                } else if (position == 10) {
                    mStreamer.setFilter(CN_FILTER_BEAUTY_PRO4.getFilter());
                } else if (position == 11) {
                    mStreamer.setToneCurveFilterStream(StreamActivity.this.getResources().openRawResource(R.raw.tone_cuver_sample));
                } else if (position == 12) {
                    mStreamer.setToneCurveFilterStream(StreamActivity.this.getResources().openRawResource(R.raw.fugu));
                } else if (position == 13) {
                    mStreamer.setToneCurveFilterStream(StreamActivity.this.getResources().openRawResource(R.raw.jiaopian));
                } else if (position == 14) {
                    //设置风格滤镜
                    mStreamer.setSpecialEffectsFilter(CN_SPECIAL_EFFECT_AMATORKA.getFilter());
                } else if (position == 15) {
                    mStreamer.setSpecialEffectsFilter(CN_SPECIAL_EFFECT_ELEGANCE.getFilter());
                } else if (position >= 16 && position <= 32) {
                    int diff = position - 16;
                    mStreamer.setFilter(CN_FILTER_BEAUTY_1977.getFilter() + diff);
                }
                List<CNNewImgFilterBase> filters = mStreamer.getFilter();
                if (filters != null && !filters.isEmpty()) {
                    final CNNewImgFilterBase filter = filters.get(0);
                    mBeautyGrindLayout.setVisibility(filter.isGrindRatioSupported() ?
                            View.VISIBLE : View.GONE);
                    mBeautyWhitenLayout.setVisibility(filter.isWhitenRatioSupported() ?
                            View.VISIBLE : View.GONE);
                    mBeautyRuddyLayout.setVisibility(filter.isRuddyRatioSupported() ?
                            View.VISIBLE : View.GONE);
                    SeekBar.OnSeekBarChangeListener seekBarChangeListener =
                            new SeekBar.OnSeekBarChangeListener() {
                                @Override
                                public void onProgressChanged(SeekBar seekBar, int progress,
                                                              boolean fromUser) {
                                    if (!fromUser) {
                                        return;
                                    }
                                    float val = progress / 100.f;
                                    if (seekBar == mGrindSeekBar) {
                                        filter.setGrindRatio(val);
                                    } else if (seekBar == mWhitenSeekBar) {
                                        filter.setWhitenRatio(val);
                                    } else if (seekBar == mRuddySeekBar) {
                                        if (filter instanceof CNImgBeautyProFilter) {
                                            val = progress / 50.f - 1.0f;
                                        }
                                        filter.setRuddyRatio(val);
                                    }
                                }

                                @Override
                                public void onStartTrackingTouch(SeekBar seekBar) {
                                }

                                @Override
                                public void onStopTrackingTouch(SeekBar seekBar) {
                                }
                            };
                    mGrindSeekBar.setOnSeekBarChangeListener(seekBarChangeListener);
                    mWhitenSeekBar.setOnSeekBarChangeListener(seekBarChangeListener);
                    mRuddySeekBar.setOnSeekBarChangeListener(seekBarChangeListener);
                    mGrindSeekBar.setProgress((int) (filter.getGrindRatio() * 100));
                    mWhitenSeekBar.setProgress((int) (filter.getWhitenRatio() * 100));
                    int ruddyVal = (int) (filter.getRuddyRatio() * 100);
                    if (filter instanceof CNImgBeautyProFilter) {
                        ruddyVal = (int) (filter.getRuddyRatio() * 50 + 50);
                    }
                    mRuddySeekBar.setProgress(ruddyVal);
                } else {
                    mBeautyGrindLayout.setVisibility(View.GONE);
                    mBeautyWhitenLayout.setVisibility(View.GONE);
                    mBeautyRuddyLayout.setVisibility(View.GONE);
                }
            }

            @Override
            public void onNothingSelected(AdapterView<?> parent) {
                // do nothing
            }
        });
        mBeautySpinner.setPopupBackgroundResource(R.color.transparent1);
        mBeautySpinner.setSelection(4);
    }

    private boolean[] mChooseFilter = {false, false, false, false
            , false, false, false, false, false, false};

    private void showChooseAudioFilter() {
        AlertDialog alertDialog;
        alertDialog = new AlertDialog.Builder(this)
                .setTitle("音频滤镜")
                .setMultiChoiceItems(new String[]{"录音棚", "KTV", "小舞台", "演唱会", "萝莉",
                                "大叔", "庄严", "机器人"}, mChooseFilter,
                        new DialogInterface.OnMultiChoiceClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which, boolean isChecked) {
                                if (isChecked) {
                                    mChooseFilter[which] = true;
                                }
                            }
                        }).setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        List<CNAudioFilterBase> filterBases = new LinkedList<CNAudioFilterBase>();
                        if (mChooseFilter[0]) {
                            CNAudioReverbFilter reverbFilter = new CNAudioReverbFilter();
                            reverbFilter.setReverbLevel(IStreamer.AUDIO_REVERB_LEVEL_1);
                            filterBases.add(reverbFilter);
                        }
                        if (mChooseFilter[1]) {
                            CNAudioReverbFilter reverbFilter = new CNAudioReverbFilter();
                            reverbFilter.setReverbLevel(IStreamer.AUDIO_REVERB_LEVEL_2);
                            filterBases.add(reverbFilter);
                        }
                        if (mChooseFilter[2]) {
                            CNAudioReverbFilter reverbFilter = new CNAudioReverbFilter();
                            reverbFilter.setReverbLevel(IStreamer.AUDIO_REVERB_LEVEL_3);
                            filterBases.add(reverbFilter);
                        }
                        if (mChooseFilter[3]) {
                            CNAudioReverbFilter reverbFilter = new CNAudioReverbFilter();
                            reverbFilter.setReverbLevel(IStreamer.AUDIO_REVERB_LEVEL_4);
                            filterBases.add(reverbFilter);
                        }
                        if (mChooseFilter[4]) {
                            CNAudioEffectFilter effectFilter = new CNAudioEffectFilter(ICNAudioEffectFilter.AUDIO_EFFECT_TYPE_FEMALE);
                            filterBases.add(effectFilter);
                        }
                        if (mChooseFilter[5]) {
                            CNAudioEffectFilter effectFilter = new CNAudioEffectFilter(ICNAudioEffectFilter.AUDIO_EFFECT_TYPE_MALE);
                            filterBases.add(effectFilter);
                        }

                        if (mChooseFilter[6]) {
                            CNAudioEffectFilter effectFilter = new CNAudioEffectFilter(ICNAudioEffectFilter.AUDIO_EFFECT_TYPE_HEROIC);
                            filterBases.add(effectFilter);
                        }

                        if (mChooseFilter[7]) {
                            CNAudioEffectFilter effectFilter = new CNAudioEffectFilter(ICNAudioEffectFilter.AUDIO_EFFECT_TYPE_ROBOT);
                            filterBases.add(effectFilter);
                        }

                        if (!mChooseFilter[0] && !mChooseFilter[1] && !mChooseFilter[2] && !mChooseFilter[3] && !mChooseFilter[4] && !mChooseFilter[5] && !mChooseFilter[6] && !mChooseFilter[7]) {
                            filterBases = null;
                        }
                        mStreamer.getAudioFilterMgt().setFilter(filterBases);

                        dialog.dismiss();
                    }
                }).create();
        alertDialog.setCancelable(false);
        alertDialog.show();
    }

    @Override
    public void onResume() {
        super.onResume();

        mStreamer.setDisplayPreview(mCameraPreviewView);
        mStreamer.resume();
        if (mStreamer.isRecording() && !mAudioOnlyCheckBox.isChecked()) {
            mStreamer.setAudioOnly(false);
            mStreamer.setMuteAudio(false);
        }
        if (mWaterMarkCheckBox.isChecked()) {
            showWaterMark();
        }

    }

    @Override
    public void onPause() {
        super.onPause();

        mStreamer.pause();
//        mStreamer.stopCameraPreview();
//        if (mStreamer.isRecording() && !mAudioOnlyCheckBox.isChecked()) {
//            mStreamer.setAudioOnly(true);
//            mStreamer.setMuteAudio(true);
//        }
        hideWaterMark();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        animatedImageCapture.stop();
        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();
        mStreamer.getAudioPlayerCapture().release();
        mRecording = false;
    }

    private int mChooseBGMFilter = 3;
    private String[] mBGMFilterName = {"-3", "-2", "-1", "0", "1", "2", "3"};

    //bgm升降调
    private void onChooseBGMFilter() {
        AlertDialog alertDialog;
        alertDialog = new AlertDialog.Builder(this)
                .setTitle("请选择背景音乐变调等级")
                .setSingleChoiceItems(mBGMFilterName, mChooseBGMFilter, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        mChooseBGMFilter = which;
                    }
                })
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        int level = Integer.parseInt(mBGMFilterName[mChooseBGMFilter]);
                        CNAudioEffectFilter audioEffectFilter = new CNAudioEffectFilter(ICNAudioEffectFilter.AUDIO_EFFECT_TYPE_PITCH);
                        audioEffectFilter.setPitchLevel(level);
                        mStreamer.getBGMAudioFilterMgt().setFilter(audioEffectFilter);
                        dialog.dismiss();
                    }
                })
                .create();
        alertDialog.setCancelable(false);
        alertDialog.show();
    }

    //截屏
    private void onCaptureScreenShotClick() {
        mStreamer.requestScreenShot(new IStreamer.ScreenShotListener() {
            @Override
            public void onBitmapAvailable(Bitmap bitmap) {
                BufferedOutputStream bos = null;
                try {
                    Date date = new Date();
                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss");
                    final String fileName = "/sdcard/screenshot" + dateFormat.format(date) + ".jpg";

                    bos = new BufferedOutputStream(new FileOutputStream(fileName));

                    if (bitmap != null) {
                        bitmap.compress(Bitmap.CompressFormat.JPEG, 90, bos);
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(StreamActivity.this, "保存截图到" + fileName, Toast.LENGTH_SHORT).show();
                            }
                        });
                    }
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    if (bos != null) {
                        try {
                            bos.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    }

    //亮度调节
    private void onExposureClick() {
        if (mExposureSeekBar.getVisibility() == View.VISIBLE) {
            mExposureSeekBar.setVisibility(View.GONE);
        } else {
            mExposureSeekBar.setVisibility(View.VISIBLE);
        }
    }

    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;
                case R.id.audio_mix:
                    showChooseAudioFilter();
                    break;
                case R.id.bgm_filter:
                    onChooseBGMFilter();
                    break;
                case R.id.click_to_capture_screenshot:
                    onCaptureScreenShotClick();
                    break;
                case R.id.exposure:
                    onExposureClick();
                    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;
                case R.id.bg_img:
                    onBgImageChecked(isChecked);
                    break;
                default:
                    break;
            }
        }

    }

    //背景图推流
    private void onBgImageChecked(boolean isChecked) {
        if (isChecked) {
            mStreamer.stopCameraPreview();
            mStreamer.startImageCapture(mBgImagePath);
        } else {
            mStreamer.startCameraPreview();
            mStreamer.stopImageCapture();
        }
    }

    //转换摄像头
    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();
            //如果服务器端已经创建好了直播活动则startActivity(String activityId, String url)开始直播活动
//            mStreamer.startActivity("7273647488", "rtmp://jsrtmp.up.cnlive.com/live/60_androidtest?vdoid=60_7273647488");
        }
    }

    private void onBeautyChecked(boolean isChecked) {
        if (mStreamer.getVideoEncodeMethod() ==
                IStreamer.ENCODE_METHOD_SOFTWARE_COMPAT) {
            mStreamer.getImgTexFilterMgt().setFilter(mStreamer.getGLRender(), isChecked ?
                    CN_FILTER_BEAUTY_DENOISE.getFilter() :
                    CN_FILTER_BEAUTY_DISABLE.getFilter());
            mStreamer.setEnableImgBufBeauty(isChecked);
        } else {
            mBeautyChooseView.setVisibility(isChecked ? View.VISIBLE : View.INVISIBLE);
        }
    }

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

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

    private void onMuteChecked(boolean isChecked) {
        //如果需要静音所有音频，调用下面方法
//        mStreamer.setMuteAudio(isChecked);
        //如果只想要静音麦克风，则需要调用下面方法
        if (isChecked) {
            mStreamer.setVoiceVolume(0.0f);
        } else {
            mStreamer.setVoiceVolume(0.4f);
        }
    }

    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) {
            if (!mShowAnimatedLogo) {
                /**
                 * 设置并显示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);
            } else {
                animatedImageCapture.showAnimatedWaterMard(mAnimatedLogoPath, 0.08f, 0.04f, 0.25f, 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 {
            if (!mShowAnimatedLogo) {
                mStreamer.showWaterMarkLogo(mLogoPath, 0.05f, 0.09f, 0, 0.08f, 0.8f);
            } else {
                animatedImageCapture.showAnimatedWaterMard(mAnimatedLogoPath, 0.05f, 0.09f, 0, 0.25f, 0.8f);
            }
            mStreamer.showWaterMarkTime(0.01f, 0.03f, 0.22f, Color.RED, 1.0f);
        }
        mShowAnimatedLogo = !mShowAnimatedLogo;
    }

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

    //摄像头权限检测
    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 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;
                case IStreamer.cnstream_error_already_over:
                    //直播已结束
                    Log.d(TAG, "cnstream_error_already_over");
                    break;
//                case IStreamer.cnstream_auto_restart_failed:
//                    //如果开启自动重连则会有此回调
//                    //自动重连失败
//                    Log.d(TAG, "cnstream_auto_restart_failed");
//                    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 "";
        }
    };

    private VerticalSeekBar.OnSeekBarChangeListener verticalSeekBarlistener = new VerticalSeekBar.OnSeekBarChangeListener() {
        @Override
        public void onProgressChanged(VerticalSeekBar seekBar, int progress, boolean fromUser) {
            Camera.Parameters parameters = mStreamer.getCameraCapture().getCameraParameters();
            if (parameters != null) {
                int minValue = parameters.getMinExposureCompensation();
                int maxValue = parameters.getMaxExposureCompensation();
                int range = 100 / (maxValue - minValue);
                parameters.setExposureCompensation(progress / range - maxValue);
            }
            mStreamer.getCameraCapture().setCameraParameters(parameters);
        }

        @Override
        public void onStartTrackingTouch(VerticalSeekBar seekBar) {

        }

        @Override
        public void onStopTrackingTouch(VerticalSeekBar seekBar) {

        }

        @Override
        public void onRequestDisallowInterceptTouchEvent(boolean enable) {

        }
    };
}