/*
 * MainActivity.java
 * Author: daniusdk.com
 */
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    
    ...
    context_ = this.getApplicationContext();
    
    libPublisher = new SmartPublisherJniV2();
}

class ButtonStartPushListener implements View.OnClickListener {
    public void onClick(View v) {
        if (stream_publisher_.is_rtmp_publishing()) {
            stopPush();
            btnRTMPPusher.setText("推送RTMP");
            return;
        }
        Log.i(TAG, "onClick start push rtmp..");
        
        InitAndSetConfig();
        String rtmp_pusher_url ="rtmp://192.168.0.101:1935/hls/stream123";;
        if (!stream_publisher_.SetURL(rtmp_pusher_url))
            Log.e(TAG, "Failed to set publish stream URL..");
        boolean start_ret = stream_publisher_.StartPublisher();
        if (!start_ret) {
            stream_publisher_.try_release();
            Log.e(TAG, "Failed to start push stream..");
            return;
        }
        startAudioRecorder();
        startLayerPostThread();
        btnRTMPPusher.setText("停止推送 ");
    }
}

//停止rtmp推送
private void stopPush() {
    stream_publisher_.StopPublisher();
    stream_publisher_.try_release();
    if (!stream_publisher_.is_publishing())
        stopAudioRecorder();
}

/*
 * MainActivity.java
 * Author: daniusdk.com
 */
private void InitAndSetConfig() {
    if (null == libPublisher)
        return;
    if (!stream_publisher_.empty())
        return;
    Log.i(TAG, "InitAndSetConfig video width: " + video_width_ + ", height" + video_height_ + " imageRotationDegree:" + cameraImageRotationDegree_);
    int audio_opt = 1;
    long handle = libPublisher.SmartPublisherOpen(context_, audio_opt, 3,  video_width_, video_height_);
    if (0==handle) {
        Log.e(TAG, "sdk open failed!");
        return;
    }
    Log.i(TAG, "publisherHandle=" + handle);
    int fps = 25;
    int gop = fps * 3;
    initialize_publisher(libPublisher, handle, video_width_, video_height_, fps, gop);
    stream_publisher_.set(libPublisher, handle);
}

