CNLive Android Team / VEUIDemo · Files

package com.rd.ve.demo;

import android.Manifest;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.graphics.Rect;
import android.graphics.RectF;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.text.TextUtils;
import android.util.Log;
import android.util.SparseArray;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

import com.cnlive.rdcore.CNVirtualVideo;
import com.cnlive.rdcore.listener.CNExportListener;
import com.cnlive.rdcore.models.CNTrailer;
import com.cnlive.rdcore.models.CNVideoConfig;
import com.cnlive.rdcore.models.CNWatermark;
import com.cnlive.veuisdk.CNSdkEntry;
import com.cnlive.veuisdk.CNSdkService;
import com.cnlive.veuisdk.callback.ICNCompressVideoCallback;
import com.cnlive.veuisdk.manager.CNCameraConfiguration;
import com.cnlive.veuisdk.manager.CNCompressConfiguration;
import com.cnlive.veuisdk.manager.CNEditObject;
import com.cnlive.veuisdk.manager.CNExportConfiguration;
import com.cnlive.veuisdk.manager.CNFaceuInfo;
import com.cnlive.veuisdk.manager.CNTrimConfiguration;
import com.cnlive.veuisdk.manager.CNUIConfiguration;
import com.cnlive.veuisdk.manager.CNVEOSDBuilder;
import com.cnlive.veuisdk.manager.CNVideoMetadataRetriever;
import com.rd.ve.demo.dialog.AlbumConfigDialog;
import com.rd.ve.demo.dialog.AudioConfigDialog;
import com.rd.ve.demo.dialog.CameraConfigDialog;
import com.rd.ve.demo.dialog.CompressConfigDialog;
import com.rd.ve.demo.dialog.ConfigData;
import com.rd.ve.demo.dialog.ConfigDialogListener;
import com.rd.ve.demo.dialog.EditorUIAndExportConfigDialog;
import com.rd.ve.demo.dialog.OsdConfigDialog;
import com.rd.ve.demo.dialog.VideoTrimConfigDialog;
import com.rd.ve.demo.utils.SDKUtils;

import java.util.ArrayList;

import static com.cnlive.veuisdk.manager.CNCameraConfiguration.SQUARE_SCREEN_CAN_CHANGE;


/**
 * xpkUISDK演示页
 */
@TargetApi(23)
public class MainActivity extends Activity {
    private final String TAG = "MainActivity";
    private String EDIT_PICTURE_PATH = Environment
            .getExternalStorageDirectory() + "/android.jpg";
    /**
     * 导出的横向16:9视频
     */
    private String EDIT_L_VIDEO_PATH = Environment
            .getExternalStorageDirectory() + "/demoVideo1.mp4";
    /**
     * 瓦罐
     * 测试用1：1方型视频
     */
    private String EDIT_S_VIDEO_PATH = Environment
            .getExternalStorageDirectory() + "/demoVideo2.mp4";
    /**
     * 测试用竖向9:16视频
     */
    private String EDIT_P_VIDEO_PATH = Environment
            .getExternalStorageDirectory() + "/demoVideo3.mp4";
    /**
     * 测试用水印图片
     */
    private String EDIT_WATERMARK_PATH = Environment
            .getExternalStorageDirectory() + "/watermark.png";

    /**
     * REQUEST_CODE定义：<br>
     * 录制
     */
    private final int CAMERA_REQUEST_CODE = 100;
    /**
     * REQUEST_CODE定义：<br>
     * 相册
     */
    private final int ALBUM_REQUEST_CODE = 101;

    /**
     * 从相册选折要压缩的文件
     */
    private final int ALBUM_COMPRESS_REQUEST_CODE = 1011;
    /**
     * 从相册选折要播放的视频
     */
    private final int ALBUM_PLAYER_REQUEST_CODE = 1012;

    /**
     * 防篡改录制演示
     */
    private final int CAMERA_ANTI_CHANGE_REQUEST_CODE = 1013;

    /**
     * REQUEST_CODE定义：<br>
     * 视频编辑
     */
    private final int EDIT_REQUEST_CODE = 102;
    /**
     * REQUEST_CODE定义：<br>
     * 读取外置存储
     */
    private static final int REQUEST_CODE_READ_EXTERNAL_STORAGE_PERMISSIONS = 1;

    /**
     * REQUEST_CODE定义：<br>
     * 视频截取
     */
    private final int TRIM_REQUEST_CODE = 103;
    /**
     * REQUEST_CODE定义：<br>
     * 视频截取相册选择
     */
    private final int TRIM_ALBUM_REQUEST_CODE = 104;

    /**
     * 短视频录制演示request_code
     */
    private final int SHORTVIDEO_CAMERA_REQUEST_CODE = 110;
    /**
     * 短视频录制进入相册演示request_code
     */
    private final int SHORTVIDEO_ALBUM_REQUEST_CODE = 111;
    /**
     * 短视频录制进入相册进入截取演示request_code
     */
    private final int SHORTVIDEO_TRIM_REQUEST_CODE = 112;

    /**
     * 画中画
     */
    private final int MIX_VIDEO_REQUEST_CODE = 113;


