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

package com.huawei.hiassistant.platform.commonaction.abilityaction;

import android.content.Intent;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.huawei.hiai.pdk.bigreport.BigReportKeyValue;
import com.huawei.hiai.tts.constants.BaseConstants;
import com.huawei.hiassistant.platform.base.action.Action;
import com.huawei.hiassistant.platform.base.action.BaseActionGroup;
import com.huawei.hiassistant.platform.base.bean.HintChipsPayload;
import com.huawei.hiassistant.platform.base.bean.Indication;
import com.huawei.hiassistant.platform.base.bean.ResendTextInfo;
import com.huawei.hiassistant.platform.base.bean.UiConversationCard;
import com.huawei.hiassistant.platform.base.bean.recognize.RecognizeContext;
import com.huawei.hiassistant.platform.base.bean.recognize.Session;
import com.huawei.hiassistant.platform.base.bean.recognize.VoiceKitMessage;
import com.huawei.hiassistant.platform.base.bean.recognize.common.DisplayAsr;
import com.huawei.hiassistant.platform.base.bean.recognize.common.DisplayText;
import com.huawei.hiassistant.platform.base.bean.recognize.common.JsViewCard;
import com.huawei.hiassistant.platform.base.bean.recognize.common.Speak;
import com.huawei.hiassistant.platform.base.bean.recognize.common.StreamingSpeak;
import com.huawei.hiassistant.platform.base.bean.ui.ChipsPayload;
import com.huawei.hiassistant.platform.base.bean.ui.UiMessageType;
import com.huawei.hiassistant.platform.base.bean.util.GsonUtils;
import com.huawei.hiassistant.platform.base.commonrejection.CommonRejection;
import com.huawei.hiassistant.platform.base.fullduplex.FullDuplex;
import com.huawei.hiassistant.platform.base.module.IntentionExecutorInterface;
import com.huawei.hiassistant.platform.base.module.RecordStartType;
import com.huawei.hiassistant.platform.base.msg.AssistantMessage;
import com.huawei.hiassistant.platform.base.multipintentions.MultiIntentConstant;
import com.huawei.hiassistant.platform.base.northinterface.Constants;
import com.huawei.hiassistant.platform.base.northinterface.recognize.RecognizerIntent;
import com.huawei.hiassistant.platform.base.util.InterruptUtil;
import com.huawei.hiassistant.platform.base.util.KitLog;
import com.huawei.hiassistant.platform.base.util.NumberUtil;
import com.huawei.hiassistant.platform.commonaction.payload.userinteraction.DialogFinished;
import com.huawei.hiassistant.platform.commonaction.payload.userinteraction.StartRecord;
import com.huawei.hiassistant.platform.commonaction.util.CommonUtil;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.json.JSONException;
import org.json.JSONObject;

public class UserInteractionActionGroup extends BaseActionGroup {
    private static final String ASR_TEXT_KEY = "asrText";
    private static final String CHIPS_TYPE_DIALOG = "dialog";
    private static final int MSG_RESEND = 272;
    private static final String TAG = "UserInteractionActionGroup";
    private static final String UI_PAYLOAD_CONTENT_DIALOG_CHIPS = "DIALOG_CHIPS";
    private Handler messageHandler = new a();
    private static final String MATCHER_REGEX = "#\\{[\\w]*\\}";
    private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile(MATCHER_REGEX);

    public class a extends Handler {
        public a() {
        }

        @Override
        public void handleMessage(Message message) {
            if (message == null || message.what != UserInteractionActionGroup.MSG_RESEND) {
                return;
            }
            KitLog.info(UserInteractionActionGroup.TAG, "resendMsg");
            Object obj = message.obj;
            if (obj instanceof String) {
                String str = (String) obj;
                if (TextUtils.isEmpty(str)) {
                    UserInteractionActionGroup.this.commandUpdateVoiceContext();
                } else {
                    UserInteractionActionGroup.this.sendTextToRecognize(str);
                }
            }
        }
    }

