package com.mstar.android.tv;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;
import com.mstar.android.tv.IEventClient;
import com.mstar.android.tvapi.common.exception.TvCommonException;
import com.mstar.android.tvapi.common.vo.EnumNlaSetIndex;
import com.mstar.android.tvapi.common.vo.EnumPowerOnLogoMode;
import com.mstar.android.tvapi.common.vo.EnumPowerOnMusicMode;
import com.mstar.android.tvapi.common.vo.TvOsType;
import com.mstar.android.tvapi.dtv.vo.DtvDemodVersion;
import com.mstar.android.tvapi.factory.vo.EnumAcOnPowerOnMode;
import com.mstar.android.tvapi.factory.vo.EnumAdcSetIndexType;
import com.mstar.android.tvapi.factory.vo.EnumScreenMute;
import com.mstar.android.tvapi.factory.vo.PanelVersionInfo;
import com.mstar.android.tvapi.factory.vo.UrsaVersionInfo;
import java.util.ArrayList;
import java.util.Iterator;

/* JADX INFO: loaded from: classes.dex */
public class TvFactoryManager extends IEventClient.Stub {
    public static final int ACON_POWERON_DIRECT = 2;
    public static final int ACON_POWERON_MEMORY = 1;
    public static final int ACON_POWERON_SECONDARY = 0;
    public static final int ADC_ADJUST_GAIN_MAX = 4095;
    public static final int ADC_ADJUST_GAIN_MIN = 0;
    public static final int ADC_ADJUST_OFFSET_MAX = 4095;
    public static final int ADC_ADJUST_OFFSET_MIN = 0;
    public static final int ADC_SET_SCART_RGB = 3;
    public static final int ADC_SET_VGA = 0;
    public static final int ADC_SET_YPBPR2_HD = 5;
    public static final int ADC_SET_YPBPR2_SD = 4;
    public static final int ADC_SET_YPBPR3_HD = 7;
    public static final int ADC_SET_YPBPR3_SD = 6;
    public static final int ADC_SET_YPBPR_HD = 2;
    public static final int ADC_SET_YPBPR_SD = 1;
    public static final int AUDIO_HIDEV_BW_LV1 = 1;
    public static final int AUDIO_HIDEV_BW_LV2 = 2;
    public static final int AUDIO_HIDEV_BW_LV3 = 3;
    public static final int AUDIO_HIDEV_BW_MAX = 4;
    public static final int AUDIO_HIDEV_OFF = 0;
    public static final int CITY_NUM_ONE = 0;
    public static final int CITY_NUM_TWO = 1;
    public static final int DEMOD_DTMB = 3;
    public static final int DEMOD_DVB_C = 1;
    public static final int DEMOD_DVB_S = 2;
    public static final int DEMOD_DVB_T = 0;
    public static final int DEMOD_DVB_T2 = 4;
    public static final int DEMOD_MAX = 5;
    public static final int DEMOD_NULL = 5;
    public static final int EV_TV_FACTORYPROGRAM_FINISHED = 1;
    public static final int NLA_BACKLIGHT = 6;
    public static final int NLA_BRIGHTNESS = 1;
    public static final int NLA_CONTRAST = 2;
    public static final int NLA_HUE = 5;
    public static final int NLA_SATURATION = 3;
    public static final int NLA_SHARPNESS = 4;
    public static final int NLA_VOLUME = 0;
    public static final int PEQ_ADJUST_COARSE_MAX = 160;
    public static final int PEQ_ADJUST_COARSE_MIN = 1;
    public static final int PEQ_ADJUST_FINE_MAX = 99;
    public static final int PEQ_ADJUST_FINE_MIN = 0;
    public static final int PEQ_ADJUST_GAIN_MAX = 240;
    public static final int PEQ_ADJUST_GAIN_MIN = 0;
    public static final int PEQ_ADJUST_QVALUE_MAX = 160;
    public static final int PEQ_ADJUST_QVALUE_MIN = 5;
    public static final int PEQ_BAND_NUM = 5;
    public static final int POWERON_LOGO_CAPTURE1 = 2;
    public static final int POWERON_LOGO_CAPTURE2 = 3;
    public static final int POWERON_LOGO_DEFAULT = 1;
    public static final int POWERON_LOGO_OFF = 0;
    public static final int POWERON_MUSIC_DEFAULT = 1;
    public static final int POWERON_MUSIC_OFF = 0;
    public static final int POWERON_MUSIC_ONE = 2;
    public static final int SCREEN_MUTE_BLACK = 5;
    public static final int SCREEN_MUTE_BLUE = 4;
    public static final int SCREEN_MUTE_GREEN = 3;
    public static final int SCREEN_MUTE_OFF = 0;
    public static final int SCREEN_MUTE_RED = 2;
    public static final int SCREEN_MUTE_WHITE = 1;
    private static final String TAG = "TvFactoryManager";
    public static final int THREE_DIMENSION_SELFADAPTIVE_LEVEL_HIGH = 2;
    public static final int THREE_DIMENSION_SELFADAPTIVE_LEVEL_LOW = 0;
    public static final int THREE_DIMENSION_SELFADAPTIVE_LEVEL_MIDDLE = 1;
    public static final int VIDEO_MUTE_COLOR_BLACK = 0;
    public static final int VIDEO_MUTE_COLOR_BLUE = 3;
    public static final int VIDEO_MUTE_COLOR_GREEN = 4;
    public static final int VIDEO_MUTE_COLOR_NUMBER = 5;
    public static final int VIDEO_MUTE_COLOR_RED = 2;
    public static final int VIDEO_MUTE_COLOR_WHITE = 1;
    public static final int WB_ADJUST_GAIN_MAX = 4095;
    public static final int WB_ADJUST_GAIN_MIN = 0;
    static TvFactoryManager mInstance;
    private static ITvFactory mService;
    private ArrayList<OnFactoryProgramFinishedEventListener> mFactoryProgramFinishedListeners = new ArrayList<>();
    private EventHandler mHandler;

    private class EventHandler extends Handler {
        EventHandler(Looper looper) {
            super(looper);
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            if (TvFactoryManager.this.mFactoryProgramFinishedListeners != null) {
                synchronized (TvFactoryManager.this.mFactoryProgramFinishedListeners) {
                    try {
                        Iterator it = TvFactoryManager.this.mFactoryProgramFinishedListeners.iterator();
                        while (it.hasNext()) {
                            ((OnFactoryProgramFinishedEventListener) it.next()).onFactoryProgramFinishedEvent(message.what, message.arg1, message.arg2, message.obj);
                        }
                    } finally {
                    }
                }
            }
        }
    }

    public interface OnFactoryProgramFinishedEventListener {
        boolean onFactoryProgramFinishedEvent(int i2, int i3, int i4, Object obj);
    }