    /**
     * 选折导出的文件(仅视频)
     */
    private final int ALBUM_REQUEST_EXPORT_CODE = 114;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT) != 0) {
            finish();
            return;
        }
        setContentView(R.layout.activity_main_layout);

        EDIT_PICTURE_PATH = ((AppImpl) getApplication()).getCustomPath() + "/android.jpg";
        EDIT_L_VIDEO_PATH = ((AppImpl) getApplication()).getCustomPath() + "/demoVideo1.mp4";
        EDIT_S_VIDEO_PATH = ((AppImpl) getApplication()).getCustomPath() + "/demoVideo2.mp4";
        EDIT_P_VIDEO_PATH = ((AppImpl) getApplication()).getCustomPath() + "/demoVideo3.mp4";
        EDIT_WATERMARK_PATH = ((AppImpl) getApplication()).getCustomPath() + "/watermark.png";

        restoreConfigInstanceState();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
                && !CNSdkEntry.isInitialized()) {
            if (checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(
                        new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                        REQUEST_CODE_READ_EXTERNAL_STORAGE_PERMISSIONS);
            }
        } else {
            exportDemoResource();
        }
        // 初始化秀拍客配置
        initEditorUIAndExportConfig();
        registerAllResultHandlers();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        CNSdkEntry.onExitApp(this);
    }

    /**
     * 初始标准编辑及导出配置
     */
    private void initEditorUIAndExportConfig() {
        initAndGetConfigData();
        // 视频编辑UI配置
        CNUIConfiguration uiConfig = new CNUIConfiguration()
                // 设置是否使用自定义相册
                .setUseCustomAlbum(configData.useCustomAlbum)
                // 设置向导化
                .setEnableWizard(configData.enableWizard)
                // 设置自动播放
                .setEnableAutoRepeat(configData.enableAutoRepeat)
                // 设置MV和mv网络地址
                .setEnableMV(configData.enableMV, ConfigData.WEB_MV_URL)
                // 配音模式
                .setVoiceLayoutType(configData.voiceLayoutType)
                // 设置秀拍客相册支持格式]
                .setAlbumSupportFormatType(configData.albumSupportFormatType)
                // 设置默认进入界面画面比例
                .setVideoProportion(configData.videoProportionType)
                // 设置滤镜界面风格
                .setFilterLayoutType(configData.filterLayoutType)
                // 设置相册媒体选择数量上限(目前只对相册接口生效)
                .setMediaCountLimit(configData.albumMediaCountLimit)
                // 设置相册是否显示跳转拍摄按钮(目前只对相册接口生效)
                .setEnableAlbumCamera(configData.enableAlbumCamera)
                // 编辑与导出模块显示与隐藏（默认不设置为显示）
                .setEditAndExportModuleVisibility(
                        CNUIConfiguration.CNEditAndExportModules.SOUNDTRACK,
                        configData.enableSoundTrack)

                .setEditAndExportModuleVisibility(CNUIConfiguration.CNEditAndExportModules.DUBBING,
                        configData.enableDubbing)
                .setEditAndExportModuleVisibility(CNUIConfiguration.CNEditAndExportModules.FILTER,
                        configData.enableFilter)
                .setEditAndExportModuleVisibility(CNUIConfiguration.CNEditAndExportModules.TITLING,
                        configData.enableTitling)
                .setEditAndExportModuleVisibility(
                        CNUIConfiguration.CNEditAndExportModules.SPECIAL_EFFECTS,
                        configData.enableSpecialEffects)
                .setEditAndExportModuleVisibility(
                        CNUIConfiguration.CNEditAndExportModules.CLIP_EDITING,
                        configData.enableClipEditing)
                // 片段编辑模块显示与隐藏（默认不设置为显示）
                .setClipEditingModuleVisibility(
                        CNUIConfiguration.CNClipEditingModules.IMAGE_DURATION_CONTROL,
                        configData.enableImageDuration)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.EDIT,
                        configData.enableEdit)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.TRIM,
                        configData.enableTrim)
                .setClipEditingModuleVisibility(
                        CNUIConfiguration.CNClipEditingModules.VIDEO_SPEED_CONTROL,
                        configData.enableVideoSpeed)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.SPLIT,
                        configData.enableSplit)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.COPY,
                        configData.enableCopy)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.PROPORTION,
                        configData.enableProportion)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.SORT,
                        configData.enableSort)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.TEXT,
                        configData.enableText)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.REVERSE,
                        configData.enableReverse)
                .setClipEditingModuleVisibility(CNUIConfiguration.CNClipEditingModules.TRANSITION, true)

                // 设置自定义的网络音乐
                .setMusicUrl(ConfigData.MUSIC_URL)
                // 设置云音乐
                .setCloudMusicUrl(ConfigData.CLOUDMUSIC_URL)
                //是否显示本地音乐
                .setEnableLocalMusic(configData.enableLocalMusic)
                // 字幕、特效在mv的上面
                .setEnableTitlingAndSpecialEffectOuter(configData.enableTitlingAndSpecialEffectOuter);

        // 导出视频参数配置
        CNExportConfiguration exportConfig = new CNExportConfiguration()
                // 设置保存路径，传null或不设置
                // 将保存至默认路径(即调用SdkEntry.initialize初始时自定义路径）
                .setSavePath(null)
                //设置导出时最大边,不设置时，默认为640
                .setExportVideoMaxWH(640)
                //设置视频导出码率，Mbps为单位,不设置时，默认为4
                .setExportVideoBitRate(4)
                //设置视频导出帧率，,不设置时，默认为30
                .setExportVideoFrameRate(30)
                // 设置片尾图片路径，传null或者不设置 将没有片尾
                .setTrailerPath(configData.videoTrailerPath)
                // 设置片尾时长 单位s 默认2s
                .setTrailerDuration(2)
                // 设置导出视频时长 单位ms 传0或者不设置 将导出完整视频
                .setExportVideoDuration(configData.exportVideoDuration)
                // 设置图片水印路径
                .setWatermarkPath(configData.enableWatermark ? EDIT_WATERMARK_PATH : null)
                // 设置是否使用文字水印（使用文字水印，将不再显示图片水印）
                .setEnableTextWatermark(configData.enableTextWatermark)
                // 设置文字水印内容（开启文字水印才生效）
                .setTextWatermarkContent("watarmark")
                // 设置文字水印大小（开启文字水印才生效）
                .setTextWatermarkSize(10)
                // 设置文字水印颜色（开启文字水印才生效）
                .setTextWatermarkColor(Color.WHITE)
                // 设置文字水印阴影颜色（开启文字水印才生效）
                .setTextWatermarkShadowColor(Color.BLACK)
                // 设置水印位置 (文字或图片水印开启才生效)
                .setWatermarkShowRectF(configData.watermarkShowRectF);

        // 获取秀拍客配置服务器
        CNSdkService sdkService = CNSdkEntry.getSdkService();
        if (null != sdkService) {
            // 初始化所有配置
            sdkService.initConfiguration(exportConfig, uiConfig);
        }
    }

    /**
     * 选折相册资源
     */
    private void initUIAblumConfig() {
        // 视频编辑UI配置
        CNUIConfiguration uiConfig = new CNUIConfiguration()
                // 设置是否使用自定义相册
                .setUseCustomAlbum(false)
                // 设置秀拍客相册支持格式
                .setAlbumSupportFormatType(CNUIConfiguration.ALBUM_SUPPORT_DEFAULT)
                // 设置滤镜界面风格
                // 设置相册媒体选择数量上限(目前只对相册接口生效)
                .setMediaCountLimit(1)
                // 设置相册是否显示跳转拍摄按钮(目前只对相册接口生效)
                .setEnableAlbumCamera(false);

        // 获取秀拍客配置服务器
        CNSdkService sdkService = CNSdkEntry.getSdkService();
        if (null != sdkService) {
            // 初始化所有配置
            sdkService.initConfiguration(null, uiConfig);
        }
    }

    /**
     * 初始拍摄配置
     *
     * @param UIType * 设置录制时默认界面:<br>
     *               默认16：9录制:<br>
     *               CNCameraConfiguration#WIDE_SCREEN_CAN_CHANGE<br>
     *               默认1：1:<br>
     *               CNCameraConfiguration. SQUARE_SCREEN_CAN_CHANGE<br>
     *               仅16：9录制:<br>
     *               CNCameraConfiguration.ONLY_WIDE_SCREEN<br>
     *               仅1：1录制:<br>
     *               CNCameraConfiguration.ONLY_SQUARE_SCREEN
     */
    private void initCameraConfig(int UIType) {
        CNSdkEntry.getSdkService().initConfiguration(
                new CNCameraConfiguration()
                        // 可设置最小录制时长,0代表不限制
                        .setVideoMinTime(configData.cameraMinTime)
                        // 可设置最大录制时长,0代表不限制
                        .setVideoMaxTime(configData.cameraMaxTime)
                        // 为true代表多次拍摄，拍摄完成一段之后，将保存至相册并开始下一段拍摄，默认为false单次拍摄，拍摄完成后返回资源地址
                        .setUseMultiShoot(configData.useMultiShoot)
                        /**
                         * 设置录制时默认界面:<br>
                         * 默认16：9录制:<br>
                         * CNCameraConfiguration. WIDE_SCREEN_CAN_CHANGE<br>
                         * 默认1：1:<br>
                         * CNCameraConfiguration. SQUARE_SCREEN_CAN_CHANGE<br>
                         * 仅16：9录制:<br>
                         * CNCameraConfiguration.ONLY_SCREEN_SCREEN 仅1：1录制:<br>
                         * CNCameraConfiguration.ONLY_SQUARE_SCREEN
                         */
                        .setCameraUIType(UIType)
                        // 设置拍摄完成后，是否保存至相册（仅单次拍摄方式有效），同时通过onActivityResult及SIMPLE_CAMERA_REQUEST_CODE返回
                        .setSaveToAlbum(configData.isSaveToAlbum)
                        // 设置录制时是否静音，true代表录制后无声音
                        .setAudioMute(false)
                        // 设置是否启用人脸贴纸功能
                        .setEnableFaceU(configData.isDefaultFace)
                        // 设置人脸贴纸鉴权证书
                        .setPack(authpack.A())
                        // 设置是否默认为后置摄像头
                        .setDefaultRearCamera(configData.isDefaultRearCamera)
                        // 是否显示相册按钮
                        .setEnableAlbum(configData.enableAlbum)
                        // 是否使用自定义相册
                        .setUseCustomAlbum(configData.useCustomAlbum)
                        // 设置隐藏拍摄功能（全部隐藏将强制开启视频拍摄）
                        .setHideMV(configData.hideMV)
                        .setHidePhoto(configData.hidePhoto)
                        .setHideRec(configData.hideRec)
                        // 设置mv最小时长
                        .setCameraMVMinTime(configData.cameraMVMinTime)
                        // 设置mv最大时长
                        .setCameraMVMaxTime(configData.cameraMVMaxTime)
                        // 开启相机水印时需注册水印
                        // CNSdkEntry.registerOSDBuilder(CameraWatermarkBuilder.class);
                        // 相机录制水印
                        .setEnableWatermark(configData.enableCameraWatermark)
                        // 相机水印片头
                        .setCameraTrailerTime(CNVEOSDBuilder.CNOSDState.header, 2f)
                        // 相机录制结束时片尾水印时长(0-1.0 单位：秒)
                        .setCameraTrailerTime(CNVEOSDBuilder.CNOSDState.end,
                                configData.cameraWatermarkEnd)
                        // 是否启用防篡改录制
                        .setEnableAntiChange(configData.enableAntiChange)
                        // 启用前置输出时镜像
                        .setEnableFrontMirror(configData.enableFrontMirror)
                        // 固定录制界面的方向
                        .setOrientation(configData.mRecordOrientation)
                        // 是否支持录制时播放音乐
                        .setEnablePlayMusic(configData.enablePlayMusic)
                        // 是否美颜
                        .setEnableBeauty(configData.enableBeauty));
    }

    /**
     * 防篡改录制的相机配置
     */
    private void initCameraAntiChangeConfig() {

        CNCameraConfiguration config = new CNCameraConfiguration()
                // 可设置最小录制时长,0代表不限制
                .setVideoMinTime(configData.cameraMinTime)
                // 可设置最大录制时长,0代表不限制
                .setVideoMaxTime(configData.cameraMaxTime)
                // 为true代表多次拍摄，拍摄完成一段之后，将保存至相册并开始下一段拍摄，默认为false单次拍摄，拍摄完成后返回资源地址
                .setUseMultiShoot(false)
                /*
                 * 仅16：9录制:<br> CNCameraConfiguration.ONLY_WIDE_SCREEN
				 */
                .setCameraUIType(CNCameraConfiguration.ONLY_WIDE_SCREEN)
                // 设置拍摄完成后，是否保存至相册（仅单次拍摄方式有效），同时通过onActivityResult及SIMPLE_CAMERA_REQUEST_CODE返回
                .setSaveToAlbum(true)
                // 设置录制时是否静音，true代表录制后无声音
                .setAudioMute(false)
                // 设置是否启用人脸贴纸功能
                .setEnableFaceU(configData.isDefaultFace)
                // 设置人脸贴纸鉴权证书
                .setPack(authpack.A())
                // 设置是否默认为后置摄像头
                .setDefaultRearCamera(false)
                // 是否显示相册按钮
                .setEnableAlbum(true)
                // 是否使用自定义相册
                // .useCustomAlbum(configData.useCustomAlbum)
                // 设置隐藏拍摄功能（全部隐藏将强制开启视频拍摄）
                .setHideMV(true)
                .setHidePhoto(true)
                .setHideRec(false)
                // 设置mv最小时长
                .setCameraMVMinTime(configData.cameraMVMinTime)
                // 设置mv最大时长
                .setCameraMVMaxTime(configData.cameraMVMaxTime)
                // 开启相机水印时需注册水印
                // CNSdkEntry.registerOSDBuilder(CameraWatermarkBuilder.class);
                // 相机录制水印
                .setEnableWatermark(true)
                // 相机录制结束时片尾水印时长(0-1.0 单位：秒)
                .setCameraTrailerTime(CNVEOSDBuilder.CNOSDState.header, 2f)
                .setCameraTrailerTime(CNVEOSDBuilder.CNOSDState.end, 1f)
                // 是否启用防篡改录制
                .setEnableAntiChange(true)
                .setEnableFrontMirror(true)
                .setEnableBeauty(true);

        CNSdkService sdkService = CNSdkEntry.getSdkService();
        if (null != sdkService) {
            // 初始化所有配置
            sdkService.initConfiguration(config);
        }
    }

    /**
     * 短视频录制推荐参数
     */
    private void initCameraShortVideoConfig() {

        CNCameraConfiguration cameraConfig = new CNCameraConfiguration()
                // 为true代表多次拍摄，拍摄完成一段之后，将保存至相册并开始下一段拍摄，默认为false单次拍摄，拍摄完成后返回资源地址
                .setUseMultiShoot(false)
                /**
                 * 设置录制时默认界面:<br>
                 * 默认16：9录制:<br>
                 * CNCameraConfiguration. WIDE_SCREEN_CAN_CHANGE<br>
                 * 默认1：1:<br>
                 * CNCameraConfiguration. SQUARE_SCREEN_CAN_CHANGE<br>
                 * 仅1：1录制:<br>
                 * CNCameraConfiguration.ONLY_SQUARE_SCREEN
                 */
                .setCameraUIType(CNCameraConfiguration.ONLY_SQUARE_SCREEN)
                // 设置拍摄完成后，是否保存至相册（仅单次拍摄方式有效），同时通过onActivityResult及SIMPLE_CAMERA_REQUEST_CODE返回
                .setSaveToAlbum(true)
                // 设置录制时是否静音，true代表录制后无声音
                .setAudioMute(false)
                // 设置是否启用人脸贴纸
                .setEnableFaceU(false)
                // 设置启用人脸贴纸鉴权证书
                .setPack(authpack.A())
                // 设置是否默认为后置摄像头
                .setDefaultRearCamera(false)
                // 是否显示相册按钮
                .setEnableAlbum(true)
                // 是否使用自定义相册
                .setUseCustomAlbum(false)
                // 设置隐藏拍摄功能（全部隐藏将强制开启视频拍摄）
                .setHideMV(false)
                .setHidePhoto(true)
                .setHideRec(true)
                // 设置mv最小时长
                .setCameraMVMinTime(3)
                // 设置mv最大时长
                .setCameraMVMaxTime(15)
                // 强制美颜
                .setEnableBeauty(true);
        // 视频编辑UI配置
        CNUIConfiguration uiConfig = new CNUIConfiguration()
                // 设置是否使用自定义相册
                .setUseCustomAlbum(false)
                // 设置MV和mv网络地址
                .setEnableMV(true, ConfigData.WEB_MV_URL)
                // 设置画面比例为1:1
                .setVideoProportion(CNUIConfiguration.PROPORTION_SQUARE)
                // 相册仅支持视频
                .setAlbumSupportFormatType(CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY)
                // 设置视频选择最大数量
                .setMediaCountLimit(1)
                // 设置隐藏相册中的拍摄按钮
                .setEnableAlbumCamera(false)
                //显示配乐
                .setEditAndExportModuleVisibility(CNUIConfiguration.CNEditAndExportModules.SOUNDTRACK, true)
                //关闭配音
                .setEditAndExportModuleVisibility(CNUIConfiguration.CNEditAndExportModules.DUBBING, false)
                // 隐藏字幕
                .setEditAndExportModuleVisibility(CNUIConfiguration.CNEditAndExportModules.TITLING,
                        false)
                // 隐藏片段编辑
                .setEditAndExportModuleVisibility(
                        CNUIConfiguration.CNEditAndExportModules.CLIP_EDITING, false)
                // 隐藏特效
                .setEditAndExportModuleVisibility(
                        CNUIConfiguration.CNEditAndExportModules.SPECIAL_EFFECTS, false)
                // 启用自动重播
                .setEnableAutoRepeat(true);

        CNTrimConfiguration trimConfig = new CNTrimConfiguration()
                //设置实际截取时视频导出最大边,不设置时，默认为640
                .setExportVideoMaxWH(640)
                //设置实际截取时视频导出码率，Mbps为单位,不设置时，默认为4
                .setExportVideoBitRate(4)
                // 设置默认裁剪区域为1:1
                .setDefault1x1CropMode(true)
                // 设置截取返回类型
                .setTrimReturnMode(CNTrimConfiguration.TRIM_RETURN_TIME)
                // 设置截取类型
                .setTrimType(CNTrimConfiguration.TRIM_TYPE_SINGLE_FIXED)
                // 设置是否显示1：1按钮
                .setEnable1x1(false)
                // 设置定长截取时间
                .setTrimDuration(15);
        CNSdkEntry.getSdkService().initConfiguration(null, uiConfig,
                cameraConfig);
        CNSdkEntry.getSdkService().initTrimConfiguration(trimConfig);
    }

    /**
     * 初始压缩配置
     */
    private void initCompressConfig() {
        CNSdkService sdkService = CNSdkEntry.getSdkService();
        if (null != sdkService) {
            sdkService
                    .initCompressConfiguration(new CNCompressConfiguration()
                            // 设置是否使用硬件加速
                            .setEnableHWCode(configData.enableHWCode)
                            // 设置压缩视频码率
                            .setBitRate(configData.compressBitRate)
                            // 是否显示水印
                            .setEnableWatermark(configData.enableCompressWatermark)
                            // 显示水印的位置
                            .setWatermarkPosition(
                                    configData.compressWatermarkShowRect)
                            // 设置视频分辨率
                            .setVideoSize(configData.compressVideoWidth,
                                    configData.compressVideoHeight)
                            // 设置保存路径
                            .setSavePath(
                                    Environment.getExternalStorageDirectory()
                                            + "/xpkVideos/"));
        }
    }

    /**
     * 初始视频截取配置
     */
    private void initTrimConfig() {
        CNSdkService sdkService = CNSdkEntry.getSdkService();
        if (null != sdkService) {
            sdkService
                    .initTrimConfiguration(new CNTrimConfiguration()
                            //设置实际截取时视频导出最大边,不设置时，默认为640
                            .setExportVideoMaxWH(640)
                            //设置实际截取时视频导出码率，Mbps为单位,不设置时，默认为4
                            .setExportVideoBitRate(4)
                            // 设置默认裁剪区域为1:1
                            .setDefault1x1CropMode(
                                    configData.default1x1CropMode)
                            // 设置是否显示1:1裁剪按钮
                            .setEnable1x1(configData.enable1x1)
                            // 设置截取返回类型
                            .setTrimReturnMode(configData.mTrimReturnMode)
                            // 设置截取类型
                            .setTrimType(configData.mTrimType)
                            // 设置两定长截取时间
                            .setTrimDuration(configData.trimTime1, configData.trimTime2)
                            // 设置单个定长截取时间
                            .setTrimDuration(configData.trimSingleFixedDuration));
        }
    }

    @SuppressLint("NewApi")
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String[] permissions, int[] grantResults) {
        switch (requestCode) {
            case REQUEST_CODE_READ_EXTERNAL_STORAGE_PERMISSIONS: {
                for (int i = 0; i < permissions.length; i++) {
                    if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                        if (!CNSdkEntry.isInitialized()) {
                            ((AppImpl) getApplication()).initializeSdk();
                        }
                        exportDemoResource();
                    } else {
                        Toast.makeText(this, "未允许读写存储！", Toast.LENGTH_SHORT).show();
                        finish();
                    }
                }
            }
            break;
            default: {
                super.onRequestPermissionsResult(requestCode, permissions,
                        grantResults);
            }
        }
    }


    /**
     * 响应点击
     *
     * @param v
     */
    public void onVideo(View v) {
        switch (v.getId()) {
            case R.id.record_square: // 正方形录制视频，编辑录制后的视频，如果有导出时，导出视频的路径
                CNSdkEntry.registerOSDBuilder(CameraWatermarkBuilder.class);
                CameraWatermarkBuilder.setText("");// 可自定义水印显示文本
                initCameraConfig(CNCameraConfiguration.ONLY_SQUARE_SCREEN);
                CNSdkEntry.record(this, CAMERA_REQUEST_CODE);
                break;
            case R.id.record_wide: // 长方形录制视频，编辑录制后的视频，如果有导出时，导出视频的路径
                CNSdkEntry.registerOSDBuilder(CameraWatermarkBuilder.class);
                CameraWatermarkBuilder.setText("");// 可自定义水印显示文本
                initCameraConfig(CNCameraConfiguration.ONLY_WIDE_SCREEN);
                CNSdkEntry.record(this, CAMERA_REQUEST_CODE);
                break;
            case R.id.record: // 正方形，长方形可切换录制视频，编辑录制后的视频，如果有导出时，导出视频的路径
                CNSdkEntry.registerOSDBuilder(CameraWatermarkBuilder.class);
                CameraWatermarkBuilder.setText("");// 可自定义水印显示文本
                initCameraConfig(SQUARE_SCREEN_CAN_CHANGE);
                CNSdkEntry.record(this, CAMERA_REQUEST_CODE);
                break;
            case R.id.recordAntiChange: // 全屏录制，防篡改录制
                CNSdkEntry.registerOSDBuilder(CameraWatermarkBuilder.class);
                String osd = TextUtils.isEmpty(configData.antiChangeText) ? getString(R.string.osd_content)
                        : configData.antiChangeText;
                CameraWatermarkBuilder.setText(osd);
                initCameraAntiChangeConfig();
                CNSdkEntry.record(this, CAMERA_ANTI_CHANGE_REQUEST_CODE);


                break;

            case R.id.directEdit: // 传递资源路径，进入视频编辑，返回导出的视频的地址
                initEditorUIAndExportConfig();
                initCameraConfig(SQUARE_SCREEN_CAN_CHANGE);
//                CNSdkEntry.getSdkService().initConfiguration(
//                        new CNCameraConfiguration());
                ArrayList<String> list = new ArrayList<String>();
                list.add(EDIT_PICTURE_PATH);
                list.add(EDIT_L_VIDEO_PATH);
                CNSdkEntry.editMedia(MainActivity.this, list, EDIT_REQUEST_CODE);
                break;
            case R.id.selectMediaAndEdit: // 进入sdk媒体资源的选择界面(图片、视频)
                initEditorUIAndExportConfig();
                initCameraConfig(SQUARE_SCREEN_CAN_CHANGE);
                CNSdkEntry.selectMedia(this, EDIT_REQUEST_CODE);
                break;
            case R.id.player: // 播放器
                initUIAblumConfig();
                CNSdkEntry.openAlbum(this, CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY,
                        ALBUM_PLAYER_REQUEST_CODE);
                break;
            case R.id.export:
                initEditorUIAndExportConfig();
                CNSdkEntry.getSdkService().initConfiguration(
                        new CNCameraConfiguration());
                CNSdkEntry.openAlbum(this, CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY,
                        ALBUM_REQUEST_EXPORT_CODE);
                break;
            case R.id.trim_l: // 截取横屏视频
                initTrimConfig();
                CNSdkEntry.trimVideo(this, EDIT_L_VIDEO_PATH, TRIM_REQUEST_CODE);
                break;
            case R.id.trim_p: // 截取竖屏视频
                initTrimConfig();
                CNSdkEntry.trimVideo(this, EDIT_P_VIDEO_PATH, TRIM_REQUEST_CODE);
                break;
            case R.id.trim_s: // 截取正方型视频
                initTrimConfig();
                CNSdkEntry.trimVideo(this, EDIT_S_VIDEO_PATH, TRIM_REQUEST_CODE);
                break;
            case R.id.trim_alum:
                initUIAblumConfig();
                CNSdkEntry.openAlbum(this, CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY,
                        TRIM_ALBUM_REQUEST_CODE);
                break;
            case R.id.default_album: // 默认相册（支持图片和视频）
                initEditorUIAndExportConfig();
                CNSdkEntry.getSdkService().initConfiguration(
                        new CNCameraConfiguration());
                CNSdkEntry.openAlbum(this, CNUIConfiguration.ALBUM_SUPPORT_DEFAULT,
                        ALBUM_REQUEST_CODE);
                break;
            case R.id.only_video: // 相册只显示视频
                initEditorUIAndExportConfig();
                CNSdkEntry.getSdkService().initConfiguration(
                        new CNCameraConfiguration());
                CNSdkEntry.openAlbum(this, CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY,
                        ALBUM_REQUEST_CODE);
                break;
            case R.id.only_photo: // 相册只显示图片
                initEditorUIAndExportConfig();
                CNSdkEntry.getSdkService().initConfiguration(
                        new CNCameraConfiguration());
                CNSdkEntry.openAlbum(this, CNUIConfiguration.ALBUM_SUPPORT_IMAGE_ONLY,
                        ALBUM_REQUEST_CODE);
                break;
            case R.id.compress: // 压缩视频
                // 选折要压缩的视频
                initUIAblumConfig();
                CNSdkEntry.openAlbum(this, CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY,
                        ALBUM_COMPRESS_REQUEST_CODE);
                break;
            case R.id.ui_config: // ui配置
                if (isConfigDialogShow) {
                    return;
                }
                new EditorUIAndExportConfigDialog(this, new ConfigDialogListener() {

                    @Override
                    public void onSaveConfigData(ConfigData configData) {
                        initAndGetConfigData().setConfig(configData);
                        initEditorUIAndExportConfig();
                        initCameraConfig(SQUARE_SCREEN_CAN_CHANGE);
                        saveConfigInstanceState();
                    }

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        isConfigDialogShow = false;
                    }
                }, configData);
                isConfigDialogShow = true;
                break;
            case R.id.camera_config: // 拍摄配置
                if (isConfigDialogShow) {
                    return;
                }
                new CameraConfigDialog(this, new ConfigDialogListener() {

                    @Override
                    public void onSaveConfigData(ConfigData configData) {
                        initAndGetConfigData().setConfig(configData);
                        saveConfigInstanceState();
                    }

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        isConfigDialogShow = false;
                    }
                }, configData);
                isConfigDialogShow = true;
                break;
            case R.id.trimConfig: // 截取配置
                if (isConfigDialogShow) {
                    return;
                }
                new VideoTrimConfigDialog(this, new ConfigDialogListener() {

                    @Override
                    public void onSaveConfigData(ConfigData configData) {
                        initAndGetConfigData().setConfig(configData);
                        saveConfigInstanceState();
                    }

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        isConfigDialogShow = false;
                    }
                }, configData);
                isConfigDialogShow = true;
                break;
            case R.id.album_config: // 相册配置
                if (isConfigDialogShow) {
                    return;
                }
                new AlbumConfigDialog(this, new ConfigDialogListener() {

                    @Override
                    public void onSaveConfigData(ConfigData configData) {
                        initAndGetConfigData().setConfig(configData);
                        saveConfigInstanceState();
                    }

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        isConfigDialogShow = false;
                    }
                }, configData);
                isConfigDialogShow = true;
                break;
            case R.id.compress_config: // 压缩配置
                if (isConfigDialogShow) {
                    return;
                }
                new CompressConfigDialog(this, new ConfigDialogListener() {

                    @Override
                    public void onSaveConfigData(ConfigData configData) {
                        initAndGetConfigData().setConfig(configData);
                        initCompressConfig();
                        saveConfigInstanceState();
                    }

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        isConfigDialogShow = false;
                    }
                }, configData);
                isConfigDialogShow = true;
                break;

            case R.id.shortVideoEdit:// 15秒短视频
                initCameraShortVideoConfig();
                CNSdkEntry.record(this, SHORTVIDEO_CAMERA_REQUEST_CODE);
                break;
            case R.id.mixVideoEdit:
                registerActivityResultHandler(MIX_VIDEO_REQUEST_CODE, mixVideoResultHandler);
                CNSdkEntry.mixVideo(this, MIX_VIDEO_REQUEST_CODE);