    public void commandUpdateVoiceContext() {
        Session session;
        Map<String, Object> map = this.sharedDataMap;
        if (map != null && map.containsKey(RecognizerIntent.EXT_RECOGNIZE_SESSION)) {
            Object obj = this.sharedDataMap.get(RecognizerIntent.EXT_RECOGNIZE_SESSION);
            if (obj instanceof Session) {
                session = (Session) obj;
                this.intentionExecutorCallBack.onCommanderProcess(IntentionExecutorInterface.CommanderCode.UPDATE_VOICE_CONTEXT, AssistantMessage.builder(CommonUtil.buildVoiceContext("System", "DialogContinue", new JsonObject()), session).build());
            }
        }
        session = null;
        this.intentionExecutorCallBack.onCommanderProcess(IntentionExecutorInterface.CommanderCode.UPDATE_VOICE_CONTEXT, AssistantMessage.builder(CommonUtil.buildVoiceContext("System", "DialogContinue", new JsonObject()), session).build());
    }

    private String getUpdateText(String str) {
        if (TextUtils.isEmpty(str)) {
            KitLog.warn(TAG, "content is empty");
            return "";
        }
        Matcher matcher = PLACEHOLDER_PATTERN.matcher(str);
        Object obj = this.sharedDataMap.get("placeHolderValues");
        List arrayList = new ArrayList();
        if (obj instanceof List) {
            arrayList = (List) obj;
        }
        int size = arrayList.size();
        int i = 0;
        while (matcher.find()) {
            String group = matcher.group();
            if (i > size - 1) {
                KitLog.warn(TAG, "out of match list");
                str = str.replace(group, "");
            } else {
                Object obj2 = arrayList.get(i);
                if (obj2 instanceof String) {
                    str = str.replace(group, (String) obj2);
                } else {
                    KitLog.warn(TAG, "content is not string");
                    str = str.replace(group, "");
                }
            }
            i++;
        }
        KitLog.debug(TAG, "resultString{}", str);
        return str;
    }

    private void sendDialogChipsMsgToUi(ChipsPayload chipsPayload) {
        chipsPayload.setContent(UI_PAYLOAD_CONTENT_DIALOG_CHIPS);
        this.intentionExecutorCallBack.onUiProcess(VoiceKitMessage.buildUiMessage(UiMessageType.UI_BACKGROUD, chipsPayload));
    }

    private void sendFinishReasonToAppIfNeeded(String str) {
        if (TextUtils.isEmpty(str)) {
        }
        str.hashCode();
        switch (str) {
            case "rejection":
            case "timeout":
            case "cloudServiceError":
            case "slbOverload":
            case "asrOverload":
                sendRejectionInfoToApp(str);
                break;
        }
    }

    private void sendRejectionInfoToApp(String str) {
        KitLog.info(TAG, "sendRejectionInfoToApp");
        Intent intent = new Intent();
        intent.putExtra("finishReason", str);
        this.intentionExecutorCallBack.onCommanderProcess(IntentionExecutorInterface.CommanderCode.SEND_APP_REJECT_RECOGNIZE, intent);
    }

    @Action(name = "DisplayASR", nameSpace = "UserInteraction")
    public int displayAsr(DisplayAsr displayAsr) {
        if (displayAsr == null) {
            return 0;
        }
        sendHumanContentToUi(displayAsr.getText(), displayAsr.isCorrectable());
        return 0;
    }

    @Action(name = "Chips", nameSpace = "UserInteraction")
    public void displayChips(ChipsPayload chipsPayload) {
        KitLog.debug(TAG, "displayChips", new Object[0]);
        if (chipsPayload == null) {
            KitLog.warn(TAG, "displayChips chipsPayload is null");
            return;
        }
        String chipsType = chipsPayload.getChipsType();
        KitLog.debug(TAG, "displayChips chipsType={}", chipsType);
        if (CHIPS_TYPE_DIALOG.equals(chipsType)) {
            sendDialogChipsMsgToUi(chipsPayload);
        } else {
            sendChipsMsgToUi(chipsPayload);
        }
    }

    @Action(name = "Hint", nameSpace = "UserInteraction")
    public void displayHintChips(HintChipsPayload hintChipsPayload) {
        List<HintChipsPayload.HintChipsData> hints;
        KitLog.debug(TAG, "displayHintChips", new Object[0]);
        if (hintChipsPayload == null || (hints = hintChipsPayload.getHints()) == null) {
            return;
        }
        Intent intent = new Intent();
        ArrayList<String> arrayList = new ArrayList<>();
        Iterator<HintChipsPayload.HintChipsData> it = hints.iterator();
        while (it.hasNext()) {
            arrayList.add(it.next().getText());
        }
        intent.putStringArrayListExtra("HINT_DISPLAY_KEY", arrayList);
        sendCacheableMsgToUi("HINT", intent);
    }

