Initial commit

sources/com/ubt/jimu/blockly/command/BlocklyCommand.java

@@ -0,0 +1,63 @@
+package com.ubt.jimu.blockly.command;
+
+import com.ubt.jimu.utils.JsonHelper;
+
+/* loaded from: classes.dex */
+public class BlocklyCommand<T> {
+    private T arg;
+    private String callback;
+    private BlocklyCommand<T>.CommandArg extraArg;
+    private String name;
+    private String url;
+
+    public class CommandArg {
+        private String branchId;
+
+        public CommandArg() {
+        }
+
+        public String getBranchId() {
+            return this.branchId;
+        }
+    }
+
+    public BlocklyCommand(String str, Class<T> cls) {
+        parseCommand(str, cls);
+    }
+
+    private void parseCommand(String str, Class<T> cls) {
+        if (str.startsWith(BlocklyCommandController.BASE_REQUEST_URL)) {
+            String[] split = str.split("\\|");
+            this.name = split[0];
+            if (split.length > 1 && split[1].contains("\":") && cls != null) {
+                this.arg = (T) JsonHelper.a(split[1], (Class<?>) cls);
+            }
+            if (split.length > 2) {
+                this.callback = split[2];
+            }
+            if (split.length > 3) {
+                this.extraArg = (CommandArg) JsonHelper.a(split[3], (Class<?>) CommandArg.class);
+            }
+        }
+    }
+
+    public T getArg() {
+        return this.arg;
+    }
+
+    public String getCallback() {
+        return this.callback;
+    }
+
+    public BlocklyCommand<T>.CommandArg getExtraArg() {
+        return this.extraArg;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public String getUrl() {
+        return this.url;
+    }
+}

sources/com/ubt/jimu/blockly/command/BlocklyCommandController.java

@@ -0,0 +1,213 @@
+package com.ubt.jimu.blockly.command;
+
+import android.text.TextUtils;
+import android.webkit.WebView;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+
+/* loaded from: classes.dex */
+public class BlocklyCommandController {
+    public static final String ACTION = "action";
+    public static final String ADJUST_SERVO = "adjustServo";
+    public static final String BASE_REQUEST_URL = "jimu://";
+    public static final String GET_POSTURE = "getPosture";
+    public static final String QUERY = "query";
+    public static final String QUERY_ALL_SENSOR = "queryAllSensor";
+    public static final String QUERY_GYROSCOPE = "queryGyroscope";
+    public static final String QUERY_INFRARED = "queryInfrared";
+    public static final String QUERY_TOUCH_STATUS = "queryTouchStatus";
+    public static final String SERVO_POWER_OFF = "servoPowerOff";
+    public static final String SERVO_POWER_ON = "servoPowerOn";
+    public static final String SERVO_SET = "servoSet";
+    public static final String SERVO_SETBY_SPEED = "servoSetbySpeed";
+    public static final String SET_DIGITAL_TUBE = "setDigitalTube";
+    public static final String SET_EMOJI = "setEmoji";
+    public static final String SET_LEDS = "setLEDs";
+    public static final String SET_SERSOR_LED = "setSensorLED";
+    public static final String SET_SERVO_MODE = "setServoMode";
+    public static final String STOP_ROBOT = "stopRobot";
+    public static final String STOP_SERVO = "stopServo";
+    private JimuBlocklyCommand jsInterface;
+    private final String tag = BlocklyCommandController.class.getSimpleName();
+    public final String CONFIRM = "confirm";
+    public final String SAVE_XML = "SaveXml";
+    public final String READ_XML = "ReadXml";
+    public final String DELETE_XML = "DeleteXml";
+    public final String XML_LIST = "XmlList";
+    public final String CONNECT_BLE = JimuBlocklyCommand.CONNECT_BLE;
+    public final String DISCONNECT_BLE = "DisconnectBLE";
+    public final String CLOSE_WINDOW = "CloseWindow";
+    public final String BLE_STATE = JimuBlocklyCommand.BLE_STATE;
+    public final String OPEN_HEART_BEAT = "openHeartbeat";
+    public final String CLOSE_HEART_BEAT = "closeHeartbeat";
+    public final String START_SENSOR_TIMER = "startInfraredTimer";
+    public final String STOP_SENSOR_TIMER = "stopInfraredTimer";
+
+    public BlocklyCommandController(JimuBlocklyCommand jimuBlocklyCommand) {
+        this.jsInterface = jimuBlocklyCommand;
+    }
+
+    private void bleStateCommand(String str) {
+        this.jsInterface.bleState();
+    }
+
+    private void closeWindowCommand() {
+        this.jsInterface.closeWindow();
+    }
+
+    private void confirmCommand(String str) {
+        this.jsInterface.confirm(str);
+    }
+
+    private void connectedBLECommand() {
+        this.jsInterface.connectedBLE();
+    }
+
+    private void deleteXmlCommand(String str) {
+        BlocklyCommand blocklyCommand = new BlocklyCommand(str, BlocklyProject.class);
+        this.jsInterface.deleteXml(((BlocklyProject) blocklyCommand.getArg()).getXmlId(), blocklyCommand.getCallback());
+    }
+
+    private void disconnectBleCommand(String str) {
+        this.jsInterface.notifyBLEState("{\"blueState\":3}");
+        this.jsInterface.unityComm(str);
+    }
+
+    private void distribute(String str, String str2) {
+        if (str2.contains("confirm")) {
+            confirmCommand(str);
+            return;
+        }
+        if (str2.contains(JimuBlocklyCommand.CONNECT_BLE)) {
+            connectedBLECommand();
+            return;
+        }
+        if (str2.contains("CloseWindow")) {
+            closeWindowCommand();
+            return;
+        }
+        if (str2.contains("ReadXml")) {
+            readXmlCommand(str);
+            return;
+        }
+        if (str2.contains("SaveXml")) {
+            saveXmlCommand(str);
+            return;
+        }
+        if (str2.contains("DeleteXml")) {
+            deleteXmlCommand(str);
+            return;
+        }
+        if (str2.contains("XmlList")) {
+            xmlListCommand(str);
+            return;
+        }
+        if (str2.contains(JimuBlocklyCommand.BLE_STATE)) {
+            bleStateCommand(str);
+            return;
+        }
+        if (str2.contains("openHeartbeat")) {
+            heartBeatCommand("1");
+            return;
+        }
+        if (str2.contains("closeHeartbeat")) {
+            heartBeatCommand("0");
+            return;
+        }
+        if (str2.contains("startInfraredTimer")) {
+            startInfraredTimerCommand(str);
+            return;
+        }
+        if (str2.contains("stopInfraredTimer")) {
+            stopInfraredTimerCommand(str);
+            return;
+        }
+        if (str2.contains(QUERY_INFRARED)) {
+            queryInfraredCommand(str);
+            return;
+        }
+        if (str2.contains("DisconnectBLE")) {
+            disconnectBleCommand(str);
+            return;
+        }
+        if (str2.contains("setServoMode")) {
+            setServoMode();
+        } else if (str2.contains(SERVO_SET)) {
+            servoSet(str, str2);
+        } else {
+            unityCommand(str);
+        }
+    }
+
+    private void heartBeatCommand(String str) {
+        this.jsInterface.heartBeat(str);
+    }
+
+    private void queryInfraredCommand(String str) {
+        this.jsInterface.queryInfrared(str, new BlocklyCommand(str, null).getCallback());
+    }
+
+    private void readXmlCommand(String str) {
+        BlocklyCommand blocklyCommand = new BlocklyCommand(str, BlocklyProject.class);
+        BlocklyProject blocklyProject = (BlocklyProject) blocklyCommand.getArg();
+        if (blocklyProject != null) {
+            this.jsInterface.readXml(blocklyProject.getXmlId(), blocklyCommand.getCallback());
+        }
+    }
+
+    private void saveXmlCommand(String str) {
+        BlocklyCommand blocklyCommand = new BlocklyCommand(str, BlocklyProject.class);
+        this.jsInterface.saveXml(((BlocklyProject) blocklyCommand.getArg()).getXmlName(), ((BlocklyProject) blocklyCommand.getArg()).getXmlContent(), ((BlocklyProject) blocklyCommand.getArg()).getXmlId(), ((BlocklyProject) blocklyCommand.getArg()).getBlocklyVersion(), blocklyCommand.getCallback());
+    }
+
+    private void servoSet(String str, String str2) {
+        String[] split = str.split("\\|");
+        if (TextUtils.isEmpty(split[1])) {
+            this.jsInterface.servoSet(split[2]);
+        } else {
+            unityCommand(str);
+        }
+    }
+
+    private void setServoMode() {
+        this.jsInterface.setServoMode();
+    }
+
+    private void startInfraredTimerCommand(String str) {
+        this.jsInterface.startSensorTimer(str, new BlocklyCommand(str, BlocklyProject.class).getCallback());
+    }
+
+    private void stopInfraredTimerCommand(String str) {
+        this.jsInterface.stopSensorTimer(str);
+    }
+
+    private void unityCommand(String str) {
+        this.jsInterface.unityComm(str);
+    }
+
+    private void xmlListCommand(String str) {
+        this.jsInterface.xmlList(new BlocklyCommand(str, BlocklyProject.class).getCallback());
+    }
+
+    public JimuBlocklyCommand getJsInterface() {
+        return this.jsInterface;
+    }
+
+    public boolean onBlocklyCommand(WebView webView, String str) {
+        if (TextUtils.isEmpty(str)) {
+            return false;
+        }
+        try {
+            String decode = URLDecoder.decode(str, "UTF-8");
+            if (!decode.startsWith(BASE_REQUEST_URL)) {
+                return false;
+            }
+            distribute(decode, decode.split("\\|")[0]);
+            return true;
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+}

sources/com/ubt/jimu/blockly/command/IBlocklyCommand.java

@@ -0,0 +1,43 @@
+package com.ubt.jimu.blockly.command;
+
+import com.ubt.jimu.blockly.JimuRobot;
+
+@Deprecated
+/* loaded from: classes.dex */
+public interface IBlocklyCommand {
+    void bleState();
+
+    void closeWindow();
+
+    void confirm();
+
+    void connectedBLE();
+
+    void deleteXml(String str, String str2);
+
+    JimuRobot getJimuRobot();
+
+    void heartBeat(String str);
+
+    void notifyBLEState(String str);
+
+    void queryInfrared(String str, String str2);
+
+    void readXml(String str, String str2);
+
+    void saveXml(String str, String str2, String str3, String str4, String str5);
+
+    void servoSet(String str);
+
+    void setJimuRobot(JimuRobot jimuRobot);
+
+    void setServoMode();
+
+    void startSensorTimer(String str, String str2);
+
+    void stopSensorTimer(String str);
+
+    void unityComm(String str);
+
+    void xmlList(String str);
+}

sources/com/ubt/jimu/blockly/command/IUnityCommand.java

@@ -0,0 +1,21 @@
+package com.ubt.jimu.blockly.command;
+
+@Deprecated
+/* loaded from: classes.dex */
+public interface IUnityCommand {
+    void blueConnectCallBack(String str);
+
+    void chargeProtected(String str);
+
+    void jsExceptionWaitResult();
+
+    void jsShowException(String str);
+
+    void notifyKeyboardHidden(String str);
+
+    void refreshAllServo(String str);
+
+    void showInfraredRef(String str, String str2);
+
+    void wakeupBlockly(String str, int i);
+}

sources/com/ubt/jimu/blockly/command/JavaScriptCommand.java

@@ -0,0 +1,690 @@
+package com.ubt.jimu.blockly.command;
+
+import android.app.Activity;
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+import android.webkit.WebView;
+import com.ubt.jimu.Channel;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.db.DatabaseUtils;
+import com.ubt.jimu.base.db.diy.DiyProgramFileDbHandler;
+import com.ubt.jimu.blockly.JimuRobot;
+import com.ubt.jimu.blockly.Utils;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.bean.JimuMotion;
+import com.ubt.jimu.blockly.bean.JimuSound;
+import com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction;
+import com.ubt.jimu.blockly.command.result.JavaResultBean;
+import com.ubt.jimu.blockly.command.result.XmlListBean;
+import com.ubt.jimu.blockly.dao.BlocklyProjectDbHandler;
+import com.ubt.jimu.blockly.dao.JimuMotionDbHandler;
+import com.ubt.jimu.blockly.dao.JimuSoundDbHandler;
+import com.ubt.jimu.blockly.feature.audio.AudioPlayer;
+import com.ubt.jimu.blockly.feature.audio.AudioRecoder;
+import com.ubt.jimu.course.repository.CourseResult;
+import com.ubt.jimu.unity.bluetooth.UnityActivity;
+import com.ubt.jimu.utils.JsonHelper;
+import com.ubt.jimu.utils.LogUtils;
+import com.ubt.jimu.utils.SystemUtils;
+import com.ubtech.utils.FileHelper;
+import com.ubtrobot.log.ALog;
+import com.ubtrobot.ubtlib.analytics.IAnalytics;
+import com.ubtrobot.ubtlib.analytics.JimuAnalytics;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public class JavaScriptCommand {
+    private AbstractBlocklyInteraction blocklyInteraction;
+    private Context context;
+    private JimuCourseCommand jimuCourseCommand;
+    private JimuRobot jimuRobot;
+    private WebView webView;
+    protected String TAG = JavaScriptCommand.class.getSimpleName();
+    private ArrayList<BlocklyProject> projects = new ArrayList<>();
+    private final String BLOCKLY_INTERVAL = "continueSteps";
+    private BlocklyProjectDbHandler blocklyProjectDbHandler = new BlocklyProjectDbHandler(DatabaseUtils.getDaoSession(true).a());
+    private JimuMotionDbHandler jimuMotionDbHandler = new JimuMotionDbHandler(DatabaseUtils.getDaoSession(true).o());
+    private JimuSoundDbHandler jimuSoundDbHandler = new JimuSoundDbHandler(DatabaseUtils.getDaoSession(true).p());
+    private IAnalytics mAnalytics = JimuAnalytics.b();
+
+    public JavaScriptCommand(WebView webView, Context context, JimuRobot jimuRobot, AbstractBlocklyInteraction abstractBlocklyInteraction) {
+        this.jimuRobot = jimuRobot;
+        this.webView = webView;
+        this.context = context;
+        this.blocklyInteraction = abstractBlocklyInteraction;
+        this.jimuCourseCommand = new JimuCourseCommand((UnityActivity) context);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r8v2, types: [T, com.ubt.jimu.blockly.bean.JimuSound, java.lang.Object] */
+    public JavaResultBean<JimuSound> addCustomSound(String str) {
+        JavaResultBean<JimuSound> javaResultBean = new JavaResultBean<>();
+        ?? r8 = (JimuSound) JsonHelper.a(str, (Class<?>) JimuSound.class);
+        if (r8 == 0) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            return javaResultBean;
+        }
+        if (TextUtils.isEmpty(AudioRecoder.getInstance().getFileName())) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            return javaResultBean;
+        }
+        File file = new File(AudioRecoder.getInstance().getFileName());
+        if (!file.exists()) {
+            if (file.getParentFile().exists()) {
+                FileHelper.a(file.getParentFile());
+            }
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            return javaResultBean;
+        }
+        if (TextUtils.isEmpty(r8.getDescription())) {
+            r8.setDescription(this.jimuSoundDbHandler.getDefaultSoundName(Cache.getInstance().getUserId(), r8.getDefaultName()));
+        }
+        if (this.jimuSoundDbHandler.nameExist(Cache.getInstance().getUserId(), r8.getDescription())) {
+            javaResultBean.retCode = JavaResultBean.RESULT_NAME;
+            return javaResultBean;
+        }
+        r8.setUserId(Cache.getInstance().getUserId());
+        r8.setKey(AudioRecoder.getInstance().getKey());
+        r8.setAudioId(AudioRecoder.getInstance().getKey());
+        r8.setType(JimuSound.TYPE_RECORDING);
+        r8.setDuration(((AudioPlayer.getInstance().getAudioDuration(file.getAbsolutePath()) + 500) / 1000) + "");
+        r8.setIsDeleted("0");
+        r8.setLastUploadTime(SystemUtils.a());
+        this.jimuSoundDbHandler.insert(r8);
+        javaResultBean.retCode = "0000";
+        javaResultBean.result = r8;
+        AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+        if (abstractBlocklyInteraction != 0) {
+            abstractBlocklyInteraction.addJimuSound(r8, file);
+        }
+        return javaResultBean;
+    }
+
+    public List<JimuSound> customSoundList(String str) {
+        return this.jimuSoundDbHandler.getJimuSounds(this.jimuRobot.getCustomSounds(), str);
+    }
+
+    public JavaResultBean<String> deleteCustomMotion(String str) {
+        JavaResultBean<String> javaResultBean = new JavaResultBean<>();
+        JimuMotion jimuMotion = (JimuMotion) JsonHelper.b(str, JimuMotion.class);
+        if (jimuMotion == null) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            javaResultBean.retMsg = "failed";
+            return javaResultBean;
+        }
+        jimuMotion.setUserId(Cache.getInstance().getUserId());
+        jimuMotion.setCustomModelId(this.jimuRobot.getModelId());
+        JimuMotion selectUnique = this.jimuMotionDbHandler.selectUnique(jimuMotion);
+        if (selectUnique == null) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            javaResultBean.retMsg = "failed";
+            return javaResultBean;
+        }
+        if (selectUnique.getIsFirst() != 0 || selectUnique.getIsUploadService()) {
+            selectUnique.setIsDeleted("1");
+            selectUnique.setLastUploadTime(SystemUtils.a());
+            selectUnique.setIsUploadService(false);
+            this.jimuMotionDbHandler.update(selectUnique);
+            javaResultBean.retCode = "0000";
+            javaResultBean.retMsg = CourseResult.SUCCESS;
+        } else {
+            this.jimuMotionDbHandler.deleteJimuMotionByModeelId(selectUnique.getActionID());
+        }
+        AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+        if (abstractBlocklyInteraction != null) {
+            abstractBlocklyInteraction.deleteJimuMotion(selectUnique);
+        }
+        return javaResultBean;
+    }
+
+    public boolean deleteCustomSound(String str, String str2) {
+        JimuSound jimuSound;
+        JimuSound jimuSound2 = (JimuSound) JsonHelper.a(str2, (Class<?>) JimuSound.class);
+        if (jimuSound2 == null || (jimuSound = this.jimuSoundDbHandler.getJimuSound(str, jimuSound2.getKey())) == null) {
+            return false;
+        }
+        jimuSound.setIsDeleted("1");
+        jimuSound.setLastUploadTime(SystemUtils.a());
+        this.jimuSoundDbHandler.update(jimuSound);
+        File file = new File(this.jimuRobot.getCustomSounds() + jimuSound2.getKey());
+        if (file.exists()) {
+            try {
+                FileHelper.a(file);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+        if (abstractBlocklyInteraction == null) {
+            return true;
+        }
+        abstractBlocklyInteraction.deleteJimuSound(jimuSound, file);
+        return true;
+    }
+
+    public JavaResultBean<Object> deleteXml(String str) {
+        boolean z;
+        Iterator<BlocklyProject> it = this.projects.iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                z = false;
+                break;
+            }
+            BlocklyProject next = it.next();
+            if (next.getXmlId().equals(str)) {
+                z = next.getIsDefault();
+                break;
+            }
+        }
+        JavaResultBean<Object> javaResultBean = new JavaResultBean<>();
+        if (z) {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            javaResultBean.retMsg = "can not delete sample project.";
+            return javaResultBean;
+        }
+        BlocklyProject blocklyProject = this.blocklyProjectDbHandler.getBlocklyProject(Cache.getInstance().getUserId(), this.jimuRobot.getServerModelType(), this.jimuRobot.getModelId(), str);
+        if (blocklyProject != null) {
+            File file = new File(this.jimuRobot.getBlocklyProject(blocklyProject.getBlocklyType()) + str + ".xml");
+            blocklyProject.setIsDeleted("1");
+            blocklyProject.setModelId(this.jimuRobot.getServerModelId());
+            blocklyProject.setLastUploadTime(SystemUtils.a());
+            blocklyProject.setIsModify(true);
+            blocklyProject.setIsUploadService(false);
+            this.blocklyProjectDbHandler.update(blocklyProject);
+            if (file.exists()) {
+                file.delete();
+            }
+            javaResultBean.retCode = "0000";
+            AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+            if (abstractBlocklyInteraction != null) {
+                abstractBlocklyInteraction.deleteBlocklyProject(blocklyProject, file);
+            }
+        } else {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+        }
+        return javaResultBean;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v1, types: [T, com.ubt.jimu.blockly.bean.BlocklyProject, java.lang.Object] */
+    public JavaResultBean<BlocklyProject> editXml(String str, String str2, String str3, String str4, String str5) {
+        JavaResultBean<BlocklyProject> javaResultBean = new JavaResultBean<>();
+        ?? blocklyProject = this.blocklyProjectDbHandler.getBlocklyProject(Cache.getInstance().getUserId(), this.jimuRobot.getServerModelType(), this.jimuRobot.getModelId(), str3);
+        if (blocklyProject == 0) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            javaResultBean.retMsg = "the project you editing not exist!";
+            return javaResultBean;
+        }
+        blocklyProject.setXmlName(str);
+        blocklyProject.setBlocklyVersion(str4);
+        blocklyProject.setModelId(this.jimuRobot.getServerModelId());
+        blocklyProject.setIsUploadService(false);
+        blocklyProject.setIsModify(true);
+        blocklyProject.setIsUploadQiNiu(false);
+        blocklyProject.setLastUploadTime(SystemUtils.a());
+        this.blocklyProjectDbHandler.update(blocklyProject);
+        String str6 = this.jimuRobot.getBlocklyProject(blocklyProject.getBlocklyType()) + str3 + ".xml";
+        if (!FileHelper.a(str6, str2, (String) null)) {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            javaResultBean.retMsg = "can not write xmlContent to file";
+            return javaResultBean;
+        }
+        javaResultBean.retCode = "0000";
+        javaResultBean.retMsg = CourseResult.SUCCESS;
+        javaResultBean.result = blocklyProject;
+        AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+        if (abstractBlocklyInteraction != 0) {
+            abstractBlocklyInteraction.updateBlocklyProject(blocklyProject, new File(str6));
+        }
+        return javaResultBean;
+    }
+
+    /* JADX WARN: Type inference failed for: r6v4, types: [T, com.ubt.jimu.blockly.bean.JimuMotion] */
+    public JavaResultBean<JimuMotion> getCustomMotion(String str) {
+        JavaResultBean<JimuMotion> javaResultBean = new JavaResultBean<>();
+        JimuMotion jimuMotion = (JimuMotion) JsonHelper.b(str, JimuMotion.class);
+        if (jimuMotion == null) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            javaResultBean.retMsg = "无效的参数输入";
+            return javaResultBean;
+        }
+        ?? jimuMotionById = this.jimuMotionDbHandler.getJimuMotionById(Cache.getInstance().getUserId(), this.jimuRobot.getModelId(), jimuMotion.getActionID());
+        if (jimuMotionById == 0) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            javaResultBean.retMsg = "failed";
+        } else {
+            javaResultBean.retCode = "0000";
+            javaResultBean.retMsg = CourseResult.SUCCESS;
+            javaResultBean.result = jimuMotionById;
+        }
+        return javaResultBean;
+    }
+
+    public List<JimuMotion> getMotionList() {
+        return this.jimuMotionDbHandler.getUserModelMotions(Cache.getInstance().getUserId(), this.jimuRobot.getModelId());
+    }
+
+    public JavaResultBean<String> helpUrl() {
+        JavaResultBean<String> javaResultBean = new JavaResultBean<>();
+        javaResultBean.retCode = "0000";
+        javaResultBean.retMsg = CourseResult.SUCCESS;
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("funcName", UnityActivity.BLOCKLY_HELP);
+            jSONObject.put("arg", "");
+            UnityActivity.communityWithUnity(jSONObject.toString());
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return javaResultBean;
+    }
+
+    public void playAudio(String str) {
+        final JimuSound jimuSound = (JimuSound) JsonHelper.a(str, (Class<?>) JimuSound.class);
+        if (jimuSound == null) {
+            return;
+        }
+        String str2 = null;
+        if (JimuSound.TYPE_RECORDING.equals(jimuSound.getType())) {
+            File file = new File(this.jimuRobot.getCustomSounds() + jimuSound.getKey());
+            if (file.exists()) {
+                String[] list = file.list();
+                int length = list.length;
+                int i = 0;
+                while (true) {
+                    if (i >= length) {
+                        break;
+                    }
+                    String str3 = list[i];
+                    if (str3.matches("^.+(aac|wav|mp3|3gp)$")) {
+                        str2 = file.getAbsolutePath() + File.separator + str3;
+                        break;
+                    }
+                    i++;
+                }
+            }
+        } else {
+            str2 = Utils.baseUrl + jimuSound.getPlayPath();
+        }
+        long parseDouble = JimuSound.TYPE_TUNE.equals(jimuSound.getType()) ? !TextUtils.isEmpty(jimuSound.getBeatTime()) ? (long) (Double.parseDouble(jimuSound.getBeatTime()) * 1000.0d) : AudioPlayer.getInstance().getAudioDuration(str2) : 0L;
+        if (new File(str2).exists()) {
+            if (jimuSound.getIsDelay()) {
+                AudioPlayer.getInstance().play(str2, parseDouble, new AudioPlayer.IProgressListener() { // from class: com.ubt.jimu.blockly.command.JavaScriptCommand.1
+                    private void wakeupBlockly() {
+                        JavaScriptCommand.this.webView.post(new Runnable() { // from class: com.ubt.jimu.blockly.command.JavaScriptCommand.1.1
+                            @Override // java.lang.Runnable
+                            public void run() {
+                                Utils.setJSResult(JavaScriptCommand.this.webView, "continueSteps", jimuSound.getBranchId(), "1");
+                            }
+                        });
+                    }
+
+                    @Override // com.ubt.jimu.blockly.feature.audio.AudioPlayer.IProgressListener
+                    public void onError() {
+                        wakeupBlockly();
+                    }
+
+                    @Override // com.ubt.jimu.blockly.feature.audio.AudioPlayer.IProgressListener
+                    public void onFinished() {
+                        wakeupBlockly();
+                    }
+                });
+                return;
+            } else {
+                AudioPlayer.getInstance().play(str2);
+                return;
+            }
+        }
+        Log.e(this.TAG, "音效文件丢失：" + str2);
+        if (jimuSound.getIsDelay()) {
+            Utils.setJSResult(this.webView, "continueSteps", jimuSound.getBranchId(), "1");
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r0v5, types: [T, java.lang.String] */
+    public JavaResultBean<String> readXml(String str) {
+        String str2;
+        if (this.projects.size() == 0) {
+            xmlList();
+        }
+        BlocklyProject blocklyProject = null;
+        Iterator<BlocklyProject> it = this.projects.iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                break;
+            }
+            BlocklyProject next = it.next();
+            if (next.getXmlId().equals(str)) {
+                blocklyProject = next;
+                break;
+            }
+        }
+        JavaResultBean<String> javaResultBean = new JavaResultBean<>();
+        if (blocklyProject != null) {
+            if (blocklyProject.getIsDefault()) {
+                str2 = this.jimuRobot.getSamplePath() + str + ".xml";
+            } else {
+                str2 = this.jimuRobot.getBlocklyProject(blocklyProject.getBlocklyType()) + str + ".xml";
+            }
+            String b = FileHelper.b(str2, "");
+            javaResultBean.retCode = "0000";
+            XmlListBean xmlListBean = new XmlListBean(b);
+            xmlListBean.type = TextUtils.isEmpty(blocklyProject.getBlocklyType()) ? "newBlockly" : blocklyProject.getBlocklyType();
+            xmlListBean.isDefault = blocklyProject.getIsDefault();
+            xmlListBean.blocklyVersion = blocklyProject.getBlocklyVersion();
+            javaResultBean.result = JsonHelper.a(xmlListBean);
+            if ("google_play".equals(Channel.FIR_TEST.getChannelName())) {
+                ALog.a(this.TAG).d(FileHelper.b(str2, ""));
+            }
+        } else {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            javaResultBean.retMsg = "xmlId not in projects";
+        }
+        return javaResultBean;
+    }
+
+    public void recordContentViewEnd(String str) {
+        this.mAnalytics.b((Activity) this.context, str);
+    }
+
+    public void recordContentViewStart(String str) {
+        this.mAnalytics.a((Activity) this.context, str);
+    }
+
+    public void recordEvent(String str, String str2) {
+        if (TextUtils.isEmpty(str2)) {
+            JimuAnalytics.b().a(str);
+            return;
+        }
+        try {
+            JSONObject jSONObject = new JSONObject(str2);
+            Iterator<String> keys = jSONObject.keys();
+            HashMap hashMap = new HashMap();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                hashMap.put(next, String.valueOf(jSONObject.get(next)));
+            }
+            JimuAnalytics.b().a(str, hashMap);
+        } catch (JSONException e) {
+            Log.e(this.TAG, "Parse data report event param fail!", e);
+        } catch (Exception e2) {
+            Log.e(this.TAG, "Parse data report event param fail!", e2);
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:26:0x00ad, code lost:
+    
+        if (r4 == false) goto L28;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:27:0x00af, code lost:
+    
+        r0.retCode = "0000";
+        r0.result = r8;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:28:0x00b8, code lost:
+    
+        return r0;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:29:0x00b6, code lost:
+    
+        r0.retCode = com.ubt.jimu.blockly.command.result.JavaResultBean.RESULT_EXCEPTION;
+     */
+    /* JADX WARN: Type inference failed for: r8v2, types: [T, com.ubt.jimu.blockly.bean.JimuSound] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public com.ubt.jimu.blockly.command.result.JavaResultBean<com.ubt.jimu.blockly.bean.JimuSound> renameAudio(java.lang.String r8) {
+        /*
+            r7 = this;
+            com.ubt.jimu.blockly.command.result.JavaResultBean r0 = new com.ubt.jimu.blockly.command.result.JavaResultBean
+            r0.<init>()
+            java.lang.Class<com.ubt.jimu.blockly.bean.JimuSound> r1 = com.ubt.jimu.blockly.bean.JimuSound.class
+            java.lang.Object r8 = com.ubt.jimu.utils.JsonHelper.a(r8, r1)
+            com.ubt.jimu.blockly.bean.JimuSound r8 = (com.ubt.jimu.blockly.bean.JimuSound) r8
+            java.lang.String r1 = "0011"
+            if (r8 == 0) goto Lbc
+            java.lang.String r2 = r8.getDescription()
+            boolean r2 = android.text.TextUtils.isEmpty(r2)
+            if (r2 == 0) goto L1d
+            goto Lbc
+        L1d:
+            com.ubt.jimu.blockly.dao.JimuSoundDbHandler r2 = r7.jimuSoundDbHandler
+            com.ubt.jimu.blockly.JimuRobot r3 = r7.jimuRobot
+            java.lang.String r3 = r3.getCustomSounds()
+            com.ubt.jimu.base.cache.Cache r4 = com.ubt.jimu.base.cache.Cache.getInstance()
+            java.lang.String r4 = r4.getUserId()
+            java.util.List r2 = r2.getJimuSounds(r3, r4)
+            if (r2 == 0) goto Lb9
+            int r3 = r2.size()
+            if (r3 != 0) goto L3b
+            goto Lb9
+        L3b:
+            java.util.Iterator r2 = r2.iterator()
+        L3f:
+            boolean r3 = r2.hasNext()
+            r4 = 0
+            if (r3 == 0) goto Lad
+            java.lang.Object r3 = r2.next()
+            com.ubt.jimu.blockly.bean.JimuSound r3 = (com.ubt.jimu.blockly.bean.JimuSound) r3
+            java.lang.String r5 = r3.getDescription()
+            boolean r6 = android.text.TextUtils.isEmpty(r5)
+            if (r6 != 0) goto L65
+            java.lang.String r6 = r8.getDescription()
+            boolean r5 = r5.equals(r6)
+            if (r5 == 0) goto L65
+            java.lang.String r8 = "0001"
+            r0.retCode = r8
+            return r0
+        L65:
+            java.lang.String r5 = r3.getKey()
+            java.lang.String r6 = r8.getKey()
+            boolean r5 = r5.equals(r6)
+            if (r5 == 0) goto L3f
+            java.lang.String r2 = r8.getDescription()
+            r3.setDescription(r2)
+            java.lang.String r2 = r3.getDuration()
+            r8.setDuration(r2)
+            java.lang.String r2 = r3.getIcon()
+            r8.setIcon(r2)
+            java.lang.String r2 = r3.getType()
+            r8.setType(r2)
+            long r5 = com.ubt.jimu.utils.SystemUtils.a()
+            r8.setLastUploadTime(r5)
+            r8.setIsSyncUbtService(r4)
+            r4 = 1
+            long r5 = r8.getLastUploadTime()
+            r3.setLastUploadTime(r5)
+            com.ubt.jimu.blockly.dao.JimuSoundDbHandler r2 = r7.jimuSoundDbHandler
+            r2.insertOrUpdate(r3)
+            com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction r2 = r7.blocklyInteraction
+            if (r2 == 0) goto Lad
+            r2.renameJimuSound(r3)
+        Lad:
+            if (r4 == 0) goto Lb6
+            java.lang.String r1 = "0000"
+            r0.retCode = r1
+            r0.result = r8
+            goto Lb8
+        Lb6:
+            r0.retCode = r1
+        Lb8:
+            return r0
+        Lb9:
+            r0.retCode = r1
+            return r0
+        Lbc:
+            r0.retCode = r1
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.ubt.jimu.blockly.command.JavaScriptCommand.renameAudio(java.lang.String):com.ubt.jimu.blockly.command.result.JavaResultBean");
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r1v2, types: [T, com.ubt.jimu.blockly.bean.JimuMotion, java.lang.Object] */
+    public JavaResultBean<JimuMotion> renameMotion(String str) {
+        JavaResultBean<JimuMotion> javaResultBean = new JavaResultBean<>();
+        JimuMotion jimuMotion = (JimuMotion) JsonHelper.b(str, JimuMotion.class);
+        if (jimuMotion == null) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            return javaResultBean;
+        }
+        ?? jimuMotionById = this.jimuMotionDbHandler.getJimuMotionById(Cache.getInstance().getUserId(), this.jimuRobot.getModelId(), jimuMotion.getActionID());
+        if (jimuMotionById == 0) {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            return javaResultBean;
+        }
+        if (this.jimuMotionDbHandler.nameExist(jimuMotion)) {
+            javaResultBean.retCode = JavaResultBean.RESULT_NAME;
+            return javaResultBean;
+        }
+        jimuMotionById.setLastUploadTime(SystemUtils.a());
+        jimuMotionById.setIsUploadService(false);
+        jimuMotionById.setActionName(jimuMotion.getActionName());
+        this.jimuMotionDbHandler.insertOrUpdate(jimuMotionById);
+        javaResultBean.result = jimuMotionById;
+        javaResultBean.retCode = "0000";
+        AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+        if (abstractBlocklyInteraction != 0) {
+            abstractBlocklyInteraction.renameJimuMotion(jimuMotionById);
+        }
+        return javaResultBean;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r2v10, types: [T, com.ubt.jimu.blockly.bean.BlocklyProject, java.lang.Object] */
+    public JavaResultBean<BlocklyProject> renameProject(String str) {
+        JavaResultBean<BlocklyProject> javaResultBean = new JavaResultBean<>();
+        BlocklyProject blocklyProject = (BlocklyProject) JsonHelper.b(str, BlocklyProject.class);
+        if (blocklyProject == null) {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            return javaResultBean;
+        }
+        blocklyProject.setUserId(Cache.getInstance().getUserId());
+        blocklyProject.setModelType(this.jimuRobot.getServerModelType());
+        blocklyProject.setCustomModelId(this.jimuRobot.getModelId());
+        blocklyProject.setBlocklyType("newBlockly");
+        blocklyProject.setModelId(this.jimuRobot.getServerModelId());
+        ?? selectUnique = this.blocklyProjectDbHandler.selectUnique(blocklyProject);
+        if (selectUnique == 0) {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            return javaResultBean;
+        }
+        if (this.blocklyProjectDbHandler.isNameExist(blocklyProject)) {
+            javaResultBean.retCode = JavaResultBean.RESULT_NAME;
+            javaResultBean.retMsg = "project's name already exist!";
+            return javaResultBean;
+        }
+        selectUnique.setLastUploadTime(SystemUtils.a());
+        selectUnique.setXmlName(blocklyProject.getXmlName());
+        selectUnique.setIsUploadService(false);
+        selectUnique.setIsModify(true);
+        this.blocklyProjectDbHandler.insertOrUpdate(selectUnique);
+        javaResultBean.retCode = "0000";
+        javaResultBean.result = selectUnique;
+        selectUnique.setModelId(this.jimuRobot.getServerModelId());
+        if (this.blocklyInteraction != null) {
+            this.blocklyInteraction.renameBlocklyProject(selectUnique, new File(this.jimuRobot.getBlocklyProject(selectUnique.getBlocklyType()) + selectUnique.getXmlId() + ".xml"));
+        }
+        return javaResultBean;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r1v4, types: [T, java.lang.String] */
+    public JavaResultBean<String> saveCustomMotion(String str) {
+        LogUtils.c("保存动作");
+        JavaResultBean<String> javaResultBean = new JavaResultBean<>();
+        JimuMotion jimuMotion = (JimuMotion) JsonHelper.b(str, JimuMotion.class);
+        if (jimuMotion == 0) {
+            javaResultBean.retMsg = "参数输入异常";
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            return javaResultBean;
+        }
+        if (TextUtils.isEmpty(jimuMotion.getActionName())) {
+            jimuMotion.setActionName(this.jimuMotionDbHandler.getDefaultMotionName(Cache.getInstance().getUserId(), this.jimuRobot.getModelId(), jimuMotion.getDefaultName()));
+        }
+        ?? formatId = Utils.getFormatId(System.currentTimeMillis());
+        jimuMotion.setUserId(Cache.getInstance().getUserId());
+        jimuMotion.setActionID(formatId);
+        jimuMotion.setCustomModelId(this.jimuRobot.getModelId());
+        jimuMotion.setModelType(this.jimuRobot.getServerModelType());
+        jimuMotion.setIsDeleted("0");
+        jimuMotion.setModelId((int) this.jimuRobot.getServerModelId());
+        if (this.jimuMotionDbHandler.nameExist(jimuMotion)) {
+            javaResultBean.retCode = JavaResultBean.RESULT_NAME;
+            javaResultBean.retMsg = "重名";
+            return javaResultBean;
+        }
+        jimuMotion.setLastUploadTime(SystemUtils.a());
+        this.jimuMotionDbHandler.insert(jimuMotion);
+        javaResultBean.retCode = "0000";
+        javaResultBean.retMsg = CourseResult.SUCCESS;
+        javaResultBean.result = formatId;
+        AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+        if (abstractBlocklyInteraction != null) {
+            abstractBlocklyInteraction.addJimuMotion(jimuMotion);
+        }
+        return javaResultBean;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r14v0, types: [T, com.ubt.jimu.blockly.bean.BlocklyProject, java.lang.Object] */
+    public JavaResultBean<BlocklyProject> saveXml(String str, String str2, String str3, String str4) {
+        JavaResultBean<BlocklyProject> javaResultBean = new JavaResultBean<>();
+        String defaultXmlName = TextUtils.isEmpty(str) ? this.blocklyProjectDbHandler.getDefaultXmlName(str4, Cache.getInstance().getUserId(), this.jimuRobot.getServerModelType(), this.jimuRobot.getModelId()) : str;
+        String formatId = Utils.getFormatId(System.currentTimeMillis());
+        ?? blocklyProject = new BlocklyProject(Cache.getInstance().getUserId(), this.jimuRobot.getServerModelType(), this.jimuRobot.getServerModelId(), this.jimuRobot.getModelId(), "newBlockly", formatId, defaultXmlName, str3, null);
+        if (this.blocklyProjectDbHandler.isNameExist(blocklyProject)) {
+            javaResultBean.retCode = JavaResultBean.RESULT_NAME;
+            javaResultBean.retMsg = "project's name already exist!";
+            return javaResultBean;
+        }
+        String str5 = this.jimuRobot.getBlocklyProject(blocklyProject.getBlocklyType()) + formatId + ".xml";
+        if (!FileHelper.a(str5, str2, (String) null)) {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            javaResultBean.retMsg = "can not write xmlContent to file";
+            return javaResultBean;
+        }
+        blocklyProject.setIsDeleted("0");
+        blocklyProject.setModelId(this.jimuRobot.getServerModelId());
+        this.blocklyProjectDbHandler.insertOrUpdate(blocklyProject);
+        javaResultBean.retCode = "0000";
+        javaResultBean.retMsg = CourseResult.SUCCESS;
+        javaResultBean.result = blocklyProject;
+        AbstractBlocklyInteraction abstractBlocklyInteraction = this.blocklyInteraction;
+        if (abstractBlocklyInteraction != 0) {
+            abstractBlocklyInteraction.addBlocklyProject(blocklyProject, new File(str5));
+        }
+        return javaResultBean;
+    }
+
+    public JavaResultBean<Object> successDeal(String str) {
+        JavaResultBean<Object> javaResultBean = new JavaResultBean<>();
+        this.jimuCourseCommand.successDeal(str);
+        return javaResultBean;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v8, types: [T, com.ubt.jimu.blockly.command.result.XmlListBean] */
+    public JavaResultBean<XmlListBean> xmlList() {
+        this.projects.clear();
+        JavaResultBean<XmlListBean> javaResultBean = new JavaResultBean<>();
+        javaResultBean.retCode = "0000";
+        List<BlocklyProject> diyBlocklyProject = ((UnityActivity) this.context).getBlocklyType() == 8196 ? DiyProgramFileDbHandler.getDiyBlocklyProject(this.jimuRobot.getModelId()) : BlocklyProjectDbHandler.getProjects(Cache.getInstance().getUserId(), this.jimuRobot.getModelId(), Integer.valueOf(this.jimuRobot.getServerModelType()).intValue());
+        if (diyBlocklyProject != null && diyBlocklyProject.size() > 0) {
+            this.projects.addAll(diyBlocklyProject);
+        }
+        javaResultBean.result = new XmlListBean(this.projects);
+        return javaResultBean;
+    }
+
+    public void recordEvent(String str) {
+        this.mAnalytics.a(str);
+    }
+}

sources/com/ubt/jimu/blockly/command/JimuBlocklyCommand.java

@@ -0,0 +1,501 @@
+package com.ubt.jimu.blockly.command;
+
+import android.text.TextUtils;
+import android.util.Log;
+import android.webkit.WebView;
+import com.alibaba.android.arouter.facade.Postcard;
+import com.alibaba.android.arouter.launcher.ARouter;
+import com.google.gson.reflect.TypeToken;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.db.diy.DiyDBModel;
+import com.ubt.jimu.base.db.diy.DiyHelper;
+import com.ubt.jimu.base.entities.Robot;
+import com.ubt.jimu.blockly.JimuRobot;
+import com.ubt.jimu.blockly.Utils;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.command.result.JavaResultBean;
+import com.ubt.jimu.blockly.command.result.SaveBean;
+import com.ubt.jimu.blockly.command.result.XmlListBean;
+import com.ubt.jimu.blockly.exception.BlocklyEvent;
+import com.ubt.jimu.course.repository.JimuCourse;
+import com.ubt.jimu.course.view.JimuTaskListActivity;
+import com.ubt.jimu.discover.view.CourseListActivity;
+import com.ubt.jimu.diy.view.DiyBrowseActivity;
+import com.ubt.jimu.diy.view.DiyFanActivity;
+import com.ubt.jimu.unity.bluetooth.UnityActivity;
+import com.ubt.jimu.utils.JsonHelper;
+import com.ubt.jimu.utils.LogUtils;
+import com.ubt.jimu.utils.SPUtils;
+import com.ubtech.utils.FileHelper;
+import com.ubtrobot.log.ALog;
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Type;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+import org.greenrobot.eventbus.EventBus;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public class JimuBlocklyCommand {
+    public static final String BLE_STATE = "BLEState";
+    public static final String CONNECT_BLE = "ConnectBLE";
+    public static final String EXIT_LOGIC_VIEW = "ExitLogicView";
+    public static final String LOGIC_CMD = "LogicCMD";
+    public static final String SET_SEND_XT_STATE = "setSendXTState";
+    public static final String SET_SERVO_MODE = "setServoMode";
+    public static final String WAKEUP_BLOCKLY = "continueSteps";
+    private UnityActivity context;
+    private TimerTask infraredTask;
+    private JimuRobot jimuRobot;
+    private int moduleType;
+    private String queryCallback;
+    private String queryUrl;
+    private Timer timer;
+    private WebView webView;
+    private final String BLE_CONNECT_CALLBACK = JimuUnityCommand.BLE_CONNECT_CALLBACK;
+    protected final long INFRARED_INTERVAL = 200;
+    protected String tag = JimuBlocklyCommand.class.getSimpleName();
+    private ArrayList<BlocklyProject> projects = new ArrayList<>();
+
+    private class InfraredTimerTask extends TimerTask {
+        private String url;
+
+        public InfraredTimerTask(String str) {
+            this.url = str;
+        }
+
+        @Override // java.util.TimerTask, java.lang.Runnable
+        public void run() {
+            JimuBlocklyCommand.this.unityComm(this.url);
+        }
+    }
+
+    public JimuBlocklyCommand(WebView webView, UnityActivity unityActivity, JimuRobot jimuRobot) {
+        this.context = unityActivity;
+        this.webView = webView;
+        this.jimuRobot = jimuRobot;
+    }
+
+    private boolean isNameExist(String str, String str2, String str3) {
+        JavaResultBean<?> javaResultBean = new JavaResultBean<>();
+        if (TextUtils.isEmpty(str)) {
+            javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+            javaResultBean.retMsg = "";
+            setJSResult(javaResultBean, str3, true);
+            return true;
+        }
+        String b = FileHelper.b(this.jimuRobot.getBlocklyProject("blockly") + this.jimuRobot.getModelId() + ".config", (String) null);
+        if (!TextUtils.isEmpty(b)) {
+            ArrayList arrayList = (ArrayList) JsonHelper.a(b, new TypeToken<List<BlocklyProject>>() { // from class: com.ubt.jimu.blockly.command.JimuBlocklyCommand.3
+            }.getType());
+            if (arrayList == null) {
+                arrayList = new ArrayList();
+            }
+            if (arrayList.size() > 0) {
+                Iterator it = arrayList.iterator();
+                while (it.hasNext()) {
+                    BlocklyProject blocklyProject = (BlocklyProject) it.next();
+                    if (blocklyProject.getXmlName().equals(str) && !blocklyProject.getXmlId().equals(str2)) {
+                        break;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private String writeConfigFile(String str, String str2, String str3, String str4) {
+        String str5 = this.jimuRobot.getBlocklyProject("blockly") + this.jimuRobot.getModelId() + ".config";
+        BlocklyProject blocklyProject = null;
+        String b = FileHelper.b(str5, (String) null);
+        boolean isEmpty = TextUtils.isEmpty(b);
+        ArrayList arrayList = (ArrayList) JsonHelper.a(b, new TypeToken<List<BlocklyProject>>() { // from class: com.ubt.jimu.blockly.command.JimuBlocklyCommand.4
+        }.getType());
+        if (arrayList == null) {
+            arrayList = new ArrayList();
+        }
+        if (TextUtils.isEmpty(str3)) {
+            str3 = System.currentTimeMillis() + "";
+            File file = new File(this.jimuRobot.getBlocklyProject("blockly"));
+            if (!file.exists()) {
+                file.mkdirs();
+            }
+            BlocklyProject blocklyProject2 = new BlocklyProject();
+            blocklyProject2.setXmlId(str3);
+            blocklyProject2.setXmlName(str);
+            blocklyProject2.setBlocklyVersion(str4);
+            blocklyProject2.setIsDefault(false);
+            arrayList.add(0, blocklyProject2);
+            this.projects.add(0, blocklyProject2);
+        } else {
+            Iterator it = arrayList.iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                }
+                BlocklyProject blocklyProject3 = (BlocklyProject) it.next();
+                if (blocklyProject3.getXmlId().equals(str3)) {
+                    blocklyProject3.setXmlName(str);
+                    blocklyProject = blocklyProject3;
+                    break;
+                }
+            }
+            if (blocklyProject != null) {
+                arrayList.remove(blocklyProject);
+                arrayList.add(0, blocklyProject);
+            }
+        }
+        FileHelper.a(str5, JsonHelper.a(arrayList), "utf-8");
+        if (isEmpty) {
+            try {
+                if (!TextUtils.isEmpty(this.jimuRobot.getModelType())) {
+                    Integer.parseInt(this.jimuRobot.getModelType());
+                }
+            } catch (NumberFormatException e) {
+                e.printStackTrace();
+                Log.e(this.tag, "保存文件：" + e.getMessage());
+            }
+        }
+        return str3;
+    }
+
+    public void bleState() {
+        UnityActivity.communityWithUnity(this.context, BLE_STATE, "");
+    }
+
+    public void closeWindow() {
+        UnityActivity unityActivity;
+        UnityActivity.communityWithUnity(this.context, EXIT_LOGIC_VIEW, "");
+        if (8194 == this.context.getBlocklyType()) {
+            JimuCourse jimuCourse = Cache.getInstance().getJimuCourse();
+            Robot robot = Cache.getInstance().getRobot();
+            if (robot != null && jimuCourse != null && (unityActivity = this.context) != null) {
+                JimuTaskListActivity.start(unityActivity, Cache.getInstance().getPackageId(), robot.getModelId(), jimuCourse.getId());
+            }
+        } else if (8193 == this.context.getBlocklyType()) {
+            LogUtils.c("返回首页");
+            ARouter.b().a("/page/main").t();
+        } else if (8197 == this.context.getBlocklyType()) {
+            CourseListActivity.start(this.context, "AstroBot");
+        } else if (8195 == this.context.getBlocklyType()) {
+            DiyFanActivity.start(this.context, DiyFanActivity.uuid);
+        } else if (8196 == this.context.getBlocklyType() || 8192 == this.context.getBlocklyType()) {
+            SPUtils.b(String.format(DiyBrowseActivity.DIYSTEP, this.context.getModelID()), -2);
+            ARouter.b().a("/diy/detail").t();
+        } else {
+            ARouter.b().a("/page/main").t();
+        }
+        stopSensorTimer("");
+    }
+
+    public void confirm(String str) {
+        String[] split;
+        FileHelper.a(Utils.baseUrl + "status.txt", "", (String) null);
+        if (TextUtils.isEmpty(str) || (split = str.split("\\|")) == null || split.length < 2) {
+            return;
+        }
+        try {
+            Utils.setJSResult(this.webView, "continueSteps", URLEncoder.encode(new JSONObject(split[1]).optString("branchId"), "utf-8"), "1");
+        } catch (JSONException e) {
+            e.printStackTrace();
+        } catch (Exception e2) {
+            e2.printStackTrace();
+        }
+    }
+
+    public void connectedBLE() {
+        UnityActivity.communityWithUnity(this.context, CONNECT_BLE, "");
+    }
+
+    public void deleteXml(String str, String str2) {
+        boolean z;
+        ALog.a(this.tag).d("deleteXml");
+        Iterator<BlocklyProject> it = this.projects.iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                z = false;
+                break;
+            }
+            BlocklyProject next = it.next();
+            if (next.getXmlId().equals(str)) {
+                z = next.getIsDefault();
+                break;
+            }
+        }
+        JavaResultBean<?> javaResultBean = new JavaResultBean<>();
+        if (z) {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            javaResultBean.retMsg = "can not delete sample project.";
+        } else {
+            File file = new File(this.jimuRobot.getBlocklyProject("blockly") + str + ".xml");
+            if (file.exists()) {
+                file.delete();
+                javaResultBean.retCode = "0000";
+            } else {
+                javaResultBean.retCode = "0000";
+                javaResultBean.retMsg = "file not exit";
+            }
+            String str3 = this.jimuRobot.getBlocklyProject("blockly") + this.jimuRobot.getModelId() + ".config";
+            ArrayList arrayList = (ArrayList) JsonHelper.a(FileHelper.b(str3, (String) null), new TypeToken<List<BlocklyProject>>() { // from class: com.ubt.jimu.blockly.command.JimuBlocklyCommand.5
+            }.getType());
+            if (arrayList == null) {
+                arrayList = new ArrayList();
+            }
+            Iterator it2 = arrayList.iterator();
+            while (true) {
+                if (!it2.hasNext()) {
+                    break;
+                }
+                BlocklyProject blocklyProject = (BlocklyProject) it2.next();
+                if (blocklyProject.getXmlId().equals(str)) {
+                    arrayList.remove(blocklyProject);
+                    break;
+                }
+            }
+            FileHelper.a(str3, JsonHelper.a(arrayList), "utf-8");
+        }
+        setJSResult(javaResultBean, str2, false);
+    }
+
+    public JimuRobot getJimuRobot() {
+        return this.jimuRobot;
+    }
+
+    public int getModuleType() {
+        return this.moduleType;
+    }
+
+    public String getQueryCallback() {
+        return this.queryCallback;
+    }
+
+    public String getQueryUrl() {
+        return this.queryUrl;
+    }
+
+    public void heartBeat(String str) {
+        UnityActivity.communityWithUnity(this.context, SET_SEND_XT_STATE, str);
+    }
+
+    public void notifyBLEState(String str) {
+        EventBus.b().b(new BlocklyEvent(1006, str));
+        setJSResult(JimuUnityCommand.BLE_CONNECT_CALLBACK, str, true);
+    }
+
+    public void queryInfrared(String str, String str2) {
+        unityComm(str);
+    }
+
+    /* JADX WARN: Type inference failed for: r1v4, types: [T, com.ubt.jimu.blockly.command.result.XmlListBean] */
+    public void readXml(String str, String str2) {
+        BlocklyProject blocklyProject;
+        String str3;
+        ALog.a(this.tag).d("readXml");
+        Iterator<BlocklyProject> it = this.projects.iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                blocklyProject = null;
+                break;
+            } else {
+                blocklyProject = it.next();
+                if (blocklyProject.getXmlId().equals(str)) {
+                    break;
+                }
+            }
+        }
+        JavaResultBean<?> javaResultBean = new JavaResultBean<>();
+        if (blocklyProject != null) {
+            if (blocklyProject.getIsDefault()) {
+                str3 = this.jimuRobot.getSamplePath() + str + ".xml";
+            } else {
+                str3 = this.jimuRobot.getBlocklyProject("blockly") + str + ".xml";
+            }
+            javaResultBean.retCode = "0000";
+        } else {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+            javaResultBean.retMsg = "xmlId not in projects";
+            str3 = "";
+        }
+        javaResultBean.result = new XmlListBean(str3);
+        setJSResult(javaResultBean, str2, true);
+    }
+
+    /* JADX WARN: Type inference failed for: r4v3, types: [T, com.ubt.jimu.blockly.command.result.SaveBean] */
+    public void saveXml(String str, String str2, String str3, String str4, String str5) {
+        ALog.a(this.tag).d("saveXml");
+        if (TextUtils.isEmpty(str3)) {
+            isNameExist(str, str3, str5);
+        }
+        String writeConfigFile = writeConfigFile(str, str2, str3, str4);
+        JavaResultBean<?> javaResultBean = new JavaResultBean<>();
+        if (FileHelper.a(this.jimuRobot.getBlocklyProject("blockly") + writeConfigFile + ".xml", str2, (String) null)) {
+            javaResultBean.retCode = "0000";
+        } else {
+            javaResultBean.retCode = JavaResultBean.RESULT_FAILED;
+        }
+        ?? saveBean = new SaveBean();
+        saveBean.xmlId = writeConfigFile;
+        javaResultBean.result = saveBean;
+        setJSResult(javaResultBean, str5, true);
+        Iterator<BlocklyProject> it = this.projects.iterator();
+        while (it.hasNext()) {
+            BlocklyProject next = it.next();
+            if (!TextUtils.isEmpty(next.getXmlId())) {
+                next.getXmlId().equals(writeConfigFile);
+            }
+        }
+        Integer.parseInt(this.jimuRobot.getModelType());
+    }
+
+    public void servoSet(String str) {
+        try {
+            FileHelper.a(Utils.baseUrl + "status.txt", "", (String) null);
+            Utils.setJSResult(this.webView, "continueSteps", URLEncoder.encode(str, "utf-8"), "1");
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+            Log.e(this.tag, e.getMessage());
+        }
+    }
+
+    protected void setJSResult(String str, String str2, boolean z) {
+        if (z) {
+            try {
+                str2 = URLEncoder.encode(str2, "utf-8");
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+                Log.e(this.tag, e.getMessage());
+                return;
+            }
+        }
+        final String str3 = "javascript:" + str + "('" + str2 + "')";
+        this.webView.post(new Runnable() { // from class: com.ubt.jimu.blockly.command.JimuBlocklyCommand.1
+            @Override // java.lang.Runnable
+            public void run() {
+                JimuBlocklyCommand.this.webView.loadUrl(str3);
+            }
+        });
+    }
+
+    public void setJimuRobot(JimuRobot jimuRobot) {
+    }
+
+    public void setModuleType(int i) {
+        this.moduleType = i;
+    }
+
+    public void setServoMode() {
+        DiyDBModel queryForUUid;
+        if (!"1".equals(this.jimuRobot.getModelType()) || (queryForUUid = DiyHelper.getInstance().queryForUUid(this.jimuRobot.getModelId())) == null) {
+            return;
+        }
+        this.context.setIsBack(true);
+        Postcard a = ARouter.b().a("/controller/servosettings");
+        a.a("isFromUnity", true);
+        a.a("robotLite", queryForUUid.getRobotLite());
+        a.a(this.context, 107);
+    }
+
+    public void startSensorTimer(String str, String str2) {
+        ALog.a(this.tag).d("startSensorTimer");
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        this.queryUrl = str;
+        this.queryCallback = str2;
+        String str3 = "jimu://queryAllSensor";
+        String[] split = str.split("\\|");
+        if (split != null && split.length >= 1) {
+            str3 = ("jimu://queryAllSensor|") + split[1];
+        }
+        if (split != null && split.length >= 2) {
+            str3 = str3 + "|" + str2;
+        }
+        stopSensorTimer("");
+        this.timer = new Timer();
+        this.infraredTask = new InfraredTimerTask(str3);
+        this.timer.schedule(this.infraredTask, 50L, 200L);
+    }
+
+    public void stopSensorTimer(String str) {
+        ALog.a(this.tag).d("stopSensorTimer");
+        TimerTask timerTask = this.infraredTask;
+        if (timerTask != null) {
+            timerTask.cancel();
+            this.infraredTask = null;
+        }
+        Timer timer = this.timer;
+        if (timer != null) {
+            timer.cancel();
+            this.timer.purge();
+            this.timer = null;
+        }
+    }
+
+    public void unityComm(String str) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("funcName", LOGIC_CMD);
+            jSONObject.put("arg", URLDecoder.decode(str, "UTF-8"));
+            UnityActivity.communityWithUnity(this.context, jSONObject.toString());
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        } catch (JSONException e2) {
+            e2.printStackTrace();
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r0v10, types: [T, com.ubt.jimu.blockly.command.result.XmlListBean] */
+    /* JADX WARN: Type inference failed for: r0v8, types: [T, com.ubt.jimu.blockly.command.result.XmlListBean] */
+    public void xmlList(String str) {
+        ALog.a(this.tag).d("xmlList");
+        this.projects.clear();
+        File file = new File(this.jimuRobot.getBlocklyProject("blockly") + this.jimuRobot.getModelId() + ".config");
+        File file2 = new File(this.jimuRobot.getSamplePath() + this.jimuRobot.getModelId() + ".config");
+        JavaResultBean<?> javaResultBean = new JavaResultBean<>();
+        javaResultBean.retCode = "0000";
+        if (file.exists() || file2.exists()) {
+            String b = FileHelper.b(file.getAbsolutePath(), (String) null);
+            String b2 = FileHelper.b(file2.getAbsolutePath(), (String) null);
+            Type type = new TypeToken<List<BlocklyProject>>() { // from class: com.ubt.jimu.blockly.command.JimuBlocklyCommand.6
+            }.getType();
+            ArrayList arrayList = (ArrayList) JsonHelper.a(b, type);
+            ArrayList arrayList2 = (ArrayList) JsonHelper.a(b2, type);
+            if (arrayList2 != null) {
+                this.projects.addAll(arrayList2);
+            }
+            if (arrayList != null) {
+                this.projects.addAll(arrayList);
+            }
+            javaResultBean.result = new XmlListBean(this.projects);
+        } else {
+            javaResultBean.result = new XmlListBean(new ArrayList());
+        }
+        setJSResult(javaResultBean, str, false);
+    }
+
+    private void setJSResult(JavaResultBean<?> javaResultBean, String str, boolean z) {
+        String a = JsonHelper.a(javaResultBean);
+        if (z) {
+            try {
+                a = URLEncoder.encode(a, "utf-8");
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+                return;
+            }
+        }
+        final String str2 = "javascript:" + str + "('" + a + "')";
+        this.webView.post(new Runnable() { // from class: com.ubt.jimu.blockly.command.JimuBlocklyCommand.2
+            @Override // java.lang.Runnable
+            public void run() {
+                JimuBlocklyCommand.this.webView.loadUrl(str2);
+            }
+        });
+    }
+}

sources/com/ubt/jimu/blockly/command/JimuCourseCommand.java

@@ -0,0 +1,325 @@
+package com.ubt.jimu.blockly.command;
+
+import com.ubt.jimu.JimuApplication;
+import com.ubt.jimu.R;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.db.course.JimuCourseMissionDbHandler;
+import com.ubt.jimu.base.entities.Robot;
+import com.ubt.jimu.base.http.ApiObserver;
+import com.ubt.jimu.base.http.ApiResponse;
+import com.ubt.jimu.course.repository.CourseResult;
+import com.ubt.jimu.course.repository.JimuCourse;
+import com.ubt.jimu.course.repository.JimuCourseMission;
+import com.ubt.jimu.course.repository.JimuCourseMissionRepository;
+import com.ubt.jimu.course.repository.JimuCourseTask;
+import com.ubt.jimu.course.repository.JimuModule;
+import com.ubt.jimu.course.repository.UpdateMission;
+import com.ubt.jimu.course.view.JimuTaskListActivity;
+import com.ubt.jimu.unity.bluetooth.UnityActivity;
+import com.ubt.jimu.utils.DeviceUtils;
+import com.ubt.jimu.utils.JsonHelper;
+import com.ubt.jimu.widgets.LoadingView;
+import com.ubtech.utils.XLog;
+import com.ubtech.view.widget.ToastView;
+import com.ubtrobot.log.ALog;
+import io.reactivex.Observable;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import java.net.URLEncoder;
+import java.util.Iterator;
+import java.util.List;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public class JimuCourseCommand {
+    private final String TAG = JimuCourseCommand.class.getSimpleName();
+    private CompositeDisposable disposables = new CompositeDisposable();
+    private boolean loading = false;
+    private UnityActivity unityActivity;
+
+    public JimuCourseCommand(UnityActivity unityActivity) {
+        this.unityActivity = unityActivity;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void backFromCourse() {
+        backFromCourse(false);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public boolean isLastMission(JimuCourseMission jimuCourseMission) {
+        List<JimuCourseMission> missions;
+        if (jimuCourseMission == null) {
+            return false;
+        }
+        List<JimuCourseTask> courseTaskList = Cache.getInstance().getCourseTaskList();
+        return courseTaskList == null || courseTaskList.size() == 0 || (missions = courseTaskList.get(courseTaskList.size() - 1).getMissions()) == null || missions.size() == 0 || missions.get(missions.size() - 1).getId() == jimuCourseMission.getId();
+    }
+
+    private JimuCourseMission nextCourse() {
+        JimuCourseMission jimuCourseMission;
+        List<JimuCourseTask> courseTaskList = Cache.getInstance().getCourseTaskList();
+        JimuCourseTask jimuCourseTask = Cache.getInstance().getJimuCourseTask();
+        JimuCourseMission courseMission = Cache.getInstance().getCourseMission();
+        int i = 0;
+        for (JimuCourseMission jimuCourseMission2 : jimuCourseTask.getMissions()) {
+            i++;
+            if (jimuCourseMission2 != null && jimuCourseMission2.getId() == courseMission.getId()) {
+                break;
+            }
+        }
+        if (i == jimuCourseTask.getMissions().size()) {
+            Iterator<JimuCourseTask> it = courseTaskList.iterator();
+            int i2 = 0;
+            while (it.hasNext()) {
+                i2++;
+                if (it.next().getId() == jimuCourseTask.getId()) {
+                    break;
+                }
+            }
+            if (i2 == courseTaskList.size()) {
+                return null;
+            }
+            Cache.getInstance().setJimuCourseTask(courseTaskList.get(i2));
+            jimuCourseMission = courseTaskList.get(i2).getMissions().get(0);
+        } else {
+            jimuCourseMission = jimuCourseTask.getMissions().get(i);
+        }
+        Cache.getInstance().setCourseMission(jimuCourseMission);
+        return jimuCourseMission;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onNextCourse() {
+        JimuCourseMission nextCourse = nextCourse();
+        if (nextCourse == null) {
+            backFromCourse();
+            return;
+        }
+        if ("1".equals(nextCourse.getIsLock())) {
+            backFromCourse();
+            return;
+        }
+        List<JimuModule> missingComponents = nextCourse.getMissingComponents(Cache.getInstance().getBoardInfo());
+        if (missingComponents != null && missingComponents.size() > 0) {
+            backFromCourse(true);
+            return;
+        }
+        CourseResult.ResultData resultData = new CourseResult.ResultData();
+        Robot robot = Cache.getInstance().getRobot();
+        if (robot != null) {
+            resultData.modelID = robot.getModelName();
+            resultData.modelId = robot.getModelId();
+            resultData.moveType = robot.getMoveType();
+        }
+        JimuCourse jimuCourse = Cache.getInstance().getJimuCourse();
+        if (jimuCourse != null) {
+            resultData.level = jimuCourse.getFolderName();
+        }
+        JimuCourseTask jimuCourseTask = Cache.getInstance().getJimuCourseTask();
+        if (jimuCourseTask != null) {
+            resultData.stage = jimuCourseTask.getFolderName();
+        }
+        JimuCourseMission courseMission = Cache.getInstance().getCourseMission();
+        if (courseMission != null) {
+            resultData.mission = courseMission.getFolderName();
+            resultData.missionId = courseMission.getId();
+        }
+        String a = JsonHelper.a(new CourseResult(CourseResult.SUCCESS, CourseResult.SUCCESS, resultData));
+        ALog.a(this.TAG).d(a);
+        try {
+            this.unityActivity.getUnityCallback().loadJavascript("loadNextMission", URLEncoder.encode(a, "UTF-8"));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void playAgain(ApiResponse<UpdateMission> apiResponse) {
+        CourseResult.ResultData resultData = new CourseResult.ResultData();
+        Robot robot = Cache.getInstance().getRobot();
+        if (robot != null) {
+            resultData.modelID = robot.getModelName();
+            resultData.modelId = robot.getModelId();
+            resultData.moveType = robot.getMoveType();
+        }
+        JimuCourse jimuCourse = Cache.getInstance().getJimuCourse();
+        if (jimuCourse != null) {
+            resultData.level = jimuCourse.getFolderName();
+        }
+        JimuCourseTask jimuCourseTask = Cache.getInstance().getJimuCourseTask();
+        if (jimuCourseTask != null) {
+            resultData.stage = jimuCourseTask.getFolderName();
+        }
+        JimuCourseMission courseMission = Cache.getInstance().getCourseMission();
+        if (courseMission != null) {
+            resultData.mission = courseMission.getFolderName();
+            resultData.missionId = courseMission.getId();
+        }
+        String a = JsonHelper.a(new CourseResult(CourseResult.SUCCESS, CourseResult.SUCCESS, resultData));
+        ALog.a(this.TAG).d(a);
+        try {
+            this.unityActivity.getUnityCallback().loadJavascript("loadNextMission", URLEncoder.encode(a, "UTF-8"));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void skipCourse(String str, String str2, long j, long j2, long j3) {
+        JimuCourseMissionRepository.getInstance().skipMission(str, j3, str2, j, j2, new ApiObserver<ApiResponse<List<JimuCourseMission>>>(null) { // from class: com.ubt.jimu.blockly.command.JimuCourseCommand.2
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onComplete() {
+            }
+
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onError(Throwable th) {
+            }
+
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onSubscribe(Disposable disposable) {
+                JimuCourseCommand.this.disposables.b(disposable);
+            }
+
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onNext(ApiResponse<List<JimuCourseMission>> apiResponse) {
+                if (apiResponse == null || apiResponse.getModels() == null) {
+                    JimuCourseCommand.this.backFromCourse();
+                } else {
+                    JimuCourseCommand.unLockMission(apiResponse.getModels());
+                    JimuCourseCommand.this.onNextCourse();
+                }
+            }
+        });
+    }
+
+    public static void unLockMission(List<JimuCourseMission> list) {
+        boolean z;
+        if (list == null || list.size() == 0) {
+            return;
+        }
+        for (JimuCourseMission jimuCourseMission : list) {
+            List<JimuCourseTask> courseTaskList = Cache.getInstance().getCourseTaskList();
+            if (courseTaskList != null) {
+                for (int i = 0; i < courseTaskList.size(); i++) {
+                    Iterator<JimuCourseMission> it = courseTaskList.get(i).getMissions().iterator();
+                    while (true) {
+                        if (!it.hasNext()) {
+                            z = false;
+                            break;
+                        }
+                        JimuCourseMission next = it.next();
+                        if (next.getId() == jimuCourseMission.getId()) {
+                            next.setIsLock(jimuCourseMission.getIsLock());
+                            next.setIsSkip(jimuCourseMission.getIsSkip());
+                            next.setStar(jimuCourseMission.getStar());
+                            z = true;
+                            break;
+                        }
+                    }
+                    if (z) {
+                        break;
+                    }
+                }
+            }
+        }
+        JimuCourseMissionDbHandler.updateMissions(list);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void updateCurrentMission(UpdateMission updateMission) {
+        JimuCourseMission courseMission = Cache.getInstance().getCourseMission();
+        if (courseMission == null || updateMission == null) {
+            return;
+        }
+        if (courseMission.getId() == updateMission.getMissionId()) {
+            courseMission.setStar(updateMission.getStar());
+        }
+        JimuCourseMissionDbHandler.updateNextMission(courseMission);
+    }
+
+    private synchronized Observable updateMission(String str, long j, int i, String str2, long j2, long j3, final int i2) {
+        LoadingView loadingView = null;
+        if (this.loading) {
+            return null;
+        }
+        this.loading = true;
+        return JimuCourseMissionRepository.getInstance().updateMission(str, j, i, str2, j2, j3, new ApiObserver<ApiResponse<UpdateMission>>(loadingView) { // from class: com.ubt.jimu.blockly.command.JimuCourseCommand.1
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onComplete() {
+                JimuCourseCommand.this.loading = false;
+            }
+
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onError(Throwable th) {
+                JimuCourseCommand.this.loading = false;
+                if (i2 == 1) {
+                    JimuCourseCommand.this.backFromCourse();
+                }
+                ToastView.a(JimuCourseCommand.this.unityActivity, JimuCourseCommand.this.unityActivity.getString(R.string.network_error), ToastView.Type.ERROR).a();
+            }
+
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onSubscribe(Disposable disposable) {
+                JimuCourseCommand.this.disposables.b(disposable);
+            }
+
+            @Override // com.ubt.jimu.base.http.ApiObserver, io.reactivex.Observer
+            public void onNext(ApiResponse<UpdateMission> apiResponse) {
+                JimuCourseCommand.this.loading = false;
+                if (apiResponse == null || apiResponse.getModels() == null) {
+                    JimuCourseCommand.this.backFromCourse();
+                    return;
+                }
+                UpdateMission models = apiResponse.getModels();
+                JimuCourseCommand.this.updateCurrentMission(models);
+                if ((models.getMissions() == null || models.getMissions().size() == 0) && JimuCourseCommand.this.isLastMission(Cache.getInstance().getCourseMission())) {
+                    JimuCourseCommand.this.backFromCourse();
+                    return;
+                }
+                JimuCourseCommand.unLockMission(models.getMissions());
+                int i3 = i2;
+                if (i3 == 1) {
+                    JimuCourseCommand.this.backFromCourse();
+                    return;
+                }
+                if (i3 == 2) {
+                    JimuCourseCommand.this.playAgain(apiResponse);
+                } else if (i3 != 3) {
+                    XLog.b("Course", "unknow type");
+                } else {
+                    JimuCourseCommand.this.onNextCourse();
+                }
+            }
+        });
+    }
+
+    public void clearRequest() {
+        this.disposables.dispose();
+        this.disposables.a();
+    }
+
+    public void successDeal(String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            int optInt = jSONObject.optInt("type");
+            int optInt2 = jSONObject.optInt("starCount");
+            int optInt3 = jSONObject.optInt("missionId");
+            if (optInt == 4) {
+                skipCourse(Cache.getInstance().getUserId(), DeviceUtils.a(JimuApplication.l()), Cache.getInstance().getPackageId(), Cache.getInstance().getRobot().getModelId(), optInt3);
+            } else {
+                updateMission(Cache.getInstance().getUserId(), optInt3, optInt2, DeviceUtils.a(JimuApplication.l()), Cache.getInstance().getPackageId(), Cache.getInstance().getRobot().getModelId(), optInt);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void backFromCourse(boolean z) {
+        this.unityActivity.closeBlockly();
+        this.unityActivity.setIsBack(true);
+        if (Cache.getInstance().getJimuCourse() == null) {
+            return;
+        }
+        JimuTaskListActivity.start(this.unityActivity, Cache.getInstance().getPackageId(), Cache.getInstance().getRobot().getModelId(), r0.getId(), z);
+    }
+}

sources/com/ubt/jimu/blockly/command/JimuJavascriptInterface.java

@@ -0,0 +1,628 @@
+package com.ubt.jimu.blockly.command;
+
+import android.app.Activity;
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+import android.webkit.JavascriptInterface;
+import android.webkit.WebView;
+import com.ubt.jimu.JimuApplication;
+import com.ubt.jimu.R;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.cache.Constants;
+import com.ubt.jimu.base.db.diy.DiyHelper;
+import com.ubt.jimu.base.db.starcourse.CourseDbHandler;
+import com.ubt.jimu.base.entities.ActionResult;
+import com.ubt.jimu.base.entities.Constant;
+import com.ubt.jimu.base.entities.Course;
+import com.ubt.jimu.base.entities.Robot;
+import com.ubt.jimu.blockly.JimuRobot;
+import com.ubt.jimu.blockly.Utils;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction;
+import com.ubt.jimu.blockly.command.interaction.BlocklyInteraction;
+import com.ubt.jimu.blockly.command.interaction.BlocklyUpload;
+import com.ubt.jimu.blockly.command.result.JavaResultBean;
+import com.ubt.jimu.blockly.feature.audio.AudioParams;
+import com.ubt.jimu.blockly.feature.audio.AudioPlayer;
+import com.ubt.jimu.blockly.feature.audio.AudioRecoder;
+import com.ubt.jimu.blockly.feature.course.BlocklyDomCompare;
+import com.ubt.jimu.blockly.feature.sensor.SensorObservable;
+import com.ubt.jimu.blockly.feature.sensor.SensorObserver;
+import com.ubt.jimu.blockly.view.DialogBlocklyWebView;
+import com.ubt.jimu.course.repository.JimuCourse;
+import com.ubt.jimu.course.repository.JimuCourseMission;
+import com.ubt.jimu.course.repository.JimuCourseTask;
+import com.ubt.jimu.discover.CourseHelper;
+import com.ubt.jimu.discover.IAccomplishEventListener;
+import com.ubt.jimu.discover.view.AccomplishWithoutUserDialog;
+import com.ubt.jimu.diy.DiyRobotDbHandler;
+import com.ubt.jimu.unity.ModelType;
+import com.ubt.jimu.unity.bluetooth.UnityActivity;
+import com.ubt.jimu.utils.DeviceUtils;
+import com.ubt.jimu.utils.JsonHelper;
+import com.ubt.jimu.utils.LogUtils;
+import com.ubt.jimu.utils.SPUtils;
+import com.ubtech.permission.JimuPermissionRequest;
+import com.ubtech.permission.PermissionRequestListener;
+import com.ubtech.utils.FileHelper;
+import com.ubtech.utils.PermissionHelper;
+import com.ubtech.utils.XLog;
+import com.ubtrobot.log.ALog;
+import java.io.File;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public class JimuJavascriptInterface {
+    private Context context;
+    private Course course;
+    private DialogBlocklyWebView dialogBlocklyWebView;
+    private JavaScriptCommand javaScriptCommand;
+    private JimuRobot jimuRobot;
+    private WebView webView;
+    private final String TAG = JimuJavascriptInterface.class.getSimpleName();
+    private final String BLOCKLY_INTERVAL = "continueSteps";
+    private final String SOUND_FILE_MODEL_ID = "0";
+    private int platformType = 1;
+    private AbstractBlocklyInteraction transportAction = new BlocklyInteraction(new BlocklyUpload());
+
+    public JimuJavascriptInterface(WebView webView, Context context, JimuRobot jimuRobot) {
+        this.jimuRobot = jimuRobot;
+        this.webView = webView;
+        this.context = context;
+        this.javaScriptCommand = new JavaScriptCommand(webView, context, jimuRobot, this.transportAction);
+    }
+
+    private String getBlocklyProjectId(String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            if (jSONObject.has("xmlId")) {
+                return jSONObject.getString("xmlId");
+            }
+            return null;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @JavascriptInterface
+    public String DeleteXml(String str) {
+        return JsonHelper.a(this.javaScriptCommand.deleteXml(getBlocklyProjectId(str)));
+    }
+
+    @JavascriptInterface
+    public String EditXml(String str) {
+        BlocklyProject blocklyProject = (BlocklyProject) JsonHelper.a(str, (Class<?>) BlocklyProject.class);
+        if (blocklyProject != null) {
+            return JsonHelper.a(this.javaScriptCommand.editXml(blocklyProject.getXmlName(), blocklyProject.getXmlContent(), blocklyProject.getXmlId(), blocklyProject.getBlocklyVersion(), blocklyProject.getDefaultName()));
+        }
+        JavaResultBean javaResultBean = new JavaResultBean();
+        javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+        javaResultBean.retMsg = "unknow input";
+        return JsonHelper.a(javaResultBean);
+    }
+
+    @JavascriptInterface
+    public String ReadXml(String str) {
+        return JsonHelper.a(this.javaScriptCommand.readXml(getBlocklyProjectId(str)));
+    }
+
+    @JavascriptInterface
+    public String ReadXmlList() {
+        return JsonHelper.a(this.javaScriptCommand.xmlList());
+    }
+
+    @JavascriptInterface
+    public String SaveXml(String str) {
+        BlocklyProject blocklyProject = (BlocklyProject) JsonHelper.a(str, (Class<?>) BlocklyProject.class);
+        if (blocklyProject != null) {
+            return JsonHelper.a(this.javaScriptCommand.saveXml(blocklyProject.getXmlName(), blocklyProject.getXmlContent(), blocklyProject.getBlocklyVersion(), blocklyProject.getDefaultName()));
+        }
+        JavaResultBean javaResultBean = new JavaResultBean();
+        javaResultBean.retCode = JavaResultBean.RESULT_EXCEPTION;
+        javaResultBean.retMsg = "unknow input";
+        return JsonHelper.a(javaResultBean);
+    }
+
+    @JavascriptInterface
+    public String addCustomSound(String str) {
+        return JsonHelper.a(this.javaScriptCommand.addCustomSound(str));
+    }
+
+    @JavascriptInterface
+    public void cancelRecordAudio() {
+        AudioRecoder.getInstance().stopRecod();
+        File parentFile = new File(AudioRecoder.getInstance().getFileName()).getParentFile();
+        if (parentFile == null || !parentFile.exists()) {
+            return;
+        }
+        FileHelper.a(parentFile);
+    }
+
+    @JavascriptInterface
+    public void courseSuccessPopup(String str) {
+        LogUtils.c("courseId:" + str + " " + str);
+        final IAccomplishEventListener iAccomplishEventListener = new IAccomplishEventListener() { // from class: com.ubt.jimu.blockly.command.JimuJavascriptInterface.4
+            @Override // com.ubt.jimu.discover.IAccomplishEventListener
+            public void onPlayAgain(Course course) {
+                JimuJavascriptInterface.this.webView.reload();
+            }
+
+            @Override // com.ubt.jimu.discover.IAccomplishEventListener
+            public void onPlayContinue(Course course) {
+                ((UnityActivity) JimuJavascriptInterface.this.context).setIsBack(true);
+                ((UnityActivity) JimuJavascriptInterface.this.context).closeBlockly();
+            }
+        };
+        final AccomplishWithoutUserDialog a = AccomplishWithoutUserDialog.a(this.course);
+        a.a(iAccomplishEventListener);
+        String userId = Cache.getInstance().getUserId();
+        if (!"local".equals(userId) && !TextUtils.isEmpty(userId)) {
+            if (Course.STATUS_COMPLETED.equals(this.course.getStatus())) {
+                a.show(((Activity) this.context).getFragmentManager(), "course");
+                return;
+            }
+            CourseHelper courseHelper = new CourseHelper(new CourseHelper.IUploadCourseListener() { // from class: com.ubt.jimu.blockly.command.JimuJavascriptInterface.5
+                @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+                public void onFailed() {
+                    JimuJavascriptInterface.this.dialogBlocklyWebView.hideWait();
+                    JimuJavascriptInterface.this.webView.postDelayed(new Runnable() { // from class: com.ubt.jimu.blockly.command.JimuJavascriptInterface.5.1
+                        @Override // java.lang.Runnable
+                        public void run() {
+                            JimuJavascriptInterface.this.dialogBlocklyWebView.commonTips(JimuJavascriptInterface.this.dialogBlocklyWebView.getString(R.string.network_error), 2);
+                        }
+                    }, 500L);
+                }
+
+                @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+                public void onFinished() {
+                    JimuJavascriptInterface.this.dialogBlocklyWebView.hideWait();
+                }
+
+                @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+                public void onStart() {
+                }
+
+                @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+                public void onSuccess(ActionResult actionResult) {
+                    if (actionResult != null && actionResult.getCourse() != null && actionResult.getFlag() == 0) {
+                        a.show(((Activity) JimuJavascriptInterface.this.context).getFragmentManager(), "course");
+                        return;
+                    }
+                    CourseDbHandler.setCourseComplete(JimuJavascriptInterface.this.course);
+                    AccomplishWithoutUserDialog a2 = AccomplishWithoutUserDialog.a(JimuJavascriptInterface.this.course, actionResult);
+                    a2.a(((Activity) JimuJavascriptInterface.this.context).getFragmentManager(), "course", actionResult);
+                    a2.a(iAccomplishEventListener);
+                }
+            });
+            String b = SPUtils.b(Constant.SelectRobot.INTERSTELLAR_ADVENTURE_SELECT_PACKAGE_KEY);
+            long parseLong = Long.parseLong(str);
+            if (Constant.SelectRobot.INTERSTELLAR_ADVENTURE_NEW_PACKAGE_COSMOS.equals(b) || Constant.SelectRobot.INTERSTELLAR_ADVENTURE_NEW_PACKAGE_STEM.equals(b) || Constant.SelectRobot.INTERSTELLAR_ADVENTURE_NEW_PACKAGE_UPGRADED.equals(b)) {
+                parseLong += 24;
+            }
+            courseHelper.a(parseLong);
+            this.dialogBlocklyWebView.showWait();
+            return;
+        }
+        String storyName = this.course.getStoryName();
+        LogUtils.c("storyName:" + storyName + " " + str);
+        if (Constant.SelectRobot.ASTROBOT_MINI.equals(storyName)) {
+            if (!TextUtils.isEmpty(str)) {
+                SPUtils.b(Constant.SelectRobot.LOCAL_USER_COSMOS_FLAG_NEW, Integer.parseInt(str));
+            }
+        } else if (!TextUtils.isEmpty(str)) {
+            SPUtils.b(Constant.SelectRobot.LOCAL_USER_COSMOS_FLAG_OLD, Integer.parseInt(str));
+        }
+        CourseDbHandler.setCourseComplete(this.course);
+        a.show(((Activity) this.context).getFragmentManager(), "course");
+    }
+
+    @JavascriptInterface
+    public String customSoundList() {
+        return JsonHelper.a(this.javaScriptCommand.customSoundList(Cache.getInstance().getUserId()));
+    }
+
+    @JavascriptInterface
+    public String deleteCustomMotion(String str) {
+        return JsonHelper.a(this.javaScriptCommand.deleteCustomMotion(str));
+    }
+
+    @JavascriptInterface
+    public boolean deleteCustomSound(String str) {
+        return this.javaScriptCommand.deleteCustomSound(Cache.getInstance().getUserId(), str);
+    }
+
+    @JavascriptInterface
+    public String getBlocklyProjectDescription(String str) {
+        return FileHelper.b(this.jimuRobot.getSamplePath() + str + ".desc", "");
+    }
+
+    @JavascriptInterface
+    public String getCustomMotion(String str) {
+        return JsonHelper.a(this.javaScriptCommand.getCustomMotion(str));
+    }
+
+    @JavascriptInterface
+    public String getCustomMotionList() {
+        return JsonHelper.a(this.javaScriptCommand.getMotionList());
+    }
+
+    @JavascriptInterface
+    public String getDeviceDirection() {
+        return this.dialogBlocklyWebView.getDirection() == null ? "" : this.dialogBlocklyWebView.getDirection().getValue();
+    }
+
+    @JavascriptInterface
+    public String getInitProgramInfo() {
+        return this.jimuRobot.getProgram() == null ? "" : JsonHelper.a(this.jimuRobot.getProgram());
+    }
+
+    @JavascriptInterface
+    public String getMotionList() {
+        return TextUtils.isEmpty(this.jimuRobot.getMotion()) ? "{}" : this.jimuRobot.getMotion();
+    }
+
+    @JavascriptInterface
+    public String getServoID() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(JimuRobot.ACTIONS);
+        sb.append(this.jimuRobot.getAction());
+        if (!TextUtils.isEmpty(this.jimuRobot.getServo())) {
+            sb.append("&");
+            sb.append(JimuRobot.SERVOS);
+            sb.append(this.jimuRobot.getServo());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getInfraredId())) {
+            sb.append("&");
+            sb.append(JimuRobot.INFRARED_ID);
+            sb.append(this.jimuRobot.getInfraredId());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getTouchId())) {
+            sb.append("&");
+            sb.append(JimuRobot.TOUCH_ID);
+            sb.append(this.jimuRobot.getTouchId());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getGyroscopeId())) {
+            sb.append("&");
+            sb.append(JimuRobot.GYROSCOPE_ID);
+            sb.append(this.jimuRobot.getGyroscopeId());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getCircleServos())) {
+            sb.append("&");
+            sb.append(JimuRobot.CIRCLE_SERVOS);
+            sb.append(this.jimuRobot.getCircleServos());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getLights())) {
+            sb.append("&");
+            sb.append(JimuRobot.LIGHTS);
+            sb.append(this.jimuRobot.getLights());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getColorId())) {
+            sb.append("&colorId=");
+            sb.append(this.jimuRobot.getColorId());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getUnicornId())) {
+            sb.append("&unicornId=");
+            sb.append(this.jimuRobot.getUnicornId());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getMotor())) {
+            sb.append("&motor=");
+            sb.append(this.jimuRobot.getMotor());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getIsLithium())) {
+            sb.append("&isLithium=");
+            sb.append(this.jimuRobot.getIsLithium());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getUltrasonicId())) {
+            sb.append("&ultrasonicId=");
+            sb.append(this.jimuRobot.getUltrasonicId());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getModelType())) {
+            sb.append("&modelType=");
+            sb.append(this.jimuRobot.getModelType());
+        }
+        if (!TextUtils.isEmpty(this.jimuRobot.getModelId())) {
+            sb.append("&modelID=");
+            sb.append(this.jimuRobot.getModelId());
+        }
+        String g = JimuApplication.l().g();
+        sb.append("&");
+        sb.append(JimuRobot.LANGUAGE);
+        sb.append(g);
+        sb.append("&");
+        sb.append(JimuRobot.BLUE_STATE);
+        sb.append(this.jimuRobot.getBlueState());
+        sb.append("&");
+        sb.append(JimuRobot.MODEL_TYPE);
+        sb.append(SPUtils.a(Constant.Black.BLACK_MODEL_TYPE_KEY, 0));
+        sb.append("&platformType=");
+        sb.append(this.platformType);
+        Robot robot = Cache.getInstance().getRobot();
+        String logPath = String.valueOf(ModelType.DEFAULT.getType()).equals(this.jimuRobot.getServerModelType()) ? robot != null ? DiyRobotDbHandler.getLogPath(ModelType.DEFAULT, robot.getModelName()) : "" : DiyHelper.getInstance().queryForUUid(this.jimuRobot.getModelId()) == null ? DiyRobotDbHandler.getLogPath(ModelType.PLAYER_DATA, this.jimuRobot.getModelId()) : DiyHelper.getInstance().queryForUUid(this.jimuRobot.getModelId()).getFilePath();
+        sb.append("&modelLogo=");
+        sb.append(logPath);
+        String userId = Cache.getInstance().getUserId();
+        if ("local".equals(userId)) {
+            userId = DeviceUtils.a(this.context);
+        }
+        sb.append("&");
+        sb.append("userId=");
+        sb.append(userId);
+        sb.append("&");
+        sb.append("edit=");
+        sb.append(((UnityActivity) this.context).code != 1007 ? 1 : 0);
+        if (1 == this.dialogBlocklyWebView.getModuleType()) {
+            JimuCourse jimuCourse = Cache.getInstance().getJimuCourse();
+            JimuCourseTask jimuCourseTask = Cache.getInstance().getJimuCourseTask();
+            JimuCourseMission courseMission = Cache.getInstance().getCourseMission();
+            if (robot != null && jimuCourse != null && jimuCourseTask != null && courseMission != null) {
+                String str = Constants.COURSE_RESOURCE_PATH + jimuCourse.getId();
+                sb.append("&");
+                sb.append("packageId=");
+                sb.append(Cache.getInstance().getPackageId());
+                sb.append("&");
+                sb.append("modelId=");
+                sb.append(robot.getModelId());
+                sb.append("&");
+                sb.append("modelID=");
+                sb.append(robot.getModelName());
+                sb.append("&");
+                sb.append("modelName=");
+                sb.append(robot.getModelDescriptionLangeage());
+                sb.append("&");
+                sb.append("moveType=");
+                sb.append(robot.getMoveType());
+                sb.append("&");
+                sb.append("level=");
+                sb.append(jimuCourse.getFolderName());
+                sb.append("&");
+                sb.append("stage=");
+                sb.append(jimuCourseTask.getFolderName());
+                sb.append("&");
+                sb.append("mission=");
+                sb.append(courseMission.getFolderName());
+                sb.append("&");
+                sb.append("missionId=");
+                sb.append(courseMission.getId());
+                sb.append("&");
+                sb.append("sourcePath=");
+                sb.append(str);
+            }
+        } else {
+            sb.append("&");
+            sb.append(JimuRobot.IS_FIRST);
+            sb.append(this.jimuRobot.firstOpen());
+        }
+        Course course = this.course;
+        if (course != null) {
+            String nameKey = course.getNameKey();
+            String replace = TextUtils.isEmpty(nameKey) ? "" : nameKey.replace("course_", "");
+            sb.append("&");
+            sb.append("courseId=");
+            sb.append(replace);
+            sb.append("&");
+            sb.append("serialName=");
+            sb.append("AstroBot");
+            sb.append("&");
+            sb.append("sourcePath=");
+            sb.append(Utils.getStarCourseDirPath());
+        }
+        String tTSToken = Cache.getInstance().getTTSToken();
+        LogUtils.c("ttsToken:" + tTSToken);
+        if (!TextUtils.isEmpty(tTSToken)) {
+            sb.append("&");
+            sb.append("tok=");
+            sb.append(tTSToken);
+            String valueOf = Cache.getInstance().getLoginUserIntId() > 0 ? String.valueOf(Cache.getInstance().getLoginUserIntId()) : DeviceUtils.a(this.context);
+            sb.append("&");
+            sb.append("cuid=");
+            sb.append(valueOf);
+        }
+        String sb2 = sb.toString();
+        XLog.a("Chrome", sb2);
+        return sb2;
+    }
+
+    @JavascriptInterface
+    public boolean hasRecordAuthority() {
+        if (PermissionHelper.a(this.context, "android.permission.RECORD_AUDIO")) {
+            return PermissionHelper.a(this.context, "android.permission.RECORD_AUDIO");
+        }
+        this.webView.post(new Runnable() { // from class: com.ubt.jimu.blockly.command.JimuJavascriptInterface.2
+            @Override // java.lang.Runnable
+            public void run() {
+                JimuPermissionRequest.a((Activity) JimuJavascriptInterface.this.context, (PermissionRequestListener) null);
+            }
+        });
+        return false;
+    }
+
+    @JavascriptInterface
+    public String helpUrl() {
+        String str = "https://jimu.ubtrobot.com/jimu/help_new/help_new.html?language=" + JimuApplication.l().g();
+        this.javaScriptCommand.helpUrl();
+        return str;
+    }
+
+    @JavascriptInterface
+    public boolean isTablet() {
+        return true;
+    }
+
+    @JavascriptInterface
+    public void playAudio(String str) {
+        this.javaScriptCommand.playAudio(str);
+    }
+
+    public void playCurrentRecordAudio() {
+        AudioPlayer.getInstance().play(AudioRecoder.getInstance().getFileName());
+    }
+
+    @JavascriptInterface
+    public void recordContentViewEnd(String str) {
+        this.javaScriptCommand.recordContentViewEnd(str);
+    }
+
+    @JavascriptInterface
+    public void recordContentViewStart(String str) {
+        this.javaScriptCommand.recordContentViewStart(str);
+    }
+
+    @JavascriptInterface
+    public void recordEvent(String str, String str2) {
+        this.javaScriptCommand.recordEvent(str, str2);
+    }
+
+    @JavascriptInterface
+    public void registerSensorObserver(String str) {
+        SensorObservable.getInstance().addObserver((SensorObserver) JsonHelper.a(str, (Class<?>) SensorObserver.class));
+    }
+
+    @JavascriptInterface
+    public void registerSensorObservers(String str) {
+        try {
+            JSONArray jSONArray = new JSONArray(str);
+            for (int i = 0; i < jSONArray.length(); i++) {
+                JSONObject jSONObject = jSONArray.getJSONObject(i);
+                if (jSONObject != null) {
+                    SensorObservable.getInstance().addObserver((SensorObserver) JsonHelper.a(jSONObject.toString(), (Class<?>) SensorObserver.class));
+                }
+            }
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @JavascriptInterface
+    public String renameAudio(String str) {
+        return JsonHelper.a(this.javaScriptCommand.renameAudio(str));
+    }
+
+    @JavascriptInterface
+    public String renameMotion(String str) {
+        return JsonHelper.a(this.javaScriptCommand.renameMotion(str));
+    }
+
+    @JavascriptInterface
+    public String renameProject(String str) {
+        return JsonHelper.a(this.javaScriptCommand.renameProject(str));
+    }
+
+    @JavascriptInterface
+    public void resignActiveBranch() {
+        ALog.a(this.TAG).d("重新激活分支");
+        SensorObservable.getInstance().reActiveObserver();
+    }
+
+    @JavascriptInterface
+    public String saveCustomMotion(String str) {
+        return JsonHelper.a(this.javaScriptCommand.saveCustomMotion(str));
+    }
+
+    public void setCourse(Course course) {
+        this.course = course;
+    }
+
+    public void setDialogBlocklyWebView(DialogBlocklyWebView dialogBlocklyWebView) {
+        this.dialogBlocklyWebView = dialogBlocklyWebView;
+    }
+
+    protected void setJSResult(String str, String... strArr) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("javascript:");
+        sb.append(str);
+        sb.append("(");
+        if (strArr != null && strArr.length > 0) {
+            for (int i = 0; i < strArr.length; i++) {
+                sb.append("'");
+                sb.append(strArr[i]);
+                sb.append("'");
+                if (i < strArr.length - 1) {
+                    sb.append(",");
+                }
+            }
+        }
+        sb.append(")");
+        final String sb2 = sb.toString();
+        Log.i(this.TAG, sb2);
+        this.webView.post(new Runnable() { // from class: com.ubt.jimu.blockly.command.JimuJavascriptInterface.1
+            @Override // java.lang.Runnable
+            public void run() {
+                JimuJavascriptInterface.this.webView.loadUrl(sb2);
+            }
+        });
+    }
+
+    public void setJimuRobot(JimuRobot jimuRobot) {
+    }
+
+    @JavascriptInterface
+    public boolean startRecordAudio() {
+        if (!PermissionHelper.a(this.context, "android.permission.RECORD_AUDIO")) {
+            this.webView.post(new Runnable() { // from class: com.ubt.jimu.blockly.command.JimuJavascriptInterface.3
+                @Override // java.lang.Runnable
+                public void run() {
+                    JimuPermissionRequest.a((Activity) JimuJavascriptInterface.this.context, (PermissionRequestListener) null);
+                }
+            });
+            return false;
+        }
+        String formatId = Utils.getFormatId(System.currentTimeMillis());
+        try {
+            return AudioRecoder.getInstance().startRecord((this.jimuRobot.getCustomSounds() + formatId) + File.separator + formatId + AudioParams.AAC);
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.e(this.TAG, "录音失败");
+            return false;
+        }
+    }
+
+    @JavascriptInterface
+    public void stopPlayAudio() {
+        AudioPlayer.getInstance().stop();
+    }
+
+    @JavascriptInterface
+    public void stopRecordAudio() {
+        AudioRecoder.getInstance().stopRecod();
+    }
+
+    @JavascriptInterface
+    public void successDeal(String str) {
+        this.javaScriptCommand.successDeal(str);
+    }
+
+    @JavascriptInterface
+    public void unRegisterAllSensorObserver() {
+        ALog.a(this.TAG).d("删除所有的观察者");
+        SensorObservable.getInstance().deleteObservers();
+        SensorObservable.getInstance().clearActiveObserver();
+    }
+
+    @JavascriptInterface
+    public void unRegisterSensorObserver(String str) {
+        ALog.a(this.TAG).d("删除观察者:" + str);
+        SensorObservable.getInstance().deleteObserver((SensorObserver) JsonHelper.a(str, (Class<?>) SensorObserver.class));
+    }
+
+    @JavascriptInterface
+    public String verifyCourse(String str, String str2) {
+        String check = new BlocklyDomCompare().check(str, str2);
+        Log.i(this.TAG, check);
+        return check;
+    }
+
+    @JavascriptInterface
+    @Deprecated
+    public String versionSwitch(String str) {
+        return "";
+    }
+
+    @JavascriptInterface
+    public void recordEvent(String str) {
+        this.javaScriptCommand.recordEvent(str);
+    }
+}

sources/com/ubt/jimu/blockly/command/JimuUnityCommand.java

@@ -0,0 +1,105 @@
+package com.ubt.jimu.blockly.command;
+
+import android.util.Log;
+import android.webkit.WebView;
+import com.ubt.jimu.blockly.Utils;
+import com.ubt.jimu.blockly.feature.audio.AudioRecoder;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+
+/* loaded from: classes.dex */
+public class JimuUnityCommand {
+    public static final String BLE_CONNECT_CALLBACK = "blueConnectCallBack";
+    public static final String CHARGE_PROTECTION = "chargeProtection";
+    public static final String NOTIFY_KEYBOARD_HIDDEN = "notifyKeyboardHidden";
+    public static final String REFRESH_ALL_SERVO = "refreshAllServo";
+    public static final String SHOW_EXCEPTION = "showException";
+    public static final String STOP_RECORD_ON_PAUSE = "stopRecordAudioCallBack";
+    public static final String WAKEUP_BLOCKLY = "continueSteps";
+    public static final String tag = "JimuUnityCommand";
+    private WebView webView;
+
+    public JimuUnityCommand(WebView webView) {
+        this.webView = webView;
+    }
+
+    public void blueConnectCallBack(String str) {
+        try {
+            Utils.setJSResult(this.webView, BLE_CONNECT_CALLBACK, URLEncoder.encode(str, "utf-8"));
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+            Log.e(tag, e.getMessage());
+        }
+    }
+
+    public void chargeProtected(String str) {
+        setJSResult2(CHARGE_PROTECTION, str);
+    }
+
+    public void jsExceptionWaitResult() {
+    }
+
+    public void jsShowException(String str) {
+        Utils.setJSResult(this.webView, SHOW_EXCEPTION, str);
+        if (AudioRecoder.recoding) {
+            Utils.setJSResult(this.webView, STOP_RECORD_ON_PAUSE, new String[0]);
+        }
+    }
+
+    public void notifyKeyboardHidden(String str) {
+        Utils.setJSResult(this.webView, NOTIFY_KEYBOARD_HIDDEN, str);
+    }
+
+    public void refreshAllServo(String str) {
+        try {
+            Utils.setJSResult(this.webView, "refreshAllServo", URLEncoder.encode(str, "utf-8"));
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected void setJSResult2(String str, String... strArr) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("javascript:");
+        sb.append(str);
+        sb.append("(");
+        if (strArr != null && strArr.length > 0) {
+            for (int i = 0; i < strArr.length; i++) {
+                sb.append("\"");
+                sb.append(strArr[i]);
+                sb.append("\"");
+                if (i < strArr.length - 1) {
+                    sb.append(",");
+                }
+            }
+        }
+        sb.append(")");
+        final String sb2 = sb.toString();
+        Log.i(tag, sb2);
+        this.webView.post(new Runnable() { // from class: com.ubt.jimu.blockly.command.JimuUnityCommand.1
+            @Override // java.lang.Runnable
+            public void run() {
+                JimuUnityCommand.this.webView.loadUrl(sb2);
+            }
+        });
+    }
+
+    public void showInfraredRef(String str, String str2) {
+        try {
+            Utils.setJSResult(this.webView, str2, URLEncoder.encode(str, "utf-8"));
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+            Log.e(tag, e.getMessage());
+        }
+    }
+
+    public void wakeupBlockly(String str, int i, String str2, String str3) {
+        try {
+            String encode = URLEncoder.encode(str, "utf-8");
+            Utils.setJSResult(this.webView, "continueSteps", encode, i + "", str2, str3);
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+            Log.e(tag, e.getMessage());
+        }
+    }
+}

sources/com/ubt/jimu/blockly/command/UnityCommandController.java

@@ -0,0 +1,534 @@
+package com.ubt.jimu.blockly.command;
+
+import android.R;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.text.TextUtils;
+import android.util.Log;
+import com.ubt.jimu.JimuApplication;
+import com.ubt.jimu.base.cache.SharePreferenceHelper;
+import com.ubt.jimu.base.entities.Course;
+import com.ubt.jimu.blockly.Utils;
+import com.ubt.jimu.blockly.command.result.QueryResult;
+import com.ubt.jimu.blockly.exception.BlocklyEvent;
+import com.ubt.jimu.blockly.exception.JimuRobotMessage;
+import com.ubt.jimu.blockly.feature.blockly.JimuSensor;
+import com.ubt.jimu.blockly.feature.sensor.DeviceDirection;
+import com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact;
+import com.ubt.jimu.blockly.feature.sensor.ManagerHelper;
+import com.ubt.jimu.blockly.feature.sensor.SensorObservable;
+import com.ubt.jimu.blockly.view.DialogBlocklyWebView;
+import com.ubt.jimu.course.repository.CourseResult;
+import com.ubt.jimu.unity.ModelType;
+import com.ubt.jimu.unity.bluetooth.ConnectionStatus;
+import com.ubt.jimu.unity.bluetooth.UnityActivity;
+import com.ubt.jimu.utils.ExternalOverFroyoUtils;
+import com.ubt.jimu.utils.JsonHelper;
+import com.ubtech.utils.StringUtils;
+import com.ubtech.utils.XLog;
+import com.ubtrobot.jimu.bluetooth.proxy.BluetoothProxy;
+import java.io.File;
+import java.util.List;
+import org.greenrobot.eventbus.EventBus;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public class UnityCommandController {
+    public static final String CONNECTION_BLE_CALLBACK = "ConnectBLECallBack";
+    public static final String DELETE_PROGRAM = "deleteProgram";
+    public static final String FRAGMENT_TAG_BLOCKLY = "tag_blockly";
+    public static final String OPEN_LOGIC_PROGRAMMING = "OpenLogicProgramming";
+    public static final String REFRESH_ALL_SERVO = "refreshAllServo";
+    public static final String RESULT_FAILED = "1|failure";
+    public static final String RESULT_SUCCESS = "1|success";
+    public static final String SHOW_EXCEPTION_CALLBACK = "JsShowExceptionCallback";
+    private UnityActivity activity;
+    AudioManager am;
+    private DialogBlocklyWebView blockly;
+    private int code;
+    private DirectionSensorEventListerCompact compactListener;
+    private String connenctDevice;
+    private Course course;
+    boolean hasMagnetic;
+    private ManagerHelper managerHelper;
+    private int moduleType;
+    private long serverModelId;
+    private final String TAG = UnityCommandController.class.getSimpleName();
+    private final String BLE_DISCONNECT_NOTITY = "BLEDisconnectNotity";
+    private final String JS_SHOW_EXCEPTION = "JsShowException";
+    private final String COMMON_TIPS = "CommonTips";
+    private final String CHARGE_PROTECTED = "ChargeProtected";
+    private final String LOGIC_CMD_RESULT = "LogicCMDResult";
+    private final String BLUE_SETTING = "OpenAndroidBLESetting";
+    private final String CANCEL_WAIT_DIALOG = "JsExceptionWaitResult";
+    private final String SUCCESS = CourseResult.SUCCESS;
+    private boolean open = false;
+    private boolean isBlocklyRunning = false;
+
+    public UnityCommandController(UnityActivity unityActivity) {
+        this.activity = unityActivity;
+        this.managerHelper = new ManagerHelper(this.activity);
+        this.am = (AudioManager) unityActivity.getSystemService("audio");
+    }
+
+    private void SetSendXTState(int i) {
+        if (this.connenctDevice != null) {
+            BluetoothProxy.c().a(this.connenctDevice, i == 1);
+        }
+    }
+
+    private void bleState(String str) {
+    }
+
+    private void blocklyResult(String str, int i, String str2, String str3) {
+        DialogBlocklyWebView dialogBlocklyWebView = this.blockly;
+        if (dialogBlocklyWebView != null) {
+            dialogBlocklyWebView.wakeupBlockly(str, i, str2, str3);
+        }
+    }
+
+    private void chargeProtected(String str) {
+        DialogBlocklyWebView dialogBlocklyWebView = this.blockly;
+        if (dialogBlocklyWebView != null) {
+            dialogBlocklyWebView.chargeProtected(str);
+        }
+    }
+
+    private void commonTips(String str) {
+        JimuRobotMessage jimuRobotMessage = (JimuRobotMessage) JsonHelper.a(str, (Class<?>) JimuRobotMessage.class);
+        if (this.blockly == null) {
+            this.activity.showToast(jimuRobotMessage);
+        } else {
+            EventBus.b().b(new BlocklyEvent(1001, jimuRobotMessage));
+        }
+    }
+
+    private void deleteProgram(String str) {
+        XLog.a(this.TAG, "删除案例");
+    }
+
+    private String formatResult(String str) {
+        QueryResult queryResult = (QueryResult) JsonHelper.a(str, (Class<?>) QueryResult.class);
+        if (queryResult == null) {
+            return null;
+        }
+        List<JimuSensor> infrared = queryResult.getInfrared();
+        if (infrared != null) {
+            for (JimuSensor jimuSensor : infrared) {
+                jimuSensor.setResult(JimuSensor.convertInfraredValueToLevel2(jimuSensor.getResult()));
+            }
+        }
+        String a = JsonHelper.a(queryResult);
+        SensorObservable.getInstance().setData(queryResult);
+        return a;
+    }
+
+    private void initCompactSensorEventListener() {
+        if (this.compactListener == null) {
+            this.compactListener = new DirectionSensorEventListerCompact(new DirectionSensorEventListerCompact.ActionListener() { // from class: com.ubt.jimu.blockly.command.UnityCommandController.3
+                @Override // com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact.ActionListener
+                public void onBottomUp() {
+                    if (UnityCommandController.this.blockly != null) {
+                        UnityCommandController.this.blockly.refreshDirection(DeviceDirection.DOWN);
+                    }
+                }
+
+                @Override // com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact.ActionListener
+                public void onChange(float[] fArr) {
+                }
+
+                @Override // com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact.ActionListener
+                public void onLeftUp() {
+                    if (UnityCommandController.this.blockly != null) {
+                        UnityCommandController.this.blockly.refreshDirection(DeviceDirection.LEFT);
+                    }
+                }
+
+                @Override // com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact.ActionListener
+                public void onNormal() {
+                    if (UnityCommandController.this.blockly != null) {
+                        UnityCommandController.this.blockly.refreshDirection(DeviceDirection.NONE);
+                    }
+                }
+
+                @Override // com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact.ActionListener
+                public void onRightUp() {
+                    if (UnityCommandController.this.blockly != null) {
+                        UnityCommandController.this.blockly.refreshDirection(DeviceDirection.RIGHT);
+                    }
+                }
+
+                @Override // com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact.ActionListener
+                public void onShake(long j, float[] fArr) {
+                    if (UnityCommandController.this.blockly != null) {
+                        UnityCommandController.this.blockly.refreshDirection(DeviceDirection.SWING);
+                    }
+                }
+
+                @Override // com.ubt.jimu.blockly.feature.sensor.DirectionSensorEventListerCompact.ActionListener
+                public void onTopUp() {
+                    if (UnityCommandController.this.blockly != null) {
+                        UnityCommandController.this.blockly.refreshDirection(DeviceDirection.UP);
+                    }
+                }
+            });
+        }
+        this.managerHelper.registerListener(this.compactListener, 1, 3);
+    }
+
+    private void notifyBleState(String str) {
+        DialogBlocklyWebView dialogBlocklyWebView = this.blockly;
+        if (dialogBlocklyWebView != null) {
+            dialogBlocklyWebView.blueConnectCallBack(str);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void onBlocklyResult(String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            String string = jSONObject.getString(UnityActivity.RESULT);
+            String replace = jSONObject.getString("cmd").replace(BlocklyCommandController.BASE_REQUEST_URL, "");
+            String[] split = replace.split("\\|");
+            int i = 1;
+            i = 1;
+            JSONObject jSONObject2 = new JSONObject(split[split.length - 1]);
+            if (BlocklyCommandController.QUERY.equals(split[0])) {
+                JSONObject jSONObject3 = new JSONObject(string);
+                String string2 = jSONObject3.has("state") ? jSONObject3.getString("state") : "";
+                string = (jSONObject3.has(UnityActivity.RESULT) ? jSONObject3.getInt(UnityActivity.RESULT) : 1) == 0 ? RESULT_FAILED : RESULT_SUCCESS;
+                i = CourseResult.SUCCESS.equals(string2);
+            } else if ("queryRobotStatus".equals(split[0])) {
+                JSONObject jSONObject4 = new JSONObject(string);
+                if (jSONObject4.has("state")) {
+                    i = jSONObject4.optInt("state");
+                }
+            } else if (TextUtils.isEmpty(string) || !string.contains(CourseResult.SUCCESS)) {
+                i = 0;
+            }
+            blocklyResult(jSONObject2.getString("branchId"), i, replace, string);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        } catch (Exception e2) {
+            e2.printStackTrace();
+        }
+    }
+
+    private void onDirectionResult(JSONObject jSONObject, String[] strArr) {
+        try {
+            JSONObject jSONObject2 = new JSONObject();
+            int i = 0;
+            if (!this.compactListener.directionNotChange()) {
+                String string = new JSONObject(strArr[1]).getString("direction");
+                if (DeviceDirection.SWING.getValue().equals(string)) {
+                    if (!this.compactListener.isShaking()) {
+                    }
+                    i = 1;
+                } else {
+                    DeviceDirection deviceDirection = this.compactListener.getDeviceDirection();
+                    if (deviceDirection != null) {
+                        if (!deviceDirection.getValue().equals(string)) {
+                        }
+                        i = 1;
+                    }
+                }
+            }
+            jSONObject2.put("state", CourseResult.SUCCESS);
+            jSONObject2.put(UnityActivity.RESULT, i);
+            jSONObject.put(UnityActivity.RESULT, jSONObject2.toString());
+            onBlocklyResult(jSONObject.toString());
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void onInfraredTimerResult(JSONObject jSONObject, String str) {
+        try {
+            if (jSONObject.has(UnityActivity.RESULT)) {
+                String string = jSONObject.getString(UnityActivity.RESULT);
+                if (TextUtils.isEmpty(string)) {
+                    return;
+                }
+                String[] split = string.split("\\|");
+                if (split.length <= 1 || !CourseResult.SUCCESS.equals(split[0])) {
+                    return;
+                }
+                this.blockly.showInfraredRef(formatResult(split[1]), str);
+            }
+        } catch (JSONException e) {
+            e.printStackTrace();
+            Log.e(this.TAG, e.getMessage());
+        }
+    }
+
+    private void onLogicCMDResult(String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            String string = jSONObject.getString(UnityActivity.RESULT);
+            String[] split = jSONObject.getString("cmd").replace(BlocklyCommandController.BASE_REQUEST_URL, "").split("\\|");
+            if ("failure".equals(string) && !BlocklyCommandController.QUERY_ALL_SENSOR.equals(split[0])) {
+                onBlocklyResult(str);
+                return;
+            }
+            if (split[0].equals(BlocklyCommandController.QUERY) && split[1].contains("direction")) {
+                onDirectionResult(jSONObject, split);
+            } else if (BlocklyCommandController.QUERY_ALL_SENSOR.equals(split[0])) {
+                onInfraredTimerResult(jSONObject, split.length >= 2 ? split[2] : "");
+            } else {
+                onBlocklyResult(str);
+            }
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public synchronized void open(String str) {
+        if (this.isBlocklyRunning) {
+            return;
+        }
+        int i = new SharePreferenceHelper().getInt(SharePreferenceHelper.SP_KEY_CONNECTION_STATUS, ConnectionStatus.DIS_CONNECT.getStatus());
+        if (this.blockly == null) {
+            this.blockly = DialogBlocklyWebView.getInstance(str, i, this.serverModelId, this.moduleType, this.code, this.activity.size, this.course);
+            register();
+        }
+        if (this.activity.getFragmentManager().findFragmentByTag(FRAGMENT_TAG_BLOCKLY) == null) {
+            if (this.blockly.isAdded()) {
+                XLog.a(this.TAG, "show blockly");
+                this.activity.getFragmentManager().beginTransaction().show(this.blockly).commit();
+            } else {
+                XLog.a(this.TAG, "add blockly");
+                this.activity.getFragmentManager().beginTransaction().add(R.id.content, this.blockly, FRAGMENT_TAG_BLOCKLY).commit();
+            }
+        } else if (TextUtils.isEmpty(str)) {
+            UnityActivity.communityWithUnity(this.activity, JimuBlocklyCommand.EXIT_LOGIC_VIEW, "");
+            return;
+        } else {
+            XLog.a(this.TAG, "show blockly");
+            this.blockly.updateJimuRobot(str);
+            this.activity.getFragmentManager().beginTransaction().show(this.blockly).commit();
+        }
+        this.isBlocklyRunning = true;
+    }
+
+    private synchronized void openBlockly(final String str) {
+        if (new File((ExternalOverFroyoUtils.a(JimuApplication.l(), (ModelType) null) + "data/blockly/") + Utils.BLOCKLY_NEW + File.separator + "teachMaterial/index.html").exists()) {
+            open(str);
+        } else {
+            Utils.unZipBlockly(new Utils.IUnzipBlockly() { // from class: com.ubt.jimu.blockly.command.UnityCommandController.1
+                @Override // com.ubt.jimu.blockly.Utils.IUnzipBlockly
+                public void unZipFailed() {
+                    XLog.b(UnityCommandController.this.TAG, "openBlockly unZipFailed 无法解压Blockly到指定目录");
+                    UnityActivity.communityWithUnity(UnityCommandController.this.activity, JimuBlocklyCommand.EXIT_LOGIC_VIEW, "");
+                }
+
+                @Override // com.ubt.jimu.blockly.Utils.IUnzipBlockly
+                public void unZipSuccessed() {
+                    UnityCommandController.this.open(str);
+                }
+            });
+        }
+        this.am.requestAudioFocus(new AudioManager.OnAudioFocusChangeListener() { // from class: com.ubt.jimu.blockly.command.UnityCommandController.2
+            @Override // android.media.AudioManager.OnAudioFocusChangeListener
+            public void onAudioFocusChange(int i) {
+                XLog.a(UnityCommandController.this.TAG, "audiomanager focusChange.");
+            }
+        }, 3, 2);
+    }
+
+    private void register() {
+        initCompactSensorEventListener();
+    }
+
+    private void showException(String str) {
+        XLog.b(this.TAG, "showException:" + str);
+        if (this.blockly != null) {
+            EventBus.b().b(new BlocklyEvent(1002, str));
+        }
+    }
+
+    private void unRegister() {
+        this.managerHelper.unRegisterListener(this.compactListener);
+    }
+
+    public void blocklyCallUnity(String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            String string = jSONObject.has("funcName") ? jSONObject.getString("funcName") : null;
+            if (JimuBlocklyCommand.EXIT_LOGIC_VIEW.equals(string)) {
+                this.open = false;
+                closeBlockly();
+                unRegister();
+                this.activity.setIsBack(true);
+                return;
+            }
+            if (JimuBlocklyCommand.CONNECT_BLE.equals(string)) {
+                hideBlockly();
+                return;
+            }
+            if (JimuBlocklyCommand.BLE_STATE.equals(string)) {
+                if (TextUtils.isEmpty(this.connenctDevice)) {
+                    bleState("0");
+                    return;
+                } else {
+                    bleState("1");
+                    return;
+                }
+            }
+            if (JimuBlocklyCommand.SET_SEND_XT_STATE.equals(string)) {
+                SetSendXTState(Integer.parseInt(jSONObject.getString("arg")));
+            } else if ("setServoMode".equals(string)) {
+                hideBlockly();
+            }
+        } catch (Exception e) {
+            Log.e(this.TAG, e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    public void closeBlockly() {
+        XLog.a(this.TAG, "close blockly");
+        this.isBlocklyRunning = false;
+        this.open = false;
+        if (this.blockly != null) {
+            synchronized (this) {
+                if (this.blockly != null) {
+                    this.blockly.stopQueryTimer();
+                    this.activity.getFragmentManager().beginTransaction().remove(this.blockly).commit();
+                    this.blockly = null;
+                    XLog.a(this.TAG, "销毁 DilogBlocklyWebview");
+                }
+            }
+        }
+        this.am.abandonAudioFocus(null);
+    }
+
+    public synchronized void hideBlockly() {
+        if (this.blockly != null) {
+            this.isBlocklyRunning = false;
+            this.activity.getFragmentManager().beginTransaction().hide(this.blockly).commit();
+            XLog.a(this.TAG, "隐藏 DilogBlocklyWebview");
+        }
+    }
+
+    public void loadJavascript(String str, String... strArr) {
+        DialogBlocklyWebView dialogBlocklyWebView = this.blockly;
+        if (dialogBlocklyWebView == null) {
+            return;
+        }
+        dialogBlocklyWebView.setJSResult(str, strArr);
+    }
+
+    public void notifyConnectionState(String str) {
+        if (this.blockly != null && StringUtils.f(str)) {
+            this.blockly.setJSResult("BLEStateChanged", str);
+        }
+    }
+
+    public void notifyKeyboardHidden(String str) {
+        DialogBlocklyWebView dialogBlocklyWebView = this.blockly;
+        if (dialogBlocklyWebView == null || !this.isBlocklyRunning) {
+            return;
+        }
+        dialogBlocklyWebView.notifyKeyboardHidden(str);
+    }
+
+    public boolean onUnityCallback(String str, String str2) {
+        if ("CommonTips".equals(str)) {
+            commonTips(str2);
+        }
+        if (!this.open && !OPEN_LOGIC_PROGRAMMING.equals(str)) {
+            return false;
+        }
+        if (OPEN_LOGIC_PROGRAMMING.equals(str)) {
+            this.open = true;
+            openBlockly(str2);
+        } else if ("ConnectBLECallBack".equals(str)) {
+            openBlockly(str2);
+            notifyBleState(str2);
+        } else if ("BLEDisconnectNotity".equals(str)) {
+            notifyBleState("{\"blueState\":\"3\"}");
+            notifyConnectionState("3");
+            EventBus.b().b(new BlocklyEvent(1003, str2));
+        } else if ("JsShowException".equals(str)) {
+            showException(str2);
+        } else if ("ChargeProtected".equals(str)) {
+            chargeProtected(str2);
+        } else if ("LogicCMDResult".equals(str)) {
+            onLogicCMDResult(str2);
+        } else if ("JsExceptionWaitResult".equals(str)) {
+            this.blockly.hideWait();
+        } else if ("OpenAndroidBLESetting".equals(str)) {
+            this.activity.startActivity(new Intent("android.settings.BLUETOOTH_SETTINGS"));
+        } else if ("refreshAllServo".equals(str)) {
+            openRefreshAllServo(str2);
+        } else {
+            if (!"deleteProgram".equals(str)) {
+                return false;
+            }
+            deleteProgram(str2);
+        }
+        return true;
+    }
+
+    public void openRefreshAllServo(String str) {
+        this.activity.getFragmentManager().beginTransaction().show(this.blockly).commit();
+        this.blockly.refreshAllServo(str);
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            this.blockly.refreshAllServo(jSONObject.has("commonServo") ? jSONObject.getString("commonServo") : "", jSONObject.has("circleServo") ? jSONObject.getString("circleServo") : "");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void setCode(int i) {
+        this.code = i;
+    }
+
+    public void setConnenctDevice(String str) {
+        try {
+            this.connenctDevice = str;
+            int status = (TextUtils.isEmpty(this.connenctDevice) ? ConnectionStatus.DIS_CONNECT : ConnectionStatus.CONNECTED).getStatus();
+            if (this.blockly != null) {
+                this.blockly.setBlueState(status);
+            }
+        } catch (Exception e) {
+            Log.e(this.TAG, e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    public void setCourse(Course course) {
+        this.course = course;
+    }
+
+    public void setModuleType(int i) {
+        this.moduleType = i;
+    }
+
+    public void setServerModelId(long j) {
+        this.serverModelId = j;
+    }
+
+    public synchronized void showBlockly() {
+        if (this.blockly != null) {
+            this.activity.getFragmentManager().beginTransaction().show(this.blockly).commit();
+        }
+    }
+
+    public void stopBlockly() {
+        DialogBlocklyWebView dialogBlocklyWebView = this.blockly;
+        if (dialogBlocklyWebView == null) {
+            return;
+        }
+        dialogBlocklyWebView.jsShowException("EnterBackground");
+    }
+
+    public void updateBluetoothState(String str) {
+        if (this.blockly != null && TextUtils.isDigitsOnly(str)) {
+            this.blockly.setBlueState(Integer.valueOf(str).intValue());
+        }
+    }
+}

sources/com/ubt/jimu/blockly/command/interaction/AbstractBlocklyInteraction.java

@@ -0,0 +1,39 @@
+package com.ubt.jimu.blockly.command.interaction;
+
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.bean.JimuMotion;
+import com.ubt.jimu.blockly.bean.JimuSound;
+import java.io.File;
+
+/* loaded from: classes.dex */
+public abstract class AbstractBlocklyInteraction {
+    public void addBlocklyProject(BlocklyProject blocklyProject, File file) {
+    }
+
+    public void addJimuMotion(JimuMotion jimuMotion) {
+    }
+
+    public void addJimuSound(JimuSound jimuSound, File file) {
+    }
+
+    public void deleteBlocklyProject(BlocklyProject blocklyProject, File file) {
+    }
+
+    public void deleteJimuMotion(JimuMotion jimuMotion) {
+    }
+
+    public void deleteJimuSound(JimuSound jimuSound, File file) {
+    }
+
+    public void renameBlocklyProject(BlocklyProject blocklyProject, File file) {
+    }
+
+    public void renameJimuMotion(JimuMotion jimuMotion) {
+    }
+
+    public void renameJimuSound(JimuSound jimuSound) {
+    }
+
+    public void updateBlocklyProject(BlocklyProject blocklyProject, File file) {
+    }
+}

sources/com/ubt/jimu/blockly/command/interaction/BlocklyInteraction.java

@@ -0,0 +1,139 @@
+package com.ubt.jimu.blockly.command.interaction;
+
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.bean.JimuMotion;
+import com.ubt.jimu.blockly.bean.JimuSound;
+import java.io.File;
+
+/* loaded from: classes.dex */
+public class BlocklyInteraction extends AbstractBlocklyInteraction {
+    private AbstractBlocklyInteraction[] listeners;
+
+    public BlocklyInteraction(AbstractBlocklyInteraction... abstractBlocklyInteractionArr) {
+        if (abstractBlocklyInteractionArr == null || abstractBlocklyInteractionArr.length == 0) {
+            this.listeners = new AbstractBlocklyInteraction[0];
+        } else {
+            this.listeners = abstractBlocklyInteractionArr;
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addBlocklyProject(BlocklyProject blocklyProject, File file) {
+        super.addBlocklyProject(blocklyProject, file);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.addBlocklyProject(blocklyProject, file);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addJimuMotion(JimuMotion jimuMotion) {
+        super.addJimuMotion(jimuMotion);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.addJimuMotion(jimuMotion);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addJimuSound(JimuSound jimuSound, File file) {
+        super.addJimuSound(jimuSound, file);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.addJimuSound(jimuSound, file);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteBlocklyProject(BlocklyProject blocklyProject, File file) {
+        super.deleteBlocklyProject(blocklyProject, file);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.deleteBlocklyProject(blocklyProject, file);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteJimuMotion(JimuMotion jimuMotion) {
+        super.deleteJimuMotion(jimuMotion);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.deleteJimuMotion(jimuMotion);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteJimuSound(JimuSound jimuSound, File file) {
+        super.deleteJimuSound(jimuSound, file);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.deleteJimuSound(jimuSound, file);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameBlocklyProject(BlocklyProject blocklyProject, File file) {
+        super.renameBlocklyProject(blocklyProject, file);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.renameBlocklyProject(blocklyProject, file);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameJimuMotion(JimuMotion jimuMotion) {
+        super.renameJimuMotion(jimuMotion);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.renameJimuMotion(jimuMotion);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameJimuSound(JimuSound jimuSound) {
+        super.renameJimuSound(jimuSound);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.renameJimuSound(jimuSound);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void updateBlocklyProject(BlocklyProject blocklyProject, File file) {
+        super.updateBlocklyProject(blocklyProject, file);
+        for (AbstractBlocklyInteraction abstractBlocklyInteraction : this.listeners) {
+            try {
+                abstractBlocklyInteraction.updateBlocklyProject(blocklyProject, file);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

sources/com/ubt/jimu/blockly/command/interaction/BlocklyUpload.java

@@ -0,0 +1,200 @@
+package com.ubt.jimu.blockly.command.interaction;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.db.DatabaseUtils;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.bean.JimuMotion;
+import com.ubt.jimu.blockly.bean.JimuSound;
+import com.ubt.jimu.blockly.dao.BlocklyProjectDbHandler;
+import com.ubt.jimu.blockly.dao.JimuMotionDbHandler;
+import com.ubt.jimu.blockly.dao.JimuSoundDbHandler;
+import com.ubt.jimu.blockly.networkSync.BlocklySyncHttpImpl;
+import com.ubt.jimu.blockly.networkSync.httpListener.DownloadSoundListener;
+import com.ubt.jimu.blockly.networkSync.httpListener.JimuMotionHttpListener;
+import com.ubt.jimu.blockly.networkSync.httpListener.RenameHttpListener;
+import com.ubt.jimu.blockly.networkSync.httpListener.UploadBlocklyHttpListener;
+import com.ubt.jimu.blockly.networkSync.httpListener.UploadJimuSoundHttpListener;
+import java.io.File;
+
+/* loaded from: classes.dex */
+public class BlocklyUpload extends AbstractBlocklyInteraction implements RenameHttpListener, UploadBlocklyHttpListener, UploadJimuSoundHttpListener, DownloadSoundListener, JimuMotionHttpListener {
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addBlocklyProject(BlocklyProject blocklyProject, File file) {
+        if (blocklyProject == null || file == null) {
+            return;
+        }
+        blocklyProject.setLocalFilePath(file.getAbsolutePath());
+        BlocklySyncHttpImpl.getInstance().setUploadBlocklyHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().prepareUploadBlockly(BlocklyUploadType.ADD_TYPE, blocklyProject);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addJimuMotion(JimuMotion jimuMotion) {
+        BlocklySyncHttpImpl.getInstance().setJimuMotionHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().syncJimuMotionToUbtService(BlocklyUploadType.ADD_TYPE, jimuMotion);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addJimuSound(JimuSound jimuSound, File file) {
+        jimuSound.setLocalFilePath(file.getAbsolutePath());
+        BlocklySyncHttpImpl.getInstance().setUploadJimuSoundHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().prepareUploadJimuSound(BlocklyUploadType.ADD_TYPE, jimuSound);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteBlocklyProject(BlocklyProject blocklyProject, File file) {
+        BlocklyProjectDbHandler.getInstance().setDeleteState(blocklyProject.getXmlId(), true);
+        BlocklySyncHttpImpl.getInstance().setUploadBlocklyHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().syncDataToUbtHttp(BlocklyUploadType.DELETE_TYPE, BlocklySyncHttpImpl.getInstance().getBlocklyProjectParameterFromProject(blocklyProject));
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteJimuMotion(JimuMotion jimuMotion) {
+        BlocklySyncHttpImpl.getInstance().setJimuMotionHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().syncJimuMotionToUbtService(BlocklyUploadType.DELETE_TYPE, jimuMotion);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteJimuSound(JimuSound jimuSound, File file) {
+        jimuSound.setLocalFilePath(file.getAbsolutePath());
+        BlocklySyncHttpImpl.getInstance().setUploadJimuSoundHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().syncJimuSoundToUbtService(BlocklyUploadType.DELETE_TYPE, jimuSound);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.DownloadSoundListener
+    public void downloadSoundFaulted(JimuSound jimuSound) {
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.DownloadSoundListener
+    public void downloadSoundSucceed(JimuSound jimuSound) {
+        JimuSoundDbHandler jimuSoundDbHandler = new JimuSoundDbHandler(DatabaseUtils.getDaoSession(true).p());
+        jimuSoundDbHandler.updateQiNiuSyncState(jimuSound, true);
+        jimuSoundDbHandler.updateJimuSoundUbtServiceState(jimuSound, true);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameBlocklyProject(BlocklyProject blocklyProject, File file) {
+        if (blocklyProject == null) {
+            return;
+        }
+        String userId = Cache.getInstance().getUserId();
+        if (TextUtils.isEmpty(userId) || "local".equals(userId)) {
+            return;
+        }
+        BlocklySyncHttpImpl.getInstance().setRenameHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().blocklyRenameSyncHttp(blocklyProject);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.RenameHttpListener
+    public void renameHttpFaulted(BlocklyProject blocklyProject) {
+        BlocklyProjectDbHandler.getInstance().updateBlocklyState(blocklyProject.getXmlId(), true);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.RenameHttpListener
+    public void renameHttpSucceed(BlocklyProject blocklyProject) {
+        BlocklyProjectDbHandler.getInstance().updateBlocklyState(blocklyProject.getXmlId(), false);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameJimuMotion(JimuMotion jimuMotion) {
+        BlocklySyncHttpImpl.getInstance().setJimuMotionHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().syncJimuMotionToUbtService(BlocklyUploadType.UPDATE_TYPE, jimuMotion);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameJimuSound(JimuSound jimuSound) {
+        BlocklySyncHttpImpl.getInstance().setUploadJimuSoundHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().syncJimuSoundToUbtService(BlocklyUploadType.UPDATE_TYPE, jimuSound);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadBlocklyHttpListener
+    public void syncDataToUbtHttpFaulted(BlocklyProject blocklyProject, BlocklyUploadType blocklyUploadType) {
+        if (blocklyUploadType == BlocklyUploadType.UPDATE_TYPE || BlocklyUploadType.ADD_TYPE == blocklyUploadType) {
+            BlocklyProjectDbHandler.getInstance().setServiceUplaodState(blocklyProject.getXmlId(), false);
+        } else if (blocklyUploadType == BlocklyUploadType.DELETE_TYPE) {
+            BlocklyProjectDbHandler.getInstance().setDeleteState(blocklyProject.getXmlId(), true);
+            BlocklyProjectDbHandler.getInstance().setServiceUplaodState(blocklyProject.getXmlId(), false);
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadBlocklyHttpListener
+    public void syncDataToUbtHttpSucceed(BlocklyProject blocklyProject, BlocklyUploadType blocklyUploadType) {
+        if (blocklyUploadType == BlocklyUploadType.ADD_TYPE || blocklyUploadType == BlocklyUploadType.UPDATE_TYPE) {
+            BlocklyProjectDbHandler.getInstance().setServiceUplaodState(blocklyProject.getXmlId(), true);
+            BlocklyProjectDbHandler.getInstance().setsetModifyState(blocklyProject.getXmlId(), false);
+            BlocklyProjectDbHandler.getInstance().isFirs(blocklyProject.getXmlId(), 1);
+        } else if (blocklyUploadType == BlocklyUploadType.DELETE_TYPE) {
+            BlocklyProjectDbHandler.getInstance().deleteBlocklyProject(blocklyProject.getXmlId());
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadJimuSoundHttpListener
+    public void syncToUbtServiceFaulted(BlocklyUploadType blocklyUploadType, JimuSound jimuSound) {
+        JimuSoundDbHandler jimuSoundDbHandler = new JimuSoundDbHandler(DatabaseUtils.getDaoSession(true).p());
+        if (blocklyUploadType == BlocklyUploadType.ADD_TYPE || blocklyUploadType == BlocklyUploadType.UPDATE_TYPE) {
+            jimuSoundDbHandler.updateJimuSoundUbtServiceState(jimuSound, false);
+        } else if (blocklyUploadType == BlocklyUploadType.DELETE_TYPE) {
+            jimuSoundDbHandler.uploadDeleteState(jimuSound, true);
+            jimuSoundDbHandler.updateJimuSoundUbtServiceState(jimuSound, false);
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadJimuSoundHttpListener
+    public void syncToUbtServiceSucceed(BlocklyUploadType blocklyUploadType, JimuSound jimuSound) {
+        JimuSoundDbHandler jimuSoundDbHandler = new JimuSoundDbHandler(DatabaseUtils.getDaoSession(true).p());
+        if (blocklyUploadType == BlocklyUploadType.ADD_TYPE || blocklyUploadType == BlocklyUploadType.UPDATE_TYPE) {
+            jimuSoundDbHandler.updateJimuSoundUbtServiceState(jimuSound, true);
+        } else if (blocklyUploadType == BlocklyUploadType.DELETE_TYPE) {
+            jimuSoundDbHandler.deleteJimuSound(jimuSound);
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void updateBlocklyProject(BlocklyProject blocklyProject, File file) {
+        if (blocklyProject == null) {
+            return;
+        }
+        BlocklySyncHttpImpl.getInstance().setUploadBlocklyHttpListener(this);
+        BlocklySyncHttpImpl.getInstance().prepareUploadBlockly(BlocklyUploadType.UPDATE_TYPE, blocklyProject);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadBlocklyHttpListener
+    public void uploadBlocklyToQiNiuFaulted(BlocklyProject blocklyProject) {
+        BlocklyProjectDbHandler.getInstance().setQiNiuUplaodState(blocklyProject.getXmlId(), false);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadBlocklyHttpListener
+    public void uploadBlocklyToQiNiuSucceed(BlocklyProject blocklyProject) {
+        BlocklyProjectDbHandler.getInstance().setQiNiuUplaodState(blocklyProject.getXmlId(), true);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadJimuSoundHttpListener
+    public void uploadJimuSoundToQiNiuFaulted(BlocklyUploadType blocklyUploadType, JimuSound jimuSound) {
+        new JimuSoundDbHandler(DatabaseUtils.getDaoSession(true).p()).updateQiNiuSyncState(jimuSound, false);
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.UploadJimuSoundHttpListener
+    public void uploadJimuSoundToQiNiuSucceed(BlocklyUploadType blocklyUploadType, JimuSound jimuSound) {
+        JimuSoundDbHandler jimuSoundDbHandler = new JimuSoundDbHandler(DatabaseUtils.getDaoSession(true).p());
+        if (blocklyUploadType == BlocklyUploadType.ADD_TYPE) {
+            jimuSoundDbHandler.updateQiNiuSyncState(jimuSound, true);
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.JimuMotionHttpListener
+    public void uploadMotionToUbtServiceFaulted(BlocklyUploadType blocklyUploadType, JimuMotion jimuMotion) {
+    }
+
+    @Override // com.ubt.jimu.blockly.networkSync.httpListener.JimuMotionHttpListener
+    public void uploadMotionToUbtServiceSucceed(BlocklyUploadType blocklyUploadType, JimuMotion jimuMotion) {
+        JimuMotionDbHandler jimuMotionDbHandler = new JimuMotionDbHandler(DatabaseUtils.getDaoSession(true).o());
+        if (blocklyUploadType != BlocklyUploadType.ADD_TYPE && blocklyUploadType != BlocklyUploadType.UPDATE_TYPE) {
+            jimuMotionDbHandler.deleteJimuMotionByModeelId(jimuMotion.getActionID());
+            return;
+        }
+        jimuMotion.setIsFirst(1);
+        jimuMotion.setIsUploadService(true);
+        jimuMotionDbHandler.insertOrUpdate(jimuMotion);
+    }
+}

sources/com/ubt/jimu/blockly/command/interaction/BlocklyUploadType.java

@@ -0,0 +1,8 @@
+package com.ubt.jimu.blockly.command.interaction;
+
+/* loaded from: classes.dex */
+public enum BlocklyUploadType {
+    ADD_TYPE,
+    UPDATE_TYPE,
+    DELETE_TYPE
+}

sources/com/ubt/jimu/blockly/command/interaction/TransportBlocklyInteraction.java

@@ -0,0 +1,170 @@
+package com.ubt.jimu.blockly.command.interaction;
+
+import com.ubt.jimu.base.db.DatabaseUtils;
+import com.ubt.jimu.blockly.JimuRobot;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.bean.JimuMotion;
+import com.ubt.jimu.blockly.bean.JimuSound;
+import com.ubt.jimu.transport.Transporter;
+import com.ubt.jimu.transport.dao.ConfigItemDbHandler;
+import com.ubt.jimu.transport.model.ConfigItem;
+import com.ubt.jimu.utils.SystemUtils;
+import java.io.File;
+
+/* loaded from: classes.dex */
+public class TransportBlocklyInteraction extends AbstractBlocklyInteraction {
+    private final String TAG = TransportBlocklyInteraction.class.getSimpleName();
+    private ConfigItemDbHandler configItemDbHandler = new ConfigItemDbHandler(DatabaseUtils.getDaoSession(true).b());
+    private JimuRobot jimuRobot;
+
+    public TransportBlocklyInteraction(JimuRobot jimuRobot) {
+        this.jimuRobot = jimuRobot;
+    }
+
+    private void uploadConfigItem(String str, ConfigItem configItem) {
+        Transporter.b().a(str, configItem);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addBlocklyProject(BlocklyProject blocklyProject, File file) {
+        super.addBlocklyProject(blocklyProject, file);
+        if (blocklyProject == null) {
+            return;
+        }
+        ConfigItem fromBlocklyProject = ConfigItem.fromBlocklyProject(blocklyProject);
+        fromBlocklyProject.setFileModifyTime(SystemUtils.a());
+        fromBlocklyProject.setIsDeleted("0");
+        fromBlocklyProject.setIsModify(true);
+        ConfigItem selectById = this.configItemDbHandler.selectById(Long.valueOf(this.configItemDbHandler.insert(fromBlocklyProject)));
+        Transporter.b().a(this.jimuRobot.getServerModelId(), this.jimuRobot.getModelId(), this.jimuRobot.getServerModelType(), file);
+        uploadConfigItem("add", selectById);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addJimuMotion(JimuMotion jimuMotion) {
+        super.addJimuMotion(jimuMotion);
+        ConfigItem fromJimuMotion = ConfigItem.fromJimuMotion(jimuMotion);
+        fromJimuMotion.setIsModify(true);
+        fromJimuMotion.setIsDeleted("0");
+        ConfigItem selectById = this.configItemDbHandler.selectById(Long.valueOf(this.configItemDbHandler.insert(fromJimuMotion)));
+        if (selectById == null) {
+            return;
+        }
+        uploadConfigItem("add", selectById);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void addJimuSound(JimuSound jimuSound, File file) {
+        ConfigItem fromJimuSound;
+        super.addJimuSound(jimuSound, file);
+        if (jimuSound == null || (fromJimuSound = ConfigItem.fromJimuSound(jimuSound)) == null) {
+            return;
+        }
+        fromJimuSound.setIsModify(true);
+        fromJimuSound.setIsDeleted("0");
+        uploadConfigItem("add", this.configItemDbHandler.selectById(Long.valueOf(this.configItemDbHandler.insert(fromJimuSound))));
+        Transporter.b().a(Long.parseLong("0"), "0", "0", file);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteBlocklyProject(BlocklyProject blocklyProject, File file) {
+        ConfigItem a;
+        super.deleteBlocklyProject(blocklyProject, file);
+        if (blocklyProject == null || (a = this.configItemDbHandler.a(blocklyProject)) == null) {
+            return;
+        }
+        if (!"0000".equals(a.getServerID())) {
+            this.configItemDbHandler.delete(a);
+            return;
+        }
+        this.configItemDbHandler.c(a);
+        uploadConfigItem("delete", a);
+        Transporter.b().a(file);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteJimuMotion(JimuMotion jimuMotion) {
+        super.deleteJimuMotion(jimuMotion);
+        ConfigItem a = this.configItemDbHandler.a(jimuMotion);
+        if (a == null) {
+            return;
+        }
+        if (!"0000".equals(a.getServerID())) {
+            this.configItemDbHandler.delete(a);
+        } else {
+            this.configItemDbHandler.c(a);
+            uploadConfigItem("delete", a);
+        }
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void deleteJimuSound(JimuSound jimuSound, File file) {
+        ConfigItem a;
+        super.deleteJimuSound(jimuSound, file);
+        if (jimuSound == null || (a = this.configItemDbHandler.a(jimuSound)) == null) {
+            return;
+        }
+        if (!"0000".equals(a.getServerID())) {
+            this.configItemDbHandler.delete(a);
+            return;
+        }
+        this.configItemDbHandler.c(a);
+        uploadConfigItem("delete", a);
+        Transporter.b().a(file);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameBlocklyProject(BlocklyProject blocklyProject, File file) {
+        ConfigItem a;
+        super.renameBlocklyProject(blocklyProject, file);
+        if (blocklyProject == null || (a = this.configItemDbHandler.a(blocklyProject)) == null) {
+            return;
+        }
+        a.setFileModifyTime(SystemUtils.a());
+        a.setIsModify(true);
+        a.setDescription(blocklyProject.getXmlName());
+        this.configItemDbHandler.update(a);
+        uploadConfigItem("update", a);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameJimuMotion(JimuMotion jimuMotion) {
+        super.renameJimuMotion(jimuMotion);
+        ConfigItem a = this.configItemDbHandler.a(jimuMotion);
+        if (a == null) {
+            return;
+        }
+        a.setDescription(jimuMotion.getActionName());
+        a.setIsModify(true);
+        this.configItemDbHandler.update(a);
+        uploadConfigItem("update", a);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void renameJimuSound(JimuSound jimuSound) {
+        ConfigItem a;
+        super.renameJimuSound(jimuSound);
+        if (jimuSound == null || (a = this.configItemDbHandler.a(jimuSound)) == null) {
+            return;
+        }
+        a.setFileModifyTime(SystemUtils.a());
+        a.setDescription(jimuSound.getDescription());
+        a.setIsModify(true);
+        this.configItemDbHandler.update(a);
+        uploadConfigItem("update", a);
+    }
+
+    @Override // com.ubt.jimu.blockly.command.interaction.AbstractBlocklyInteraction
+    public void updateBlocklyProject(BlocklyProject blocklyProject, File file) {
+        ConfigItem a;
+        super.updateBlocklyProject(blocklyProject, file);
+        if (blocklyProject == null || (a = this.configItemDbHandler.a(blocklyProject)) == null) {
+            return;
+        }
+        a.setFileModifyTime(SystemUtils.a());
+        a.setIsModify(true);
+        this.configItemDbHandler.update(a);
+        uploadConfigItem("update", a);
+        Transporter.b().b(file);
+    }
+}

sources/com/ubt/jimu/blockly/command/result/JavaResultBean.java

@@ -0,0 +1,21 @@
+package com.ubt.jimu.blockly.command.result;
+
+/* loaded from: classes.dex */
+public class JavaResultBean<T> {
+    public static final String RESULT_EXCEPTION = "0011";
+    public static final String RESULT_FAILED = "0022";
+    public static final String RESULT_NAME = "0001";
+    public static final String RESULT_SUCCESS = "0000";
+    public T result;
+    public String retCode;
+    public String retMsg;
+
+    public JavaResultBean() {
+    }
+
+    public JavaResultBean(String str, String str2, T t) {
+        this.retCode = str;
+        this.retMsg = str2;
+        this.result = t;
+    }
+}

sources/com/ubt/jimu/blockly/command/result/JimuActionList.java

@@ -0,0 +1,11 @@
+package com.ubt.jimu.blockly.command.result;
+
+import com.ubt.jimu.blockly.feature.blockly.JimuAction;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class JimuActionList {
+    public List<JimuAction> degree;
+    public List<JimuAction> distance;
+    public List<JimuAction> time;
+}

sources/com/ubt/jimu/blockly/command/result/QueryResult.java

@@ -0,0 +1,59 @@
+package com.ubt.jimu.blockly.command.result;
+
+import com.ubt.jimu.blockly.feature.blockly.ColorSensor;
+import com.ubt.jimu.blockly.feature.blockly.Gyroscope;
+import com.ubt.jimu.blockly.feature.blockly.JimuSensor;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class QueryResult {
+    private List<ColorSensor> Color;
+    private List<JimuSensor> DigitalTube;
+    private List<JimuSensor> Gravity;
+    private List<Gyroscope> Gyro;
+    private List<JimuSensor> Infrared;
+    private List<JimuSensor> Light;
+    private List<JimuSensor> Phone;
+    private List<JimuSensor> Touch;
+    private List<JimuSensor> Ultrasonic;
+
+    public List<ColorSensor> getColor() {
+        return this.Color;
+    }
+
+    public List<JimuSensor> getDigitalTube() {
+        return this.DigitalTube;
+    }
+
+    public List<JimuSensor> getGravity() {
+        return this.Gravity;
+    }
+
+    public List<Gyroscope> getGyro() {
+        return this.Gyro;
+    }
+
+    public List<JimuSensor> getInfrared() {
+        return this.Infrared;
+    }
+
+    public List<JimuSensor> getLight() {
+        return this.Light;
+    }
+
+    public List<JimuSensor> getPhone() {
+        return this.Phone;
+    }
+
+    public List<JimuSensor> getTouch() {
+        return this.Touch;
+    }
+
+    public List<JimuSensor> getUltrasonic() {
+        return this.Ultrasonic;
+    }
+
+    public void setPhone(List<JimuSensor> list) {
+        this.Phone = list;
+    }
+}

sources/com/ubt/jimu/blockly/command/result/SaveBean.java

@@ -0,0 +1,6 @@
+package com.ubt.jimu.blockly.command.result;
+
+/* loaded from: classes.dex */
+public class SaveBean {
+    public String xmlId;
+}

sources/com/ubt/jimu/blockly/command/result/XmlListBean.java

@@ -0,0 +1,26 @@
+package com.ubt.jimu.blockly.command.result;
+
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class XmlListBean {
+    public String blocklyVersion;
+    public boolean isDefault;
+    public String type;
+    public String xmlContent;
+    public List<BlocklyProject> xmlList;
+
+    public XmlListBean(List<BlocklyProject> list) {
+        this.xmlList = list;
+    }
+
+    public XmlListBean(String str) {
+        this.type = "newBlockly";
+        this.xmlContent = str;
+    }
+
+    public XmlListBean() {
+        this.type = "newBlockly";
+    }
+}