package kr.co.icontrols.callengine.engine;

import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Matrix;
import android.media.AudioManager;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

import com.artncore.WallPadDataMgr.WallpadDeviceSet;
import com.artncore.WallPadDataMgr.wallpaddbmgr;
import com.artncore.commons.define;
import com.artncore.wallpadapi.Sdb_LivingRoomLightAPI;
import com.artncore.wallpadapi.WallPadAPI;
import com.artncore.wallpadimap.RetProci;
import com.util.LogUtil;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

import bssoft.stack.sip.SIPStack;
import ceres.api.SipManager;
import ceres.cminterface.CMInterface;
import kr.co.icontrols.callengine.engine.SIPInterface.SIPEventListener;
import kr.co.icontrols.callengine.remotecall.RemoteCallMSG;
import kr.co.icontrols.callengine.sip.SIPController;
import kr.co.icontrols.callengine.sip.SIPStun;
import kr.co.icontrols.callengine.subphone.SubPhoneCmds.SUBPHONEHANDELKEY;
import kr.co.icontrols.wallpadcall.MainActivity;
import kr.co.icontrols.wallpadcall.R;
import kr.co.icontrols.wallpadcall.declare.DataClasses.MultiCallInfo;
import kr.co.icontrols.wallpadcall.declare.DataClasses.PSTNInfo;
import kr.co.icontrols.wallpadcall.declare.DataClasses.RemoteIDInfo;
import kr.co.icontrols.wallpadcall.declare.DataClasses.VisitorPictureHistoryUnit;
import kr.co.icontrols.wallpadcall.declare.Declare;
import kr.co.icontrols.wallpadcall.declare.Declare.DBInfo;
import kr.co.icontrols.wallpadcall.declare.Declare.DEVICENAME;
import kr.co.icontrols.wallpadcall.declare.Declare.DeviceType;
import kr.co.icontrols.wallpadcall.declare.Declare.IGW300CMD;
import kr.co.icontrols.wallpadcall.declare.Global;
import kr.co.icontrols.wallpadcall.declare.Global.BOARD_TYPE;
import kr.co.icontrols.wallpadcall.declare.Global.ConfigValues;
import kr.co.icontrols.wallpadcall.declare.Global.FRONTCAMERATYPE;
import kr.co.icontrols.wallpadcall.declare.Global.WALLPADTYPE;
import kr.co.icontrols.wallpadcall.declare.ID;
import kr.co.icontrols.wallpadcall.imap.Request_check_sip_activation;
import kr.co.icontrols.wallpadcall.screen.TalkFront;
import kr.co.icontrols.wallpadsupport.Version;
import kr.co.icontrols.wallpadsupport.Version.MODEL_TYPE;

public class CallController extends CallManager implements SIPEventListener {

    static String TAG = "CallController";

    boolean bLOG = true;

    private void LOG(String log) {
        if (bLOG) Log.v(TAG, log);
    }

    boolean bLOG_DEBUG = false;

    private void LOG_DEBUG(String log) {
        if (bLOG_DEBUG) Log.d(TAG, log);
    }

    boolean bLOG_INFO = true;

    private void LOG_INFO(String log) {
        if (bLOG_INFO) Log.i(TAG, log);
    }

    boolean bLOG_WARN = true;

    private void LOG_WARN(String log) {
        if (bLOG_WARN) Log.w(TAG, log);
    }

    Context mContext;
    public VideoJNI mVideoJNI;
    public SIPInterface mSIPInterface;
    public CallInfo mCallInfo;
    public CTT mCTT;
    public MultiCallInfo mMultiCallInfo;
    public int mCurrentScreenId_update = -1;

    WallPadAPI mWallPadAPI = null;
    Sdb_LivingRoomLightAPI sdbLivingRoomLightAPI = null;

    private CMInterface mCMIF = null;

    public CallController(Context context, WallPadAPI wallPadAPI) {
        try {
            LOG_INFO("[CallController]");
            mContext = context;

            if(mCMIF == null){
                mCMIF = new CMInterface();
            }

            if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                mWallPadAPI = wallPadAPI;
                initAPI();
            }

            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) {
                mSIPInterface = new SIPInterface(mContext);
                mSIPInterface.setSIPEventListener(this);
            }