private boolean initialize_publisher(SmartPublisherJniV2 lib_publisher, long handle, int width, int height, int fps, int gop) {
    if (null == lib_publisher) {
        Log.e(TAG, "initialize_publisher lib_publisher is null");
        return false;
    }
    if (0 == handle) {
        Log.e(TAG, "initialize_publisher handle is 0");
        return false;
    }
    if (videoEncodeType == 1) {
        int kbps = LibPublisherWrapper.estimate_video_hardware_kbps(width, height, fps, true);
        Log.i(TAG, "h264HWKbps: " + kbps);
        int isSupportH264HWEncoder = lib_publisher.SetSmartPublisherVideoHWEncoder(handle, kbps);
        if (isSupportH264HWEncoder == 0) {
            lib_publisher.SetNativeMediaNDK(handle, 0);
            lib_publisher.SetVideoHWEncoderBitrateMode(handle, 1); // 0:CQ, 1:VBR, 2:CBR
            lib_publisher.SetVideoHWEncoderQuality(handle, 39);
            lib_publisher.SetAVCHWEncoderProfile(handle, 0x08); // 0x01: Baseline, 0x02: Main, 0x08: High
            // lib_publisher.SetAVCHWEncoderLevel(handle, 0x200); // Level 3.1
            // lib_publisher.SetAVCHWEncoderLevel(handle, 0x400); // Level 3.2
            // lib_publisher.SetAVCHWEncoderLevel(handle, 0x800); // Level 4
            lib_publisher.SetAVCHWEncoderLevel(handle, 0x1000); // Level 4.1 多数情况下,这个够用了
            //lib_publisher.SetAVCHWEncoderLevel(handle, 0x2000); // Level 4.2
            // lib_publisher.SetVideoHWEncoderMaxBitrate(handle, ((long)h264HWKbps)*1300);
            Log.i(TAG, "Great, it supports h.264 hardware encoder!");
        }
    } else if (videoEncodeType == 2) {
        int kbps = LibPublisherWrapper.estimate_video_hardware_kbps(width, height, fps, false);
        Log.i(TAG, "hevcHWKbps: " + kbps);
        int isSupportHevcHWEncoder = lib_publisher.SetSmartPublisherVideoHevcHWEncoder(handle, kbps);
        if (isSupportHevcHWEncoder == 0) {
            lib_publisher.SetNativeMediaNDK(handle, 0);
            lib_publisher.SetVideoHWEncoderBitrateMode(handle, 1); // 0:CQ, 1:VBR, 2:CBR
            lib_publisher.SetVideoHWEncoderQuality(handle, 39);
            // libPublisher.SetVideoHWEncoderMaxBitrate(handle, ((long)hevcHWKbps)*1200);
            Log.i(TAG, "Great, it supports hevc hardware encoder!");
        }
    }
    boolean is_sw_vbr_mode = true;
    //H.264 software encoder
    if (is_sw_vbr_mode) {
        int is_enable_vbr = 1;
        int video_quality = LibPublisherWrapper.estimate_video_software_quality(width, height, true);
        int vbr_max_kbps = LibPublisherWrapper.estimate_video_vbr_max_kbps(width, height, fps);
        lib_publisher.SmartPublisherSetSwVBRMode(handle, is_enable_vbr, video_quality, vbr_max_kbps);
    }
    if (is_pcma_) {
        lib_publisher.SmartPublisherSetAudioCodecType(handle, 3);
    } else {
        lib_publisher.SmartPublisherSetAudioCodecType(handle, 1);
    }
    lib_publisher.SetSmartPublisherEventCallbackV2(handle, new EventHandlerPublisherV2().set(handler_, record_executor_));
    lib_publisher.SmartPublisherSetSWVideoEncoderProfile(handle, 3);
    lib_publisher.SmartPublisherSetSWVideoEncoderSpeed(handle, 2);
    lib_publisher.SmartPublisherSetGopInterval(handle, gop);
    lib_publisher.SmartPublisherSetFPS(handle, fps);
    // lib_publisher.SmartPublisherSetSWVideoBitRate(handle, 600, 1200);
    boolean is_noise_suppression = true;
    lib_publisher.SmartPublisherSetNoiseSuppression(handle, is_noise_suppression ? 1 : 0);
    boolean is_agc = false;
    lib_publisher.SmartPublisherSetAGC(handle, is_agc ? 1 : 0);
    int echo_cancel_delay = 0;
    lib_publisher.SmartPublisherSetEchoCancellation(handle, 1, echo_cancel_delay);
    return true;
}

@Override
public void onCameraImageData(Image image) {
    ....
    for (LibPublisherWrapper i : publisher_array_)
        i.PostLayerImageYUV420888ByteBuffer(0, 0, 0,
            planes[0].getBuffer(), y_offset, planes[0].getRowStride(),
            planes[1].getBuffer(), u_offset, planes[1].getRowStride(),
            planes[2].getBuffer(), v_offset, planes[2].getRowStride(), planes[1].getPixelStride(),
            w, h, 0, 0,
            scale_w, scale_h, scale_filter_mode, rotation_degree);
}

void startAudioRecorder() {
    if (audio_recorder_ != null)
        return;
    audio_recorder_ = new NTAudioRecordV2(this);
    Log.i(TAG, "startAudioRecorder call audio_recorder_.start()+++...");
    audio_recorder_callback_ = new NTAudioRecordV2CallbackImpl(stream_publisher_, null);
    audio_recorder_.AddCallback(audio_recorder_callback_);
    if (!audio_recorder_.Start(is_pcma_ ? 8000 : 44100, 1) ) {
        audio_recorder_.RemoveCallback(audio_recorder_callback_);
        audio_recorder_callback_ = null;
        audio_recorder_ = null;
        Log.e(TAG, "startAudioRecorder start failed.");
    }
    else {
        Log.i(TAG, "startAudioRecorder call audio_recorder_.start() OK---...");
    }
}
void stopAudioRecorder() {
    if (null == audio_recorder_)
        return;
    Log.i(TAG, "stopAudioRecorder+++");
    audio_recorder_.Stop();
    if (audio_recorder_callback_ != null) {
        audio_recorder_.RemoveCallback(audio_recorder_callback_);
        audio_recorder_callback_ = null;
    }
    audio_recorder_ = null;
    Log.i(TAG, "stopAudioRecorder---");
}

