package kr.co.icontrols.wallpadcall.screen;

import android.content.Context;
import android.content.Intent;
import android.graphics.Color;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.RelativeLayout.LayoutParams;
import android.widget.SeekBar;

import com.artncore.WallPadDataMgr.WallpadAccessData;
import com.artncore.WallPadDataMgr.WallpadStatusData;
import com.artncore.commons.define;
import com.artncore.wallpadapi.WallPadAPI;
import com.artncore.wallpadimap.RetProci;
import com.util.LogUtil;

import java.io.File;

import kr.co.icontrols.callengine.engine.AutoSaveVisitorPicture.startAutoSaveVisitorPicture;
import kr.co.icontrols.callengine.engine.CallController.CallEventListener;
import kr.co.icontrols.callengine.engine.CallManager.CALLEVENTTYPE;
import kr.co.icontrols.callengine.engine.CallManager.CALLOWNER;
import kr.co.icontrols.callengine.engine.CallManager.CALLPATH;
import kr.co.icontrols.callengine.engine.CallManager.CALLSTATUS;
import kr.co.icontrols.callengine.engine.CallManager.CALLTYPE;
import kr.co.icontrols.callengine.engine.MissedCallVisitorPicture.startMissedCallVisitorPicture;
import kr.co.icontrols.callengine.remotecall.RemoteCallManager;
import kr.co.icontrols.wallpadcall.MainActivity;
import kr.co.icontrols.wallpadcall.MainActivity.MAINEVENT;
import kr.co.icontrols.wallpadcall.MainActivity.MainEventListener;
import kr.co.icontrols.wallpadcall.R;
import kr.co.icontrols.wallpadcall.declare.Common;
import kr.co.icontrols.wallpadcall.declare.DataClasses.AutoPictureInfo;
import kr.co.icontrols.wallpadcall.declare.DataClasses.MultiCallInfo;
import kr.co.icontrols.wallpadcall.declare.DataClasses.RemoteIDInfo;
import kr.co.icontrols.wallpadcall.declare.DataClasses.SmartRFCamLEDMode;
import kr.co.icontrols.wallpadcall.declare.DataClasses.SmartRFCamStatusMode;
import kr.co.icontrols.wallpadcall.declare.Declare;
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.CALLACTION;
import kr.co.icontrols.wallpadcall.declare.Global.CALLDIRECTION;
import kr.co.icontrols.wallpadcall.declare.Global.CALLRESULT;
import kr.co.icontrols.wallpadcall.declare.Global.ConfigValues;
import kr.co.icontrols.wallpadcall.declare.Global.DOORLOCKTYPE;
import kr.co.icontrols.wallpadcall.declare.Global.FRONTCAMERATYPE;
import kr.co.icontrols.wallpadcall.declare.ID;
import kr.co.icontrols.wallpadcall.imap.Request_check_sip_activation;
import kr.co.icontrols.wallpadcall.imap.Request_lobby_capture;
import kr.co.icontrols.wallpadcall.imap.Request_lobby_open;
import kr.co.icontrols.wallpadcall.imap.Request_start_talking;
import kr.co.icontrols.wallpadcall.imap.Request_stop_talking;
import kr.co.icontrols.wallpadsupport.Version;
import kr.co.icontrols.wallpadsupport.WpadImageView;
import kr.co.icontrols.wallpadsupport.WpadImageView.TOUCH_KIND;
import kr.co.icontrols.wallpadsupport.WpadScale;
import kr.co.icontrols.wallpadsupport.WpadScreen;
import kr.co.icontrols.wallpadsupport.WpadSound.SND;
import kr.co.icontrols.wallpadsupport.WpadTextView;

import static kr.co.icontrols.callengine.remotecall.RemoteCallMSG.REMOTECALL_CMD.CMD_MULTICALL;

public class TalkFront extends WpadScreen implements CallEventListener, MainEventListener {

    private final static String TAG = "TalkFront";

    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);
    }

    WpadImageView SCREEN_BG;
    WpadImageView IMG_LOBBY_BACKGROUND;
    WpadImageView IMG_VIDEO_MODULE;
    WpadImageView IMG_VOLUME;
    WpadImageView BTN_TALK;
    WpadImageView BTN_END;
    WpadImageView BTN_SAVE_PICTURE;
    WpadImageView BTN_DOOROPEN;
    WpadImageView BTN_RELIEF_FILTER_01, BTN_RELIEF_FILTER_02; //, BTN_RELIEF_FILTER_03, BTN_RELIEF_FILTER_04;

    SeekBar SEEKBAR_VOLUME;
    WpadTextView TXT_VOLUME_LEVEL;

    int nCurrentVolume = 0;

    Context mContext;

    public TalkFront(Context context, RelativeLayout layout) {
        super(context, layout);
        try {
            mContext = context;
            Initialize();

            SCREEN_BG = new WpadImageView(context, TOUCH_KIND.NONE, 1280, 690, R.drawable.bg_body, R.drawable.bg_body, ID.SCREEN.TALKFRONT.ELEMENT.IMAGE.BG);
            ViewRegistration(layout, SCREEN_BG, 0, 0);

            if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                IMG_LOBBY_BACKGROUND = new WpadImageView(context, TOUCH_KIND.NONE, 729, 544, R.drawable.bg_lobby, 0, ID.SCREEN.TALKFRONT.ELEMENT.IMAGE.BACKGROUND);
                ViewRegistration(layout, IMG_LOBBY_BACKGROUND, Common.ImgPosition.GetX(101), Common.ImgPosition.GetY(110));

                IMG_VIDEO_MODULE = new WpadImageView(context, TOUCH_KIND.NONE, 727, 540, R.drawable.image_lobby, 0, ID.SCREEN.TALKFRONT.ELEMENT.IMAGE.VIDEO_MODULE);
                ViewRegistration(layout, IMG_VIDEO_MODULE, Common.ImgPosition.GetX(103), Common.ImgPosition.GetY(112));
            }
            else {
                IMG_LOBBY_BACKGROUND = new WpadImageView(context, TOUCH_KIND.NONE, 722, 544, R.drawable.bg_lobby, 0, ID.SCREEN.TALKFRONT.ELEMENT.IMAGE.BACKGROUND);
                ViewRegistration(layout, IMG_LOBBY_BACKGROUND, Common.ImgPosition.GetX(93), Common.ImgPosition.GetY(110));

                IMG_VIDEO_MODULE = new WpadImageView(context, TOUCH_KIND.NONE, 720, 540, R.drawable.image_lobby, 0, ID.SCREEN.TALKFRONT.ELEMENT.IMAGE.VIDEO_MODULE);
                ViewRegistration(layout, IMG_VIDEO_MODULE, Common.ImgPosition.GetX(95), Common.ImgPosition.GetY(112));
            }

            IMG_VOLUME = new WpadImageView(context, TOUCH_KIND.NONE, 40, 40, R.drawable.bar_icon_sound, 0, ID.SCREEN.TALKFRONT.ELEMENT.IMAGE.VOLUME);
            ViewRegistration(layout, IMG_VOLUME, Common.ImgPosition.GetX(454), Common.ImgPosition.GetY(707));

            TXT_VOLUME_LEVEL = new WpadTextView(context, false, 40, 40, Gravity.CENTER, Color.WHITE, Common.fontsize._30, false, ID.SCREEN.TALKFRONT.ELEMENT.TEXT.VOLUME_LEVEL);
            ViewRegistration(layout, TXT_VOLUME_LEVEL, Common.ImgPosition.GetX(785), Common.ImgPosition.GetY(705));

            if (WpadScale.getWidthPixels() == WpadScale.DEFAULT_WIDTH_PIXELS) {
                LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                LinearLayout volumeLayout = (LinearLayout) inflater.inflate(R.layout.volume_seekbar_1280, null);
                LayoutParams volumeParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
                int volMarginLeft = WpadScale.getWidth(Common.ImgPosition.GetX(507));
                int volMarginTop = WpadScale.getHeight(Common.ImgPosition.GetY(707));
                volumeParams.setMargins(volMarginLeft, volMarginTop, 0, 0);
                volumeLayout.setLayoutParams(volumeParams);
                SEEKBAR_VOLUME = (SeekBar) volumeLayout.findViewById(R.id.volumeSeekBar);
                SEEKBAR_VOLUME.setMax(100);
                SEEKBAR_VOLUME.setOnSeekBarChangeListener(mOnVolumeChangeListener);
                layout.addView(volumeLayout);
            }
            else {
                LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                LinearLayout volumeLayout = (LinearLayout) inflater.inflate(R.layout.volume_seekbar, null);
                LayoutParams volumeParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
                int volMarginLeft = WpadScale.getWidth(Common.ImgPosition.GetX(502));
                int volMarginTop = WpadScale.getHeight(Common.ImgPosition.GetY(703));
                volumeParams.setMargins(volMarginLeft, volMarginTop, 0, 0);
                volumeLayout.setLayoutParams(volumeParams);
                SEEKBAR_VOLUME = (SeekBar) volumeLayout.findViewById(R.id.volumeSeekBar);
                SEEKBAR_VOLUME.setMax(100);
                SEEKBAR_VOLUME.setOnSeekBarChangeListener(mOnVolumeChangeListener);
                layout.addView(volumeLayout);
            }

            // 안심통화
            if (ConfigValues.bReliefCall) {
                BTN_TALK = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 210, R.drawable.btn_call_normal, R.drawable.btn_call_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.TALK);
                ViewRegistration(layout, BTN_TALK, Common.ImgPosition.GetX(815), Common.ImgPosition.GetY(110));
                BTN_TALK.setButtonEventOffEnable(R.drawable.btn_call_disabled);

                BTN_END = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 210, R.drawable.btn_endl_normal, R.drawable.btn_endl_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.END);
                ViewRegistration(layout, BTN_END, Common.ImgPosition.GetX(815), Common.ImgPosition.GetY(320));
                BTN_END.setButtonEventOffEnable(R.drawable.btn_endl_disabled);

                BTN_SAVE_PICTURE = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 210, R.drawable.btn_photo_normal, R.drawable.btn_photo_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.SAVE_PICTURE);
                ViewRegistration(layout, BTN_SAVE_PICTURE, Common.ImgPosition.GetX(1001), Common.ImgPosition.GetY(110));

                BTN_DOOROPEN = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 210, R.drawable.btn_open_normal, R.drawable.btn_open_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.DOOROPEN);
                ViewRegistration(layout, BTN_DOOROPEN, Common.ImgPosition.GetX(1001), Common.ImgPosition.GetY(320));
                BTN_DOOROPEN.setButtonEventOffEnable(R.drawable.btn_open_disabled);

                /**
                 * JEFF, 2020.01.02
                 * 안심통화는 1, 2 단계만 지원한다.
                 */
                int[] filterImg_01 = {R.drawable.btn_big_filter_1_normal, R.drawable.btn_big_filter_1_pressed};
                int[] filterSelectedImg_01 = {R.drawable.btn_big_filter_1_selected, R.drawable.btn_big_filter_1_selected};
                int[] filterImg_02 = {R.drawable.btn_big_filter_2_normal, R.drawable.btn_big_filter_2_pressed};
                int[] filterSelectedImg_02 = {R.drawable.btn_big_filter_2_selected, R.drawable.btn_big_filter_2_selected};
//                int[] filterImg_03 = {R.drawable.btn_filter_3_normal, R.drawable.btn_filter_3_pressed};
//                int[] filterSelectedImg_03 = {R.drawable.btn_filter_3_selected, R.drawable.btn_filter_3_selected};
//                int[] filterImg_04 = {R.drawable.btn_filter_4_normal, R.drawable.btn_filter_4_pressed};
//                int[] filterSelectedImg_04 = {R.drawable.btn_filter_4_selected, R.drawable.btn_filter_4_selected};

                BTN_RELIEF_FILTER_01 = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 124, filterImg_01, filterSelectedImg_01, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_01);
                ViewRegistration(layout, BTN_RELIEF_FILTER_01, Common.ImgPosition.GetX(815), Common.ImgPosition.GetY(530));

                BTN_RELIEF_FILTER_02 = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 124, filterImg_02, filterSelectedImg_02, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_02);
                ViewRegistration(layout, BTN_RELIEF_FILTER_02, Common.ImgPosition.GetX(1001), Common.ImgPosition.GetY(530));