    @Action(name = "DisplayText", nameSpace = "UserInteraction")
    public int displayText(DisplayText displayText) {
        sendRobotContentToUi(getUpdateText(displayText.getText()));
        return 0;
    }

    @Action(name = "DialogFinished", nameSpace = "UserInteraction")
    public int executeDialogFinished(DialogFinished dialogFinished) {
        Map<String, Object> map = this.sharedDataMap;
        Boolean bool = Boolean.FALSE;
        map.put(RecognizerIntent.VISIBLE_OMT, bool);
        Boolean bool2 = (Boolean) getSharedDataInDialog(RecognizerIntent.DIALOG_FINISHED_BREAK, Boolean.class).orElse(bool);
        boolean booleanValue = bool2.booleanValue();
        KitLog.debug(TAG, "isNeedBreak:{}", bool2);
        if (booleanValue) {
            this.sharedDataMap.put(RecognizerIntent.DIALOG_FINISHED_BREAK, bool);
            return 0;
        }
        sendFinishReasonToAppIfNeeded(dialogFinished.getFinishReason());
        if (FullDuplex.stateManager().isFullDuplexMode()) {
            if (dialogFinished.isContinuousListening()) {
                KitLog.info(TAG, "DialogFinished in fullduplex isContinuousListening =ture, continueDialog");
                this.intentionExecutorCallBack.onCommanderProcess(IntentionExecutorInterface.CommanderCode.SEND_APP_CONTINUE_DIALOG, new Intent());
            } else {
                KitLog.info(TAG, "DialogFinished in fullduplex isContinuousListening =false, abortbusiness");
                this.intentionExecutorCallBack.onCommanderProcess(IntentionExecutorInterface.CommanderCode.CANCEL_FULLDUPLEX_RECOGNIZE, null);
            }
            return 0;
        }
        if (!dialogFinished.isContinuousListening()) {
            return 3;
        }
        RecognizeContext recognizeContext = new RecognizeContext();
        Boolean bool3 = Boolean.TRUE;
        String json = GsonUtils.toJson(CommonUtil.setContextProperty(CommonUtil.setContextProperty(recognizeContext, "System", "ClientContext", "continuousListening", new JsonPrimitive(bool3)), "System", "ASRSettingsParameter", "vadfonttimems", new JsonPrimitive(BigReportKeyValue.EVENT_TTS_DO_INIT)));
        Intent intent = new Intent();
        intent.putExtra(RecognizerIntent.EXT_VOICE_CONTEXT, json);
        intent.putExtra(RecognizerIntent.RECORD_TYPE, RecordStartType.CONTINUE.getType());
        this.intentionExecutorCallBack.onCommanderProcess(IntentionExecutorInterface.CommanderCode.SEND_APP_CONTINUE_DIALOG, intent);
        this.sharedDataMap.put(RecognizerIntent.EXT_CONTINUOUS_DIALOGUE, bool3);
        return 3;
    }

