package com.cvte.tv.api;

import a.b.c.a.a;
import android.content.Context;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.KeyEvent;
import com.cvte.tv.api.aidl.EnumResetLevel;
import com.cvte.tv.api.aidl.INotifyGlobalKeyListener;
import com.cvte.tv.api.aidl.INotifyListener;
import com.cvte.tv.api.aidl.ITVApiAnalogCloseCaptionAidl;
import com.cvte.tv.api.aidl.ITVApiAtvAfcAidl;
import com.cvte.tv.api.aidl.ITVApiAtvNicamMtsAidl;
import com.cvte.tv.api.aidl.ITVApiAtvNicamMtsPreferenceAidl;
import com.cvte.tv.api.aidl.ITVApiAudioSourceAidl;
import com.cvte.tv.api.aidl.ITVApiBluetoothAidl;
import com.cvte.tv.api.aidl.ITVApiCloseCaptionStyleAidl;
import com.cvte.tv.api.aidl.ITVApiDPModeAidl;
import com.cvte.tv.api.aidl.ITVApiDataImportsAndExportsAidl;
import com.cvte.tv.api.aidl.ITVApiDigitalCloseCaptionAidl;
import com.cvte.tv.api.aidl.ITVApiDtvAudioDescriptionAidl;
import com.cvte.tv.api.aidl.ITVApiDtvAudioLanguageAidl;
import com.cvte.tv.api.aidl.ITVApiDtvAudioLanguagePreferenceAidl;
import com.cvte.tv.api.aidl.ITVApiDtvCiInformationAidl;
import com.cvte.tv.api.aidl.ITVApiDtvCiPlusOpProfileAidl;
import com.cvte.tv.api.aidl.ITVApiDtvEpgAidl;
import com.cvte.tv.api.aidl.ITVApiDtvHearingImpairedAidl;
import com.cvte.tv.api.aidl.ITVApiDtvSubtitleAidl;
import com.cvte.tv.api.aidl.ITVApiDtvSubtitlePreferenceAidl;
import com.cvte.tv.api.aidl.ITVApiDvbsBissAidl;
import com.cvte.tv.api.aidl.ITVApiDvbsMotorManagerAidl;
import com.cvte.tv.api.aidl.ITVApiDvbsSatelliteManagerAidl;
import com.cvte.tv.api.aidl.ITVApiDvbsTransponderManagerAidl;
import com.cvte.tv.api.aidl.ITVApiFactoryAutoTestAidl;
import com.cvte.tv.api.aidl.ITVApiFactoryHdmiEdidModeAidl;
import com.cvte.tv.api.aidl.ITVApiHDMIOUTAidl;
import com.cvte.tv.api.aidl.ITVApiI2cAidl;
import com.cvte.tv.api.aidl.ITVApiIsdbEwbsAidl;
import com.cvte.tv.api.aidl.ITVApiMHLAidl;
import com.cvte.tv.api.aidl.ITVApiOADAidl;
import com.cvte.tv.api.aidl.ITVApiPictureAdcAidl;
import com.cvte.tv.api.aidl.ITVApiPictureAdvanceAdjustAidl;
import com.cvte.tv.api.aidl.ITVApiPictureColorCorrectionAidl;
import com.cvte.tv.api.aidl.ITVApiPictureColorEnhanceAidl;
import com.cvte.tv.api.aidl.ITVApiPictureColorTempAidl;
import com.cvte.tv.api.aidl.ITVApiPictureControlAidl;
import com.cvte.tv.api.aidl.ITVApiPictureDbcAidl;
import com.cvte.tv.api.aidl.ITVApiPictureDlcAidl;
import com.cvte.tv.api.aidl.ITVApiPictureEcoModeAidl;
import com.cvte.tv.api.aidl.ITVApiPictureGammaAidl;
import com.cvte.tv.api.aidl.ITVApiPictureHdmiVideoPcModeAidl;
import com.cvte.tv.api.aidl.ITVApiPictureHdrAidl;
import com.cvte.tv.api.aidl.ITVApiPictureMpegNrAidl;
import com.cvte.tv.api.aidl.ITVApiPictureNrAidl;
import com.cvte.tv.api.aidl.ITVApiScreen2DTo3DAidl;
import com.cvte.tv.api.aidl.ITVApiScreen3DGeneralAidl;
import com.cvte.tv.api.aidl.ITVApiScreen3DTo2DAidl;
import com.cvte.tv.api.aidl.ITVApiScreenAspectAidl;
import com.cvte.tv.api.aidl.ITVApiScreenCaptureAidl;
import com.cvte.tv.api.aidl.ITVApiScreenCropAidl;
import com.cvte.tv.api.aidl.ITVApiScreenFreezeAidl;
import com.cvte.tv.api.aidl.ITVApiScreenKeystoneAidl;
import com.cvte.tv.api.aidl.ITVApiScreenMemcAidl;
import com.cvte.tv.api.aidl.ITVApiScreenMirrorAidl;
import com.cvte.tv.api.aidl.ITVApiScreenWindowAidl;
import com.cvte.tv.api.aidl.ITVApiSerialControlAidl;
import com.cvte.tv.api.aidl.ITVApiSoundAndroidAidl;
import com.cvte.tv.api.aidl.ITVApiSoundArcAidl;
import com.cvte.tv.api.aidl.ITVApiSoundAvlAidl;
import com.cvte.tv.api.aidl.ITVApiSoundDbxAidl;
import com.cvte.tv.api.aidl.ITVApiSoundEqAidl;
import com.cvte.tv.api.aidl.ITVApiSoundHDMIAidl;
import com.cvte.tv.api.aidl.ITVApiSoundHeadSetOutAidl;
import com.cvte.tv.api.aidl.ITVApiSoundLineOutAidl;
import com.cvte.tv.api.aidl.ITVApiSoundMicAidl;
import com.cvte.tv.api.aidl.ITVApiSoundPowerLimitControlAidl;
import com.cvte.tv.api.aidl.ITVApiSoundPreScaleAidl;
import com.cvte.tv.api.aidl.ITVApiSoundSpdifOutAidl;
import com.cvte.tv.api.aidl.ITVApiSoundSpeakerOutAidl;
import com.cvte.tv.api.aidl.ITVApiSoundSrsAidl;
import com.cvte.tv.api.aidl.ITVApiSoundSurroundAidl;
import com.cvte.tv.api.aidl.ITVApiSoundWirelessMicAidl;
import com.cvte.tv.api.aidl.ITVApiSystemAgingAidl;
import com.cvte.tv.api.aidl.ITVApiSystemBacklightAidl;
import com.cvte.tv.api.aidl.ITVApiSystemBlueScreenAidl;
import com.cvte.tv.api.aidl.ITVApiSystemBoardSnAidl;
import com.cvte.tv.api.aidl.ITVApiSystemBurningKeyAidl;
import com.cvte.tv.api.aidl.ITVApiSystemCecAidl;
import com.cvte.tv.api.aidl.ITVApiSystemCiPlusAidl;
import com.cvte.tv.api.aidl.ITVApiSystemCountryAidl;
import com.cvte.tv.api.aidl.ITVApiSystemDateTimeAidl;
import com.cvte.tv.api.aidl.ITVApiSystemDebugAidl;
import com.cvte.tv.api.aidl.ITVApiSystemEwsAidl;
import com.cvte.tv.api.aidl.ITVApiSystemFactoryDataAidl;
import com.cvte.tv.api.aidl.ITVApiSystemHdcp1xKeyAidl;
import com.cvte.tv.api.aidl.ITVApiSystemHdcp2xKeyAidl;
import com.cvte.tv.api.aidl.ITVApiSystemHdcpTXKeyAidl;
import com.cvte.tv.api.aidl.ITVApiSystemInformationAidl;
import com.cvte.tv.api.aidl.ITVApiSystemInputSourceAidl;
import com.cvte.tv.api.aidl.ITVApiSystemKeyPadAidl;
import com.cvte.tv.api.aidl.ITVApiSystemLedLightAidl;
import com.cvte.tv.api.aidl.ITVApiSystemLockAidl;
import com.cvte.tv.api.aidl.ITVApiSystemLvdsAidl;
import com.cvte.tv.api.aidl.ITVApiSystemLvdsFrcAidl;
import com.cvte.tv.api.aidl.ITVApiSystemLvdsFrcAlpdAidl;
import com.cvte.tv.api.aidl.ITVApiSystemMacAidl;
import com.cvte.tv.api.aidl.ITVApiSystemMiuAidl;
import com.cvte.tv.api.aidl.ITVApiSystemNetworkUpgradeAidl;
import com.cvte.tv.api.aidl.ITVApiSystemNoActionAutoPowerOffAidl;
import com.cvte.tv.api.aidl.ITVApiSystemOadUpgradeAidl;
import com.cvte.tv.api.aidl.ITVApiSystemOnOffTimeAidl;
import com.cvte.tv.api.aidl.ITVApiSystemOsdLanguageAidl;
import com.cvte.tv.api.aidl.ITVApiSystemParentalControlAidl;
import com.cvte.tv.api.aidl.ITVApiSystemProductModelAidl;
import com.cvte.tv.api.aidl.ITVApiSystemPropertiesAidl;
import com.cvte.tv.api.aidl.ITVApiSystemRemoteControlAidl;
import com.cvte.tv.api.aidl.ITVApiSystemSignalAidl;
import com.cvte.tv.api.aidl.ITVApiSystemSleepTimeAidl;
import com.cvte.tv.api.aidl.ITVApiTvAntennaTypeAidl;
import com.cvte.tv.api.aidl.ITVApiTvAtscAidl;
import com.cvte.tv.api.aidl.ITVApiTvAtscFrontEndAidl;
import com.cvte.tv.api.aidl.ITVApiTvAtvAidl;
import com.cvte.tv.api.aidl.ITVApiTvChannelEditChNameAidl;
import com.cvte.tv.api.aidl.ITVApiTvChannelFavoriteAidl;
import com.cvte.tv.api.aidl.ITVApiTvChannelLockAidl;
import com.cvte.tv.api.aidl.ITVApiTvChannelMoveSwapSkipDeleteAidl;
import com.cvte.tv.api.aidl.ITVApiTvChannelsAidl;
import com.cvte.tv.api.aidl.ITVApiTvDtmbAidl;
import com.cvte.tv.api.aidl.ITVApiTvDtmbFrontEndAidl;
import com.cvte.tv.api.aidl.ITVApiTvDvbcAidl;
import com.cvte.tv.api.aidl.ITVApiTvDvbcFrontEndAidl;
import com.cvte.tv.api.aidl.ITVApiTvDvbsAidl;
import com.cvte.tv.api.aidl.ITVApiTvDvbsFrontEndAidl;
import com.cvte.tv.api.aidl.ITVApiTvDvbtAidl;
import com.cvte.tv.api.aidl.ITVApiTvDvbtFrontEndAidl;
import com.cvte.tv.api.aidl.ITVApiTvFrontEndAidl;
import com.cvte.tv.api.aidl.ITVApiTvIsdbAidl;
import com.cvte.tv.api.aidl.ITVApiTvIsdbFrontEndAidl;
import com.cvte.tv.api.aidl.ITVApiTvIsdbGingaAidl;
import com.cvte.tv.api.aidl.ITVApiTvLcnAidl;
import com.cvte.tv.api.aidl.ITVApiTvMHEG5Aidl;
import com.cvte.tv.api.aidl.ITVApiTvPlaceModeAidl;
import com.cvte.tv.api.aidl.ITVApiTvPvrAidl;
import com.cvte.tv.api.aidl.ITVApiTvSurfaceHolderAidl;
import com.cvte.tv.api.aidl.ITVApiTvSystemHotelModeAidl;
import com.cvte.tv.api.aidl.ITVApiTvTeletextAidl;
import com.cvte.tv.api.aidl.ITVApiUsbAidl;
import com.cvte.tv.api.aidl.ITVApiVChipCanadaRatingAidl;
import com.cvte.tv.api.aidl.ITVApiVChipNoRatingLockAidl;
import com.cvte.tv.api.aidl.ITVApiVChipRRT5Aidl;
import com.cvte.tv.api.aidl.ITVApiVChipUSRatingAidl;
import com.cvte.tv.api.aidl.ITVApiWifiAidl;
import com.cvte.tv.api.aidl.ITvApiManager;
import com.cvte.tv.api.functions.ITVApiAnalogCloseCaption;
import com.cvte.tv.api.functions.ITVApiAtvAfc;
import com.cvte.tv.api.functions.ITVApiAtvNicamMts;
import com.cvte.tv.api.functions.ITVApiAtvNicamMtsPreference;
import com.cvte.tv.api.functions.ITVApiAudioSource;
import com.cvte.tv.api.functions.ITVApiBluetooth;
import com.cvte.tv.api.functions.ITVApiCloseCaptionStyle;
import com.cvte.tv.api.functions.ITVApiDPMode;
import com.cvte.tv.api.functions.ITVApiDataImportsAndExports;
import com.cvte.tv.api.functions.ITVApiDigitalCloseCaption;
import com.cvte.tv.api.functions.ITVApiDtvAudioDescription;
import com.cvte.tv.api.functions.ITVApiDtvAudioLanguage;
import com.cvte.tv.api.functions.ITVApiDtvAudioLanguagePreference;
import com.cvte.tv.api.functions.ITVApiDtvCiInformation;
import com.cvte.tv.api.functions.ITVApiDtvCiPlusOpProfile;
import com.cvte.tv.api.functions.ITVApiDtvEpg;
import com.cvte.tv.api.functions.ITVApiDtvHearingImpaired;
import com.cvte.tv.api.functions.ITVApiDtvSubtitle;
import com.cvte.tv.api.functions.ITVApiDtvSubtitlePreference;
import com.cvte.tv.api.functions.ITVApiDvbsBiss;
import com.cvte.tv.api.functions.ITVApiDvbsMotorManager;
import com.cvte.tv.api.functions.ITVApiDvbsSatelliteManager;
import com.cvte.tv.api.functions.ITVApiDvbsTransponderManager;
import com.cvte.tv.api.functions.ITVApiFactoryAutoTest;
import com.cvte.tv.api.functions.ITVApiFactoryHdmiEdidMode;
import com.cvte.tv.api.functions.ITVApiHDMIOUT;
import com.cvte.tv.api.functions.ITVApiI2c;
import com.cvte.tv.api.functions.ITVApiIsdbEwbs;
import com.cvte.tv.api.functions.ITVApiMHL;
import com.cvte.tv.api.functions.ITVApiOAD;
import com.cvte.tv.api.functions.ITVApiPictureAdc;
import com.cvte.tv.api.functions.ITVApiPictureAdvanceAdjust;
import com.cvte.tv.api.functions.ITVApiPictureColorCorrection;
import com.cvte.tv.api.functions.ITVApiPictureColorEnhance;
import com.cvte.tv.api.functions.ITVApiPictureColorTemp;
import com.cvte.tv.api.functions.ITVApiPictureControl;
import com.cvte.tv.api.functions.ITVApiPictureDbc;
import com.cvte.tv.api.functions.ITVApiPictureDlc;
import com.cvte.tv.api.functions.ITVApiPictureEcoMode;
import com.cvte.tv.api.functions.ITVApiPictureGamma;
import com.cvte.tv.api.functions.ITVApiPictureHdmiVideoPcMode;
import com.cvte.tv.api.functions.ITVApiPictureHdr;
import com.cvte.tv.api.functions.ITVApiPictureMpegNr;
import com.cvte.tv.api.functions.ITVApiPictureNr;
import com.cvte.tv.api.functions.ITVApiScreen2DTo3D;
import com.cvte.tv.api.functions.ITVApiScreen3DGeneral;
import com.cvte.tv.api.functions.ITVApiScreen3DTo2D;
import com.cvte.tv.api.functions.ITVApiScreenAspect;
import com.cvte.tv.api.functions.ITVApiScreenCapture;
import com.cvte.tv.api.functions.ITVApiScreenCrop;
import com.cvte.tv.api.functions.ITVApiScreenFreeze;
import com.cvte.tv.api.functions.ITVApiScreenKeystone;
import com.cvte.tv.api.functions.ITVApiScreenMemc;
import com.cvte.tv.api.functions.ITVApiScreenMirror;
import com.cvte.tv.api.functions.ITVApiScreenWindow;
import com.cvte.tv.api.functions.ITVApiSerialControl;
import com.cvte.tv.api.functions.ITVApiSoundAndroid;
import com.cvte.tv.api.functions.ITVApiSoundArc;
import com.cvte.tv.api.functions.ITVApiSoundAvl;
import com.cvte.tv.api.functions.ITVApiSoundDbx;
import com.cvte.tv.api.functions.ITVApiSoundEq;
import com.cvte.tv.api.functions.ITVApiSoundHDMI;
import com.cvte.tv.api.functions.ITVApiSoundHeadSetOut;
import com.cvte.tv.api.functions.ITVApiSoundLineOut;
import com.cvte.tv.api.functions.ITVApiSoundMic;
import com.cvte.tv.api.functions.ITVApiSoundPowerLimitControl;
import com.cvte.tv.api.functions.ITVApiSoundPreScale;
import com.cvte.tv.api.functions.ITVApiSoundSpdifOut;
import com.cvte.tv.api.functions.ITVApiSoundSpeakerOut;
import com.cvte.tv.api.functions.ITVApiSoundSrs;
import com.cvte.tv.api.functions.ITVApiSoundSurround;
import com.cvte.tv.api.functions.ITVApiSoundWirelessMic;
import com.cvte.tv.api.functions.ITVApiSystemAging;
import com.cvte.tv.api.functions.ITVApiSystemBacklight;
import com.cvte.tv.api.functions.ITVApiSystemBlueScreen;
import com.cvte.tv.api.functions.ITVApiSystemBoardSn;
import com.cvte.tv.api.functions.ITVApiSystemBurningKey;
import com.cvte.tv.api.functions.ITVApiSystemCec;
import com.cvte.tv.api.functions.ITVApiSystemCiPlus;
import com.cvte.tv.api.functions.ITVApiSystemCountry;
import com.cvte.tv.api.functions.ITVApiSystemDateTime;
import com.cvte.tv.api.functions.ITVApiSystemDebug;
import com.cvte.tv.api.functions.ITVApiSystemEws;
import com.cvte.tv.api.functions.ITVApiSystemFactoryData;
import com.cvte.tv.api.functions.ITVApiSystemHdcp1xKey;
import com.cvte.tv.api.functions.ITVApiSystemHdcp2xKey;
import com.cvte.tv.api.functions.ITVApiSystemHdcpTXKey;
import com.cvte.tv.api.functions.ITVApiSystemInformation;
import com.cvte.tv.api.functions.ITVApiSystemInputSource;
import com.cvte.tv.api.functions.ITVApiSystemKeyPad;
import com.cvte.tv.api.functions.ITVApiSystemLedLight;
import com.cvte.tv.api.functions.ITVApiSystemLock;
import com.cvte.tv.api.functions.ITVApiSystemLvds;
import com.cvte.tv.api.functions.ITVApiSystemLvdsFrc;
import com.cvte.tv.api.functions.ITVApiSystemLvdsFrcAlpd;
import com.cvte.tv.api.functions.ITVApiSystemMac;
import com.cvte.tv.api.functions.ITVApiSystemMiu;
import com.cvte.tv.api.functions.ITVApiSystemNetworkUpgrade;
import com.cvte.tv.api.functions.ITVApiSystemNoActionAutoPowerOff;
import com.cvte.tv.api.functions.ITVApiSystemOadUpgrade;
import com.cvte.tv.api.functions.ITVApiSystemOnOffTime;
import com.cvte.tv.api.functions.ITVApiSystemOsdLanguage;
import com.cvte.tv.api.functions.ITVApiSystemParentalControl;
import com.cvte.tv.api.functions.ITVApiSystemProductModel;
import com.cvte.tv.api.functions.ITVApiSystemProperties;
import com.cvte.tv.api.functions.ITVApiSystemRemoteControl;
import com.cvte.tv.api.functions.ITVApiSystemSignal;
import com.cvte.tv.api.functions.ITVApiSystemSleepTime;
import com.cvte.tv.api.functions.ITVApiTvAntennaType;
import com.cvte.tv.api.functions.ITVApiTvAtsc;
import com.cvte.tv.api.functions.ITVApiTvAtscFrontEnd;
import com.cvte.tv.api.functions.ITVApiTvAtv;
import com.cvte.tv.api.functions.ITVApiTvChannelEditChName;
import com.cvte.tv.api.functions.ITVApiTvChannelFavorite;
import com.cvte.tv.api.functions.ITVApiTvChannelLock;
import com.cvte.tv.api.functions.ITVApiTvChannelMoveSwapSkipDelete;
import com.cvte.tv.api.functions.ITVApiTvChannels;
import com.cvte.tv.api.functions.ITVApiTvDtmb;
import com.cvte.tv.api.functions.ITVApiTvDtmbFrontEnd;
import com.cvte.tv.api.functions.ITVApiTvDvbc;
import com.cvte.tv.api.functions.ITVApiTvDvbcFrontEnd;
import com.cvte.tv.api.functions.ITVApiTvDvbs;
import com.cvte.tv.api.functions.ITVApiTvDvbsFrontEnd;
import com.cvte.tv.api.functions.ITVApiTvDvbt;
import com.cvte.tv.api.functions.ITVApiTvDvbtFrontEnd;
import com.cvte.tv.api.functions.ITVApiTvFrontEnd;
import com.cvte.tv.api.functions.ITVApiTvIsdb;
import com.cvte.tv.api.functions.ITVApiTvIsdbFrontEnd;
import com.cvte.tv.api.functions.ITVApiTvIsdbGinga;
import com.cvte.tv.api.functions.ITVApiTvLcn;
import com.cvte.tv.api.functions.ITVApiTvMHEG5;
import com.cvte.tv.api.functions.ITVApiTvPlaceMode;
import com.cvte.tv.api.functions.ITVApiTvPvr;
import com.cvte.tv.api.functions.ITVApiTvSurfaceHolder;
import com.cvte.tv.api.functions.ITVApiTvSystemHotelMode;
import com.cvte.tv.api.functions.ITVApiTvTeletext;
import com.cvte.tv.api.functions.ITVApiUsb;
import com.cvte.tv.api.functions.ITVApiVChipCanadaRating;
import com.cvte.tv.api.functions.ITVApiVChipNoRatingLock;
import com.cvte.tv.api.functions.ITVApiVChipRRT5;
import com.cvte.tv.api.functions.ITVApiVChipUSRating;
import com.cvte.tv.api.functions.ITVApiWifi;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public abstract class TvApiManagerService {
    public static final String TVAPI_NOFOUND_ERROR = "TV Api not found";
    public static final String TVAPI_SERVICE = "TV_API_SERVCE";
    private TVApiAnalogCloseCaptionService cvteTVApiAnalogCloseCaptionService = null;
    private TVApiAtvAfcService cvteTVApiAtvAfcService = null;
    private TVApiAtvNicamMtsPreferenceService cvteTVApiAtvNicamMtsPreferenceService = null;
    private TVApiAtvNicamMtsService cvteTVApiAtvNicamMtsService = null;
    private TVApiBluetoothService cvteTVApiBluetoothService = null;
    private TVApiCloseCaptionStyleService cvteTVApiCloseCaptionStyleService = null;
    private TVApiDataImportsAndExportsService cvteTVApiDataImportsAndExportsService = null;
    private TVApiDigitalCloseCaptionService cvteTVApiDigitalCloseCaptionService = null;
    private TVApiDtvAudioDescriptionService cvteTVApiDtvAudioDescriptionService = null;
    private TVApiDtvAudioLanguagePreferenceService cvteTVApiDtvAudioLanguagePreferenceService = null;
    private TVApiDtvAudioLanguageService cvteTVApiDtvAudioLanguageService = null;
    private TVApiDtvCiInformationService cvteTVApiDtvCiInformationService = null;
    private TVApiDtvCiPlusOpProfileService cvteTVApiDtvCiPlusOpProfileService = null;
    private TVApiDtvEpgService cvteTVApiDtvEpgService = null;
    private TVApiDtvHearingImpairedService cvteTVApiDtvHearingImpairedService = null;
    private TVApiDtvSubtitlePreferenceService cvteTVApiDtvSubtitlePreferenceService = null;
    private TVApiDtvSubtitleService cvteTVApiDtvSubtitleService = null;
    private TVApiDvbsBissService cvteTVApiDvbsBissService = null;
    private TVApiDvbsMotorManagerService cvteTVApiDvbsMotorManagerService = null;
    private TVApiDvbsSatelliteManagerService cvteTVApiDvbsSatelliteManagerService = null;
    private TVApiDvbsTransponderManagerService cvteTVApiDvbsTransponderManagerService = null;
    private TVApiFactoryAutoTestService cvteTVApiFactoryAutoTestService = null;
    private TVApiFactoryHdmiEdidModeService cvteTVApiFactoryHdmiEdidModeService = null;
    private TVApiHDMIOUTService cvteTVApiHDMIOUTService = null;
    private TVApiI2cService cvteTVApiI2cService = null;
    private TVApiIsdbEwbsService cvteTVApiIsdbEwbsService = null;
    private TVApiMHLService cvteTVApiMHLService = null;
    private TVApiOADService cvteTVApiOADService = null;
    private TVApiPictureAdcService cvteTVApiPictureAdcService = null;
    private TVApiPictureAdvanceAdjustService cvteTVApiPictureAdvanceAdjustService = null;
    private TVApiPictureColorCorrectionService cvteTVApiPictureColorCorrectionService = null;
    private TVApiPictureColorEnhanceService cvteTVApiPictureColorEnhanceService = null;
    private TVApiPictureColorTempService cvteTVApiPictureColorTempService = null;
    private TVApiPictureControlService cvteTVApiPictureControlService = null;
    private TVApiPictureDbcService cvteTVApiPictureDbcService = null;
    private TVApiPictureDlcService cvteTVApiPictureDlcService = null;
    private TVApiPictureEcoModeService cvteTVApiPictureEcoModeService = null;
    private TVApiPictureGammaService cvteTVApiPictureGammaService = null;
    private TVApiPictureHdmiVideoPcModeService cvteTVApiPictureHdmiVideoPcModeService = null;
    private TVApiPictureHdrService cvteTVApiPictureHdrService = null;
    private TVApiPictureMpegNrService cvteTVApiPictureMpegNrService = null;
    private TVApiPictureNrService cvteTVApiPictureNrService = null;
    private TVApiScreen2DTo3DService cvteTVApiScreen2DTo3DService = null;
    private TVApiScreen3DGeneralService cvteTVApiScreen3DGeneralService = null;
    private TVApiScreen3DTo2DService cvteTVApiScreen3DTo2DService = null;
    private TVApiScreenAspectService cvteTVApiScreenAspectService = null;
    private TVApiScreenCaptureService cvteTVApiScreenCaptureService = null;
    private TVApiScreenCropService cvteTVApiScreenCropService = null;
    private TVApiScreenFreezeService cvteTVApiScreenFreezeService = null;
    private TVApiScreenKeystoneService cvteTVApiScreenKeystoneService = null;
    private TVApiScreenMemcService cvteTVApiScreenMemcService = null;
    private TVApiScreenMirrorService cvteTVApiScreenMirrorService = null;
    private TVApiScreenWindowService cvteTVApiScreenWindowService = null;
    private TVApiSoundArcService cvteTVApiSoundArcService = null;
    private TVApiSoundAvlService cvteTVApiSoundAvlService = null;
    private TVApiSoundDbxService cvteTVApiSoundDbxService = null;
    private TVApiSoundEqService cvteTVApiSoundEqService = null;
    private TVApiSoundHeadSetOutService cvteTVApiSoundHeadSetOutService = null;
    private TVApiSoundLineOutService cvteTVApiSoundLineOutService = null;
    private TVApiSoundPowerLimitControlService cvteTVApiSoundPowerLimitControlService = null;
    private TVApiSoundPreScaleService cvteTVApiSoundPreScaleService = null;
    private TVApiSoundSpdifOutService cvteTVApiSoundSpdifOutService = null;
    private TVApiSoundSpeakerOutService cvteTVApiSoundSpeakerOutService = null;
    private TVApiSoundSrsService cvteTVApiSoundSrsService = null;
    private TVApiSoundSurroundService cvteTVApiSoundSurroundService = null;
    private TVApiSystemAgingService cvteTVApiSystemAgingService = null;
    private TVApiSystemBacklightService cvteTVApiSystemBacklightService = null;
    private TVApiSystemBlueScreenService cvteTVApiSystemBlueScreenService = null;
    private TVApiSystemBoardSnService cvteTVApiSystemBoardSnService = null;
    private TVApiSystemBurningKeyService cvteTVApiSystemBurningKeyService = null;
    private TVApiSystemCecService cvteTVApiSystemCecService = null;
    private TVApiSystemCiPlusService cvteTVApiSystemCiPlusService = null;
    private TVApiSystemCountryService cvteTVApiSystemCountryService = null;
    private TVApiSystemDateTimeService cvteTVApiSystemDateTimeService = null;
    private TVApiSystemDebugService cvteTVApiSystemDebugService = null;
    private TVApiSystemEwsService cvteTVApiSystemEwsService = null;
    private TVApiSystemFactoryDataService cvteTVApiSystemFactoryDataService = null;
    private TVApiSystemHdcp1xKeyService cvteTVApiSystemHdcp1xKeyService = null;
    private TVApiSystemHdcp2xKeyService cvteTVApiSystemHdcp2xKeyService = null;
    private TVApiSystemHdcpTXKeyService cvteTVApiSystemHdcpTXKeyService = null;
    private TVApiSystemInformationService cvteTVApiSystemInformationService = null;
    private TVApiSystemInputSourceService cvteTVApiSystemInputSourceService = null;
    private TVApiSystemKeyPadService cvteTVApiSystemKeyPadService = null;
    private TVApiSystemLedLightService cvteTVApiSystemLedLightService = null;
    private TVApiSystemLockService cvteTVApiSystemLockService = null;
    private TVApiSystemLvdsFrcAlpdService cvteTVApiSystemLvdsFrcAlpdService = null;
    private TVApiSystemLvdsFrcService cvteTVApiSystemLvdsFrcService = null;
    private TVApiSystemLvdsService cvteTVApiSystemLvdsService = null;
    private TVApiSystemMacService cvteTVApiSystemMacService = null;
    private TVApiSystemMiuService cvteTVApiSystemMiuService = null;
    private TVApiSystemNetworkUpgradeService cvteTVApiSystemNetworkUpgradeService = null;
    private TVApiSystemNoActionAutoPowerOffService cvteTVApiSystemNoActionAutoPowerOffService = null;
    private TVApiSystemOadUpgradeService cvteTVApiSystemOadUpgradeService = null;
    private TVApiSystemOnOffTimeService cvteTVApiSystemOnOffTimeService = null;
    private TVApiSystemOsdLanguageService cvteTVApiSystemOsdLanguageService = null;
    private TVApiSystemParentalControlService cvteTVApiSystemParentalControlService = null;
    private TVApiSystemProductModelService cvteTVApiSystemProductModelService = null;
    private TVApiSystemPropertiesService cvteTVApiSystemPropertiesService = null;
    private TVApiSystemRemoteControlService cvteTVApiSystemRemoteControlService = null;
    private TVApiSystemSignalService cvteTVApiSystemSignalService = null;
    private TVApiSystemSleepTimeService cvteTVApiSystemSleepTimeService = null;
    private TVApiTvAntennaTypeService cvteTVApiTvAntennaTypeService = null;
    private TVApiTvAtscFrontEndService cvteTVApiTvAtscFrontEndService = null;
    private TVApiTvAtscService cvteTVApiTvAtscService = null;
    private TVApiTvAtvService cvteTVApiTvAtvService = null;
    private TVApiTvChannelEditChNameService cvteTVApiTvChannelEditChNameService = null;
    private TVApiTvChannelFavoriteService cvteTVApiTvChannelFavoriteService = null;
    private TVApiTvChannelLockService cvteTVApiTvChannelLockService = null;
    private TVApiTvChannelMoveSwapSkipDeleteService cvteTVApiTvChannelMoveSwapSkipDeleteService = null;
    private TVApiTvChannelsService cvteTVApiTvChannelsService = null;
    private TVApiTvDtmbFrontEndService cvteTVApiTvDtmbFrontEndService = null;
    private TVApiTvDtmbService cvteTVApiTvDtmbService = null;
    private TVApiTvDvbcFrontEndService cvteTVApiTvDvbcFrontEndService = null;
    private TVApiTvDvbcService cvteTVApiTvDvbcService = null;
    private TVApiTvDvbsFrontEndService cvteTVApiTvDvbsFrontEndService = null;
    private TVApiTvDvbsService cvteTVApiTvDvbsService = null;
    private TVApiTvDvbtFrontEndService cvteTVApiTvDvbtFrontEndService = null;
    private TVApiTvDvbtService cvteTVApiTvDvbtService = null;
    private TVApiTvFrontEndService cvteTVApiTvFrontEndService = null;
    private TVApiTvIsdbFrontEndService cvteTVApiTvIsdbFrontEndService = null;
    private TVApiTvIsdbGingaService cvteTVApiTvIsdbGingaService = null;
    private TVApiTvIsdbService cvteTVApiTvIsdbService = null;
    private TVApiTvLcnService cvteTVApiTvLcnService = null;
    private TVApiTvMHEG5Service cvteTVApiTvMHEG5Service = null;
    private TVApiTvPlaceModeService cvteTVApiTvPlaceModeService = null;
    private TVApiTvPvrService cvteTVApiTvPvrService = null;
    private TVApiTvSurfaceHolderService cvteTVApiTvSurfaceHolderService = null;
    private TVApiTvSystemHotelModeService cvteTVApiTvSystemHotelModeService = null;
    private TVApiTvTeletextService cvteTVApiTvTeletextService = null;
    private TVApiUsbService cvteTVApiUsbService = null;
    private TVApiVChipCanadaRatingService cvteTVApiVChipCanadaRatingService = null;
    private TVApiVChipNoRatingLockService cvteTVApiVChipNoRatingLockService = null;
    private TVApiVChipRRT5Service cvteTVApiVChipRRT5Service = null;
    private TVApiVChipUSRatingService cvteTVApiVChipUSRatingService = null;
    private TVApiWifiService cvteTVApiWifiService = null;
    private TVApiSerialControlService cvteTVApiSerialControlService = null;
    private TVApiSoundWirelessMicService cvteTVApiSoundWirelessMicService = null;
    private TVApiSoundMicService cvteTVApiSoundMicService = null;
    private TVApiSoundHDMIService cvteTVApiSoundHDMIService = null;
    private TVApiSoundAndroidService cvteTVApiSoundAndroidService = null;
    private TVApiDPModeService cvteTVApiDPModeService = null;
    private TVApiAudioSourceService cvteTVApiAudioSourceService = null;
    public ITvApiManager.Stub mBinder = new ITvApiManager.Stub() { // from class: com.cvte.tv.api.TvApiManagerService.1
        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public void addGlobalKeyListener(INotifyGlobalKeyListener iNotifyGlobalKeyListener) {
            MiddleWareApi.getInstance().addNotifyGlobalKeyListener(iNotifyGlobalKeyListener);
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public void addNotifyListener(INotifyListener iNotifyListener) {
            MiddleWareApi.getInstance().addNotifyListener(iNotifyListener);
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public String getCVTEConfigPath() {
            return MiddleWareApi.getInstance().getCVTEConfigPath();
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public String getGlobalKeyPackage() {
            return "com.cvte.tv.androidsetting";
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public List<String> getGlobalKeyPackageList() {
            return TvApiManagerService.this.apiConfigGlobalKeyPackageList();
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public List<String> getPackageWhitelist() {
            return TvApiManagerService.this.apiConfigPackageWhitelist();
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public int getRemoteLibraryVersionCode() {
            return 1490089988;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public String getRemoteLibraryVersionName() {
            return "1.0.14";
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiAnalogCloseCaptionAidl getTVApiAnalogCloseCaption() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiAnalogCloseCaption.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiAnalogCloseCaptionService == null) {
                TvApiManagerService.this.cvteTVApiAnalogCloseCaptionService = new TVApiAnalogCloseCaptionService();
            }
            return TvApiManagerService.this.cvteTVApiAnalogCloseCaptionService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiAtvAfcAidl getTVApiAtvAfc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiAtvAfc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiAtvAfcService == null) {
                TvApiManagerService.this.cvteTVApiAtvAfcService = new TVApiAtvAfcService();
            }
            return TvApiManagerService.this.cvteTVApiAtvAfcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiAtvNicamMtsAidl getTVApiAtvNicamMts() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiAtvNicamMts.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiAtvNicamMtsService == null) {
                TvApiManagerService.this.cvteTVApiAtvNicamMtsService = new TVApiAtvNicamMtsService();
            }
            return TvApiManagerService.this.cvteTVApiAtvNicamMtsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiAtvNicamMtsPreferenceAidl getTVApiAtvNicamMtsPreference() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiAtvNicamMtsPreference.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiAtvNicamMtsPreferenceService == null) {
                TvApiManagerService.this.cvteTVApiAtvNicamMtsPreferenceService = new TVApiAtvNicamMtsPreferenceService();
            }
            return TvApiManagerService.this.cvteTVApiAtvNicamMtsPreferenceService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiAudioSourceAidl getTVApiAudioSource() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiAudioSource.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiAudioSourceService == null) {
                TvApiManagerService.this.cvteTVApiAudioSourceService = new TVApiAudioSourceService();
            }
            return TvApiManagerService.this.cvteTVApiAudioSourceService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiBluetoothAidl getTVApiBluetooth() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiBluetooth.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiBluetoothService == null) {
                TvApiManagerService.this.cvteTVApiBluetoothService = new TVApiBluetoothService();
            }
            return TvApiManagerService.this.cvteTVApiBluetoothService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiCloseCaptionStyleAidl getTVApiCloseCaptionStyle() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiCloseCaptionStyle.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiCloseCaptionStyleService == null) {
                TvApiManagerService.this.cvteTVApiCloseCaptionStyleService = new TVApiCloseCaptionStyleService();
            }
            return TvApiManagerService.this.cvteTVApiCloseCaptionStyleService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDPModeAidl getTVApiDPMode() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDPMode.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDPModeService == null) {
                TvApiManagerService.this.cvteTVApiDPModeService = new TVApiDPModeService();
            }
            return TvApiManagerService.this.cvteTVApiDPModeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDataImportsAndExportsAidl getTVApiDataImportsAndExports() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDataImportsAndExports.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDataImportsAndExportsService == null) {
                TvApiManagerService.this.cvteTVApiDataImportsAndExportsService = new TVApiDataImportsAndExportsService();
            }
            return TvApiManagerService.this.cvteTVApiDataImportsAndExportsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDigitalCloseCaptionAidl getTVApiDigitalCloseCaption() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDigitalCloseCaption.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDigitalCloseCaptionService == null) {
                TvApiManagerService.this.cvteTVApiDigitalCloseCaptionService = new TVApiDigitalCloseCaptionService();
            }
            return TvApiManagerService.this.cvteTVApiDigitalCloseCaptionService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvAudioDescriptionAidl getTVApiDtvAudioDescription() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvAudioDescription.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvAudioDescriptionService == null) {
                TvApiManagerService.this.cvteTVApiDtvAudioDescriptionService = new TVApiDtvAudioDescriptionService();
            }
            return TvApiManagerService.this.cvteTVApiDtvAudioDescriptionService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvAudioLanguageAidl getTVApiDtvAudioLanguage() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvAudioLanguage.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvAudioLanguageService == null) {
                TvApiManagerService.this.cvteTVApiDtvAudioLanguageService = new TVApiDtvAudioLanguageService();
            }
            return TvApiManagerService.this.cvteTVApiDtvAudioLanguageService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvAudioLanguagePreferenceAidl getTVApiDtvAudioLanguagePreference() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvAudioLanguagePreference.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvAudioLanguagePreferenceService == null) {
                TvApiManagerService.this.cvteTVApiDtvAudioLanguagePreferenceService = new TVApiDtvAudioLanguagePreferenceService();
            }
            return TvApiManagerService.this.cvteTVApiDtvAudioLanguagePreferenceService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvCiInformationAidl getTVApiDtvCiInformation() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvCiInformation.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvCiInformationService == null) {
                TvApiManagerService.this.cvteTVApiDtvCiInformationService = new TVApiDtvCiInformationService();
            }
            return TvApiManagerService.this.cvteTVApiDtvCiInformationService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvCiPlusOpProfileAidl getTVApiDtvCiPlusOpProfile() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvCiPlusOpProfile.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvCiPlusOpProfileService == null) {
                TvApiManagerService.this.cvteTVApiDtvCiPlusOpProfileService = new TVApiDtvCiPlusOpProfileService();
            }
            return TvApiManagerService.this.cvteTVApiDtvCiPlusOpProfileService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvEpgAidl getTVApiDtvEpg() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvEpg.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvEpgService == null) {
                TvApiManagerService.this.cvteTVApiDtvEpgService = new TVApiDtvEpgService();
            }
            return TvApiManagerService.this.cvteTVApiDtvEpgService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvHearingImpairedAidl getTVApiDtvHearingImpaired() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvHearingImpaired.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvHearingImpairedService == null) {
                TvApiManagerService.this.cvteTVApiDtvHearingImpairedService = new TVApiDtvHearingImpairedService();
            }
            return TvApiManagerService.this.cvteTVApiDtvHearingImpairedService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvSubtitleAidl getTVApiDtvSubtitle() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvSubtitle.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvSubtitleService == null) {
                TvApiManagerService.this.cvteTVApiDtvSubtitleService = new TVApiDtvSubtitleService();
            }
            return TvApiManagerService.this.cvteTVApiDtvSubtitleService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDtvSubtitlePreferenceAidl getTVApiDtvSubtitlePreference() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDtvSubtitlePreference.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDtvSubtitlePreferenceService == null) {
                TvApiManagerService.this.cvteTVApiDtvSubtitlePreferenceService = new TVApiDtvSubtitlePreferenceService();
            }
            return TvApiManagerService.this.cvteTVApiDtvSubtitlePreferenceService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDvbsBissAidl getTVApiDvbsBiss() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDvbsBiss.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDvbsBissService == null) {
                TvApiManagerService.this.cvteTVApiDvbsBissService = new TVApiDvbsBissService();
            }
            return TvApiManagerService.this.cvteTVApiDvbsBissService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDvbsMotorManagerAidl getTVApiDvbsMotorManager() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDvbsMotorManager.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDvbsMotorManagerService == null) {
                TvApiManagerService.this.cvteTVApiDvbsMotorManagerService = new TVApiDvbsMotorManagerService();
            }
            return TvApiManagerService.this.cvteTVApiDvbsMotorManagerService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDvbsSatelliteManagerAidl getTVApiDvbsSatelliteManager() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDvbsSatelliteManager.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDvbsSatelliteManagerService == null) {
                TvApiManagerService.this.cvteTVApiDvbsSatelliteManagerService = new TVApiDvbsSatelliteManagerService();
            }
            return TvApiManagerService.this.cvteTVApiDvbsSatelliteManagerService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiDvbsTransponderManagerAidl getTVApiDvbsTransponderManager() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiDvbsTransponderManager.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiDvbsTransponderManagerService == null) {
                TvApiManagerService.this.cvteTVApiDvbsTransponderManagerService = new TVApiDvbsTransponderManagerService();
            }
            return TvApiManagerService.this.cvteTVApiDvbsTransponderManagerService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiFactoryAutoTestAidl getTVApiFactoryAutoTest() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiFactoryAutoTest.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiFactoryAutoTestService == null) {
                TvApiManagerService.this.cvteTVApiFactoryAutoTestService = new TVApiFactoryAutoTestService();
            }
            return TvApiManagerService.this.cvteTVApiFactoryAutoTestService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiFactoryHdmiEdidModeAidl getTVApiFactoryHdmiEdidMode() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiFactoryHdmiEdidMode.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiFactoryHdmiEdidModeService == null) {
                TvApiManagerService.this.cvteTVApiFactoryHdmiEdidModeService = new TVApiFactoryHdmiEdidModeService();
            }
            return TvApiManagerService.this.cvteTVApiFactoryHdmiEdidModeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiHDMIOUTAidl getTVApiHDMIOUT() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiHDMIOUT.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiHDMIOUTService == null) {
                TvApiManagerService.this.cvteTVApiHDMIOUTService = new TVApiHDMIOUTService();
            }
            return TvApiManagerService.this.cvteTVApiHDMIOUTService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiI2cAidl getTVApiI2c() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiI2c.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiI2cService == null) {
                TvApiManagerService.this.cvteTVApiI2cService = new TVApiI2cService();
            }
            return TvApiManagerService.this.cvteTVApiI2cService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiIsdbEwbsAidl getTVApiIsdbEwbs() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiIsdbEwbs.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiIsdbEwbsService == null) {
                TvApiManagerService.this.cvteTVApiIsdbEwbsService = new TVApiIsdbEwbsService();
            }
            return TvApiManagerService.this.cvteTVApiIsdbEwbsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiMHLAidl getTVApiMHL() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiMHL.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiMHLService == null) {
                TvApiManagerService.this.cvteTVApiMHLService = new TVApiMHLService();
            }
            return TvApiManagerService.this.cvteTVApiMHLService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiOADAidl getTVApiOAD() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiOAD.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiOADService == null) {
                TvApiManagerService.this.cvteTVApiOADService = new TVApiOADService();
            }
            return TvApiManagerService.this.cvteTVApiOADService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureAdcAidl getTVApiPictureAdc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureAdc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureAdcService == null) {
                TvApiManagerService.this.cvteTVApiPictureAdcService = new TVApiPictureAdcService();
            }
            return TvApiManagerService.this.cvteTVApiPictureAdcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureAdvanceAdjustAidl getTVApiPictureAdvanceAdjust() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureAdvanceAdjust.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureAdvanceAdjustService == null) {
                TvApiManagerService.this.cvteTVApiPictureAdvanceAdjustService = new TVApiPictureAdvanceAdjustService();
            }
            return TvApiManagerService.this.cvteTVApiPictureAdvanceAdjustService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureColorCorrectionAidl getTVApiPictureColorCorrection() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureColorCorrection.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureColorCorrectionService == null) {
                TvApiManagerService.this.cvteTVApiPictureColorCorrectionService = new TVApiPictureColorCorrectionService();
            }
            return TvApiManagerService.this.cvteTVApiPictureColorCorrectionService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureColorEnhanceAidl getTVApiPictureColorEnhance() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureColorEnhance.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureColorEnhanceService == null) {
                TvApiManagerService.this.cvteTVApiPictureColorEnhanceService = new TVApiPictureColorEnhanceService();
            }
            return TvApiManagerService.this.cvteTVApiPictureColorEnhanceService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureColorTempAidl getTVApiPictureColorTemp() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureColorTemp.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureColorTempService == null) {
                TvApiManagerService.this.cvteTVApiPictureColorTempService = new TVApiPictureColorTempService();
            }
            return TvApiManagerService.this.cvteTVApiPictureColorTempService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureControlAidl getTVApiPictureControl() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureControl.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureControlService == null) {
                TvApiManagerService.this.cvteTVApiPictureControlService = new TVApiPictureControlService();
            }
            return TvApiManagerService.this.cvteTVApiPictureControlService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureDbcAidl getTVApiPictureDbc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureDbc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureDbcService == null) {
                TvApiManagerService.this.cvteTVApiPictureDbcService = new TVApiPictureDbcService();
            }
            return TvApiManagerService.this.cvteTVApiPictureDbcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureDlcAidl getTVApiPictureDlc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureDlc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureDlcService == null) {
                TvApiManagerService.this.cvteTVApiPictureDlcService = new TVApiPictureDlcService();
            }
            return TvApiManagerService.this.cvteTVApiPictureDlcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureEcoModeAidl getTVApiPictureEcoMode() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureEcoMode.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureEcoModeService == null) {
                TvApiManagerService.this.cvteTVApiPictureEcoModeService = new TVApiPictureEcoModeService();
            }
            return TvApiManagerService.this.cvteTVApiPictureEcoModeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureGammaAidl getTVApiPictureGamma() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureGamma.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureGammaService == null) {
                TvApiManagerService.this.cvteTVApiPictureGammaService = new TVApiPictureGammaService();
            }
            return TvApiManagerService.this.cvteTVApiPictureGammaService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureHdmiVideoPcModeAidl getTVApiPictureHdmiVideoPcMode() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureHdmiVideoPcMode.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureHdmiVideoPcModeService == null) {
                TvApiManagerService.this.cvteTVApiPictureHdmiVideoPcModeService = new TVApiPictureHdmiVideoPcModeService();
            }
            return TvApiManagerService.this.cvteTVApiPictureHdmiVideoPcModeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureHdrAidl getTVApiPictureHdr() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureHdr.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureHdrService == null) {
                TvApiManagerService.this.cvteTVApiPictureHdrService = new TVApiPictureHdrService();
            }
            return TvApiManagerService.this.cvteTVApiPictureHdrService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureMpegNrAidl getTVApiPictureMpegNr() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureMpegNr.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureMpegNrService == null) {
                TvApiManagerService.this.cvteTVApiPictureMpegNrService = new TVApiPictureMpegNrService();
            }
            return TvApiManagerService.this.cvteTVApiPictureMpegNrService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiPictureNrAidl getTVApiPictureNr() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiPictureNr.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiPictureNrService == null) {
                TvApiManagerService.this.cvteTVApiPictureNrService = new TVApiPictureNrService();
            }
            return TvApiManagerService.this.cvteTVApiPictureNrService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreen2DTo3DAidl getTVApiScreen2DTo3D() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreen2DTo3D.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreen2DTo3DService == null) {
                TvApiManagerService.this.cvteTVApiScreen2DTo3DService = new TVApiScreen2DTo3DService();
            }
            return TvApiManagerService.this.cvteTVApiScreen2DTo3DService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreen3DGeneralAidl getTVApiScreen3DGeneral() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreen3DGeneral.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreen3DGeneralService == null) {
                TvApiManagerService.this.cvteTVApiScreen3DGeneralService = new TVApiScreen3DGeneralService();
            }
            return TvApiManagerService.this.cvteTVApiScreen3DGeneralService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreen3DTo2DAidl getTVApiScreen3DTo2D() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreen3DTo2D.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreen3DTo2DService == null) {
                TvApiManagerService.this.cvteTVApiScreen3DTo2DService = new TVApiScreen3DTo2DService();
            }
            return TvApiManagerService.this.cvteTVApiScreen3DTo2DService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenAspectAidl getTVApiScreenAspect() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenAspect.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenAspectService == null) {
                TvApiManagerService.this.cvteTVApiScreenAspectService = new TVApiScreenAspectService();
            }
            return TvApiManagerService.this.cvteTVApiScreenAspectService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenCaptureAidl getTVApiScreenCapture() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenCapture.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenCaptureService == null) {
                TvApiManagerService.this.cvteTVApiScreenCaptureService = new TVApiScreenCaptureService();
            }
            return TvApiManagerService.this.cvteTVApiScreenCaptureService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenCropAidl getTVApiScreenCrop() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenCrop.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenCropService == null) {
                TvApiManagerService.this.cvteTVApiScreenCropService = new TVApiScreenCropService();
            }
            return TvApiManagerService.this.cvteTVApiScreenCropService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenFreezeAidl getTVApiScreenFreeze() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenFreeze.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenFreezeService == null) {
                TvApiManagerService.this.cvteTVApiScreenFreezeService = new TVApiScreenFreezeService();
            }
            return TvApiManagerService.this.cvteTVApiScreenFreezeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenKeystoneAidl getTVApiScreenKeystone() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenKeystone.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenKeystoneService == null) {
                TvApiManagerService.this.cvteTVApiScreenKeystoneService = new TVApiScreenKeystoneService();
            }
            return TvApiManagerService.this.cvteTVApiScreenKeystoneService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenMemcAidl getTVApiScreenMemc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenMemc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenMemcService == null) {
                TvApiManagerService.this.cvteTVApiScreenMemcService = new TVApiScreenMemcService();
            }
            return TvApiManagerService.this.cvteTVApiScreenMemcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenMirrorAidl getTVApiScreenMirror() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenMirror.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenMirrorService == null) {
                TvApiManagerService.this.cvteTVApiScreenMirrorService = new TVApiScreenMirrorService();
            }
            return TvApiManagerService.this.cvteTVApiScreenMirrorService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiScreenWindowAidl getTVApiScreenWindow() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiScreenWindow.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiScreenWindowService == null) {
                TvApiManagerService.this.cvteTVApiScreenWindowService = new TVApiScreenWindowService();
            }
            return TvApiManagerService.this.cvteTVApiScreenWindowService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSerialControlAidl getTVApiSerialControl() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSerialControl.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSerialControlService == null) {
                TvApiManagerService.this.cvteTVApiSerialControlService = new TVApiSerialControlService();
            }
            return TvApiManagerService.this.cvteTVApiSerialControlService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundAndroidAidl getTVApiSoundAndroid() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundAndroid.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundAndroidService == null) {
                TvApiManagerService.this.cvteTVApiSoundAndroidService = new TVApiSoundAndroidService();
            }
            return TvApiManagerService.this.cvteTVApiSoundAndroidService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundArcAidl getTVApiSoundArc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundArc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundArcService == null) {
                TvApiManagerService.this.cvteTVApiSoundArcService = new TVApiSoundArcService();
            }
            return TvApiManagerService.this.cvteTVApiSoundArcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundAvlAidl getTVApiSoundAvl() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundAvl.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundAvlService == null) {
                TvApiManagerService.this.cvteTVApiSoundAvlService = new TVApiSoundAvlService();
            }
            return TvApiManagerService.this.cvteTVApiSoundAvlService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundDbxAidl getTVApiSoundDbx() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundDbx.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundDbxService == null) {
                TvApiManagerService.this.cvteTVApiSoundDbxService = new TVApiSoundDbxService();
            }
            return TvApiManagerService.this.cvteTVApiSoundDbxService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundEqAidl getTVApiSoundEq() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundEq.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundEqService == null) {
                TvApiManagerService.this.cvteTVApiSoundEqService = new TVApiSoundEqService();
            }
            return TvApiManagerService.this.cvteTVApiSoundEqService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundHDMIAidl getTVApiSoundHDMI() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundHDMI.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundHDMIService == null) {
                TvApiManagerService.this.cvteTVApiSoundHDMIService = new TVApiSoundHDMIService();
            }
            return TvApiManagerService.this.cvteTVApiSoundHDMIService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundHeadSetOutAidl getTVApiSoundHeadSetOut() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundHeadSetOut.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundHeadSetOutService == null) {
                TvApiManagerService.this.cvteTVApiSoundHeadSetOutService = new TVApiSoundHeadSetOutService();
            }
            return TvApiManagerService.this.cvteTVApiSoundHeadSetOutService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundLineOutAidl getTVApiSoundLineOut() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundLineOut.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundLineOutService == null) {
                TvApiManagerService.this.cvteTVApiSoundLineOutService = new TVApiSoundLineOutService();
            }
            return TvApiManagerService.this.cvteTVApiSoundLineOutService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundMicAidl getTVApiSoundMic() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundMic.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundMicService == null) {
                TvApiManagerService.this.cvteTVApiSoundMicService = new TVApiSoundMicService();
            }
            return TvApiManagerService.this.cvteTVApiSoundMicService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundPowerLimitControlAidl getTVApiSoundPowerLimitControl() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundPowerLimitControl.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundPowerLimitControlService == null) {
                TvApiManagerService.this.cvteTVApiSoundPowerLimitControlService = new TVApiSoundPowerLimitControlService();
            }
            return TvApiManagerService.this.cvteTVApiSoundPowerLimitControlService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundPreScaleAidl getTVApiSoundPreScale() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundPreScale.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundPreScaleService == null) {
                TvApiManagerService.this.cvteTVApiSoundPreScaleService = new TVApiSoundPreScaleService();
            }
            return TvApiManagerService.this.cvteTVApiSoundPreScaleService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundSpdifOutAidl getTVApiSoundSpdifOut() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundSpdifOut.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundSpdifOutService == null) {
                TvApiManagerService.this.cvteTVApiSoundSpdifOutService = new TVApiSoundSpdifOutService();
            }
            return TvApiManagerService.this.cvteTVApiSoundSpdifOutService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundSpeakerOutAidl getTVApiSoundSpeakerOut() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundSpeakerOut.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundSpeakerOutService == null) {
                TvApiManagerService.this.cvteTVApiSoundSpeakerOutService = new TVApiSoundSpeakerOutService();
            }
            return TvApiManagerService.this.cvteTVApiSoundSpeakerOutService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundSrsAidl getTVApiSoundSrs() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundSrs.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundSrsService == null) {
                TvApiManagerService.this.cvteTVApiSoundSrsService = new TVApiSoundSrsService();
            }
            return TvApiManagerService.this.cvteTVApiSoundSrsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundSurroundAidl getTVApiSoundSurround() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundSurround.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundSurroundService == null) {
                TvApiManagerService.this.cvteTVApiSoundSurroundService = new TVApiSoundSurroundService();
            }
            return TvApiManagerService.this.cvteTVApiSoundSurroundService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSoundWirelessMicAidl getTVApiSoundWirelessMic() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSoundWirelessMic.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSoundWirelessMicService == null) {
                TvApiManagerService.this.cvteTVApiSoundWirelessMicService = new TVApiSoundWirelessMicService();
            }
            return TvApiManagerService.this.cvteTVApiSoundWirelessMicService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemAgingAidl getTVApiSystemAging() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemAging.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemAgingService == null) {
                TvApiManagerService.this.cvteTVApiSystemAgingService = new TVApiSystemAgingService();
            }
            return TvApiManagerService.this.cvteTVApiSystemAgingService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemBacklightAidl getTVApiSystemBacklight() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemBacklight.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemBacklightService == null) {
                TvApiManagerService.this.cvteTVApiSystemBacklightService = new TVApiSystemBacklightService();
            }
            return TvApiManagerService.this.cvteTVApiSystemBacklightService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemBlueScreenAidl getTVApiSystemBlueScreen() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemBlueScreen.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemBlueScreenService == null) {
                TvApiManagerService.this.cvteTVApiSystemBlueScreenService = new TVApiSystemBlueScreenService();
            }
            return TvApiManagerService.this.cvteTVApiSystemBlueScreenService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemBoardSnAidl getTVApiSystemBoardSn() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemBoardSn.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemBoardSnService == null) {
                TvApiManagerService.this.cvteTVApiSystemBoardSnService = new TVApiSystemBoardSnService();
            }
            return TvApiManagerService.this.cvteTVApiSystemBoardSnService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemBurningKeyAidl getTVApiSystemBurningKey() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemBurningKey.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemBurningKeyService == null) {
                TvApiManagerService.this.cvteTVApiSystemBurningKeyService = new TVApiSystemBurningKeyService();
            }
            return TvApiManagerService.this.cvteTVApiSystemBurningKeyService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemCecAidl getTVApiSystemCec() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemCec.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemCecService == null) {
                TvApiManagerService.this.cvteTVApiSystemCecService = new TVApiSystemCecService();
            }
            return TvApiManagerService.this.cvteTVApiSystemCecService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemCiPlusAidl getTVApiSystemCiPlus() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemCiPlus.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemCiPlusService == null) {
                TvApiManagerService.this.cvteTVApiSystemCiPlusService = new TVApiSystemCiPlusService();
            }
            return TvApiManagerService.this.cvteTVApiSystemCiPlusService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemCountryAidl getTVApiSystemCountry() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemCountry.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemCountryService == null) {
                TvApiManagerService.this.cvteTVApiSystemCountryService = new TVApiSystemCountryService();
            }
            return TvApiManagerService.this.cvteTVApiSystemCountryService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemDateTimeAidl getTVApiSystemDateTime() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemDateTime.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemDateTimeService == null) {
                TvApiManagerService.this.cvteTVApiSystemDateTimeService = new TVApiSystemDateTimeService();
            }
            return TvApiManagerService.this.cvteTVApiSystemDateTimeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemDebugAidl getTVApiSystemDebug() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemDebug.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemDebugService == null) {
                TvApiManagerService.this.cvteTVApiSystemDebugService = new TVApiSystemDebugService();
            }
            return TvApiManagerService.this.cvteTVApiSystemDebugService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemEwsAidl getTVApiSystemEws() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemEws.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemEwsService == null) {
                TvApiManagerService.this.cvteTVApiSystemEwsService = new TVApiSystemEwsService();
            }
            return TvApiManagerService.this.cvteTVApiSystemEwsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemFactoryDataAidl getTVApiSystemFactoryData() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemFactoryData.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemFactoryDataService == null) {
                TvApiManagerService.this.cvteTVApiSystemFactoryDataService = new TVApiSystemFactoryDataService();
            }
            return TvApiManagerService.this.cvteTVApiSystemFactoryDataService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemHdcp1xKeyAidl getTVApiSystemHdcp1xKey() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemHdcp1xKey.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemHdcp1xKeyService == null) {
                TvApiManagerService.this.cvteTVApiSystemHdcp1xKeyService = new TVApiSystemHdcp1xKeyService();
            }
            return TvApiManagerService.this.cvteTVApiSystemHdcp1xKeyService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemHdcp2xKeyAidl getTVApiSystemHdcp2xKey() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemHdcp2xKey.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemHdcp2xKeyService == null) {
                TvApiManagerService.this.cvteTVApiSystemHdcp2xKeyService = new TVApiSystemHdcp2xKeyService();
            }
            return TvApiManagerService.this.cvteTVApiSystemHdcp2xKeyService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemHdcpTXKeyAidl getTVApiSystemHdcpTXKey() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemHdcpTXKey.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemHdcpTXKeyService == null) {
                TvApiManagerService.this.cvteTVApiSystemHdcpTXKeyService = new TVApiSystemHdcpTXKeyService();
            }
            return TvApiManagerService.this.cvteTVApiSystemHdcpTXKeyService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemInformationAidl getTVApiSystemInformation() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemInformation.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemInformationService == null) {
                TvApiManagerService.this.cvteTVApiSystemInformationService = new TVApiSystemInformationService();
            }
            return TvApiManagerService.this.cvteTVApiSystemInformationService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemInputSourceAidl getTVApiSystemInputSource() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemInputSource.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemInputSourceService == null) {
                TvApiManagerService.this.cvteTVApiSystemInputSourceService = new TVApiSystemInputSourceService();
            }
            return TvApiManagerService.this.cvteTVApiSystemInputSourceService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemKeyPadAidl getTVApiSystemKeyPad() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemKeyPad.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemKeyPadService == null) {
                TvApiManagerService.this.cvteTVApiSystemKeyPadService = new TVApiSystemKeyPadService();
            }
            return TvApiManagerService.this.cvteTVApiSystemKeyPadService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemLedLightAidl getTVApiSystemLedLight() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemLedLight.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemLedLightService == null) {
                TvApiManagerService.this.cvteTVApiSystemLedLightService = new TVApiSystemLedLightService();
            }
            return TvApiManagerService.this.cvteTVApiSystemLedLightService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemLockAidl getTVApiSystemLock() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemLock.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemLockService == null) {
                TvApiManagerService.this.cvteTVApiSystemLockService = new TVApiSystemLockService();
            }
            return TvApiManagerService.this.cvteTVApiSystemLockService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemLvdsAidl getTVApiSystemLvds() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemLvds.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemLvdsService == null) {
                TvApiManagerService.this.cvteTVApiSystemLvdsService = new TVApiSystemLvdsService();
            }
            return TvApiManagerService.this.cvteTVApiSystemLvdsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemLvdsFrcAidl getTVApiSystemLvdsFrc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemLvdsFrc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemLvdsFrcService == null) {
                TvApiManagerService.this.cvteTVApiSystemLvdsFrcService = new TVApiSystemLvdsFrcService();
            }
            return TvApiManagerService.this.cvteTVApiSystemLvdsFrcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemLvdsFrcAlpdAidl getTVApiSystemLvdsFrcAlpd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemLvdsFrcAlpd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemLvdsFrcAlpdService == null) {
                TvApiManagerService.this.cvteTVApiSystemLvdsFrcAlpdService = new TVApiSystemLvdsFrcAlpdService();
            }
            return TvApiManagerService.this.cvteTVApiSystemLvdsFrcAlpdService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemMacAidl getTVApiSystemMac() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemMac.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemMacService == null) {
                TvApiManagerService.this.cvteTVApiSystemMacService = new TVApiSystemMacService();
            }
            return TvApiManagerService.this.cvteTVApiSystemMacService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemMiuAidl getTVApiSystemMiu() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemMiu.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemMiuService == null) {
                TvApiManagerService.this.cvteTVApiSystemMiuService = new TVApiSystemMiuService();
            }
            return TvApiManagerService.this.cvteTVApiSystemMiuService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemNetworkUpgradeAidl getTVApiSystemNetworkUpgrade() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemNetworkUpgrade.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemNetworkUpgradeService == null) {
                TvApiManagerService.this.cvteTVApiSystemNetworkUpgradeService = new TVApiSystemNetworkUpgradeService();
            }
            return TvApiManagerService.this.cvteTVApiSystemNetworkUpgradeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemNoActionAutoPowerOffAidl getTVApiSystemNoActionAutoPowerOff() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemNoActionAutoPowerOff.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemNoActionAutoPowerOffService == null) {
                TvApiManagerService.this.cvteTVApiSystemNoActionAutoPowerOffService = new TVApiSystemNoActionAutoPowerOffService();
            }
            return TvApiManagerService.this.cvteTVApiSystemNoActionAutoPowerOffService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemOadUpgradeAidl getTVApiSystemOadUpgrade() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemOadUpgrade.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemOadUpgradeService == null) {
                TvApiManagerService.this.cvteTVApiSystemOadUpgradeService = new TVApiSystemOadUpgradeService();
            }
            return TvApiManagerService.this.cvteTVApiSystemOadUpgradeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemOnOffTimeAidl getTVApiSystemOnOffTime() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemOnOffTime.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemOnOffTimeService == null) {
                TvApiManagerService.this.cvteTVApiSystemOnOffTimeService = new TVApiSystemOnOffTimeService();
            }
            return TvApiManagerService.this.cvteTVApiSystemOnOffTimeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemOsdLanguageAidl getTVApiSystemOsdLanguage() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemOsdLanguage.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemOsdLanguageService == null) {
                TvApiManagerService.this.cvteTVApiSystemOsdLanguageService = new TVApiSystemOsdLanguageService();
            }
            return TvApiManagerService.this.cvteTVApiSystemOsdLanguageService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemParentalControlAidl getTVApiSystemParentalControl() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemParentalControl.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemParentalControlService == null) {
                TvApiManagerService.this.cvteTVApiSystemParentalControlService = new TVApiSystemParentalControlService();
            }
            return TvApiManagerService.this.cvteTVApiSystemParentalControlService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemProductModelAidl getTVApiSystemProductModel() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemProductModel.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemProductModelService == null) {
                TvApiManagerService.this.cvteTVApiSystemProductModelService = new TVApiSystemProductModelService();
            }
            return TvApiManagerService.this.cvteTVApiSystemProductModelService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemPropertiesAidl getTVApiSystemProperties() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemProperties.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemPropertiesService == null) {
                TvApiManagerService.this.cvteTVApiSystemPropertiesService = new TVApiSystemPropertiesService();
            }
            return TvApiManagerService.this.cvteTVApiSystemPropertiesService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemRemoteControlAidl getTVApiSystemRemoteControl() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemRemoteControl.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemRemoteControlService == null) {
                TvApiManagerService.this.cvteTVApiSystemRemoteControlService = new TVApiSystemRemoteControlService();
            }
            return TvApiManagerService.this.cvteTVApiSystemRemoteControlService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemSignalAidl getTVApiSystemSignal() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemSignal.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemSignalService == null) {
                TvApiManagerService.this.cvteTVApiSystemSignalService = new TVApiSystemSignalService();
            }
            return TvApiManagerService.this.cvteTVApiSystemSignalService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiSystemSleepTimeAidl getTVApiSystemSleepTime() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiSystemSleepTime.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiSystemSleepTimeService == null) {
                TvApiManagerService.this.cvteTVApiSystemSleepTimeService = new TVApiSystemSleepTimeService();
            }
            return TvApiManagerService.this.cvteTVApiSystemSleepTimeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvAntennaTypeAidl getTVApiTvAntennaType() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvAntennaType.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvAntennaTypeService == null) {
                TvApiManagerService.this.cvteTVApiTvAntennaTypeService = new TVApiTvAntennaTypeService();
            }
            return TvApiManagerService.this.cvteTVApiTvAntennaTypeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvAtscAidl getTVApiTvAtsc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvAtsc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvAtscService == null) {
                TvApiManagerService.this.cvteTVApiTvAtscService = new TVApiTvAtscService();
            }
            return TvApiManagerService.this.cvteTVApiTvAtscService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvAtscFrontEndAidl getTVApiTvAtscFrontEnd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvAtscFrontEnd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvAtscFrontEndService == null) {
                TvApiManagerService.this.cvteTVApiTvAtscFrontEndService = new TVApiTvAtscFrontEndService();
            }
            return TvApiManagerService.this.cvteTVApiTvAtscFrontEndService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvAtvAidl getTVApiTvAtv() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvAtv.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvAtvService == null) {
                TvApiManagerService.this.cvteTVApiTvAtvService = new TVApiTvAtvService();
            }
            return TvApiManagerService.this.cvteTVApiTvAtvService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvChannelEditChNameAidl getTVApiTvChannelEditChName() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvChannelEditChName.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvChannelEditChNameService == null) {
                TvApiManagerService.this.cvteTVApiTvChannelEditChNameService = new TVApiTvChannelEditChNameService();
            }
            return TvApiManagerService.this.cvteTVApiTvChannelEditChNameService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvChannelFavoriteAidl getTVApiTvChannelFavorite() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvChannelFavorite.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvChannelFavoriteService == null) {
                TvApiManagerService.this.cvteTVApiTvChannelFavoriteService = new TVApiTvChannelFavoriteService();
            }
            return TvApiManagerService.this.cvteTVApiTvChannelFavoriteService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvChannelLockAidl getTVApiTvChannelLock() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvChannelLock.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvChannelLockService == null) {
                TvApiManagerService.this.cvteTVApiTvChannelLockService = new TVApiTvChannelLockService();
            }
            return TvApiManagerService.this.cvteTVApiTvChannelLockService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvChannelMoveSwapSkipDeleteAidl getTVApiTvChannelMoveSwapSkipDelete() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvChannelMoveSwapSkipDelete.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvChannelMoveSwapSkipDeleteService == null) {
                TvApiManagerService.this.cvteTVApiTvChannelMoveSwapSkipDeleteService = new TVApiTvChannelMoveSwapSkipDeleteService();
            }
            return TvApiManagerService.this.cvteTVApiTvChannelMoveSwapSkipDeleteService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvChannelsAidl getTVApiTvChannels() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvChannels.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvChannelsService == null) {
                TvApiManagerService.this.cvteTVApiTvChannelsService = new TVApiTvChannelsService();
            }
            return TvApiManagerService.this.cvteTVApiTvChannelsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDtmbAidl getTVApiTvDtmb() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDtmb.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDtmbService == null) {
                TvApiManagerService.this.cvteTVApiTvDtmbService = new TVApiTvDtmbService();
            }
            return TvApiManagerService.this.cvteTVApiTvDtmbService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDtmbFrontEndAidl getTVApiTvDtmbFrontEnd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDtmbFrontEnd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDtmbFrontEndService == null) {
                TvApiManagerService.this.cvteTVApiTvDtmbFrontEndService = new TVApiTvDtmbFrontEndService();
            }
            return TvApiManagerService.this.cvteTVApiTvDtmbFrontEndService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDvbcAidl getTVApiTvDvbc() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDvbc.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDvbcService == null) {
                TvApiManagerService.this.cvteTVApiTvDvbcService = new TVApiTvDvbcService();
            }
            return TvApiManagerService.this.cvteTVApiTvDvbcService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDvbcFrontEndAidl getTVApiTvDvbcFrontEnd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDvbcFrontEnd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDvbcFrontEndService == null) {
                TvApiManagerService.this.cvteTVApiTvDvbcFrontEndService = new TVApiTvDvbcFrontEndService();
            }
            return TvApiManagerService.this.cvteTVApiTvDvbcFrontEndService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDvbsAidl getTVApiTvDvbs() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDvbs.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDvbsService == null) {
                TvApiManagerService.this.cvteTVApiTvDvbsService = new TVApiTvDvbsService();
            }
            return TvApiManagerService.this.cvteTVApiTvDvbsService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDvbsFrontEndAidl getTVApiTvDvbsFrontEnd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDvbsFrontEnd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDvbsFrontEndService == null) {
                TvApiManagerService.this.cvteTVApiTvDvbsFrontEndService = new TVApiTvDvbsFrontEndService();
            }
            return TvApiManagerService.this.cvteTVApiTvDvbsFrontEndService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDvbtAidl getTVApiTvDvbt() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDvbt.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDvbtService == null) {
                TvApiManagerService.this.cvteTVApiTvDvbtService = new TVApiTvDvbtService();
            }
            return TvApiManagerService.this.cvteTVApiTvDvbtService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvDvbtFrontEndAidl getTVApiTvDvbtFrontEnd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvDvbtFrontEnd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvDvbtFrontEndService == null) {
                TvApiManagerService.this.cvteTVApiTvDvbtFrontEndService = new TVApiTvDvbtFrontEndService();
            }
            return TvApiManagerService.this.cvteTVApiTvDvbtFrontEndService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvFrontEndAidl getTVApiTvFrontEnd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvFrontEnd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvFrontEndService == null) {
                TvApiManagerService.this.cvteTVApiTvFrontEndService = new TVApiTvFrontEndService();
            }
            return TvApiManagerService.this.cvteTVApiTvFrontEndService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvIsdbAidl getTVApiTvIsdb() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvIsdb.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvIsdbService == null) {
                TvApiManagerService.this.cvteTVApiTvIsdbService = new TVApiTvIsdbService();
            }
            return TvApiManagerService.this.cvteTVApiTvIsdbService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvIsdbFrontEndAidl getTVApiTvIsdbFrontEnd() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvIsdbFrontEnd.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvIsdbFrontEndService == null) {
                TvApiManagerService.this.cvteTVApiTvIsdbFrontEndService = new TVApiTvIsdbFrontEndService();
            }
            return TvApiManagerService.this.cvteTVApiTvIsdbFrontEndService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvIsdbGingaAidl getTVApiTvIsdbGinga() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvIsdbGinga.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvIsdbGingaService == null) {
                TvApiManagerService.this.cvteTVApiTvIsdbGingaService = new TVApiTvIsdbGingaService();
            }
            return TvApiManagerService.this.cvteTVApiTvIsdbGingaService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvLcnAidl getTVApiTvLcn() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvLcn.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvLcnService == null) {
                TvApiManagerService.this.cvteTVApiTvLcnService = new TVApiTvLcnService();
            }
            return TvApiManagerService.this.cvteTVApiTvLcnService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvMHEG5Aidl getTVApiTvMHEG5() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvMHEG5.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvMHEG5Service == null) {
                TvApiManagerService.this.cvteTVApiTvMHEG5Service = new TVApiTvMHEG5Service();
            }
            return TvApiManagerService.this.cvteTVApiTvMHEG5Service;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvPlaceModeAidl getTVApiTvPlaceMode() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvPlaceMode.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvPlaceModeService == null) {
                TvApiManagerService.this.cvteTVApiTvPlaceModeService = new TVApiTvPlaceModeService();
            }
            return TvApiManagerService.this.cvteTVApiTvPlaceModeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvPvrAidl getTVApiTvPvr() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvPvr.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvPvrService == null) {
                TvApiManagerService.this.cvteTVApiTvPvrService = new TVApiTvPvrService();
            }
            return TvApiManagerService.this.cvteTVApiTvPvrService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvSurfaceHolderAidl getTVApiTvSurfaceHolder() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvSurfaceHolder.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvSurfaceHolderService == null) {
                TvApiManagerService.this.cvteTVApiTvSurfaceHolderService = new TVApiTvSurfaceHolderService();
            }
            return TvApiManagerService.this.cvteTVApiTvSurfaceHolderService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvSystemHotelModeAidl getTVApiTvSystemHotelMode() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvSystemHotelMode.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvSystemHotelModeService == null) {
                TvApiManagerService.this.cvteTVApiTvSystemHotelModeService = new TVApiTvSystemHotelModeService();
            }
            return TvApiManagerService.this.cvteTVApiTvSystemHotelModeService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiTvTeletextAidl getTVApiTvTeletext() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiTvTeletext.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiTvTeletextService == null) {
                TvApiManagerService.this.cvteTVApiTvTeletextService = new TVApiTvTeletextService();
            }
            return TvApiManagerService.this.cvteTVApiTvTeletextService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiUsbAidl getTVApiUsb() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiUsb.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiUsbService == null) {
                TvApiManagerService.this.cvteTVApiUsbService = new TVApiUsbService();
            }
            return TvApiManagerService.this.cvteTVApiUsbService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiVChipCanadaRatingAidl getTVApiVChipCanadaRating() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiVChipCanadaRating.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiVChipCanadaRatingService == null) {
                TvApiManagerService.this.cvteTVApiVChipCanadaRatingService = new TVApiVChipCanadaRatingService();
            }
            return TvApiManagerService.this.cvteTVApiVChipCanadaRatingService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiVChipNoRatingLockAidl getTVApiVChipNoRatingLock() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiVChipNoRatingLock.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiVChipNoRatingLockService == null) {
                TvApiManagerService.this.cvteTVApiVChipNoRatingLockService = new TVApiVChipNoRatingLockService();
            }
            return TvApiManagerService.this.cvteTVApiVChipNoRatingLockService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiVChipRRT5Aidl getTVApiVChipRRT5() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiVChipRRT5.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiVChipRRT5Service == null) {
                TvApiManagerService.this.cvteTVApiVChipRRT5Service = new TVApiVChipRRT5Service();
            }
            return TvApiManagerService.this.cvteTVApiVChipRRT5Service;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiVChipUSRatingAidl getTVApiVChipUSRating() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiVChipUSRating.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiVChipUSRatingService == null) {
                TvApiManagerService.this.cvteTVApiVChipUSRatingService = new TVApiVChipUSRatingService();
            }
            return TvApiManagerService.this.cvteTVApiVChipUSRatingService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public ITVApiWifiAidl getTVApiWifi() throws RemoteException {
            if (!MiddleWareApi.getInstance().checkSupportable(ITVApiWifi.class)) {
                throw new RemoteException("TV Api not found");
            }
            if (TvApiManagerService.this.cvteTVApiWifiService == null) {
                TvApiManagerService.this.cvteTVApiWifiService = new TVApiWifiService();
            }
            return TvApiManagerService.this.cvteTVApiWifiService;
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public boolean onGlobalKeyEvent(KeyEvent keyEvent) {
            StringBuilder sbC = a.C("onGlobalKeyEvent keycode=");
            sbC.append(keyEvent.getKeyCode());
            Log.d("Evan", sbC.toString());
            return TvApiManagerService.this.apiHandleGlobalKeyEvent(keyEvent);
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public boolean onGlobalKeyEventBefore(KeyEvent keyEvent) {
            return TvApiManagerService.this.apiHandleGlobalKeyEventBefore(keyEvent);
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public void removeGlobalKeyListener(INotifyGlobalKeyListener iNotifyGlobalKeyListener) {
            MiddleWareApi.getInstance().addNotifyGlobalKeyListener(iNotifyGlobalKeyListener);
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public void removeNotifyListener(INotifyListener iNotifyListener) {
            MiddleWareApi.getInstance().removeNotifyListener(iNotifyListener);
        }

        @Override // com.cvte.tv.api.aidl.ITvApiManager
        public boolean resetAllFunction(EnumResetLevel enumResetLevel) {
            return MiddleWareApi.getInstance().invokeAllResetMethod(enumResetLevel) && TvApiManagerService.this.apiOnResetSystemSettings(enumResetLevel);
        }
    };

    public TvApiManagerService(Context context) {
        MiddleWareApi middleWareApi = MiddleWareApi.getInstance(context);
        String strApiConfigPath = apiConfigPath();
        if (strApiConfigPath != null && !strApiConfigPath.isEmpty()) {
            MiddleWareApi.getInstance().setCVTEConfigPath(strApiConfigPath);
        }
        apiRegisterImplClz(middleWareApi);
    }

    public String apiConfigGlobalKeyPackage() {
        return "com.cvte.tv.androidsetting";
    }

    public List<String> apiConfigGlobalKeyPackageList() {
        return null;
    }

    public List<String> apiConfigPackageWhitelist() {
        return null;
    }

    public abstract String apiConfigPath();

    public boolean apiHandleGlobalKeyEvent(KeyEvent keyEvent) {
        return MiddleWareApi.getInstance().invokeGlobalKeyListener(keyEvent);
    }

    public boolean apiHandleGlobalKeyEventBefore(KeyEvent keyEvent) {
        return false;
    }

    public abstract boolean apiOnResetSystemSettings(EnumResetLevel enumResetLevel);

    public abstract void apiRegisterImplClz(MiddleWareApi middleWareApi);

    public IBinder getBinder() {
        return this.mBinder;
    }
}
