package com.hdl.hdllinphonesdk;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Build;
import android.os.IBinder;
import android.util.Log;
import android.view.TextureView;
import android.widget.Toast;

import com.hdl.hdllinphonesdk.activity.HDLLinphoneIntercomActivity;
import com.hdl.hdllinphonesdk.activity.HDLLinphoneReverseCallActivity;
import com.hdl.hdllinphonesdk.callback.OnHDLLinphoneCallListener;
import com.hdl.hdllinphonesdk.callback.OnLPOpenDoorCallBack;
import com.hdl.hdllinphonesdk.core.callback.PhoneCallback;
import com.hdl.hdllinphonesdk.core.callback.RegistrationCallback;
import com.hdl.hdllinphonesdk.core.service.HDLLinphoneService;
import com.hdl.hdllinphonesdk.utils.HDLLog;

import org.linphone.core.AccountCreator;
import org.linphone.core.Address;
import org.linphone.core.AudioDevice;
import org.linphone.core.AuthInfo;
import org.linphone.core.Buffer;
import org.linphone.core.Call;
import org.linphone.core.CallParams;
import org.linphone.core.ChatMessage;
import org.linphone.core.ChatMessageListener;
import org.linphone.core.ChatRoom;
import org.linphone.core.Content;
import org.linphone.core.Core;
import org.linphone.core.CoreException;
import org.linphone.core.Factory;
import org.linphone.core.ParticipantImdnState;
import org.linphone.core.ProxyConfig;
import org.linphone.core.TransportType;

import java.io.FileOutputStream;
import java.io.InputStream;

import static java.lang.Thread.sleep;

/**
 * Created by jlchen on 2021/8/4.
 */
public class HDLLinphoneKit {
    /**
     * 丰林可视对讲
     */
    public static final String INTER_PHONE_TYPE_FLVI = "FLVI";
    /**
     * 大华可视对讲
     */
    public static final String INTER_PHONE_TYPE_IMOUVISIAL = "IMOUVISIAL";
    /**
     * 萤石猫眼
     */
    public static final String INTER_PHONE_TYPE_EZVIZ = "EZVIZ";
    /**
     * HDL可视对讲
     */
    public static final String INTER_PHONE_TYPE_HDL = "HDL";
    /**
     * 全视通可视对讲
     */
    public static final String INTER_PHONE_TYPE_FREEVIEW = "FREEVIEW";

    public static final String KEY_TITLE_NAME = "lpTitleName";
    public static final String KEY_SIP_ACCOUNT = "lpSipAccount";
    public static final String HDLLinphoneKitNAME = "HDLLinphoneKit";
    private volatile static HDLLinphoneKit instance;
    private Context viewContext;
    private ServiceWaitThread mServiceWaitThread;
    private String mUsername, mPassword, mServerIP,mTransportType;
    //    private TextureView mRenderingView, mPreviewView;
    private boolean isAutoJumpCallView;//是否自动跳转呼叫页面
    private String intercomeType;

    /**
     * 铃声播放器
     */
    private MediaPlayer mediaPlayer;

    /**
     * 未接事件触发时间
     */
    public int missedCallsTime = 30;

    public AudioManager audioManager;


    private HDLLinphoneKit() {

    }

    private void InitMediaPlayer(Context context) {
        if (mediaPlayer == null) {
            try {
                mediaPlayer = MediaPlayer.create(context, R.raw.oldphone_mono);
            } catch (Exception ex) {

            }
        }
    }

    private void initAudioManager(Context context){
        if(audioManager == null){
            try{
                audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
            }catch (Exception exception){

            }
        }
    }

    public int getRingerMode()
    {
        return audioManager.getRingerMode();
    }

    public boolean getMediaPlayerPlayingStatus(){
        if (mediaPlayer != null){
            return mediaPlayer.isPlaying();
        }
        return false;
    }


    // 播放铃声
    public void playRingtone() {
        if (mediaPlayer != null && !mediaPlayer.isPlaying()) {
            mediaPlayer.start(); // 开始播放
        }
    }