    @Action(name = "StartRecord", nameSpace = "UserInteraction")
    public int expectSpeech(StartRecord startRecord) {
        KitLog.debug(TAG, "expectSpeech: begin", new Object[0]);
        if (FullDuplex.stateManager().isFullDuplexMode()) {
            KitLog.info(TAG, "StartRecord in fullduplex, continueDialog");
            this.intentionExecutorCallBack.onCommanderProcess(IntentionExecutorInterface.CommanderCode.SEND_APP_CONTINUE_DIALOG, new Intent());
            return 0;
        }
        Intent intent = new Intent();
        if (((Boolean) Optional.ofNullable(startRecord).map(new Function() {
            @Override
            public final Object apply(Object obj) {
                return Boolean.valueOf(((StartRecord) obj).isContinueFrontVad());
            }
        }).orElse(Boolean.FALSE)).booleanValue()) {
            KitLog.info(TAG, "startRecord isContinueFrontVad= " + startRecord.isContinueFrontVad());
            sendRejectionInfoToApp(CommonRejection.Constants.FINISH_REASON_REJECTION);
            if (CommonRejection.Helper.calculator().isTimeOut()) {
                KitLog.info(TAG, "commonRejection isTimeOut");
                return 3;
            }
            intent.putExtra(RecognizerIntent.CONTINUE_FRONT_VAD, startRecord.isContinueFrontVad());
        }
        intent.putExtra(RecognizerIntent.EXT_VOICE_CONTEXT, GsonUtils.toJson(CommonUtil.setContextProperty((RecognizeContext) GsonUtils.toBean((String) getSharedDataInDialog(RecognizerIntent.EXT_VOICE_CONTEXT, String.class).orElse(""), RecognizeContext.class), "System", "ClientContext", "dataType", new JsonPrimitive("AUDIO"))));
        KitLog.info(TAG, "send START_RECORD to ui.");
        intent.putExtra(RecognizerIntent.RECORD_TYPE, RecordStartType.MULTI_TURN.getType());
        sendControlMessage("START_RECORD", intent);
        return 0;
    }

    @Action(name = "Indication", nameSpace = "UserInteraction")
    public int handleIndication(Indication indication) {
        KitLog.debug(TAG, "handleIndication", new Object[0]);
        if (indication != null) {
            InterruptUtil.setInterruptTimeOut(indication.getInterruptWaitTime());
            this.sharedDataMap.put(BaseActionGroup.INDICATION_KEY, indication);
        }
        return 0;
    }

    @Action(name = "ResendMsg", nameSpace = "UserInteraction")
    public int resendMsg(ResendTextInfo resendTextInfo) {
        int delay = resendTextInfo.getDelay();
        this.messageHandler.removeMessages(MSG_RESEND);
        this.messageHandler.sendMessageDelayed(this.messageHandler.obtainMessage(MSG_RESEND, TextUtils.isEmpty(resendTextInfo.getText()) ? "" : resendTextInfo.getText()), delay);
        return 0;
    }

    @com.huawei.hiassistant.platform.base.action.Action(name = "ResendNlu", nameSpace = "UserInteraction")
    public int resendNlu(com.huawei.hiassistant.platform.base.bean.recognize.payload.Payload r5) {
        throw new UnsupportedOperationException("Method not decompiled: com.huawei.hiassistant.platform.commonaction.abilityaction.UserInteractionActionGroup.resendNlu(com.huawei.hiassistant.platform.base.bean.recognize.payload.Payload):int");
    }