//                BTN_RELIEF_FILTER_03 = new WpadImageView(context, TOUCH_KIND.BUTTON, 93, 124, filterImg_03, filterSelectedImg_03, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_03);
//                ViewRegistration(layout, BTN_RELIEF_FILTER_03, Common.ImgPosition.GetX(1001), Common.ImgPosition.GetY(530));
//
//                BTN_RELIEF_FILTER_04 = new WpadImageView(context, TOUCH_KIND.BUTTON, 94, 124, filterImg_04, filterSelectedImg_04, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_04);
//                ViewRegistration(layout, BTN_RELIEF_FILTER_04, Common.ImgPosition.GetX(1094), Common.ImgPosition.GetY(530));
            }
            else {
                BTN_TALK = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 272, R.drawable.btn_lobby_call_normal, R.drawable.btn_lobby_call_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.TALK);
                ViewRegistration(layout, BTN_TALK, Common.ImgPosition.GetX(815), Common.ImgPosition.GetY(110));
                BTN_TALK.setButtonEventOffEnable(R.drawable.btn_lobby_call_disabled);

                BTN_END = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 272, R.drawable.btn_lobby_end_normal, R.drawable.btn_lobby_end_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.END);
                ViewRegistration(layout, BTN_END, Common.ImgPosition.GetX(815), Common.ImgPosition.GetY(382));
                BTN_END.setButtonEventOffEnable(R.drawable.btn_lobby_end_disabled);

                BTN_SAVE_PICTURE = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 272, R.drawable.btn_lobby_photo_normal, R.drawable.btn_lobby_photo_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.SAVE_PICTURE);
                ViewRegistration(layout, BTN_SAVE_PICTURE, Common.ImgPosition.GetX(1001), Common.ImgPosition.GetY(110));

                BTN_DOOROPEN = new WpadImageView(context, TOUCH_KIND.BUTTON, 186, 272, R.drawable.btn_lobby_open_normal, R.drawable.btn_lobby_open_pressed, ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.DOOROPEN);
                ViewRegistration(layout, BTN_DOOROPEN, Common.ImgPosition.GetX(1001), Common.ImgPosition.GetY(382));
                BTN_DOOROPEN.setButtonEventOffEnable(R.drawable.btn_lobby_open_disabled);

                BTN_RELIEF_FILTER_01 = null;
                BTN_RELIEF_FILTER_02 = null;