//
                break;
            case R.id.reset_config:
                resetConfigInstanceState();
                break;
            case R.id.AntiChange_config:
                if (isConfigDialogShow) {
                    return;
                }
                new OsdConfigDialog(this, new ConfigDialogListener() {

                    @Override
                    public void onSaveConfigData(ConfigData configData) {
                        MainActivity.this.configData.antiChangeText = configData.antiChangeText;
                        initCameraAntiChangeConfig();
                        saveConfigInstanceState();
                    }

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        isConfigDialogShow = false;
                    }
                }, configData);
                isConfigDialogShow = true;
                break;
            case R.id.audio_config:
                if (isConfigDialogShow) {
                    return;
                }
                new AudioConfigDialog(this, new ConfigDialogListener() {

                    @Override
                    public void onSaveConfigData(ConfigData configData) {

                    }

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        isConfigDialogShow = false;
                    }
                });
                isConfigDialogShow = true;
                break;
            default:
                break;
        }
    }

    /**
     * TODO:registerAllResultHandlers
     */
    private void registerAllResultHandlers() {
        registerActivityResultHandler(CAMERA_REQUEST_CODE,
                cameraResultHandler);
        registerActivityResultHandler(CAMERA_ANTI_CHANGE_REQUEST_CODE,
                cameraAntiChangeResultHandler);

        registerActivityResultHandler(ALBUM_REQUEST_CODE,
                albumResultHandler);
        registerActivityResultHandler(ALBUM_COMPRESS_REQUEST_CODE,
                albumCompressResultHandler);

        registerActivityResultHandler(EDIT_REQUEST_CODE, editResultHandler);
        registerActivityResultHandler(ALBUM_PLAYER_REQUEST_CODE,
                albumPlayerResultHandler);
        registerActivityResultHandler(TRIM_REQUEST_CODE, trimResultHandler);
        registerActivityResultHandler(TRIM_ALBUM_REQUEST_CODE, trimAlbumResultHandler);


        registerActivityResultHandler(SHORTVIDEO_CAMERA_REQUEST_CODE,
                shortvideoCameraResultHandler);
        registerActivityResultHandler(SHORTVIDEO_ALBUM_REQUEST_CODE,
                shortvideoAlbumResultHandler);
        registerActivityResultHandler(SHORTVIDEO_TRIM_REQUEST_CODE,
                shortvideoTrimResultHandler);
        registerActivityResultHandler(ALBUM_REQUEST_EXPORT_CODE, albumExportResultHandler);

    }

    private ActivityResultHandler cameraResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == CNSdkEntry.RESULT_CAMERA_TO_ALBUM) {
                // 点击拍摄的相册按钮，将返回在此，并在这里做进入相册界面操作
                CNSdkEntry.openAlbum(context,
                        CNUIConfiguration.ALBUM_SUPPORT_DEFAULT,
                        ALBUM_REQUEST_CODE);
            } else if (resultCode == RESULT_OK) {
                // 美颜参数回调
                CNFaceuInfo info = data
                        .getParcelableExtra(CNSdkEntry.INTENT_KEY_FACEU);
                if (null != info) {
                    Log.e("faceu美颜参数", info.toString());
                }
                // 拍摄后返回的媒体路径
                ArrayList<String> arrMediaListPath = new ArrayList<String>();
                String videoPath = data
                        .getStringExtra(CNSdkEntry.INTENT_KEY_VIDEO_PATH);
                String picPath = data
                        .getStringExtra(CNSdkEntry.INTENT_KEY_PICTURE_PATH);
                arrMediaListPath.add(videoPath);
                arrMediaListPath.add(picPath);
                String logInfo = String.format("Video path：%s,Picture path：%s",
                        videoPath, picPath);
                Log.d(TAG, logInfo);


                if (configData.albumSupportFormatType == CNUIConfiguration.ALBUM_SUPPORT_IMAGE_ONLY) {

                    if (videoPath != null) {
                        CNSdkEntry.selectMedia(context);
                        return;
                    }
                } else if (configData.albumSupportFormatType == CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY) {
                    if (picPath != null) {
                        CNSdkEntry.selectMedia(context);
                        return;
                    }
                }

                if (data.getBooleanExtra(CNSdkEntry.INTENT_KEY_USE_MV_EDIT, false)) {
                    Log.e(TAG, "onActivityResult: mv");
                    initCameraShortVideoConfig();
                } else {
                    Log.e(TAG, "onActivityResult: false");
                    initEditorUIAndExportConfig();
                }
                CNSdkEntry.editMedia(context, arrMediaListPath);
            }
        }
    };


    private ActivityResultHandler cameraAntiChangeResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                String logInfo = String.format("Video path：%s,Picture path：%s",
                        data.getStringExtra(CNSdkEntry.INTENT_KEY_VIDEO_PATH),
                        data.getStringExtra(CNSdkEntry.INTENT_KEY_PICTURE_PATH));
                Log.d(TAG, logInfo);
                SDKUtils.onPlayVideo(context, data.getStringExtra(CNSdkEntry.INTENT_KEY_VIDEO_PATH));
            }
        }
    };
    private ActivityResultHandler mixVideoResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                String logInfo = String.format("mixVideoResultHandler Video path：%s,Picture path：%s",
                        data.getStringExtra(CNSdkEntry.INTENT_KEY_VIDEO_PATH),
                        data.getStringExtra(CNSdkEntry.INTENT_KEY_PICTURE_PATH));
                Log.d(TAG, logInfo);