            mVideoJNI = new VideoJNI();
            setCallManagerContext(mContext);
            mCallInfo = new CallInfo();
            mCallInfo.resetCallStatus();
            mCTT = new CTT();

//            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) {
//                mSIPInterface = new SIPInterface(mContext);
//                mSIPInterface.setSIPEventListener(this);
//            }

        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] CallController(context)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void releaseCallController() {
        try {
            LOG_INFO("[releaseCallController]");

            setTalkPath(CALLPATH.NORMAL);
            quitMoIPCall();
            rejectMoIPCall();
            rejectMoIPMultiCall();
            mCallInfo.resetAllCallInfo();
            stop1stCallTimer();
            stop2ndCallTimer();
//            stop3rdCallTimer();

            mCallInfo = null;
            mCTT = null;

            if (mVideoJNI != null) {
                mVideoJNI.deallocate();
                mVideoJNI = null;
            }

            if (mSIPInterface != null) {
                mSIPInterface.setSIPEventListener(null);
                mSIPInterface.releaseSIPInterface();
            }

            if (mWallPadApiCheckHandler != null) {
                mWallPadApiCheckHandler.removeMessages(0);
                mWallPadApiCheckHandler.removeMessages(1);
            }

            releaseAPI();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] releaseCallController()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void initAPI() {
        try {
            if (mWallPadAPI != null) {
                Log.w(TAG, "[initAPI] --------------- sdbLivingRoomLightAPI is connected!! ---------------");
                sdbLivingRoomLightAPI = mWallPadAPI.Get_Sdb_LivingRoomLightAPI();
            } else {
                Log.w(TAG, "[initAPI] --------------- mWallPadAPI is null ---------------");
                mWallPadApiCheckHandler.sendEmptyMessage(0);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] initAPI()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void releaseAPI() {
        try {
            if (sdbLivingRoomLightAPI != null) sdbLivingRoomLightAPI = null;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] releaseAPI()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    int apiHandlerCnt1 = 0, apiHandlerCnt2 = 0;
    protected Handler mWallPadApiCheckHandler = new Handler() {
        public void handleMessage(Message msg) {
            if (msg.what == 0) {
                apiHandlerCnt1++;
                if (apiHandlerCnt1 > 1000) {
                    Log.w(TAG, "[mWallPadApiCheckHandler] apiHandlerCnt1 is over!! [" + apiHandlerCnt1 + "]");
                    mWallPadApiCheckHandler.removeMessages(0);
                    mWallPadApiCheckHandler.removeMessages(1);
                } else {
                    if (mWallPadAPI != null) {
                        if (mWallPadAPI.Check_Connect())
                            mWallPadApiCheckHandler.sendEmptyMessageDelayed(1, 10);
                        else mWallPadApiCheckHandler.sendEmptyMessageDelayed(0, 10);
                    }
                }
            } else if (msg.what == 1) {
                sdbLivingRoomLightAPI = mWallPadAPI.Get_Sdb_LivingRoomLightAPI();
                Log.d(TAG, "[mWallPadApiCheckHandler.handleMessage] sdbLivingRoomLightAPI is connected !!!");
            } else if (msg.what == 2) {
                apiHandlerCnt2++;
                if (apiHandlerCnt2 > 1000) {
                    Log.w(TAG, "[mWallPadApiCheckHandler] apiHandlerCnt2 is over!! [" + apiHandlerCnt2 + "]");
                    mWallPadApiCheckHandler.removeMessages(2);
                    mWallPadApiCheckHandler.removeMessages(3);
                } else {
                    if (mWallPadAPI != null) {
                        if (mWallPadAPI.Check_Connect())
                            mWallPadApiCheckHandler.sendEmptyMessageDelayed(3, 10);
                        else mWallPadApiCheckHandler.sendEmptyMessageDelayed(2, 10);
                    }
                }
            } else if (msg.what == 3) {
                sdbLivingRoomLightAPI = mWallPadAPI.Get_Sdb_LivingRoomLightAPI();
                Log.d(TAG, "[mWallPadApiCheckHandler] sdbLivingRoomLightAPI.SetWifiModuleOnOff [FALSE]");
                sdbLivingRoomLightAPI.SetWifiModuleOnOff(false);
            }
        }
    };

    CallEventListener mCallEventListener;

    public interface CallEventListener {
        public void onCallEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, String strRemoteIP, String strRemoteSIPID, String strMessage);

        public void onSubPhoneEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, String strTargetID, String strMessage);

        public void onVideoSet(boolean bSet, String strRemoteSIPID);

        public void onShowRemoteVideo(boolean bShow);
    }

    public void setCallEventListener(CallEventListener SIPEV) {
        mCallEventListener = SIPEV;
    }

    public void releaseCallEventListener() {
        mCallEventListener = null;
    }

    // SubWallPad
    public interface SubWallPadEventListener {
        public void onSubWallPadCallEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, String strTargetID, String strMessage);
    }

    SubWallPadEventListener mSubWallPadEventListener;

    public void setSubWallPadEventListener(SubWallPadEventListener SIPEV) {
        mSubWallPadEventListener = SIPEV;
    }

    public void releaseSubWallPadEventListener() {
        mSubWallPadEventListener = null;
    }

    public interface DTMFEventListener {
        public void onDTMFEvent(String strMessage);
    }

    DTMFEventListener mDTMFEventListener;

    public void setDTMFEventListener(DTMFEventListener DTMFEV) {
        mDTMFEventListener = DTMFEV;
    }

    public void releaseDTMFEventListener() {
        mDTMFEventListener = null;
    }

    public boolean checkSIPActivation() {
        try {
            if (mSIPInterface != null) return mSIPInterface.checkSIPActivation();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] checkSIPActivation()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    public boolean tryMoIPCall(CALLTYPE eCallType, String strHeadID, String strTailID) {
        try {
            if (eCallType == CALLTYPE.RESIDENCE || eCallType == CALLTYPE.RENTRESIDENCE) {
                if (mSIPInterface != null) {
                    mSIPInterface.makeResidenceCall(eCallType, strHeadID, strTailID);
                    mCallInfo.setCallStatus(CALLTYPE.RESIDENCE, CALLSTATUS.WAITNG_INVITE_ACK);
                    set1stCallTimer(eCallType, mCTT.WAITNG_INVITE_ACK);
                    return true;
                }
            } else if (eCallType == CALLTYPE.GUARD) {
                if (mSIPInterface != null) {
                    CALLOWNER eCallOwner = MainActivity.mCallController.mCallInfo.getCallOwner();
                    LOG("[tryMoIPCall] eCallOwner [" + eCallOwner  + "]");
                    if (eCallOwner == CALLOWNER.MOBILE) SIPController.bMobileCall = true; // 모바일에서 경비실 통화 요청시 플래그 설정 필요
                    else SIPController.bMobileCall = false;
                    LOG("[tryMoIPCall] bMobileCall [" + SIPController.bMobileCall + "]");
                    mSIPInterface.makeGuardCall(strHeadID, strTailID);
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.WAITNG_INVITE_ACK);
                    set1stCallTimer(eCallType, mCTT.WAITNG_INVITE_ACK);
                    return true;
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] tryMoIPCall(eCallType, strHeadID, strTailID)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    public CALLTYPE tryAutoCall(String strTargetIP, String strName) {
        try {
            LOG_INFO("[tryAutoCall] strTargetIP [" + strTargetIP + "], strName [" + strName + "]");
            if (strTargetIP.equals("FRONT")) {
                RemoteIDInfo.bAutoCall = true;
                ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKFRONT);
                return CALLTYPE.FRONT;
            } else if (strTargetIP.contains("PSTN")) {
                RemoteIDInfo.bAutoCall = true;
                RemoteIDInfo.strPSTNInfo = strName;
                ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKPSTN);
                return CALLTYPE.PSTN;
            }

            String strHeadID = "101";
            String strTailID = "101";

            String[] IP_Parse = strTargetIP.split("\\.");

            if (ConfigValues.bIPExpansion) {
                if (IP_Parse[1].equals("0")) {
                    strHeadID = "100";
                } else {
                    strHeadID = Integer.toString((Integer.parseInt(IP_Parse[0]) * 100) + Integer.parseInt(IP_Parse[1]));
                }
            } else {
                strHeadID = Integer.toString((((Integer.parseInt(Global.getDongString()) / 100) * 100) + Integer.parseInt(IP_Parse[1])));
            }
            LOG_INFO("[tryAutoCall] strHeadID [" + strHeadID + "]");

            if (IP_Parse[2].equals("128")) strTailID = IP_Parse[3];   // 경비실
            else if (IP_Parse[2].equals("0")) strTailID = IP_Parse[3];   // 로비폰
            else if (IP_Parse[2].equals("201")) strTailID = IP_Parse[3];   // 아이허브
            else {
                if (ConfigValues.bEnableHouseDivision) {
                    int nTailID = Integer.parseInt(IP_Parse[3]);

                    if (200 < nTailID) {
                        RemoteIDInfo.bRentRoomSelected = true;
                        nTailID = nTailID - 200;
                    }
                    strTailID = IP_Parse[2] + Global.ZeroPadding_Head(2, Integer.toString(nTailID));   // 세대
                } else {
                    strTailID = IP_Parse[2] + Global.ZeroPadding_Head(2, IP_Parse[3]);   // 세대
                }
            }

            if (IP_Parse[2].equals("128")) {
                RemoteIDInfo.strDong = strHeadID;
                RemoteIDInfo.strHo = strTailID;
                RemoteIDInfo.strIP = strTargetIP;
                RemoteIDInfo.strName = strName;
                RemoteIDInfo.bAutoCall = true;
                ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKGUARD);
                return CALLTYPE.GUARD;
            } else if (IP_Parse[2].equals("0")) {
                // Lobby
                return CALLTYPE.LOBBY;
            } else if (IP_Parse[2].equals("201")) {
                // Ihub
                return CALLTYPE.IHUB;
            } else {
                int nType = Integer.parseInt(IP_Parse[2]);
                if (0 < nType && nType < 100) {
                    RemoteIDInfo.strDong = strHeadID;
                    RemoteIDInfo.strHo = strTailID;
                    RemoteIDInfo.strIP = strTargetIP;
                    RemoteIDInfo.strName = strName;
                    RemoteIDInfo.bAutoCall = true;
                    ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKRESIDENCE);
                    return CALLTYPE.RESIDENCE;
                } else {
                    RemoteIDInfo.InitVariables();
                    return CALLTYPE.NONE;
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return CALLTYPE.NONE;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] tryAutoCall(strTargetIP, strName)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            RemoteIDInfo.InitVariables();
            return CALLTYPE.NONE;
        }
    }

    public CALLTYPE tryAutoMoIPCall(String strTargetIP, String strTargetURI) {
        try {
            LOG_INFO("[tryAutoMoIPCall] strTargetIP [" + strTargetIP + "], strTargetURI [" + strTargetURI + "]");

            String[] strParsed_01 = strTargetURI.split("_");

            if (strTargetURI.contains("_Guard_")) {
                RemoteIDInfo.strDong = strParsed_01[2];
                RemoteIDInfo.strHo = strParsed_01[3];
                RemoteIDInfo.strIP = strTargetIP;
                RemoteIDInfo.strName = Integer.toString(Integer.parseInt(RemoteIDInfo.strDong)) + "동 " + Integer.toString(Integer.parseInt(RemoteIDInfo.strHo)) + "번";
                RemoteIDInfo.bAutoCall = true;
                return CALLTYPE.GUARD;
            } else if (strTargetURI.contains("_Lobby_")) {
                LOG_WARN("[tryAutoMoIPCall] Not supported Target -> Lobby");
                RemoteIDInfo.InitVariables();
                return CALLTYPE.LOBBY;
            } else if (strTargetURI.contains("_Resi_")) {
                RemoteIDInfo.strDong = strParsed_01[2];
                RemoteIDInfo.strHo = strParsed_01[3];
                RemoteIDInfo.strIP = strTargetIP;
                RemoteIDInfo.strName = Integer.toString(Integer.parseInt(RemoteIDInfo.strDong)) + "동 " + Integer.toString(Integer.parseInt(RemoteIDInfo.strHo)) + "호";
                RemoteIDInfo.bAutoCall = true;
                return CALLTYPE.RESIDENCE;
            } else {
                RemoteIDInfo.InitVariables();
                return CALLTYPE.NONE;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return CALLTYPE.ERROR;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] tryAutoMoIPCall(String strTargetIP, String strTargetURI)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            RemoteIDInfo.InitVariables();
            return CALLTYPE.ERROR;
        }
    }

    public boolean acceptMoIPCall(boolean bMobile) {
        try {
            LOG_INFO("[acceptMoIPCall] bMobile [" + bMobile + "]");
            if (mSIPInterface != null) {
                mSIPInterface.acceptMoIPCall(bMobile);
                return true;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] acceptMoIPCall()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    public boolean quitMoIPCall() {
        try {
            Log.d(TAG, "[quitMoIPCall]");
            if (mSIPInterface != null) {
                mSIPInterface.ui_callEnd();
                return true;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] quitMoIPCall()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    public boolean rejectMoIPCall() {
        try {
            if (mSIPInterface != null) {
                mSIPInterface.rejectCall();
                return true;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] rejectMoIPCall()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    public boolean rejectMoIPMultiCall() {
        try {
            if (mSIPInterface != null) {
                mSIPInterface.rejectMultiCall();
                return true;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] rejectMoIPMultiCall()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    public boolean rejectBusyMoIPCall() {
        try {
            if (mSIPInterface != null) {
                mSIPInterface.rejectBusyCall();
                return true;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return false;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] rejectBusyMoIPCall()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return false;
        }
        return false;
    }

    public void CallScenarioManager(CALLOWNER eCallOwner, CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strRemoteIP, String strRemoteSIPID, String strMessage) {
        try {
            LOG_INFO("[CallScenarioManager] eCallOwner [" + eCallOwner + "], eEventType [" + eEventType + "], eCallType [" + eCallType + "], strRemoteIP [" + strRemoteIP + "], strRemoteSIPID [" + strRemoteSIPID + "], strMessage [" + strMessage + "]");
            mCallInfo.printCallStatus();

            if (eEventType == CALLEVENTTYPE.CALLERID) {
                // Caller ID
                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.CALLERID, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                } else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.REQUEST_FRONT_MONITORING) {
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    if (eCallType == CALLTYPE.FRONT) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKFRONT);

                        if (mCallEventListener != null) {
                            RemoteCallMSG.REMOTE_CALLOWNER = eCallOwner;
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.CALLING);
                            if (eCallOwner == CALLOWNER.MOBILE) {
                                LOG("[CallScenarioManager] CALLOWNER [" + eCallOwner + "]");
                                if (MainActivity.mDataSender != null) MainActivity.mDataSender.start();
                            }
                            mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.CALLING, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                            MainActivity.mSubPhoneController.sendACKFrontMonitoring(eCallOwner, eCallType);
                        }
                        else {
                            LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                            MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        }
                    }
                    else if (eCallType == CALLTYPE.RESIDENCE) {
                        if (eCallOwner == CALLOWNER.MOBILE) {
                            ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKRESIDENCE);
                            if (MainActivity.mDataSender != null) MainActivity.mDataSender.start(); // 모바일에서 홈뷰어 요청하였을 때

                            if (mCallEventListener != null) {
                                mCallInfo.setCallStatus(eCallType, CALLSTATUS.HOMEVIEW);
                                mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.HOMEVIEW, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                            }
                            else {
                                LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                                MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                                mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                            }
                        }
                    }
                    else {
                        LOG_WARN("[CallScenarioManager] Incorrect eCallType!! [" + eCallType + "]");
                        MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    }
                }
                else {
                    MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.TRYING_CALL) {
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    if (eCallType == CALLTYPE.GUARD) {
                        if (mCallEventListener != null) {
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.TRYING_CALL);
                            mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.TRYING_CALL, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                        }
                        else {
                            LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                            MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        }
                    }
                    else if (eCallType == CALLTYPE.PSTN) {
                        if (mCallEventListener != null) {
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.TRYING_CALL);
                            mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.TRYING_CALL, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                        }
                        else {
                            LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        }
                    }
                    else {
                        LOG_WARN("[CallScenarioManager] Incorrect eCallType!! [" + eCallType + "]");
                        MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    }
                }
                else {
                    MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.RECEIVE_CALL) {
                // 호출 수신

                // 착신전환 설정시, TccInterface로 전환메시지를 전달한다.
                if (ConfigValues.bUnoccupiedMode) {
                    if (eCallType != CALLTYPE.FRONT && eCallType != CALLTYPE.PSTN && eCallType != CALLTYPE.LOBBY) {
                        // 현관과 국선전화는 착신전환을 지원하지 않는다. 로비는 로비통화 화면에서 착신전환 기능을 수행한다 (방문자 사진 저장 후, 착신전환)
                        checkCallForward(strRemoteIP);
                    }
                }
                else {
                    if (mSIPInterface != null) mSIPInterface.cancelCallForwardToStun();
                }

                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX
                        || /**yjyoon 거동수상자 녹화중 콜 수신*/(mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX - 1 && mCallInfo.getFRONT() == CALLSTATUS.RECORDING)) {

                    //yjyoon. 녹화중 로비/세대/경비로부터의 새로운 콜이면 Front 상태를 IDLE로 변경.
                    if (eCallType != CALLTYPE.FRONT && mCallInfo.getFRONT() == CALLSTATUS.RECORDING) {
                        mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);

                        // 녹화가 중지되지 않았다면 다시 한번 중지 br 전송.
                        LOG("[CallScenarioManager] CALLEVENTTYPE.RECEIVE_CALL - bRecordingStatus[" + Global.getRecordingStatus() + "]");
                        if (Global.getRecordingStatus()) {
                            Intent iIntent = new Intent();
                            iIntent.setAction(Declare.BR.BR_REQUEST_RECORD_STOP);
                            iIntent.putExtra(define.NOTIBR_KIND, 1);
                            mContext.sendBroadcast(iIntent);
                        }
                    }

                    LOG("[CallScenarioManager] ===== SINGLE CALL =====");
                    if (eCallType == CALLTYPE.FRONT) {
                        LOG("[CallScenarioManager] ===== SINGLE CALL 1 =====");
                        if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
//                            ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.SET_DINGDONG_VOLUME, 0, 0); // 현관띵똥 볼륨 고정(시스템 볼륨 따라가지 않도록)
//                            sendHandlerMsg(HANDLERMSG.SETTALKPATH_DOORMUSIC, 0, 0);
                            if (TalkFront.BTN_TALK != null) { // 현관 단일콜일 경우 띵똥 소리 출력 중인 경우에는 통화버튼 disable
                                if (ConfigValues.bReliefCall) TalkFront.BTN_TALK.setButtonEventOffEnable(R.drawable.btn_call_disabled);
                                else TalkFront.BTN_TALK.setButtonEventOffEnable(R.drawable.btn_front_call_disabled);
                            }
                        }
                        LOG("[CallScenarioManager] ===== SINGLE CALL 2 ===== " + ConfigValues.bRemoteCall);
//                        ((MainActivity) mContext).mCallPathCheckHandler.sendEmptyMessage(0); // 대외향 월패드 현관카메라 띵똥을 WallPadMain으로 코드 이동
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKFRONT);
                        if (ConfigValues.bRemoteCall) {
                            RemoteCallMSG.REMOTE_CALLTYPE = eCallType;
                            RemoteCallMSG.REMOTE_CALLSTATUS = CALLSTATUS.CALLED;
                            MainActivity.mRemoteCallController.sendOpenRemoteCall(RemoteCallMSG.REMOTE_CALLTYPE, RemoteCallMSG.REMOTE_CALLSTATUS);
                            if (MainActivity.mDataSender != null) MainActivity.mDataSender.start();
                        }
                    }
                    else if (eCallType == CALLTYPE.LOBBY) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKLOBBY);
                        LOG("[CallScenarioManager] ===== SINGLE CALL 111 ===== " + ConfigValues.bRemoteCall);
                        if (ConfigValues.bRemoteCall) {
                            RemoteCallMSG.REMOTE_CALLTYPE = eCallType;
                            RemoteCallMSG.REMOTE_CALLSTATUS = CALLSTATUS.CALLED;
                            MainActivity.mRemoteCallController.sendOpenRemoteCall(RemoteCallMSG.REMOTE_CALLTYPE, RemoteCallMSG.REMOTE_CALLSTATUS);
                            if (MainActivity.mDataSender != null) MainActivity.mDataSender.start();
                        }
                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKGUARD);
                        if (ConfigValues.bRemoteCall) {
                            RemoteCallMSG.REMOTE_CALLTYPE = eCallType;
                            MainActivity.mRemoteCallController.sendOpenRemoteCall(RemoteCallMSG.REMOTE_CALLTYPE, strRemoteSIPID, strRemoteIP);
                            if (MainActivity.mDataSender != null) MainActivity.mDataSender.start();
                        }
                    }
                    else if (eCallType == CALLTYPE.RESIDENCE) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKRESIDENCE);
                    }
                    else if (eCallType == CALLTYPE.PSTN) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKPSTN);
                    }
                    else {
                        LOG_WARN("[CallScenarioManager] Incorrect eCallType!! [" + eCallType + "]");
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        return;
                    }
                }
                else {
                    LOG("[CallScenarioManager] ===== MULTI CALL ===== " + eCallType.toString());

                    LOG("[CallScenarioManager] ===== MULTI CALL ===== " + mCallInfo.getFRONT().toString());
                    if (eCallType == CALLTYPE.FRONT) {
                        if (mCallInfo.getFRONT() != CALLSTATUS.IDLE) {
                            return;
                        }
                    }
                    else if (eCallType == CALLTYPE.LOBBY) {
                        //if (mCallInfo.getLOBBY() == CALLSTATUS.IDLE) {
                            //LOG("[CallScenarioManager] ===== MULTI CALL ===== " + mCallInfo.getLOBBY().toString());
                            if (mSIPInterface != null) mSIPInterface.rejectBusyMultiCall();
                            //return;
                        //}
                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        //if (mCallInfo.getGUARD() != CALLSTATUS.IDLE) {
                            if (mSIPInterface != null) mSIPInterface.rejectBusyMultiCall();
                            //return;
                        //}
                    }
                    else if (eCallType == CALLTYPE.RESIDENCE) {
                        //if (mCallInfo.getRESI() != CALLSTATUS.IDLE) {
                            if (mSIPInterface != null) mSIPInterface.rejectBusyMultiCall();
                            //return;
                        //}
                    }
                    else if (eCallType == CALLTYPE.PSTN) {
                        if (mCallInfo.getPSTN() != CALLSTATUS.IDLE) {
                            return;
                        }
                    }

                    if (mCallEventListener != null) {
                        mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.CALLED, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                        //procSubPhoneScenario(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP);
                    }
                    else {
                        LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    }
                    return;
                }

                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.CALLED);

                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.CALLED, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                    procSubPhoneScenario(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.RECEIVE_CALL_ACK) {
                // 호출응답 수신
                if (mCallInfo.getIDLECnt() < mCallInfo.IDLECNT_MAX) {
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.CALLING);

                    if (mCallEventListener != null) {
                        if (eCallType == CALLTYPE.GUARD) {
                            if (eCallOwner == CALLOWNER.MOBILE) {
                                if (ConfigValues.bRemoteCall) {
                                    if (MainActivity.mDataSender != null) MainActivity.mDataSender.start(); // 모바일에서 경비실기 발신하였을 때, 경비실기에서 수락하는 경우
                                }
                            }
                        }
                        mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.CALLING, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                    }
                    else {
                        Global.stopMelodyRepeat();
                        mCallInfo.resetCallStatus();
                        quitMoIPCall();
                    }
                }
                else {
                    LOG_WARN("[CallScenarioManager] Undefined scenario!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.CONNECT_CALL) {
                // 통화 시작
                if (mCallInfo.getIDLECnt() < mCallInfo.IDLECNT_MAX || eCallOwner == CALLOWNER.MOBILE) {
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.TALKING);

                    if (sdbLivingRoomLightAPI != null) {
                        Log.d(TAG, "[CallScenarioManager] sdbLivingRoomLightAPI.SetWifiModuleOnOff [FALSE]");
                        sdbLivingRoomLightAPI.SetWifiModuleOnOff(false); // 통화 시작시 Wifi/BLE 모듈 출력 OFF
                    }
                    else mWallPadApiCheckHandler.sendEmptyMessage(2);

                    if (mCallEventListener != null) {
                        RemoteCallMSG.REMOTE_CALLOWNER = eCallOwner;
                        mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.TALKING, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
//                        ((MainActivity) mContext).checkMemoryUsage(); // 통화중 메모리 체크
                    }
                    else {
                        LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                        Global.stopMelodyRepeat();
                        mCallInfo.resetCallStatus();
                        quitMoIPCall();
                    }
                }
                else {
                    LOG_WARN("[CallScenarioManager] Undefined scenario!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
                procSubPhoneScenario(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP);
            }
            else if (eEventType == CALLEVENTTYPE.TERMINATE_CALL) {
                // 통화 종료
                if (eCallOwner == CALLOWNER.MOBILE) {
                    if (mCallInfo.getTalkingCnt() == 0 && mCallInfo.getCallingCnt() == 0) {
                        Log.d(TAG, "[CallScenarioManager] Close Mobile Call!");
                        if (RemoteCallMSG.REMOTE_CALLTYPE == CALLTYPE.LOBBY) {
                            if (mSIPInterface != null) mSIPInterface.videoSet(false, false, false); // 모바일에서 로비통화 종료시 영상 먼저 종료
                        }
                        if (MainActivity.mDataSender != null) MainActivity.mDataSender.interrupt();
                        RemoteCallMSG.REMOTE_CALLTYPE = CALLTYPE.NONE;
                        RemoteCallMSG.REMOTE_CALLSTATUS = CALLSTATUS.IDLE;
                        RemoteCallMSG.REMOTE_CALLOWNER = CALLOWNER.NONE;
                        MainActivity.mRemoteCallController.sendCloseRemoteCall();
                    }
                }

                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.END);

                if (sdbLivingRoomLightAPI != null) {
                    Log.d(TAG, "[CallScenarioManager] sdbLivingRoomLightAPI.SetWifiModuleOnOff [TRUE]");
                    sdbLivingRoomLightAPI.SetWifiModuleOnOff(true); // 통화 종료시 Wifi/BLE 모듈 출력 ON(원복)
                }

//                sendHandlerMsgDelayed(HANDLERMSG.SELECT_VIDEO_FRONT, 0, 0, 1000); // 스마트현관카메라 통화종료시 영상 깨짐 방지 딜레이

                if (mCallEventListener != null) {
                    procSubPhoneScenario(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP);
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.END, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
//                    ((MainActivity) mContext).checkMemoryUsage(); // 통화 종료시 메모리 체크
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
                ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.RECOVER_SYSTEM_VOLUME, 0, 0);// 통화 종료 후 시스템 볼륨 원복 seulki
            }
            else if (eEventType == CALLEVENTTYPE.CANCEL_CALL) {
                // SIP 호출 취소
                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.CANCEL);
                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.CANCEL, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
                procSubPhoneScenario(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP);
            }
            else if (eEventType == CALLEVENTTYPE.REJECT_CALL) {
                // SIP 호출 거절
                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.REJECT);
                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.REJECT, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
                procSubPhoneScenario(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP);
            }
            else if (eEventType == CALLEVENTTYPE.REJECT_BUSY_CALL) {
                // SIP Busy 거절
                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.BUSY);
                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.BUSY, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
            }
            else if (eEventType == CALLEVENTTYPE.FORWARD_CALL) {
                // SIP 착신전환
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.FORWARD);

                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.FORWARD, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
            }
            else if (eEventType == CALLEVENTTYPE.TIMEOUT_1STCALL) {
                // 단독콜 타임아웃
                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.TIMEOUT_1STCALL);

                if (mCallEventListener != null) {
                    if (ConfigValues.bRemoteCall) MainActivity.mRemoteCallController.sendCloseRemoteCall();
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.TIMEOUT_1STCALL, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
                procSubPhoneScenario(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP);
            }
            else if (eEventType == CALLEVENTTYPE.TIMEOUT_2NDCALL) {
                // 멀티콜 타임아웃
                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.TIMEOUT_2NDCALL);

                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.TIMEOUT_2NDCALL, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
            }
            else if (eEventType == CALLEVENTTYPE.TIMEOUT_3RDCALL) {
                // 멀티콜 타임아웃
                sendBlockSIPCallBR();
                ((MainActivity) mContext).setBlockFrontCall();
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.TIMEOUT_3RDCALL);

                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.TIMEOUT_3RDCALL, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
            }
            else if (eEventType == CALLEVENTTYPE.MOIP_VIDEO_SET) {
                // SIP 영상 설정
            }
            else if (eEventType == CALLEVENTTYPE.DOOR_OPEN) {
                // 문열림 요청
                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.DOOR_OPEN, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
            }
            else if (eEventType == CALLEVENTTYPE.PSTN_RING) {
                // PSTN Ring 수신
                if (mCallEventListener != null) {
                    mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.PSTN_RING, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
                else {
                    LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                }
            }
            else if (eEventType == CALLEVENTTYPE.DETECT_STRANGER) {
                // [스마트현관카메라] 거동수상자 발생
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    LOG("[CallScenarioManager] ========== SINGLE CALL ==========");
                    ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKFRONT);
                }
                else {
                    // 거동수상자 멀티콜인 경우 front 상태를 'recording' 변경하기에 아래와 같이 조건문을 구성함.
                    if (mCallInfo.getRESI() == CALLSTATUS.IDLE && mCallInfo.getLOBBY() == CALLSTATUS.IDLE && mCallInfo.getGUARD() == CALLSTATUS.IDLE
                            && mCallInfo.getPSTN() == CALLSTATUS.IDLE && mCallInfo.getIHUB() == CALLSTATUS.IDLE) {
                        // 20220715 yjyoon
                        // call 앱 시작시 실제 이벤트는 500ms 뒤에 생성.
                        // 거동수상자 감지로 앱이 시작되고 500ms 사이에 현관콜이 발생하면 거동수상자 이벤트 보다 현관콜 이벤트가 먼저 진행.
                        // 거동수상자 이벤트보다 콜 이벤트의 우선순위가 높기 때문에 거동수상자 이벤트를 폐기한다.
                        Log.w(TAG, "[CallScenarioManager] ignore DETECT_STRANGER event !! (mCallInfo.getIDLECnt() != mCallInfo.IDLECNT_MAX)");
                        return;
                    } else {
                        // yjyoon. 현관 통화가 아니면 감지 팝업 표시.
                        LOG("[CallScenarioManager] ========== MULTI CALL ==========");
                    }
                }

                if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMARTIOT || ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMART_HS || ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMART_DW) {
                    mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.RECORDING);

                    if (mCallEventListener != null) {
                        LOG_INFO("[CallScenarioManager] ========== DETECT_STRANGER [RECORDING] ==========");
                        mCallInfo.printCallStatus();
                        mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.RECORDING, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                        if (ConfigValues.bRemoteCall) {
                            RemoteCallMSG.REMOTE_CALLTYPE = eCallType;
                            RemoteCallMSG.REMOTE_CALLSTATUS = CALLSTATUS.RECORDING;
                            MainActivity.mRemoteCallController.sendOpenRemoteCall(RemoteCallMSG.REMOTE_CALLTYPE, RemoteCallMSG.REMOTE_CALLSTATUS); // [방문객원격통화] 모바일로 거동수상자 알림
                            if (MainActivity.mDataSender != null) MainActivity.mDataSender.start();
                        }
                    }
                    else {
                        LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    }
                }
