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

package com.huawei.hiassistant.voice.abilityconnector.tts;

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.text.TextUtils;
import com.huawei.hiai.pdk.unifiedaccess.HttpConfig;
import com.huawei.hiassistant.platform.base.VoiceKitSdkContext;
import com.huawei.hiassistant.platform.base.bean.decision.DsEventCallerAppinfo;
import com.huawei.hiassistant.platform.base.bean.llmstatus.StreamingStatusManager;
import com.huawei.hiassistant.platform.base.module.ability.TtsAbilityInterface;
import com.huawei.hiassistant.platform.base.northinterface.Constants;
import com.huawei.hiassistant.platform.base.northinterface.recognize.RecognizerIntent;
import com.huawei.hiassistant.platform.base.northinterface.tts.ClientIdConstant;
import com.huawei.hiassistant.platform.base.report.OperationReportUtils;
import com.huawei.hiassistant.platform.base.report.fault.TtsFaultReporter;
import com.huawei.hiassistant.platform.base.util.AbilityConnectorThread;
import com.huawei.hiassistant.platform.base.util.BusinessFlowId;
import com.huawei.hiassistant.platform.base.util.FixedLinkedHashMap;
import com.huawei.hiassistant.platform.base.util.IAssistantConfig;
import com.huawei.hiassistant.platform.base.util.InterruptUtil;
import com.huawei.hiassistant.platform.base.util.KitLog;
import com.huawei.hiassistant.platform.base.util.PluginUtil;
import com.huawei.hiassistant.platform.base.util.SecureIntentUtil;
import com.huawei.hiassistant.platform.base.util.StringUtils;
import com.huawei.hiassistant.platform.base.util.TtsUtils;
import com.huawei.hiassistant.platform.base.util.UuidUtils;
import com.huawei.hiassistant.voice.abilityconnector.tts.TtsAbilityProxy;
import defpackage.jvb;
import defpackage.nsb;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.function.Consumer;

public class TtsAbilityProxy implements TtsAbilityInterface {
    public BaseTtsAbility c;
    public TtsAbilityInterface.Callback e;
    public String i;
    public String j;
    public Intent k;
    public String m;
    public MultiInstanceTimeoutListener n;
    public final Object a = new Object();
    public final Object b = new Object();
    public boolean d = false;
    public Map<String, String> f = new HashMap();
    public Map<String, TtsAbilityInterface.Callback> g = new HashMap();
    public volatile LinkedHashMap<String, Bundle> h = new FixedLinkedHashMap(20);
    public boolean l = true;
    public int o = Constants.Tts.DEFAULT_TONE_COLOR;
    public volatile String p = "";
    public CountDownTimer q = new a(InterruptUtil.DEFAULT_INTERRUPT_TIME_OUT, InterruptUtil.DEFAULT_INTERRUPT_TIME_OUT);
    public CountDownTimer r = new b(3000, 3000);

    public interface MultiInstanceTimeoutListener {
        void onTimeout(String str);

        void ttsToneChanged(String str);
    }

    public class c implements TtsAbilityInterface.Callback {
        public c() {
        }

        @Override
        public void onCanceled(Bundle bundle) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onCanceled()", new Object[0]);
        }

        @Override
        public void onInit() {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onInit()", new Object[0]);
        }