    @Action(name = "DisplayHWCard", nameSpace = "UserInteraction")
    public int showJsViewCard(JsViewCard jsViewCard) {
        UiConversationCard uiConversationCard = new UiConversationCard();
        if (TextUtils.isEmpty(jsViewCard.getCardUrl())) {
            uiConversationCard.setTemplateName(jsViewCard.getCardId());
        } else {
            uiConversationCard.setTemplateName("JsCard");
        }
        UiConversationCard.TemplateData templateData = new UiConversationCard.TemplateData();
        JSONObject cardParams = jsViewCard.getCardParams();
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("cardParams", cardParams);
        } catch (JSONException unused) {
            KitLog.error(TAG, "cardParams JSONException");
        }
        templateData.setKeyValue("jsParameters", jSONObject.toString());
        templateData.setKeyValue("jsTemplateId", jsViewCard.getCardId());
        templateData.setKeyValue("jsUrl", jsViewCard.getCardUrl());
        templateData.setKeyValue("minPlatformVer", jsViewCard.getMinPlatformVer());
        String cardType = jsViewCard.getCardType();
        if (!TextUtils.isEmpty(cardType)) {
            KitLog.debug(TAG, "cardType {}", cardType);
            templateData.setKeyValue("jsCardType", cardType);
        }
        String templateType = jsViewCard.getTemplateType();
        if (!TextUtils.isEmpty(templateType)) {
            KitLog.debug(TAG, "templateType {}", templateType);
            templateData.setKeyValue("jsTemplateType", templateType);
        }
        JSONObject ohosAbilityForm = jsViewCard.getOhosAbilityForm();
        if (ohosAbilityForm != null) {
            JSONObject jSONObject2 = new JSONObject();
            try {
                jSONObject2.put("ohosAbilityForm", ohosAbilityForm);
            } catch (JSONException unused2) {
                KitLog.error(TAG, "ohosAbilityForm JSONException");
            }
            templateData.setKeyValue("jsOhosAbilityForm", jSONObject2.toString());
        }
        if (jsViewCard.getOhosAbilityForms() != null) {
            templateData.setKeyValue("jsOhosAbilityForms", jsViewCard.getOhosAbilityForms().toString());
        }
        if (jsViewCard.getAbilityInfos() != null) {
            templateData.setKeyValue("jsAbilityInfos", jsViewCard.getAbilityInfos().toString());
        }
        templateData.setShowEvaluation(Boolean.parseBoolean(String.valueOf(this.sharedDataMap.get(RecognizerIntent.VISIBLE_OMT))));
        uiConversationCard.setTemplateData(templateData);
        sendCardMsgToUi(uiConversationCard);
        return 0;
    }

    @Action(name = "Speak", nameSpace = "UserInteraction")
    public int speak(Speak speak) {
        Intent intent = new Intent();
        intent.putExtra("TtsType", "normal");
        int i = 0;
        if (speak.isAsync()) {
            String uuid = UUID.randomUUID().toString();
            KitLog.info(TAG, "ignoreTtsId: " + uuid);
            this.sharedDataMap.put("ignoreTtsId", uuid);
            intent.putExtra("utteranceId", uuid);
        } else {
            KitLog.debug(TAG, "normal speak", new Object[0]);
            i = 1;
        }
        String language = speak.getLanguage();
        KitLog.debug(TAG, "language: {}", language);
        intent.putExtra("language", language);
        String text = speak.getText();
        String type = speak.getType();
        intent.putExtra(BaseConstants.INTENT_TEXTTYPE, type);
        if (BaseConstants.SSML_TEXT_TYPE.equals(type)) {
            text = speak.getSsml();
        }
        if (!TextUtils.isEmpty(speak.getStyle())) {
            intent.putExtra("style", speak.getStyle());
        }
        int parseInt = TextUtils.isEmpty(speak.getPerson()) ? -1 : NumberUtil.parseInt(speak.getPerson(), -1, TAG);
        if (parseInt != -1) {
            intent.putExtra(Constants.Tts.TONE_COLOR, parseInt);
        }
        sendTextToSpeak(MultiIntentConstant.TTS_SPEAK_OK, getUpdateText(text), intent);
        return i;
    }

    @Action(name = "StreamingSpeak", nameSpace = "UserInteraction")
    public int streamingSpeak(StreamingSpeak streamingSpeak) {
        int i;
        Intent intent = new Intent();
        if ("high".equalsIgnoreCase(streamingSpeak.getPriority())) {
            i = -1;
        } else {
            String status = streamingSpeak.getStatus();
            i = "START".equalsIgnoreCase(status) ? 0 : "PARTIAL".equalsIgnoreCase(status) ? 1 : "FINAL".equalsIgnoreCase(status) ? 2 : -1;
            if (i != -1) {
                intent.putExtra("streamState", i);
            }
        }
        KitLog.debug(TAG, "toneId = {} style = {}", streamingSpeak.getToneId(), streamingSpeak.getStyle());
        if (!TextUtils.isEmpty(streamingSpeak.getToneId())) {
            int parseInt = Integer.parseInt(streamingSpeak.getToneId());
            intent.putExtra("speaker", parseInt);
            KitLog.info(TAG, "toneId = " + parseInt);
        }
        if (!TextUtils.isEmpty(streamingSpeak.getStyle())) {
            String style = streamingSpeak.getStyle();
            if (style.equals("interaction-broadcast") || style.equals("interaction-oral") || style.equals("reading") || style.equals("anthropomorphic")) {
                intent.putExtra("style", style);
                KitLog.info(TAG, "style = " + style);
            }
        }
        if (!TextUtils.isEmpty(streamingSpeak.getToneId()) && !TextUtils.isEmpty(streamingSpeak.getStyle())) {
            intent.putExtra(Constants.Tts.FORCE_TONE_STYLE, true);
        }
        sendStreamTextToSpeak(streamingSpeak.getText(), intent);
        return (i == -1 || i == 2) ? 1 : 0;
    }
}