//                else if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMART_DW) {
//                    mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.TAKINGPIC);
//
//                    if (mCallEventListener != null) {
//                        LOG_INFO("[CallScenarioManager] ========== DETECT_STRANGER [TAKINGPIC] ==========");
//                        mCallEventListener.onCallEvent(eCallOwner, CALLSTATUS.TAKINGPIC, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
//                    }
//                    else {
//                        LOG_WARN("[CallScenarioManager] mCallEventListener is null!!");
//                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
//                    }
//                }
            } else {
                // 기타
                LOG_WARN("[CallScenarioManager] = ERROR = Unknown eEventType!! [" + eEventType + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] CallScenarioManager(eEventType, eCallType, strRemoteIP, strRemoteSIPID, strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public static boolean bMultiCall = false; // 로비 매뉴얼 출력시 멀티콜 여부를 판단하기 위한 플래그 (멀티콜로 진입시 매뉴얼 종료되면 영상이 위로)
    public void MultiCallScenarioManager() {
        try {
            CALLTYPE eMultiCallRemoteType = mCallInfo.getMultiCallType();
            LOG("[MultiCallScenarioManager] eMultiCallRemoteType [" + eMultiCallRemoteType + "]");
            ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_ALL);
            ((MainActivity) mContext).finishManual(ID.MANUAL.MANUAL_ALL);
            if (eMultiCallRemoteType == CALLTYPE.FRONT) {
                ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.CHANGESCREEN, MainActivity.HANDLERMSG.CHANGESCREEN_FRONT, 0);
            }
            else if (eMultiCallRemoteType == CALLTYPE.LOBBY) {
                bMultiCall = true;
                ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.CHANGESCREEN, MainActivity.HANDLERMSG.CHANGESCREEN_LOBBY, 0);
            }
            else if (eMultiCallRemoteType == CALLTYPE.GUARD) {
                ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.CHANGESCREEN, MainActivity.HANDLERMSG.CHANGESCREEN_GUARD, 0);
            }
            else if (eMultiCallRemoteType == CALLTYPE.RESIDENCE) {
                ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.CHANGESCREEN, MainActivity.HANDLERMSG.CHANGESCREEN_RESIDENCE, 0);
            }
            else if (eMultiCallRemoteType == CALLTYPE.PSTN) {
                ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.CHANGESCREEN, MainActivity.HANDLERMSG.CHANGESCREEN_PSTN, 0);
            }
            else {
                LOG_WARN("[MultiCallScenarioManager] No Multicall!!");
                if (mCallInfo.getPSTNCallHold()) {
                    ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.CHANGESCREEN, MainActivity.HANDLERMSG.CHANGESCREEN_PSTN, 0);
                }
                else {
                    ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.CLEAR_ALL_CALL, 0, 0);
                    mCallInfo.setCallOwner(CALLOWNER.NONE);
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] MultiCallScenarioManager()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    String strCID = "NONE";

    public void onPSTNEvent(CALLEVENTTYPE eEventType, PSTNInfo Info, String strMessage) {
        try {
            LOG("[onPSTNEvent] eEventType [" + eEventType + "]");

            if (eEventType == CALLEVENTTYPE.RECEIVE_CALL) {
                if (strMessage != null) LOG("[onPSTNEvent] strMessage [" + strMessage + "]");
                if (mCallInfo != null) {
                    if (!mCallInfo.getMultiCallPSTNReject()) {
                        CallScenarioManager(mCallInfo.getCallOwner(), eEventType, CALLTYPE.PSTN, "", strCID, strMessage);
                    }
                }
            } else if (eEventType == CALLEVENTTYPE.TERMINATE_CALL) {
                if (mCallInfo.getMultiCallPSTNReject()) mCallInfo.setPSTNRejectFlag(false);
                else CallScenarioManager(mCallInfo.getCallOwner(), eEventType, CALLTYPE.PSTN, "", strCID, strMessage);
            } else if (eEventType == CALLEVENTTYPE.CALLERID) {
                if (Info != null) {
                    Info.printValue();
                    strCID = Info.getPSTN_CID();
                } else strCID = "NONE";
                if (strMessage != null) LOG("[onPSTNEvent] strMessage [" + strMessage + "]");
                if (mPopupEventListener != null) {
                    mPopupEventListener.onCallerID(strCID);
                } else {
                    LOG_WARN("[onPSTNEvent] mPopupEventListener is null!!");
                }
                CallScenarioManager(mCallInfo.getCallOwner(), eEventType, CALLTYPE.PSTN, "", strCID, strMessage);
            } else if (eEventType == CALLEVENTTYPE.PSTN_DTMF) {
                if (mDTMFEventListener != null) {
                    mDTMFEventListener.onDTMFEvent(strMessage);
                } else {
                    LOG_WARN("[onPSTNEvent] mDTMFEventListener is null!!");
                }
            } else {
                if (strMessage != null) LOG("[onPSTNEvent] strMessage [" + strMessage + "]");
                CallScenarioManager(mCallInfo.getCallOwner(), eEventType, CALLTYPE.PSTN, "", strCID, strMessage);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onPSTNEvent(CALLEVENTTYPE eEventType, PSTNInfo Info, String strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void StartLobby()
    {
        LOG("[StartLobby] mCallInfo.getCallOwner() " + mCallInfo.getCallOwner());
        mLobbyCallOwner = mCallInfo.getCallOwner();
        CallScenarioManager(mLobbyCallOwner, mLobbyEvent, mLobbyType, mStrLobbyRemoteIP, mStrLobbyRemoteSIPID, mStrLobbyMessage);
        mbCallConnect = true;
    }

    CALLOWNER mLobbyCallOwner;
    CALLEVENTTYPE mLobbyEvent;
    CALLTYPE mLobbyType;
    String mStrLobbyRemoteIP, mStrLobbyRemoteSIPID, mStrLobbyMessage;
    public boolean mbCallConnect = false;

    @Override
    public void onSIPEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strRemoteIP, String strRemoteSIPID, String strMessage) {
        try {
            LOG("[onSIPEvent] eEventType [" + eEventType + "], eCallType [" + eCallType + "], strRemoteSIPID [" + strRemoteSIPID + "]");
            if(strRemoteSIPID != null)
                if(!strRemoteSIPID.contains("_Lobby_") && !strRemoteSIPID.contains("_Guard_") && !strRemoteSIPID.contains("_Resi_"))
                    strRemoteSIPID = makeSIPID(strRemoteSIPID);

            if(eEventType == CALLEVENTTYPE.CONNECT_CALL && eCallType == CALLTYPE.LOBBY)
            {
                mLobbyCallOwner = mCallInfo.getCallOwner();
                mLobbyEvent = eEventType;
                mLobbyType = eCallType;
                mStrLobbyRemoteIP = strRemoteIP;

                mStrLobbyRemoteSIPID = strRemoteSIPID;
                mStrLobbyMessage = strMessage;
            }
            else {
                if(eEventType == CALLEVENTTYPE.TERMINATE_CALL)
                    mbCallConnect = false;
                else if(eEventType == CALLEVENTTYPE.CONNECT_CALL)
                    mbCallConnect = true;

                if((MainActivity.m_bRejectCall) && ((eEventType == CALLEVENTTYPE.REJECT_BUSY_CALL) || (eEventType == CALLEVENTTYPE.REJECT_CALL)))
                {

                }
                else {
                    CallScenarioManager(mCallInfo.getCallOwner(), eEventType, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
                }
            }

        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onSIPEvent(eEventType, eCallType, strRemoteIP, strRemoteSIPID, strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public String makeSIPID(String strIPAddress) {
        try {
            LOG_INFO("[makeSIPID] strIPAddress : " + strIPAddress);
            String SIPID = "12345678_Resi_0101_0101_01";
            String dong = "101";
            String ho = "101";
            String strType = SIPStun.DeviceString.strType_Resi;
            String strDeviceCnt = "01";

            String[] IP_Parse = strIPAddress.split("\\.");
            if (IP_Parse != null) {
                dong = Integer.toString((((Integer.parseInt(getDongString()) / 100) * 100) + Integer.parseInt(IP_Parse[1])));

                if (IP_Parse[2].equals("128")) {
                    // 경비실폰
                    strType = SIPStun.DeviceString.strType_Guard;
                    ho = IP_Parse[3];
                } else if (IP_Parse[2].equals("0")) {
                    // 로비폰
                    strType = SIPStun.DeviceString.strType_Lobby;
                    ho = IP_Parse[3];
                } else if (IP_Parse[2].equals("201")) {
                    // 아이허브
                    strType = SIPStun.DeviceString.strType_Ihub;
                    ho = IP_Parse[3];
                } else {
                    int nIP_DClass = Integer.parseInt(IP_Parse[3]);

                    if (nIP_DClass < 200) {
                        // 메인 세대 월패드
                        strType = SIPStun.DeviceString.strType_Resi;
                    } else {
                        // 분리 세대 월패드
                        strType = SIPStun.DeviceString.strType_RentResi;
                        nIP_DClass = nIP_DClass - 200;
                    }
                    ho = IP_Parse[2] + ZeroPadding_Head(2, Integer.toString(nIP_DClass));
                }

                SIPID = ZeroPadding_Head(8, getSitecodeString()) + "_" + strType + "_" + ZeroPadding_Head(4, dong) + "_" + ZeroPadding_Head(4, ho) + "_" + strDeviceCnt;
                LOG_INFO("[makeSIPID] SIPID : " + SIPID);

                return SIPID;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] MakeSIPID(...) : " + e);
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return "ERROR";
    }

    private String getSitecodeString() {
        try {
            String strResult = "";
            WallpadDeviceSet Devset = new WallpadDeviceSet(mContext);
            String[] getData = Devset.GetSettingData("site_code");
            Devset.closeDB();
            if ((getData != null) && getData.length > 1) {
                strResult = getData[1];
            }
            LOG("[getSitecodeString] strResult [" + strResult + "]");
            return strResult;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return null;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getSitecodeString()");
            return null;
        }
    }

    public static String ZeroPadding_Head(int nOutLength, String strOriginalString) {
        String strResult = strOriginalString;
        try {

            if (strOriginalString.length() < nOutLength) {
                for (int i = strOriginalString.length(); i < nOutLength; i++) {
                    strResult = "0" + strResult;
                }
                return strResult;
            } else if (strOriginalString.length() == nOutLength) {
                return strResult;
            } else {
                Log.d(TAG, "[ZeroPadding_Head] strOriginalString(" + strOriginalString.length() + ") is longer than nOutLength(" + nOutLength + ")");
                return strResult;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return strResult;
        } catch (Exception e) {
            Log.e(TAG, "[ZeroPadding_Head] (Exception) ZeroPadding_Head(...) + e");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return strResult;
        }
    }

    private String getDongString() {
        try {
            String strResult = "";
            wallpaddbmgr DBMGR = new wallpaddbmgr(mContext);
            wallpaddbmgr.AddressSet Addr = DBMGR.getAddressMGR();
            DBMGR.closeDB();
            strResult = Addr.Dong;
            LOG("[getDongString] strResult [" + strResult + "]");
            return strResult;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return null;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getDongString()");
            return null;
        }
    }

    public void onFrontEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType) {
        try {
            CallScenarioManager(mCallInfo.getCallOwner(), eEventType, eCallType, null, null, null);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onFrontEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void onLobbyEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType) {
        try {
            CallScenarioManager(mCallInfo.getCallOwner(), eEventType, eCallType, null, null, null);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onLobbyEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void onGuardEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType) {
        try {
            CallScenarioManager(mCallInfo.getCallOwner(), eEventType, eCallType, null, null, null);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onGuardEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void onResidenceEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType) {
        try {
            CallScenarioManager(mCallInfo.getCallOwner(), eEventType, eCallType, null, null, null);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onResidenceEvent(CALLEVENTTYPE eEventType, CALLTYPE eCallType)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void onSubPhoneEvent(CALLOWNER eCallOwner, CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strTargetID, String strMessage) {
        try {
            LOG_INFO("[onSubPhoneEvent] eCallOwner [" + eCallOwner + "], eEventType [" + eEventType + "], eCallType [" + eCallType + "], strTargetID [" + strTargetID + "], strTargetID [" + strMessage + "]");
            if (eEventType == CALLEVENTTYPE.REQUEST_FRONT_MONITORING) {
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    if (eCallType == CALLTYPE.FRONT) {
                        if (mCallEventListener != null) {
                            mCallEventListener.onSubPhoneEvent(eCallOwner, CALLSTATUS.CALLING, eCallType, strTargetID, strMessage);
                            MainActivity.mSubPhoneController.sendACKFrontMonitoring(eCallOwner, eCallType);
                        }
                        else {
                            LOG_WARN("[onSubPhoneEvent] mCallEventListener is null!!");
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                            MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                        }
                    }
                    else {
                        LOG_WARN("[onSubPhoneEvent] Incorrect eCallType!! [" + eCallType + "]");
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                    }
                }
                else {
                    LOG_WARN("[onSubPhoneEvent] CallStatus is NOT IDLE!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                }
            } else if (eEventType == CALLEVENTTYPE.TRYING_CALL) {
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    if (eCallType == CALLTYPE.GUARD) {
                        if (mCallEventListener != null) {
                            mCallEventListener.onSubPhoneEvent(eCallOwner, CALLSTATUS.TRYING_CALL, eCallType, strTargetID, strMessage);
                        } else {
                            LOG_WARN("[onSubPhoneEvent] mCallEventListener is null!!");
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                            MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                        }
                    } else {
                        LOG_WARN("[onSubPhoneEvent] Incorrect eCallType!! [" + eCallType + "]");
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                    }
                } else {
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    MainActivity.mSubPhoneController.sendBusyCall(eCallOwner, eCallType);
                }
            } else if (eEventType == CALLEVENTTYPE.CONNECT_CALL) {
                // 통화 시작
                if (mCallInfo.getIDLECnt() < mCallInfo.IDLECNT_MAX) {
                    if (mCallEventListener != null) {
                        mCallEventListener.onSubPhoneEvent(eCallOwner, CALLSTATUS.TALKING, eCallType, strTargetID, strMessage);
                    } else {
                        LOG_WARN("[onSubPhoneEvent] mCallEventListener is null!!");
                    }
                } else {
                    LOG_WARN("[onSubPhoneEvent] Undefined scenario!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            } else if (eEventType == CALLEVENTTYPE.TERMINATE_CALL) {
                // 통화 종료
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.END);
                if (mCallEventListener != null) {
                    mCallEventListener.onSubPhoneEvent(eCallOwner, CALLSTATUS.END, eCallType, strTargetID, strMessage);
                } else {
                    LOG_WARN("[onSubPhoneEvent] mCallEventListener is null!!");
                }
            } else if (eEventType == CALLEVENTTYPE.DOOR_OPEN) {
                // 문열림 요청
                if (mCallEventListener != null) {
                    mCallEventListener.onSubPhoneEvent(eCallOwner, CALLSTATUS.DOOR_OPEN, eCallType, strTargetID, strMessage);
                } else {
                    LOG_WARN("[onSubPhoneEvent] mCallEventListener is null!!");
                    mCallInfo.resetCallStatus();
                    quitMoIPCall();
                }
            } else {
                // 기타
                LOG_WARN("[onSubPhoneEvent] = ERROR = Unknown eEventType!! [" + eEventType + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onSubPhoneEvent(CALLOWNER eCallOwner, CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strTargetID, String strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void onSubWallPadEvent(CALLOWNER eCallOwner, CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strTargetID, String strMessage) {
        try {
            LOG_INFO("[onSubWallPadEvent] eCallOwner [" + eCallOwner + "], eEventType [" + eEventType + "], eCallType [" + eCallType +"], strTargetID [" + strTargetID +"], strTargetID [" + strMessage +"]");
            if (eEventType == CALLEVENTTYPE.REQUEST_FRONT_MONITORING) {
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    if (eCallType == CALLTYPE.FRONT) {
                        if (mSubWallPadEventListener != null) {
                            MainActivity.mCallController.mCallInfo.setCallStatus(eCallType, CALLSTATUS.CALLING);
                            mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.CALLING, eCallType, strTargetID, strMessage);
                            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN)
                                MainActivity.mSubWallPadController.sendACKFrontMonitoring(eCallOwner, eCallType);
                        }
                        else {
                            LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                            MainActivity.mSubWallPadController.sendBusyCall(eCallOwner, eCallType);
                        }
                    }
                } else {
                    LOG_WARN("[onSubWallPadEvent] CallStatus is NOT IDLE!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    MainActivity.mSubWallPadController.sendBusyCall(eCallOwner, eCallType);
                }
            }
            else if (eEventType == CALLEVENTTYPE.TRYING_CALL) {
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    if (eCallType == CALLTYPE.GUARD) {
                        if (mSubWallPadEventListener != null) {
                            mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.TRYING_CALL, eCallType, strTargetID, strMessage);
                        }
                        else {
                            Log.w(TAG, "[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                            mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                            MainActivity.mSubWallPadController.sendBusyCall(eCallOwner, eCallType);
                        }
                    }
                    else {
                        LOG_WARN("[onSubWallPadEvent] Incorrect eCallType!! [" + eCallType + "]");
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        MainActivity.mSubWallPadController.sendBusyCall(eCallOwner, eCallType);
                    }
                }
                else {
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    MainActivity.mSubWallPadController.sendBusyCall(eCallOwner, eCallType);
                }
            }
            else if (eEventType == CALLEVENTTYPE.RECEIVE_CALL) {
                if (mCallInfo.getIDLECnt() == mCallInfo.IDLECNT_MAX) {
                    // SingleCall
                    if (eCallType == CALLTYPE.FRONT) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKFRONT);
                    }
                    else if (eCallType == CALLTYPE.LOBBY) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKLOBBY);
                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKGUARD);
                    }
                    else if (eCallType == CALLTYPE.RESIDENCE) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKRESIDENCE);
                    }
                    else if (eCallType == CALLTYPE.PSTN) {
                        ((MainActivity) mContext).changeMenuNScreen(ID.MENU.MENU_TALKPSTN);
                    }
                    else {
                        LOG_WARN("[onSubWallPadEvent] Incorrect eCallType!! [" + eCallType + "]");
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        return;
                    }
                }
                else {
                    // MultiCall
                    LOG("[onSubWallPadEvent] mCallInfo.getIDLECnt() [" + mCallInfo.getIDLECnt() + "]");
                    if (eCallType == CALLTYPE.FRONT) {
                        if (mCallInfo.getFRONT() != CALLSTATUS.IDLE) {
                            return;
                        }
                    }
                    else if (eCallType == CALLTYPE.LOBBY) {
                        if (mCallInfo.getLOBBY() != CALLSTATUS.IDLE) {
                            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) mSIPInterface.rejectBusyMultiCall();
                            return;
                        }
                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        if (mCallInfo.getGUARD() != CALLSTATUS.IDLE) {
                            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) mSIPInterface.rejectBusyMultiCall();
                            return;
                        }
                    }
                    else if (eCallType == CALLTYPE.RESIDENCE) {
                        if (mCallInfo.getRESI() != CALLSTATUS.IDLE) {
                            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) mSIPInterface.rejectBusyMultiCall();
                            return;
                        }
                    }
                    else if (eCallType == CALLTYPE.PSTN) {
                        if (mCallInfo.getPSTN() != CALLSTATUS.IDLE) {
                            return;
                        }
                    }
                }

                mCallInfo.setCallStatus(eCallType, CALLSTATUS.CALLED);
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.CALLED, eCallType, strTargetID, strMessage);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.RECEIVE_CALL_ACK) {
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.CALLING);
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.CALLING, eCallType, strTargetID, strMessage);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    mCallInfo.resetCallStatus();
                }
            }
            else if (eEventType == CALLEVENTTYPE.CONNECT_CALL) {
                // 통화 시작
                if (mCallInfo.getIDLECnt() < mCallInfo.IDLECNT_MAX) {
                    if (mSubWallPadEventListener != null) {
                        mCallInfo.setCallStatus(eCallType, CALLSTATUS.TALKING);
                        mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.TALKING, eCallType, strTargetID, strMessage);
                        MainActivity.mSubWallPadController.notifyStartCall(eCallOwner, eCallType);
                    }
                    else {
                        LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    }
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] Undefined scenario!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.TERMINATE_CALL) {
                // 통화 종료
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.END);
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.END, eCallType, strTargetID, strMessage);
                    if (eCallOwner == CALLOWNER.SUB_WALLPAD) MainActivity.mSubWallPadController.notifyEndCall(eCallOwner, eCallType);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                }
            }
            else if (eEventType == CALLEVENTTYPE.DOOR_OPEN) {
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.DOOR_OPEN);
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.DOOR_OPEN, eCallType, strTargetID, strMessage);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    mCallInfo.resetCallStatus();
                }
            }
            else if (eEventType == CALLEVENTTYPE.REJECT_CALL) {
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.REJECT);
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.REJECT, eCallType, strTargetID, strMessage);
                    MainActivity.mSubWallPadController.notifyEndCall(eCallOwner, eCallType);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    mCallInfo.resetCallStatus();
                }
            }
            else if (eEventType == CALLEVENTTYPE.CANCEL_CALL) {
                mCallInfo.setCallStatus(eCallType, CALLSTATUS.CANCEL);
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.CANCEL, eCallType, strTargetID, strMessage);
                    MainActivity.mSubWallPadController.notifyEndCall(eCallOwner, eCallType);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    mCallInfo.resetCallStatus();
                }
            }
            else if (eEventType == CALLEVENTTYPE.CALLERID) {
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.CALLERID, eCallType, strTargetID, strMessage);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else if (eEventType == CALLEVENTTYPE.INITIALIZE_ALLCALL) {
                if (mSubWallPadEventListener != null) {
                    mSubWallPadEventListener.onSubWallPadCallEvent(eCallOwner, CALLSTATUS.CALLERID, eCallType, strTargetID, strMessage);
                }
                else {
                    LOG_WARN("[onSubWallPadEvent] mSubWallPadEventListener is null!!");
                    mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                }
            }
            else {
                LOG_WARN("[onSubWallPadEvent] Unknown eEventType!! [" + eEventType + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onSubWallPadEvent(CALLOWNER eCallOwner, CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strTargetID, String strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    public void onVideoSet(boolean bSet, String strRemoteSIPID) {
        try {
            LOG_INFO("[onVideoSet] bSet [" + bSet + "], strRemoteSIPID [" + strRemoteSIPID + "]");
            if (mCallEventListener != null) {
                mCallEventListener.onVideoSet(bSet, strRemoteSIPID);
            } else {
                LOG_WARN("[onVideoSet] mCallEventListener is null!!");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onVideoSet(boolean bSet, String strRemoteSIPID)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    public void onShowRemoteVideo(boolean bShow) {
        try {
            LOG_INFO("[onShowRemoteVideo] bShow [" + bShow + "]");
            if (mCallEventListener != null) {
                mCallEventListener.onShowRemoteVideo(bShow);
            } else {
                LOG_WARN("[onShowRemoteVideo] mCallEventListener is null!!");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onShowRemoteVideo(boolean bShow)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void procSubPhoneScenario(CALLOWNER eCallOwner, CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strRemoteIP) {
        try {
            if (!ConfigValues.bSubPhoneEnable) {
                LOG_INFO("[procSubPhoneScenario] ConfigValues.bSubPhoneEnable [" + ConfigValues.bSubPhoneEnable + "]");
                return;
            }

            if (eCallType == CALLTYPE.PSTN && !ConfigValues.bSubPhonePSTNEnable) {
                LOG_INFO("[procSubPhoneScenario] ConfigValues.bSubPhonePSTNEnable [" + ConfigValues.bSubPhonePSTNEnable + "]");
                return;
            }

            if (MainActivity.mSubPhoneController == null) {
                LOG_INFO("[procSubPhoneScenario] MainActivity.mSubPhoneController is null!!!");
                return;
            }

            LOG_INFO("[procSubPhoneScenario] eCallOwner [" + eCallOwner + "], eEventType [" + eEventType + "], eCallType [" + eCallType + "], strRemoteIP [" + strRemoteIP + "]");
            if (eEventType == CALLEVENTTYPE.RECEIVE_CALL) {
                if(eCallType == CALLTYPE.LOBBY)
                    eCallOwner = CALLOWNER.NONE;

                if (eCallOwner != CALLOWNER.WALLPAD  && mCallInfo.getCalledCnt() < 2) {
                    if (eCallType == CALLTYPE.GUARD) {
                        MainActivity.mSubPhoneController.notifyNewCallGuard(eCallOwner, eCallType, getGuardType(strRemoteIP), Global.ConfigValues.bGuardVideoEnable);
                    }
                    if (eCallType == CALLTYPE.RESIDENCE) {
                        MainActivity.mSubPhoneController.notifyNewCallResidence(eCallOwner, eCallType, strRemoteIP, Global.ConfigValues.bGuardVideoEnable);
                    }
                    else {
                        MainActivity.mSubPhoneController.notifyNewCall(eCallOwner, eCallType);
                    }
                }
            } else if (eEventType == CALLEVENTTYPE.CONNECT_CALL) {
                if (eCallOwner == CALLOWNER.WALLPAD) {
                    MainActivity.mSubPhoneController.notifyStartCall(eCallOwner, eCallType);
                } else {
                    if (eCallOwner == CALLOWNER.MOBILE) {
                        // 모바일에서 수신시 서브기기에게 통화시작 커맨드 날려야함
                        if (eCallType == CALLTYPE.FRONT || eCallType == CALLTYPE.LOBBY || eCallType == CALLTYPE.GUARD) {
                            MainActivity.mSubPhoneController.notifyMobileStartCall(eCallOwner, eCallType);
                        }
                    } else if (Global.getKitchenTVIdx(eCallOwner) >= 0 || Global.getBathPhoneIdx(eCallOwner) >= 0 || eCallOwner == CALLOWNER.SUB_WALLPAD || Global.getBathTVIdx(eCallOwner) >= 0) {
                        if (eCallType == CALLTYPE.GUARD) {
                            MainActivity.mSubPhoneController.notifyStartCall(eCallOwner, eCallType);
                        }
                    }
                }
            } else if (eEventType == CALLEVENTTYPE.TERMINATE_CALL) {
                if (eCallOwner != CALLOWNER.WALLPAD) {
                    MainActivity.mSubPhoneController.notifyEndCall(eCallOwner, eCallType);
                }
            } else if (eEventType == CALLEVENTTYPE.CANCEL_CALL) {
                if (eCallOwner != CALLOWNER.WALLPAD) {
                    MainActivity.mSubPhoneController.notifyEndCall(eCallOwner, eCallType);
                }
            } else if (eEventType == CALLEVENTTYPE.REJECT_CALL) {
                if (eCallOwner != CALLOWNER.WALLPAD) {
                    MainActivity.mSubPhoneController.notifyEndCall(eCallOwner, eCallType);
                }
            } else if (eEventType == CALLEVENTTYPE.TIMEOUT_1STCALL) {
                if (eCallOwner != CALLOWNER.WALLPAD) {
                    MainActivity.mSubPhoneController.notifyEndCall(eCallOwner, eCallType);
                }
            } else {
                LOG_WARN("[procSubPhoneScenario] Invalid eEventType [" + eEventType + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] procSubPhoneScenario(CALLOWNER eCallOwner, CALLEVENTTYPE eEventType, CALLTYPE eCallType, String strRemoteIP)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public String getRemoteName(String strSIPID, String strIP) {
        try {
            LOG("[getRemoteName] strSIPID [" + strSIPID + "], strIP [" + strIP + "]");
            String[] strParse = strSIPID.split("_");
            String strDeviceType = strParse[1];
            String strHeadID = Integer.toString(Integer.parseInt(strParse[2]));
            String strTailID = Integer.toString(Integer.parseInt(strParse[3]));

            String strResult = "NONE";
            if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_Resi)) {
                strResult = strHeadID + "동 " + strTailID + "호";
            } else if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_RentResi)) {
                strResult = strHeadID + "동 " + strTailID + "-1호";
            } else if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_Guard)) {
                strResult = getGuardName(strIP);
                if (strResult.equals("NONE") || strResult.equals("ERROR")) {
                    strResult = strHeadID + "동 " + strTailID + "번 경비";
                }

                if (strResult.equals("경비실")) strResult = "관할 경비실";
                else if (strResult.equals("관리실")) strResult = "관리사무소";
            } else if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_Lobby)) {
                strResult = strHeadID + "동 " + strTailID + "번 로비폰";
            }
            LOG_INFO("[getRemoteName] strResult [" + strResult + "]");
            return strResult;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return "ERROR";
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getRemoteName(String strSIPID, String strIP)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return "ERROR";
        }
    }

    public int getRemoteDong(String strSIPID) {
        try {
            LOG("[getRemoteDong] strSIPID = " + strSIPID);
            String[] strParse = strSIPID.split("_");
            String strHeadID = Integer.toString(Integer.parseInt(strParse[2]));
            return Integer.parseInt(strHeadID);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return -1;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getRemoteDong(strSIPID)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return -1;
        }
    }

    public int getRemoteID(String strSIPID) {
        try {
            LOG("[getRemoteID] strSIPID = " + strSIPID);
            String[] strParse = strSIPID.split("_");
            String strTailID = Integer.toString(Integer.parseInt(strParse[3]));
            return Integer.parseInt(strTailID);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return -1;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getRemoteID(strSIPID)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return -1;
        }
    }

    public boolean setRemoteInfo(String strSIPID, String strRemoteIP) {
        try {
            LOG("[setRemoteInfo] strSIPID = [" + strSIPID + "], strRemoteIP = [" + strRemoteIP + "]");
            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) {
                if (strSIPID == null || strSIPID.equals("null") || strSIPID.equals("")) {
//                RemoteIDInfo.InitVariables();
                    return false;
                }
                if (strRemoteIP == null || strRemoteIP.equals("null") || strRemoteIP.equals("")) {
//                RemoteIDInfo.InitVariables();
                    return false;
                }

                RemoteIDInfo.strSIPID = strSIPID;
                RemoteIDInfo.strIP = strRemoteIP;

                String[] strParse = RemoteIDInfo.strSIPID.split("_");
                String strDeviceType = strParse[1];
                RemoteIDInfo.nDong = Integer.parseInt(strParse[2]);
                RemoteIDInfo.nHo = Integer.parseInt(strParse[3]);
                RemoteIDInfo.strDong = Integer.toString(RemoteIDInfo.nDong);
                RemoteIDInfo.strHo = Integer.toString(RemoteIDInfo.nHo);
                RemoteIDInfo.strName = "NONE";

                if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_Resi)) {
                    RemoteIDInfo.strName = RemoteIDInfo.strDong + "동 " + RemoteIDInfo.strHo + "호";
                }
                else if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_RentResi)) {
                    RemoteIDInfo.nHo_Extension = 1;
                    RemoteIDInfo.strName = RemoteIDInfo.strDong + "동 " + RemoteIDInfo.strHo + "-" + RemoteIDInfo.nHo_Extension + "호";
                }
                else if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_Guard)) {
                    RemoteIDInfo.strName = getGuardName(RemoteIDInfo.strIP);
                    if (RemoteIDInfo.strName.equals("NONE") || RemoteIDInfo.strName.equals("ERROR")) {
                        if ((Integer.parseInt(RemoteIDInfo.strDong) % 100) == 0) {
                            RemoteIDInfo.strName = "관리동 " + RemoteIDInfo.strHo + "번 경비";
                        }
                        else {
                            RemoteIDInfo.strName = RemoteIDInfo.strDong + "동 " + RemoteIDInfo.strHo + "번 경비";
                        }
                    }

                    if (RemoteIDInfo.strName.equals("경비실")) RemoteIDInfo.strName = "관할 경비실";
                    else if (RemoteIDInfo.strName.equals("관리실")) RemoteIDInfo.strName = "관리사무소";
                }
                else if (strDeviceType.equalsIgnoreCase(DEVICENAME.strType_Lobby)) {
                    if ((Integer.parseInt(RemoteIDInfo.strDong) % 100) == 0) {
                        RemoteIDInfo.strName = "관리동 " + RemoteIDInfo.strHo + "번 로비";
                    }
                    else {
                        RemoteIDInfo.strName = RemoteIDInfo.strDong + "동 " + RemoteIDInfo.strHo + "번 로비";
                    }
                }
            }
            else {
                RemoteIDInfo.strName = strSIPID;
            }
            return true;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return false;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setRemoteInfo(String strSIPID, String strRemoteIP)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            RemoteIDInfo.InitVariables();
            return false;
        }
    }

    public String getGuardName(String strGuardIP) {
        try {
            LOG("[getGuardName] strGuardIP [" + strGuardIP + "]");
            int nGuardCnt = Global.ConfigValues.mGuardListTable.getCnt();
            for (int i = 0; i < nGuardCnt; i++) {
                if (Global.ConfigValues.mGuardListTable.getGuardInfo(i).IP().equals(strGuardIP)) {
                    return Global.ConfigValues.mGuardListTable.getGuardInfo(i).NAME();
                }
            }
            return "NONE";
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return "ERROR";
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getGuardName(String strGuardIP)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return "ERROR";
        }
    }

    private String getGuardType(String strGuardIP) {
        try {
            LOG("[getGuardType] strGuardIP [" + strGuardIP + "]");
            String strResult = getGuardName(strGuardIP);
            if (strResult.contains("관할") || strResult.contains("경비실")) strResult = SUBPHONEHANDELKEY.GUARD_01;
            else if (strResult.contains("정문")) strResult = SUBPHONEHANDELKEY.GUARD_02;
            else if (strResult.contains("후문")) strResult = SUBPHONEHANDELKEY.GUARD_03;
            else if (strResult.equals("관리실")) strResult = SUBPHONEHANDELKEY.GUARD_04;
            else strResult = "NONE";
            return strResult;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return "ERROR";
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getGuardType(strGuardIP)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return "ERROR";
        }
    }

    private void checkCallForward(String strRemoteIP) {
        try {
            LOG("[checkCallForward] strRemoteIP [" + strRemoteIP + "], ConfigValues.bOccupiedMode [" + ConfigValues.bUnoccupiedMode + "]");
            if (ConfigValues.bUnoccupiedMode) {
                for (int i = 0; i < ConfigValues.mGuardListTable.getCnt(); i++) {
                    if (ConfigValues.mGuardListTable.getGuardInfo(i).NAME().equals(("경비실"))) {
                        // 관할경비실의 IP를 가져와서 현재 수신된 경비실기가 관할경비실이면 착신전환을 하지 않는다.
                        String strForwardingIP = ConfigValues.mGuardListTable.getGuardInfo(i).IP();
                        LOG("[checkCallForward] strRemoteIP [" + strRemoteIP + "], strForwardingIP [" + strForwardingIP + "]");
                        if ((!strForwardingIP.equals(strRemoteIP)) && (!strForwardingIP.equals("ERROR"))) {
                            send_check_sip_activation_request(strForwardingIP);
                            return;
                        } else {
                            if (mSIPInterface != null) mSIPInterface.cancelCallForwardToStun();
                        }
                    }
                }
            } else {
                if (mSIPInterface != null) mSIPInterface.cancelCallForwardToStun();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] checkCallForward(String strRemoteIP)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private boolean send_check_sip_activation_request(final String strTargetIP) {
        try {
            Request_check_sip_activation check_sip_activation = new Request_check_sip_activation(mContext);
            if (check_sip_activation.send_check_sip_activation(strTargetIP, null)) {
                check_sip_activation.setResultCtrl(new RetProci() {

                    @Override
                    public void ProcSuccess() {
                        LOG_INFO("[send_check_sip_activation_request] ProcSuccess()");
                        if (mSIPInterface != null) mSIPInterface.requestCallForwardToStun(makeCallForwarInfo(strTargetIP));
                    }

                    @Override
                    public void ProcError() {
                        LOG_INFO("[send_check_sip_activation_request] ProcError()");
                        if (mSIPInterface != null) mSIPInterface.cancelCallForwardToStun();
                    }

                    @Override
                    public void ProcDoing() {
                        LOG_INFO("[send_check_sip_activation_request] ProcDoing()");
                    }
                });
                return true;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] send_check_sip_activation_request(String strTargetIP, String strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            if (mSIPInterface != null) mSIPInterface.cancelCallForwardToStun();
        }
        return false;
    }

    /* =================================================== *
     *                Audio Mode (통화패스)                  *
     * =================================================== */
    int AUDIO_MODE_NORMAL = AudioManager.MODE_NORMAL;              // 0, NORMAL
    int AUDIO_MODE_RINGTONE = AudioManager.MODE_RINGTONE;          // 1, 사용안함
    int AUDIO_MODE_MOIP = AudioManager.MODE_IN_CALL;               // 2, MOIP
//    int AUDIO_MODE_FRONT = AudioManager.MODE_IN_COMMUNICATION;     // 3, FRONT(Door - WallPad)
    int AUDIO_MODE_IN_CALL_PSTN = 4;                               // PSTN 로 WallPad 와 통화시 (Speaker ON, MIC OFF)
    int AUDIO_MODE_SUBPHONE = 5;                                   // MoIP로 WallPad 와 SubPhone 통화시
    int AUDIO_MODE_PSTN_SUBPHONE = 6;                              // PSTN 로 SubPhone 과 통화시
    int AUDIO_MODE_FRONT_SUBPHONE = 7;                             // 현관폰과 SubPhone 통화시
    int AUDIO_MODE_IN_MIC_PSTN = 8;                                // PSTN 로 WallPad 와 통화시 MIC On (Speaker ON, MIC ON)
    int AUDIO_MODE_IN_ARS_PSTN = 9;                                // PSTN 로 WallPad 와 통화시 ARS 모드로
    int AUDIO_MODE_MOIP_IHN750_RESIDENCE = 9;                      // IHN-750의 경우 세대간 통화는 별도로 수행한다.
    int AUDIO_MODE_IN_VOICE_DOOR = 10;                             // 현관 VOICE 모드
    int AUDIO_MODE_IN_DOORWALLPADMUSIC = 10;                       // IHN-1010 현관 초인종
    int AUDIO_MODE_MOIP_RESIDENCE = 11;                            // A20/V40 월패드 세대 통화
    int AUDIO_MODE_MOIP_LOBBY_IHN1010 = 12;                  // IHN-1010 월패드 로비/경비 통화
    int AUDIO_MODE_MOIP_GUARD_IHN1010 = 13;                  // IHN-1010 월패드 로비/경비 통화
    int AUDIO_MODE_MOIP_LOBBY_IHND101 = 12;                        // IHN-D101 월패드 로비 통화
    int AUDIO_MODE_MOIP_GUARD_IHND101 = 13;                        // IHN-D101 월패드 경비실 통화
    int AUDIO_MODE_IN_DOOR_COMMUNICATION_V40 = 15;                 // V40 현관 통화
    int AUDIO_MODE_IN_DTMF_PHONEOUT = 18;                          // IHN-1010 DTMF Phone out
    int AUDIO_MODE_IN_DOOR_RELIEFCALL_V40 = 19;                    // 안심통화
    int AUDIO_MODE_IN_DOOR_REMOTECALL_V40 = 8;                     // 방문객원격통화 (모바일로 현관통화, BSP 2020.12.03.01 메이드인랩)
    int AUDIO_MODE_IN_DOOR_REMOTECALL_V40_IGW30 = 18;              // IHN-D101-I/IHN-D101 방문객원격통화 (BSP 2021.03.16 메이드인랩)

    /* 서브월패드 */
    int AUDIO_MODE_SUBWALLPAD = 15;                             // 메인월패드일 경우 통화패스!! (V40(메인)-?(서브))
//    int AUDIO_MODE_V40_SUBWALLPAD_FRONT = 18;                   // 서브월패드일 경우 현관 통화패스!! (?(메인)-V40(서브))
//    int AUDIO_MODE_V40_SUBWALLPAD_MOIP = 19;				      // 서브월패드일 경우 MOIP 통화패스!! (?(메인)-V40(서브))
    int AUDIO_MODE_V40_SUBWALLPAD_FRONT = 20;                   // 서브월패드일 경우 현관 통화패스!! (?(메인)-V40(서브)) (메이드인랩 BSP)
    int AUDIO_MODE_V40_SUBWALLPAD_MOIP = 21;				    // 서브월패드일 경우 MOIP 통화패스!! (?(메인)-V40(서브)) (메이드인랩 BSP)
    int AUDIO_MODE_IN_FACE_LOBBY_MOIP = 20;                     // 얼굴인식 로비폰과의 통화시 2443 대체품
    // ========================== IHN-D101 ========================== ========================== IHN-1010 ==========================
    //       *  Normal:                        setMode(0)                      Normal:                        setMode(0)
    //       *  DOOR-WALLPAD:                  setMode(15)                     DOOR-WALLPAD:                  setMode(15)
    //       *  PSTN-WALLPAD:                  setMode(4)                      PSTN-WALLPAD:                  setMode(4)
    //       *  MoIP-SubPhone:                 setMode(5)                      MoIP-SubPhone:                 setMode(5)
    //       *  PSTN ARS:                      setMode(9)                      PSTN ARS:                      setMode(9)
    //       *  Residence(WP-WP):              setMode(11)                     Residence(WP-WP):              setMode(11)
    //       *  Lobby-WALLPAD:                 setMode(12)                     Lobby-WALLPAD:                 setMode(12)
    //       *  Guard-WALLPAD:                 setMode(13)                     Guard-WALLPAD:                 setMode(12)
    //       *  PSTN DTMF:                                                                                    setMode(18)
    //       *  DOOR CPU:                      setMode(19)                     DOOR CPU:                      setMode(19)
    //       *  DINGDONG~:                                                                                    setMode(20)
    //       *  DOOR-MOBILE:                   setMode(22)
    // ============================================================== ==============================================================

    public void setTalkPath(CALLPATH eCallPath) {
        try {
            LOG("[setTalkPath] eCallPath [" + eCallPath + "]");

            if (eCallPath == CALLPATH.FRONT) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
//                    MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.AUDIO_FRONT_WALLPAD); // IGW300_CallPathCtrl -> Handler로 수정
//                    MainActivity.mAudioManager.setMode(AUDIO_MODE_FRONT); // Audio setMode -> Handler로 수정
//                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true); // JNI Control
                    ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_FRONT_WALLPAD, 0, 0);
                    sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_FRONT_WALLPAD, 0, 0);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                    MainActivity.mIOInterface.ctrlSetTalkPathDoor();
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_DOOR_COMMUNICATION_V40);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                }
            }
            else if (eCallPath == CALLPATH.MOIP) {
                MainActivity.mAudioManager.setMode(AUDIO_MODE_MOIP);
                MainActivity.mIOInterface.ctrlAudioSwitch34118(false);
            }
            else if (eCallPath == CALLPATH.MOIP_IHN750_RESIDENCE) {
                MainActivity.mAudioManager.setMode(AUDIO_MODE_MOIP_IHN750_RESIDENCE);
                MainActivity.mIOInterface.ctrlAudioSwitch34118(false);
            }
            else if (eCallPath == CALLPATH.MOIP_V40_RESIDENCE) {
                MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_MOIP_RESIDENCE_WALLPAD, 0, 0);
            }
            else if (eCallPath == CALLPATH.MOIP_IHND101_LOBBY) {
                MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_MOIP_LOBBY_WALLPAD, 0, 0);
            }
            else if (eCallPath == CALLPATH.MOIP_IHND101_GUARD) {
                MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_MOIP_GUARD_WALLPAD, 0, 0);
            }
            else if (eCallPath == CALLPATH.MOIP_IHN1010_LOBBY) {
                MainActivity.mAudioManager.setMode(AUDIO_MODE_MOIP_LOBBY_IHN1010);
                MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
            }
            else if (eCallPath == CALLPATH.MOIP_IHN1010_GUARD) {
                MainActivity.mAudioManager.setMode(AUDIO_MODE_MOIP_GUARD_IHN1010);
                MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
            }
            else if (eCallPath == CALLPATH.PSTN) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40) {
                    sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_PSTN_WALLPAD, 0, 0);
                }
                else {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_MIC_PSTN);
                }
            }
            else if (eCallPath == CALLPATH.PSTN_MIC) {
                MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_MIC_PSTN);
            }
            else if (eCallPath == CALLPATH.PSTN_SPEAKER) {
                MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_CALL_PSTN);
            }
            else if (eCallPath == CALLPATH.PSTN_ARS) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300) {
                    sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_PSTN_ARS, 0, 0);
                }
                else {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_MIC_PSTN);
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_ARS_PSTN);
                }
            }
            else if (eCallPath == CALLPATH.SUBPHONE_FRONT) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                    ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_FRONT_SUBPHONE, 0, 0);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(false);
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_FRONT_SUBPHONE);
                    MainActivity.mIOInterface.ctrlSetTalkPathDoor_SubPhone();
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(false);
                }
                else {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_FRONT_SUBPHONE);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(false);
                }
            }
            else if (eCallPath == CALLPATH.SUBPHONE_MOIP) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                    ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_MOIP_SUBPHONE, 0, 0);
                    sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_MOIP_SUBPHONE, 0, 0);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_SUBPHONE);
                    MainActivity.mIOInterface.ctrlSetTalkPathMoIP_SubPhone();
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                }
                else {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_SUBPHONE);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                }
            }
            else if (eCallPath == CALLPATH.SUBPHONE_PSTN) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                    ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_PSTN_SUBPHONE, 0, 0);
                    sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_PSTN_SUBPHONE, 0, 0);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(false);
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_PSTN_SUBPHONE);
                    MainActivity.mIOInterface.ctrlSetTalkPathPSTN_SubPhone();
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                }
                else {
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_MIC_PSTN);
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_PSTN_SUBPHONE);
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                }
            }
            else if (eCallPath == CALLPATH.SUBWALLPAD) {
                if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) {
                    if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) MainActivity.mAudioManager.setMode(AUDIO_MODE_SUBWALLPAD); // 메인: V40_IGW300
                    else LOG_WARN("[setTalkPath] Not Supported MainWallPad BOARDTYPE!! BOARDTYPE [" + ConfigValues.DEVICE_BOARDTYPE + "]");
                }
            }
            else if (eCallPath == CALLPATH.SUB_FRONT_SUBWALLPAD) {
                if (ConfigValues.eWallPadType == WALLPADTYPE.SUB) {
                    // 서브월패드일 경우
                    if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                        LOG("[setTalkPath] setMode [" + AUDIO_MODE_V40_SUBWALLPAD_FRONT + "]");
                        MainActivity.mAudioManager.setMode(AUDIO_MODE_V40_SUBWALLPAD_FRONT); // IHN-1010S
                        sendHandlerMsgDelayed(HANDLERMSG.SET_V40_NOUGAT_SUBWALLPAD_TALKPATH, 0, 0, 2000);
                    }
                    else LOG_WARN("[setTalkPath] Not Supported SubWallPad BOARDTYPE!! BOARD_TYPE [" + ConfigValues.DEVICE_BOARDTYPE + "]");
                }
                else {
                    Log.w(TAG, "[setTalkPath] This talk-paht is only for sub-wallpad!!");
                }
            }
            else if (eCallPath == CALLPATH.SUB_MOIP_SUBWALLPAD) {
                if (ConfigValues.eWallPadType == WALLPADTYPE.SUB) {
                    // 서브월패드일 경우
                    if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                        LOG("[setTalkPath] setMode [" + AUDIO_MODE_V40_SUBWALLPAD_MOIP + "]");
                        MainActivity.mAudioManager.setMode(AUDIO_MODE_V40_SUBWALLPAD_MOIP); // IHN-1010S
                        sendHandlerMsgDelayed(HANDLERMSG.SET_V40_NOUGAT_SUBWALLPAD_TALKPATH, 0, 0, 2000);
                    }
                    else LOG_WARN("[setTalkPath] Not Supported SubWallPad BOARDTYPE!! BOARD_TYPE [" + ConfigValues.DEVICE_BOARDTYPE + "]");
                }
                else {
                    Log.w(TAG, "[setTalkPath] This talk-paht is only for sub-wallpad!!");
                }
            }
            else if (eCallPath == CALLPATH.DTMF) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                    LOG("[setTalkPath] setMode [" + AUDIO_MODE_IN_DTMF_PHONEOUT + "]");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_DTMF_PHONEOUT);
                }
            }
            else if (eCallPath == CALLPATH.DOORMUSIC) {
                LOG("[setTalkPath] setMode [" + AUDIO_MODE_IN_DOORWALLPADMUSIC + "]");
                MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_DOORWALLPADMUSIC);
            }
            else if (eCallPath == CALLPATH.DOOR_RELIEFCALL) {
                LOG("[setTalkPath] setMode [" + AUDIO_MODE_IN_DOOR_RELIEFCALL_V40 + "]");
                MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_DOOR_RELIEFCALL_V40);
                ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_FRONT_WALLPAD, 0, 0); // IHN-D101
                MainActivity.mIOInterface.ctrlSetTalkPathDoor(); // IHN-1010
            }
            else if (eCallPath == CALLPATH.DOOR_REMOTECALL) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                    LOG("[setTalkPath] setMode [" + AUDIO_MODE_IN_DOOR_REMOTECALL_V40_IGW30 + "]");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_DOOR_REMOTECALL_V40_IGW30);
                }
                else {
                    LOG("[setTalkPath] setMode [" + AUDIO_MODE_IN_DOOR_REMOTECALL_V40 + "]");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_DOOR_REMOTECALL_V40);
                }
                ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_FRONT_WALLPAD, 0, 0); // IHN-D101
                MainActivity.mIOInterface.ctrlSetTalkPathDoor();
            }
            else {
                // TalkPath Normal
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300) {
                    ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_OFF, 1, 0);
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                    ((MainActivity) mContext).sendHandlerMsg(IGW300CMD.AUDIO_OFF, 1, 0);
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                    MainActivity.mIOInterface.ctrlSetTalkPathNormal();
                }
                sendHandlerMsg(HANDLERMSG.SETMODE_AUDIO_NORMAL, 0, 0);
                if (MainActivity.mIOInterface != null) {
                    MainActivity.mIOInterface.ctrlAudioSwitch34118(true);
                    MainActivity.mIOInterface.setWallPadSpeakerDefaultGain();
                }
                else Log.w(TAG, "[setTalkPath] MainActivity.mIOInterface is null!!");
                sendHandlerMsg(HANDLERMSG.UNSET_V40_NOUGAT_SUBWALLPAD_TALKPATH, 0, 0);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setTalkPath(eCallPath)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public CALLPATH getTalkPath() {
        try {
            int nMode = MainActivity.mAudioManager.getMode();
//            LOG("[getTalkPath] nMode [" + nMode + "]");
            if (nMode == AUDIO_MODE_NORMAL) {
                return CALLPATH.NORMAL;
            }
            else if (nMode == AUDIO_MODE_MOIP) {
                return CALLPATH.MOIP;
            }
            else if (nMode == AUDIO_MODE_IN_CALL_PSTN) {
                return CALLPATH.PSTN;
            }
            else if (nMode == AUDIO_MODE_SUBPHONE) {
                return CALLPATH.SUBPHONE_MOIP;
            }
            else if (nMode == AUDIO_MODE_PSTN_SUBPHONE) {
                return CALLPATH.SUBPHONE_PSTN;
            }
            else if (nMode == AUDIO_MODE_FRONT_SUBPHONE) {
                return CALLPATH.SUBPHONE_FRONT;
            }
            else if (nMode == AUDIO_MODE_IN_ARS_PSTN) {
                return CALLPATH.PSTN_ARS;
            }
            else if (nMode == AUDIO_MODE_IN_MIC_PSTN) {
                return CALLPATH.PSTN;
            }
            else if (nMode == AUDIO_MODE_IN_DOORWALLPADMUSIC) { // 10 -> 20
                return CALLPATH.DOORMUSIC;
            }
            else if (nMode == AUDIO_MODE_MOIP_RESIDENCE) { // 11
                return CALLPATH.MOIP_V40_RESIDENCE;
            }
            else if (nMode == AUDIO_MODE_MOIP_LOBBY_IHN1010) { // 12
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) return CALLPATH.MOIP_IHND101_LOBBY;
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) return CALLPATH.MOIP_IHN1010_LOBBY;
                else return CALLPATH.NONE;
            }
            else if (nMode == AUDIO_MODE_MOIP_GUARD_IHN1010) { // 13
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) return CALLPATH.MOIP_IHND101_GUARD;
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) return CALLPATH.MOIP_IHN1010_GUARD;
                else return CALLPATH.NONE;
            }
            else if (nMode == AUDIO_MODE_MOIP_LOBBY_IHND101) { // 12
                return CALLPATH.MOIP_IHND101_LOBBY;
            }
            else if (nMode == AUDIO_MODE_MOIP_GUARD_IHND101) { // 13
                return CALLPATH.MOIP_IHND101_GUARD;
            }
            else if (nMode == AUDIO_MODE_IN_DOOR_COMMUNICATION_V40) {
                return CALLPATH.FRONT;
            }
            else if (nMode == AUDIO_MODE_IN_DTMF_PHONEOUT) {
                return CALLPATH.DTMF;
            }
            else if (nMode == AUDIO_MODE_IN_DOOR_RELIEFCALL_V40) {
                return CALLPATH.DOOR_RELIEFCALL;
            }
            else if (nMode == AUDIO_MODE_IN_DOOR_REMOTECALL_V40 || nMode == AUDIO_MODE_IN_DOOR_REMOTECALL_V40_IGW30) {
                return CALLPATH.DOOR_REMOTECALL;
            }
            else if (nMode == AUDIO_MODE_V40_SUBWALLPAD_FRONT) {
                return CALLPATH.SUB_FRONT_SUBWALLPAD;
            }
            else if (nMode == AUDIO_MODE_V40_SUBWALLPAD_MOIP) {
                return CALLPATH.SUB_MOIP_SUBWALLPAD;
            }
            else {
                Log.w(TAG, "[getTalkPath] Not supported nMode [" + nMode + "]");
                return CALLPATH.NONE;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return CALLPATH.ERROR;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getTalkPath()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return CALLPATH.ERROR;
        }
    }

    // 영상제어 관련
    public void selectVideoSourceToSubPhone(boolean bFront, boolean bResidence) {
        try {
            LOG_INFO("[selectVideoSourceToSubPhone] bFront [" + bFront + "], bResidence [" + bResidence + "]");
            if (ConfigValues.bSubPhoneEnable) {
                mVideoJNI.setComposite(!bResidence);
                MainActivity.mIOInterface.selectFrontCam(bFront);
            } else {
                Log.w(TAG, "[selectVideoSourceToSubPhone] ConfigValues.bSubPhoneEnable [" + ConfigValues.bSubPhoneEnable + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] selectVideoSourceToSubPhone(boolean bFront)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void selectVideoSourceToSubPhone(CALLTYPE eCallType, boolean bFinish) { // 통화가 종료될때 finish 플래그 추가(현관통화시 decoderStopOperation 호출을 위해서)
        try {
            Log.d(TAG, "[selectVideoSourceToSubPhone] eCallType [" + eCallType + "], bFinish [" + bFinish + "], ConfigValues.DEVICE_BOARDTYPE [ " + ConfigValues.DEVICE_BOARDTYPE + " ] ConfigValues.eFrontCameraType [ " +  ConfigValues.eFrontCameraType + " ]");

            Log.d(TAG, "[selectVideoSourceToSubPhone] ConfigValues.bSubPhoneEnable " + ConfigValues.bSubPhoneEnable);
            if (ConfigValues.bSubPhoneEnable) {
                if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300) {
                    if (eCallType == CALLTYPE.FRONT) {
                        if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMARTIOT) {
                            MainActivity.mIOInterface.selectFrontCam(false);
                            MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_MOIP);
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                        else {
                            MainActivity.mIOInterface.selectFrontCam(true);
                            MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_FRONT);
                        }
                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_MOIP);
                        mVideoJNI.setComposite(ConfigValues.bGuardVideoEnable);
                        MainActivity.mIOInterface.selectFrontCam(false);
                    }
                    else if (eCallType == CALLTYPE.LOBBY || eCallType == CALLTYPE.RESIDENCE) {
                        MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_MOIP);
                        mVideoJNI.setComposite(true);
                        MainActivity.mIOInterface.selectFrontCam(false);
                    }
                    else {
//                        mVideoJNI.setComposite(false); // decoderStart와 decoderStop 사이에 COM Value를 재설정하면 오동작
                        if (MainActivity.mIOInterface != null)
                            MainActivity.mIOInterface.selectFrontCam(false);
                        if (bFinish) {
                            if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMARTIOT)
                                mVideoJNI.decoderStopOperation();
                        }
                    }
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                    if (eCallType == CALLTYPE.FRONT) {
                        if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMARTIOT) {
                            MainActivity.mIOInterface.selectFrontCam(false);
                            MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_MOIP);
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                        else {
                            MainActivity.mIOInterface.selectFrontCam(true);
                            MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_FRONT);
                        }
                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_MOIP);
                        mVideoJNI.setComposite(ConfigValues.bGuardVideoEnable);
                        MainActivity.mIOInterface.selectFrontCam(false);
                    }
                    else if (eCallType == CALLTYPE.LOBBY)
                    {
                        MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_MOIP);
                        mVideoJNI.setComposite(true);
                        MainActivity.mIOInterface.selectFrontCam(false);
                        //mVideoJNI.decoderStartOperation();
                    }
                    else if(eCallType == CALLTYPE.RESIDENCE) {
                        MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_MOIP);
                        mVideoJNI.setComposite(true);
                        MainActivity.mIOInterface.selectFrontCam(false);
                        //mVideoJNI.decoderStartOperation();
                    }
                    else {
//                        mVideoJNI.setComposite(false); // decoderStart와 decoderStop 사이에 COM Value를 재설정하면 오동작
                        if (MainActivity.mIOInterface != null)
                            MainActivity.mIOInterface.selectFrontCam(false);
                        if (bFinish) {
                            if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMARTIOT)
                                mVideoJNI.decoderStopOperation();


                        }
                    }
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40) {
                    if (eCallType == CALLTYPE.FRONT) {
                        if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMART_HS) {
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                        else if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMART_DW) {
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                        else {
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                    }
//                    else if (eCallType == CALLTYPE.LOBBY || eCallType == CALLTYPE.RESIDENCE) {
//                        mVideoJNI.setComposite(true);
//                    }
                    else if (eCallType == CALLTYPE.LOBBY) {
                        mVideoJNI.setComposite(true);
                    }
                    else if (eCallType == CALLTYPE.RESIDENCE) {
                        mVideoJNI.setComposite(false);
                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        mVideoJNI.setComposite(ConfigValues.bGuardVideoEnable);
                    }
                    else {
//                        mVideoJNI.setComposite(false); // decoderStart와 decoderStop 사이에 COM Value를 재설정하면 오동작
                        if (bFinish) {
                            mVideoJNI.decoderStopOperation();
                        }
                    }
                }
                else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                    if (eCallType == CALLTYPE.FRONT) {
                        if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMART_HS) {
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                        else if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMART_DW) {
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                        else {
                            mVideoJNI.setComposite(false);
                            mVideoJNI.decoderStartOperation();
                        }
                    }
                    else if (eCallType == CALLTYPE.LOBBY || eCallType == CALLTYPE.RESIDENCE) {
                        mVideoJNI.setComposite(true);
                        //mVideoJNI.decoderStartOperation();
                    }
//                    else if (eCallType == CALLTYPE.LOBBY) {
//                        mVideoJNI.setComposite(true);
//                    }
//                    else if (eCallType == CALLTYPE.RESIDENCE) {
//                        mVideoJNI.setComposite(false);
//                    }
                    else if (eCallType == CALLTYPE.GUARD) {
                        mVideoJNI.setComposite(ConfigValues.bGuardVideoEnable);
                    }
                    else {
//                        mVideoJNI.setComposite(false); // decoderStart와 decoderStop 사이에 COM Value를 재설정하면 오동작
                        if (bFinish) {
                            mVideoJNI.decoderStopOperation();
                        }
                    }
                }
                else {
                    Log.w(TAG, "[selectVideoSourceToSubPhone] NOT Supported DEVICE_BOARDTYPE [" + ConfigValues.DEVICE_BOARDTYPE + "]");
                }
            }
            else {
                Log.w(TAG, "[selectVideoSourceToSubPhone] bSubPhoneEnable [" + ConfigValues.bSubPhoneEnable + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] selectVideoSourceToSubPhone(CALLOWNER eCallOwner, CALLTYPE eCallType, CALLSTATUS eCallStatus)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public int SEC_DOOROPEN_DELAYQUITCALL = 3;
    static Timer DelayQuitMoIPCallTimer = null;
    private static int nDelayQuitMoIPCallSec = 0;   // Sec 단위

    public boolean setDelayQuitMoIPCall(int nDelaySec) {
        try {
            LOG("[setDelayQuitMoIPCall] nDelaySec [" + nDelaySec + "]");
            if (nDelayQuitMoIPCallSec > 0) {
                // 타이머가 이미 동작중이므로, 시간을 새로 설정한다.
                nDelayQuitMoIPCallSec = nDelaySec;
            } else {
                // 타이머가 돌아가고 있지 않으므로, 새로 구동한다.
                if (DelayQuitMoIPCallTimer == null) {
                    LOG("[setAutoScreenChange] AutoScreenChangeTimer is null!!");
                    DelayQuitMoIPCallTimer = new Timer();
                    DelayQuitMoIPCallTimer.schedule(new DelayQuitMoIPCallCntDN(), 0, 1000);
                }
                nDelayQuitMoIPCallSec = nDelaySec;
            }
            return true;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return false;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setDelayQuitMoIPCall(nDelaySec) : " + e);
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return false;
        }
    }

    public class DelayQuitMoIPCallCntDN extends TimerTask {
        @Override
        public void run() {
            try {
                nDelayQuitMoIPCallSec--;
                LOG("[DelayQuitMoIPCallCntDN.run()] nDelayQuitMoIPCallSec = " + nDelayQuitMoIPCallSec);
                if (nDelayQuitMoIPCallSec <= 0) {
                    LOG("[DelayQuitMoIPCallCntDN.run()] QuitMoIPCall!!");
                    DelayQuitMoIPCallTimer.cancel();
                    DelayQuitMoIPCallTimer = null;
                    if (mCallInfo.getIDLECnt() != mCallInfo.IDLECNT_MAX) quitMoIPCall();
                }
            } catch (RuntimeException re) {
                LogUtil.errorLogInfo("", TAG, re);
            } catch (Exception e) {
                Log.e(TAG, "[Exception] DelayQuitMoIPCallCntDN().run() : " + e);
                //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            }
        }
    }

    HDCTimer CallTimer_1st = new HDCTimer(mContext);

    public void set1stCallTimer(CALLTYPE eCallType, int nSec) {
        try {
            LOG_INFO("[set1stCallTimer] nSec [" + nSec + "]");
            CallTimer_1st.setCallTimer(CALLEVENTTYPE.TIMEOUT_1STCALL, eCallType, nSec, 1);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] set1stCallTimer(int nSec)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void stop1stCallTimer() {
        try {
            CallTimer_1st.setCallTimer(null, null, -99, 1);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] stop1stCallTimer()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    HDCTimer CallTimer_2nd = new HDCTimer(mContext);

    public void set2ndCallTimer(CALLTYPE eCallType, int nSec) {
        try {
            LOG_INFO("[set2ndCallTimer] nSec [" + nSec + "]");
            CallTimer_2nd.setCallTimer(CALLEVENTTYPE.TIMEOUT_2NDCALL, eCallType, nSec, 2);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] set2ndCallTimer(int nSec)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void stop2ndCallTimer() {
        try {
            CallTimer_2nd.setCallTimer(null, null, -99, 2);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] stop2ndCallTimer()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    HDCTimer CallTimer_3rd = new HDCTimer(mContext);

    public void set3rdCallTimer(CALLTYPE eCallType, int nSec) {
        try {
            LOG_INFO("[set3rdCallTimer] nSec [" + nSec + "]");
            CallTimer_3rd.setCallTimer(CALLEVENTTYPE.TIMEOUT_3RDCALL, eCallType, nSec, 3);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] set3rdCallTimer(int nSec)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void stop3rdCallTimer() {
        try {
            CallTimer_3rd.setCallTimer(null, null, -99, 3);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] stop3rdCallTimer()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    String[] astrPhoneNoPrefix = {
            "001", "002", "003", "003XX", "004", "005", "007XX", "008", "009",   // 국제전화
            "010", "011", "012", "013", "015", "016", "017", "018", "019",   // 이동통신
            "020", "030", "040", "050", "060", "070", "080", "090",   // 공통서비스
            "02", "031", "032", "033", "041", "042", "043", "044", "051", "052", "053", "054", "055", "061", "062", "063", "064",   // 지역번호
            "081", "082", "083", "084", "085", "086", "087", "088", "089",   // 시외전화
            "1588", "1577", "1899", "1544", "1644", "1661", "1566", "1600", "1670", "1688", "1666", "1599", "1877", "1855", "1800",   // 기간통신사업자 공통부가서비스
            "1541", "1633", "08217", "1655", "1677", "1682",   // 콜렉트콜
    };

    public String getPSTNPhoneNo(String strPhoneNo) {
        try {
            return strPhoneNo;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return null;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getPSTNPhoneNo(String strPhoneNo)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return null;
        }
    }

    public interface PopupEventListener {
        public void onCallerID(String strCallerID);

        public void onMulticallChange(CALLTYPE eCallType, CALLSTATUS eCallStatus, String strRemoteInfo);

        public void onShowPopupRemoteVideo(boolean bShow);
    }

    public PopupEventListener mPopupEventListener;

    public void setPopupEventListener(PopupEventListener POPEV) {
        mPopupEventListener = POPEV;
    }

    public void releasePopupEventListener() {
        mPopupEventListener = null;
    }

    // 방문자 사진 저장관련
    public boolean saveMoIPPicture(CALLTYPE eCallType, String strFilePath) {
        try {
            LOG_INFO("[saveMoIPPicture] eCallType [" + eCallType + "], strFilePath [" + strFilePath + "]");
            if (mVideoJNI != null) {
                Bitmap mBitmap = mVideoJNI.getMoIPPicture(eCallType);

                if (mBitmap == null) return false;

                if (((MainActivity) mContext).bLCDReverse) {
                    Matrix mMatrix = new Matrix();
                    mMatrix.postRotate(180);
                    mBitmap = Bitmap.createBitmap(mBitmap, 0, 0, mBitmap.getWidth(), mBitmap.getHeight(), mMatrix, true);
                }

                if (eCallType == CALLTYPE.FRONT) {
                    Matrix matrix = new Matrix();
                    if (ConfigValues.eFrontCameraType == FRONTCAMERATYPE.SMARTIOT) {
                        if (ConfigValues.bSmartIOTCamFlip) matrix.setScale(1, 1);
                        else matrix.setScale(-1, 1); // 스마트현관카메라(좌우반전X)일 경우 사진이 반대로 찍히므로 좌우반전하여 저장
                    }
                    if (ConfigValues.DEVICE_MODELTYPE == MODEL_TYPE.IHN_HS101 || ConfigValues.DEVICE_MODELTYPE == MODEL_TYPE.IHN_HS101_I)
                        mBitmap = Bitmap.createBitmap(mBitmap, 4, 0, mBitmap.getWidth() - 4, mBitmap.getHeight(), matrix, true); // 효성월패드 방문자사진 좌측 검은줄 삭제
                    else mBitmap = Bitmap.createBitmap(mBitmap, 0, 0, 320, 240, matrix, true);
                }
                else if (eCallType == CALLTYPE.LOBBY) {
                    // ILP-300과 통화시 좌측에 생기는 검은 줄 삭제 -> 로비폰에서 보내주는 영상에 검은줄이 있으나, 로비폰 BSP 수정에 시간이 걸려 월패드 앱에서 수정 (JEFF, 2020.01.12)
                    Matrix mMatrix = new Matrix();
                    mBitmap = Bitmap.createBitmap(mBitmap, 4, 0, mBitmap.getWidth() - 4, mBitmap.getHeight(), mMatrix, true);
                }

                if (mBitmap != null) return saveBMPtoJPG(mBitmap, strFilePath);
                else Log.w(TAG, "[saveMoIPPicture] mBitmap is null!!");
            }
            else {
                Log.w(TAG, "[saveMoIPPicture] mVideoJNI is null!!");
                return false;
            }

        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] saveMoIPPicture(CALLTYPE eCallType, String strFilePath)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    public String makeVisitorPictureName(CALLTYPE eCallType) {
        try {
            String strDeviceType = DeviceType.RESIDENCE.toString();
            if (ConfigValues.bSetRentHouse) strDeviceType = DeviceType.RENTRESIDENCE.toString();

            String strDeviceInfo = Global.getSitecodeString() + "_" + strDeviceType + "_" +
                    Global.ZeroPadding_Head(4, ConfigValues.strDong) + "_" + Global.ZeroPadding_Head(4, ConfigValues.strHo) + "_" + eCallType.toString().replace("_", "") + "_";
            String strTimeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
            String strResult = strDeviceInfo + strTimeStamp + ".jpg";
            Log.i(TAG, "[makeVisitorPictureName] strResult [" + strResult + "]");
            return strResult;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return null;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] makeVisitorPictureName(CALLTYPE eCallType)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return null;
        }
    }

    public boolean saveBMPtoJPG(Bitmap bitmap, String strFilePath) {
        LOG_INFO("[saveBMPtoJPG] bitmap [" + bitmap.getByteCount() + "], strFilePath [" + strFilePath + "]");
        OutputStream mFileOutputStream = null;
        try {
            File mFile = new File(strFilePath);
//            mFile.createNewFile();
            mFileOutputStream = new FileOutputStream(mFile);
            bitmap.compress(CompressFormat.JPEG, 100, mFileOutputStream);
//            ((MainActivity) mContext).encryptPictureFile(mFile); // TODO 추후 적용!!! 홈넷 AAA등급 인증을 위한 사진 암호화
            return true;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] saveBMPtoJPG(Bitmap bitmap, String strFilePath)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        } finally {
            try {
                mFileOutputStream.close();
            } catch (IOException e) {
                Log.e(TAG, "[IOException] saveBMPtoJPG(Bitmap bitmap, String strFilePath)");
                //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            }
        }
        return false;
    }

    public String strVisitorPicturePath = null;

    public String saveVisitorPicture(CALLTYPE eCallType, CALLSTATUS eCallStatus, String strRemoteSIPID, boolean bChecked, boolean bThief, boolean bRemote_FrontCalled) {
        try {
            LOG_INFO("[saveVisitorPicture] eCallType [" + eCallType + "], eCallStatus [" + eCallStatus + "], strRemoteSIPID [" + strRemoteSIPID + "], " + "bChecked [" + bChecked + "], bThief [" + bThief + "], bRemote_FrontCalled [" + bRemote_FrontCalled + "]");
            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) {
                strVisitorPicturePath = null;
                File mFile = new File(DBInfo.DIRECTORY_URI_VISITORPICTURE);
                if (!mFile.exists()) {
                    if (!mFile.mkdirs()) {
                        Log.e(TAG, "[saveVisitorPicture] failed to create directory");
                        return null;
                    }
                }

                String strName = "NONE";
                if (eCallType == CALLTYPE.PSTN) strName = eCallType.toString() + ":" + strRemoteSIPID;
                else if (eCallType == CALLTYPE.FRONT) {
                    if (eCallStatus == CALLSTATUS.TAKINGPIC) {
                        strName = DEVICENAME.strType_Front_Stranger + ":" + strRemoteSIPID;
                    }
                    else {
                        strName = DEVICENAME.strType_Front + ":" + strRemoteSIPID;
                    }
                }
                else strName = Global.makeCallHistoryName(strRemoteSIPID);
                Log.d(TAG, "[saveVisitorPicture] strName [" + strName + "]");

                VisitorPictureHistoryUnit mVisitorPictureHistoryUnit = new VisitorPictureHistoryUnit();
                strVisitorPicturePath = DBInfo.DIRECTORY_URI_VISITORPICTURE + makeVisitorPictureName(eCallType);
                if (eCallType == CALLTYPE.FRONT) {
                    if (eCallStatus == CALLSTATUS.TAKINGPIC) {
                        if (!((MainActivity) mContext).saveFrontPicture()) return null;
                    }
                    else {
                        if (bRemote_FrontCalled) {
                            if (((MainActivity)mContext).mFrontCamera != null) {
                                if (!saveMoIPPicture(eCallType, strVisitorPicturePath)) return null;
                            }
                            else {
                                Log.w(TAG, "[saveVisitorPicture] mFrontCamera is null!!");
                                return null;
                            }
                        }
                        else {
                            if (((MainActivity)mContext).mFrontCamera != null) {
                                if (!((MainActivity) mContext).saveFrontPicture()) return null;
                            }
                            else {
                                Log.w(TAG, "[saveVisitorPicture] mFrontCamera is null!!");
                                return null;
                            }
                        }
                    }
                }
                else if (eCallType == CALLTYPE.LOBBY || eCallType == CALLTYPE.GUARD || eCallType == CALLTYPE.RESIDENCE) {
                    if (!saveMoIPPicture(eCallType, strVisitorPicturePath)) {
                        return null;
                    }
                }

                if (strVisitorPicturePath != null) {
                    String strThief = "FALSE";
                    if (bThief) strThief = "TRUE";
                    else strThief = "FALSE";
                    Log.d(TAG, "[saveVisitorPicture] strThief [" + strThief + "]");

                    if (bChecked) {
                        // 사용자가 집적 찍은 경우에도 New 표시를 한다.
                        mVisitorPictureHistoryUnit.setValue(strName, strRemoteSIPID, "FALSE", strThief, strVisitorPicturePath, "null", "null");
                    } else {
                        mVisitorPictureHistoryUnit.setValue(strName, strRemoteSIPID, "FALSE", strThief, strVisitorPicturePath, "null", "null");
                    }
                    if (MainActivity.mVisitorPictureHistoryManager.addVisitorPictureHistory(mVisitorPictureHistoryUnit) < 0) {
                        if (MainActivity.mVisitorPictureHistoryManager.initVisitorPictureDB(Declare.DBInfo.TABLE_NAME_HISTORY_VISITORPICTURE, Declare.DBInfo.VALUE_NAME_HISTORY_VISITORPICTURE)) {
                            if (MainActivity.mVisitorPictureHistoryManager.addVisitorPictureHistory(mVisitorPictureHistoryUnit) < 0) {
                                return strVisitorPicturePath;
                            }
                        }
                    } else {
                        return strVisitorPicturePath;
                    }
                }
            }
            else {
                Log.w(TAG, "[saveVisitorPicture] Only main-wallpad supports visitor picture! no visitor picture!!");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] saveVisitorPicture(CALLTYPE eCallType, String strRemoteSIPID)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return null;
    }

    public String saveVisitorPictureFile(CALLTYPE eCallType, String strRemoteSIPID, boolean bChecked, boolean bRemote_FrontCalled) {
        try {
            LOG_INFO("[saveVisitorPictureFile] eCallType [" + eCallType + "], strRemoteSIPID [" + strRemoteSIPID + "], bRemote_FrontCalled [" + bRemote_FrontCalled + "]");
            if (ConfigValues.eWallPadType == WALLPADTYPE.MAIN) {
                strVisitorPicturePath = null;
                File mFile = new File(DBInfo.DIRECTORY_URI_VISITORPICTURE);
                if (!mFile.exists()) {
                    if (!mFile.mkdirs()) {
                        Log.e(TAG, "[saveVisitorPictureFile] failed to create directory");
                        return null;
                    }
                }

                strVisitorPicturePath = DBInfo.DIRECTORY_URI_VISITORPICTURE + makeVisitorPictureName(eCallType);
                if (eCallType == CALLTYPE.FRONT) {
                    if (bRemote_FrontCalled) {
                        if (!saveMoIPPicture(eCallType, strVisitorPicturePath)) return null;
                    }
                    else {
                        if (!((MainActivity) mContext).saveFrontPicture()) return null;
                    }
                }
                else if (eCallType == CALLTYPE.LOBBY || eCallType == CALLTYPE.GUARD || eCallType == CALLTYPE.RESIDENCE) {
                    if (!saveMoIPPicture(eCallType, strVisitorPicturePath)) {
                        return null;
                    }
                }

                if (strVisitorPicturePath != null) return strVisitorPicturePath;
            }
            else {
                Log.w(TAG, "[saveVisitorPictureFile] Only main-wallpad supports visitor picture! no visitor picture!!");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] saveVisitorPictureFile(CALLTYPE eCallType, String strRemoteSIPID)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return null;
    }

    public final class HANDLERMSG {
        // setMode 관련
        public final static int SETMODE_AUDIO_FRONT_WALLPAD = 100;
        public final static int SETMODE_AUDIO_FRONT_SUBPHONE = 101;
        public final static int SETMODE_AUDIO_FRONT_VOICE = 102;
        public final static int SETMODE_AUDIO_MOIP_RESIDENCE_WALLPAD = 103;
        public final static int SETMODE_AUDIO_MOIP_LOBBY_WALLPAD = 104;
        public final static int SETMODE_AUDIO_MOIP_GUARD_WALLPAD = 105;
        public final static int SETMODE_AUDIO_MOIP_SUBPHONE = 106;
        public final static int SETMODE_AUDIO_PSTN_WALLPAD = 107;
        public final static int SETMODE_AUDIO_PSTN_ARS = 108;
        public final static int SETMODE_AUDIO_PSTN_SUBPHONE = 109;
        public final static int SETMODE_AUDIO_PSTN_MIC = 110;
        public final static int SETMODE_AUDIO_NORMAL = 111;
        public final static int SELECT_VIDEO_FRONT = 300;
        public final static int SETTALKPATH_DOORMUSIC = 400;
        public final static int SET_V40_NOUGAT_SUBWALLPAD_TALKPATH = 500;
        public final static int UNSET_V40_NOUGAT_SUBWALLPAD_TALKPATH = 501;
    }

    public Handler CallControllerHandler = new Handler(Looper.getMainLooper()) {
        public void handleMessage(Message msg) {
//            LOG("[CallControllerHandler] what [" + msg.what + "], arg1 [" + msg.arg1 + "], arg2 [" + msg.arg2 + "]");

            switch (msg.what) {
                // setMode
                case HANDLERMSG.SETMODE_AUDIO_FRONT_WALLPAD:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_FRONT_WALLPAD");
//                    MainActivity.mAudioManager.setMode(AUDIO_MODE_FRONT); // V40 현관패스 3->15로 변경
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_DOOR_COMMUNICATION_V40);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_FRONT_SUBPHONE:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_FRONT_SUBPHONE");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_FRONT_SUBPHONE);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_FRONT_VOICE:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_FRONT_VOICE");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_VOICE_DOOR);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_MOIP_RESIDENCE_WALLPAD:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_MOIP_RESIDENCE_WALLPAD");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_MOIP_RESIDENCE);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_MOIP_LOBBY_WALLPAD:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_MOIP_LOBBY_WALLPAD");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_MOIP_LOBBY_IHND101);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_MOIP_GUARD_WALLPAD:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_MOIP_GUARD_WALLPAD");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_MOIP_GUARD_IHND101);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_MOIP_SUBPHONE:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_MOIP_SUBPHONE");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_SUBPHONE);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_PSTN_WALLPAD:
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_CALL_PSTN);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_PSTN_ARS:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_PSTN_ARS");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_ARS_PSTN);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_PSTN_SUBPHONE:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_PSTN_SUBPHONE");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_PSTN_SUBPHONE);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_PSTN_MIC:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_PSTN_MIC");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_IN_MIC_PSTN);
                    break;

                case HANDLERMSG.SETMODE_AUDIO_NORMAL:
                    Log.d(TAG, "[CallControllerHandler] SETMODE_AUDIO_NORMAL");
                    MainActivity.mAudioManager.setMode(AUDIO_MODE_NORMAL);
                    break;

                case HANDLERMSG.SELECT_VIDEO_FRONT:
                    Log.d(TAG, "[CallControllerHandler] SELECT_VIDEO_FRONT");
                    MainActivity.mIOInterface.interfaceIGW300(IGW300CMD.VIDEO_FRONT);
                    break;

                case HANDLERMSG.SETTALKPATH_DOORMUSIC:
                    Log.d(TAG, "[CallControllerHandler] SETTALKPATH_DOORMUSIC");
                    setTalkPath(CALLPATH.DOORMUSIC);
                    break;

                case HANDLERMSG.SET_V40_NOUGAT_SUBWALLPAD_TALKPATH:
                    Log.d(TAG, "[CallControllerHandler] SET_V40_NOUGAT_SUBWALLPAD_TALKPATH");
                    if (MainActivity.mIOInterface != null) MainActivity.mIOInterface.ctrlSubWallPadTalkPath(true);
                    break;

                case HANDLERMSG.UNSET_V40_NOUGAT_SUBWALLPAD_TALKPATH:
                    Log.d(TAG, "[CallControllerHandler] UNSET_V40_NOUGAT_SUBWALLPAD_TALKPATH");
                    if (MainActivity.mIOInterface != null) MainActivity.mIOInterface.ctrlSubWallPadTalkPath(false);
                    break;

                default:
                    LOG("CallControllerHandler : " + msg.what);
                    break;
            }
        }
    };

    public void sendHandlerMsg(int what, int arg1, int arg2) {
        try {
            LOG("[sendHandlerMsg] what [" + what + "], arg1 [" + arg1 + "], arg2 [" + arg2 + "]");
            Message HandleMsg = CallControllerHandler.obtainMessage();
            HandleMsg.what = what;
            HandleMsg.arg1 = arg1;
            HandleMsg.arg2 = arg2;
            CallControllerHandler.sendMessage(HandleMsg);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] sendHandlerMsg(msg)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void sendHandlerMsgDelayed(int what, int arg1, int arg2, long delay) {
        try {
            LOG("[sendHandlerMsgDelayed] what [" + what + "], arg1 [" + arg1 + "], arg2 [" + arg2 + "], delay [" + delay + "]");
            Message HandleMsg = CallControllerHandler.obtainMessage();
            HandleMsg.what = what;
            HandleMsg.arg1 = arg1;
            HandleMsg.arg2 = arg2;
            CallControllerHandler.sendMessageDelayed(HandleMsg, delay);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] sendHandlerMsgDelayed(msg)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void sendBlockSIPCallBR() {
        try {
            Log.i(TAG, "[sendBlockSIPCallBR] ===== START =====");
            Intent mIntent = new Intent();
            mIntent.setAction(Declare.BR.BR_BLOCK_SIPCALL);
            mContext.sendBroadcast(mIntent);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] sendBlockSIPCallBR()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void setSubWallPadAudioGPIO() {
        try {
            Log.i(TAG, "[setSubWallPadAudioGPIO] ===== START =====");
            Intent mIntent = new Intent();
            mIntent.setAction(Declare.BR.BR_BLOCK_SIPCALL);
            mContext.sendBroadcast(mIntent);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setSubWallPadAudioGPIO()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void setSubWallPadAudioPath() {
        try {
            Log.i(TAG, "[setSubWallPadAudioPath] doesn't work!!!");
//            String strResult = execBashShellCmd("/system/bin/tinymix 1 60");
//            Log.i(TAG, "[setSubWallPadAudioPath] strResult [" +strResult + "]");
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setSubWallPadAudioPath()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private String execBashShellCmd(String strCmd) throws RuntimeException {
        try {
            Log.i(TAG, "[execBashShellCmd] strCmd [" + strCmd + "]");
            // 명령문 실행
            Process process = Runtime.getRuntime().exec(strCmd);

            // 결과를 읽는다
            // 참고 : process.getOutputStream() 을 통해서 명령문의 stdin 에 쓰기를 할 수 있다.
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            int read;
            char[] buffer = new char[4096];
            StringBuffer output = new StringBuffer();
            while ((read = reader.read(buffer)) > 0) {
                output.append(buffer, 0, read);
            }
            reader.close();

            // 명령문이 종료될 때까지 기다린다
            process.waitFor();

            return output.toString();
        } catch (IOException e) {
            Log.e(TAG, "[IOException] execBashShellCmd(String strCmd)");
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            Log.e(TAG, "[RuntimeException] execBashShellCmd(String strCmd)");
            throw new RuntimeException(e);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] execBashShellCmd(String strCmd)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return "Exception";
        }
    }

    public void onCeresCallEvent(Intent mIntent) {
        try {
            String strCallOwner = mIntent.getStringExtra(Declare.CALLTRIGGER.CALLOWNER);
            String strCallEvent = mIntent.getStringExtra(Declare.CALLTRIGGER.CALLEVENTTYPE);
            String strCallType = mIntent.getStringExtra(Declare.CALLTRIGGER.CALLTYPE);
            String strRemoteNum =  mIntent.getStringExtra(Declare.CALLTRIGGER.REMOTEINFO);

            CALLOWNER callowner = CALLOWNER.getCALLOWNER(strCallOwner);
            CALLTYPE calltype = CALLTYPE.getCALLTYPE(strCallType);
            CALLEVENTTYPE calleventtype = CALLEVENTTYPE.getCALLEVENTTYPE(strCallEvent);

            RemoteIDInfo.strSIPID = makeSIPID(strRemoteNum);

            Log.d(TAG, "calleventtype : " + calleventtype);

            if (calleventtype == CALLEVENTTYPE.CONNECT_CALL) {
                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.CONNECT_CALL, calltype, strRemoteNum, RemoteIDInfo.strSIPID, "null");
            }
            else if (calleventtype == CALLEVENTTYPE.TERMINATE_CALL)
            {
                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.TERMINATE_CALL, calltype, strRemoteNum, RemoteIDInfo.strSIPID, "null");
            }
            else if(calleventtype == CALLEVENTTYPE.RECEIVE_CALL_ACK)
            {
                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.RECEIVE_CALL_ACK, calltype, strRemoteNum, RemoteIDInfo.strSIPID, "null");
            }
//            else if (ncalleventtype == CALLEVENTTYPE.CALLTYPE_RECEIVE_CALL_END) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.TERMINATE_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.CONNECT_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            int nDeviceType = mIntent.getIntExtra(HomeAutomation_Call.BR_DEVICE, HomeAutomation_Call.DEVICE_NONE);
//            int nEventType = mIntent.getIntExtra(HomeAutomation_Call.BR_TYPE_CALL, HomeAutomation_Call.CALLTYPE_NONE);
//            int nDong = mIntent.getIntExtra(HomeAutomation_Call.BR_ID_DONG, 0);
//            int nHo = mIntent.getIntExtra(HomeAutomation_Call.BR_ID_HO, 0);
//
//            m_iCallDeviceType = nDeviceType;
//            Log.i(TAG, "[onAnalogCallEvent] nDeviceType [" + nDeviceType + "], nEventType [" + nEventType + "], nDong [" + nDong + "], nHo [" + nHo + "]");
//
//            if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_REQUEST) {
//                if (mCallInfo.getIDLECnt() != mCallInfo.IDLECNT_MAX) {
//                    if (mCallInfo.getIDLECnt() < mCallInfo.IDLECNT_MAX - 1) {
//                        sendNACKRequestCall(getAnalogEnumCallType(nDeviceType), nDong, nHo);
//                        return;
//                    }
//                    else {
//                        if (mCallInfo.getGUARD() != CALLSTATUS.IDLE || mCallInfo.getLOBBY() != CALLSTATUS.IDLE || mCallInfo.getRESI() != CALLSTATUS.IDLE || mCallInfo.getFRONT() != CALLSTATUS.IDLE) {
//                            sendNACKRequestCall(getAnalogEnumCallType(nDeviceType), nDong, nHo);
//                            return;
//                        }
//                    }
//                }
//
//                RemoteIDInfo.strDong = Integer.toString(nDong);
//                RemoteIDInfo.strHo = Integer.toString(nHo);
//                RemoteIDInfo.strIP = Global.makeIPAddress(getDeviceType(nDeviceType), RemoteIDInfo.strDong, RemoteIDInfo.strHo);
//                RemoteIDInfo.strSIPID = makeSIPID(RemoteIDInfo.strIP);
//
//                sendACKRequestCall(getAnalogEnumCallType(nDeviceType), Integer.parseInt(RemoteIDInfo.strDong), Integer.parseInt(RemoteIDInfo.strHo));
//                CallScenarioManager(CALLOWNER.NONE, CALLEVENTTYPE.RECEIVE_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_END) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.TERMINATE_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_ACK) {
//                Log.i(TAG, "[onAnalogCallEvent] RemoteIDInfo.strDong [" + RemoteIDInfo.strDong + "], RemoteIDInfo.strHo [" + RemoteIDInfo.strHo + "]");
//                if(m_bCallSendState) {
//                    m_bCallSendState = false;
//                    CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.RECEIVE_CALL_ACK, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//                }
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_ACK_FAIL) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.REJECT_BUSY_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_START) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.CONNECT_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_DOOR_OPEN_ACK) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.DOOR_OPEN, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_SEND_CALL_ACK_FAIL) {
//                MultiCallInfo MCInfo = new MultiCallInfo();
//
//                if(nDeviceType == 1)
//                    MCInfo.setMulticallInfo(CALLTYPE.NONE, CALLTYPE.GUARD, CALLSTATUS.BUSY, CALLOWNER.NONE, "", "", "", "경비실", "");
//                else if(nDeviceType == 2)
//                    MCInfo.setMulticallInfo(CALLTYPE.NONE, CALLTYPE.LOBBY, CALLSTATUS.BUSY, CALLOWNER.NONE, "", "", "", "로비", "");
//                else if(nDeviceType == 3) {
//                    MCInfo.setMulticallInfo(CALLTYPE.NONE, CALLTYPE.RENTRESIDENCE, CALLSTATUS.BUSY, CALLOWNER.NONE, "", "", "", nDong + "동 " + nHo + "호", "");
//                }
//
//                MainActivity.mCallController.mCallInfo.setMultiCallInfo(MCInfo);
//                //Global.make2ndCallHistoryInfo(eCallType.toString(), "NONE", Global.CALLDIRECTION.IN, Global.CALLACTION.MISS, Global.CALLRESULT.IN_MISS);
//                ((MainActivity) mContext).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL_NOTICE);
//
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_SEND_CALL_REQUEST) {
//
//                m_bCallSendState = true;
//                Handler Handler = new Handler();
//                Handler.postDelayed(new Runnable()  {
//                    public void run() {
//                        // 시간 지난 후 실행할 코딩
//                        if(m_bCallSendState) {
//                            m_bCallSendState = false;
//                            CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.REJECT_CALL, getAnalogEnumCallType(m_iCallDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//                        }
//                    }
//                }, 2000);
//
//            }
            else {
                LOG_WARN("[onCeresCallEvent1] nEventType is unavailable!! nEventType [" + calleventtype + "]");
            }
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onCeresCallEvent1(Intent mIntent)");
            e.printStackTrace();
        }
    }

    public void onCeresCallEvent(CALLTYPE nDeviceType, CALLEVENTTYPE nEventType, String strIP) {
        try {
//            RemoteIDInfo.strDong = Integer.toString(nDong);
//            RemoteIDInfo.strHo = Integer.toString(nHo);
//
//            RemoteIDInfo.strIP = Global.makeIPAddress(getDeviceType(nDeviceType), RemoteIDInfo.strDong, RemoteIDInfo.strHo);
            RemoteIDInfo.strSIPID = makeSIPID(strIP);
            Log.i(TAG, "[onCeresCallEvent] nDeviceType [" + nDeviceType + "], nEventType [" + nEventType + "], " + " strIP [" + strIP + "], " + "RemoteIDInfo.strSIPID [" + RemoteIDInfo.strSIPID + "]");
            if (nEventType == CALLEVENTTYPE.RECEIVE_CALL) {
//                if (mCallInfo.getIDLECnt() != mCallInfo.IDLECNT_MAX) {
//                    if (mCallInfo.getIDLECnt() < mCallInfo.IDLECNT_MAX - 1) {
//                        sendNACKRequestCall(getAnalogEnumCallType(nDeviceType), Integer.parseInt(RemoteIDInfo.strDong), Integer.parseInt(RemoteIDInfo.strHo));
//                        return;
//                    }
//                    else {
//                        if (mCallInfo.getGUARD() != CALLSTATUS.IDLE || mCallInfo.getLOBBY() != CALLSTATUS.IDLE || mCallInfo.getRESI() != CALLSTATUS.IDLE || mCallInfo.getFRONT() != CALLSTATUS.IDLE) {
//                            sendNACKRequestCall(getAnalogEnumCallType(nDeviceType), nDong, nHo);
//                            return;
//                        }
//                    }
//                }

                // 어플이 실행되는 경우에는 API에서 먼저 ACK를 전송하므로, 통화어플에서 ACK를 전송할 필요가 없다. (JEFF, 2017.04.24)
//                sendACKRequestCall(getAnalogEnumCallType(nDeviceType), Integer.parseInt(RemoteIDInfo.strDong), Integer.parseInt(RemoteIDInfo.strHo));
                CallScenarioManager(CALLOWNER.NONE, CALLEVENTTYPE.RECEIVE_CALL, nDeviceType, RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
            }

//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_END) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.TERMINATE_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_ACK) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.RECEIVE_CALL_ACK, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_ACK_FAIL) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.REJECT_BUSY_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_CALL_START) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.CONNECT_CALL, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
//            else if (nEventType == HomeAutomation_Call.CALLTYPE_RECEIVE_DOOR_OPEN_ACK) {
//                CallScenarioManager(mCallInfo.getCallOwner(), CALLEVENTTYPE.DOOR_OPEN, getAnalogEnumCallType(nDeviceType), RemoteIDInfo.strIP, RemoteIDInfo.strSIPID, "null");
//            }
            else {
                LOG_WARN("[onAnalogCallEvent] nEventType is unavailable!! nEventType [" + nEventType + "]");
            }
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onAnalogCallEvent(Intent mIntent)");
            e.printStackTrace();
        }
    }





}