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

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

import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
import android.os.Bundle;
import android.text.TextUtils;
import com.huawei.hiassistant.platform.base.bean.llmstatus.StreamingStatusManager;
import com.huawei.hiassistant.platform.base.grs.GrsHelper;
import com.huawei.hiassistant.platform.base.northinterface.Constants;
import com.huawei.hiassistant.platform.base.policy.RealMachineStatusManager;
import com.huawei.hiassistant.platform.base.util.AbilityConnectorThread;
import com.huawei.hiassistant.platform.base.util.KitLog;
import com.huawei.hiassistant.platform.base.util.SecureIntentUtil;
import com.huawei.hiassistant.platform.base.util.common.HeadsetScoManager;
import com.huawei.hiassistant.voice.abilityconnector.tts.BaseTtsAbility;
import com.huawei.hiassistant.voice.abilityconnector.tts.TtsListenerInterface;
import java.util.Locale;

public abstract class BaseTtsAbility {
    static final String APP_ID = "0Q9NwvGPgSkj5ITd7qffuA==lYQwEWvdSYM8F_sd9Zl7Sfn7QgjPE15QZvpF-DhJ4Bj05FxDQUPi4UtsAOQX8ao-";
    static final String APP_ID_AS = "MVoRwwG8BDEzFdlatPp7Ow==gDxLTq3x1LpDF9t3BrVZCOoZgupVapVGQEjOKadTpfQ35-v5RB3o0CVopguQ7n-z";
    static final String APP_NAME = "R210k-nREruLdeeSSJE25A==fCyrmN5_Gn0y3SzxTjuUhaD0sFoQEssbPaSZp8NlKFnSekChng5NGJr6sANQROif";
    static final String APP_NAME_AS = "I7kTC399wkVtOGYT1T7_mA==BugPf_w-3QEbfInn1KC52a3ouICn4w7LeLbEyOt9UyXaUH0Fa7iSw0EkBJ9ctGlF";
    static final int DEFAULT_AUDIO_DEVICE_TYPE = -1;
    static final String IS_NEED_AUDIO_FOCUS = "isNeedAudioFocus";
    private static final String TAG = "BaseTtsAbility";
    private int usage;
    private int streamType = 9;
    private int deviceType = 0;
    private boolean isNeedAudioFocus = true;
    private boolean isNeedTtsMixPlay = false;
    private boolean isSupportMultiInstance = false;
    private boolean isSupportNewSampleRate = false;
    private int secondSpeaker = -1;
    private int compressRate = -1;
    private int audioFormat = -1;
    private String deviceCategory = "";

    public static class a implements AudioManager.OnAudioFocusChangeListener {
        @Override
        public void onAudioFocusChange(int i) {
            KitLog.debug(BaseTtsAbility.TAG, "onAudioFocusChange:{}", Integer.valueOf(i));
        }
    }

    private String convertDeviceInfo() {
        int i = this.deviceType;
        return i != 1 ? i != 3 ? i != 4 ? "phone" : "hd" : "pad" : "speaker";
    }

    public void lambda$abandonAudioFocus$1(AudioManager audioManager, AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener) {
        if (audioManager == null || !this.isNeedAudioFocus) {
            return;
        }
        audioManager.abandonAudioFocus(onAudioFocusChangeListener);
    }