//                onPlayVideo(data.getStringExtra(CNSdkEntry.INTENT_KEY_VIDEO_PATH));

                initEditorUIAndExportConfig();
                initCameraConfig(SQUARE_SCREEN_CAN_CHANGE);
                ArrayList<String> list = new ArrayList<String>();
                list.add(data.getStringExtra(CNSdkEntry.INTENT_KEY_VIDEO_PATH));
                CNSdkEntry.editMedia(MainActivity.this, list, EDIT_REQUEST_CODE);

            }
        }
    };

    private ActivityResultHandler albumResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == CNSdkEntry.RESULT_ALBUM_TO_CAMERA) {
                // 点击相册的拍摄按钮，将返回在此，并在这里做进入拍摄界面操作
                CNSdkEntry.record(context, CAMERA_REQUEST_CODE);
            } else if (resultCode == RESULT_OK) {
                // 返回选择的图片视频地址list
                ArrayList<String> arrMediaListPath = data
                        .getStringArrayListExtra(CNSdkEntry.ALBUM_RESULT);
                String logInfo = "";
                for (String path : arrMediaListPath) {
                    Log.d(TAG, path);
                    logInfo += path + "\n";
                }
                Toast.makeText(context, logInfo, Toast.LENGTH_LONG).show();
            }
        }
    };
    /**
     * 要导出的视频
     */
    private ActivityResultHandler albumExportResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                // 返回选择的图片视频地址list
                ArrayList<String> arrMediaListPath = data
                        .getStringArrayListExtra(CNSdkEntry.ALBUM_RESULT);

                for (String path : arrMediaListPath) {
                    CNVideoConfig videoConfig = new CNVideoConfig();
                    float durationS = CNVirtualVideo.getMediaInfo(path, videoConfig, true);
                    Log.d(TAG, path + "," + durationS + "," + videoConfig);
                }

                CNVideoConfig videoConfig = new CNVideoConfig();
                videoConfig.setVideoEncodingBitRate(4000 * 1000);

                int numChannel = AudioConfigDialog.audioNumChannel;
                if (numChannel == 0) {
                    numChannel = videoConfig.getAudioNumChannels();
                }
                int sampleRate = AudioConfigDialog.audioSampleRate;
                if (sampleRate == 0) {
                    sampleRate = videoConfig.getAudioSampleRate();
                }
                int audioBitRate = AudioConfigDialog.audioBitRate;
                if (audioBitRate == 0) {
                    audioBitRate = videoConfig.getAudioBitrate();
                }
                videoConfig.setAudioEncodingParameters(numChannel, sampleRate, audioBitRate);

                //.水印,左下角
                CNWatermark watermark = new CNWatermark(EDIT_WATERMARK_PATH);
                watermark.setShowRect(new RectF(0, 1f, 1f, 1.0f));
                //片尾
                CNTrailer trailer = new CNTrailer(SDKUtils.createVideoTrailerImage(MainActivity.this, "秀友", 480, 50, 50), 2f, 0.5f);

                String exportPath = Environment.getExternalStorageDirectory() + "/export.mp4";
                ExportVideoLisenter mExportListener = new ExportVideoLisenter(exportPath);
                CNSdkEntry.exportVideo(MainActivity.this, videoConfig, arrMediaListPath, exportPath, watermark, trailer, mExportListener);
            }
        }
    };

    /**
     * 导出视频的回调演示
     */
    private class ExportVideoLisenter implements CNExportListener {
        private String mPath;
        private AlertDialog mDialog;
        private ProgressBar mProgressBar;
        private Button mBtnCancel;
        private TextView mTvTitle;

        public ExportVideoLisenter(String videoPath) {
            mPath = videoPath;
        }

        @Override
        public void onExportStart() {
            View v = LayoutInflater.from(MainActivity.this).inflate(
                    R.layout.progress_view, null);
            mTvTitle = (TextView) v.findViewById(R.id.tvTitle);
            mTvTitle.setText("正在导出...");
            mProgressBar = (ProgressBar) v.findViewById(R.id.pbCompress);
            mBtnCancel = (Button) v.findViewById(R.id.btnCancelCompress);
            mBtnCancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    CNSdkEntry.cancelExport();
                }
            });
            mDialog = new AlertDialog.Builder(MainActivity.this).setView(v)
                    .show();
            mDialog.setCanceledOnTouchOutside(false);
        }

        /**
         * 导出进度回调
         *
         * @param progress 当前进度
         * @param max      最大进度
         * @return 返回是否继续执行，false为终止导出
         */
        @Override
        public boolean onExporting(int progress, int max) {
            if (mProgressBar != null) {
                mProgressBar.setMax(max);
                mProgressBar.setProgress(progress);
            }
            return true;
        }

        @Override
        public void onExportEnd(int result) {
            mDialog.dismiss();
            if (result >= CNVirtualVideo.RESULT_SUCCESS) {
                SDKUtils.onPlayVideo(MainActivity.this, mPath);
            } else if (result != CNVirtualVideo.RESULT_SAVE_CANCEL) {
                Log.e(TAG, "onExportEnd: " + result);
                Toast.makeText(MainActivity.this, "导出失败" + result, Toast.LENGTH_LONG).show();
            }
        }
    }

    private ActivityResultHandler editResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK && null != data) {
                String mediaPath = data.getStringExtra(CNSdkEntry.EDIT_RESULT);
                if (mediaPath != null) {
                    Log.d(TAG, mediaPath);
                    Toast.makeText(context, mediaPath, Toast.LENGTH_LONG)
                            .show();
                }
            }
        }
    };

    private ActivityResultHandler trimResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                float startTime = data.getFloatExtra(CNSdkEntry.TRIM_START_TIME, 0f);
                float endTime = data.getFloatExtra(CNSdkEntry.TRIM_END_TIME, 0);
                String path = data.getStringExtra(CNSdkEntry.TRIM_MEDIA_PATH);
                Rect rect = data.getParcelableExtra(CNSdkEntry.TRIM_CROP_RECT);
                String logInfo = "截取开始时间:" + startTime + "s" + ",结束时间:"
                        + endTime + "s\n裁剪区域：" + rect + "...视频:" + path;
                Log.d(TAG, logInfo);
                Toast.makeText(context, logInfo, Toast.LENGTH_LONG).show();
            }
        }
    };

    private ActivityResultHandler trimAlbumResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                ArrayList<String> arrCameraMediaListPath = data
                        .getStringArrayListExtra(CNSdkEntry.ALBUM_RESULT);
                if (arrCameraMediaListPath != null
                        && arrCameraMediaListPath.get(0) != null) {
                    String path = arrCameraMediaListPath.get(0);
                    initTrimConfig();
                    CNSdkEntry.trimVideo(context, path, TRIM_REQUEST_CODE);
                }
            }
        }
    };


    private ActivityResultHandler shortvideoCameraResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == CNSdkEntry.RESULT_CAMERA_TO_ALBUM) {
                // TODO: 按下拍摄的相册按钮，在此进入相册
                CNSdkEntry.openAlbum(context,
                        CNUIConfiguration.ALBUM_SUPPORT_VIDEO_ONLY,
                        SHORTVIDEO_ALBUM_REQUEST_CODE);
            } else if (resultCode == RESULT_OK) {
                // TODO: 拍摄完成，在此进入编辑界面
                CNFaceuInfo info = data
                        .getParcelableExtra(CNSdkEntry.INTENT_KEY_FACEU);
                if (null != info) {
                    Log.e("faceu美颜参数", info.toString());
                }

                ArrayList<String> arrMediaListPath = new ArrayList<String>();
                arrMediaListPath.add(data
                        .getStringExtra(CNSdkEntry.INTENT_KEY_VIDEO_PATH));
                CNSdkEntry.editMedia(context, arrMediaListPath);
            }
        }
    };

    private ActivityResultHandler shortvideoAlbumResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == CNSdkEntry.RESULT_ALBUM_TO_CAMERA) {
                // TODO: 按下相册的拍摄按钮，在此进入拍摄界面
                CNSdkEntry.record(context, SHORTVIDEO_CAMERA_REQUEST_CODE);
            } else if (resultCode == RESULT_OK) {
                // TODO: 选择媒体结束后，在此进入截取界面
                ArrayList<String> arrCameraMediaListPath = data
                        .getStringArrayListExtra(CNSdkEntry.ALBUM_RESULT);
                if (arrCameraMediaListPath != null) {
                    if (arrCameraMediaListPath.get(0) != null) {
                        String path = arrCameraMediaListPath.get(0);
                        // 获取视频信息
                        CNVideoMetadataRetriever vmr = new CNVideoMetadataRetriever();
                        vmr.setDataSource(path);
                        float duration = Float
                                .valueOf(vmr
                                        .extractMetadata(CNVideoMetadataRetriever.METADATA_KEY_VIDEO_DURATION));
                        int videoHeight = Integer
                                .valueOf(vmr
                                        .extractMetadata(CNVideoMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
                        int videoWidth = Integer
                                .valueOf(vmr
                                        .extractMetadata(CNVideoMetadataRetriever.METADATA_KEY_VIDEO_WIDHT));

                        if (duration < 15 && videoHeight == videoWidth) {
                            // TODO: 视频小于15秒且为正方形视频，将跳过截取，进入编辑界面
                            CNSdkEntry.editMedia(MainActivity.this,
                                    arrCameraMediaListPath,
                                    EDIT_REQUEST_CODE);
                            return;
                        }
                        CNSdkEntry.trimVideo(MainActivity.this,
                                arrCameraMediaListPath.get(0),
                                SHORTVIDEO_TRIM_REQUEST_CODE);
                    }
                }
            }
        }
    };

    private ActivityResultHandler shortvideoTrimResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                // TODO: 截取完成，在此进入编辑界面
                CNEditObject eo = new CNEditObject(
                        data.getStringExtra(CNSdkEntry.TRIM_MEDIA_PATH));
                Rect clip = data.getParcelableExtra(CNSdkEntry.TRIM_CROP_RECT);
                if (clip != null) {
                    eo.setCropRect(new RectF(clip));
                }
                eo.setStartTime(data.getFloatExtra(CNSdkEntry.TRIM_START_TIME, 0f));
                eo.setEndTime(data.getFloatExtra(CNSdkEntry.TRIM_END_TIME, 0f));
                CNSdkEntry.editMedia(context, eo, EDIT_REQUEST_CODE);
            }
        }
    };

    private ActivityResultHandler albumPlayerResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                // 返回选择的视频地址list
                ArrayList<String> arrMediaListPath = data
                        .getStringArrayListExtra(CNSdkEntry.ALBUM_RESULT);
                if (arrMediaListPath.size() > 0) {
                    if (!TextUtils.isEmpty(arrMediaListPath.get(0))) {
                        SDKUtils.onPlayVideo(context, arrMediaListPath.get(0));
                    }
                }
            }
        }
    };

    /**
     * 选择要压缩的视频资源
     */
    private ActivityResultHandler albumCompressResultHandler = new ActivityResultHandler() {

        @Override
        public void onActivityResult(Context context, int resultCode,
                                     Intent data) {
            if (resultCode == RESULT_OK) {
                // 返回选择的图片视频地址list
                ArrayList<String> arrMediaListPath = data
                        .getStringArrayListExtra(CNSdkEntry.ALBUM_RESULT);
                if (arrMediaListPath.size() > 0) {
                    if (!TextUtils.isEmpty(arrMediaListPath.get(0))) {
                        CNSdkEntry.onCompressVideo(context,
                                arrMediaListPath.get(0), iCompressVideoCallback);
                    }
                }
            }
        }
    };

    /**
     * 压缩视频回调函数
     */
    private ICNCompressVideoCallback iCompressVideoCallback = new ICNCompressVideoCallback() {
        private AlertDialog dialog;
        private ProgressBar progressBar;
        private Button btnCancel;

        @Override
        public void onCompressStart() {
            View v = LayoutInflater.from(MainActivity.this).inflate(
                    R.layout.progress_view, null);
            progressBar = (ProgressBar) v.findViewById(R.id.pbCompress);
            btnCancel = (Button) v.findViewById(R.id.btnCancelCompress);
            btnCancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    CNSdkEntry.cancelCompressVideo();
                }
            });
            dialog = new AlertDialog.Builder(MainActivity.this).setView(v)
                    .show();
            dialog.setCanceledOnTouchOutside(false);
        }

        @Override
        public void onProgress(int progress, int max) {
            if (progressBar != null) {
                progressBar.setMax(max);
                progressBar.setProgress(progress);
            }
        }

        @Override
        public void onCompressError(String errorLog) {
            Log.e(TAG, errorLog);
            if (dialog != null) {
                dialog.dismiss();
                dialog = null;
            }
        }

        @Override
        public void onCompressComplete(String path) {
            SDKUtils.onPlayVideo(MainActivity.this, path);
            if (dialog != null) {
                dialog.dismiss();
                dialog = null;
            }
        }
    };

    // 防止多次弹出对话框
    private boolean isConfigDialogShow;
    private ConfigData configData;

    /**
     * 初始化并返回配置
     */
    private ConfigData initAndGetConfigData() {
        if (configData == null) {
            configData = new ConfigData();
        }
        return configData;
    }

    /**
     * 导出测试资源
     */
    private void exportDemoResource() {

        if (!SDKUtils.isValidFile(EDIT_PICTURE_PATH)
                || !SDKUtils.isValidFile(EDIT_L_VIDEO_PATH)
                || !SDKUtils.isValidFile(EDIT_S_VIDEO_PATH)
                || !SDKUtils.isValidFile(EDIT_P_VIDEO_PATH)
                || !SDKUtils.isValidFile(EDIT_WATERMARK_PATH)) {
            new AsyncTask<Integer, Integer, Integer>() {
                private ProgressDialog m_dlgProgress;


                @Override
                protected void onPreExecute() {
                    m_dlgProgress = ProgressDialog.show(MainActivity.this,
                            null, "导出测试资源...");
                }

                @Override
                protected Integer doInBackground(Integer... params) {
                    SDKUtils.assetRes2File(getAssets(), "demomedia/android.jpg", EDIT_PICTURE_PATH);
                    SDKUtils.assetRes2File(getAssets(), "demomedia/demoVideo1.mp4", EDIT_L_VIDEO_PATH);
                    SDKUtils.assetRes2File(getAssets(), "demomedia/demoVideo2.mp4", EDIT_S_VIDEO_PATH);
                    SDKUtils.assetRes2File(getAssets(), "demomedia/demoVideo3.mp4", EDIT_P_VIDEO_PATH);
                    SDKUtils.assetRes2File(getAssets(), "watermark.png", EDIT_WATERMARK_PATH);
                    return null;
                }

                @Override
                protected void onPostExecute(Integer result) {
                    m_dlgProgress.dismiss();
                    m_dlgProgress = null;
                }
            }.execute();
        }
    }

    /**
     * 重置持续化保存的配置
     */
    private void resetConfigInstanceState() {
        configData = null;
        Toast.makeText(this,
                "所有设置重置" + (saveConfigInstanceState() ? "成功！" : "失败！"),
                Toast.LENGTH_SHORT).show();
    }

    /**
     * 持续化保存配置
     */
    private boolean saveConfigInstanceState() {
        SharedPreferences sharedPreferences = getSharedPreferences("demo",
                Context.MODE_PRIVATE);
        return CNSdkService.saveObject(sharedPreferences, "CONFIG_DATA",
                initAndGetConfigData());
    }

    /**
     * 还原持续久化保存的配置
     */
    private void restoreConfigInstanceState() {
        SharedPreferences sharedPreferences = getSharedPreferences("demo",
                Context.MODE_PRIVATE);
        configData = CNSdkService.restoreObject(sharedPreferences,
                "CONFIG_DATA", initAndGetConfigData());
    }

    private SparseArray<ActivityResultHandler> registeredActivityResultHandlers;

    /**
     * 注册响应activity result
     *
     * @param requestCode
     * @param handler
     */
    private void registerActivityResultHandler(int requestCode,
                                               ActivityResultHandler handler) {
        if (null == registeredActivityResultHandlers) {
            registeredActivityResultHandlers = new SparseArray<ActivityResultHandler>();
        }
        registeredActivityResultHandlers.put(requestCode, handler);
    }

    private interface ActivityResultHandler {
        /**
         * 响应
         *
         * @param context
         * @param resultCode The integer result code returned by the child activity
         *                   through its setResult().
         * @param data       An Intent, which can return result data to the caller
         *                   (various data can be attached to Intent "extras").
         */
        void onActivityResult(Context context, int resultCode, Intent data);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (null != registeredActivityResultHandlers) {
            ActivityResultHandler handler = registeredActivityResultHandlers
                    .get(requestCode);
            if (null != handler) {
                handler.onActivityResult(this, resultCode, data);
            }
        }
    }
}