    private TvFactoryManager() throws TvCommonException {
        this.mHandler = null;
        Looper looperMyLooper = Looper.myLooper();
        if (looperMyLooper != null) {
            this.mHandler = new EventHandler(looperMyLooper);
        } else {
            Looper mainLooper = Looper.getMainLooper();
            if (mainLooper != null) {
                this.mHandler = new EventHandler(mainLooper);
            } else {
                this.mHandler = null;
            }
        }
        try {
            getService().addClient(this);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public static TvFactoryManager getInstance() {
        if (mInstance == null) {
            synchronized (TvFactoryManager.class) {
                if (mInstance == null) {
                    try {
                        mInstance = new TvFactoryManager();
                    } catch (TvCommonException e2) {
                        e2.printStackTrace();
                        return null;
                    }
                }
            }
        }
        return mInstance;
    }

    private static ITvFactory getService() {
        ITvFactory iTvFactory = mService;
        if (iTvFactory != null) {
            return iTvFactory;
        }
        if (true == TvServiceBinder.isNeedBindService()) {
            ITvService tvService = TvServiceBinder.getTvService();
            if (tvService == null) {
                Log.e(TAG, "TvService doesn't exist!!");
                throw new NullPointerException("TvService doesn't exist.");
            }
            try {
                mService = tvService.getTvFactory();
            } catch (RemoteException e2) {
                e2.printStackTrace();
            }
        } else {
            mService = TvManager.getInstance().getTvFactory();
        }
        return mService;
    }

    public boolean changeWbParameterWhenSourceChange() {
        try {
            return getService().changeWbParameterWhenSourceChange();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean enableUartDebug() {
        try {
            return getService().enableUartDebug();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean execAutoAdc() {
        try {
            getService().execAutoAdc();
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean execSetInputSource(TvOsType.EnumInputSource enumInputSource) {
        Log.d(TAG, "execSetInputSource, paras inputSource = " + enumInputSource);
        try {
            getService().execSetInputSource(enumInputSource.ordinal());
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    protected void finalize() throws Throwable {
        Log.d(TAG, "finalize TvFactoryManager listener");
        if (TvServiceBinder.isNeedBindService()) {
            return;
        }
        try {
            getService().removeClient(this);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public int get3DSelfAdaptiveLevel() {
        short s2;
        try {
            s2 = (short) getService().get3DSelfAdaptiveLevel();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            s2 = -1;
        }
        Log.d(TAG, "get3DSelfAdaptiveLevel, return int " + ((int) s2));
        return s2;
    }

    public int getAcPowerOnMode() {
        try {
            return getService().getPowerOnMode();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return -1;
        }
    }

    public int getAdcBlueGain() {
        int adcBlueGain;
        try {
            adcBlueGain = getService().getAdcBlueGain();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            adcBlueGain = -1;
        }
        Log.d(TAG, "getAdcBlueGain, return int " + adcBlueGain);
        return adcBlueGain;
    }

    public int getAdcBlueOffset() {
        int adcBlueOffset;
        try {
            adcBlueOffset = getService().getAdcBlueOffset();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            adcBlueOffset = -1;
        }
        Log.d(TAG, "getAdcBlueOffset, return int " + adcBlueOffset);
        return adcBlueOffset;
    }

    public int getAdcGreenGain() {
        int adcGreenGain;
        try {
            adcGreenGain = getService().getAdcGreenGain();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            adcGreenGain = -1;
        }
        Log.d(TAG, "getAdcGreenGain, return int " + adcGreenGain);
        return adcGreenGain;
    }

    public int getAdcGreenOffset() {
        int adcGreenOffset;
        try {
            adcGreenOffset = getService().getAdcGreenOffset();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            adcGreenOffset = -1;
        }
        Log.d(TAG, "getAdcGreenOffset, return int " + adcGreenOffset);
        return adcGreenOffset;
    }

    @Deprecated
    public EnumAdcSetIndexType getAdcIndex() {
        return EnumAdcSetIndexType.values()[getFactoryAdcIndex()];
    }

    public int getAdcPhase() {
        int adcPhase;
        try {
            adcPhase = getService().getAdcPhase();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            adcPhase = -1;
        }
        Log.d(TAG, "getAdcPhase, return int " + adcPhase);
        return adcPhase;
    }

    public int getAdcRedGain() {
        int adcRedGain;
        try {
            adcRedGain = getService().getAdcRedGain();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            adcRedGain = -1;
        }
        Log.d(TAG, "getAdcRedGain, return int " + adcRedGain);
        return adcRedGain;
    }

    public int getAdcRedOffset() {
        int adcRedOffset;
        try {
            adcRedOffset = getService().getAdcRedOffset();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            adcRedOffset = -1;
        }
        Log.d(TAG, "getAdcRedOffset, return int " + adcRedOffset);
        return adcRedOffset;
    }

    public short getAefc43() {
        short aefc43;
        try {
            aefc43 = (short) getService().getAefc43();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefc43 = -1;
        }
        Log.d(TAG, "getAefc43, return short " + ((int) aefc43));
        return aefc43;
    }

    public short getAefc44() {
        short aefc44;
        try {
            aefc44 = (short) getService().getAefc44();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefc44 = -1;
        }
        Log.d(TAG, "getAefc44, return short " + ((int) aefc44));
        return aefc44;
    }

    public short getAefc66Bit76() {
        short aefc66Bit76;
        try {
            aefc66Bit76 = (short) getService().getAefc66Bit76();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefc66Bit76 = -1;
        }
        Log.d(TAG, "getAefc66Bit76, return short " + ((int) aefc66Bit76));
        return aefc66Bit76;
    }

    public short getAefc6EBit3210() {
        short aefc6EBit3210;
        try {
            aefc6EBit3210 = (short) getService().getAefc6EBit3210();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefc6EBit3210 = -1;
        }
        Log.d(TAG, "getAefc6EBit3210, return short " + ((int) aefc6EBit3210));
        return aefc6EBit3210;
    }

    public short getAefc6EBit7654() {
        short aefc6EBit7654;
        try {
            aefc6EBit7654 = (short) getService().getAefc6EBit7654();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefc6EBit7654 = -1;
        }
        Log.d(TAG, "getAefc6EBit7654, return short " + ((int) aefc6EBit7654));
        return aefc6EBit7654;
    }

    public short getAefcA0() {
        short aefcA0;
        try {
            aefcA0 = (short) getService().getAefcA0();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcA0 = -1;
        }
        Log.d(TAG, "getAefcA0, return short " + ((int) aefcA0));
        return aefcA0;
    }

    public short getAefcA1() {
        short aefcA1;
        try {
            aefcA1 = (short) getService().getAefcA1();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcA1 = -1;
        }
        Log.d(TAG, "getAefcA1, return short " + ((int) aefcA1));
        return aefcA1;
    }

    public short getAefcCb() {
        short aefcCb;
        try {
            aefcCb = (short) getService().getAefcCb();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcCb = -1;
        }
        Log.d(TAG, "getVifVgaMaximum, return short " + ((int) aefcCb));
        return aefcCb;
    }

    public short getAefcCfBit2Atv() {
        short aefcCfBit2Atv;
        try {
            aefcCfBit2Atv = (short) getService().getAefcCfBit2Atv();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcCfBit2Atv = -1;
        }
        Log.d(TAG, "getVifVgaMaximum, return short " + ((int) aefcCfBit2Atv));
        return aefcCfBit2Atv;
    }

    public short getAefcCfBit2Av() {
        short aefcCfBit2Av;
        try {
            aefcCfBit2Av = (short) getService().getAefcCfBit2Av();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcCfBit2Av = -1;
        }
        Log.d(TAG, "getVifVgaMaximum, return short " + ((int) aefcCfBit2Av));
        return aefcCfBit2Av;
    }

    public short getAefcD4() {
        short aefcD4;
        try {
            aefcD4 = (short) getService().getAefcD4();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcD4 = -1;
        }
        Log.d(TAG, "getAefcD4, return short " + ((int) aefcD4));
        return aefcD4;
    }

    public short getAefcD5Bit2() {
        short aefcD5Bit2;
        try {
            aefcD5Bit2 = (short) getService().getAefcD5Bit2();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcD5Bit2 = -1;
        }
        Log.d(TAG, "getAefcD5Bit2, return short " + ((int) aefcD5Bit2));
        return aefcD5Bit2;
    }

    public short getAefcD7HighBound() {
        short aefcD7HighBound;
        try {
            aefcD7HighBound = (short) getService().getAefcD7HighBound();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcD7HighBound = -1;
        }
        Log.d(TAG, "getAefcD7HighBound, return short " + ((int) aefcD7HighBound));
        return aefcD7HighBound;
    }

    public short getAefcD7LowBound() {
        short aefcD7LowBound;
        try {
            aefcD7LowBound = (short) getService().getAefcD7LowBound();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcD7LowBound = -1;
        }
        Log.d(TAG, "getAefcD7LowBound, return short " + ((int) aefcD7LowBound));
        return aefcD7LowBound;
    }

    public short getAefcD8Bit3210() {
        short aefcD8Bit3210;
        try {
            aefcD8Bit3210 = (short) getService().getAefcD8Bit3210();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcD8Bit3210 = -1;
        }
        Log.d(TAG, "getAefcD8Bit3210, return short " + ((int) aefcD8Bit3210));
        return aefcD8Bit3210;
    }

    public short getAefcD9Bit0() {
        short aefcD9Bit0;
        try {
            aefcD9Bit0 = (short) getService().getAefcD9Bit0();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            aefcD9Bit0 = -1;
        }
        Log.d(TAG, "getAefcD9Bit0, return short " + ((int) aefcD9Bit0));
        return aefcD9Bit0;
    }

    public short getAudioDspVersion() {
        short audioDspVersion;
        try {
            audioDspVersion = (short) getService().getAudioDspVersion();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            audioDspVersion = -1;
        }
        Log.d(TAG, "getAudioDspVersion, return short " + ((int) audioDspVersion));
        return audioDspVersion;
    }

    public int getAudioHiDevMode() {
        short audioHiDevMode;
        try {
            audioHiDevMode = (short) getService().getAudioHiDevMode();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            audioHiDevMode = -1;
        }
        Log.d(TAG, "getAudioHiDevMode, return short " + ((int) audioHiDevMode));
        return audioHiDevMode;
    }

    public short getAudioNrThreshold() {
        short audioNrThreshold;
        try {
            audioNrThreshold = (short) getService().getAudioNrThreshold();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            audioNrThreshold = -1;
        }
        Log.d(TAG, "getAudioNrThreshold, return short " + ((int) audioNrThreshold));
        return audioNrThreshold;
    }

    public short getAudioPrescale() {
        short audioPrescale;
        try {
            audioPrescale = (short) getService().getAudioPrescale();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            audioPrescale = -1;
        }
        Log.d(TAG, "getAudioPrescale, return short " + ((int) audioPrescale));
        return audioPrescale;
    }

    public short getAudioSifThreshold() {
        short audioSifThreshold;
        try {
            audioSifThreshold = (short) getService().getAudioSifThreshold();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            audioSifThreshold = -1;
        }
        Log.d(TAG, "getAudioSifThreshold, return short " + ((int) audioSifThreshold));
        return audioSifThreshold;
    }

    public String getBoardType() {
        String boardType;
        try {
            boardType = getService().getBoardType();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            boardType = null;
        }
        Log.d(TAG, "getBoardType, return String " + boardType);
        return boardType;
    }

    public short getChinaDescramblerBox() {
        short chinaDescramblerBox;
        try {
            chinaDescramblerBox = (short) getService().getChinaDescramblerBox();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            chinaDescramblerBox = -1;
        }
        Log.d(TAG, "getChinaDescramblerBox, return short " + ((int) chinaDescramblerBox));
        return chinaDescramblerBox;
    }

    public short getChinaDescramblerBoxDelay() {
        short chinaDescramblerBoxDelay;
        try {
            chinaDescramblerBoxDelay = (short) getService().getChinaDescramblerBoxDelay();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            chinaDescramblerBoxDelay = -1;
        }
        Log.d(TAG, "getChinaDescramblerBoxDelay, return short " + ((int) chinaDescramblerBoxDelay));
        return chinaDescramblerBoxDelay;
    }

    public String getCompileTime() {
        String compileTime;
        try {
            compileTime = getService().getCompileTime();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            compileTime = null;
        }
        Log.d(TAG, "getCompileTime, return String " + compileTime);
        return compileTime;
    }

    @Deprecated
    public EnumNlaSetIndex getCurveType() {
        return EnumNlaSetIndex.values()[getNlaCurveType()];
    }

    public short getDelayReduce() {
        short delayReduce;
        try {
            delayReduce = (short) getService().getDelayReduce();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            delayReduce = -1;
        }
        Log.d(TAG, "getDelayReduce, return short " + ((int) delayReduce));
        return delayReduce;
    }

    public boolean getDtvAvAbnormalDelay() {
        try {
            return getService().getDtvAvAbnormalDelay();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public DtvDemodVersion getDtvDemodVersion(int i2) {
        Log.d(TAG, "getDtvDemodVersion, paras demodType = " + i2);
        try {
            return getService().getDtvDemodVersion(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    @Deprecated
    public EnumPowerOnLogoMode getEnvironmentPowerOnLogoMode() {
        return EnumPowerOnLogoMode.values()[getPowerOnLogoMode()];
    }

    @Deprecated
    public EnumPowerOnMusicMode getEnvironmentPowerOnMusicMode() {
        return EnumPowerOnMusicMode.values()[getPowerOnMusicMode()];
    }

    public int getEnvironmentPowerOnMusicVolume() {
        int environmentPowerOnMusicVolume;
        try {
            environmentPowerOnMusicVolume = getService().getEnvironmentPowerOnMusicVolume();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            environmentPowerOnMusicVolume = 0;
        }
        Log.d(TAG, "getEnvironmentPowerOnMusicVolume, return ret " + environmentPowerOnMusicVolume);
        return environmentPowerOnMusicVolume;
    }

    public int getFactoryAdcIndex() {
        try {
            return getService().getAdcIndex();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return -1;
        }
    }

    public int getFactoryPreSetFeature() {
        short factoryPreSetFeature;
        try {
            factoryPreSetFeature = (short) getService().getFactoryPreSetFeature();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            factoryPreSetFeature = -1;
        }
        Log.d(TAG, "getFactoryPreSetFeature, return int " + ((int) factoryPreSetFeature));
        return factoryPreSetFeature;
    }

    public int getGainDistributionThreshold() {
        int vifCrThreshold;
        try {
            vifCrThreshold = getService().getVifCrThreshold();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifCrThreshold = -1;
        }
        Log.d(TAG, "getVifCrThreshold, return int " + vifCrThreshold);
        return vifCrThreshold;
    }

    public int getLvdsModulation() {
        int lvdsModulation;
        try {
            lvdsModulation = getService().getLvdsModulation();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            lvdsModulation = -1;
        }
        Log.d(TAG, "getLvdsModulation, return int " + lvdsModulation);
        return lvdsModulation;
    }

    public int getLvdsPercentage() {
        int lvdsPercentage;
        try {
            lvdsPercentage = getService().getLvdsPercentage();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            lvdsPercentage = -1;
        }
        Log.d(TAG, "getLvdsPercentage, return int " + lvdsPercentage);
        return lvdsPercentage;
    }

    public boolean getLvdsenable() {
        try {
            return getService().getLvdsenable();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean getMiuEnable() {
        try {
            return getService().getMiuEnable();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public int getMiuModulation() {
        int miuModulation;
        try {
            miuModulation = getService().getMiuModulation();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            miuModulation = -1;
        }
        Log.d(TAG, "getMiuModulation, return int " + miuModulation);
        return miuModulation;
    }

    public int getMiuPercentage() {
        int miuPercentage;
        try {
            miuPercentage = getService().getMiuPercentage();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            miuPercentage = -1;
        }
        Log.d(TAG, "getMiuPercentage, return int " + miuPercentage);
        return miuPercentage;
    }

    public int getNlaCurveType() {
        try {
            return getService().getCurveType();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return -1;
        }
    }

    public short getOsdV0Nonlinear() {
        short osdV0Nonlinear;
        try {
            osdV0Nonlinear = (short) getService().getOsdV0Nonlinear();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            osdV0Nonlinear = -1;
        }
        Log.d(TAG, "getOsdV0Nonlinear, return short " + ((int) osdV0Nonlinear));
        return osdV0Nonlinear;
    }

    public short getOsdV100Nonlinear() {
        short osdV100Nonlinear;
        try {
            osdV100Nonlinear = (short) getService().getOsdV100Nonlinear();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            osdV100Nonlinear = -1;
        }
        Log.d(TAG, "getOsdV100Nonlinear, return short " + ((int) osdV100Nonlinear));
        return osdV100Nonlinear;
    }

    public short getOsdV25Nonlinear() {
        short osdV25Nonlinear;
        try {
            osdV25Nonlinear = (short) getService().getOsdV25Nonlinear();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            osdV25Nonlinear = -1;
        }
        Log.d(TAG, "getOsdV25Nonlinear, return short " + ((int) osdV25Nonlinear));
        return osdV25Nonlinear;
    }

    public short getOsdV50Nonlinear() {
        short osdV50Nonlinear;
        try {
            osdV50Nonlinear = (short) getService().getOsdV50Nonlinear();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            osdV50Nonlinear = -1;
        }
        Log.d(TAG, "getOsdV50Nonlinear, return short " + ((int) osdV50Nonlinear));
        return osdV50Nonlinear;
    }

    public short getOsdV75Nonlinear() {
        short osdV75Nonlinear;
        try {
            osdV75Nonlinear = (short) getService().getOsdV75Nonlinear();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            osdV75Nonlinear = -1;
        }
        Log.d(TAG, "getOsdV75Nonlinear, return short " + ((int) osdV75Nonlinear));
        return osdV75Nonlinear;
    }

    public short getOverScanHPosition() {
        short overScanHPosition;
        try {
            overScanHPosition = (short) getService().getOverScanHPosition();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            overScanHPosition = -1;
        }
        Log.d(TAG, "getOverScanHPosition, return short " + ((int) overScanHPosition));
        return overScanHPosition;
    }

    public short getOverScanHSize() {
        short overScanHSize;
        try {
            overScanHSize = (short) getService().getOverScanHSize();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            overScanHSize = -1;
        }
        Log.d(TAG, "getOverScanHSize, return short " + ((int) overScanHSize));
        return overScanHSize;
    }

    public int getOverScanInputSource() {
        try {
            return getService().getOverScanSourceType();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return -1;
        }
    }

    @Deprecated
    public TvOsType.EnumInputSource getOverScanSourceType() {
        return TvOsType.EnumInputSource.values()[getOverScanInputSource()];
    }

    public short getOverScanVPosition() {
        short overScanVPosition;
        try {
            overScanVPosition = (short) getService().getOverScanVPosition();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            overScanVPosition = -1;
        }
        Log.d(TAG, "getOverScanVPosition, return short " + ((int) overScanVPosition));
        return overScanVPosition;
    }

    public short getOverScanVSize() {
        short overScanVSize;
        try {
            overScanVSize = (short) getService().getOverScanVSize();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            overScanVSize = -1;
        }
        Log.d(TAG, "getOverScanVSize, return short " + ((int) overScanVSize));
        return overScanVSize;
    }

    public String getPQVersion(int i2) {
        String pQVersion;
        try {
            pQVersion = getService().getPQVersion(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            pQVersion = null;
        }
        Log.d(TAG, "getPQVersion, return String " + pQVersion);
        return pQVersion;
    }

    public short getPanelSwing() {
        short panelSwing;
        try {
            panelSwing = (short) getService().getPanelSwing();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            panelSwing = -1;
        }
        Log.d(TAG, "getPanelSwing, return short " + ((int) panelSwing));
        return panelSwing;
    }

    public String getPanelType() {
        String panelType;
        try {
            panelType = getService().getPanelType();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            panelType = null;
        }
        Log.d(TAG, "getPanelType, return String " + panelType);
        return panelType;
    }

    public PanelVersionInfo getPanelVersionInfo() {
        try {
            return getService().getPanelVersionInfo();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public int getPeqEnable(int i2) {
        int peqEnable;
        try {
            peqEnable = getService().getPeqEnable(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            peqEnable = -1;
        }
        Log.d(TAG, "getPeqEnable, return int " + peqEnable);
        return peqEnable;
    }

    public int getPeqFoCoarse(int i2) {
        int peqFoCoarse;
        try {
            peqFoCoarse = getService().getPeqFoCoarse(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            peqFoCoarse = -1;
        }
        Log.d(TAG, "getPeqFoCoarse, return int " + peqFoCoarse);
        return peqFoCoarse;
    }

    public int getPeqFoFine(int i2) {
        int peqFoFine;
        try {
            peqFoFine = getService().getPeqFoFine(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            peqFoFine = -1;
        }
        Log.d(TAG, "getPeqFoFine, return int " + peqFoFine);
        return peqFoFine;
    }

    public int getPeqGain(int i2) {
        int peqGain;
        try {
            peqGain = getService().getPeqGain(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            peqGain = -1;
        }
        Log.d(TAG, "getPeqGain, return int " + peqGain);
        return peqGain;
    }

    public int getPeqQ(int i2) {
        int peqQ;
        try {
            peqQ = getService().getPeqQ(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            peqQ = -1;
        }
        Log.d(TAG, "getPeqQ, return int " + peqQ);
        return peqQ;
    }

    public int getPowerOnLogoMode() {
        try {
            return getService().getEnvironmentPowerOnLogoMode();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return -1;
        }
    }

    @Deprecated
    public EnumAcOnPowerOnMode getPowerOnMode() {
        return EnumAcOnPowerOnMode.values()[getAcPowerOnMode()];
    }

    public int getPowerOnMusicMode() {
        try {
            return getService().getEnvironmentPowerOnMusicMode();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return -1;
        }
    }

    public boolean getPvrRecordAll() {
        boolean pvrRecordAll;
        try {
            pvrRecordAll = getService().getPvrRecordAll();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            pvrRecordAll = false;
        }
        Log.d(TAG, "getOverScanVPosition, return boolean " + pvrRecordAll);
        return pvrRecordAll;
    }

    public String getSoftWareVersion() {
        String softWareVersion;
        try {
            softWareVersion = getService().getSoftWareVersion();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            softWareVersion = null;
        }
        Log.d(TAG, "getSoftWareVersion, return String " + softWareVersion);
        return softWareVersion;
    }

    @Deprecated
    public EnumScreenMute getTestPattern() {
        return EnumScreenMute.values()[getVideoTestPattern()];
    }

    public boolean getUARTToHDMI() {
        try {
            return getService().getUARTToHDMI();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean getUartOnOff() {
        try {
            return getService().getUartOnOff();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public UrsaVersionInfo getUrsaVersionInfo() {
        try {
            return getService().getUrsaVersionInfo();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public short getVdDspVersion() {
        short vdDspVersion;
        try {
            vdDspVersion = (short) getService().getVdDspVersion();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vdDspVersion = -1;
        }
        Log.d(TAG, "getVdDspVersion, return short " + ((int) vdDspVersion));
        return vdDspVersion;
    }

    public int getVideoMuteColor() {
        try {
            return getService().getVideoMuteColor();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return 0;
        }
    }

    public int getVideoTestPattern() {
        try {
            return getService().getTestPattern();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return -1;
        }
    }

    public short getVifAgcRef() {
        short vifAgcRef;
        try {
            vifAgcRef = (short) getService().getVifAgcRef();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifAgcRef = -1;
        }
        Log.d(TAG, "getVifAgcRef, return short " + ((int) vifAgcRef));
        return vifAgcRef;
    }

    public boolean getVifAsiaSignalOption() {
        try {
            return getService().getVifAsiaSignalOption();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public int getVifClampGainOvNegative() {
        int vifClampGainOvNegative;
        try {
            vifClampGainOvNegative = getService().getVifClampGainOvNegative();
        } catch (RemoteException e2) {
            e = e2;
            vifClampGainOvNegative = -1;
        }
        try {
            Log.d(TAG, "getVifClampGainOvNegative, return int " + vifClampGainOvNegative);
        } catch (RemoteException e3) {
            e = e3;
            e.printStackTrace();
        }
        return vifClampGainOvNegative;
    }

    public short getVifCrKi() {
        short vifCrKi;
        try {
            vifCrKi = (short) getService().getVifCrKi();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifCrKi = -1;
        }
        Log.d(TAG, "getVifCrKi, return short " + ((int) vifCrKi));
        return vifCrKi;
    }

    public short getVifCrKp() {
        short vifCrKp;
        try {
            vifCrKp = (short) getService().getVifCrKp();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifCrKp = -1;
        }
        Log.d(TAG, "getVifCrKp, return int " + ((int) vifCrKp));
        return vifCrKp;
    }

    public boolean getVifCrKpKiAdjust() {
        try {
            return getService().getVifCrKpKiAdjust();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public int getVifCrThreshold() {
        int vifCrThreshold;
        try {
            vifCrThreshold = getService().getVifCrThreshold();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifCrThreshold = -1;
        }
        Log.d(TAG, "getVifCrThreshold, return int " + vifCrThreshold);
        return vifCrThreshold;
    }

    public boolean getVifOverModulation() {
        try {
            return getService().getVifOverModulation();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public short getVifTop() {
        short vifTop;
        try {
            vifTop = (short) getService().getVifTop();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifTop = -1;
        }
        Log.d(TAG, "getVifTop, return short " + ((int) vifTop));
        return vifTop;
    }

    public short getVifVersion() {
        short vifVersion;
        try {
            vifVersion = (short) getService().getVifVersion();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifVersion = -1;
        }
        Log.d(TAG, "getVifVersion, return short " + ((int) vifVersion));
        return vifVersion;
    }

    public int getVifVgaMaximum() {
        int vifVgaMaximum;
        try {
            vifVgaMaximum = getService().getVifVgaMaximum();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            vifVgaMaximum = -1;
        }
        Log.d(TAG, "getVifVgaMaximum, return int " + vifVgaMaximum);
        return vifVgaMaximum;
    }

    public boolean getWatchDogMode() {
        try {
            return getService().getWatchDogMode();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public short getWbBlueGain() {
        short wbBlueGain;
        try {
            wbBlueGain = (short) getService().getWbBlueGain();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            wbBlueGain = -1;
        }
        Log.d(TAG, "getWbBlueGain, return short " + ((int) wbBlueGain));
        return wbBlueGain;
    }

    public short getWbBlueOffset() {
        short wbBlueOffset;
        try {
            wbBlueOffset = (short) getService().getWbBlueOffset();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            wbBlueOffset = -1;
        }
        Log.d(TAG, "getWbBlueOffset, return short " + ((int) wbBlueOffset));
        return wbBlueOffset;
    }

    public short getWbGreenGain() {
        short wbGreenGain;
        try {
            wbGreenGain = (short) getService().getWbGreenGain();
            try {
                Log.d(TAG, "getWbGreenGain, return short " + ((int) wbGreenGain));
            } catch (RemoteException e2) {
                e = e2;
                e.printStackTrace();
            }
        } catch (RemoteException e3) {
            e = e3;
            wbGreenGain = -1;
        }
        return wbGreenGain;
    }

    public short getWbGreenOffset() {
        short wbGreenOffset;
        try {
            wbGreenOffset = (short) getService().getWbGreenOffset();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            wbGreenOffset = -1;
        }
        Log.d(TAG, "getWbGreenOffset, return short " + ((int) wbGreenOffset));
        return wbGreenOffset;
    }

    public short getWbRedGain() {
        short wbRedGain;
        try {
            wbRedGain = (short) getService().getWbRedGain();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            wbRedGain = -1;
        }
        Log.d(TAG, "getWbRedGain, return short " + ((int) wbRedGain));
        return wbRedGain;
    }

    public short getWbRedOffset() {
        short wbRedOffset;
        try {
            wbRedOffset = (short) getService().getWbRedOffset();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            wbRedOffset = -1;
        }
        Log.d(TAG, "getWbRedOffset, return short " + ((int) wbRedOffset));
        return wbRedOffset;
    }

    public boolean isNoSignalAutoShutdownEnable() {
        boolean zIsNoSignalAutoShutdownEnable;
        try {
            zIsNoSignalAutoShutdownEnable = getService().isNoSignalAutoShutdownEnable();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            zIsNoSignalAutoShutdownEnable = false;
        }
        Log.d(TAG, "isNoSignalAutoShutdownEnable, return value = " + zIsNoSignalAutoShutdownEnable);
        return zIsNoSignalAutoShutdownEnable;
    }

    @Override // com.mstar.android.tv.IEventClient
    public boolean onEvent(Message message) throws RemoteException {
        EventHandler eventHandler = this.mHandler;
        if (eventHandler == null) {
            return true;
        }
        Message messageObtainMessage = eventHandler.obtainMessage();
        messageObtainMessage.copyFrom(message);
        this.mHandler.sendMessage(messageObtainMessage);
        return true;
    }

    public boolean registerOnFactoryProgramFinishedEventListener(OnFactoryProgramFinishedEventListener onFactoryProgramFinishedEventListener) {
        Log.d(TAG, "registerOnFactoryProgramFinishedEventListener");
        synchronized (this.mFactoryProgramFinishedListeners) {
            this.mFactoryProgramFinishedListeners.add(onFactoryProgramFinishedEventListener);
        }
        return true;
    }

    public void restoreFactoryAtvProgramTable(int i2) {
        Log.d(TAG, "restoreFactoryAtvProgramTable, cityIndex = " + i2);
        try {
            getService().restoreFactoryAtvProgramTable(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public void restoreFactoryDtvProgramTableByRoute(int i2, int i3) {
        Log.d(TAG, "restoreFactoryDtvProgramTableByRoute, cityIndex = " + i2 + ", dtvRouteMode = " + i3);
        try {
            getService().restoreFactoryDtvProgramTableByRoute(i2, i3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public boolean restoreToDefault() {
        try {
            return getService().restoreToDefault();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean set3DSelfAdaptiveLevel(int i2) {
        ITvFactory service = getService();
        Log.d(TAG, "set3DSelfAdaptiveLevel, paras threeDSelfAdaptiveLevel = " + i2);
        try {
            return service.set3DSelfAdaptiveLevel(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAcPowerOnMode(int i2) {
        Log.d(TAG, "setAcPowerOnMode, powerOnMode = " + i2);
        try {
            return getService().setPowerOnMode(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAdcBlueGain(int i2) {
        Log.d(TAG, "setAdcBlueGain, paras blueGain = " + i2);
        try {
            getService().setAdcBlueGain(i2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAdcBlueOffset(int i2) {
        Log.d(TAG, "setAdcBlueOffset, paras blueOffset = " + i2);
        try {
            getService().setAdcBlueOffset(i2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAdcGreenGain(int i2) {
        Log.d(TAG, "setAdcGreenGain, paras greenGain = " + i2);
        try {
            getService().setAdcGreenGain(i2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAdcGreenOffset(int i2) {
        Log.d(TAG, "setAdcGreenOffset, paras greenOffset = " + i2);
        try {
            getService().setAdcGreenOffset(i2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean setAdcIndex(EnumAdcSetIndexType enumAdcSetIndexType) {
        return setFactoryAdcIndex(enumAdcSetIndexType.ordinal());
    }

    public boolean setAdcPhase(int i2) {
        Log.d(TAG, "setAdcPhase, return int " + i2);
        try {
            getService().setAdcPhase(i2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAdcRedGain(int i2) {
        Log.d(TAG, "setAdcRedGain, paras redGain = " + i2);
        try {
            getService().setAdcRedGain(i2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAdcRedOffset(int i2) {
        Log.d(TAG, "setAdcRedOffset, paras redOffset = " + i2);
        try {
            getService().setAdcRedOffset(i2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefc43(short s2) {
        Log.d(TAG, "setAefc43, paras aefc43 = " + ((int) s2));
        try {
            return getService().setAefc43(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefc44(short s2) {
        Log.d(TAG, "setAefc44, paras aefc44 = " + ((int) s2));
        try {
            return getService().setAefc44(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefc66Bit76(short s2) {
        Log.d(TAG, "setAefc66Bit76, paras aefc66Bit76 = " + ((int) s2));
        try {
            return getService().setAefc66Bit76(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefc6EBit3210(short s2) {
        Log.d(TAG, "setAefc6EBit3210, paras aefc6EBit3210 = " + ((int) s2));
        try {
            return getService().setAefc6EBit3210(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefc6EBit7654(short s2) {
        Log.d(TAG, "setAefc6EBit7654, paras aefc6EBit7654 = " + ((int) s2));
        try {
            return getService().setAefc6EBit7654(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcA0(short s2) {
        Log.d(TAG, "setAefcA0, paras aefcA0 = " + ((int) s2));
        try {
            return getService().setAefcA0(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcA1(short s2) {
        Log.d(TAG, "setAefcA1, paras aefcA1 = " + ((int) s2));
        try {
            return getService().setAefcA1(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcCB(short s2) {
        Log.d(TAG, "setAefcCB, paras aefcCB = " + ((int) s2));
        try {
            return getService().setAefcCB(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcCfBit2Atv(short s2) {
        Log.d(TAG, "setAefcCfBit2Atv, paras aefcCfBit2Atv = " + ((int) s2));
        try {
            return getService().setAefcCfBit2Atv(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcCfBit2Av(short s2) {
        Log.d(TAG, "setAefcCfBit2Av, paras aefcCfBit2Av = " + ((int) s2));
        try {
            return getService().setAefcCfBit2Av(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcD4(short s2) {
        Log.d(TAG, "setAefcD4, paras aefcD4 = " + ((int) s2));
        try {
            return getService().setAefcD4(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcD5Bit2(short s2) {
        Log.d(TAG, "setAefcD5Bit2, paras aefcD5Bit2 = " + ((int) s2));
        try {
            return getService().setAefcD5Bit2(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcD7HighBound(short s2) {
        Log.d(TAG, "setAefcD7HighBound, paras aefcD7HighBound = " + ((int) s2));
        try {
            return getService().setAefcD7HighBound(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcD7LowBound(short s2) {
        Log.d(TAG, "setAefcD7LowBound, paras aefcD7LowBound = " + ((int) s2));
        try {
            return getService().setAefcD7LowBound(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcD8Bit3210(short s2) {
        Log.d(TAG, "setAefcD8Bit3210, paras aefcD8Bit3210 = " + ((int) s2));
        try {
            return getService().setAefcD8Bit3210(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAefcD9Bit0(short s2) {
        Log.d(TAG, "setAefcD9Bit0, paras aefcD9Bit0 = " + ((int) s2));
        try {
            return getService().setAefcD9Bit0(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAudioDspVersion(short s2) {
        Log.d(TAG, "setAudioDspVersion, paras aduioDspVersion = " + ((int) s2));
        try {
            return getService().setAudioDspVersion(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAudioHiDevMode(int i2) {
        Log.d(TAG, "setAudioHiDevMode, paras audioHiDevMode = " + i2);
        try {
            return getService().setAudioHiDevMode(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAudioNrThreshold(short s2) {
        Log.d(TAG, "setAudioNrThreshold, paras audioNrThreshold = " + ((int) s2));
        try {
            return getService().setAudioNrThreshold(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean setAudioPrescale(short s2) {
        Log.d(TAG, "setAudioPrescale, paras audioPrescaleVal = " + ((int) s2));
        try {
            return getService().setAudioPrescale(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setAudioSifThreshold(short s2) {
        Log.d(TAG, "setAudioSifThreshold, paras audioSifThreshold = " + ((int) s2));
        try {
            return getService().setAudioSifThreshold(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setChinaDescramblerBox(short s2) {
        Log.d(TAG, "setChinaDescramblerBox, paras chinaDescramblerBox = " + ((int) s2));
        try {
            return getService().setChinaDescramblerBox(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setChinaDescramblerBoxDelay(int i2) {
        Log.d(TAG, "setChinaDescramblerBoxDelay, paras chinaDescramblerBoxDelay = " + i2);
        try {
            return getService().setChinaDescramblerBoxDelay(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean setCurveType(EnumNlaSetIndex enumNlaSetIndex) {
        Log.d(TAG, "setCurveType, paras curveTypeIndex = " + enumNlaSetIndex);
        return setNlaCurveType(enumNlaSetIndex.ordinal());
    }

    public boolean setDelayReduce(short s2) {
        Log.d(TAG, "setDelayReduce, paras delayReduce = " + ((int) s2));
        try {
            return getService().setDelayReduce(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setDtvAvAbnormalDelay(boolean z2) {
        Log.d(TAG, "setDtvAvAbnormalDelay, paras isEnable = " + z2);
        try {
            return getService().setDtvAvAbnormalDelay(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setEnvironment(String str, String str2) {
        Log.d(TAG, "setEnvironment, paras name = " + str);
        try {
            return getService().setEnvironment(str, str2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean setEnvironmentPowerOnLogoMode(EnumPowerOnLogoMode enumPowerOnLogoMode) {
        Log.d(TAG, "setEnvironmentPowerOnLogoMode, paras EnumPowerOnLogoMode = " + enumPowerOnLogoMode);
        return setPowerOnLogoMode(enumPowerOnLogoMode.ordinal());
    }

    @Deprecated
    public boolean setEnvironmentPowerOnMusicMode(EnumPowerOnMusicMode enumPowerOnMusicMode) {
        Log.d(TAG, "setEnvironmentPowerOnMusicMode, paras eMusicMode = " + enumPowerOnMusicMode);
        return setPowerOnMusicMode(enumPowerOnMusicMode.ordinal());
    }

    public boolean setEnvironmentPowerOnMusicVolume(int i2) {
        Log.d(TAG, "setEnvironmentPowerOnMusicVolume, paras valume = " + i2);
        try {
            return getService().setEnvironmentPowerOnMusicVolume(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setFactoryAdcIndex(int i2) {
        Log.d(TAG, "setFactoryAdcIndex, index = " + i2);
        try {
            return getService().setAdcIndex(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setFactoryPreSetFeature(int i2) {
        Log.d(TAG, "setFactoryPreSetFeature, paras factoryPreset = " + i2);
        try {
            return getService().setFactoryPreSetFeature(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setGainDistributionThreshold(int i2) {
        Log.d(TAG, "setGainDistributionThreshold, paras gainDistributionThreshold = " + i2);
        try {
            return getService().setGainDistributionThreshold(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setLvdsEnable(boolean z2) {
        Log.d(TAG, "setLvdsEnable, paras lvdsSscEnable = " + z2);
        try {
            return getService().setLvdsEnable(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setLvdsModulation(int i2) {
        Log.d(TAG, "setLvdsModulation, paras lvdsSscSpan = " + i2);
        try {
            return getService().setLvdsModulation(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setLvdsPercentage(int i2) {
        Log.d(TAG, "setLvdsPercentage, paras lvdsSscStep = " + i2);
        try {
            return getService().setLvdsPercentage(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setMiuEnable(boolean z2) {
        Log.d(TAG, "setMiuEnable, paras miuSscEnable = " + z2);
        try {
            return getService().setMiuEnable(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setMiuModulation(int i2) {
        Log.d(TAG, "setMiuModulation, paras miuSscSpan = " + i2);
        try {
            return getService().setMiuModulation(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setMiuPercentage(int i2) {
        Log.d(TAG, "setMiuPercentage, paras miuSscStep = " + i2);
        try {
            return getService().setMiuPercentage(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setNlaCurveType(int i2) {
        Log.d(TAG, "setNlaCurveType, curveType = " + i2);
        try {
            return getService().setCurveType(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setNoSignalAutoShutdown(boolean z2) {
        Log.d(TAG, "setNoSignalAutoShutdown, isEnable = " + z2);
        try {
            return getService().setNoSignalAutoShutdown(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return true;
        }
    }

    public boolean setOsdV0Nonlinear(short s2) {
        Log.d(TAG, "setOsdV0Nonlinear, paras nonlinearVal = " + ((int) s2));
        try {
            return getService().setOsdV0Nonlinear(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOsdV100Nonlinear(short s2) {
        Log.d(TAG, "setOsdV100Nonlinear, paras nonlinearVal = " + ((int) s2));
        try {
            return getService().setOsdV100Nonlinear(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOsdV25Nonlinear(short s2) {
        Log.d(TAG, "setOsdV25Nonlinear, paras nonlinearVal = " + ((int) s2));
        try {
            return getService().setOsdV25Nonlinear(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOsdV50Nonlinear(short s2) {
        Log.d(TAG, "setOsdV50Nonlinear, paras nonlinearVal = " + ((int) s2));
        try {
            return getService().setOsdV50Nonlinear(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOsdV75Nonlinear(short s2) {
        Log.d(TAG, "setOsdV75Nonlinear, paras nonlinearVal = " + ((int) s2));
        try {
            return getService().setOsdV75Nonlinear(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOverScanHPosition(short s2) {
        ITvFactory service = getService();
        Log.d(TAG, "setOverScanHPosition, paras hPosition = " + ((int) s2));
        try {
            return service.setOverScanHPosition(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOverScanHSize(short s2) {
        Log.d(TAG, "setOverScanHSize, paras hSize = " + ((int) s2));
        try {
            return getService().setOverScanHSize(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOverScanInputSource(int i2) {
        Log.d(TAG, "setOverScanInputSource, inputSource = " + i2);
        try {
            return getService().setOverScanSourceType(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean setOverScanSourceType(TvOsType.EnumInputSource enumInputSource) {
        Log.d(TAG, "setOverScanSourceType, paras SourceType = " + enumInputSource);
        return setOverScanInputSource(enumInputSource.ordinal());
    }

    public boolean setOverScanVPosition(short s2) {
        Log.d(TAG, "setOverScanVPosition, paras vPosition = " + ((int) s2));
        try {
            return getService().setOverScanVPosition(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setOverScanVSize(short s2) {
        ITvFactory service = getService();
        Log.d(TAG, "setOverScanVSize, paras vSize = " + ((int) s2));
        try {
            return service.setOverScanVSize(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPanelSwing(short s2) {
        Log.d(TAG, "setPanelSwing, paras panleSwingVal = " + ((int) s2));
        try {
            return getService().setPanelSwing(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPeqEnable(int i2, int i3) {
        Log.d(TAG, "setPeqEnable, paras PeqEnable = " + i3);
        try {
            return getService().setPeqEnable(i2, i3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPeqFoCoarse(int i2, int i3) {
        Log.d(TAG, "setPeqFoCoarse, paras coarseVal = " + i3);
        try {
            return getService().setPeqFoCoarse(i2, i3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPeqFoFine(int i2, int i3) {
        Log.d(TAG, "setPeqFoFine, paras fineVal = " + i3);
        try {
            return getService().setPeqFoFine(i2, i3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPeqGain(int i2, int i3) {
        Log.d(TAG, "setPeqGain, paras gainVal = " + i3);
        try {
            return getService().setPeqGain(i2, i3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPeqQ(int i2, int i3) {
        Log.d(TAG, "setPeqQ, paras QValue = " + i3);
        try {
            return getService().setPeqQ(i2, i3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPowerOnLogoMode(int i2) {
        Log.d(TAG, "setPowerOnLogoMode, logoMode = " + i2);
        try {
            return getService().setEnvironmentPowerOnLogoMode(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean setPowerOnMode(EnumAcOnPowerOnMode enumAcOnPowerOnMode) {
        Log.d(TAG, "setPowerOnMode, paras factoryPowerMode = " + enumAcOnPowerOnMode);
        return setAcPowerOnMode(enumAcOnPowerOnMode.ordinal());
    }

    public boolean setPowerOnMusicMode(int i2) {
        Log.d(TAG, "setPowerOnMusicMode, musicMode = " + i2);
        try {
            return getService().setEnvironmentPowerOnMusicMode(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setPvrRecordAll(boolean z2) {
        Log.d(TAG, "setPvrRecordAll, paras boolean = " + z2);
        try {
            return getService().setPvrRecordAll(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @Deprecated
    public boolean setTestPattern(EnumScreenMute enumScreenMute) {
        Log.d(TAG, "setTestPattern, paras testPatternMode = " + enumScreenMute);
        return setVideoTestPattern(enumScreenMute.ordinal());
    }

    public void setUARTToHDMI(boolean z2) {
        try {
            getService().setUARTToHDMI(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public boolean setUartOnOff(boolean z2) {
        Log.d(TAG, "setUartOnOff, paras isEnable = " + z2);
        try {
            return getService().setUartOnOff(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVdDspVersion(short s2) {
        Log.d(TAG, "setVdDspVersion, paras vdDspVersion = " + ((int) s2));
        try {
            return getService().setVdDspVersion(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVideoMuteColor(int i2) {
        try {
            return getService().setVideoMuteColor(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVideoTestPattern(int i2) {
        Log.d(TAG, "setVideoTestPattern, testPatternMode = " + i2);
        try {
            return getService().setTestPattern(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifAgcRef(short s2) {
        Log.d(TAG, "setVifAgcRef, paras vifAgcRef = " + ((int) s2));
        try {
            return getService().setVifAgcRef(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifAsiaSignalOption(boolean z2) {
        Log.d(TAG, "setVifAsiaSignalOption, paras vifAsiaSignalOption = " + z2);
        try {
            return getService().setVifAsiaSignalOption(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifClampGainOvNegative(int i2) {
        Log.d(TAG, "setVifClampGainOvNegative, paras vifClampGainOvNegative = " + i2);
        try {
            return getService().setVifClampGainOvNegative(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifCrKi(short s2) {
        Log.d(TAG, "setVifCrKi, paras vifCrKi = " + ((int) s2));
        try {
            return getService().setVifCrKi(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifCrKp(short s2) {
        Log.d(TAG, "setVifCrKp, paras vifCrKp = " + ((int) s2));
        try {
            return getService().setVifCrKp(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifCrKpKiAdjust(boolean z2) {
        Log.d(TAG, "setVifCrKpKiAdjust, paras vifCrKpKiAdjust = " + z2);
        try {
            return getService().setVifCrKpKiAdjust(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifCrThreshold(int i2) {
        Log.d(TAG, "setVifCrThreshold, paras vifCrThreshold = " + i2);
        try {
            return getService().setVifCrThreshold(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifOverModulation(boolean z2) {
        Log.d(TAG, "setVifOverModulation, paras vifOverModulation = " + z2);
        try {
            return getService().setVifOverModulation(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifTop(short s2) {
        Log.d(TAG, "setVifTop, paras vifTop = " + ((int) s2));
        try {
            return getService().setVifTop(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifVersion(short s2) {
        Log.d(TAG, "setVifVersion, paras vifVersion = " + ((int) s2));
        try {
            return getService().setVifVersion(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setVifVgaMaximum(int i2) {
        Log.d(TAG, "setVifVgaMaximum, paras vifVgaMaximum = " + i2);
        try {
            return getService().setVifVgaMaximum(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setWatchDogMode(boolean z2) {
        Log.d(TAG, "setWatchDogMode, paras isEnable = " + z2);
        try {
            return getService().setWatchDogMode(z2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setWbBlueGain(short s2) {
        Log.d(TAG, "setWbBlueGain, paras blueGain = " + ((int) s2));
        try {
            return getService().setWbBlueGain(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setWbBlueOffset(short s2) {
        Log.d(TAG, "setWbBlueOffset, paras blueOffset = " + ((int) s2));
        try {
            return getService().setWbBlueOffset(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setWbGreenGain(short s2) {
        Log.d(TAG, "setWbGreenGain, paras greenGain = " + ((int) s2));
        try {
            return getService().setWbGreenGain(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setWbGreenOffset(short s2) {
        Log.d(TAG, "setWbGreenOffset, paras greenOffset = " + ((int) s2));
        try {
            return getService().setWbGreenOffset(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setWbRedGain(short s2) {
        Log.d(TAG, "setWbRedGain, paras redGain = " + ((int) s2));
        try {
            getService().setWbRedGain(s2);
            return false;
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean setWbRedOffset(short s2) {
        Log.d(TAG, "setWbRedOffset, paras redOffset = " + ((int) s2));
        try {
            return getService().setWbRedOffset(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public boolean unregisterOnFactoryProgramFinishedEventListener(OnFactoryProgramFinishedEventListener onFactoryProgramFinishedEventListener) {
        Log.d(TAG, "unregisterOnFactoryProgramFinishedEventListener");
        synchronized (this.mFactoryProgramFinishedListeners) {
            this.mFactoryProgramFinishedListeners.remove(onFactoryProgramFinishedEventListener);
            Log.d(TAG, "unregisterOnFactoryProgramFinishedEventListener  size: " + this.mFactoryProgramFinishedListeners.size());
        }
        return true;
    }

    public boolean setAudioPrescale(int i2) {
        Log.d(TAG, "setAudioPrescale, paras audioPrescaleVal = " + i2);
        try {
            return getService().setAudioPrescale(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }
}