Petal Maps v4.7.0.310001 - TTSAPIMulService.java 源代码

package com.huawei.hiai.tts.sdk;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.text.TextUtils;
import com.huawei.hiai.pdk.interfaces.PluginId;
import com.huawei.hiai.pdk.interfaces.tts.ITtsListener;
import com.huawei.hiai.pdk.interfaces.tts.ITtsService;
import com.huawei.hiai.pdk.interfaces.tts.InitParams;
import com.huawei.hiai.pdk.interfaces.tts.ParamsConstants;
import com.huawei.hiai.pdk.pluginlabel.PluginLabelConstants;
import com.huawei.hiai.pdk.pluginservice.IPluginService;
import com.huawei.hiai.tts.constants.BaseConstants;
import com.huawei.hiai.tts.sdk.TTSAPIMulService;
import com.huawei.hiai.tts.utils.AppUtil;
import com.huawei.hiai.tts.utils.ReflectUtil;
import com.huawei.hiai.tts.utils.SystemPropertyUtil;
import com.huawei.hiai.tts.utils.TLog;
import com.huawei.hiai.tts.utils.TtsSharedProperty;
import com.huawei.hiassistant.voice.abilityconnector.recognizer.cloud.http.HttpConfig;
import com.huawei.hms.navi.navibase.enums.PathType;
import java.lang.reflect.Field;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Function;

public class TTSAPIMulService implements ITts {
    private static final String CONVERT_LANGUAGE_CN = "0";
    private static final String CONVERT_LANGUAGE_EN = "1";
    private static final String DEFAULT_SESSION_STR = "{}";
    private static final String EMPTY_STRING = "";
    private static final String HIAI_FRAME_NAME = "com.huawei.hiai.plugin.PluginService";
    private static final int INVALID_INT_VALUE = -1;
    private static final String LANGUAGE_CN = "cn";
    private static final String LANGUAGE_EN_US = "en_US";
    private static final int NO_NEED_SPLIT_LEN = 1;
    private static final String SPACE = " ";
    private static final String TAG = "TTSAPIMulService";
    private Context mContext;
    private final TtsCallback mInvokerCallback;
    private TtsSpeakAbility mTtsSpeakAbility;
    private static final String HIAI_TTS_ENGINE_PROVIDER_URI = "content://com.huawei.hiai.tts.feature";
    private static final Uri URI_HIAI_TTS_ENGINE_PROVIDER = Uri.parse(HIAI_TTS_ENGINE_PROVIDER_URI);
    private static final Object LOCK = new Object();
    private final LocalTtsCallback mLocalTtsCallback = new LocalTtsCallback();
    private Optional<ITtsService> mOptTtsService = Optional.empty();
    private Optional<TtsMulConnection> mOptConnection = Optional.empty();
    private int mPlugin = PluginId.TTS_PLUGIN_ID;
    private boolean isAutoInvoke = false;
    private String mOriginUtteranceId = "";
    private String mOriginLanguage = "";

    public class LocalTtsCallback extends ITtsListener.Stub {
        private LocalTtsCallback() {
        }

        private int getQueueSize() {
            if (TTSAPIMulService.this.mTtsSpeakAbility != null) {
                return TTSAPIMulService.this.mTtsSpeakAbility.getQueueSize();
            }
            TLog.e(TTSAPIMulService.TAG, "getQSize mTtsSpeakAbility is null");
            return -1;
        }