    /**
     * 是否循环播放铃声
     * @param isLooping
     */
    public void setMediaPlayerLooping(boolean isLooping) {
        mediaPlayer.setLooping(isLooping);
    }

    // 停止铃声
    public void stopRingtone() {
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.stop(); // 停止播放
//            mediaPlayer.reset(); // 重置 MediaPlayer
//            mediaPlayer.release(); // 释放资源
//            mediaPlayer = null;
        }
    }

    public void releaseRingtone(){
        if (mediaPlayer != null ) {
            mediaPlayer.release(); // 释放资源
            mediaPlayer = null;
        }
    }

    /**
     * getInstance
     *
     * @return HDLLinphoneKit
     */
    public static synchronized HDLLinphoneKit getInstance() {
        if (instance == null) {
            synchronized (HDLLinphoneKit.class) {
                if (instance == null) {
                    instance = new HDLLinphoneKit();
                }
            }
        }
        return instance;
    }

    /**
     * 获取 LinphoneCore
     *
     * @return Core
     */
    public Core getCore() {
        if (!HDLLinphoneService.isReady()) {
            CheckIfNeedstartService();
            return null;
        } else {
            return HDLLinphoneService.getCore();
        }
    }

    /**
     * 初始化Linphone
     *
     * @param context
     */
    public void initLinphone(Context context) {
        viewContext = context.getApplicationContext();
        if (!HDLLinphoneService.isReady()) {
            CheckIfNeedstartService();
            InitMediaPlayer(context);
            initAudioManager(context);
        } else {
        }
    }

    /**
     * startService
     */
    private synchronized void CheckIfNeedstartService() {
        startService(viewContext);
        addCallback(new RegistrationCallback() {
            @Override
            public void registrationOk() {
                super.registrationOk();
                HDLLog.e(HDLLinphoneKitNAME, "registrationOk: ");
                callBackRegistrationOk(viewContext);
            }

            @Override
            public void registrationFailed() {
                super.registrationFailed();
                HDLLog.e(HDLLinphoneKitNAME, "registrationFailed: ");
//                    Toast.makeText(LoginActivity.this, "登录失败！", Toast.LENGTH_SHORT).show();
            }
        }, null);
    }

    /**
     * 注册成功后，注册呼叫监听
     */
    void callBackRegistrationOk(Context context) {
        addCallback(null, new PhoneCallback() {
            @Override
            public void incomingCall(Call linphoneCall) {
                super.incomingCall(linphoneCall);
                Log.d("HDLLinphoneKit", "------incomingCall------");
                if (linphoneCall != null) {
                    String callUsername = linphoneCall.getRemoteAddress().getUsername();
                    HDLLog.I("来电号码：" + callUsername);
//                    HDLLog.Log("来电号码DisplayName：" + linphoneCall.getRemoteAddress().getDisplayName());
                    if (mOnHDLLinphoneCallListener != null) {
                        mOnHDLLinphoneCallListener.onIncomingCall(callUsername);
                    }
                }

                if (isAutoJumpCallView) {
                    //是否需要自动打开呼叫页面
                    gotoHDLLinphoneIntercomActivity();
                }
            }

            @Override
            public void outgoingInit() {
                super.outgoingInit();
                Log.d("HDLLinphoneKit", "------outgoingInit------");
            }

            @Override
            public void callConnected() {
                super.callConnected();
                // 视频通话默认免提，语音通话默认非免提
                Log.d("HDLLinphoneKit", "------callConnected------");
                toggleSpeaker(true);
            }

            @Override
            public void callEnd() {
                super.callEnd();
                Log.d("HDLLinphoneKit", "------callEnd------");
//                context.sendBroadcast(new Intent(HDLLinphoneIntercomActivity.RECEIVE_FINISH_VIDEO_ACTIVITY));
            }
        });
    }

    /**
     * 跳转打开呼叫页面
     */
    public void gotoHDLLinphoneIntercomActivity() {
        try {
            Intent intent = new Intent(viewContext, HDLLinphoneIntercomActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            viewContext.startActivity(intent);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private HDLLinphoneService mService;
    private final ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder ibinder) {
            HDLLinphoneService.LinphoneBinder binder = (HDLLinphoneService.LinphoneBinder) ibinder;
            mService = binder.getService();
            //初始化
            mService.initCore();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mService = null;
        }

    };

    /**
     * 开启服务
     *
     * @param context 上下文
     */
    public void startService(Context context) {
        try {
            if (!HDLLinphoneService.isReady()) {
                Intent intent = new Intent(Intent.ACTION_MAIN);
                intent.setClass(context, HDLLinphoneService.class);
                context.bindService(intent, connection, Context.BIND_AUTO_CREATE);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * onResume
     */
    public void onResume() {

    }

    /**
     * onPause
     */
    public void onPause() {

    }

    /**
     * onDestroy
     */
    public void onDestroy() {
        removePreviewWindow();
        removeVideoWindow();
    }

    /**
     * 设置 sip 账户信息
     *
     * @param username sip 账户
     * @param password 密码
     * @param serverIP sip 服务器
     */
    public void setAccountAndLogin(String username, String password, String serverIP, String inter_type) {
        mUsername = username;
        mPassword = password;
        mServerIP = serverIP;
        intercomeType = inter_type;
        mTransportType = "UDP";
        login(inter_type);
    }

    public void setAccountAndLogin(String username, String password, String serverIP, String inter_type, String transportType) {
        mUsername = username;
        mPassword = password;
        mServerIP = serverIP;
        mTransportType = transportType;
        intercomeType = inter_type;
        login(inter_type);
    }

    public String getIntercomeType() {
        return intercomeType;
    }

    /**
     * 添加注册状态、通话状态回调
     *
     * @param phoneCallback        通话回调
     * @param registrationCallback 注册状态回调
     */
    public void addCallback(RegistrationCallback registrationCallback, PhoneCallback phoneCallback) {
        if (HDLLinphoneService.isReady()) {
            HDLLinphoneService.addRegistrationCallback(registrationCallback);
            HDLLinphoneService.addPhoneCallback(phoneCallback);
        } else {
            mServiceWaitThread = new ServiceWaitThread(registrationCallback, phoneCallback);
            mServiceWaitThread.start();
        }
    }

    /**
     * 登录到 SIP 服务器
     */
    public void login(String inter_type) {
        new Thread(() -> {
            while (!HDLLinphoneService.isReady()) {
                try {
                    sleep(80);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            loginToServer(inter_type);
        }).start();
    }

    /**
     * 退出清空账号
     * enableRegister false
     */
    public void logout() {
        try {
            Core core = HDLLinphoneService.getCore();
            if (core != null) {
                ProxyConfig[] configs = core.getProxyConfigList();
                for (ProxyConfig config : configs) {
                    if (config != null) {
                        config.edit();
                        config.enableRegister(false);
                        config.done();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 清除配置表, 切换账号时会用到
     */
    public void clearProxyConfig() {
        Core core = HDLLinphoneService.getCore();
        if (core != null) {
            core.setDefaultProxyConfig(null);
            core.clearAllAuthInfo();//清除所有认证信息。
            core.clearProxyConfig();//从配置中删除所有代理。
        }
    }

    /**
     * ServiceWaitThread
     */
    private class ServiceWaitThread extends Thread {
        private PhoneCallback mPhoneCallback;
        private RegistrationCallback mRegistrationCallback;

        ServiceWaitThread(RegistrationCallback registrationCallback, PhoneCallback phoneCallback) {
            mRegistrationCallback = registrationCallback;
            mPhoneCallback = phoneCallback;
        }

        @Override
        public void run() {
            super.run();
            while (!HDLLinphoneService.isReady()) {
                try {
                    sleep(80);
                } catch (InterruptedException e) {
                    throw new RuntimeException("waiting thread sleep() has been interrupted");
                }
            }
            HDLLinphoneService.addPhoneCallback(mPhoneCallback);
            HDLLinphoneService.addRegistrationCallback(mRegistrationCallback);
            mServiceWaitThread = null;
        }
    }

    /**
     * 登录 SIP 服务器
     */
    private void loginToServer(String inter_type) {
        Log.e("==========", "loginToServer: ");

        try {
            if (mUsername == null || mPassword == null || mServerIP == null) {
                throw new RuntimeException("The sip account is not configured.");
            }
            if (inter_type.equals(INTER_PHONE_TYPE_FREEVIEW)) {
                // 全视通可视对讲注册
                freeViewRegisterUserAuth(mUsername, mPassword, mServerIP,mTransportType);
            } else {
                // 其他可视对讲注册
                registerUserAuth(mUsername, mPassword, mServerIP,mTransportType);
            }
        } catch (CoreException e) {
            e.printStackTrace();
        }
    }

    /**
     * 提交账号和密码注册到服务器
     *
     * @param name
     * @param password
     * @param host
     * @throws CoreException
     */
    public void registerUserAuth(String name, String password, String host,String transportType) throws CoreException {
        Core mLinphoneCore = HDLLinphoneService.getCore();
        if (mLinphoneCore == null) return;

        AuthInfo authInfo = Factory.instance().createAuthInfo(name, name, password, null, null, host);
        AccountCreator mAccountCreator = mLinphoneCore.createAccountCreator(null);
        mAccountCreator.setUsername(name);
        mAccountCreator.setDomain(host);
        mAccountCreator.setPassword(password);
        switch (transportType.toUpperCase()){
            case "UDP":
                mAccountCreator.setTransport(TransportType.Udp);
                Log.i("linphone", "setting : TransportType.Udp");
                break;
            case "TCP":
                mAccountCreator.setTransport(TransportType.Tcp);
                Log.i("linphone", "setting : TransportType.Tcp");
                break;
            default:
                mAccountCreator.setTransport(TransportType.Udp);
                Log.i("linphone", "default : TransportType.Udp");
                break;
        }
        ProxyConfig prxCfg = mAccountCreator.createProxyConfig();

        prxCfg.enableQualityReporting(false);
        prxCfg.setQualityReportingCollector(null);
        prxCfg.setQualityReportingInterval(0);
        prxCfg.enableRegister(true);
        mLinphoneCore.addProxyConfig(prxCfg);//添加代理配置。如果启用了注册，这将开始在代理上注册。
        mLinphoneCore.addAuthInfo(authInfo);//添加认证信息到,该信息片段将在所有需要的SIP事务中使用身份验证
        mLinphoneCore.setDefaultProxyConfig(prxCfg);//设置默认代理。

    }

    public void sendSipMessage(String sipAddress, String message) {
        try {
            Core mLinphoneCore = HDLLinphoneService.getCore();
            if (mLinphoneCore == null) {
                Log.e("Linphone", "Linphone Core 未初始化");
                return;
            }

            // 解析对方的SIP地址
            Address address = mLinphoneCore.interpretUrl(sipAddress);

            // 建立对话
            ChatRoom chatRoom = mLinphoneCore.getChatRoom(address);

            // 创建消息
            ChatMessage chatMessage = chatRoom.createMessageFromUtf8(message);

            // 监听消息状态
            chatMessage.addListener(new ChatMessageListener() {
                @Override
                public void onFileTransferSendChunk(ChatMessage message, Content content, int offset, int size, Buffer buffer) {
                    // 文件传输的分块发送回调，未使用
                }

                @Override
                public void onMsgStateChanged(ChatMessage message, ChatMessage.State state) {
                    if (state == ChatMessage.State.Delivered) {
                        Log.d("Linphone", "消息已成功发送");
                    } else if (state == ChatMessage.State.NotDelivered) {
                        Log.d("Linphone", "消息发送失败");
                    }
                }

                @Override
                public Buffer onFileTransferSend(ChatMessage message, Content content, int offset, int size) {
                    return null;  // 文件传输回调，未使用
                }

                @Override
                public void onEphemeralMessageDeleted(ChatMessage message) {
                    // 临时消息删除回调，未使用
                }

                @Override
                public void onEphemeralMessageTimerStarted(ChatMessage message) {
                    // 临时消息计时器开始回调，未使用
                }

                @Override
                public void onParticipantImdnStateChanged(ChatMessage message, ParticipantImdnState state) {
                    // 参与者消息通知状态改变回调，未使用
                }

                @Override
                public void onFileTransferRecv(ChatMessage message, Content content, Buffer buffer) {
                    // 文件传输接收回调，未使用
                }

                @Override
                public void onFileTransferProgressIndication(ChatMessage message, Content content, int offset, int total) {
                    // 文件传输进度回调，未使用
                }
            });
            // 发送消息
            chatMessage.send();

        } catch (Exception e) {
            Log.e("Linphone", "消息发送失败", e);
            e.printStackTrace();
        }
    }



    /**
     * 提交账号和密码注册到全视通服务器
     *
     * @throws CoreException
     */
    public void freeViewRegisterUserAuth(String userName, String password, String domain,String transportType) throws CoreException {
        Core mLinphoneCore = HDLLinphoneService.getCore();
        if (mLinphoneCore == null) return;

        AuthInfo authInfo = Factory.instance().createAuthInfo(userName, "", password, null, null, domain);

        AccountCreator mAccountCreator = mLinphoneCore.createAccountCreator(null);
        mAccountCreator.setUsername(userName);
        mAccountCreator.setDomain("yun");
        mAccountCreator.setPassword(password);

        switch (transportType.toUpperCase()){
            case "UDP":
                mAccountCreator.setTransport(TransportType.Udp);
                Log.i("linphone", "setting : TransportType.Udp");
                break;
            case "TCP":
                mAccountCreator.setTransport(TransportType.Tcp);
                Log.i("linphone", "setting : TransportType.Tcp");
                break;
            default:
                mAccountCreator.setTransport(TransportType.Udp);
                Log.i("linphone", "default : TransportType.Udp");
                break;
        }

        ProxyConfig prxCfg = mAccountCreator.createProxyConfig();
        prxCfg.enableQualityReporting(false);
        prxCfg.setQualityReportingCollector(null);
        prxCfg.setQualityReportingInterval(0);
        prxCfg.enableRegister(true);
        //全视通需要设置固定代理服务器ip
        prxCfg.setServerAddr("sip:139.159.157.75:46000;transport=udp");

        mLinphoneCore.addProxyConfig(prxCfg);//添加代理配置。如果启用了注册，这将开始在代理上注册。
        mLinphoneCore.addAuthInfo(authInfo);//添加认证信息到,该信息片段将在所有需要的SIP事务中使用身份验证
        mLinphoneCore.setDefaultProxyConfig(prxCfg);//设置默认代理。
    }

    /**
     * 呼叫,全视通可视对讲需要将 外出代理服务器打开，才能使用 空间号呼叫；
     * 暂时没找到怎么打开，所以需要手动加上proxy
     */
    public Call startSingleCallingTo(String userName, boolean isVideoCall) {
        Core mLinphoneCore = HDLLinphoneService.getCore();
        if (mLinphoneCore == null) return null;

        Call call = null;
        Core core = HDLLinphoneService.getCore();
        if (core != null) {
            Address addressToCall = core.interpretUrl(userName);
            CallParams params = core.createCallParams(null);

            if (isVideoCall) {
                params.enableVideo(true);
                params.enableLowBandwidth(false);
                params.setAudioBandwidthLimit(0); // disable limitation
            } else {
                params.enableVideo(false);
                params.setAudioBandwidthLimit(40); // disable limitation
            }

            if (addressToCall != null) {
                call = core.inviteAddressWithParams(addressToCall, params);
                // 设置外放
                try {
                    for (AudioDevice audioDevice : HDLLinphoneService.getCore().getAudioDevices()) {
                        if (audioDevice.getType() == AudioDevice.Type.Speaker) {
                            call.setOutputAudioDevice(audioDevice);
                        }
                    }
                }catch (Exception exception){
                    Log.e("LinphoneError",exception.getMessage());
                }
            }
        }
        return call;
    }

    /**
     * 呼叫指定号码
     *
     * @param num 呼叫号码
     */
    public void callTo(String num, boolean isVideoCall) {
        if (!HDLLinphoneService.isReady() || !HDLLinphoneService.getCoreIsNotNull()) {
            return;
        }
        if (!num.equals("")) {
            startSingleCallingTo(num, isVideoCall);
        }
    }

    /**
     * 接听来电
     */
    public void acceptCall() {
        try {
            if (HDLLinphoneService.getCore() == null) return;
            Call currentCall = HDLLinphoneService.getCore().getCurrentCall();
            CallParams params = HDLLinphoneService.getCore().createCallParams(currentCall);
            params.enableVideo(true);
            params.enableLowBandwidth(false);
            params.setAudioBandwidthLimit(0); // disable limitation
            currentCall.acceptWithParams(params);
            Log.d("HDLLinphoneKit", "---acceptCall= ");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 接听来电
     */
    public void acceptCallWithVideo(boolean enableVideo) {
        try {
            if (HDLLinphoneService.getCore() == null) return;
            Call currentCall = HDLLinphoneService.getCore().getCurrentCall();
            CallParams params = HDLLinphoneService.getCore().createCallParams(currentCall);
            params.enableVideo(enableVideo);
            params.setAudioBandwidthLimit(enableVideo ? 0 : 40);
            currentCall.acceptWithParams(params);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 挂断电话
     */
    public void hangUp() {
        Core mLinphoneCore = HDLLinphoneService.getCore();
        if (mLinphoneCore == null) return;
        Call currentCall = mLinphoneCore.getCurrentCall();
        if (currentCall != null) {
//            mLinphoneCore.terminateCall(currentCall);
            mLinphoneCore.terminateAllCalls();
        } else if (mLinphoneCore.isInConference()) {
            mLinphoneCore.terminateConference();
        } else {
            mLinphoneCore.terminateAllCalls();
        }
    }

    /**
     * 是否静音
     *
     * @param isMicMuted
     */
    public void toggleMicro(boolean isMicMuted) {
        Core mLinphoneCore = HDLLinphoneService.getCore();
        if (mLinphoneCore == null) return;
        mLinphoneCore.enableMic(!isMicMuted);
    }

    /**
     * 是否外放
     *
     * @param isSpeakerEnabled
     */
    public void toggleSpeaker(boolean isSpeakerEnabled) {
        routeAudioToSpeakerHelper(isSpeakerEnabled);
    }

    /**
     * 设置外放设备
     */
    private void routeAudioToSpeakerHelper(boolean speakerOn) {
        Log.d("HDLLinphoneKit", "设置外放设备[Audio Manager] Routing audio to " + (speakerOn ? "speaker" : "earpiece"));
        try {
            if (HDLLinphoneService.getCore() == null) return;
            if (HDLLinphoneService.getCore().getCallsNb() == 0) return;
            Call currentCall = HDLLinphoneService.getCore().getCurrentCall();
            if (currentCall == null) currentCall = HDLLinphoneService.getCore().getCalls()[0];
            if (currentCall == null) return;

            for (AudioDevice audioDevice : HDLLinphoneService.getCore().getAudioDevices()) {
                Log.d("HDLLinphoneKit", "audioDevice.getType()= " + audioDevice.getType());
            }

            for (AudioDevice audioDevice : HDLLinphoneService.getCore().getAudioDevices()) {
                Log.d("HDLLinphoneKit", "设置外放设备speakerOn=" + speakerOn + " audioDevice.getType()=" + audioDevice.getType());
                if (speakerOn && audioDevice.getType() == AudioDevice.Type.Speaker) {
                    currentCall.setOutputAudioDevice(audioDevice);
                    Log.d("HDLLinphoneKit", "AudioDevice.Type.Speaker");
                    return;
                } else if (!speakerOn && audioDevice.getType() == AudioDevice.Type.Earpiece) {
                    currentCall.setOutputAudioDevice(audioDevice);
                    return;
                }
            }
            currentCall.setSpeakerVolumeGain(1.0f);
            currentCall.setSpeakerMuted(speakerOn);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 设置 TextureView
     *
     * @param renderingView 远程 TextureView
     * @param previewView   本地 TextureView
     */
    public void setAndroidVideoWindow(final TextureView renderingView, final TextureView previewView) {
//        mRenderingView = renderingView;
//        mPreviewView = previewView;
        setVideoWindow(renderingView);
        setPreviewWindow(previewView);

    }

    /**
     * 设置播放View
     *
     * @param o
     */
    private void setVideoWindow(Object o) {
        Core linphoneCore = HDLLinphoneService.getCore();
        if (linphoneCore != null) {
            linphoneCore.setNativeVideoWindowId(o);
        }
    }

    /**
     * 移除播放View
     */
    private void removeVideoWindow() {
        Core linphoneCore = HDLLinphoneService.getCore();
        if (linphoneCore != null) {
            linphoneCore.setNativeVideoWindowId(null);
        }
    }

    /**
     * 设置本机摄像头采集的View
     *
     * @param o
     */
    private void setPreviewWindow(Object o) {
        Core linphoneCore = HDLLinphoneService.getCore();
        if (linphoneCore != null) {
            linphoneCore.setNativePreviewWindowId(o);
        }
    }

    /**
     * 移除视频采集View
     */
    private void removePreviewWindow() {
        Core linphoneCore = HDLLinphoneService.getCore();
        if (linphoneCore != null) {
            linphoneCore.setNativePreviewWindowId(null);
        }
    }

    /**
     * 获取当前通话状态
     */
    public Call.State getCallState() {
        if (HDLLinphoneService.getInstance() == null) {
            return null;
        } else {
            return HDLLinphoneService.getInstance().getCurrentCallState();
        }
    }

    /**
     * 获取当前通话状态是否为来电中
     */
    public boolean isIncomingReceivedCallState() {
        if (HDLLinphoneService.getInstance() == null || HDLLinphoneService.getInstance().getCurrentCallState() == null) {
            return false;
        } else {
            return (HDLLinphoneService.getInstance().getCurrentCallState() == Call.State.IncomingReceived);
        }
    }

    /**
     * 是否自动跳转呼叫页面方案
     */
    public boolean isAutoJumpCallView() {
        return isAutoJumpCallView;
    }

    /**
     * 设置是否自动跳转呼叫页面标志
     *
     * @param autoJumpCallView
     */
    public void setAutoJumpCallView(boolean autoJumpCallView) {
        isAutoJumpCallView = autoJumpCallView;
    }

    /**
     * 开门回调接口
     */
    private OnLPOpenDoorCallBack openOpenDoorCallBack;

    /**
     * setOpenOpenDoorCallBack
     */
    public void setOpenOpenDoorCallBack(OnLPOpenDoorCallBack openOpenDoorCallBack) {
        this.openOpenDoorCallBack = openOpenDoorCallBack;
    }

    /**
     * 通知开门成功
     */
    public void onOpenSuccess() {
        if (openOpenDoorCallBack != null) {
            openOpenDoorCallBack.onOpenSuccess();
        }
    }

    /**
     * 通知开门失败
     */
    public void onOpenError(String mes) {
        if (openOpenDoorCallBack != null) {
            openOpenDoorCallBack.onOpenError(mes);
        }
    }

    /**
     * 呼叫页面相关操作回调接口
     */
    private OnHDLLinphoneCallListener mOnHDLLinphoneCallListener;

    /**
     * 获取onHDLLinphoneCallListener
     * 接听、挂断、开锁等 Listener实现
     *
     * @return OnHDLLinphoneCallListener
     */
    public OnHDLLinphoneCallListener getOnHDLLinphoneCallListener() {
        return mOnHDLLinphoneCallListener;
    }

    /**
     * 设置onHDLLinphoneCallListener
     *
     * @param onHDLLinphoneCallListener
     */
    public void setOnHDLLinphoneCallListener(OnHDLLinphoneCallListener onHDLLinphoneCallListener) {
        mOnHDLLinphoneCallListener = onHDLLinphoneCallListener;
    }

    /**
     * showToast
     */
    private void showToast(String text) {
        Toast.makeText(viewContext, text, Toast.LENGTH_SHORT).show();
    }
}