//                BTN_RELIEF_FILTER_03 = null;
//                BTN_RELIEF_FILTER_04 = null;
            }

            sendReliefFilterSelectBR(nSelectedFilter);
            displayScreenValues();
            sendHandlerMsg(TalkFront.HANDLERMSG.PROC_ADDCALL, 0, 0, null);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] ScreenTalkFront(Context context, RelativeLayout layout)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    protected void Initialize() {
        try {
            LOG_INFO("[Initialize]");
            if (MainActivity.mCallController.mCallInfo.getFRONT() != CALLSTATUS.IDLE) ((MainActivity) mContext).setMenuBTNEnable(false);
            else ((MainActivity) mContext).setMenuBTNEnable(true);

            MainActivity.mCallController.setCallEventListener(this);
            ((MainActivity) mContext).setMainEventListener(this);

            int mMarginLeft = ((MainActivity) mContext).TopBackBtn.getVisibility() == View.VISIBLE ? 893 : 1019;
            ((MainActivity) mContext).setManualBtnVisible(((MainActivity) mContext).getManualUse(), mMarginLeft);
            ((MainActivity) mContext).setTopHideBtnVisible(true);

            super.setFinishTimerCreate(Common.FINISH_TIME_START_SCREEN);

            getVolume();

            if (MainActivity.bFFMPEGEnable) ((MainActivity)mContext).showRemoteVideo(false, false);

            MainActivity.mCallController.mVideoJNI.setDecoderInfo_V40(76, 85, 576, 405); // 영상 좌표 재설정 (세대 통화 멀티콜 이후 상황 대비)

            bEnableVisitorPic = true;
            nSelectedFilter = 0;
//            bEnableVisitorPic = false;   // 부재중 방문객 사진 저장은 임시로 삭제한다.

            MainActivity.mIOInterface.ctrlPopupGUI(false);
            MainActivity.mCallController.mSIPInterface.videoSet(true, false, true);

            sendHandlerMsgDelayed(TalkFront.HANDLERMSG.ENABLE_SAVE_VISITORPICTURE, 0, 0, null, 3000);
            sendHandlerMsgDelayed(TalkFront.HANDLERMSG.SHOW_FRONTVIDEO, 0, 0, null, 1000);
            sendHandlerMsgDelayed(TalkFront.HANDLERMSG.SHOW_FRONTVIDEO, 0, 0, null, 2000);

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

    private void initCallVariables() {
        try {
            nSelectedFilter = 0;

            RemoteIDInfo.InitVariables();
            MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] initCallVariables()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    protected void onClose() {
        super.onClose();
        try {
            LOG_INFO("[onClose]");
            //MainActivity.mIOInterface.ctrlPopupGUI(false);
            if (MainActivity.mIOInterface != null) MainActivity.mIOInterface.ctrlWallPadLED_Call(false);
            nSelectedFilter = 0;
            sendReliefFilterSelectBR(nSelectedFilter);
            ctrlAlphaBlending(false);

            if (TalkFrontHandler != null) {
                TalkFrontHandler.removeMessages(TalkFront.HANDLERMSG.ENABLE_SAVE_VISITORPICTURE);
                TalkFrontHandler.removeMessages(TalkFront.HANDLERMSG.SAVE_VISITORPICTURE);
                TalkFrontHandler.removeMessages(TalkFront.HANDLERMSG.TAKE_VISITORPICTURE);
            }

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

            bEnableVisitorPic = false;
            bReliefCallInit = false;
            MainActivity.mCallController.selectVideoSourceToSubPhone(CALLTYPE.NONE, true);
            initCallVariables();
            if (ConfigValues.bReliefCall) selectReliefCallFilter(nSelectedFilter);
            MainActivity.mCallController.releaseCallEventListener();
            ((MainActivity) mContext).releaseMainEventListener();
            MainActivity.mCallController.mSIPInterface.videoSet(false, false, false);
            //Global.add1stCallHistoryInfoFinal();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onClose()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    protected void onBrReceive(Intent intent) {
        super.onBrReceive(intent);
        try {
            LOG_INFO("[onBrReceive] intent : " + intent);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onBrReceive()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    protected void onTouchEvent(View v, MotionEvent event) {
        try {
            int nEvent = event.getAction();
            int nID = v.getId();
            if (nEvent == MotionEvent.ACTION_UP) {
                LOG("[onTouchEvent] nID [" + nID + "], nEvent [" + nEvent + "]");
                if (ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.TALK <= nID && nID <= ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_02) {
                    // 통화중에 버튼 터치음을 발생시키면, 통화 상대방에게 터치음이 전달되므로 통화중에는 터치음을 출력하지 않는다.(JEFF, 2019.12.24)
                    if (MainActivity.mCallController.mCallInfo.getFRONT() != CALLSTATUS.TALKING) MainActivity.mSound.Play(SND.effect.TOUCH_LATCHED);

                    if (nID == ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.TALK) {
                        doTalk(CALLOWNER.WALLPAD);
                    } else if (nID == ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.END) {
                        bEnableVisitorPic = false;
                        ctrlAlphaBlending(false);
                        doEnd();
                        send_stop_talking_request(RemoteIDInfo.strIP);
                    } else if (nID == ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.SAVE_PICTURE) {
                        //String strVisitorPicResult = MainActivity.mCallController.saveVisitorPicture(CALLTYPE.FRONT, MainActivity.mCallController.mCallInfo.getFRONT(), RemoteIDInfo.strSIPID, true, false, false);
                        //LOG_INFO("[onTouchEvent] strVisitorPicResult [" + strVisitorPicResult + "]");
                        send_lobby_capture_request(RemoteIDInfo.strIP);
                        enableSavePicBTN(false);
                        sendHandlerMsgDelayed(TalkFront.HANDLERMSG.ENABLE_SAVE_VISITORPICTURE, 0, 0, null, 3000);
                    } else if (nID == ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.DOOROPEN) {
                        if (!bSentiMAP) {
                            sendHandlerMsgDelayed(TalkFront.HANDLERMSG.HIDE_LOBBYVIDEO, 0, 0, null, 3000); // 문열림으로 통화 종료시 로비 영상 노이즈가 생기므로 영상을 GUI 아래로 내림
                            doDoorOpen();
                            //send_stop_talking_request(RemoteIDInfo.strIP);
                        }
                    } else if (ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_01 <= nID && nID <= ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_04) {
                        LOG_INFO("[onTouchEvent] [RELIEF_FILTER] BUTTON");
                        selectReliefCallFilter(nID);
                        doTalk(CALLOWNER.WALLPAD); // 통화시작 전에 필터버튼 클릭하면 변조되어 통화 시작
                    }
                }
                else {
                    Log.w(TAG, "[onTouchEvent] The touch event is not supported!! nID -> nID");
                }
            }
            else {
                Log.w(TAG, "[onTouchEvent] The touch event is not supported!! nEvent -> nEvent");
            }

        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onTouchEvent(View v, MotionEvent event)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    public void onMainTouchEvent(MAINEVENT eEvent) {
        try {
            LOG_INFO("[onMainTouchEvent] eEvent [" + eEvent + "] RemoteIDInfo.strIP [" + RemoteIDInfo.strIP + "]");
            if (eEvent == MAINEVENT.BTN_HOME) {
                send_stop_talking_request(RemoteIDInfo.strIP);
                if (MainActivity.mCallController.mCallInfo.getFRONT() != CALLSTATUS.TALKING) Sound().Play(SND.effect.TOUCH_LATCHED);
                finishWallpadCallApp();
            } else if (eEvent == MAINEVENT.BTN_HOME_MOBILE) {
                finishWallpadCallApp();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onMainTouchEvent(MAINEVENT eEvent)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    protected void onKeyDown(int keyCode, KeyEvent event) {
        LOG_INFO("[onKeyDown] keyCode [" + keyCode + "], event.getAction() [" + event.getAction() + "]");
        if (keyCode == Declare.BTN.TALK || keyCode == Declare.BTN.TALK_V40) {
            doTalkByBTN(CALLOWNER.WALLPAD);
        } else if (keyCode == Declare.BTN.DOOR_OPEN || keyCode == Declare.BTN.DOOR_OPEN_V40) {
            if (!bSentiMAP) {
                sendHandlerMsgDelayed(TalkFront.HANDLERMSG.HIDE_LOBBYVIDEO, 0, 0, null, 3000); // 문열림으로 통화 종료시 로비 영상 노이즈가 생기므로 영상을 GUI 아래로 내림
                doDoorOpen();
            }
        } else if (keyCode == Declare.BTN.PLAY_DECODED_VIDEO || keyCode == Declare.BTN.PLAY_DECODED_VIDEO_V40) {
            ctrlAlphaBlending(true);
        }

        super.onKeyDown(keyCode, event);
    }

    @Override
    public void onCallEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, String strRemoteIP, String strRemoteSIPID, String strMessage) {
        try {
            LOG_INFO("[onCallEvent] eCallOwner [" + eCallOwner + "], eCallStatus [" + eCallStatus + "], eCallType [" + eCallType + "], strRemoteIP [" + strRemoteIP + "], strRemoteSIPID [" + strRemoteSIPID + "], strMessage [" + strMessage + "]");
            if (eCallType == CALLTYPE.NONE) return;

            if (eCallType == CALLTYPE.FRONT) {
                MainActivity.mCallController.setRemoteInfo(strRemoteSIPID, strRemoteIP);
                sendHandlerMsg(TalkFront.HANDLERMSG.SET_BTN_STATUS, 0, 0, null);
                if (eCallStatus == CALLSTATUS.CALLED) {
                    MainActivity.mCallController.selectVideoSourceToSubPhone(CALLTYPE.FRONT, false);
                    Global.playMelodyRepeat(eCallType);
                    super.setFinishTimerDestroy();
                    MainActivity.mCallController.set1stCallTimer(eCallType, MainActivity.mCallController.mCTT.CALLED);
                    ((MainActivity) mContext).displayRemoteID(RemoteIDInfo.strName);
                    //Global.make1stCallHistoryInfo(CALLTYPE.FRONT.toString(), "NONE", CALLDIRECTION.IN, CALLACTION.MISS, CALLRESULT.IN_MISS);

                    // 부재중인 경우를 대비하여 임시저장 (외출방범 설정중에도 통화 부재중과 동일한 방식으로 처리한다. jeff, 2021.07.26)
                    //sendHandlerMsgDelayed(TalkFront.HANDLERMSG.TAKE_VISITORPICTURE, 0, 0, strRemoteSIPID, 5000);   // 5초
                    if (ConfigValues.bUnoccupiedMode) {
                        sendHandlerMsgDelayed(TalkFront.HANDLERMSG.CALL_FORWARD, 0, 0, null, 15000);   // 15초
                    }
                    else {
                        MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
                    }


//                    if (ConfigValues.bUnoccupiedMode) {
//                        sendHandlerMsgDelayed(HANDLERMSG.SAVE_VISITORPICTURE, 0, 0, null, 5000);   // 5초
//                        sendHandlerMsgDelayed(HANDLERMSG.SAVE_VISITORPICTURE, 0, 0, null, 10000);   // 10초
//                        sendHandlerMsgDelayed(HANDLERMSG.CALL_FORWARD, 0, 0, null, 15000);   // 15초
//                    } else {
//                        // 부재중인 경우를 대비하여 임시저장한다.
//                        sendHandlerMsgDelayed(HANDLERMSG.TAKE_VISITORPICTURE, 0, 0, strRemoteSIPID, 5000);   // 5초
//                        MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
//                    }

                }
                else if (eCallStatus == CALLSTATUS.CALLING) {
                    //MainActivity.mCallController.selectVideoSourceToSubPhone(CALLTYPE.FRONT, false);
                    //Global.playMelodyRepeat(eCallType);
                    //MainActivity.mIOInterface.ctrlPopupGUI(false);
                    super.setFinishTimerDestroy();
                    MainActivity.mCallController.set1stCallTimer(eCallType, MainActivity.mCallController.mCTT.CALLED);
                    ((MainActivity) mContext).displayRemoteID(RemoteIDInfo.strName);
                    //Global.make1stCallHistoryInfo(CALLTYPE.FRONT.toString(), "NONE", CALLDIRECTION.OUT, CALLACTION.MISS, CALLRESULT.OUT_MISS);
                    //Global.make1stCallHistoryInfo(strRemoteIP, strRemoteSIPID, CALLDIRECTION.IN, CALLACTION.MISS, CALLRESULT.IN_MISS);

                    // 부재중인 경우를 대비하여 임시저장 (외출방범 설정중에도 통화 부재중과 동일한 방식으로 처리한다. jeff, 2021.07.26)
                    //sendHandlerMsgDelayed(TalkFront.HANDLERMSG.TAKE_VISITORPICTURE, 0, 0, strRemoteSIPID, 5000);   // 5초

                }
                else if (eCallStatus == CALLSTATUS.TALKING) {
                    Global.stopMelodyRepeat();
                    if (eCallOwner == CALLOWNER.MOBILE) {
                        // 모바일에서 로비 호출 수신!! (방문객 원격통화)
                        RemoteCallManager.bMobileTalk = true;
                        ((MainActivity) mContext).showRemoteCallNoticeText(true); // 방문객원격통화 팝업 삭제 -> 상단 문구로 대체
//                        ((MainActivity) mContext).StartPopup(ID.POPUP.POPUP_NOTICE_REMOTECALL);
                        MainActivity.mCallController.acceptMoIPCall(true);
                        MainActivity.mCallController.mCallInfo.setCallOwner(eCallOwner);
                    }
                    else {
                        if (ConfigValues.bRemoteCall) RemoteCallManager.bMobileTalk = false;
                        if (eCallOwner != CALLOWNER.WALLPAD) {
                            ((MainActivity) mContext).StartPopup(ID.POPUP.POPUP_NOTICE_SUBPHONETALK);
                            MainActivity.mCallController.setTalkPath(CALLPATH.SUBPHONE_MOIP);
                            if (eCallOwner == CALLOWNER.SUB_WALLPAD) MainActivity.mCallController.setSubWallPadAudioPath();
                        }
                        else {
                            ((MainActivity) mContext).sendHandlerMsg(MainActivity.HANDLERMSG.SET_TEMPSYSTEM_VOLUME, 0, 0);// 통화 중 임의 볼륨값 설정 seulki
                            MainActivity.mCallController.selectVideoSourceToSubPhone(CALLTYPE.NONE, false);
                            if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                                //MainActivity.mCallController.setTalkPath(CALLPATH.FRONT);
                                if ((Version.getModelType() == Version.MODEL_TYPE.IHN_D101_I_LX2) || (Version.getModelType() == Version.MODEL_TYPE.IHN_D101_I))
                                {
                                    MainActivity.mCallController.setTalkPath(CALLPATH.FRONT);
                                }
                                else if ((Version.getModelType() == Version.MODEL_TYPE.IHN_1010_I_LX2) || (Version.getModelType() == Version.MODEL_TYPE.IHN_1010_I))
                                {
                                    MainActivity.mCallController.setTalkPath(CALLPATH.MOIP_IHND101_LOBBY);
                                }
                            }
                            else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                                MainActivity.mCallController.setTalkPath(CALLPATH.MOIP_IHN1010_LOBBY_GUARD);
                            }
                            else {
                                MainActivity.mCallController.setTalkPath(CALLPATH.MOIP);
                            }
                        }
                        mPathCheckHandler.sendEmptyMessage(0);
                    }
                    MainActivity.mCallController.set1stCallTimer(eCallType, MainActivity.mCallController.mCTT.RESIDENCEnLOBBY);
                    Global.change1stCallLogAction(CALLACTION.TALK);
                }
                else if (eCallStatus == CALLSTATUS.END) {
                    bEnableVisitorPic = false;
                    bReliefCallInit = false;
                    //Global.stopMelodyRepeat();
                    MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_ALL);
                    ((MainActivity) mContext).finishManual(ID.MANUAL.MANUAL_ALL);
                    ((MainActivity) mContext).displayRemoteID(null);
                    if (eCallOwner == CALLOWNER.MOBILE) {
                        MainActivity.mCallController.quitMoIPCall();
//                        ((MainActivity) mContext).showRemoteCallNoticeText(false);
                    }
                    MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);
                    MainActivity.mCallController.stop1stCallTimer();
                    MainActivity.mCallController.stop2ndCallTimer();
                    MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
                    nSelectedFilter = 0;
                    sendReliefFilterSelectBR(nSelectedFilter);
                    MainActivity.mCallController.MultiCallScenarioManager();
                } else if (eCallStatus == CALLSTATUS.REJECT) {
                    bEnableVisitorPic = false;
                    bReliefCallInit = false;
                    Global.stopMelodyRepeat();
                    MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
                    ((MainActivity) mContext).displayRemoteID(null);
                    MainActivity.mSound.PlayMent(SND.setting.RETRY_ACTION);
                    MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);
                    MainActivity.mCallController.stop1stCallTimer();
                    MainActivity.mCallController.stop2ndCallTimer();
                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_NOTICE_SUBPHONETALK);
                    Global.change1stCallLogAction(CALLACTION.REJECT);
                    //Global.add1stCallHistoryInfoFinal();
                    nSelectedFilter = 0;
                    sendReliefFilterSelectBR(nSelectedFilter);
                    MainActivity.mCallController.MultiCallScenarioManager();
                } else if (eCallStatus == CALLSTATUS.BUSY) {
                    bEnableVisitorPic = false;
                    bReliefCallInit = false;
                    Global.stopMelodyRepeat();
                    MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
                    ((MainActivity) mContext).displayRemoteID(null);
                    MainActivity.mSound.PlayMent(SND.call.BUSY_TRY_LATER);
                    MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);
                    MainActivity.mCallController.stop1stCallTimer();
                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_NOTICE_SUBPHONETALK);
                    Global.change1stCallLogAction(CALLACTION.BUSY);
                    nSelectedFilter = 0;
                    sendReliefFilterSelectBR(nSelectedFilter);
                    MainActivity.mCallController.MultiCallScenarioManager();
                } else if (eCallStatus == CALLSTATUS.CANCEL) {
                    bEnableVisitorPic = false;
                    bReliefCallInit = false;
                    Global.stopMelodyRepeat();
                    MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
                    ((MainActivity) mContext).displayRemoteID(null);
                    MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);
                    MainActivity.mCallController.stop1stCallTimer();
                    MainActivity.mCallController.stop2ndCallTimer();
                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_NOTICE_SUBPHONETALK);
                    Global.change1stCallLogAction(CALLACTION.CANCEL);
                    nSelectedFilter = 0;
                    sendReliefFilterSelectBR(nSelectedFilter);
                    MainActivity.mCallController.MultiCallScenarioManager();
                } else if (eCallStatus == CALLSTATUS.TIMEOUT_1STCALL) {
                    MainActivity.mIOInterface.ctrlPopupGUI(true);
                    bEnableVisitorPic = false;
                    bReliefCallInit = false;
                    Global.stopMelodyRepeat();
                    MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
                    if (eCallOwner != CALLOWNER.WALLPAD) {
                        ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_NOTICE_SUBPHONETALK);
                    }
                    MainActivity.mCallController.quitMoIPCall();
                    MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);
                    MainActivity.mCallController.stop1stCallTimer();
                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_ALL);
                    ((MainActivity) mContext).finishManual(ID.MANUAL.MANUAL_ALL);
                    initCallVariables();
                    ((MainActivity) mContext).displayRemoteID(null);
                    Global.change1stCallLogAction(CALLACTION.CANCEL);
                    //Global.add1stCallHistoryInfoFinal();
                    nSelectedFilter = 0;
                    sendReliefFilterSelectBR(nSelectedFilter);
                    MainActivity.mCallController.MultiCallScenarioManager();
                } else if (eCallStatus == CALLSTATUS.DOOR_OPEN) {
                    sendHandlerMsg(TalkFront.HANDLERMSG.DOOR_OPEN, 0, 0, null); // 방문객 원격통화 모바일에서 문열림
                } else {
                    Log.w(TAG, "[onCallEvent] Incorrect eCallStatus!!! eCallStatus = " + eCallStatus);
                }
            } else {
                onMultiCallEvent(eCallOwner, eCallStatus, eCallType, strRemoteIP, strRemoteSIPID, strMessage);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onCallEvent(CALLSTATUS eCallStatus, CALLTYPE eCallType, String strRemoteIP, String strRemoteSIPID, String strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    public void onMultiCallEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, String strRemoteIP, String strRemoteSIPID, String strMessage) {
        try {
            LOG_INFO("[onMultiCallEvent] eCallOwner [" + eCallOwner + "], eCallStatus [" + eCallStatus + "], eCallType [" + eCallType + "], strRemoteIP [" + strRemoteIP + "], strRemoteSIPID [" + strRemoteSIPID + "], strMessage [" + strMessage + "]");
            MainActivity.mCallController.mCallInfo.printCallStatus();
            MainActivity.mCallController.mCallInfo.printMultiCallStatus();

            if (eCallStatus == CALLSTATUS.CALLED) {
                if (eCallType == CALLTYPE.FRONT) {
                    playFrontCamBell(true);
                    if (MainActivity.mCallController.mCallInfo.getMultiCallStatus() == CALLSTATUS.IDLE) {
                        // 멀티콜 없음
                        MultiCallInfo MCInfo = new MultiCallInfo();
                        MCInfo.setMulticallInfo(CALLTYPE.FRONT, eCallType, eCallStatus, CALLOWNER.NONE, strRemoteSIPID, "", "", "현관", strRemoteIP);
                        MainActivity.mCallController.mCallInfo.setMultiCallInfo(MCInfo);
                        //Global.make2ndCallHistoryInfo(eCallType.toString(), "NONE", CALLDIRECTION.IN, CALLACTION.MISS, CALLRESULT.IN_MISS);

                        CALLSTATUS eLobbyCallStatus = MainActivity.mCallController.mCallInfo.getFRONT();

                        /**
                         * JEFF, 2020.01.02
                         * 모든통화에서 멀티콜 발생시 알림 팝업만 띄우고 busy처리 하도록 시나리오 수정
                         */
                        if (eLobbyCallStatus == CALLSTATUS.CALLING || eLobbyCallStatus == CALLSTATUS.CALLED || eLobbyCallStatus == CALLSTATUS.TALKING) {
                            if (eCallOwner == CALLOWNER.WALLPAD || eCallOwner == CALLOWNER.NONE) {
                                ((MainActivity) (getContext())).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL_NOTICE);
                            }
                            else {
                                if (MainActivity.mPSTNController != null) MainActivity.mPSTNController.stopPSTNRingCntThread(); // PSTN 멀티콜 거절시 ring cnt 초기화
                                MainActivity.mCallController.stop2ndCallTimer();
                                MainActivity.mCallController.mCallInfo.setCallStatus(MainActivity.mCallController.mCallInfo.getMultiCallType(), CALLSTATUS.IDLE);
                                doMultiCallReject();
                                sendHandlerMsgDelayed(TalkFront.HANDLERMSG.REFRESH_BTNLED_STATUS, 0, 0, null, 1000);
                            }
                        }
                        else {
                            LOG_WARN("[onMultiCallEvent] Invalid eLobbyCallStatus [" + eLobbyCallStatus + "]");
                        }



//                        if (eLobbyCallStatus == CALLSTATUS.CALLING || eLobbyCallStatus == CALLSTATUS.CALLED) {
//                            ((MainActivity) (getContext())).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL_NOTICE);
//                        } else if (eLobbyCallStatus == CALLSTATUS.TALKING) {
//                            if (eCallOwner == CALLOWNER.MOBILE) {
//                                // 방문객원격통화 멀티콜
//                                MainActivity.mRemoteCallController.sendCmdToRemoteCall(CMD_MULTICALL, strRemoteSIPID, strRemoteIP, eCallType);
//                                doMultiCallReject();
//                            } else {
//                                MainActivity.mCallController.set2ndCallTimer(eCallType, MainActivity.mCallController.mCTT.CALLED);
//                                ((MainActivity) (getContext())).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL);
//                            }
//                        }
//                        else {
//                            LOG_WARN("[onMultiCallEvent] Invalid eLobbyCallStatus [" + eLobbyCallStatus + "]");
//                        }
                    } else {
                        // 멀티콜 있음
                        sendHandlerMsgDelayed(TalkFront.HANDLERMSG.OFF_FRONT, 0, 0, null, 2000);
                        MainActivity.mCallController.mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                        return;
                    }
                } else if (eCallType == CALLTYPE.FRONT || eCallType == CALLTYPE.LOBBY || eCallType == CALLTYPE.GUARD || eCallType == CALLTYPE.RESIDENCE) {
                    if (MainActivity.mCallController.mCallInfo.getMultiCallStatus() == CALLSTATUS.IDLE) {
                        // 멀티콜 없음
                        MultiCallInfo MCInfo = new MultiCallInfo();
                        MCInfo.setMulticallInfo(CALLTYPE.FRONT, eCallType, eCallStatus, CALLOWNER.NONE, strRemoteSIPID, Integer.toString(MainActivity.mCallController.getRemoteDong(strRemoteSIPID)),
                                Integer.toString(MainActivity.mCallController.getRemoteID(strRemoteSIPID)), MainActivity.mCallController.getRemoteName(strRemoteSIPID, strRemoteIP), strRemoteIP);
                        MainActivity.mCallController.mCallInfo.setMultiCallInfo(MCInfo);
                        //Global.make2ndCallHistoryInfo(strRemoteIP, strRemoteSIPID, CALLDIRECTION.IN, CALLACTION.MISS, CALLRESULT.IN_MISS);

                        CALLSTATUS eLobbyCallStatus = MainActivity.mCallController.mCallInfo.getFRONT();
                        /**
                         * JEFF, 2020.01.02
                         * 모든통화에서 멀티콜 발생시 알림 팝업만 띄우고 busy처리 하도록 시나리오 수정
                         */
                        if (eLobbyCallStatus == CALLSTATUS.CALLING || eLobbyCallStatus == CALLSTATUS.CALLED || eLobbyCallStatus == CALLSTATUS.TALKING) {
                            if (eCallOwner == CALLOWNER.WALLPAD || eCallOwner == CALLOWNER.NONE) {
                                ((MainActivity) (getContext())).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL_NOTICE);
                            }
                            else {
                                if (MainActivity.mPSTNController != null) MainActivity.mPSTNController.stopPSTNRingCntThread(); // PSTN 멀티콜 거절시 ring cnt 초기화
                                MainActivity.mCallController.stop2ndCallTimer();
                                MainActivity.mCallController.mCallInfo.setCallStatus(MainActivity.mCallController.mCallInfo.getMultiCallType(), CALLSTATUS.IDLE);
                                doMultiCallReject();
                                sendHandlerMsgDelayed(TalkFront.HANDLERMSG.REFRESH_BTNLED_STATUS, 0, 0, null, 1000);
                            }
                        }
                        else {
                            LOG_WARN("[onMultiCallEvent] Invalid eLobbyCallStatus [" + eLobbyCallStatus + "]");
                        }

//                        if (eLobbyCallStatus == CALLSTATUS.CALLING || eLobbyCallStatus == CALLSTATUS.CALLED) {
//                            ((MainActivity) (getContext())).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL_NOTICE);
//                        } else if (eLobbyCallStatus == CALLSTATUS.TALKING) {
//                            if (eCallOwner == CALLOWNER.MOBILE) {
//                                // 방문객원격통화 멀티콜
//                                MainActivity.mRemoteCallController.sendCmdToRemoteCall(CMD_MULTICALL, strRemoteSIPID, strRemoteIP, eCallType);
//                                doMultiCallReject();
//                            } else {
//                                MainActivity.mCallController.set2ndCallTimer(eCallType, MainActivity.mCallController.mCTT.CALLED);
//                                ((MainActivity) (getContext())).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL);
//                            }
//                        } else {
//                            LOG_WARN("[onMultiCallEvent] Invalid eLobbyCallStatus [" + eLobbyCallStatus + "]");
//                        }
                    } else {
                        // 멀티콜 있음
                        MainActivity.mCallController.rejectMoIPMultiCall();
                        MainActivity.mCallController.mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                    }
                } else if (eCallType == CALLTYPE.PSTN) {
                    TalkPSTN.bPSTNCalled = true;
                    if (MainActivity.mCallController.mCallInfo.getMultiCallStatus() == CALLSTATUS.IDLE) {
                        // 멀티콜 없음
                        if (eCallOwner == CALLOWNER.MOBILE) {
                            // 방문객원격통화 멀티콜
                            MainActivity.mRemoteCallController.sendCmdToRemoteCall(CMD_MULTICALL, strRemoteSIPID, strRemoteIP, eCallType);
                            doMultiCallReject();
                        } else {
                            MultiCallInfo MCInfo = new MultiCallInfo();
                            MCInfo.setMulticallInfo(CALLTYPE.FRONT, eCallType, eCallStatus, CALLOWNER.NONE, strRemoteSIPID, "", "", "NONE", strRemoteIP);
                            MainActivity.mCallController.mCallInfo.setMultiCallInfo(MCInfo);
                            //Global.make2ndCallHistoryInfo(eCallType.toString(), "NONE", CALLDIRECTION.IN, CALLACTION.MISS, CALLRESULT.IN_MISS);
                            ((MainActivity) (getContext())).startMultiCallPopup(ID.POPUP.POPUP_MULTICALL);
                        }
                    } else {
                        // 멀티콜 있음
                        // 기존 멀티콜을 거절하고, 국선을 멀티콜로 설정한다.
                        CALLTYPE eMulticallType = MainActivity.mCallController.mCallInfo.getMultiCallType();
                        if (eMulticallType == CALLTYPE.FRONT) playFrontCamBell(false);
                        else if  (eMulticallType == CALLTYPE.FRONT || eMulticallType == CALLTYPE.LOBBY || eMulticallType == CALLTYPE.GUARD || eMulticallType == CALLTYPE.RESIDENCE) MainActivity.mCallController.rejectMoIPMultiCall();
                        else LOG_WARN("[onMultiCallEvent] Invalid eMultiCallType [" + eMulticallType + "]");

                        MainActivity.mCallController.mCallInfo.setCallStatus(eMulticallType, CALLSTATUS.IDLE);
                        MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
                        MainActivity.mCallController.stop2ndCallTimer();
                        //Global.add2ndCallHistoryInfo(CALLRESULT.IN_MISS);
                        LOG_WARN("[onMultiCallEvent] Another multicall is processing. Change multicall to PSTN multicall!!");

                        MultiCallInfo MCInfo = new MultiCallInfo();
                        MCInfo.setMulticallInfo(CALLTYPE.FRONT, eCallType, eCallStatus, CALLOWNER.NONE, strRemoteSIPID, "", "", "NONE", strRemoteIP);
                        MainActivity.mCallController.mCallInfo.setMultiCallInfo(MCInfo);
                        //Global.make2ndCallHistoryInfo(eCallType.toString(), "NONE", CALLDIRECTION.IN, CALLACTION.MISS, CALLRESULT.IN_MISS);

                        MainActivity.mCallController.mPopupEventListener.onMulticallChange(eCallType, eCallStatus, "");
                    }
                } else {
                    LOG_WARN("[onMultiCallEvent] Invalid CallType [" + eCallType + "]");
                }
            } else if (eCallStatus == CALLSTATUS.CALLERID) {
                MainActivity.mCallController.mCallInfo.updateMultiCallName(strRemoteSIPID);
                Global.change2ndCallLogSIPID(CALLTYPE.PSTN.toString() + ":" + strRemoteSIPID);
            } else if (eCallStatus == CALLSTATUS.END) {
                MainActivity.mCallController.mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                if (MainActivity.mCallController.mCallInfo.getMultiCallType() == eCallType) {
                    MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
                    MainActivity.mCallController.stop2ndCallTimer();
                    //Global.add2ndCallHistoryInfo(CALLRESULT.IN_MISS);
                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_MULTICALL);
                } else LOG_WARN("[onMultiCallEvent] Invalid CallType [" + eCallType + "]");
            } else if (eCallStatus == CALLSTATUS.CANCEL) {
                MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
                MainActivity.mCallController.mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                MainActivity.mCallController.stop2ndCallTimer();
                //Global.add2ndCallHistoryInfo(CALLRESULT.IN_REJECT);
                ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_MULTICALL);
            } else if (eCallStatus == CALLSTATUS.TIMEOUT_2NDCALL) {
                // 거동수상자 녹화기능 수정중 (추후 동작상태보고 수정)
//                if (eCallType == CALLTYPE.FRONT_RECORD) {
//                    // [스마트현관카메라] 거동수상자 녹화 팝업 미선택시 녹화 시작
//                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_MULTICALL_RECORD);
//                    MainActivity.mCallController.stop2ndCallTimer();
//                    MainActivity.mCallController.mSIPInterface.videoSet(false, false, false);
//                    doMultiCallAccept();
//                }
//                else {
//                    doMultiCallReject();
//                    Global.add2ndCallHistoryInfo(CALLRESULT.IN_MISS);
//                    MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
//                    MainActivity.mCallController.mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
//                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_MULTICALL);
//                }
                doMultiCallReject();
                //Global.add2ndCallHistoryInfo(CALLRESULT.IN_MISS);
                MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
                MainActivity.mCallController.mCallInfo.setCallStatus(eCallType, CALLSTATUS.IDLE);
                ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_MULTICALL);
            } else {
                LOG_WARN("[onMultiCallEvent] Invalid CallStatus [" + eCallStatus + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onMultiCallEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, String strRemoteIP, String strRemoteSIPID, String strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    public void onSubPhoneEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, String strTargetID, String strMessage) {
        try {
            LOG_INFO("[onSubPhoneEvent] eCallOwner [" + eCallOwner + "], eCallStatus [" + eCallStatus + "], eCallType [" + eCallType + "], strTargetID [" + strTargetID + "], strMessage [" + strMessage + "]");

            if (eCallOwner == CALLOWNER.UNIVERSAL_DEVICE && eCallStatus == CALLSTATUS.DOOR_OPEN) {
                if (doSubPhoneDoorOpen(eCallOwner, CALLTYPE.FRONT))
                    MainActivity.mSubPhoneController.sendACKDoorOpen(eCallOwner, CALLTYPE.FRONT);
            }

            if (eCallType == CALLTYPE.NONE) return;
            if (eCallType == CALLTYPE.FRONT) {

                if (eCallStatus == CALLSTATUS.CALLING) {
                    MainActivity.mCallController.selectVideoSourceToSubPhone(CALLTYPE.FRONT, false);
                    super.setFinishTimerDestroy();
                    MainActivity.mCallController.set1stCallTimer(eCallType, MainActivity.mCallController.mCTT.CALLED);
                    MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.CALLING);
                    if (eCallOwner != CALLOWNER.WALLPAD) {
                        ((MainActivity) mContext).StartPopup(ID.POPUP.POPUP_NOTICE_SUBPHONETALK);
                    }

                    //MainActivity.mIOInterface.ctrlPopupGUI(tr);
                    //((MainActivity) mContext).displayRemoteID(RemoteIDInfo.strName);
                }
                else if (eCallStatus == CALLSTATUS.TALKING) {
                    if (eCallOwner != CALLOWNER.WALLPAD) {
                        doTalk(eCallOwner);
                    } else {
                        MainActivity.mCallController.setTalkPath(CALLPATH.SUBPHONE_MOIP);
                    }
                } else if (eCallStatus == CALLSTATUS.END) {
                    if (eCallOwner != CALLOWNER.WALLPAD) {
                        doEnd();
                    }
                } else if (eCallStatus == CALLSTATUS.DOOR_OPEN) {
                    if (!bSentiMAP) {
                        if (doSubPhoneDoorOpen(eCallOwner, eCallType))
                            MainActivity.mSubPhoneController.sendACKDoorOpen(eCallOwner, eCallType);
                    }
                }
                else if (eCallStatus == CALLSTATUS.BUSY) {
                    if (eCallOwner != CALLOWNER.WALLPAD) {
                        doEnd();
                    }
                }else {
                    Log.w(TAG, "[onSubPhoneEvent] Incorrect eCallStatus!!! eCallStatus = " + eCallStatus);
                }
            } else {
                Log.w(TAG, "[onSubPhoneEvent] Incorrect eCallType!!! eCallType = " + eCallType);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onSubPhoneEvent(CALLOWNER eCallOwner, CALLSTATUS eCallStatus, CALLTYPE eCallType, 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 (bSet) {
                if (!strRemoteSIPID.contains(Declare.DEVICENAME.strType_Front)) {
                    Log.e(TAG, "[onVideoSet] Device name is not matched!!!");
                    return;
                }
            }

            if (!bSet) ctrlAlphaBlending(bSet);
            MainActivity.mCallController.mSIPInterface.videoSet(bSet, false, bSet);
        } 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 (MainActivity.bFFMPEGEnable) ((MainActivity)mContext).showRemoteVideo(bShow, false);
//
//            if (bShow) {
//                sendHandlerMsgDelayed(TalkFront.HANDLERMSG.ENABLE_SAVE_VISITORPICTURE, 0, 0, null, 3000);
//            }
//            else {
//                enableSavePicBTN(false);
//            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onShowRemoteVideo(boolean bShow)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    @Override
    protected void onPopupResult(Intent data) {
        try {
            int nScreen = data.getIntExtra("SCREEN", -1);
            int nID = data.getIntExtra("POPUP_BTN", -1);
            boolean bFinish = data.getBooleanExtra("FINISH_FLAG", false);
            Log.d(TAG, "[onPopupResult] nScreen: " + nScreen + ", nID: " + nID + ", bFinish: " + bFinish);

            if (nScreen == ID.POPUP.POPUP_MULTICALL) {
                if (nID == ID.POPUP.MUTICALL.ELEMENT.BUTTON.ACCEPT) {
                    LOG_INFO("[onPopupResult] ID.POPUP.MUTICALL.ELEMENT.BUTTON.ACCEPT");
                    MainActivity.mCallController.stop2ndCallTimer();
                    MainActivity.mCallController.mSIPInterface.videoSet(false, false, false);
                    doMultiCallAccept();
                } else if (nID == ID.POPUP.MUTICALL.ELEMENT.BUTTON.REJECT) {
                    LOG_INFO("[onPopupResult] ID.POPUP.MUTICALL.ELEMENT.BUTTON.REJECT");
                    if (MainActivity.mPSTNController != null) MainActivity.mPSTNController.stopPSTNRingCntThread(); // PSTN 멀티콜 거절시 ring cnt 초기화
                    MainActivity.mCallController.stop2ndCallTimer();
                    MainActivity.mCallController.mCallInfo.setCallStatus(MainActivity.mCallController.mCallInfo.getMultiCallType(), CALLSTATUS.IDLE);
                    doMultiCallReject();
                    MainActivity.mIOInterface.ctrlPopupGUI(false); // 현재 통화패스가 로비통화일 경우 멀티콜 거절시 GUI 화면이 아래로(영상이 위로)
                    sendHandlerMsgDelayed(TalkFront.HANDLERMSG.REFRESH_BTNLED_STATUS, 0, 0, null, 1000);
                }
                if (bFinish) MainActivity.mIOInterface.ctrlPopupGUI(false); // 현재 통화패스가 로비통화일 경우 멀티콜 팝업 닫히면 GUI 화면이 아래로(영상이 위로)
            }
            else if (nScreen == ID.POPUP.POPUP_NOTICE_SUBPHONETALK) {
                if (nID == ID.POPUP.NOTICE_SUBPHONETALK.ELEMENT.BUTTON.END) {
                    LOG_INFO("[onPopupResult] ID.POPUP.NOTICE_SUBPHONETALK.ELEMENT.BUTTON.END");
                    MainActivity.mCallController.stop2ndCallTimer();
                    doEnd();
                }
            }
            else if (nScreen == ID.POPUP.POPUP_MULTICALL_NOTICE) {
                if (nID == ID.POPUP.MUTICALL_NOTICE.ELEMENT.BUTTON.CONFIRM) {
                    LOG_INFO("[onPopupResult] ID.POPUP.POPUP_MULTICALL_NOTICE.ELEMENT.BUTTON.CONFIRM");
                    MainActivity.mIOInterface.ctrlPopupGUI(false); // 현재 화면이 로비통화일 경우 멀티콜 알림 팝업 닫힐시 GUI 화면이 아래로(영상이 위로)

                    /**
                     * JEFF, 2020.01.01
                     * 모든 통화에서 멀티콜을 막음
                     */
                    if (MainActivity.mPSTNController != null) MainActivity.mPSTNController.stopPSTNRingCntThread(); // PSTN 멀티콜 거절시 ring cnt 초기화
                    MainActivity.mCallController.stop2ndCallTimer();
                    MainActivity.mCallController.mCallInfo.setCallStatus(MainActivity.mCallController.mCallInfo.getMultiCallType(), CALLSTATUS.IDLE);
                    doMultiCallReject();
                    sendHandlerMsgDelayed(TalkFront.HANDLERMSG.REFRESH_BTNLED_STATUS, 0, 0, null, 1000);
                }
            }
            else if (nScreen == ID.POPUP.POPUP_NOTICE_REMOTECALL) {
                if (nID == ID.POPUP.NOTICE_REMOTECALL.ELEMENT.BUTTON.END) {
                    LOG_INFO("[onPopupResult] ID.POPUP.NOTICE_REMOTECALL.ELEMENT.BUTTON.END");
                    MainActivity.mRemoteCallController.sendCloseRemoteCall();
                    MainActivity.mCallController.quitMoIPCall();
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] onPopupResult(Intent data)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void doTalk(CALLOWNER eCallOwner) {
        try {
            LOG_INFO("[doTalk] eCallOwner [" + eCallOwner + "], nSelectedFilter [" + nSelectedFilter + "]" + "RemoteIDInfo.strIP [" + RemoteIDInfo.strIP + "]");
            if ((MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED) || (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING)) {
                enableEndBTN(false);
                enableOpenDoorBTN(false);
                sendHandlerMsgDelayed(TalkLobby.HANDLERMSG.ENABLE_END_BTN, 0, 0, null, 2000);
                sendHandlerMsgDelayed(TalkLobby.HANDLERMSG.ENABLE_OPENDOOR_BTN, 0, 0, null, 2000);
                send_start_talking_request(RemoteIDInfo.strIP);
                //MainActivity.mCallController.acceptMoIPCall(false);
                MainActivity.mCallController.mCallInfo.setCallOwner(eCallOwner);
            } else {
                LOG_INFO("[doTalk] Invalid CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doTalk(CALLOWNER eCallOwner)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void doEnd() {
        try {
            if (MainActivity.mCallController.mCallInfo.getIDLECnt() != MainActivity.mCallController.mCallInfo.IDLECNT_MAX) {
                LOG_INFO("[doEnd] CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
                sendHandlerMsg(TalkFront.HANDLERMSG.HIDE_LOBBYVIDEO, 0, 0, null); // 통화 종료시 로비 영상 노이즈가 생기므로 영상을 GUI 아래로 내림

                if ((MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED) || (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING)) {
                    Global.change1stCallLogAction(CALLACTION.REJECT);
                    //Global.stopMelodyRepeat();
                    //MainActivity.mCallController.rejectMoIPCall();

                    if(MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING)
                    {
                        send_stop_talking_request(RemoteIDInfo.strIP);
                    }

                    bEnableVisitorPic = false;
                    bReliefCallInit = false;
                    Global.stopMelodyRepeat();
                    MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
                    ((MainActivity) mContext).displayRemoteID(null);
                    //if(MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED)
                        //MainActivity.mSound.PlayMent(SND.setting.RETRY_ACTION);
                    MainActivity.mCallController.mCallInfo.setCallStatus(CALLTYPE.FRONT, CALLSTATUS.IDLE);
                    MainActivity.mCallController.stop1stCallTimer();
                    MainActivity.mCallController.stop2ndCallTimer();
                    ((MainActivity) mContext).finishPopUp(ID.POPUP.POPUP_NOTICE_SUBPHONETALK);
                    Global.change1stCallLogAction(CALLACTION.REJECT);
                    //Global.add1stCallHistoryInfoFinal();
                    nSelectedFilter = 0;
                    sendReliefFilterSelectBR(nSelectedFilter);
                    MainActivity.mCallController.MultiCallScenarioManager();
                    //send_stop_talking_request(RemoteIDInfo.strIP);
                }
                else if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
                    if (MainActivity.mCallController.mCallInfo.getCallOwner() == CALLOWNER.MOBILE)
                        MainActivity.mRemoteCallController.sendCloseRemoteCall();
                    MainActivity.mCallController.quitMoIPCall();
                }
                else {
                    LOG_INFO("[doEnd] Invalid CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
                    MainActivity.mCallController.quitMoIPCall();
                }
            } else {
                LOG_INFO("[doEnd] CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
                LOG_INFO("[doEnd] IDLE Cnt is not MAX [" + MainActivity.mCallController.mCallInfo.IDLECNT_MAX + "]");
                MainActivity.mCallController.mCallInfo.printCallStatus();
                MainActivity.mCallController.MultiCallScenarioManager();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doEnd()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void doTalkByBTN(CALLOWNER eCallOwner) {
        try {
            LOG_INFO("[doTalkByBTN] CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
            if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED || MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING) {
                send_start_talking_request(RemoteIDInfo.strIP);
                //MainActivity.mCallController.acceptMoIPCall(false);
                MainActivity.mCallController.mCallInfo.setCallOwner(eCallOwner);
            } else if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
                MainActivity.mCallController.quitMoIPCall();
            } else {
                LOG_INFO("[doTalkByBTN] Invalid CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doTalkByBTN(CALLOWNER eCallOwner)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void doDoorOpen() {
        try {
            if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED || MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING) {
                Global.stopMelodyRepeat();
//                Global.changeVolumeMoIPMode(CALLTYPE.NONE);

                if (!send_lobby_open_request(RemoteIDInfo.strIP)) {
                    MainActivity.mSound.Play(SND.setting.RETRY_ACTION);
                }
                Global.change1stCallLogAction(CALLACTION.DOOR);
            } else if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
//                Global.changeVolumeMoIPMode(CALLTYPE.NONE);
                if (!send_lobby_open_request(RemoteIDInfo.strIP)) {
                    MainActivity.mSound.Play(SND.setting.RETRY_ACTION);
                }
                Global.change1stCallLogAction(CALLACTION.TALK_DOOR);
            }
            else {
                LOG_INFO("[doDoorOpen] Invalid CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doDoorOpen() : " + e);
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private boolean doSubPhoneDoorOpen(CALLOWNER eCallOwner, CALLTYPE eCallType) {
        try {
            LOG_WARN("[doSubPhoneDoorOpen] eCallOwner [" + eCallOwner + "], eCallType [" + eCallType + "]");
            if (eCallType != CALLTYPE.FRONT) {
                LOG_WARN("[doSubPhoneDoorOpen] eCallType is wrong eCallType [" + eCallType + "]");
                return false;
            }

            if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED || MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING) {
                if (Global.getKitchenTVIdx(eCallOwner) >= 0 || Global.getBathTVIdx(eCallOwner) >= 0 || Global.getBathPhoneIdx(eCallOwner) >= 0 || eCallOwner == CALLOWNER.SUB_WALLPAD || eCallOwner == CALLOWNER.UNIVERSAL_DEVICE) {
                    Global.stopMelodyRepeat();
                    if (!send_lobby_open_request(RemoteIDInfo.strIP)) {
                        MainActivity.mSound.Play(SND.setting.RETRY_ACTION);
                        return false;
                    }
                    return true;
                }
                return false;
            } else if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
                if (Global.getKitchenTVIdx(eCallOwner) >= 0 || Global.getBathTVIdx(eCallOwner) >= 0 || Global.getBathPhoneIdx(eCallOwner) >= 0 || eCallOwner == CALLOWNER.SUB_WALLPAD || eCallOwner == CALLOWNER.UNIVERSAL_DEVICE) {
                    if (!send_lobby_open_request(RemoteIDInfo.strIP)) {
                        MainActivity.mSound.Play(SND.setting.RETRY_ACTION);
                        return false;
                    }
                    return true;
                }
                return false;
            } else {
                LOG_INFO("[doDoorOpen] Invalid CALLSTATUS [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
                return false;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return false;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doSubPhoneDoorOpen(CALLOWNER eCallOwner, CALLTYPE eCallType)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return false;
        }
    }

    private void doMultiCallAccept() {
        try {
            LOG("[doMultiCallAccept]");
            MainActivity.mCallController.mCallInfo.setMultiCallAcceptFlag(true);
            doEnd();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doMultiCallAccept()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void doMultiCallReject() {
        try {
            CALLTYPE eMultiCallType = MainActivity.mCallController.mCallInfo.getMultiCallType();
            Log.d(TAG, "[doMultiCallReject] eMultiCallType [" + eMultiCallType + "]");
            if (eMultiCallType == CALLTYPE.FRONT || eMultiCallType == CALLTYPE.LOBBY || eMultiCallType == CALLTYPE.GUARD || eMultiCallType == CALLTYPE.RESIDENCE) {
                MainActivity.mCallController.rejectMoIPMultiCall();
                MainActivity.mCallController.mCallInfo.setCallStatus(eMultiCallType, CALLSTATUS.IDLE);
            } else if (eMultiCallType == CALLTYPE.PSTN) {
                if(MainActivity.mPSTNController!=null)
                    MainActivity.mPSTNController.sendReject();
                MainActivity.mCallController.onPSTNEvent(CALLEVENTTYPE.CANCEL_CALL, null, null);
                MainActivity.mCallController.mCallInfo.setCallStatus(eMultiCallType, CALLSTATUS.IDLE);
            } else {
                LOG_WARN("[doMultiCallReject] Invalid eMultiCallType [" + eMultiCallType + "]");
            }
            MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doMultiCallReject()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    boolean bMultiCallAccept = false; // 통화 버튼 활성화 여부를 판단하기 위한 플래그 (멀티콜 수락시 통화버튼 활성화 하면 안됨)

    private void procAddCall() {
        try {
            LOG("[procAddCall]");
            CALLTYPE eMType = MainActivity.mCallController.mCallInfo.getMultiCallType();
            CALLSTATUS eMStatus = MainActivity.mCallController.mCallInfo.getMultiCallStatus();
            CALLOWNER eCallOwner = MainActivity.mCallController.mCallInfo.getMultiCallOwner();

            LOG("[procAddCall] eMType [" + eMType + "], eMStatus [" + eMStatus + "], CallOwner [" + eCallOwner + "]");
            if (eMType == CALLTYPE.FRONT && eMStatus == CALLSTATUS.CALLED) {
                RemoteIDInfo.strIP = MainActivity.mCallController.mCallInfo.getMultiCall_IP();
                //Global.replace1stBy2ndCallHistory();
                if (MainActivity.mCallController.mCallInfo.getMultiCallAccept()) {
                    // 멀티콜 수락 (통화시작)
                    bMultiCallAccept = true;
                    LOG("[procAddCall] bMultiCallAccept [" + bMultiCallAccept + "]");
                    if (MainActivity.mCallController.mCallInfo.getCallOwner() != CALLOWNER.WALLPAD) {
                        MainActivity.mCallController.selectVideoSourceToSubPhone(CALLTYPE.FRONT, false);
                    }

                    super.setFinishTimerDestroy();
                    MainActivity.mCallController.set1stCallTimer(eMType, MainActivity.mCallController.mCTT.RESIDENCEnLOBBY);
                    doTalk(eCallOwner);
                } else {
                    // 멀티콜 수신중 (호출수신중)
                    if (MainActivity.mCallController.mCallInfo.getCallOwner() != CALLOWNER.WALLPAD) {
                        MainActivity.mCallController.selectVideoSourceToSubPhone(CALLTYPE.FRONT, false);
                    }

                    MainActivity.mCallController.mSIPInterface.videoSet(true, false, true);
                    if (eCallOwner == CALLOWNER.WALLPAD) ctrlAlphaBlending(true); // seulki
                    Global.playMelodyRepeat(eMType);
                    super.setFinishTimerDestroy();
                    MainActivity.mCallController.set1stCallTimer(eMType, MainActivity.mCallController.mCTT.CALLED);
                }
                sendHandlerMsg(TalkFront.HANDLERMSG.SET_BTN_STATUS, 0, 0, null);
                ((MainActivity) mContext).displayRemoteID(MainActivity.mCallController.mCallInfo.getMultiCall_Name());
                MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
            } else {
                LOG("[procAddCall] No MultiCall!!");
                // 멀티콜 없음
                if (RemoteIDInfo.bAutoCall) {
                    doAutoCall();   // 멀티콜 상황이 아닌경우 자동호출을 수행함
                }
                MainActivity.mCallController.mCallInfo.resetMultiCallInfo();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] procAddCall()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void doAutoCall() {
        try {
            Log.e(TAG, "[doAutoCall] RemoteIDInfo.bAutoCall [" + RemoteIDInfo.bAutoCall + "]");
            if (RemoteIDInfo.bAutoCall) {
                RemoteIDInfo.bAutoCall = false;
                LOG("[doAutoCall] strDong [" + RemoteIDInfo.strDong + "], strHo [" + RemoteIDInfo.strHo + "], strIP [" + RemoteIDInfo.strIP + "]");


            } else {
                LOG("[doAutoCall] AutoCall is not activated!!");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] doAutoCall()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void playFrontCamBell(boolean bBell) {
        try {
            MainActivity.mIOInterface.ctrlFrontCamPower(bBell);
            MainActivity.mIOInterface.ctrlFrontCamBell(bBell);
            if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                if (bBell) {
                    ((MainActivity) mContext).ctrlSmartIOTCamStatusMode(SmartRFCamStatusMode.STATUS_ON);
                    ((MainActivity) mContext).ctrlSmartIOTCamLEDMode(SmartRFCamLEDMode.LED_ON);
                } else {
                    ((MainActivity) mContext).ctrlSmartIOTCamStatusMode(SmartRFCamStatusMode.STATUS_OFF);
                    ((MainActivity) mContext).ctrlSmartIOTCamLEDMode(SmartRFCamLEDMode.LED_OFF);
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] playFrontCamBell(boolean bBell)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void ctrlAlphaBlending(boolean bON) {
        try {
            LOG_INFO("[ctrlAlphaBlending] bON [" + bON + "]");
            int BOARDTYPE = ConfigValues.DEVICE_BOARDTYPE;
            if (BOARDTYPE == BOARD_TYPE.V40_IGW300 || BOARDTYPE == BOARD_TYPE.V40 || BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT || BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                if (bON) {
//                    IMG_VIDEO_MODULE.setImageResource(R.drawable.video_black_back_test_4);
                    // 다담 Alphablending 적용을 위한 컬러키 수정 편의를 위하여
                    IMG_VIDEO_MODULE.setImageResource(0);
                    IMG_VIDEO_MODULE.setBackgroundColor(Color.argb(0, 0, 0, 0));
                }
                else {
                    IMG_VIDEO_MODULE.setImageResource(R.drawable.image_lobby);
                }
                MainActivity.mIOInterface.ctrlPopupGUI(!bON);
            }
            else {
                Log.w(TAG, "[ctrlAlphaBlending] Not supported BOARDTYPE!! [" + BOARDTYPE + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] ctrlAlphaBlending(boolean bON)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void displayScreenValues() {
        try {
            getVolume();
            drawVolume();
            if (ConfigValues.bReliefCall) {
                selectReliefCallFilter(nSelectedFilter);
            }
            enableSavePicBTN(false);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] displayScreenValues()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void setBTNStatus() {
        try {
//            LOG("[setBTNStatus] MainActivity.mCallController.mCallInfo.getFRONT [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");
            if ((MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED) || (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING)) {
                ((MainActivity) mContext).setMenuBTNEnable(false);
                // 로비 통화 호출 수신 3초 후 통화시작/통화종료/문열림 가능하도록 버튼 처리
                enableTalkBTN(false);
                enableEndBTN(false);
                enableOpenDoorBTN(false);
                LOG("[setBTNStatus] bMultiCallAccept [" + bMultiCallAccept + "]");
                if (!bMultiCallAccept) {
                    sendHandlerMsgDelayed(TalkFront.HANDLERMSG.ENABLE_TALK_BTN, 0, 0, null, 2000); // 멀티콜 수락시 통화버튼 활성화 안함
                }
                sendHandlerMsgDelayed(TalkFront.HANDLERMSG.ENABLE_END_BTN, 0, 0, null, 2000);
                sendHandlerMsgDelayed(TalkFront.HANDLERMSG.ENABLE_OPENDOOR_BTN, 0, 0, null, 2000);
                if (ConfigValues.bReliefCall) {
                    BTN_RELIEF_FILTER_01.setButtonEventOffDisable();
                    BTN_RELIEF_FILTER_02.setButtonEventOffDisable();
//                    BTN_RELIEF_FILTER_03.setButtonEventOffDisable();
//                    BTN_RELIEF_FILTER_04.setButtonEventOffDisable();
                }
                bSentiMAP = false;
                runFlickerCallLED();
            } else if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
                ((MainActivity) mContext).setMenuBTNEnable(false);
                enableTalkBTN(false);
                if (MainActivity.mCallController.mCallInfo.getCallOwner() == CALLOWNER.MOBILE) {
                    enableSavePicBTN(false);
                    enableOpenDoorBTN(false);
                }
                setOnCallLED();
            } else {
                ((MainActivity) mContext).setMenuBTNEnable(true);
                enableTalkBTN(false);
                enableEndBTN(false);
                enableOpenDoorBTN(false);
                enableSavePicBTN(false);
                if (ConfigValues.bReliefCall) {
                    BTN_RELIEF_FILTER_01.setButtonEventOffEnable(R.drawable.btn_big_filter_1_normal);
                    BTN_RELIEF_FILTER_02.setButtonEventOffEnable(R.drawable.btn_big_filter_2_normal);
//                    BTN_RELIEF_FILTER_03.setButtonEventOffEnable(R.drawable.btn_filter_3_normal);
//                    BTN_RELIEF_FILTER_04.setButtonEventOffEnable(R.drawable.btn_filter_4_normal);
                }
                setOffCallLED();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setBTNStatus()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void setBTNLEDStatus() {
        try {
            if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED) {
                runFlickerCallLED();
            } else if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
                setOnCallLED();
            } else {
                setOffCallLED();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setBTNLEDStatus()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void enableTalkBTN(boolean bEnable) {
        try {
            LOG("[enableTalkBTN] bEnable [" + bEnable + "]");
            if (bEnable) {
                // 이벤트 on
                if (ConfigValues.bReliefCall)
                    BTN_TALK.setImageResource(R.drawable.btn_call_normal);
                else BTN_TALK.setImageResource(R.drawable.btn_lobby_call_normal);
                BTN_TALK.setButtonEventOffDisable();
            } else {
                // 이벤트 off
                if (ConfigValues.bReliefCall)
                    BTN_TALK.setButtonEventOffEnable(R.drawable.btn_call_disabled);
                else BTN_TALK.setButtonEventOffEnable(R.drawable.btn_lobby_call_disabled);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] enableTalkBTN(boolean bEnable)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void enableEndBTN(boolean bEnable) {
        try {
            LOG("[enableEndBTN] bEnable [" + bEnable + "]");
            if (bEnable) {
                // 이벤트 on
                if (ConfigValues.bReliefCall)
                    BTN_END.setImageResource(R.drawable.btn_endl_normal);
                else BTN_END.setImageResource(R.drawable.btn_lobby_end_normal);
                BTN_END.setButtonEventOffDisable();
                ((MainActivity) mContext).TopHomeBtn.setButtonEventOffDisable();
            } else {
                // 이벤트 off
                if (ConfigValues.bReliefCall)
                    BTN_END.setButtonEventOffEnable(R.drawable.btn_endl_disabled);
                else BTN_END.setButtonEventOffEnable(R.drawable.btn_lobby_end_disabled);
                ((MainActivity) mContext).TopHomeBtn.setButtonEventOffEnable();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setEndBtnStatus(boolean bEnable)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void enableOpenDoorBTN(boolean bEnable) {
        try {
            LOG("[enableOpenDoorBTN] bEnable [" + bEnable + "]");
            if (bEnable) {
                // 이벤트 on
                if (ConfigValues.bReliefCall)
                    BTN_DOOROPEN.setImageResource(R.drawable.btn_open_normal);
                else BTN_DOOROPEN.setImageResource(R.drawable.btn_lobby_open_normal);
                BTN_DOOROPEN.setButtonEventOffDisable();
            } else {
                // 이벤트 off
                if (ConfigValues.bReliefCall)
                    BTN_DOOROPEN.setButtonEventOffEnable(R.drawable.btn_open_disabled);
                else BTN_DOOROPEN.setButtonEventOffEnable(R.drawable.btn_lobby_open_disabled);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] enableOpenDoorBTN(boolean bEnable)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void enableSavePicBTN(boolean bEnable) {
        try {

            //LOG_INFO("[enableSavePicBTN] enableSavePicBTN [" + bEnable + "]");
            if (bEnable) {
                if (ConfigValues.bReliefCall)
                    BTN_SAVE_PICTURE.setImageResource(R.drawable.btn_photo_normal);
                else BTN_SAVE_PICTURE.setImageResource(R.drawable.btn_lobby_photo_normal);
                BTN_SAVE_PICTURE.setButtonEventOffDisable();
            } else {
                if (ConfigValues.bReliefCall)
                    BTN_SAVE_PICTURE.setButtonEventOffEnable(R.drawable.btn_photo_disabled);
                else BTN_SAVE_PICTURE.setButtonEventOffEnable(R.drawable.btn_lobby_photo_disabled);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] enableSavePicBTN(boolean bEnable)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    boolean bSentiMAP = false;
    int nCurrentMicGain = 0;
    private boolean send_lobby_open_request(String strTargetIP) {
        LOG_INFO("[send_lobby_open_request] strTargetIP [" + strTargetIP + "]");
        MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
        nCurrentMicGain = MainActivity.mIOInterface.getMICGain();

        ((MainActivity) mContext).Device_DoorOpen(19); //16 address start
        try {
            bSentiMAP = true;
            Request_lobby_open lobby_open = new Request_lobby_open(mContext);
            if (lobby_open.send_lobby_open(strTargetIP, null)) {
                lobby_open.setResultCtrl(new RetProci() {

                    @Override
                    public void ProcSuccess() {
                        LOG_INFO("[send_lobby_open_request] ProcSuccess()");
//                        hideLobbyVideo();
//                        if (MainActivity.mCallController.getTalkPath() == CALLPATH.NORMAL) {
//                            MainActivity.mIOInterface.setMICGain(0);   // 월패드에 출력되는 문열림 멘트가 월패드 마이크를 통해 로비폰에 전달되므로, 멘트 출력전에 Micgain을 0으로 설정한다.
//                        }
                        //MainActivity.mCallController.setTalkPath(CALLPATH.NORMAL);
//                        MainActivity.mSound.Play(SND.mode.OPENDOOR);

                        int nMentDuration = MainActivity.mSound.PlayMent(SND.mode.OPENDOOR);
                        try {
                            Log.d(TAG, "[mPathCheckHandler.handleMessage] nMentDuration -> " + nMentDuration);
                            Thread.sleep(nMentDuration + 1500);
                        } catch (InterruptedException e) {
                            //e.printStackTrace();
                            LogUtil.errorLogInfo("", TAG, e);
                        }

                        enableTalkBTN(false);
                        enableEndBTN(false);
                        enableOpenDoorBTN(false);
                        enableSavePicBTN(false);
                        if (ConfigValues.bReliefCall) {
                            BTN_RELIEF_FILTER_01.setButtonEventOffEnable(R.drawable.btn_big_filter_1_normal);
                            BTN_RELIEF_FILTER_02.setButtonEventOffEnable(R.drawable.btn_big_filter_2_normal);
//                            BTN_RELIEF_FILTER_03.setButtonEventOffEnable(R.drawable.btn_filter_3_normal);
//                            BTN_RELIEF_FILTER_04.setButtonEventOffEnable(R.drawable.btn_filter_4_normal);
                        }
                        doEnd();
//
//                        mPathCheckHandler.sendEmptyMessage(2); // 통화패스 Normal로 변경 확인 후 멘트 출력 seulki
//
//                        // 출입 데이터 기록(로비 문열림)
////                        WallpadAccessData WpadAccessData = new WallpadAccessData(getContext());
////                        WpadAccessData.Insert(WallpadAccessData.KIND.WPAD_CALL, null);
////                        WpadAccessData.closeDB();
//                        enableTalkBTN(false);
//                        enableEndBTN(false);
//                        enableOpenDoorBTN(false);
//                        enableSavePicBTN(false);
//                        if (ConfigValues.bReliefCall) {
//                            BTN_RELIEF_FILTER_01.setButtonEventOffEnable(R.drawable.btn_big_filter_1_normal);
//                            BTN_RELIEF_FILTER_02.setButtonEventOffEnable(R.drawable.btn_big_filter_2_normal);
////                            BTN_RELIEF_FILTER_03.setButtonEventOffEnable(R.drawable.btn_filter_3_normal);
////                            BTN_RELIEF_FILTER_04.setButtonEventOffEnable(R.drawable.btn_filter_4_normal);
//                        }
//                        doEnd();
                    }

                    @Override
                    public void ProcError() {
                        LOG_INFO("[send_lobby_open_request] ProcError()");
                        bSentiMAP = false;
                        MainActivity.mSound.Play(SND.setting.RETRY_ACTION);
//                        mPathCheckHandler.sendEmptyMessage(2); // 통화패스 Normal로 변경 확인 후 멘트 출력 seulki
                    }

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

    private boolean send_lobby_capture_request(String strTargetIP) {
        LOG_INFO("[send_lobby_capture_request] strTargetIP [" + strTargetIP + "]");

        try {
            Request_lobby_capture lobby_capture = new Request_lobby_capture(mContext);
            if (lobby_capture.send_lobby_capture(strTargetIP, null)) {
                lobby_capture.setResultCtrl(new RetProci() {

                    @Override
                    public void ProcSuccess() {
                        LOG_INFO("[send_lobby_capture_request] ProcSuccess()");

                    }

                    @Override
                    public void ProcError() {
                        LOG_INFO("[send_lobby_capture_request] ProcError()");

                    }

                    @Override
                    public void ProcDoing() {
                        LOG_INFO("[send_lobby_capture_request] ProcDoing()");

                    }
                });
                return true;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] send_lobby_capture_request(String strTargetIP, String strMessage)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
        return false;
    }

    // 방문자 사진 자동 저장
    boolean bEnableVisitorPic = false;

    private void startSaveVisitorPicture(CALLTYPE eCallType, CALLSTATUS eCallStatus) {
        try {
            Log.d(TAG, "[startSaveVisitorPicture] eCallType: " + eCallType);
            AutoPictureInfo mAutoPictureInfo = new AutoPictureInfo();
            mAutoPictureInfo.setData(ConfigValues.strDong, ConfigValues.strHo, eCallType,eCallStatus, RemoteIDInfo.strSIPID, "null");
            startAutoSaveVisitorPicture mstartAutoSaveVisitorPicture = new startAutoSaveVisitorPicture(mContext, mAutoPictureInfo, false);
            mstartAutoSaveVisitorPicture.start();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] startSaveVisitorPicture()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void startTakeVisitorPicture(String strSIPID) {
        try {
            AutoPictureInfo mAutoPictureInfo = new AutoPictureInfo();
            mAutoPictureInfo.setData(ConfigValues.strDong, ConfigValues.strHo, CALLTYPE.FRONT, MainActivity.mCallController.mCallInfo.getFRONT(), strSIPID, "null");
            startMissedCallVisitorPicture mstartMIssedCallVisitorPicture = new startMissedCallVisitorPicture(mContext, mAutoPictureInfo, false);
            mstartMIssedCallVisitorPicture.start();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] startTakeVisitorPicture()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    String strForwardingIP = "ERROR";

    private void runCallForward() {
        try {
            LOG("[checkCallForward] ConfigValues.bOccupiedMode [" + ConfigValues.bUnoccupiedMode + "]");
            if (ConfigValues.bUnoccupiedMode) {
                for (int i = 0; i < ConfigValues.mGuardListTable.getCnt(); i++) {
                    if (ConfigValues.mGuardListTable.getGuardInfo(i).NAME().equals(("경비실"))) {
                        strForwardingIP = ConfigValues.mGuardListTable.getGuardInfo(i).IP();
                        if (!strForwardingIP.equals("ERROR")) {
                            if (!send_check_sip_activation_request(strForwardingIP))
                                MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
                            else return;
                        } else {
                            MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
                        }
                    } else {
                        MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
                    }
                }
            } else {
                MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] runCallForward()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private boolean send_stop_talking_request(String strTargetIP) {
        try {
            LOG_INFO("[send_stop_talking_request] strTargetIP() " + strTargetIP);
            //Request_start_talking request_start_talking = new Request_start_talking(mContext);
            Request_stop_talking request_stop_talking = new Request_stop_talking(mContext);
            if (request_stop_talking.send_stop_talking(strTargetIP, null)) {
                request_stop_talking.setResultCtrl(new RetProci() {

                    @Override
                    public void ProcSuccess() {
                        LOG_INFO("[send_stop_talking_request] ProcSuccess()");
                        //MainActivity.mCallController.mSIPInterface.requestCallForwardToStun(MainActivity.mCallController.makeCallForwarInfo(strTargetIP));
                    }

                    @Override
                    public void ProcError() {
                        LOG_INFO("[send_stop_talking_request] ProcError()");
                        //MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
                    }

                    @Override
                    public void ProcDoing() {
                        LOG_INFO("[send_stop_talking_request] ProcDoing()");
                    }
                });
                return true;
            }

        } catch (Exception e) {
            Log.e(TAG, "[Exception] send_check_sip_activation_request(String strTargetIP, String strMessage)");
            e.printStackTrace();
            MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
        }
        return false;


    }


    private boolean send_start_talking_request(String strTargetIP) {
        try {
            LOG_INFO("[send_start_talking_request] strTargetIP() "+ strTargetIP);
            Request_start_talking request_start_talking = new Request_start_talking(mContext);
            if (request_start_talking.send_start_talking(strTargetIP, null)) {
                request_start_talking.setResultCtrl(new RetProci() {

                    @Override
                    public void ProcSuccess() {
                        LOG_INFO("[send_start_talking_request] ProcSuccess()");
                        //MainActivity.mCallController.mSIPInterface.requestCallForwardToStun(MainActivity.mCallController.makeCallForwarInfo(strTargetIP));
                    }

                    @Override
                    public void ProcError() {
                        LOG_INFO("[send_start_talking_request] ProcError()");
                        //MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
                    }

                    @Override
                    public void ProcDoing() {
                        LOG_INFO("[send_start_talking_request] ProcDoing()");
                    }
                });
                return true;
            }
        } catch (Exception e) {
            Log.e(TAG, "[Exception] send_start_talking_request(String strTargetIP, String strMessage)");
            e.printStackTrace();
            MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
        }
        return false;


    }

    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()");
                        MainActivity.mCallController.mSIPInterface.requestCallForwardToStun(MainActivity.mCallController.makeCallForwarInfo(strTargetIP));
                    }

                    @Override
                    public void ProcError() {
                        LOG_INFO("[send_check_sip_activation_request] ProcError()");
                        MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
                        //MainActivity.mSound.PlayMent(SND.call.BUSY_TRY_LATER);
                        //doEnd();
                    }

                    @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);
            MainActivity.mCallController.mSIPInterface.cancelCallForwardToStun();
        }
        return false;
    }


    // 안심통화 관련
    int nSelectedFilter = 0; // 0: 변조안함 / 1~4: 필터 No
    boolean bReliefCallInit = false;

    private void selectReliefCallFilter(int nID) {
        try {
            int nFilter = nID - ID.SCREEN.TALKFRONT.ELEMENT.BUTTON.RELIEF_FILTER_01 + 1; // 현재 선택한 필터
            if (nFilter < 0) nFilter = 0;
            Log.d(TAG, "[selectReliefCallFilter] nID [" + nID + "], nFilter [" + nFilter + "], nSelectedFilter [" + nSelectedFilter + "]");
            if (nFilter == nSelectedFilter) {
                nSelectedFilter = 0;
            } else {
                nSelectedFilter = nFilter; // 기존 선택했던 필터
                LOG("[selectReliefCallFilter] nSelectedFilter [" + nSelectedFilter + "], bReliefCallInit [" + bReliefCallInit + "]");
                // 안심통화 초기화
                if (nSelectedFilter > 0) {
                    if (!bReliefCallInit) {
                        if (MainActivity.mReliefCallIF != null) {
                            Log.d(TAG, "[selectReliefCallFilter] VRSoftInit = " + MainActivity.mReliefCallIF.VRSoftInit(Declare.RELIEFCALL.RELIEFCALL_CERTIFYNAME, Declare.RELIEFCALL.RELIEFCALL_BUFFERSIZE_LOBBY));
                            bReliefCallInit = true;
                        }
                    }
                }
            }
            sendHandlerMsg(TalkFront.HANDLERMSG.SEND_BROADCAST_FILTER, 0, 0, null); // BR
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] selectReliefCallFilter(int nID)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void setFilterBTNStatus(int nFilter) {
        try {
            Log.d(TAG, "[setFilterBTNStatus] nFilter [" + nFilter + "]");
            switch (nFilter) {
                case 1:
                    BTN_RELIEF_FILTER_01.setButtonRearImage();
                    BTN_RELIEF_FILTER_02.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_03.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_04.setButtonFrontImage();
                    break;

                case 2:
                    BTN_RELIEF_FILTER_01.setButtonFrontImage();
                    BTN_RELIEF_FILTER_02.setButtonRearImage();
//                    BTN_RELIEF_FILTER_03.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_04.setButtonFrontImage();
                    break;

                case 3:
                    BTN_RELIEF_FILTER_01.setButtonFrontImage();
                    BTN_RELIEF_FILTER_02.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_03.setButtonRearImage();
//                    BTN_RELIEF_FILTER_04.setButtonFrontImage();
                    break;

                case 4:
                    BTN_RELIEF_FILTER_01.setButtonFrontImage();
                    BTN_RELIEF_FILTER_02.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_03.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_04.setButtonRearImage();
                    break;

                default:
                    BTN_RELIEF_FILTER_01.setButtonFrontImage();
                    BTN_RELIEF_FILTER_02.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_03.setButtonFrontImage();
//                    BTN_RELIEF_FILTER_04.setButtonFrontImage();
                    break;
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setFilterBTNStatus()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }


    // 음량
    SeekBar.OnSeekBarChangeListener mOnVolumeChangeListener = new SeekBar.OnSeekBarChangeListener() {
        @Override
        public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
            int nCtrlLevel = getCtrlLevel(progress);
            if (nCurrentVolume != nCtrlLevel) {
                nCurrentVolume = nCtrlLevel;
                showVolume(nCurrentVolume);
//                ctrlVolume(false);
            }
        }

        @Override
        public void onStartTrackingTouch(SeekBar seekBar) {

        }

        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {
//            Log.d(TAG, "[onStopTrackingTouch] nCurrentVolume:" + nCurrentVolume);
            nCurrentVolume = getCtrlLevel(seekBar.getProgress());
            ctrlVolume(true);
        }
    };

    private void getVolume() {
        try {
            nCurrentVolume = Global.getFrontVolume();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getVolume()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void setVolume(int nValue) {
        try {
            if (!Global.setLobbyVolume(nValue)) {
                LOG_WARN("[setVolume] Fail to set volume!! nValue [" + nValue + "]");
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setVolume()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void ctrlVolume(boolean bSave) {
        try {
            if (bSave) setVolume(nCurrentVolume);
            CALLSTATUS eCallStatus = MainActivity.mCallController.mCallInfo.getFRONT();
            LOG("[ctrlVolume] eCallStatus [" + eCallStatus + "]");
            if (eCallStatus == CALLSTATUS.TALKING) {
                Global.setV40WallPadVolume_LOBBY(nCurrentVolume);
                if ((Version.getModelType() == Version.MODEL_TYPE.IHN_D101_I_LX2) || (Version.getModelType() == Version.MODEL_TYPE.IHN_D101_I))
                {
                    Global.setV40WallPadMicGain("0x0200");
                }
                else if ((Version.getModelType() == Version.MODEL_TYPE.IHN_1010_I_LX2) || (Version.getModelType() == Version.MODEL_TYPE.IHN_1010_I))
                {
                    //Global.setV40WallPadMicGain("0x0080");
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] ctrlVolume()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void showVolume(int nValue) {
        try {
//            Log.d(TAG, "[showVolume] nValue [" + nValue + "]");
            if (TXT_VOLUME_LEVEL != null) TXT_VOLUME_LEVEL.setText(Integer.toString(nValue));
            else Log.w(TAG, "[showVolume] TXT_VOLUME_LEVEL is null!!");
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] showVolume(nValue)");
        }
    }

    private void drawVolume() {
        try {
            if (SEEKBAR_VOLUME != null) {
                SEEKBAR_VOLUME.setProgress(ctrlSeekBarThumb(nCurrentVolume));
                showVolume(nCurrentVolume);
            }
            else Log.w(TAG, "[drawVolume] SEEKBAR_VOLUME is null!!");
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] drawVolume()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private int getCtrlLevel(int nValue) {
        try {
//            Log.d(TAG, "[getCtrlLevel] nValue: " + nValue);
            if (nValue == 0) return 1;
            int result = nValue / 10;
            if ((nValue % 10) != 0) result++;
//            Log.d(TAG, "[getCtrlLevel] result: " + result);
            return result;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return 1;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] getCtrlLevel(nValue)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return 1;
        }
    }

    private int ctrlSeekBarThumb(int nValue) {
        try {
            int progress;
            if (nValue == 1) progress = 1;
            else if (nValue == 10) progress = 100;
            else progress = (nValue - 1) * 11;

            return progress;
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
            return 1;
        } catch (Exception e) {
            Log.e(TAG, "[Exception] ctrlSeekBarThumb()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
            return 1;
        }
    }


    // LED
    boolean bFlickeringCallLED = false;
    boolean bStatusFlickeringCallLED = false;

    private void runFlickerCallLED() {
        try {
            LOG("[runFlickerCallLED] bFlickeringCallLED [" + bFlickeringCallLED + "]");
            if (!bFlickeringCallLED) {
                bFlickeringCallLED = true;
                sendHandlerMsg(TalkFront.HANDLERMSG.FLICKER_LED_CALL, 0, 0, null);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] runFlickerCallLED()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void setOnCallLED() {
        try {
            if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                bFlickeringCallLED = false;
                bStatusFlickeringCallLED = true;
                MainActivity.mIOInterface.ctrlWallPadLED_Call(bStatusFlickeringCallLED);
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setOnCallLED()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void setOffCallLED() {
        try {
            LOG("[setOffCallLED] bStatusFlickeringCallLED [" + bStatusFlickeringCallLED + "]");
            if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                bFlickeringCallLED = false;
                if (bStatusFlickeringCallLED) {
                    bStatusFlickeringCallLED = false;
                    MainActivity.mIOInterface.ctrlWallPadLED_Call(bStatusFlickeringCallLED);
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] setOffCallLED()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void ctrlCallLED() {
        try {
            LOG_INFO("[ctrlCallLED] bFlickeringCallLED [" + bFlickeringCallLED + "], bStatusFlickeringCallLED [" + bStatusFlickeringCallLED + "]");
            LOG_INFO("[ctrlCallLED] MainActivity.mCallController.mCallInfo.getFRONT() [" + MainActivity.mCallController.mCallInfo.getFRONT() + "]");

            if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                if ((MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING) || (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED)) {
                    if (bFlickeringCallLED) {
                        MainActivity.mIOInterface.ctrlWallPadLED_Call(bStatusFlickeringCallLED);
                        bStatusFlickeringCallLED = !bStatusFlickeringCallLED;
                        sendHandlerMsgDelayed(TalkFront.HANDLERMSG.FLICKER_LED_CALL, 0, 0, null, 1000);
                    }
                }
                else if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
                    bStatusFlickeringCallLED = true;
                    MainActivity.mIOInterface.ctrlWallPadLED_Call(bStatusFlickeringCallLED);
                }
                else {
                    bStatusFlickeringCallLED = false;
                    MainActivity.mIOInterface.ctrlWallPadLED_Call(bStatusFlickeringCallLED);
                    LOG_INFO("[ctrlCallLED] bFlickeringCallLED [" + bFlickeringCallLED + "], bStatusFlickeringCallLED [" + bStatusFlickeringCallLED + "]");
                }
            }
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] ctrlCallLED()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }


    // Handlersend
    public final class HANDLERMSG {
        public final static int PROC_ADDCALL = 100;
        public final static int DOOR_OPEN = 110;
        public final static int SAVE_VISITORPICTURE = 120;
        public final static int TAKE_VISITORPICTURE = 125;
        public final static int CALL_FORWARD = 130;
        public final static int ENABLE_SAVE_VISITORPICTURE = 140;
        public final static int SHOW_FRONTVIDEO = 150;
        public final static int FLICKER_LED_CALL = 160;
        public final static int REFRESH_BTNLED_STATUS = 170;
        public final static int SET_BTN_STATUS = 175;
        public final static int ENABLE_TALK_BTN = 176;
        public final static int ENABLE_END_BTN = 177;
        public final static int ENABLE_OPENDOOR_BTN = 178;
        public final static int DO_TALK = 180;
        public final static int OFF_FRONT = 200;
        public final static int SET_VOLUME_TABLE = 300;
        public final static int SEND_BROADCAST_FILTER = 400;
        public final static int HIDE_LOBBYVIDEO = 500;
    }

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

            switch (msg.what) {
                case TalkFront.HANDLERMSG.PROC_ADDCALL:
                    procAddCall();
                    break;

                case TalkFront.HANDLERMSG.DOOR_OPEN:
                    doDoorOpen();
                    break;

                case TalkFront.HANDLERMSG.SAVE_VISITORPICTURE:
                    //if (bEnableVisitorPic) startSaveVisitorPicture(CALLTYPE.FRONT, MainActivity.mCallController.mCallInfo.getFRONT());
                    break;

                case TalkFront.HANDLERMSG.CALL_FORWARD:
                    if (bEnableVisitorPic) runCallForward();
                    break;

                case TalkFront.HANDLERMSG.ENABLE_SAVE_VISITORPICTURE:
                    if (MainActivity.mCallController == null) return;
                    if (MainActivity.mCallController.mCallInfo == null) return;
                    if (MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLING || MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.CALLED || MainActivity.mCallController.mCallInfo.getFRONT() == CALLSTATUS.TALKING) {
                        BTN_SAVE_PICTURE.setButtonEventOffDisable();
                        //MainActivity.mIOInterface.ctrlPopupGUI(false);
                    }
                    break;

                case HANDLERMSG.SHOW_FRONTVIDEO:

                    //ctrlAlphaBlending(true);

                    break;

                case TalkFront.HANDLERMSG.TAKE_VISITORPICTURE:
                    //if (bEnableVisitorPic) startTakeVisitorPicture((String) msg.obj);
                    break;

                case TalkFront.HANDLERMSG.FLICKER_LED_CALL:
                    ctrlCallLED();
                    break;

                case TalkFront.HANDLERMSG.DO_TALK:
                    doTalk((CALLOWNER) msg.obj);
                    break;

                case TalkFront.HANDLERMSG.REFRESH_BTNLED_STATUS:
                    setBTNLEDStatus();
                    break;

                case TalkFront.HANDLERMSG.SET_BTN_STATUS:
                    setBTNStatus();
                    break;

                case TalkFront.HANDLERMSG.ENABLE_TALK_BTN:
                    enableTalkBTN(true);
                    break;

                case TalkFront.HANDLERMSG.ENABLE_END_BTN:
                    enableEndBTN(true);
                    break;

                case TalkFront.HANDLERMSG.ENABLE_OPENDOOR_BTN:
                    enableOpenDoorBTN(true);
                    break;

                case TalkFront.HANDLERMSG.OFF_FRONT:
                    playFrontCamBell(false);
                    break;

                case TalkFront.HANDLERMSG.SET_VOLUME_TABLE:
                    Global.setV40WallPadVolume_LOBBY(nCurrentVolume);
                    break;

                case TalkFront.HANDLERMSG.SEND_BROADCAST_FILTER:
                    // 필터선택하면 BR 전송
                    Log.d(TAG, "[TalkFrontHandler] SEND_BROADCAST_FILTER -> nSelectedFilter [" + nSelectedFilter + "]");
                    setFilterBTNStatus(nSelectedFilter);
                    sendReliefFilterSelectBR(nSelectedFilter);
                    break;

                case TalkFront.HANDLERMSG.HIDE_LOBBYVIDEO:
                    ctrlAlphaBlending(false);
                    //if (IMG_VIDEO_MODULE != null) IMG_VIDEO_MODULE.setImageResource(R.drawable.image_lobby);
                    //if (MainActivity.mIOInterface != null) MainActivity.mIOInterface.ctrlPopupGUI(true);
                    break;

                default:
                    break;

            }
        }
    };

    public void sendHandlerMsg(int what, int arg1, int arg2, Object obj) {
        try {
            LOG("[sendHandlerMsg] what [" + what + "], arg1 [" + arg1 + "], arg2 [" + arg2 + "], obj [" + obj + "]");
            if(TalkFrontHandler!=null)
            {
                Message HandleMsg = TalkFrontHandler.obtainMessage();
                HandleMsg.what = what;
                HandleMsg.arg1 = arg1;
                HandleMsg.arg2 = arg2;
                HandleMsg.obj = obj;
                TalkFrontHandler.sendMessage(HandleMsg);
            }

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

    public void sendHandlerMsgDelayed(int what, int arg1, int arg2, Object obj, long delay) {
        try {
            LOG("[sendHandlerMsgDelayed] what [" + what + "], arg1 [" + arg1 + "], arg2 [" + arg2 + "], obj [" + obj + "], delay [" + delay + "]");
            if(TalkFrontHandler!=null)
            {
                Message HandleMsg = TalkFrontHandler.obtainMessage();
                HandleMsg.what = what;
                HandleMsg.arg1 = arg1;
                HandleMsg.arg2 = arg2;
                HandleMsg.obj = obj;
                TalkFrontHandler.sendMessageDelayed(HandleMsg, delay);
            }

        }
        catch (RuntimeException r)
        {
            Log.e(TAG, "[Exception] sendHandlerMsgDelayed(msg)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, r);
        }
        catch (Exception e) {
            Log.e(TAG, "[Exception] sendHandlerMsgDelayed(msg)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void sendReliefFilterSelectBR(int nSelectedFilter) {
        try {
            Log.i(TAG, "[sendReliefFilterSelectBR] nSelectedFilter = " + nSelectedFilter);
            Intent intent = new Intent();
            intent.setAction(Declare.BR.NOTIFY_CHANGE_LOBBY_FILTER);
            intent.putExtra(Declare.BR.RELIEFCALL_FILTER, nSelectedFilter);
            getContext().sendBroadcast(intent);
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] sendReliefFilterSelectBR(int nSelectedFilter)");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    int nCheckCnt1 = 0, nCheckCnt2 = 0;
    protected Handler mPathCheckHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
//            Log.d(TAG, "[mPathCheckHandler.handleMessage]");
            if (msg.what == 0) {
                nCheckCnt1++;
                if (nCheckCnt1 > 200) {
                    mPathCheckHandler.removeMessages(0);
                    mPathCheckHandler.removeMessages(1);
                } else {
                    if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_IGW300_NOUGAT) {
                        if (MainActivity.mCallController.getTalkPath() == CALLPATH.MOIP_IHND101_LOBBY)
                            mPathCheckHandler.sendEmptyMessageDelayed(1, 50);
                        else mPathCheckHandler.sendEmptyMessageDelayed(0, 50);
                    } else if (ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40 || ConfigValues.DEVICE_BOARDTYPE == BOARD_TYPE.V40_NOUGAT) {
                        if (MainActivity.mCallController.getTalkPath() == CALLPATH.MOIP_IHN1010_LOBBY_GUARD)
                            mPathCheckHandler.sendEmptyMessageDelayed(1, 50);
                        else mPathCheckHandler.sendEmptyMessageDelayed(0, 50);
                    }
                }
            } else if (msg.what == 1) {
                Log.d(TAG, "[mPathCheckHandler.handleMessage] Handler finish!!");
                sendHandlerMsg(TalkFront.HANDLERMSG.SET_VOLUME_TABLE, 0, 0, null);
            } else if (msg.what == 2) {
                nCheckCnt2++;
                if (nCheckCnt2 > 200) {
                    mPathCheckHandler.removeMessages(2);
                    mPathCheckHandler.removeMessages(3);
                }
                else {
                    if (MainActivity.mCallController.getTalkPath() == CALLPATH.NORMAL) mPathCheckHandler.sendEmptyMessageDelayed(3, 100);
                    else mPathCheckHandler.sendEmptyMessageDelayed(2, 50);
                }
            }
            else if (msg.what == 3) {
                Log.d(TAG, "[mPathCheckHandler.handleMessage] Handler finish!! PATH [NORMAL] -> play dooropen ment!");
                try {

                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    LogUtil.errorLogInfo("", TAG, e);
                }
                int nMentDuration = MainActivity.mSound.PlayMent(SND.mode.OPENDOOR);
                try {
                    Log.d(TAG, "[mPathCheckHandler.handleMessage] nMentDuration -> " + nMentDuration);
                    Thread.sleep(nMentDuration + 1500);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    LogUtil.errorLogInfo("", TAG, e);
                }

                try {
                    MainActivity.mIOInterface.setMICGain(nCurrentMicGain);
                }
                catch (NullPointerException ne)
                {
                    ne.fillInStackTrace();
                }

            }
        }
    };

    private void finishWallpadCallApp() {
        try {
            doEnd();
            if (MainActivity.mCallController.mCallInfo.getPSTNCallHold()) return;
            ((MainActivity) mContext).finishWallPadCall();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] finishWallpadCallApp()");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }

    private void hideLobbyVideo() {
        try {
            Log.i(TAG, "[hideLobbyVideo]");
            class hideLobbyVideo extends Thread {
                @Override
                public void run() {
                    super.run();
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        //e.printStackTrace();
                        LogUtil.errorLogInfo("", TAG, e);
                    }
                    sendHandlerMsgDelayed(TalkFront.HANDLERMSG.HIDE_LOBBYVIDEO, 0, 0, null, 3000);
                }
            }

            hideLobbyVideo th_hideLobbyVideo = new hideLobbyVideo();
            th_hideLobbyVideo.start();
        } catch (RuntimeException re) {
            LogUtil.errorLogInfo("", TAG, re);
        } catch (Exception e) {
            Log.e(TAG, "[Exception] hideLobbyVideo");
            //e.printStackTrace();
            LogUtil.errorLogInfo("", TAG, e);
        }
    }


}