private static class NTAudioRecordV2CallbackImpl implements NTAudioRecordV2Callback {
    private WeakReference<LibPublisherWrapper> publisher_0_;
    public NTAudioRecordV2CallbackImpl(LibPublisherWrapper publisher_0) {
        if (publisher_0 != null)
            publisher_0_ = new WeakReference<>(publisher_0);
    }
    private final LibPublisherWrapper get_publisher_0() {
        if (publisher_0_ !=null)
            return publisher_0_.get();
        return null;
    }
    @Override
    public void onNTAudioRecordV2Frame(ByteBuffer data, int size, int sampleRate, int channel, int per_channel_sample_number) {
        LibPublisherWrapper publisher_0 = get_publisher_0();
        if (publisher_0 != null)
            publisher_0.OnPCMData(data, size, sampleRate, channel, per_channel_sample_number);
    }
}

private void startLayerPostThread() {
    if (layer_post_thread_ != null)
        return;
    layer_post_thread_ = new LayerPostThread(this.context_, publisher_array_);
    layer_post_thread_.start_post();
    update_layer_post_video_size();
    layer_post_thread_.enableText(isHasTextWatermark());
    layer_post_thread_.enablePicture(isHasPictureWatermark());
}
private void update_layer_post_video_size() {
    if (null == layer_post_thread_)
        return;
    int w, h;
    int degree = cameraImageRotationDegree_;
    if (degree < 0 ) {
        w = 0;
        h = 0;
    } else if (90 == degree || 270 == degree) {
        w = video_height_;
        h = video_width_;
    }else {
        w = video_width_;
        h = video_height_;
    }
    layer_post_thread_.update_video_size(w, h);
}
private void stopLayerPostThread() {
    if (layer_post_thread_ != null) {
        layer_post_thread_.stop_post();
        layer_post_thread_ = null;
    }
}

class ButtonCaptureImageListener implements View.OnClickListener {
    public void onClick(View v) {
        if (null == snap_shot_impl_) {
            snap_shot_impl_ = new SnapShotImpl(image_path_, context_, handler_, libPublisher, snap_shot_publisher_);
            snap_shot_impl_.start();
        }
        startLayerPostThread();
        snap_shot_impl_.set_layer_post_thread(layer_post_thread_);
        snap_shot_impl_.capture();
    }
}

class ButtonStartRecorderListener implements View.OnClickListener {
    public void onClick(View v) {
        if (layer_post_thread_ != null)
            layer_post_thread_.update_layers();
        if (stream_publisher_.is_recording()) {
            stopRecorder();
            if (stream_publisher_.empty())
                ConfigControlEnable(true);
            btnStartRecorder.setText("实时录像");
            btnPauseRecorder.setText("暂停录像");
            btnPauseRecorder.setEnabled(false);
            isPauseRecording = true;
            return;
        }
        Log.i(TAG, "onClick start recorder..");
        InitAndSetConfig();
        ConfigRecorderParam();
        boolean start_ret = stream_publisher_.StartRecorder();
        if (!start_ret) {
            stream_publisher_.try_release();
            Log.e(TAG, "Failed to start recorder.");
            return;
        }
        startAudioRecorder();
        ConfigControlEnable(false);
        startLayerPostThread();
        btnStartRecorder.setText("停止录像");
        btnPauseRecorder.setEnabled(true);
        isPauseRecording = true;
    }
}

void ConfigRecorderParam() {
    if (null == libPublisher)
        return;
    if (null == recDir || recDir.isEmpty())
        return;
    int ret = libPublisher.SmartPublisherCreateFileDirectory(recDir);
    if (ret != 0) {
        Log.e(TAG, "Create record dir failed, path:" + recDir);
        return;
    }
    if (!stream_publisher_.SetRecorderDirectory(recDir)) {
        Log.e(TAG, "Set record dir failed , path:" + recDir);
        return;
    }
    // 更细粒度控制录像的, 一般情况无需调用
    //libPublisher.SmartPublisherSetRecorderAudio(publisherHandle, 0);
    //libPublisher.SmartPublisherSetRecorderVideo(publisherHandle, 0);
    if (!stream_publisher_.SetRecorderFileMaxSize(200)) {
        Log.e(TAG, "SmartPublisherSetRecorderFileMaxSize failed.");
        return;
    }
}