        @Override
        public void onError(String str, String str2) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onError(str, str2);
            }
        }

        @Override
        public void onEvent(int i, Bundle bundle) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onEvent(i, bundle);
            }
        }

        @Override
        public void onFinish(String str) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onFinish(str);
            }
        }

        @Override
        public void onFormatChange(String str, Bundle bundle) throws RemoteException {
            TLog.i(TTSAPIMulService.TAG, "onFormatChange audioFormat: " + bundle.toString());
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onFormatChange(str, bundle);
            }
        }

        @Override
        public void onProgress(String str, byte[] bArr, int i) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onProgress(str, bArr, i);
            }
        }

        @Override
        public void onResultCode(int i) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onResultCode(i);
            }
        }

        @Override
        public void onSpeechFinish(String str) throws RemoteException {
            TLog.i(TTSAPIMulService.TAG, "enter onSpeechFinish");
            if (!TTSAPIMulService.this.isAutoInvoke || SystemPropertyUtil.isOversea() || TTSAPIMulService.this.mPlugin != 524288) {
                if (TTSAPIMulService.this.mInvokerCallback != null) {
                    TTSAPIMulService.this.mInvokerCallback.onSpeechFinish(str);
                    return;
                }
                return;
            }
            TTSAPIMulService tTSAPIMulService = TTSAPIMulService.this;
            boolean isSpeakEnd = tTSAPIMulService.isSpeakEnd(tTSAPIMulService.mOriginUtteranceId, str, getQueueSize());
            TLog.i(TTSAPIMulService.TAG, "onSpeechFinish isSpeakEnd: " + isSpeakEnd);
            if (!isSpeakEnd || TTSAPIMulService.this.mInvokerCallback == null) {
                return;
            }
            TTSAPIMulService.this.mInvokerCallback.onSpeechFinish(str);
        }

        @Override
        public void onSpeechProgressChanged(String str, int i) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onSpeechProgressChanged(str, i);
            }
        }

        @Override
        public void onSpeechStart(String str) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onSpeechStart(str);
            }
        }

        @Override
        public void onStart(String str) throws RemoteException {
            if (TTSAPIMulService.this.mInvokerCallback != null) {
                TTSAPIMulService.this.mInvokerCallback.onStart(str);
            }
        }
    }

    public class TtsMulConnection implements ServiceConnection {
        private TtsMulConnection() {
        }

        private void bindRomTtsPlugin(IPluginService iPluginService) throws RemoteException {
            TLog.i(TTSAPIMulService.TAG, "bindRomTtsPlugin");
            IBinder splitBinder = iPluginService.getSplitBinder(TTSAPIMulService.this.mPlugin);
            if (splitBinder == null) {
                TLog.e(TTSAPIMulService.TAG, "iBinder = null");
                TTSAPIMulService.this.sendCallback(11, 1000);
                return;
            }
            TTSAPIMulService.this.mOptTtsService = Optional.ofNullable(ITtsService.Stub.asInterface(splitBinder));
            if (!TTSAPIMulService.this.mOptTtsService.isPresent()) {
                TLog.e(TTSAPIMulService.TAG, "mTtsService = null");
                TTSAPIMulService.this.sendCallback(11, 1000);
                return;
            }
            TTSAPIMulService.this.sendCallback(10, 1000);
            TLog.i(TTSAPIMulService.TAG, "onServiceConnected getBinder = " + TTSAPIMulService.this.mOptTtsService.orElse(null));
        }

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            TLog.i(TTSAPIMulService.TAG, "onServiceConnected");
            try {
                bindRomTtsPlugin(IPluginService.Stub.asInterface(iBinder));
            } catch (RemoteException unused) {
                TTSAPIMulService.this.sendCallback(11, 1000);
                TLog.w(TTSAPIMulService.TAG, "onServiceConnected error");
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            TTSAPIMulService.this.sendCallback(12, 1000);
            TTSAPIMulService.this.mOptTtsService = Optional.empty();
            TTSAPIMulService.this.mOptConnection = Optional.empty();
            TTSAPIMulService.this.mTtsSpeakAbility = null;
            TLog.d(TTSAPIMulService.TAG, "onServiceDisconnected - Success");
        }
    }

    public TTSAPIMulService(Context context, TtsCallback ttsCallback, int i) {
        TtsSharedProperty.getInstance().doInit(context);
        TLog.i(TAG, "TTSAPIMulService create tts sdk version: 14.24.9.210, flag: " + i);
        this.mContext = context;
        this.mInvokerCallback = ttsCallback;
        setPluginFlag(i);
    }

    private InitParams buildInitParams(Bundle bundle) {
        InitParams initParams = new InitParams();
        if (bundle.containsKey("speed")) {
            initParams.setSpeed(bundle.getInt("speed"));
        }
        if (bundle.containsKey("volume")) {
            initParams.setVolume(bundle.getInt("volume"));
        }
        if (bundle.containsKey("pitch")) {
            initParams.setPitch(bundle.getInt("pitch"));
        }
        return initParams;
    }

    private int connectToService(final Context context) {
        TLog.i(TAG, "connectToService");
        if (context == null) {
            TLog.w(TAG, "connectToService context is null");
            return 1;
        }
        this.mContext = context;
        Optional<TtsMulConnection> of = Optional.of(new TtsMulConnection());
        this.mOptConnection = of;
        return ((Integer) of.map(new Function() {
            @Override
            public final Object apply(Object obj) {
                Integer lambda$connectToService$0;
                lambda$connectToService$0 = TTSAPIMulService.this.lambda$connectToService$0(context, (TTSAPIMulService.TtsMulConnection) obj);
                return lambda$connectToService$0;
            }
        }).orElse(1)).intValue();
    }

    private int convertDeviceType(String str) {
        char c;
        TLog.i(TAG, "deviceCategory is " + str);
        int i = 0;
        if (!TextUtils.isEmpty(str)) {
            switch (str.hashCode()) {
                case -2008522753:
                    if (str.equals("speaker")) {
                        c = 2;
                        break;
                    }
                    c = 65535;
                    break;
                case -32507752:
                    if (str.equals("intelligentWatch")) {
                        c = 5;
                        break;
                    }
                    c = 65535;
                    break;
                case -16697925:
                    if (str.equals("sportWatch")) {
                        c = 6;
                        break;
                    }
                    c = 65535;
                    break;
                case 3324:
                    if (str.equals("hd")) {
                        c = 4;
                        break;
                    }
                    c = 65535;
                    break;
                case 108073:
                    if (str.equals("mhd")) {
                        c = 1;
                        break;
                    }
                    c = 65535;
                    break;
                case 110739:
                    if (str.equals("pad")) {
                        c = 3;
                        break;
                    }
                    c = 65535;
                    break;
                case 106642798:
                    if (str.equals("phone")) {
                        c = 0;
                        break;
                    }
                    c = 65535;
                    break;
                case 108668202:
                    if (str.equals("glasses")) {
                        c = 7;
                        break;
                    }
                    c = 65535;
                    break;
                default:
                    c = 65535;
                    break;
            }
            if (c != 0) {
                if (c == 1 || c == 2) {
                    i = 1;
                } else if (c == 3) {
                    i = 3;
                } else if (c == 4) {
                    i = 4;
                }
            }
            TLog.i(TAG, "convertDeviceType is " + i);
        }
        return i;
    }

    private InitParams convertFromIntent(Intent intent) {
        Bundle extras;
        InitParams initParams = new InitParams();
        if (intent != null && (extras = intent.getExtras()) != null) {
            if (extras.containsKey(BaseConstants.INTENT_AK)) {
                initParams.setAccessKey(extras.getString(BaseConstants.INTENT_AK));
            }
            if (extras.containsKey("sk")) {
                initParams.setSecretKey(extras.getString("sk"));
            }
            if (extras.containsKey("ttsMode")) {
                initParams.setTtsMode(extras.getInt("ttsMode"));
            }
            if (extras.containsKey("deviceId")) {
                initParams.setDeviceId(extras.getString("deviceId"));
            }
            if (extras.containsKey("deviceType")) {
                initParams.setDeviceType(extras.getInt("deviceType"));
            }
            if (extras.containsKey("deviceCategory")) {
                initParams.setDeviceType(convertDeviceType(extras.getString("deviceCategory")));
            }
            if (extras.containsKey("speaker")) {
                initParams.setSpeaker(extras.getInt("speaker"));
            }
            if (extras.containsKey("deviceName")) {
                initParams.setDeviceName(extras.getString("deviceName"));
            }
            if (extras.containsKey("osVersion")) {
                initParams.setOsVersion(extras.getString("osVersion"));
            }
            if (extras.containsKey("romVersion")) {
                initParams.setRomVersion(extras.getString("romVersion"));
            }
        }
        return initParams;
    }

    private String convertLangugageType(Bundle bundle) {
        String string = (bundle == null || !bundle.containsKey("language")) ? "" : bundle.getString("language");
        TLog.i(TAG, "before convert, lanType is " + string);
        if (TextUtils.isEmpty(string)) {
            TLog.i(TAG, "lanType is empty, use origin language");
            string = this.mOriginLanguage;
        }
        if (SystemPropertyUtil.isOversea()) {
            return string;
        }
        String str = (string.equalsIgnoreCase("cn") || string.equalsIgnoreCase("zh")) ? "0" : string;
        if (string.equalsIgnoreCase("en") || string.equalsIgnoreCase(LANGUAGE_EN_US)) {
            str = "1";
        }
        TLog.i(TAG, "after convert lanType is " + str);
        return str;
    }

    private int doInitInner(Intent intent, ITtsService iTtsService) {
        TtsSpeakAbility ttsSpeakAbility;
        try {
            if (this.isAutoInvoke) {
                if (!SystemPropertyUtil.isOversea() && (ttsSpeakAbility = this.mTtsSpeakAbility) != null) {
                    Optional.ofNullable(ttsSpeakAbility).ifPresent(new Consumer() {
                        @Override
                        public final void accept(Object obj) {
                            ((TtsSpeakAbility) obj).getVersionSetting();
                        }
                    });
                }
                if (this.mPlugin == 524288) {
                    TLog.i(TAG, "copyEngineResult = " + iTtsService.initOnAppStart(this.mLocalTtsCallback));
                    if (iTtsService.doInit(convertFromIntent(intent), this.mLocalTtsCallback)) {
                        return 100;
                    }
                    return LocalTtsError.DO_INIT_OLD_INTERFACE_FAILED;
                }
            }
            setSampleRateIfNeed(intent);
            return iTtsService.doInitAS(intent, this.mLocalTtsCallback);
        } catch (RemoteException unused) {
            TLog.e(TAG, "doInit RemoteException");
            return 102;
        } catch (Exception e) {
            TLog.e(TAG, "doInit " + e.getClass().getCanonicalName());
            TLog.d(TAG, "doInit exception msg: " + e.getLocalizedMessage());
            return 103;
        }
    }

    private void doReleaseInner(final Intent intent, final boolean z) {
        this.mOriginLanguage = "";
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$doReleaseInner$11(z, intent, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "doRelease service unbind");
            sendCallback(101, 1006);
        }
    }

    private int doSpeakOldIntf(ITtsService iTtsService, String str, Intent intent) throws RemoteException {
        TLog.i(TAG, "doSpeakOldIntf");
        if (intent == null || intent.getExtras() == null) {
            TLog.i(TAG, "doSpeakOldIntf params intent is null");
            return -100;
        }
        Bundle extras = intent.getExtras();
        if (!iTtsService.setParams(buildInitParams(extras), this.mLocalTtsCallback)) {
            TLog.i(TAG, "setParamsResult false");
            return -109;
        }
        if (!(extras.containsKey("streamType") ? iTtsService.setStreamType(extras.getInt("streamType"), this.mLocalTtsCallback) : true)) {
            TLog.i(TAG, "setStreamResult false");
            return LocalTtsError.SET_STREAM_OLD_INTERFACE_FAILED;
        }
        String version = getVersion();
        TLog.i(TAG, "pluginVersion is " + version);
        if (SystemPropertyUtil.compareVersion(version, MethodVerConstants.SET_LANGUAGE_TYPE_VERSION_CODE)) {
            iTtsService.setLanguageType(convertLangugageType(extras), this.mLocalTtsCallback);
        } else {
            TLog.i(TAG, "setLanguageType method not exits");
        }
        if (extras.containsKey(BaseConstants.INTENT_TEXTTYPE) && BaseConstants.SSML_TEXT_TYPE.equals(extras.getString(BaseConstants.INTENT_TEXTTYPE))) {
            TLog.e(TAG, "old interface not support ssml type");
        }
        String string = extras.containsKey("utteranceId") ? extras.getString("utteranceId") : null;
        if (TextUtils.isEmpty(string)) {
            string = UUID.randomUUID().toString();
        }
        this.mOriginUtteranceId = string;
        return invokeOldIntfLogic(iTtsService, str, string);
    }

    private void doSpeakStopInner(final Intent intent, final boolean z) {
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$doSpeakStopInner$10(z, intent, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "doSpeakStop service unbind");
            sendCallback(101, 1005);
        }
    }

    private void flagTtsAsPlugin() {
        this.isAutoInvoke = false;
        this.mPlugin = PluginId.TTS_AS_PLUGIN_ID;
    }

    private void flagTtsPlugin() {
        this.isAutoInvoke = false;
        this.mPlugin = PluginId.TTS_PLUGIN_ID;
    }

    private void flagTtsPluginAuto() {
        this.isAutoInvoke = true;
        if (SystemPropertyUtil.isOversea()) {
            TLog.i(TAG, PluginLabelConstants.REGION_OVERSEA);
            this.mPlugin = PluginId.TTS_PLUGIN_ID;
        } else if (TtsStringUtil.isHonorStr()) {
            TLog.i(TAG, "honor device");
            this.mPlugin = PluginId.TTS_AS_PLUGIN_ID;
        } else if (SystemPropertyUtil.getEMUIVersionCode() < 1100) {
            TLog.i(TAG, "TTS_PLUGIN_ID");
            this.mPlugin = PluginId.TTS_PLUGIN_ID;
        } else {
            TLog.i(TAG, "TTS_AS_PLUGIN_ID");
            this.mPlugin = PluginId.TTS_AS_PLUGIN_ID;
        }
    }

    private void flagTtsTalkbackPlugin() {
        this.isAutoInvoke = false;
        this.mPlugin = PluginId.TTS_TALKBACK_PLUGIN_ID;
    }

    private int getConstant(Class<?> cls, Object obj, String str) {
        Field orElse = ReflectUtil.getField(cls, str).orElse(null);
        if (orElse == null) {
            return -1;
        }
        return ReflectUtil.getFieldInt(obj, orElse);
    }

    private String getLanFromInitIntent(Intent intent) {
        Bundle extras;
        return (intent == null || (extras = intent.getExtras()) == null || !extras.containsKey("language")) ? "" : extras.getString("language");
    }

    private int[] getSplitArray(Class<?> cls, Object obj, String str, ApplicationInfo applicationInfo, int[] iArr) {
        Object orElse = ReflectUtil.invoke(obj, ReflectUtil.getMethod(cls, str, ApplicationInfo.class).orElse(null), applicationInfo).orElse(null);
        return orElse instanceof int[] ? (int[]) orElse : iArr;
    }

    private int invokeOldIntfLogic(ITtsService iTtsService, final String str, final String str2) throws RemoteException {
        TLog.i(TAG, "invokeOldIntfLogic");
        if (str != null && str.length() > 512 && !SystemPropertyUtil.isOversea()) {
            Optional.ofNullable(this.mTtsSpeakAbility).ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.lambda$invokeOldIntfLogic$27(str, str2, (TtsSpeakAbility) obj);
                }
            });
            return 100;
        }
        Optional.ofNullable(this.mTtsSpeakAbility).ifPresent(new Consumer() {
            @Override
            public final void accept(Object obj) {
                ((TtsSpeakAbility) obj).setQueueSize(1);
            }
        });
        iTtsService.doSpeak(str, str2, this.mLocalTtsCallback);
        return 100;
    }

    private boolean isPluginSupportFeature(String str) {
        if (TextUtils.isEmpty(str)) {
            TLog.i(TAG, "isPluginSupportFeature featureName is null or empty");
            return false;
        }
        Bundle bundle = new Bundle();
        bundle.putStringArray("featureNames", new String[]{str});
        Optional<Bundle> pluginSupportFeatures = getPluginSupportFeatures(bundle);
        boolean z = pluginSupportFeatures.isPresent() ? pluginSupportFeatures.get().getBoolean(str) : false;
        TLog.i(TAG, "isPluginSupportFeature " + str + " = " + z);
        return z;
    }

    public boolean isSpeakEnd(String str, String str2, int i) {
        TLog.i(TAG, "splitNum = " + i + ", utteranceId = " + str2 + ", originUtteranceId = " + str);
        if (i < 0) {
            TLog.e(TAG, "splitNum illegal");
            return true;
        }
        if (i == 1) {
            TLog.i(TAG, "only one");
            return true;
        }
        if (TextUtils.isEmpty(str2)) {
            TLog.i(TAG, "isSpeakEnd utteranceId is empty");
            return true;
        }
        if (str2.equals(str) || !str2.startsWith(str)) {
            return true;
        }
        String valueOf = String.valueOf(i - 1);
        String substring = str2.substring(str.length());
        TLog.i(TAG, "first part is " + valueOf + ", second part is " + substring);
        return valueOf.equals(substring);
    }

    private boolean isSpeakingInner(final Intent intent, final boolean z) {
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$isSpeakingInner$13;
                    lambda$isSpeakingInner$13 = TTSAPIMulService.this.lambda$isSpeakingInner$13(z, intent, (ITtsService) obj);
                    return lambda$isSpeakingInner$13;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "isSpeaking service unbind");
        return false;
    }

    public static Boolean lambda$checkServerVersion$17(int i, ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.checkServerVersion(i));
        } catch (RemoteException unused) {
            TLog.e(TAG, "checkServerVersion RemoteException");
            return Boolean.FALSE;
        }
    }

    public Integer lambda$connectToService$0(Context context, TtsMulConnection ttsMulConnection) {
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.huawei.hiai", HIAI_FRAME_NAME));
        try {
            if (context.bindService(intent, ttsMulConnection, 1)) {
                TLog.i(TAG, "bind to recognition service success");
                return 0;
            }
        } catch (SecurityException | NoSuchElementException unused) {
            TLog.e(TAG, "bind to recognition service exception");
        }
        TLog.w(TAG, "bind to recognition service failed");
        this.mOptConnection = Optional.empty();
        this.mOptTtsService = Optional.empty();
        return 1;
    }

    public Integer lambda$deleteTargetEngine$25(Intent intent, ITtsService iTtsService) {
        try {
            return Integer.valueOf(iTtsService.deleteTargetEngine(intent, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "deleteTargetEngine RemoteException");
            return 102;
        }
    }

    public void lambda$destroy$1(TtsMulConnection ttsMulConnection) {
        try {
            this.mContext.unbindService(ttsMulConnection);
        } catch (IllegalArgumentException | SecurityException | NoSuchElementException e) {
            TLog.d(TAG, "destroy unbindService exception: " + e.getMessage());
            TLog.e(TAG, "destroy unbindService exception");
        }
        this.mOptTtsService = Optional.empty();
        this.mOptConnection = Optional.empty();
    }

    public void lambda$doBatchSpeak$9(List list, String str, ITtsService iTtsService) {
        try {
            iTtsService.doBatchSpeak(list, str, this.mLocalTtsCallback);
            sendCallback(100, 1002);
        } catch (RemoteException unused) {
            sendCallback(102, 1002);
        }
    }

    public Boolean lambda$doInit$3(InitParams initParams, ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.doInit(initParams, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "doInit RemoteException");
            return Boolean.FALSE;
        }
    }

    public Integer lambda$doInit$4(Intent intent, ITtsService iTtsService) {
        return Integer.valueOf(doInitInner(intent, iTtsService));
    }

    public void lambda$doOnlySynthesis$18(String str, String str2, ITtsService iTtsService) {
        try {
            iTtsService.doOnlySynthesis(str, str2, this.mLocalTtsCallback);
            sendCallback(100, 1007);
        } catch (RemoteException unused) {
            sendCallback(102, 1007);
        }
    }

    public void lambda$doReleaseInner$11(boolean z, Intent intent, ITtsService iTtsService) {
        try {
            if (!z) {
                iTtsService.doRelease(this.mLocalTtsCallback);
                sendCallback(100, 1006);
            } else if (intent == null) {
                TLog.e(TAG, "doReleaseV2 intent is null");
                sendCallback(-100, 1006);
            } else {
                iTtsService.doReleaseV2(intent, this.mLocalTtsCallback);
                sendCallback(100, 1006);
            }
        } catch (RemoteException e) {
            TLog.d(TAG, "doRelease remoteException: " + e.getMessage());
            TLog.e(TAG, "doRelease remoteException");
            sendCallback(102, 1006);
        }
    }

    public void lambda$doSpeak$7(String str, String str2, ITtsService iTtsService) {
        try {
            iTtsService.doSpeak(str, str2, this.mLocalTtsCallback);
            sendCallback(100, 1001);
        } catch (RemoteException unused) {
            sendCallback(102, 1001);
        }
    }

    public Integer lambda$doSpeak$8(String str, Intent intent, ITtsService iTtsService) {
        try {
            if (this.isAutoInvoke && this.mPlugin == 524288) {
                return Integer.valueOf(doSpeakOldIntf(iTtsService, str, intent));
            }
            modifySession(intent);
            modifyLanguage(intent);
            setSampleRateIfNeed(intent);
            return Integer.valueOf(iTtsService.doSpeakAS(str, intent, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "doSpeak RemoteException");
            return 102;
        }
    }

    public void lambda$doSpeakLongText$23(String str, String str2, ITtsService iTtsService) {
        try {
            iTtsService.doSpeakLongText(str, str2, this.mLocalTtsCallback);
            sendCallback(100, MethodIdConstants.METHOD_DO_SPEAK_LONG_TEXT);
        } catch (RemoteException unused) {
            sendCallback(102, MethodIdConstants.METHOD_DO_SPEAK_LONG_TEXT);
        }
    }

    public void lambda$doSpeakOnlyPreDecode$16(String str, String str2, int i, ITtsService iTtsService) {
        try {
            iTtsService.doSpeakOnlyPreDecode(str, str2, i, this.mLocalTtsCallback);
            sendCallback(100, 1003);
        } catch (RemoteException unused) {
            sendCallback(102, 1003);
        }
    }

    public void lambda$doSpeakStopInner$10(boolean z, Intent intent, ITtsService iTtsService) {
        try {
            if (!z) {
                iTtsService.doSpeakStop(this.mLocalTtsCallback);
                sendCallback(100, 1005);
            } else if (intent == null) {
                TLog.e(TAG, "doSpeakStopV2 intent is null");
                sendCallback(-100, 1005);
            } else {
                iTtsService.doSpeakStopV2(intent, this.mLocalTtsCallback);
                sendCallback(100, 1005);
            }
        } catch (RemoteException e) {
            TLog.d(TAG, "doSpeakStop remoteException: " + e.getMessage());
            TLog.e(TAG, "doSpeakStop remoteException");
            sendCallback(102, 1005);
        }
    }

    public void lambda$downloadTargetEngine$20(String str, ITtsService iTtsService) {
        try {
            iTtsService.downloadTargetEngine(str, this.mLocalTtsCallback);
            sendCallback(100, MethodIdConstants.METHOD_DOWNLOAD_TARGET_ENGINE);
        } catch (RemoteException unused) {
            sendCallback(102, MethodIdConstants.METHOD_DOWNLOAD_TARGET_ENGINE);
        }
    }

    public void lambda$downloadTargetEngines$21(List list, ITtsService iTtsService) {
        try {
            iTtsService.downloadTargetEngines(list, this.mLocalTtsCallback);
            sendCallback(100, MethodIdConstants.METHOD_DOWNLOAD_TARGET_ENGINE);
        } catch (RemoteException unused) {
            sendCallback(102, MethodIdConstants.METHOD_DOWNLOAD_TARGET_ENGINE);
        }
    }

    public Long lambda$getSupportMaxLength$22(ITtsService iTtsService) {
        try {
            return Long.valueOf(iTtsService.getSupportMaxLength(this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "getSupportMaxLength RemoteException");
            return -1L;
        }
    }

    public String lambda$getVersion$12(ITtsService iTtsService) {
        try {
            return iTtsService.getVersion(this.mLocalTtsCallback);
        } catch (RemoteException unused) {
            TLog.e(TAG, "getVersion RemoteException");
            return "";
        }
    }

    public Boolean lambda$initOnAppStart$2(ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.initOnAppStart(this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "initOnAppStart RemoteException");
            return Boolean.FALSE;
        }
    }

    public static void lambda$invokeOldIntfLogic$27(String str, String str2, TtsSpeakAbility ttsSpeakAbility) {
        ttsSpeakAbility.resetQueueSize();
        ttsSpeakAbility.doTextSpeak(str, str2);
    }

    public Boolean lambda$isEngineExist$19(String str, ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.isEngineExist(str, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "isEngineExist RemoteException");
            return Boolean.FALSE;
        }
    }

    public Boolean lambda$isSpeakingInner$13(boolean z, Intent intent, ITtsService iTtsService) {
        try {
            if (!z) {
                return Boolean.valueOf(iTtsService.isSpeaking(this.mLocalTtsCallback));
            }
            if (intent != null) {
                return Boolean.valueOf(iTtsService.isSpeakingV2(intent, this.mLocalTtsCallback));
            }
            TLog.e(TAG, "isSpeakingV2 intent is null");
            return Boolean.FALSE;
        } catch (RemoteException e) {
            TLog.d(TAG, "isSpeaking remoteException: " + e.getMessage());
            TLog.e(TAG, "isSpeaking remoteException");
            return Boolean.FALSE;
        }
    }

    public Integer lambda$prepare$26(Intent intent, ITtsService iTtsService) {
        try {
            return Integer.valueOf(iTtsService.prepare(intent, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "prepare RemoteException");
            return 102;
        }
    }

    public void lambda$setIsSaveTtsData$5(boolean z, ITtsService iTtsService) {
        try {
            iTtsService.setIsSaveTtsData(z, this.mLocalTtsCallback);
            sendCallback(100, 1004);
        } catch (RemoteException unused) {
            sendCallback(102, 1004);
        }
    }

    public Boolean lambda$setLanguageType$24(String str, ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.setLanguageType(str, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "setLanguageType RemoteException");
            return Boolean.FALSE;
        }
    }

    public Boolean lambda$setLogLevel$15(int i, boolean z, ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.setLogLevel(i, z, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "setLogLevel RemoteException");
            return Boolean.FALSE;
        }
    }

    public Boolean lambda$setParams$6(InitParams initParams, ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.setParams(initParams, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "setParams RemoteException");
            return Boolean.FALSE;
        }
    }

    public Boolean lambda$setStreamType$14(int i, ITtsService iTtsService) {
        try {
            return Boolean.valueOf(iTtsService.setStreamType(i, this.mLocalTtsCallback));
        } catch (RemoteException unused) {
            TLog.e(TAG, "setStreamType RemoteException");
            return Boolean.FALSE;
        }
    }

    private void modifyLanguage(Intent intent) {
        Bundle extras;
        String str;
        if (intent == null || (extras = intent.getExtras()) == null) {
            return;
        }
        if (extras.containsKey("language")) {
            str = extras.getString("language");
            TLog.i(TAG, "invoker pass language " + str + " when doSpeak");
        } else {
            str = "";
        }
        if (TextUtils.isEmpty(str)) {
            TLog.i(TAG, "modifyLanguage to default language");
            str = this.mOriginLanguage;
        }
        if (!"zh".equals(str)) {
            extras.putString("language", str);
            intent.putExtras(extras);
        } else {
            TLog.i(TAG, "modifyLanguage zh to cn");
            extras.putString("language", "cn");
            intent.putExtras(extras);
        }
    }

    private void modifySession(Intent intent) {
        Bundle extras;
        if (intent != null && (extras = intent.getExtras()) != null && extras.containsKey("session") && TextUtils.isEmpty(extras.getString("session"))) {
            extras.putString("session", "{}");
            intent.putExtras(extras);
        }
    }

    private int parseVersionCode() {
        TLog.i(TAG, "getPackageVersion");
        Context context = this.mContext;
        if (context == null) {
            TLog.e(TAG, "context null");
            return -1;
        }
        PackageManager packageManager = context.getPackageManager();
        if (packageManager == null) {
            TLog.e(TAG, "getVersionCode get PackageManager failed");
            return -1;
        }
        try {
            ApplicationInfo applicationInfo = packageManager.getApplicationInfo("com.huawei.hiai", PathType.ROUTE_RESTRICTION);
            Class<?> orElse = ReflectUtil.forName("com.huawei.android.content.pm.ApplicationInfoEx").orElse(null);
            Object orElse2 = ReflectUtil.newInstance(ReflectUtil.getDeclaredConstructor(orElse, ApplicationInfo.class).orElse(null), applicationInfo).orElse(null);
            int i = 0;
            int[] iArr = new int[0];
            int[] splitArray = getSplitArray(orElse, orElse2, "getSplitVersionCodes", applicationInfo, iArr);
            int[] splitArray2 = getSplitArray(orElse, orElse2, "getHwSplitFlags", applicationInfo, iArr);
            int constant = getConstant(orElse, orElse2, "FLAG_HW_SPLIT_CONFIG");
            int constant2 = getConstant(orElse, orElse2, "FLAG_HW_SPLIT_FEATURE");
            int constant3 = getConstant(orElse, orElse2, "FLAG_HW_SPLIT_PLUGIN");
            while (true) {
                String[] strArr = applicationInfo.splitNames;
                if (i >= strArr.length) {
                    break;
                }
                int i2 = splitArray2[i];
                String str = strArr[i];
                if ((i2 & constant) != 0) {
                    TLog.w(TAG, "getVersionCode configuration：" + str);
                } else if ((i2 & constant2) == 0) {
                    TLog.w(TAG, "getVersionCode unknown split：" + str);
                } else if ((i2 & constant3) == 0) {
                    TLog.w(TAG, "getVersionCode dynamic-feature：" + str);
                } else {
                    int i3 = splitArray[i];
                    if ("tts".equals(str)) {
                        TLog.i(TAG, "getVersionCode pluginName：" + str + " versionCode：" + i3);
                        return i3;
                    }
                }
                i++;
            }
        } catch (PackageManager.NameNotFoundException unused) {
            TLog.e(TAG, "app is not installed:com.huawei.hiai");
        }
        return -1;
    }

    public void sendCallback(int i, int i2) {
        Bundle bundle = new Bundle();
        bundle.putInt(MethodIdConstants.BUNDLE_KEY_METHOD_ID, i2);
        try {
            this.mLocalTtsCallback.onEvent(i, bundle);
        } catch (RemoteException e) {
            TLog.e(TAG, "sendCallback onEvent remoteException: " + e.getMessage());
        }
    }

    private void setPluginFlag(int i) {
        TLog.i(TAG, "setPluginFlag = " + i);
        if (i == -1) {
            flagTtsPluginAuto();
            return;
        }
        if (i == 0) {
            flagTtsPlugin();
            return;
        }
        if (i == 1) {
            flagTtsAsPlugin();
        } else if (i != 2) {
            this.mPlugin = PluginId.TTS_PLUGIN_ID;
        } else {
            flagTtsTalkbackPlugin();
        }
    }

    private void setSampleRateIfNeed(Intent intent) {
        Bundle extras;
        if (intent == null || (extras = intent.getExtras()) == null || !isSupportSampleRate()) {
            return;
        }
        extras.putInt("sampleRate", BaseConstants.SAMPLE_RATE_24K);
        intent.putExtras(extras);
    }

    public void bindTtsService() {
        int connectToService;
        synchronized (LOCK) {
            try {
                TLog.i(TAG, "bindTtsService");
                if (!isBind() && (connectToService = connectToService(this.mContext)) != 0) {
                    sendCallback(connectToService, 1000);
                } else {
                    if (this.isAutoInvoke) {
                        this.mTtsSpeakAbility = new TtsSpeakAbility(this);
                    }
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public boolean checkServerVersion(final int i) {
        TLog.i(TAG, "checkServerVersion");
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$checkServerVersion$17;
                    lambda$checkServerVersion$17 = TTSAPIMulService.lambda$checkServerVersion$17(i, (ITtsService) obj);
                    return lambda$checkServerVersion$17;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "checkServerVersion service unbind");
        return false;
    }

    @Override
    public int deleteTargetEngine(final Intent intent) {
        TLog.i(TAG, "deleteTargetEngine");
        if (isBind()) {
            return ((Integer) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Integer lambda$deleteTargetEngine$25;
                    lambda$deleteTargetEngine$25 = TTSAPIMulService.this.lambda$deleteTargetEngine$25(intent, (ITtsService) obj);
                    return lambda$deleteTargetEngine$25;
                }
            }).orElse(101)).intValue();
        }
        TLog.e(TAG, "deleteTargetEngine service unbind");
        return 101;
    }

    public void destroy() {
        synchronized (LOCK) {
            try {
                TLog.i(TAG, "destroy");
                if (this.mContext == null) {
                    TLog.i(TAG, "destroy context is null");
                } else {
                    this.mOptConnection.ifPresent(new Consumer() {
                        @Override
                        public final void accept(Object obj) {
                            TTSAPIMulService.this.lambda$destroy$1((TTSAPIMulService.TtsMulConnection) obj);
                        }
                    });
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public void doBatchSpeak(final List<String> list, final String str) {
        TLog.i(TAG, "doBatchSpeak");
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$doBatchSpeak$9(list, str, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "doBatchSpeak service unbind");
            sendCallback(101, 1002);
        }
    }

    @Override
    public boolean doInit(final InitParams initParams) {
        synchronized (LOCK) {
            try {
                TLog.i(TAG, "doInit(InitParams) tts sdk version: 14.24.9.210");
                if (isBind()) {
                    return ((Boolean) this.mOptTtsService.map(new Function() {
                        @Override
                        public final Object apply(Object obj) {
                            Boolean lambda$doInit$3;
                            lambda$doInit$3 = TTSAPIMulService.this.lambda$doInit$3(initParams, (ITtsService) obj);
                            return lambda$doInit$3;
                        }
                    }).orElse(Boolean.FALSE)).booleanValue();
                }
                TLog.e(TAG, "doInit service unbind");
                return false;
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public void doOnlySynthesis(final String str, final String str2) {
        TLog.i(TAG, "doOnlySynthesis");
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$doOnlySynthesis$18(str, str2, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "doSpeakOnlyPreDecode service unbind");
            sendCallback(101, 1007);
        }
    }

    @Override
    public void doRelease() {
        synchronized (LOCK) {
            TLog.i(TAG, "doRelease");
            doReleaseInner(null, false);
        }
    }

    @Override
    public void doSpeak(final String str, final String str2) {
        TLog.i(TAG, "doSpeak(text, text)");
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$doSpeak$7(str, str2, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "doSpeak service unbind");
            sendCallback(101, 1001);
        }
    }

    @Override
    public void doSpeakLongText(final String str, final String str2) {
        TLog.i(TAG, "doSpeakLongText");
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$doSpeakLongText$23(str, str2, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "doSpeakLongText service unbind");
            sendCallback(101, MethodIdConstants.METHOD_DO_SPEAK_LONG_TEXT);
        }
    }

    @Override
    public void doSpeakOnlyPreDecode(final String str, final String str2, final int i) {
        TLog.i(TAG, "doSpeakOnlyPreDecode");
        if (!isBind()) {
            TLog.e(TAG, "doSpeakOnlyPreDecode service unbind");
            sendCallback(101, 1003);
        }
        this.mOptTtsService.ifPresent(new Consumer() {
            @Override
            public final void accept(Object obj) {
                TTSAPIMulService.this.lambda$doSpeakOnlyPreDecode$16(str, str2, i, (ITtsService) obj);
            }
        });
    }

    @Override
    public void doSpeakStop() {
        TLog.i(TAG, "doSpeakStop");
        doSpeakStopInner(null, false);
    }

    @Override
    public void downloadTargetEngine(final String str) {
        TLog.i(TAG, "downloadTargetEngine");
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$downloadTargetEngine$20(str, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "downloadTargetEngine service unbind");
            sendCallback(101, MethodIdConstants.METHOD_DOWNLOAD_TARGET_ENGINE);
        }
    }

    public void downloadTargetEngines(final List<String> list) {
        TLog.i(TAG, "downloadTargetEngine");
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$downloadTargetEngines$21(list, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "downloadTargetEngine service unbind");
            sendCallback(101, MethodIdConstants.METHOD_DOWNLOAD_TARGET_ENGINE);
        }
    }

    public Optional<Bundle> getPluginSupportFeatures(Bundle bundle) {
        TLog.i(TAG, "enter getPluginSupportFeatures");
        if (bundle == null) {
            TLog.w(TAG, "getPluginSupportFeatures params bundle is null");
            return Optional.empty();
        }
        Context context = this.mContext;
        if (context == null) {
            TLog.w(TAG, "getPluginSupportFeatures mContext is null");
            return Optional.empty();
        }
        Uri uri = URI_HIAI_TTS_ENGINE_PROVIDER;
        if (!AppUtil.isValidUri(context, uri)) {
            TLog.w(TAG, "getPluginSupportFeatures uri not belongs to hiai");
            return Optional.empty();
        }
        try {
            return Optional.ofNullable(this.mContext.getContentResolver().call(uri, ParamsConstants.METHOD_CHECK_FEATURES, "", bundle));
        } catch (IllegalArgumentException | SecurityException e) {
            TLog.e(TAG, "getPluginSupportFeatures method not supported or insufficient permission " + e.getMessage());
            return Optional.empty();
        }
    }

    @Override
    public long getSupportMaxLength() {
        TLog.i(TAG, "getSupportMaxLength");
        if (isBind()) {
            return ((Long) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Long lambda$getSupportMaxLength$22;
                    lambda$getSupportMaxLength$22 = TTSAPIMulService.this.lambda$getSupportMaxLength$22((ITtsService) obj);
                    return lambda$getSupportMaxLength$22;
                }
            }).orElse(-1L)).longValue();
        }
        TLog.e(TAG, "getSupportMaxLength service unbind");
        return -1L;
    }

    @Override
    public String getVersion() {
        if (isBind()) {
            return (String) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    String lambda$getVersion$12;
                    lambda$getVersion$12 = TTSAPIMulService.this.lambda$getVersion$12((ITtsService) obj);
                    return lambda$getVersion$12;
                }
            }).orElse("");
        }
        TLog.e(TAG, "service unbind, get version from framework");
        return "";
    }

    @Override
    public int getVersionCode() {
        return parseVersionCode();
    }

    @Override
    public boolean initOnAppStart() {
        TLog.i(TAG, "initOnAppStart");
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$initOnAppStart$2;
                    lambda$initOnAppStart$2 = TTSAPIMulService.this.lambda$initOnAppStart$2((ITtsService) obj);
                    return lambda$initOnAppStart$2;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "initOnAppStart service unbind");
        return false;
    }

    public boolean isBind() {
        if (this.mOptTtsService.isPresent()) {
            return true;
        }
        TLog.i(TAG, "mTtsService is unbind.");
        return false;
    }

    @Override
    public boolean isEngineExist(final String str) {
        TLog.i(TAG, "isEngineExist");
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$isEngineExist$19;
                    lambda$isEngineExist$19 = TTSAPIMulService.this.lambda$isEngineExist$19(str, (ITtsService) obj);
                    return lambda$isEngineExist$19;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "isEngineExist service unbind");
        return false;
    }

    public boolean isHuanYuEngine() {
        TLog.i(TAG, "enter isHuanyuEngine");
        return isPluginSupportFeature(ParamsConstants.SUPPORT_HUANYU_ENGINE);
    }

    @Override
    public boolean isSpeaking() {
        TLog.i(TAG, "isSpeaking");
        return isSpeakingInner(null, false);
    }

    public boolean isSupportCompressRate() {
        TLog.i(TAG, "enter isSupportCompressRate");
        return isPluginSupportFeature(ParamsConstants.SUPPORT_COMPRESS_RATE);
    }

    public boolean isSupportMultiInstance() {
        TLog.i(TAG, "enter isSupportMultiInstance");
        return isPluginSupportFeature(ParamsConstants.SUPPORT_MULTI_INSTANCE);
    }

    public boolean isSupportMultiSpeaker() {
        TLog.i(TAG, "enter isSupportMultiSpeaker");
        return isPluginSupportFeature(ParamsConstants.SUPPORT_MULTI_SPEAKER);
    }

    public boolean isSupportSampleRate() {
        TLog.i(TAG, "enter isSupportSampleRate");
        return isPluginSupportFeature(ParamsConstants.SUPPORT_SAMPLE_RATE);
    }

    @Override
    public int prepare(final Intent intent) {
        TLog.i(TAG, HttpConfig.HTTP_PREPARE_TAG);
        if (isBind()) {
            return ((Integer) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Integer lambda$prepare$26;
                    lambda$prepare$26 = TTSAPIMulService.this.lambda$prepare$26(intent, (ITtsService) obj);
                    return lambda$prepare$26;
                }
            }).orElse(101)).intValue();
        }
        TLog.e(TAG, "prepare service unbind");
        return 101;
    }

    @Override
    public void setIsSaveTtsData(final boolean z) {
        TLog.i(TAG, "setIsSaveTtsData");
        if (isBind()) {
            this.mOptTtsService.ifPresent(new Consumer() {
                @Override
                public final void accept(Object obj) {
                    TTSAPIMulService.this.lambda$setIsSaveTtsData$5(z, (ITtsService) obj);
                }
            });
        } else {
            TLog.e(TAG, "setIsSaveTtsData service unbind");
            sendCallback(101, 1004);
        }
    }

    @Override
    public boolean setLanguageType(final String str) {
        TLog.i(TAG, "setLanguageType");
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$setLanguageType$24;
                    lambda$setLanguageType$24 = TTSAPIMulService.this.lambda$setLanguageType$24(str, (ITtsService) obj);
                    return lambda$setLanguageType$24;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "setLanguageType service unbind");
        return false;
    }

    @Override
    public boolean setLogLevel(final int i, final boolean z) {
        TLog.i(TAG, "setLogLevel");
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$setLogLevel$15;
                    lambda$setLogLevel$15 = TTSAPIMulService.this.lambda$setLogLevel$15(i, z, (ITtsService) obj);
                    return lambda$setLogLevel$15;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "setLogLevel service unbind");
        return false;
    }

    @Override
    public boolean setParams(final InitParams initParams) {
        TLog.i(TAG, "setParams");
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$setParams$6;
                    lambda$setParams$6 = TTSAPIMulService.this.lambda$setParams$6(initParams, (ITtsService) obj);
                    return lambda$setParams$6;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "setParams service unbind");
        return false;
    }

    @Override
    public boolean setStreamType(final int i) {
        TLog.i(TAG, "setStreamType");
        if (isBind()) {
            return ((Boolean) this.mOptTtsService.map(new Function() {
                @Override
                public final Object apply(Object obj) {
                    Boolean lambda$setStreamType$14;
                    lambda$setStreamType$14 = TTSAPIMulService.this.lambda$setStreamType$14(i, (ITtsService) obj);
                    return lambda$setStreamType$14;
                }
            }).orElse(Boolean.FALSE)).booleanValue();
        }
        TLog.e(TAG, "setStreamType service unbind");
        return false;
    }

    @Override
    public void doSpeakStop(Intent intent) {
        TLog.i(TAG, "doSpeakStopV2");
        doSpeakStopInner(intent, true);
    }

    @Override
    public boolean isSpeaking(Intent intent) {
        TLog.i(TAG, "isSpeakingV2");
        return isSpeakingInner(intent, true);
    }

    @Override
    public void doRelease(Intent intent) {
        synchronized (LOCK) {
            TLog.i(TAG, "doReleaseV2");
            doReleaseInner(intent, true);
        }
    }

    @Override
    public int doSpeak(final String str, final Intent intent) {
        TLog.i(TAG, "doSpeak(text, intent)");
        if (!isBind()) {
            TLog.e(TAG, "doSpeak service unbind");
            return 101;
        }
        if (TextUtils.isEmpty(this.mOriginLanguage)) {
            TLog.i(TAG, "doSpeak failed default language empty");
            return -108;
        }
        return ((Integer) this.mOptTtsService.map(new Function() {
            @Override
            public final Object apply(Object obj) {
                Integer lambda$doSpeak$8;
                lambda$doSpeak$8 = TTSAPIMulService.this.lambda$doSpeak$8(str, intent, (ITtsService) obj);
                return lambda$doSpeak$8;
            }
        }).orElse(101)).intValue();
    }

    @Override
    public int doInit(final Intent intent) {
        synchronized (LOCK) {
            try {
                TLog.i(TAG, "doInit(Intent) tts sdk version: 14.24.9.210");
                if (!isBind()) {
                    TLog.e(TAG, "doInit service unbind");
                    return 101;
                }
                String lanFromInitIntent = getLanFromInitIntent(intent);
                this.mOriginLanguage = lanFromInitIntent;
                if (TextUtils.isEmpty(lanFromInitIntent)) {
                    TLog.w(TAG, "invoker set mOriginLanguage empty error");
                    return -108;
                }
                TLog.i(TAG, "invoker set mOriginLanguage " + this.mOriginLanguage);
                return ((Integer) this.mOptTtsService.map(new Function() {
                    @Override
                    public final Object apply(Object obj) {
                        Integer lambda$doInit$4;
                        lambda$doInit$4 = TTSAPIMulService.this.lambda$doInit$4(intent, (ITtsService) obj);
                        return lambda$doInit$4;
                    }
                }).orElse(101)).intValue();
            } catch (Throwable th) {
                throw th;
            }
        }
    }
}