    public void lambda$onError$2(TtsListenerInterface ttsListenerInterface, String str, String str2, AudioManager audioManager, AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener) {
        KitLog.info(TAG, "enter onError");
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onTtsError(2, str, str2);
        }
        abandonAudioFocus(audioManager, onAudioFocusChangeListener);
    }

    public static void lambda$onFormatChange$4(String str, TtsListenerInterface ttsListenerInterface, Bundle bundle) {
        KitLog.info(TAG, "enter onFormatChange utteranceId " + KitLog.getSecurityString(str));
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onFormatChange(str, bundle);
        }
    }

    public static void lambda$onPhonemeFinish$8(TtsListenerInterface ttsListenerInterface, String str, String str2) {
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onPhonemeFinish(str, str2);
        }
    }

    public static void lambda$onPhonemeProgress$7(TtsListenerInterface ttsListenerInterface, String str, String str2, int i, String str3) {
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onPhonemeProgress(str, str2, i, str3);
        }
    }

    public static void lambda$onSpeechProgressChanged$9(TtsListenerInterface ttsListenerInterface, String str, int i) {
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onTtsProgressChanged(str, i);
        }
    }

    public static void lambda$onSpeechStart$3(String str, TtsListenerInterface ttsListenerInterface, int i) {
        KitLog.debug(TAG, "enter onSpeechStart utteranceId {}", KitLog.getSecurityString(str));
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onTtsStart(str, i);
        }
    }

    public static void lambda$onTtsDataFinish$6(TtsListenerInterface ttsListenerInterface, String str) {
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onTtsDataFinish(str);
        }
    }

    public static void lambda$onTtsDataProgress$5(TtsListenerInterface ttsListenerInterface, String str, byte[] bArr, int i) {
        if (ttsListenerInterface != null) {
            ttsListenerInterface.onTtsDataProgress(str, bArr, i);
        }
    }

    public void lambda$postSpeechFinish$10(String str, TtsListenerInterface ttsListenerInterface, AudioManager audioManager, AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener) {
        KitLog.debug(TAG, "onSpeechFinish utteranceId {}", KitLog.getSecurityString(str));
        if (ttsListenerInterface != null) {
            KitLog.debug(TAG, "[onSpeechFinish] call mListener.onTtsComplete()", new Object[0]);
            StreamingStatusManager.getInstance().setTtsStreamingSpeaking(false);
            ttsListenerInterface.onTtsComplete(str);
        }
        abandonAudioFocus(audioManager, onAudioFocusChangeListener);
    }

    public void lambda$requestAudioFocus$0(AudioManager audioManager, AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener, int i) {
        if (audioManager == null || !this.isNeedAudioFocus) {
            return;
        }
        if (this.isNeedTtsMixPlay) {
            KitLog.debug(TAG, "requestAudioFocus, durationHint duck = {}", Integer.valueOf(audioManager.requestAudioFocus(onAudioFocusChangeListener, i, 3)));
        } else {
            KitLog.debug(TAG, "requestAudioFocus, stream = {}, currentStreamType = {}", Integer.valueOf(audioManager.requestAudioFocus(onAudioFocusChangeListener, i, 2)), Integer.valueOf(i));
        }
    }

    private void postSpeechFinish(final String str, final TtsListenerInterface ttsListenerInterface, final AudioManager audioManager, final AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener, int i) {
        AbilityConnectorThread.TtsCallback.THREAD.postDelayed(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.this.lambda$postSpeechFinish$10(str, ttsListenerInterface, audioManager, onAudioFocusChangeListener);
            }
        }, i);
    }

    public void abandonAudioFocus(final AudioManager audioManager, final AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener) {
        KitLog.debug(TAG, "abandonAudioFocus()", new Object[0]);
        AbilityConnectorThread.AudioFocus.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.this.lambda$abandonAudioFocus$1(audioManager, onAudioFocusChangeListener);
            }
        });
    }

    public abstract void cancel();

    public abstract void destroy();

    public abstract void downloadTtsToneEngine(int[] iArr);

    public String getAsUrl(Context context) {
        return (RealMachineStatusManager.getInstance().isRealMachineStatus() || context == null) ? "" : TextUtils.isEmpty(this.deviceCategory) ? GrsHelper.getInstance().getTrsAddress(context, false, convertDeviceInfo()) : GrsHelper.getInstance().getTrsAddress(context, false, this.deviceCategory);
    }

    public int getAudioFormat() {
        return this.audioFormat;
    }

    public int getCompressRate() {
        return this.compressRate;
    }

    public String getDeviceCategory() {
        return this.deviceCategory;
    }

    public int getDeviceType() {
        return this.deviceType;
    }

    public String getLanguage(Intent intent) {
        return intent == null ? "" : SecureIntentUtil.getSecureIntentString(intent, "language");
    }

    public int getSecondSpeaker() {
        return this.secondSpeaker;
    }

    public int getStreamType() {
        return this.streamType;
    }

    public int getUsage() {
        return this.usage;
    }

    public void initEngine(Intent intent) {
        if (intent != null) {
            this.isNeedAudioFocus = SecureIntentUtil.getSecureIntentBoolean(intent, IS_NEED_AUDIO_FOCUS, true);
            this.streamType = SecureIntentUtil.getSecureIntentInt(intent, "streamType", 9);
            this.deviceType = SecureIntentUtil.getSecureIntentInt(intent, "deviceType", 0);
            this.deviceCategory = SecureIntentUtil.getSecureIntentString(intent, "deviceCategory");
            this.secondSpeaker = SecureIntentUtil.getSecureIntentInt(intent, "secondSpeaker", -1);
            this.isNeedTtsMixPlay = SecureIntentUtil.getSecureIntentBoolean(intent, Constants.Tts.IS_NEED_TTS_MIX_PLAY, false);
            this.isSupportMultiInstance = SecureIntentUtil.getSecureIntentBoolean(intent, Constants.Tts.IS_SUPPORT_MULTI_INSTANCE, false);
            this.compressRate = SecureIntentUtil.getSecureIntentInt(intent, "compressRate", -1);
            this.isSupportNewSampleRate = SecureIntentUtil.getSecureIntentBoolean(intent, "supportNewSampleRate", false);
            this.audioFormat = SecureIntentUtil.getSecureIntentInt(intent, "audioFormat", -1);
            this.usage = SecureIntentUtil.getSecureIntentInt(intent, "usage", Integer.MAX_VALUE);
            KitLog.info(TAG, String.format(Locale.ROOT, "isNeedAudioFocus:%s streamType:%s deviceType:%s deviceCategory:%s isNeedTtsMixPlay:%s isSupportMultiInstance:%s secondSpeaker:%s compressRate:%s isSupportNewSampleRate:%s audioFormat:%s usage:%s", Boolean.valueOf(this.isNeedAudioFocus), Integer.valueOf(this.streamType), Integer.valueOf(this.deviceType), this.deviceCategory, Boolean.valueOf(this.isNeedTtsMixPlay), Boolean.valueOf(this.isSupportMultiInstance), Integer.valueOf(this.secondSpeaker), Integer.valueOf(this.compressRate), Boolean.valueOf(this.isSupportNewSampleRate), Integer.valueOf(this.audioFormat), Integer.valueOf(this.usage)));
        }
    }

    public abstract boolean isInitFinish();

    public abstract boolean isInitSuccess();

    public abstract boolean isSpeaking();

    public boolean isSupportMultiInstance() {
        return this.isSupportMultiInstance;
    }

    public boolean isSupportNewSampleRate() {
        return this.isSupportNewSampleRate;
    }

    public abstract boolean isTtsBind();

    public abstract boolean isTtsToneEngineExist(int i);

    public void onError(final TtsListenerInterface ttsListenerInterface, final String str, final String str2, final AudioManager audioManager, final AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.this.lambda$onError$2(ttsListenerInterface, str2, str, audioManager, onAudioFocusChangeListener);
            }
        });
    }

    public void onFormatChange(final String str, final Bundle bundle, final TtsListenerInterface ttsListenerInterface) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.lambda$onFormatChange$4(str, ttsListenerInterface, bundle);
            }
        });
    }

    public void onPhonemeFinish(final String str, final String str2, final TtsListenerInterface ttsListenerInterface) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.lambda$onPhonemeFinish$8(TtsListenerInterface.this, str, str2);
            }
        });
    }

    public void onPhonemeProgress(final String str, final String str2, final int i, final String str3, final TtsListenerInterface ttsListenerInterface) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.lambda$onPhonemeProgress$7(TtsListenerInterface.this, str, str2, i, str3);
            }
        });
    }

    public void onSpeechFinish(String str, TtsListenerInterface ttsListenerInterface, AudioManager audioManager, AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener) {
        int i;
        if (HeadsetScoManager.getInstance().isBluetoothConnected()) {
            KitLog.info(TAG, "blueToothConnected");
            i = 400;
        } else {
            i = 0;
        }
        postSpeechFinish(str, ttsListenerInterface, audioManager, onAudioFocusChangeListener, i);
    }

    public void onSpeechProgressChanged(final String str, final int i, final TtsListenerInterface ttsListenerInterface) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.lambda$onSpeechProgressChanged$9(TtsListenerInterface.this, str, i);
            }
        });
    }

    public void onSpeechStart(final String str, final int i, final TtsListenerInterface ttsListenerInterface) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.lambda$onSpeechStart$3(str, ttsListenerInterface, i);
            }
        });
    }

    public void onTtsDataFinish(final String str, final TtsListenerInterface ttsListenerInterface) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.lambda$onTtsDataFinish$6(TtsListenerInterface.this, str);
            }
        });
    }

    public void onTtsDataProgress(final String str, final byte[] bArr, final int i, final TtsListenerInterface ttsListenerInterface) {
        AbilityConnectorThread.TtsCallback.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.lambda$onTtsDataProgress$5(TtsListenerInterface.this, str, bArr, i);
            }
        });
    }

    public abstract void prepare();

    public abstract void J();

    public void requestAudioFocus(final AudioManager audioManager, final AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener, final int i) {
        AbilityConnectorThread.AudioFocus.THREAD.post(new Runnable() {
            @Override
            public final void run() {
                BaseTtsAbility.this.lambda$requestAudioFocus$0(audioManager, onAudioFocusChangeListener, i);
            }
        });
    }

    public abstract void textToSpeak(String str, String str2, Intent intent);

    public void initEngine(Intent intent, boolean z) {
        initEngine(intent);
    }
}