class ButtonPauseRecorderListener implements View.OnClickListener {
    public void onClick(View v) {
        if (stream_publisher_.is_recording()) {
            if (isPauseRecording) {
                boolean ret = stream_publisher_.PauseRecorder(true);
                if (ret) {
                    isPauseRecording = false;
                    btnPauseRecorder.setText("恢复录像");
                } else {
                    Log.e(TAG, "Pause recorder failed..");
                }
            } else {
                boolean ret = stream_publisher_.PauseRecorder(false);
                if (ret) {
                    isPauseRecording = true;
                    btnPauseRecorder.setText("暂停录像");
                } else {
                    Log.e(TAG, "Resume recorder failed..");
                }
            }
        }
    }
}

private static class EventHandlerPublisherV2 implements NTSmartEventCallbackV2 {
    @Override
    public void onNTSmartEventCallbackV2(long handle, int id, long param1, long param2, String param3, String param4, Object param5) {
        Log.i(TAG, "EventHandeV2: handle=" + handle + " id:" + id);
        String publisher_event = "";
        switch (id) {
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_STARTED:
                publisher_event = "开始..";
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_CONNECTING:
                publisher_event = "连接中..";
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_CONNECTION_FAILED:
                publisher_event = "连接失败..";
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_CONNECTED:
                publisher_event = "连接成功..";
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_DISCONNECTED:
                publisher_event = "连接断开..";
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_STOP:
                publisher_event = "关闭..";
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_RECORDER_START_NEW_FILE:
                publisher_event = "开始一个新的录像文件 : " + param3;
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_ONE_RECORDER_FILE_FINISHED:
                if (record_executor_ != null) {
                    RecordExecutorService executor = record_executor_.get();
                    if (executor != null) {
                        RecordFileFinishedHandler file_finished_handler = new RecordFileFinishedHandler().set(handle, param3, param1);
                        if (param2 > 0)
                            file_finished_handler.set_begin_time(param2);
                        executor.execute(file_finished_handler);
                    }
                }
                publisher_event = "已生成一个录像文件 : " + param3;
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_SEND_DELAY:
                publisher_event = "发送时延: " + param1 + " 帧数:" + param2;
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_CAPTURE_IMAGE:
                publisher_event = "快照: " + param1 + " 路径：" + param3;
                if (0 == param1)
                    publisher_event = publisher_event + "截取快照成功.." + ", 用户数据:" + param4;
                 else
                    publisher_event = publisher_event + "截取快照失败..";
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_RTSP_URL:
                publisher_event = "RTSP服务URL: " + param3;
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUSH_RTSP_SERVER_RESPONSE_STATUS_CODE:
                publisher_event ="RTSP status code received, codeID: " + param1 + ", RTSP URL: " + param3;
                break;
            case NTSmartEventID.EVENT_DANIULIVE_ERC_PUSH_RTSP_SERVER_NOT_SUPPORT:
                publisher_event ="服务器不支持RTSP推送, 推送的RTSP URL: " + param3;
                break;
        }
        String str = "当前回调状态：" + publisher_event;
        Log.i(TAG, str);
        if (handler_ != null) {
            android.os.Handler handler = handler_.get();
            if (handler != null) {
                Message message = new Message();
                message.what = PUBLISHER_EVENT_MSG;
                message.obj = publisher_event;
                handler.sendMessage(message);
            }
        }
    }
    public NTSmartEventCallbackV2 set(android.os.Handler handler, RecordExecutorService record_executor) {
        this.handler_ = new WeakReference<>(handler);
        this.record_executor_ = new WeakReference<>(record_executor);
        return this;
    }
    private WeakReference<android.os.Handler> handler_;
    private WeakReference<RecordExecutorService> record_executor_;
}

@Override
protected void onDestroy() {
    Log.i(TAG, "activity destory!");
    record_executor_.cancel_tasks();
    stopAudioRecorder();
    if (snap_shot_impl_ != null) {
        snap_shot_impl_.stop();
        snap_shot_impl_ = null;
    }
    snap_shot_publisher_.release();
    stopPush();
    stopRecorder();
    stream_publisher_.release();
    stopLayerPostThread();
    if (camera2Helper != null) {
        camera2Helper.release();
    }
    if (!record_executor_.shutdown(60, TimeUnit.SECONDS))
        Log.w(TAG, "call record_executor_.shutdown failed");
    super.onDestroy();
}