CNLive Android Team / CNStreamDemo · Files

package com.cnlive.demo.stream;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.opengl.GLSurfaceView;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
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;

/**
 * 纯音频推流
 */
public class AudioActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "AudioActivity";
    private GLSurfaceView surfaceView;
    private Button button, earMirror, audioFilter, mute;

    private Streamer mStreamer;

    private String activityId;
    private String channelId;
    private boolean mRecording = false;

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

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

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_audio);
        initView();
        initData();
        initStream();
    }


    /**
     * 初始化view
     */
    private void initView() {
        surfaceView = (GLSurfaceView) findViewById(R.id.cnSurfaceView);
        //开始推流
        button = (Button) findViewById(R.id.startStream);
        //音频滤镜
        audioFilter = (Button) findViewById(R.id.audio_filter);
        //耳返
        earMirror = (Button) findViewById(R.id.ear_mirror);
        //静音
        mute = (Button) findViewById(R.id.mute);
    }

    /**
     * 得到到推流所需的参数
     */
    private void initData() {
        Bundle bundle = getIntent().getExtras();
        activityId = bundle.getString(ACTIVITYID);
        channelId = bundle.getString(CHANNELID);
    }

    /**
     * 初始化推流SDK，设置一些推流所需的基本参数
     */
    private void initStream() {
        //初始化推流SDK
        mStreamer = new Streamer(this);
//        //设置音频编码码率
        mStreamer.setAudioKBitrate(48);
        //设置编码模式（硬编/软编/软编兼容）
        mStreamer.setEncodeMethod(ENCODE_METHOD_HARDWARE);
        //设置纯音频推流
        mStreamer.setAudioOnly(true);
        //设置Info回调，可以收到相关通知信息
        mStreamer.setOnInfoListener(mOnInfoListener);
        //设置错误回调，收到该回调后，一般是发生了严重错误，比如网络断开等
        mStreamer.setOnErrorListener(mOnErrorListener);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.startStream:
                //开始或结束推流
                if (mRecording) {
                    stopStream();
                } else {
                    startStream();
                }
                break;
            case R.id.audio_filter:
                showChooseAudioFilter();
                break;
            case R.id.ear_mirror:
                if (mStreamer.isAudioPreviewing()) {
                    mStreamer.setEnableAudioPreview(false);
                    earMirror.setText("开启耳返");
                } else {
                    mStreamer.setEnableAudioPreview(true);
                    earMirror.setText("关闭耳返");
                }
                break;
            case R.id.mute:
                if (mStreamer.isAudioMuted()) {
                    mStreamer.setMuteAudio(false);
                    mute.setText("开启静音");
                } else {
                    mStreamer.setMuteAudio(true);
                    mute.setText("关闭静音");
                }
                break;
        }
    }

    /**
     * 开始推流
     */
    private void startStream() {
        mStreamer.startStream(activityConfig);
        button.setText("结束推流");
        mRecording = true;
    }

    /**
     * 结束推流
     */
    private void stopStream() {
        mStreamer.stopStream();
        button.setText("开始推流");
        mRecording = false;
    }

    /**
     * 点击退出当前页面
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_BACK:
                mRecording = false;
                mStreamer.stopStream();
                AudioActivity.this.finish();
                break;
            default:
                break;
        }
        return true;
    }


    /**
     * 采集的状态依赖于 Activity 的生命周期，所以必须在 Activity 的生命周期中也调用 SDK 相应的接口
     */
    @Override
    public void onResume() {
        super.onResume();
        mStreamer.resume();
//        mStreamer.setMuteAudio(false);
    }

    public void onPause() {
        super.onPause();
        mStreamer.pause();
//        mStreamer.setMuteAudio(true);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mStreamer.release();
    }

    /**
     * 推流状态回调
     */
    private IStreamer.OnInfoListener mOnInfoListener = new IStreamer.OnInfoListener() {
        @Override
        public void onInfo(int what, int msg1, int msg2) {
            Toast.makeText(AudioActivity.this, TAG + "   " + what, Toast.LENGTH_SHORT).show();
            Log.e(TAG + "info", what + "");
            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(AudioActivity.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) {

            /**
             * 判断是否有异常，如果有SDK内部会停止推流；开发人员根据自己的需求可以做一些自己的操作；
             * 本demo中改变了按钮的状态，让其从推流状态改为停止推流状态，这样点击按钮则可以继续进行推流
             */
            if (what < 0) {
                mRecording = false;
                button.setText("开始直播");
                button.postInvalidate();
            }
            Log.e(TAG + "error", what + "");
            Toast.makeText(AudioActivity.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 0;
        }

        @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 int selectedIndex = 0;

    private void showChooseAudioFilter() {
        AlertDialog alertDialog;
        alertDialog = new AlertDialog.Builder(this)
                .setTitle("请选择音频滤镜")
                .setSingleChoiceItems(new String[]{"录音棚", "KTV", "小舞台", "演唱会"}, selectedIndex, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        selectedIndex = i;
                    }
                }).setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int which) {
                        switch (which){
                            case 0:
                                mStreamer.setAudioFilter(IStreamer.AUDIO_REVERB_LEVEL_1);
                                break;
                            case 1:
                                mStreamer.setAudioFilter(IStreamer.AUDIO_REVERB_LEVEL_2);
                                break;
                            case 2:
                                mStreamer.setAudioFilter(IStreamer.AUDIO_REVERB_LEVEL_3);
                                break;
                            case 3:
                                mStreamer.setAudioFilter(IStreamer.AUDIO_REVERB_LEVEL_4);
                                break;
                        }
                    }
                }).create();
        alertDialog.setCancelable(false);
        alertDialog.show();

    }
}