        @Override
        public void onPhonemeFinish(Bundle bundle, String str) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onPhonemeFinish()", new Object[0]);
        }

        @Override
        public void onPhonemeProgress(Bundle bundle, String str, int i, String str2) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onPhonemeProgress()", new Object[0]);
        }

        @Override
        public void onTtsDataFinish(Bundle bundle) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onTtsDataFinish", new Object[0]);
        }

        @Override
        public void onTtsDataProgress(Bundle bundle, byte[] bArr, int i) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onTtsDataProgress", new Object[0]);
        }

        @Override
        public void onTtsError(int i, String str, Bundle bundle) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onTtsError()", new Object[0]);
        }

        @Override
        public void onTtsFinish(Bundle bundle) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onTtsFinish()", new Object[0]);
        }

        @Override
        public void onTtsInterrupted(Bundle bundle) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onTtsInterrupted()", new Object[0]);
        }

        @Override
        public void onTtsProgressChanged(Bundle bundle, int i) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onTtsProgressChanged", new Object[0]);
        }

        @Override
        public void onTtsStart(Bundle bundle) {
            KitLog.debug("TtsAbilityProxy", "unexpected method call onTtsStart()", new Object[0]);
        }
    }

    public class d implements TtsListenerInterface {
        public String a;

        public d(String str) {
            this.a = str;
        }

        public final void b(TtsAbilityInterface.Callback callback) {
            callback.onTtsError(1, "init fail", TtsAbilityProxy.this.g(""));
        }

        @Override
        public void onDownloadTtsToneEngine(int i, String str) {
            Bundle bundle = new Bundle();
            bundle.putInt("errorCode", i);
            bundle.putString(HttpConfig.ERROR_MESSAGE_NAME, str);
            TtsAbilityInterface.Callback L = TtsAbilityProxy.this.L();
            if (L != null) {
                L.onDownloadTtsToneEngine(bundle);
            }
        }

        @Override
        public void onFormatChange(String str, Bundle bundle) {
            Bundle bundle2 = new Bundle();
            bundle2.putBundle("audioFormat", bundle);
            bundle2.putString("utteranceId", str);
            TtsAbilityProxy.this.n(str).onFormatChange(str, bundle2);
        }

        @Override
        public void onInit(int i) {
            KitLog.info("TtsListenerImpl", "TTS onInit finish ,result:" + i);
            synchronized (TtsAbilityProxy.this.a) {
                try {
                    if (!TtsAbilityProxy.this.v(this.a)) {
                        KitLog.info("TtsListenerImpl", "invalid tts callback");
                        return;
                    }
                    TtsAbilityProxy.this.q.cancel();
                    TtsAbilityProxy.this.w();
                    TtsAbilityInterface.Callback L = TtsAbilityProxy.this.L();
                    if (i == 0) {
                        Optional.ofNullable(L).ifPresent(new Consumer() {
                            @Override
                            public final void accept(Object obj) {
                                ((TtsAbilityInterface.Callback) obj).onInit();
                            }
                        });
                    } else {
                        Optional.ofNullable(L).ifPresent(new Consumer() {
                            @Override
                            public final void accept(Object obj) {
                                TtsAbilityProxy.d.this.b((TtsAbilityInterface.Callback) obj);
                            }
                        });
                    }
                    if (TtsAbilityProxy.this.I()) {
                        KitLog.debug("TtsListenerImpl", "hasCachedTts:{}", TtsAbilityProxy.this.j);
                        if (i != 0) {
                            TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
                            TtsAbilityInterface.Callback n = ttsAbilityProxy.n(ttsAbilityProxy.i);
                            TtsAbilityProxy ttsAbilityProxy2 = TtsAbilityProxy.this;
                            n.onTtsError(2, "tts is not init", ttsAbilityProxy2.g(ttsAbilityProxy2.i));
                        } else if (TtsAbilityProxy.this.c != null) {
                            TtsAbilityProxy.this.C();
                            TtsAbilityProxy.this.c.textToSpeak(TtsAbilityProxy.this.j, TtsAbilityProxy.this.i, TtsAbilityProxy.this.k);
                        }
                    }
                    TtsAbilityProxy.this.j = "";
                    TtsAbilityProxy.this.k = null;
                } catch (Throwable th) {
                    throw th;
                }
            }
        }

        @Override
        public void onPhonemeFinish(String str, String str2) {
            KitLog.debug("TtsListenerImpl", String.format(Locale.ROOT, "onPhonemeFinish::%s", KitLog.getSecurityString(str)), new Object[0]);
            if (TextUtils.isEmpty(TtsAbilityProxy.this.i)) {
                KitLog.error("TtsListenerImpl", "currentUtteranceId is empty ,ignore this callback");
                return;
            }
            if (TextUtils.isEmpty(str) || str.startsWith(TtsAbilityProxy.this.i)) {
                TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
                TtsAbilityInterface.Callback n = ttsAbilityProxy.n(ttsAbilityProxy.i);
                TtsAbilityProxy ttsAbilityProxy2 = TtsAbilityProxy.this;
                n.onPhonemeFinish(ttsAbilityProxy2.g(ttsAbilityProxy2.i), str2);
            }
        }

        @Override
        public void onPhonemeProgress(String str, String str2, int i, String str3) {
            KitLog.debug("TtsListenerImpl", String.format(Locale.ROOT, "onPhonemeProgress::%s#%s", Integer.valueOf(i), KitLog.getSecurityString(str)), new Object[0]);
            if (TextUtils.isEmpty(TtsAbilityProxy.this.i)) {
                KitLog.error("TtsListenerImpl", "currentUtteranceId is empty ,ignore this callback");
                return;
            }
            if (TextUtils.isEmpty(str) || str.startsWith(TtsAbilityProxy.this.i)) {
                TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
                TtsAbilityInterface.Callback n = ttsAbilityProxy.n(ttsAbilityProxy.i);
                TtsAbilityProxy ttsAbilityProxy2 = TtsAbilityProxy.this;
                n.onPhonemeProgress(ttsAbilityProxy2.g(ttsAbilityProxy2.i), str2, i, str3);
            }
        }

        @Override
        public void onTtsComplete(String str) {
            KitLog.info("TtsListenerImpl", "TTS onTtsComplete");
            TtsAbilityProxy.this.n(str).onTtsFinish(TtsAbilityProxy.this.g(str));
            if (TtsAbilityProxy.this.l) {
                TtsAbilityProxy.this.z("2");
                OperationReportUtils.getInstance().getDelayTimeRecord().setTtsEndTime(System.currentTimeMillis());
            }
            TtsAbilityProxy.this.w();
            TtsAbilityProxy.this.i = "";
        }

        @Override
        public void onTtsDataFinish(String str) {
            KitLog.debug("TtsListenerImpl", String.format(Locale.ROOT, "onTtsDataFinish::%s", KitLog.getSecurityString(str)), new Object[0]);
            if (TextUtils.isEmpty(TtsAbilityProxy.this.i)) {
                KitLog.error("TtsListenerImpl", "currentUtteranceId is empty ,ignore this callback");
                return;
            }
            if (TextUtils.isEmpty(str) || str.startsWith(TtsAbilityProxy.this.i)) {
                TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
                TtsAbilityInterface.Callback n = ttsAbilityProxy.n(ttsAbilityProxy.i);
                TtsAbilityProxy ttsAbilityProxy2 = TtsAbilityProxy.this;
                n.onTtsDataFinish(ttsAbilityProxy2.g(ttsAbilityProxy2.i));
            }
        }

        @Override
        public void onTtsDataProgress(String str, byte[] bArr, int i) {
            KitLog.debug("TtsListenerImpl", String.format(Locale.ROOT, "onTtsDataProgress::%s#%s", Integer.valueOf(i), KitLog.getSecurityString(str)), new Object[0]);
            if (TextUtils.isEmpty(TtsAbilityProxy.this.i)) {
                KitLog.error("TtsListenerImpl", "currentUtteranceId is empty ,ignore this callback");
                return;
            }
            if (TextUtils.isEmpty(str) || str.startsWith(TtsAbilityProxy.this.i)) {
                TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
                TtsAbilityInterface.Callback n = ttsAbilityProxy.n(ttsAbilityProxy.i);
                TtsAbilityProxy ttsAbilityProxy2 = TtsAbilityProxy.this;
                n.onTtsDataProgress(ttsAbilityProxy2.g(ttsAbilityProxy2.i), bArr, i);
            }
        }

        @Override
        public void onTtsError(int i, String str, String str2) {
            TtsAbilityInterface.Callback n;
            KitLog.warn("TtsListenerImpl", String.format(Locale.ROOT, "onTtsError::%s#%s", Integer.valueOf(i), KitLog.getSecurityString(str2)));
            if (TtsAbilityProxy.this.l) {
                TtsFaultReporter.getInstance().getFaultRecord().setErrorCode(i).setDescription(str);
                TtsFaultReporter.getInstance().reportFault();
            }
            if (!TextUtils.isEmpty(str2)) {
                TtsAbilityProxy.this.n(str2).onTtsError(i, str, TtsAbilityProxy.this.g(str2));
                if (TtsAbilityProxy.this.l) {
                    OperationReportUtils.getInstance().getTtsRecord().setErrorCode(String.valueOf(i));
                    TtsAbilityProxy.this.z("1");
                }
                TtsAbilityProxy.this.w();
                TtsAbilityProxy.this.i = "";
                return;
            }
            KitLog.info("TtsListenerImpl", "utteranceId is empty");
            if (TextUtils.isEmpty(TtsAbilityProxy.this.i)) {
                KitLog.info("TtsListenerImpl", "currentUtteranceId is empty");
                n = TtsAbilityProxy.this.L();
            } else {
                TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
                n = ttsAbilityProxy.n(ttsAbilityProxy.i);
            }
            if (n != null) {
                n.onTtsError(i, str, TtsAbilityProxy.this.g(str2));
            }
        }

        @Override
        public void onTtsProgressChanged(String str, int i) {
            KitLog.debug("TtsListenerImpl", String.format(Locale.ROOT, "onTtsProgressChanged::%s#%s", Integer.valueOf(i), KitLog.getSecurityString(str)), new Object[0]);
            TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
            TtsAbilityInterface.Callback n = ttsAbilityProxy.n(ttsAbilityProxy.i);
            TtsAbilityProxy ttsAbilityProxy2 = TtsAbilityProxy.this;
            n.onTtsProgressChanged(ttsAbilityProxy2.g(ttsAbilityProxy2.i), i);
        }

        @Override
        public void onTtsStart(String str, int i) {
            KitLog.info("TtsListenerImpl", "TTS onTtsStart");
            TtsAbilityProxy.this.n(str).onTtsStart(TtsAbilityProxy.this.h(str, i));
            if (TtsAbilityProxy.this.l) {
                OperationReportUtils.getInstance().getTtsRecord().setTtsBroadCastStartTime(System.currentTimeMillis());
                OperationReportUtils.getInstance().getDelayTimeRecord().setTtsStartTime(System.currentTimeMillis());
            }
        }
    }

    public TtsAbilityProxy(MultiInstanceTimeoutListener multiInstanceTimeoutListener) {
        KitLog.debug("TtsAbilityProxy", "TtsAbilityProxy", new Object[0]);
        this.n = multiInstanceTimeoutListener;
        this.e = r();
    }

    public final void C() {
        if (this.l) {
            return;
        }
        this.r.cancel();
    }

    public final void G() {
        destroy();
        MultiInstanceTimeoutListener multiInstanceTimeoutListener = this.n;
        if (multiInstanceTimeoutListener != null) {
            multiInstanceTimeoutListener.ttsToneChanged(this.m);
        }
    }

    public final boolean I() {
        return (TextUtils.isEmpty(this.j) || this.k == null || TextUtils.isEmpty(this.i)) ? false : true;
    }

    public final void K() {
        if (!this.l || TextUtils.isEmpty(OperationReportUtils.getInstance().getTtsRecord().getSpeakTextHash())) {
            return;
        }
        z("1");
    }

    public final TtsAbilityInterface.Callback L() {
        TtsAbilityInterface.Callback callback = this.e;
        if (this.g.containsKey(ClientIdConstant.NORTH_INTERFACE)) {
            return this.g.get(ClientIdConstant.NORTH_INTERFACE);
        }
        if (this.g.containsKey(ClientIdConstant.NORTH_INTERFACE_TTS_SDK_CLOUD)) {
            return this.g.get(ClientIdConstant.NORTH_INTERFACE_TTS_SDK_CLOUD);
        }
        if (this.g.containsKey(ClientIdConstant.DS_INTERFACE_TTS_SDK)) {
            return this.g.get(ClientIdConstant.DS_INTERFACE_TTS_SDK);
        }
        KitLog.warn("TtsAbilityProxy", "use pseudoCallback");
        return callback;
    }

    public int c() {
        return this.o;
    }

    @Override
    public void cancelDirectiveSpeak() {
        synchronized (this.a) {
            try {
                if (this.f.get(this.i) != ClientIdConstant.INTENTION_EXECUTOR) {
                    KitLog.info("TtsAbilityProxy", "north speak,ignore this cancel");
                } else {
                    cancelSpeak();
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public void cancelSpeak() {
        synchronized (this.a) {
            try {
                K();
                if (this.c != null) {
                    StreamingStatusManager.getInstance().setTtsStreamingSpeaking(false);
                    this.c.cancel();
                }
                n(this.i).onCanceled(g(this.i));
                if (this.l) {
                    OperationReportUtils.getInstance().getDelayTimeRecord().setCancelTtsTime(System.currentTimeMillis());
                }
                this.i = "";
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public void destroy() {
        synchronized (this.a) {
            try {
                K();
                BaseTtsAbility baseTtsAbility = this.c;
                if (baseTtsAbility != null) {
                    baseTtsAbility.destroy();
                }
                this.d = false;
                this.e = r();
                this.f.clear();
                this.g.clear();
                this.h.clear();
                this.q.cancel();
                this.r.cancel();
                this.i = "";
                this.j = "";
                this.k = null;
                KitLog.info("TtsAbilityProxy", "destroy isInitTtsEngineFinished " + this.d);
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public void destroyEngine(Intent intent) {
        synchronized (this.a) {
            try {
                K();
                if (this.l) {
                    VoiceKitSdkContext.getInstance().clearTtsContexts(SecureIntentUtil.getSecureIntentInt(intent, "ttsMode", -1));
                }
                BaseTtsAbility baseTtsAbility = this.c;
                if (baseTtsAbility != null) {
                    baseTtsAbility.destroy();
                }
                this.d = false;
                this.e = r();
                KitLog.debug("TtsAbilityProxy", "destroyEngine isInitTtsEngineFinished {}", Boolean.valueOf(this.d));
                this.i = "";
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public void downloadTtsToneEngine(int[] iArr) {
        BaseTtsAbility baseTtsAbility = this.c;
        if (baseTtsAbility != null) {
            baseTtsAbility.downloadTtsToneEngine(iArr);
        }
    }

    public final Bundle g(String str) {
        if (TextUtils.isEmpty(str)) {
            str = this.i;
        }
        Bundle bundle = (Bundle) Optional.ofNullable(this.h.get(str)).orElse(new Bundle());
        synchronized (this.b) {
            bundle.putString("utteranceId", str);
        }
        return bundle.deepCopy();
    }

    public final Bundle h(String str, int i) {
        Bundle g = g(str);
        g.putInt(Constants.Tts.TONE_COLOR, i);
        return g;
    }

    @Override
    public void initConnector() {
        KitLog.debug("TtsAbilityProxy", "initConnector start", new Object[0]);
    }

    @Override
    public void initTtsEngine(final Intent intent) {
        AbilityConnectorThread.Tts.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                TtsAbilityProxy.this.x(intent);
            }
        });
    }

    @Override
    public boolean isInitEngineFinished() {
        return this.d;
    }

    @Override
    public boolean isSpeaking() {
        BaseTtsAbility baseTtsAbility = this.c;
        if (baseTtsAbility != null) {
            return baseTtsAbility.isSpeaking();
        }
        return false;
    }

    @Override
    public boolean isTtsToneEngineExist(int i) {
        BaseTtsAbility baseTtsAbility = this.c;
        if (baseTtsAbility != null) {
            return baseTtsAbility.isTtsToneEngineExist(i);
        }
        return false;
    }

    public final String j(String str, Intent intent) {
        if (!TextUtils.isEmpty(str)) {
            return str;
        }
        if (intent == null) {
            return UuidUtils.getUuid();
        }
        String secureIntentString = SecureIntentUtil.getSecureIntentString(intent, "utteranceId");
        return !TextUtils.isEmpty(secureIntentString) ? secureIntentString : UuidUtils.getUuid();
    }

    public final void k(Intent intent) {
        Context appContext = IAssistantConfig.getInstance().getAppContext();
        int secureIntentInt = SecureIntentUtil.getSecureIntentInt(intent, "ttsMode", -1);
        KitLog.debug("TtsAbilityProxy", "ttsMode is {}", Integer.valueOf(secureIntentInt));
        boolean hasClass = PluginUtil.hasClass("com.huawei.kit.tts.sdk.TTSCloudManager");
        boolean a2 = jvb.a(appContext);
        String uuid = UUID.randomUUID().toString();
        this.p = uuid;
        if (secureIntentInt == 0 || secureIntentInt == 2) {
            if (a2) {
                this.c = new com.huawei.hiassistant.voice.abilityconnector.tts.b(appContext, new d(uuid));
                return;
            }
            return;
        }
        if (secureIntentInt == 3) {
            if (hasClass) {
                this.c = new com.huawei.hiassistant.voice.abilityconnector.tts.a(appContext, new d(uuid));
            }
        } else {
            if (hasClass && a2) {
                this.c = new nsb(appContext, new d(uuid));
                return;
            }
            if (hasClass) {
                this.c = new com.huawei.hiassistant.voice.abilityconnector.tts.a(appContext, new d(uuid));
            } else if (a2) {
                this.c = new com.huawei.hiassistant.voice.abilityconnector.tts.b(appContext, new d(uuid));
            } else {
                KitLog.error("TtsAbilityProxy", "no tts sdk");
            }
        }
    }

    public void l(String str, Intent intent, String str2) {
        String j = j(str, intent);
        this.f.put(j, p(intent));
        this.h.put(j, SecureIntentUtil.getSecureIntentExtras(intent));
        KitLog.warn("TtsAbilityProxy", "is already speaking, ignore " + KitLog.getSecurityString(j));
        n(j).onTtsError(2, str2 + " is already speaking", g(j));
    }

    public final TtsAbilityInterface.Callback n(String str) {
        if (TextUtils.isEmpty(str)) {
            KitLog.info("TtsAbilityProxy", "utteranceId is empty");
            if (TextUtils.isEmpty(this.i)) {
                KitLog.info("TtsAbilityProxy", "currentUtteranceId is empty");
                return L();
            }
            str = this.i;
        }
        TtsAbilityInterface.Callback callback = this.g.get(this.f.get(str));
        if (callback != null) {
            return callback;
        }
        KitLog.error("TtsAbilityProxy", "callback is null");
        return this.e;
    }

    public String o() {
        return isSpeaking() ? this.i : "";
    }

    public final String p(Intent intent) {
        if (intent == null || !intent.hasExtra(RecognizerIntent.EXT_CLIENT_ID)) {
            return ClientIdConstant.INTENTION_EXECUTOR;
        }
        KitLog.debug("TtsAbilityProxy", "valid clientId", new Object[0]);
        return SecureIntentUtil.getSecureIntentString(intent, RecognizerIntent.EXT_CLIENT_ID);
    }

    @Override
    public void prepare() {
        synchronized (this.a) {
            try {
                KitLog.debug("TtsAbilityProxy", "prepare start", new Object[0]);
                BaseTtsAbility baseTtsAbility = this.c;
                if (baseTtsAbility != null) {
                    baseTtsAbility.prepare();
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    public final TtsAbilityInterface.Callback r() {
        return new c();
    }

    @Override
    public void registerCallback(TtsAbilityInterface.Callback callback, String str) {
        if (callback == null) {
            KitLog.warn("TtsAbilityProxy", "registerLister null");
        } else {
            this.g.put(str, callback);
        }
    }

    @Override
    public void stopSpeak() {
        synchronized (this.a) {
            try {
                if (this.c != null) {
                    StreamingStatusManager.getInstance().setTtsStreamingSpeaking(false);
                    this.c.cancel();
                }
                n(this.i).onTtsInterrupted(g(this.i));
                if (this.l) {
                    OperationReportUtils.getInstance().getDelayTimeRecord().setCancelTtsTime(System.currentTimeMillis());
                    z("1");
                }
                w();
                this.i = "";
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override
    public void textToSpeak(String str, String str2, Intent intent) {
        synchronized (this.a) {
            try {
                this.q.cancel();
                C();
                String j = j(str2, intent);
                this.f.put(j, p(intent));
                this.h.put(j, SecureIntentUtil.getSecureIntentExtras(intent));
                KitLog.info("TtsAbilityProxy", "tts for " + KitLog.getSecurityString(j) + " is allowed");
                this.i = j;
                if (!this.d && this.l) {
                    KitLog.info("TtsAbilityProxy", "tts is not init");
                    n(j).onTtsError(2, "tts is not init", g(j));
                    return;
                }
                if (!intent.hasExtra("streamState") && TextUtils.isEmpty(str)) {
                    KitLog.error("TtsAbilityProxy", "text is empty");
                    n(j).onTtsError(2, "text is null", g(j));
                    w();
                    return;
                }
                BaseTtsAbility baseTtsAbility = this.c;
                if (baseTtsAbility != null && baseTtsAbility.isInitFinish()) {
                    if (!this.c.isTtsBind()) {
                        this.j = str;
                        this.k = intent;
                        this.c.J();
                        return;
                    } else {
                        if (this.l) {
                            OperationReportUtils.getInstance().getTtsRecord().setTtsCommandStartTime(System.currentTimeMillis()).setTextLength(String.valueOf(str.length())).setInteraction(String.valueOf((int) BusinessFlowId.getInstance().getInteractionId())).setDialogId(String.valueOf(BusinessFlowId.getInstance().getDialogId())).setSpeakTextHash(StringUtils.getStringSha256(str));
                        }
                        this.c.textToSpeak(str, j, intent);
                        n(j).onTextToSpeak(g(j));
                        return;
                    }
                }
                KitLog.info("TtsAbilityProxy", "textToSpeak init is not finish");
                this.j = str;
                this.k = intent;
                this.q.start();
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    public final void u(Intent intent) {
        KitLog.info("TtsAbilityProxy", "initTtsEngine start");
        synchronized (this.a) {
            try {
                if (this.c == null) {
                    k(intent);
                    this.o = SecureIntentUtil.getSecureIntentInt(intent, Constants.Tts.TONE_COLOR, Constants.Tts.DEFAULT_TONE_COLOR);
                } else {
                    KitLog.info("TtsAbilityProxy", "ttsAbility create already");
                }
                BaseTtsAbility baseTtsAbility = this.c;
                if (baseTtsAbility == null) {
                    KitLog.error("TtsAbilityProxy", "no tts sdk");
                    TtsAbilityInterface.Callback L = L();
                    if (L != null) {
                        w();
                        L.onTtsError(1, "init fail:no tts sdk", g(""));
                    }
                    return;
                }
                if (this.d) {
                    KitLog.info("TtsAbilityProxy", "ttsAbility initTtsEngineFinished success");
                } else {
                    baseTtsAbility.initEngine(intent, this.l);
                }
                this.d = true;
                KitLog.info("TtsAbilityProxy", "initTtsEngine isInitTtsEngineFinished " + this.d);
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    public final boolean v(String str) {
        KitLog.debug("TtsAbilityProxy", "preTtsRandomId hashCode is " + str + " , curTtsRandomId hashCode is " + this.p, new Object[0]);
        return !TextUtils.isEmpty(this.p) && TextUtils.equals(this.p, str);
    }

    public final void w() {
        if (this.l) {
            return;
        }
        if (this.o == TtsUtils.getDefaultTtsTone()) {
            this.r.start();
        } else {
            this.r.cancel();
            G();
        }
    }

    public final void x(Intent intent) {
        KitLog.info("TtsAbilityProxy", "initTtsEngine start");
        synchronized (this.a) {
            try {
                BaseTtsAbility baseTtsAbility = this.c;
                if (baseTtsAbility != null) {
                    baseTtsAbility.destroy();
                }
                k(intent);
                if (this.c == null) {
                    KitLog.error("TtsAbilityProxy", "no tts sdk");
                    TtsAbilityInterface.Callback L = L();
                    if (L != null) {
                        L.onTtsError(1, "init fail:no tts sdk", g(""));
                    }
                    return;
                }
                int secureIntentInt = SecureIntentUtil.getSecureIntentInt(intent, "ttsMode", -1);
                VoiceKitSdkContext.getInstance().clearTtsContexts(secureIntentInt);
                VoiceKitSdkContext.getInstance().setTtsParams(intent.getExtras(), secureIntentInt);
                this.c.initEngine(intent, this.l);
                this.d = true;
                KitLog.debug("TtsAbilityProxy", "initTtsEngine isInitTtsEngineFinished {}", true);
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    public final void z(String str) {
        OperationReportUtils.getInstance().getTtsRecord().setTtsBroadCastEndTime(System.currentTimeMillis());
        OperationReportUtils.getInstance().getTtsRecord().setIsTtsFinished(str);
        OperationReportUtils.getInstance().reportTtsRecord();
    }

    @Override
    public void initTtsEngine(final Intent intent, Object obj) {
        AbilityConnectorThread.Tts.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                TtsAbilityProxy.this.u(intent);
            }
        });
    }

    @Override
    public void registerCallback(TtsAbilityInterface.Callback callback, String str, Object obj) {
        if (callback == null) {
            KitLog.warn("TtsAbilityProxy", "registerLister null");
            return;
        }
        this.l = false;
        if (obj instanceof DsEventCallerAppinfo) {
            this.m = ((DsEventCallerAppinfo) obj).getTaskName();
        }
        this.g.put(str, callback);
    }

    public class a extends CountDownTimer {
        public a(long j, long j2) {
            super(j, j2);
        }

        @Override
        public void onFinish() {
            synchronized (TtsAbilityProxy.this.a) {
                try {
                    if (TtsAbilityProxy.this.I()) {
                        TtsAbilityProxy ttsAbilityProxy = TtsAbilityProxy.this;
                        TtsAbilityInterface.Callback n = ttsAbilityProxy.n(ttsAbilityProxy.i);
                        TtsAbilityProxy ttsAbilityProxy2 = TtsAbilityProxy.this;
                        n.onTtsError(1, "init fail", ttsAbilityProxy2.g(ttsAbilityProxy2.i));
                        TtsAbilityProxy.this.w();
                        TtsAbilityProxy.this.j = "";
                        TtsAbilityProxy.this.k = null;
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
        }

        @Override
        public void onTick(long j) {
        }
    }

    public class b extends CountDownTimer {
        public b(long j, long j2) {
            super(j, j2);
        }

        @Override
        public void onFinish() {
            synchronized (TtsAbilityProxy.this.a) {
                try {
                    TtsAbilityProxy.this.destroy();
                    if (TtsAbilityProxy.this.n != null) {
                        TtsAbilityProxy.this.n.onTimeout(TtsAbilityProxy.this.m);
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
        }

        @Override
        public void onTick(long j) {
        }
    }
}