Initial commit

sources/com/ubt/jimu/unity/ModelType.java

@@ -0,0 +1,24 @@
+package com.ubt.jimu.unity;
+
+/* loaded from: classes2.dex */
+public enum ModelType {
+    DEFAULT("default", 1),
+    PLAYER_DATA("playerdata", 2),
+    DOWNLOAD("download", 3);
+
+    private String name;
+    private int type;
+
+    ModelType(String str, int i) {
+        this.name = str;
+        this.type = i;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public int getType() {
+        return this.type;
+    }
+}

sources/com/ubt/jimu/unity/RobotWalkingType.java

@@ -0,0 +1,18 @@
+package com.ubt.jimu.unity;
+
+/* loaded from: classes2.dex */
+public enum RobotWalkingType {
+    DOUBLE_FEET("doubleFeet"),
+    FOUR_FEET("fourFeet"),
+    WHEEL_MODE("wheelMode");
+
+    private String type;
+
+    RobotWalkingType(String str) {
+        this.type = str;
+    }
+
+    public String getType() {
+        return this.type;
+    }
+}

sources/com/ubt/jimu/unity/UnityEvent.java

@@ -0,0 +1,28 @@
+package com.ubt.jimu.unity;
+
+/* loaded from: classes2.dex */
+public class UnityEvent {
+    public static final int TYPE_CALL_APP = 102;
+    public static final int TYPE_CALL_UNITY = 101;
+    private String data;
+    private String name;
+    private int type;
+
+    public UnityEvent(int i, String str, String str2) {
+        this.type = i;
+        this.name = str;
+        this.data = str2;
+    }
+
+    public String getData() {
+        return this.data;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public int getType() {
+        return this.type;
+    }
+}

sources/com/ubt/jimu/unity/bluetooth/AndroidData.java

@@ -0,0 +1,119 @@
+package com.ubt.jimu.unity.bluetooth;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.entities.User;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.dao.BlocklyProjectDbHandler;
+import com.ubt.jimu.utils.JsonHelper;
+import com.ubt.jimu.utils.LocaleUtils;
+import com.ubtrobot.log.ALog;
+import java.util.HashMap;
+import java.util.List;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class AndroidData {
+    private static final String DIY_STEP = "diyStepData";
+    private static final String LANGUAGE = "language";
+    private static final String PROGRAM = "program";
+    private static final String TAG = "AndroidData";
+    private static final String USER_ID = "userId";
+    private UnityActivity unityActivity;
+
+    public AndroidData(UnityActivity unityActivity) {
+        this.unityActivity = unityActivity;
+    }
+
+    private String getLang() {
+        return LocaleUtils.a();
+    }
+
+    private String getLanguage() {
+        return LocaleUtils.a();
+    }
+
+    private String getUserId() {
+        User user = Cache.getInstance().getUser();
+        if (user == null) {
+            return "local";
+        }
+        return user.getUserId() + "";
+    }
+
+    public String getData(String str, String str2) {
+        char c;
+        int hashCode = str.hashCode();
+        if (hashCode != -926533302) {
+            if (hashCode == -309387644 && str.equals("program")) {
+                c = 0;
+            }
+            c = 65535;
+        } else {
+            if (str.equals(DIY_STEP)) {
+                c = 1;
+            }
+            c = 65535;
+        }
+        if (c == 0) {
+            getProgram(str2);
+            return "";
+        }
+        if (c != 1) {
+            return "";
+        }
+        getDiyStep();
+        return "";
+    }
+
+    public String getDiyStep() {
+        HashMap hashMap = new HashMap();
+        hashMap.put("nowStep", 8);
+        hashMap.put("totalStep", 10);
+        return JsonHelper.a(hashMap);
+    }
+
+    public String getProgram(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return "[]";
+        }
+        String str2 = "";
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            List<BlocklyProject> projects = BlocklyProjectDbHandler.getProjects(Cache.getInstance().getUserId(), jSONObject.getString(UnityActivity.modelId), jSONObject.getInt(UnityActivity.pModelType));
+            String lang = getLang();
+            for (BlocklyProject blocklyProject : projects) {
+                if (blocklyProject.xmlNameLang != null) {
+                    try {
+                        blocklyProject.setXmlName(blocklyProject.xmlNameLang.get(lang));
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+            str2 = JsonHelper.a(projects);
+            ALog.a(TAG).d(str2);
+            return str2;
+        } catch (JSONException e2) {
+            e2.printStackTrace();
+            return str2;
+        }
+    }
+
+    public String getUserData(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return "null";
+        }
+        char c = 65535;
+        int hashCode = str.hashCode();
+        if (hashCode != -1613589672) {
+            if (hashCode == -836030906 && str.equals(USER_ID)) {
+                c = 0;
+            }
+        } else if (str.equals("language")) {
+            c = 1;
+        }
+        return c != 0 ? c != 1 ? "null" : getLanguage() : getUserId();
+    }
+}

sources/com/ubt/jimu/unity/bluetooth/ByteHexHelper.java

@@ -0,0 +1,452 @@
+package com.ubt.jimu.unity.bluetooth;
+
+import com.ijm.dataencryption.de.DataDecryptTool;
+import java.io.File;
+import java.io.FileInputStream;
+import java.security.MessageDigest;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Formatter;
+import java.util.regex.Pattern;
+
+/* loaded from: classes2.dex */
+public class ByteHexHelper {
+    private static boolean D = false;
+
+    public static String RandomMethod() {
+        String hexString = Integer.toHexString((int) (Math.random() * 100.0d));
+        int length = hexString.length();
+        while (length < 2) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexString;
+    }
+
+    public static String XOR(String str) {
+        byte b;
+        if (str.length() > 0) {
+            b = 0;
+            for (int i = 0; i < str.length() / 2; i++) {
+                int i2 = i * 2;
+                b = (byte) (b ^ hexStringToByte(str.substring(i2, i2 + 2)));
+            }
+        } else {
+            b = 0;
+        }
+        return bytesToHexString(new byte[]{b});
+    }
+
+    public static byte[] appendByteArray(byte[] bArr, byte[] bArr2) {
+        if (bArr.length <= 0 || bArr2.length <= 0) {
+            throw new IllegalArgumentException("<EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
+        }
+        byte[] bArr3 = new byte[bArr.length + bArr2.length];
+        System.arraycopy(bArr, 0, bArr3, 0, bArr.length);
+        System.arraycopy(bArr2, 0, bArr3, bArr.length, bArr2.length);
+        return bArr3;
+    }
+
+    public static String binaryString2hexString(String str) {
+        if (str == null || str.equals("")) {
+            return "";
+        }
+        if (str.length() % 8 != 0) {
+            int length = 8 - (str.length() % 8);
+            String str2 = str;
+            for (int i = 0; i < length; i++) {
+                str2 = str2 + "0";
+            }
+            System.out.println("choiceItem = " + str2);
+            str = str2;
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        for (int i2 = 0; i2 < str.length(); i2 += 4) {
+            int i3 = 0;
+            for (int i4 = 0; i4 < 4; i4++) {
+                int i5 = i2 + i4;
+                i3 += Integer.parseInt(str.substring(i5, i5 + 1)) << ((4 - i4) - 1);
+            }
+            stringBuffer.append(Integer.toHexString(i3));
+        }
+        System.out.println("tmp.toString() = " + stringBuffer.toString());
+        return stringBuffer.toString();
+    }
+
+    public static String byteToHexString(byte b) {
+        StringBuilder sb = new StringBuilder("");
+        String hexString = Integer.toHexString(b & 255);
+        if (hexString.length() < 2) {
+            sb.append(0);
+        }
+        sb.append(hexString);
+        return sb.toString();
+    }
+
+    public static int byteToInt(byte b) {
+        return b & 255;
+    }
+
+    public static String bytesToHexString(byte[] bArr) {
+        StringBuilder sb = new StringBuilder("");
+        if (bArr == null || bArr.length <= 0) {
+            return "";
+        }
+        for (byte b : bArr) {
+            String hexString = Integer.toHexString(b & 255);
+            if (hexString.length() < 2) {
+                sb.append(0);
+            }
+            sb.append(hexString);
+            sb.append(" ");
+        }
+        return sb.toString();
+    }
+
+    public static String calculateSingleFileMD5sum(File file) throws Exception {
+        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
+        FileInputStream fileInputStream = new FileInputStream(file);
+        try {
+            byte[] bArr = new byte[DataDecryptTool.DECRYPT_ALL_FILE];
+            while (true) {
+                int read = fileInputStream.read(bArr);
+                if (read == -1) {
+                    break;
+                }
+                messageDigest.update(bArr, 0, read);
+            }
+            fileInputStream.close();
+            StringBuilder sb = new StringBuilder();
+            byte[] digest = messageDigest.digest();
+            Formatter formatter = new Formatter();
+            try {
+                for (byte b : digest) {
+                    sb.append(formatter.format("%02x", Byte.valueOf(b)));
+                }
+                formatter.close();
+                return sb.toString();
+            } finally {
+            }
+        } catch (Throwable th) {
+            try {
+                throw th;
+            } catch (Throwable th2) {
+                try {
+                    fileInputStream.close();
+                } catch (Throwable th3) {
+                    th.addSuppressed(th3);
+                }
+                throw th2;
+            }
+        }
+    }
+
+    private static byte charToByte(char c) {
+        return (byte) "0123456789ABCDEF".indexOf(c);
+    }
+
+    public static String checkedSite(int i) {
+        String hexString = Integer.toHexString(i);
+        int length = hexString.length();
+        while (length < 2) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexString;
+    }
+
+    public static String currentData() {
+        StringBuffer stringBuffer = new StringBuffer();
+        DecimalFormat decimalFormat = new DecimalFormat("00");
+        Calendar calendar = Calendar.getInstance();
+        String format = decimalFormat.format(calendar.get(1));
+        String format2 = decimalFormat.format(calendar.get(2) + 1);
+        String format3 = decimalFormat.format(calendar.get(5));
+        String format4 = decimalFormat.format(calendar.get(11));
+        String format5 = decimalFormat.format(calendar.get(12));
+        String format6 = decimalFormat.format(calendar.get(13));
+        String format7 = decimalFormat.format(calendar.get(7) - 1);
+        stringBuffer.append(format.substring(2, format.length()));
+        stringBuffer.append(format2);
+        stringBuffer.append(format3);
+        stringBuffer.append(format4);
+        stringBuffer.append(format5);
+        stringBuffer.append(format6);
+        stringBuffer.append(format7);
+        System.out.println(stringBuffer.toString());
+        return stringBuffer.toString();
+    }
+
+    public static String dpuString(String str) {
+        if (str == null || str.length() <= 0) {
+            return "";
+        }
+        String bytesToHexString = bytesToHexString((str + "\u0000").getBytes());
+        String str2 = packLength(bytesToHexString) + bytesToHexString;
+        System.out.println("resultLength==" + str2);
+        return str2;
+    }
+
+    public static String hexString2binaryString(String str) {
+        if (str == null || str.length() % 2 != 0) {
+            return null;
+        }
+        int i = 0;
+        String str2 = "";
+        while (i < str.length()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("0000");
+            int i2 = i + 1;
+            sb.append(Integer.toBinaryString(Integer.parseInt(str.substring(i, i2), 16)));
+            str2 = str2 + sb.toString().substring(r0.length() - 4);
+            i = i2;
+        }
+        return str2;
+    }
+
+    public static byte hexStringToByte(String str) {
+        String upperCase = str.toUpperCase();
+        int length = upperCase.length() / 2;
+        char[] charArray = upperCase.toCharArray();
+        byte[] bArr = new byte[length];
+        for (int i = 0; i < length; i++) {
+            int i2 = i * 2;
+            bArr[i] = (byte) ((charToByte(charArray[i2 + 1]) & 255) | (charToByte(charArray[i2]) << 4));
+        }
+        return bArr[0];
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:11:0x004c  */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0052  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public static byte[] hexStringToBytes(java.lang.String r8) {
+        /*
+            java.lang.String r0 = " "
+            java.lang.String r1 = ""
+            java.lang.String r8 = r8.replace(r0, r1)
+            java.io.PrintStream r0 = java.lang.System.out
+            r0.println(r8)
+            int r0 = r8.length()
+            int r0 = r0 / 2
+            byte[] r0 = new byte[r0]
+            r1 = 0
+            r2 = 0
+        L17:
+            int r3 = r8.length()
+            if (r2 >= r3) goto L61
+            int r3 = r2 + 1
+            java.lang.String r2 = r8.substring(r2, r3)
+            byte[] r2 = r2.getBytes()
+            r2 = r2[r1]
+            r4 = 64
+            r5 = 96
+            if (r2 <= r5) goto L36
+            int r2 = r2 + (-97)
+        L31:
+            int r2 = r2 + 10
+        L33:
+            int r2 = r2 * 16
+            goto L3e
+        L36:
+            if (r2 <= r4) goto L3b
+            int r2 = r2 + (-65)
+            goto L31
+        L3b:
+            int r2 = r2 + (-48)
+            goto L33
+        L3e:
+            int r6 = r3 + 1
+            java.lang.String r7 = r8.substring(r3, r6)
+            byte[] r7 = r7.getBytes()
+            r7 = r7[r1]
+            if (r7 <= r5) goto L52
+            int r7 = r7 + (-97)
+        L4e:
+            int r7 = r7 + 10
+        L50:
+            int r2 = r2 + r7
+            goto L5a
+        L52:
+            if (r7 <= r4) goto L57
+            int r7 = r7 + (-65)
+            goto L4e
+        L57:
+            int r7 = r7 + (-48)
+            goto L50
+        L5a:
+            int r3 = r3 / 2
+            byte r2 = (byte) r2
+            r0[r3] = r2
+            r2 = r6
+            goto L17
+        L61:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.ubt.jimu.unity.bluetooth.ByteHexHelper.hexStringToBytes(java.lang.String):byte[]");
+    }
+
+    public static byte[] hexStringToBytes2(String str) {
+        if (str == null || str.equals("")) {
+            return new byte[0];
+        }
+        String upperCase = str.toUpperCase();
+        int length = upperCase.length() / 2;
+        char[] charArray = upperCase.toCharArray();
+        byte[] bArr = new byte[length];
+        for (int i = 0; i < length; i++) {
+            int i2 = i * 2;
+            bArr[i] = (byte) ((charToByte(charArray[i2 + 1]) & 255) | (charToByte(charArray[i2]) << 4));
+        }
+        return bArr;
+    }
+
+    public static int intPackLength(String str) {
+        return Integer.valueOf(str, 16).intValue();
+    }
+
+    public static byte[] intToFourHexBytes(int i) {
+        String hexString = Integer.toHexString(i);
+        int length = hexString.length();
+        while (length < 8) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexStringToBytes(hexString);
+    }
+
+    public static byte[] intToFourHexBytesTwo(int i) {
+        String hexString = Integer.toHexString(i);
+        int length = hexString.length();
+        if (length < 2) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        while (length < 8) {
+            hexString = hexString + "0";
+            length = hexString.length();
+        }
+        return hexStringToBytes(hexString);
+    }
+
+    public static byte intToHexByte(int i) {
+        String hexString = Integer.toHexString(i);
+        int length = hexString.length();
+        while (length < 2) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexStringToByte(hexString);
+    }
+
+    public static byte[] intToHexBytes(int i) {
+        String hexString = Integer.toHexString(i);
+        int length = hexString.length();
+        while (length < 2) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexStringToBytes(hexString);
+    }
+
+    public static byte[] intToTwoHexBytes(int i) {
+        String hexString = Integer.toHexString(i);
+        int length = hexString.length();
+        while (length < 4) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexStringToBytes(hexString);
+    }
+
+    public static String packLength(String str) {
+        String hexString = Integer.toHexString(str.length() / 2);
+        int length = hexString.length();
+        while (length < 4) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexString;
+    }
+
+    public static String packVerify(String str, String str2, String str3, String str4, String str5, String str6) {
+        return XOR(str + str2 + str3 + str4 + str5 + str6);
+    }
+
+    public static String parseAscii(String str) {
+        StringBuilder sb = new StringBuilder();
+        for (byte b : str.getBytes()) {
+            sb.append(toHex(b));
+        }
+        return sb.toString();
+    }
+
+    public static String replaceBlank(String str) {
+        return (str != null ? Pattern.compile("\t|\r|\n").matcher(str).replaceAll("") : "").trim();
+    }
+
+    public static String toHex(int i) {
+        StringBuilder sb = new StringBuilder();
+        int i2 = i / 16;
+        if (i2 == 0) {
+            return toHexUtil(i);
+        }
+        sb.append(toHex(i2));
+        sb.append(toHexUtil(i % 16));
+        return sb.toString();
+    }
+
+    private static String toHexUtil(int i) {
+        switch (i) {
+            case 10:
+                return "A";
+            case 11:
+                return "B";
+            case 12:
+                return "C";
+            case 13:
+                return "D";
+            case 14:
+                return "E";
+            case 15:
+                return "F";
+            default:
+                return "" + i;
+        }
+    }
+
+    public static ArrayList<String> toStringArray(byte[] bArr) {
+        int length;
+        if (bArr == null || (length = bArr.length) < 3) {
+            return null;
+        }
+        ArrayList<String> arrayList = new ArrayList<>();
+        int i = 0;
+        while (i < length - 1) {
+            int i2 = (bArr[i] << 8) | (bArr[i + 1] & 255);
+            int i3 = i2 - 1;
+            byte[] bArr2 = new byte[i3];
+            System.arraycopy(bArr, i + 2, bArr2, 0, i3);
+            arrayList.add(new String(bArr2));
+            i += i2 + 2;
+        }
+        return arrayList;
+    }
+
+    public static int intPackLength(byte[] bArr) {
+        return Integer.valueOf(bytesToHexString(bArr), 16).intValue();
+    }
+
+    public static String packLength(int i) {
+        String hexString = Integer.toHexString(i);
+        int length = hexString.length();
+        while (length < 4) {
+            hexString = "0" + hexString;
+            length = hexString.length();
+        }
+        return hexString;
+    }
+}

sources/com/ubt/jimu/unity/bluetooth/ConnectionStatus.java

@@ -0,0 +1,33 @@
+package com.ubt.jimu.unity.bluetooth;
+
+import com.ubt.jimu.R;
+
+/* loaded from: classes2.dex */
+public enum ConnectionStatus {
+    CONNECTED(0, R.mipmap.bluetooth_connected, "已连接"),
+    CHARGING(1, R.mipmap.bluetooth_charging, "充电中"),
+    LOW_BATTERY(2, R.mipmap.bluetooth_low_battery, "电量不足"),
+    DIS_CONNECT(3, R.mipmap.bluetooth_disconnected, "断开连接");
+
+    private String description;
+    private int status;
+    private int statusBackground;
+
+    ConnectionStatus(int i, int i2, String str) {
+        this.status = i;
+        this.description = str;
+        this.statusBackground = i2;
+    }
+
+    public String getDescription() {
+        return this.description;
+    }
+
+    public int getStatus() {
+        return this.status;
+    }
+
+    public int getStatusBackground() {
+        return this.statusBackground;
+    }
+}

sources/com/ubt/jimu/unity/bluetooth/DiyActionDownloader.java

@@ -0,0 +1,86 @@
+package com.ubt.jimu.unity.bluetooth;
+
+import android.util.Log;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.cache.Constants;
+import com.ubt.jimu.diy.contract.UserDiyHomeContract;
+import com.ubt.jimu.diy.presenter.UserDiyHomePresenter;
+import com.ubt.jimu.transport.model.TransportFile;
+import com.ubt.jimu.transport3.model.DiyModelAction;
+import java.util.HashMap;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class DiyActionDownloader implements UserDiyHomeContract.View {
+    private String modelID;
+    private String modelName;
+    private long modelServerId;
+    private int modelType;
+    private UnityActivity unityActivity;
+    private String userId;
+    private final String TAG = DiyActionDownloader.class.getSimpleName();
+    private UserDiyHomeContract.Presenter presenter = new UserDiyHomePresenter(this);
+
+    public DiyActionDownloader(UnityActivity unityActivity, String str, long j, String str2, String str3, int i) {
+        this.unityActivity = unityActivity;
+        this.userId = str;
+        this.modelServerId = j;
+        this.modelID = str2;
+        this.modelName = str3;
+        this.modelType = i + 1;
+    }
+
+    public static void reloadServos(UnityActivity unityActivity, String str, String str2, int i) {
+        if (Cache.getInstance().getSettings().getBoolean(Constants.KEY_DOWNLOAD_SERVOS, false).booleanValue()) {
+            Cache.getInstance().getSettings().put(Constants.KEY_DOWNLOAD_SERVOS, false);
+            reloadSource(unityActivity, str, str2, i, 4);
+        }
+    }
+
+    public static void reloadSource(UnityActivity unityActivity, String str, String str2, int i, int i2) {
+        if (i2 <= 0 || unityActivity == null) {
+            return;
+        }
+        HashMap hashMap = new HashMap();
+        hashMap.put(UnityActivity.modelId, str);
+        hashMap.put(UnityActivity.pModelName, str2);
+        hashMap.put(UnityActivity.pModelType, Integer.valueOf(i));
+        hashMap.put("fileType", Integer.valueOf(i2));
+        UnityActivity.CallUnityFunc("downloadFilesNotify", hashMap);
+    }
+
+    public void downloadAction() {
+        if ("local".equals(this.userId)) {
+            return;
+        }
+        long j = this.modelServerId;
+        if (j <= 0) {
+            return;
+        }
+        this.presenter.getDiyModelActions(this.userId, this.modelType, this.modelID, Integer.valueOf((int) j));
+    }
+
+    @Override // com.ubt.jimu.diy.contract.UserDiyHomeContract.View
+    public void onGetServerActionListFailed(Throwable th) {
+        Log.e(this.TAG, "DIY动作下载失败");
+    }
+
+    @Override // com.ubt.jimu.diy.contract.UserDiyHomeContract.View
+    public void onGetServerActionListSuccess(List<DiyModelAction> list) {
+        reloadSource(this.unityActivity, this.modelID, this.modelName, this.modelType - 1, 2);
+    }
+
+    @Override // com.ubt.jimu.diy.contract.UserDiyHomeContract.View
+    public void onServerDeleteActions(List<DiyModelAction> list) {
+        reloadSource(this.unityActivity, this.modelID, this.modelName, this.modelType - 1, 2);
+    }
+
+    @Override // com.ubt.jimu.diy.contract.UserDiyHomeContract.View
+    public void onStartDownload(List<TransportFile> list) {
+    }
+
+    @Override // com.ubtech.view.BaseView
+    public void setPresenter(UserDiyHomeContract.Presenter presenter) {
+        this.presenter = presenter;
+    }
+}

sources/com/ubt/jimu/unity/bluetooth/MyUnityListener.java

@@ -0,0 +1,791 @@
+package com.ubt.jimu.unity.bluetooth;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+import com.alibaba.android.arouter.facade.Postcard;
+import com.alibaba.android.arouter.launcher.ARouter;
+import com.liulishuo.filedownloader.model.FileDownloadModel;
+import com.ubt.jimu.JimuApplication;
+import com.ubt.jimu.R;
+import com.ubt.jimu.base.UbtActivityStack;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.cache.SharePreferenceHelper;
+import com.ubt.jimu.base.db.DatabaseUtils;
+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.RobotLite;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.dao.BlocklyProjectDbHandler;
+import com.ubt.jimu.blockly.exception.JimuConnectionException;
+import com.ubt.jimu.blockly.feature.audio.AudioPlayer;
+import com.ubt.jimu.connect.ConnectActivity;
+import com.ubt.jimu.discover.CourseHelper;
+import com.ubt.jimu.discover.IAccomplishEventListener;
+import com.ubt.jimu.discover.view.AccomplishWithoutUserDialog;
+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.user.setting.view.CommonSettingActivity;
+import com.ubt.jimu.utils.ExternalOverFroyoUtils;
+import com.ubt.jimu.utils.JsonHelper;
+import com.ubt.jimu.utils.LogUtils;
+import com.ubt.jimu.utils.SPUtils;
+import com.ubtech.utils.StringUtils;
+import com.ubtech.utils.XLog;
+import com.ubtrobot.log.ALog;
+import org.greenrobot.eventbus.EventBus;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class MyUnityListener {
+    public static final String ACTION_EDIT_BACK = "actionEditBack";
+    public static final String BACK_TO = "backTo";
+    public static final String CALLBACK = "callback";
+    public static final String CALLER = "from";
+    public static final String CONNECT_HELP = "NotificationNameConnectionError";
+    public static final String DELETE_PROGRAM = "deleteProgram";
+    public static final String DISCONNECT_BLE_CALLBACK = "DisConnectBLECallBack";
+    public static final String DIY_JUMP_STEP = "diyJumpStep";
+    public static final String EXIT_DIY_BROWSING = "exitDiyBrowsing";
+    public static final String FUNCTION_NAME_REQUEST_CAMERA_PERMISSION = "requestCameraPermission";
+    public static final int MINI = 1;
+    public static final String OPEN_BLUETOOTH_CONNECT_PAGE = "openBluetoothPage";
+    public static final String OPEN_BLUETOOTH_DISCONNECT_PAGE = "openDisBluetoothPage";
+    public static final String OPEN_CONTROLLER = "openController";
+    public static final String POWER_STATUS_CHANGE = "PowerStatusChange";
+    private static final long serialVersionUID = 1;
+    private String customModelId;
+    private String modelName;
+    private final String TAG = "MyUnityListener";
+    private final String EXIT_ENGINE_ID = "ExitSetupSteeringEngineID";
+    private final String MOB_EVENT = "MobClickEvent";
+    private final String ACTION_AUDIO = "playActionAudio";
+    private final String SETHARDWARE = "setHardwareBack";
+    private final String DIYSERVOSETTINGBACK = "diyServoSettingBack";
+    private final String AUDIO_PLAY = "Play";
+    private final String AUDIO_PAUSE = "Pause";
+    private final String AUDIO_CONTINUE = "Continue";
+    private final String AUDIO_STOP = "Stop";
+    private final String BACK_COURSE_MENU = "backCourseMenu";
+    private final String FINISH_LOADING = "closeWaitingPage";
+
+    public MyUnityListener(String str, String str2) {
+        this.modelName = str;
+        this.customModelId = str2;
+    }
+
+    private void back2Uri(UnityActivity unityActivity, Uri uri) {
+        Intent intent = new Intent("android.intent.action.VIEW", uri);
+        if (intent.resolveActivity(unityActivity.getPackageManager()) != null) {
+            unityActivity.setIsBack(true);
+            intent.addFlags(268435456);
+            unityActivity.startActivity(intent);
+        }
+        UbtActivityStack.getInstance().finishAllActivity();
+    }
+
+    private void backCourseMenu(final UnityActivity unityActivity, final String str) {
+        unityActivity.setIsBack(true);
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            if (jSONObject.has("blueState")) {
+                if (1 == jSONObject.getInt("blueState")) {
+                    IAccomplishEventListener iAccomplishEventListener = new IAccomplishEventListener() { // from class: com.ubt.jimu.unity.bluetooth.MyUnityListener.1
+                        @Override // com.ubt.jimu.discover.IAccomplishEventListener
+                        public void onPlayAgain(Course course) {
+                        }
+
+                        @Override // com.ubt.jimu.discover.IAccomplishEventListener
+                        public void onPlayContinue(Course course) {
+                            CourseListActivity.a(unityActivity, course, "AstroBot", str);
+                        }
+                    };
+                    AccomplishWithoutUserDialog a = AccomplishWithoutUserDialog.a(unityActivity.getCourse());
+                    a.a(iAccomplishEventListener);
+                    if (Cache.getInstance().getLoginUserIntId() <= 0) {
+                        a.show(unityActivity.getFragmentManager(), "course");
+                        CourseDbHandler.setCourseComplete(unityActivity.getCourse());
+                    } else if (Course.STATUS_COMPLETED.equals(unityActivity.getCourse().getStatus())) {
+                        a.show(unityActivity.getFragmentManager(), "course");
+                    } else {
+                        updateCourse(unityActivity, str);
+                    }
+                } else {
+                    CourseListActivity.start(unityActivity, "AstroBot");
+                }
+            }
+        } catch (JSONException e) {
+            e.printStackTrace();
+            Log.e("MyUnityListener", e.getMessage());
+        }
+    }
+
+    private void backToCaller(UnityActivity unityActivity, String str) {
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            String str2 = null;
+            try {
+                str2 = jSONObject.getString(CALLBACK);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+            if (!TextUtils.isEmpty(str2)) {
+                back2Uri(unityActivity, Uri.parse(str2));
+                return;
+            }
+            try {
+                if (1 == jSONObject.getInt(CALLER)) {
+                    back2Uri(unityActivity, Uri.parse("mini://alphamini/toycar"));
+                }
+            } catch (JSONException e2) {
+                e2.printStackTrace();
+            }
+        } catch (JSONException e3) {
+            e3.printStackTrace();
+        }
+    }
+
+    private void connectHelp(UnityActivity unityActivity, String str) {
+        String url = JimuConnectionException.getUrl(str);
+        if (TextUtils.isEmpty(url)) {
+            return;
+        }
+        int i = R.color.theme_background;
+        if (String.valueOf(JimuConnectionException.UNICORN_AR_HELP.getType()).equals(str)) {
+            i = R.color.bg_unicorn_ar_game_help;
+        }
+        unityActivity.showHelpFragment(url, " ", i);
+    }
+
+    private void deleteProgram(UnityActivity unityActivity, String str) {
+        BlocklyProject blocklyProject;
+        if (TextUtils.isEmpty(str) || (blocklyProject = (BlocklyProject) JsonHelper.b(str, BlocklyProject.class)) == null) {
+            return;
+        }
+        new BlocklyProjectDbHandler(DatabaseUtils.getDaoSession(true).a()).delete(blocklyProject);
+    }
+
+    private void finishLoading(UnityActivity unityActivity) {
+        unityActivity.hideWaitDialog();
+    }
+
+    private void jumpStep(UnityActivity unityActivity, String str) {
+        unityActivity.setIsBack(true);
+        if (TextUtils.isEmpty(str)) {
+            Log.e("MyUnityListener", "Unity 未传参数，at function diyJumpStep");
+            return;
+        }
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            int i = jSONObject.has(DiyBrowseActivity.STEP) ? jSONObject.getInt(DiyBrowseActivity.STEP) : -1;
+            if (i > (jSONObject.has("totalStep") ? jSONObject.getInt("totalStep") : 100)) {
+                DiyBrowseActivity.start(unityActivity, -1);
+            } else {
+                DiyBrowseActivity.start(unityActivity, i, UnityActivity.modelBrowse);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:23:0x006b, code lost:
+    
+        if (r2 == 1) goto L50;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:25:0x006f, code lost:
+    
+        if (r2 == 2) goto L37;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:26:0x0071, code lost:
+    
+        android.util.Log.e("MyUnityListener", "Unsupport data report type.");
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:27:0x0076, code lost:
+    
+        return;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:29:0x007b, code lost:
+    
+        if (android.text.TextUtils.isEmpty(r5) != false) goto L49;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:30:0x00b5, code lost:
+    
+        com.ubtrobot.ubtlib.analytics.JimuAnalytics.b().a(r10);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:31:?, code lost:
+    
+        return;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:33:0x007d, code lost:
+    
+        r1 = new org.json.JSONObject(r5);
+        r2 = r1.keys();
+        r3 = new java.util.HashMap();
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:35:0x008f, code lost:
+    
+        if (r2.hasNext() == false) goto L61;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:36:0x0091, code lost:
+    
+        r4 = r2.next();
+        r3.put(r4, java.lang.String.valueOf(r1.get(r4)));
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:38:0x00a3, code lost:
+    
+        com.ubtrobot.ubtlib.analytics.JimuAnalytics.b().a(r10, r3);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:40:?, code lost:
+    
+        return;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:41:0x00b0, code lost:
+    
+        r10 = move-exception;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:42:0x00b1, code lost:
+    
+        android.util.Log.e("MyUnityListener", "Parse data report event param fail!", r10);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:43:?, code lost:
+    
+        return;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:44:0x00ab, code lost:
+    
+        r10 = move-exception;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:45:0x00ac, code lost:
+    
+        android.util.Log.e("MyUnityListener", "Parse data report event param fail!", r10);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:46:?, code lost:
+    
+        return;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:47:0x00bd, code lost:
+    
+        com.ubtrobot.ubtlib.analytics.JimuAnalytics.b().b(r9, r10);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:48:?, code lost:
+    
+        return;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    private void onMobClickEvent(android.app.Activity r9, java.lang.String r10) {
+        /*
+            r8 = this;
+            java.lang.String r0 = "Parse data report event param fail!"
+            java.lang.String r1 = "type"
+            java.lang.String r2 = "params"
+            java.lang.String r3 = "eventName"
+            org.json.JSONObject r4 = new org.json.JSONObject     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            r4.<init>(r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            boolean r10 = r4.has(r3)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            r5 = 0
+            if (r10 == 0) goto L19
+            java.lang.String r10 = r4.getString(r3)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            goto L1a
+        L19:
+            r10 = r5
+        L1a:
+            boolean r3 = r4.has(r2)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            if (r3 == 0) goto L24
+            java.lang.String r5 = r4.getString(r2)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+        L24:
+            boolean r2 = android.text.TextUtils.isEmpty(r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            if (r2 == 0) goto L2b
+            return
+        L2b:
+            boolean r2 = r4.has(r1)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            if (r2 == 0) goto Ld6
+            java.lang.String r1 = r4.getString(r1)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            r2 = -1
+            int r3 = r1.hashCode()     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            r4 = -2122251988(0xffffffff8181012c, float:-4.73888E-38)
+            r6 = 2
+            r7 = 1
+            if (r3 == r4) goto L60
+            r4 = -1497377032(0xffffffffa6bfd6f8, float:-1.3311555E-15)
+            if (r3 == r4) goto L56
+            r4 = -152174785(0xfffffffff6edff3f, float:-2.4135769E33)
+            if (r3 == r4) goto L4c
+            goto L69
+        L4c:
+            java.lang.String r3 = "measure_page_time_start"
+            boolean r1 = r1.equals(r3)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            if (r1 == 0) goto L69
+            r2 = 0
+            goto L69
+        L56:
+            java.lang.String r3 = "measure_page_time_end"
+            boolean r1 = r1.equals(r3)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            if (r1 == 0) goto L69
+            r2 = 1
+            goto L69
+        L60:
+            java.lang.String r3 = "record_event"
+            boolean r1 = r1.equals(r3)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            if (r1 == 0) goto L69
+            r2 = 2
+        L69:
+            if (r2 == 0) goto Lc5
+            if (r2 == r7) goto Lbd
+            java.lang.String r9 = "MyUnityListener"
+            if (r2 == r6) goto L77
+            java.lang.String r10 = "Unsupport data report type."
+            android.util.Log.e(r9, r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            return
+        L77:
+            boolean r1 = android.text.TextUtils.isEmpty(r5)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            if (r1 != 0) goto Lb5
+            org.json.JSONObject r1 = new org.json.JSONObject     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            r1.<init>(r5)     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            java.util.Iterator r2 = r1.keys()     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            java.util.HashMap r3 = new java.util.HashMap     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            r3.<init>()     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+        L8b:
+            boolean r4 = r2.hasNext()     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            if (r4 == 0) goto La3
+            java.lang.Object r4 = r2.next()     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            java.lang.String r4 = (java.lang.String) r4     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            java.lang.Object r5 = r1.get(r4)     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            java.lang.String r5 = java.lang.String.valueOf(r5)     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            r3.put(r4, r5)     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            goto L8b
+        La3:
+            com.ubtrobot.ubtlib.analytics.JimuAnalytics r1 = com.ubtrobot.ubtlib.analytics.JimuAnalytics.b()     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            r1.a(r10, r3)     // Catch: java.lang.Exception -> Lab org.json.JSONException -> Lb0
+            goto Ld6
+        Lab:
+            r10 = move-exception
+            android.util.Log.e(r9, r0, r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            goto Ld6
+        Lb0:
+            r10 = move-exception
+            android.util.Log.e(r9, r0, r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            goto Ld6
+        Lb5:
+            com.ubtrobot.ubtlib.analytics.JimuAnalytics r9 = com.ubtrobot.ubtlib.analytics.JimuAnalytics.b()     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            r9.a(r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            goto Ld6
+        Lbd:
+            com.ubtrobot.ubtlib.analytics.JimuAnalytics r0 = com.ubtrobot.ubtlib.analytics.JimuAnalytics.b()     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            r0.b(r9, r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            goto Ld6
+        Lc5:
+            com.ubtrobot.ubtlib.analytics.JimuAnalytics r0 = com.ubtrobot.ubtlib.analytics.JimuAnalytics.b()     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            r0.a(r9, r10)     // Catch: java.lang.Exception -> Lcd org.json.JSONException -> Ld2
+            goto Ld6
+        Lcd:
+            r9 = move-exception
+            r9.printStackTrace()
+            goto Ld6
+        Ld2:
+            r9 = move-exception
+            r9.printStackTrace()
+        Ld6:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.ubt.jimu.unity.bluetooth.MyUnityListener.onMobClickEvent(android.app.Activity, java.lang.String):void");
+    }
+
+    private void onPowerStatusChange(UnityActivity unityActivity, String str) {
+        ConnectionStatus connectionStatus;
+        ALog.a("MyUnityListener").d("PowerStatusChange:" + str);
+        if (StringUtils.f(str)) {
+            SharePreferenceHelper sharePreferenceHelper = new SharePreferenceHelper();
+            int parseInt = Integer.parseInt(str);
+            sharePreferenceHelper.put(SharePreferenceHelper.SP_KEY_CONNECTION_STATUS, Integer.valueOf(parseInt));
+            if (parseInt == ConnectionStatus.CONNECTED.getStatus()) {
+                connectionStatus = ConnectionStatus.CONNECTED;
+                Cache.getInstance().setConnected(true);
+            } else if (parseInt == ConnectionStatus.CHARGING.getStatus()) {
+                connectionStatus = ConnectionStatus.CHARGING;
+                Cache.getInstance().setConnected(true);
+            } else if (parseInt == ConnectionStatus.LOW_BATTERY.getStatus()) {
+                connectionStatus = ConnectionStatus.LOW_BATTERY;
+                Cache.getInstance().setConnected(true);
+            } else if (parseInt == ConnectionStatus.DIS_CONNECT.getStatus()) {
+                connectionStatus = ConnectionStatus.DIS_CONNECT;
+                Cache.getInstance().setConnected(false);
+            } else {
+                connectionStatus = ConnectionStatus.DIS_CONNECT;
+                Cache.getInstance().setConnected(false);
+            }
+            EventBus.b().b(connectionStatus);
+        }
+    }
+
+    private void onUnitySetupSteeringEngineID(Context context, Object obj) {
+        context.startActivity(new Intent(context, (Class<?>) CommonSettingActivity.class));
+    }
+
+    private void openController(UnityActivity unityActivity, String str) {
+        RobotLite robotLite = new RobotLite(unityActivity.getModelServerId(), this.customModelId, this.modelName, unityActivity.getPicPath(), unityActivity.isDiy(), unityActivity.isCanEdit());
+        Postcard a = ARouter.b().a("/controller/control");
+        a.a("robotLite", robotLite);
+        a.t();
+    }
+
+    private void playActionAudio(Context context, String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            String string = jSONObject.has(FileDownloadModel.PATH) ? jSONObject.getString(FileDownloadModel.PATH) : null;
+            String string2 = jSONObject.has("state") ? jSONObject.getString("state") : null;
+            if (!TextUtils.isEmpty(string) && !TextUtils.isEmpty(string2)) {
+                if ("Play".equals(string2)) {
+                    AudioPlayer.getInstance().play(string);
+                    return;
+                }
+                if ("Pause".equals(string2)) {
+                    AudioPlayer.getInstance().pause();
+                    return;
+                }
+                if ("Continue".equals(string2)) {
+                    AudioPlayer.getInstance().play(string);
+                } else if ("Stop".equals(string2)) {
+                    AudioPlayer.getInstance().stop();
+                } else {
+                    Log.e("MyUnityListener", "playActionAudio未知指令");
+                }
+            }
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void updateCourse(final UnityActivity unityActivity, final String str) {
+        new CourseHelper(new CourseHelper.IUploadCourseListener() { // from class: com.ubt.jimu.unity.bluetooth.MyUnityListener.2
+            @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+            public void onFailed() {
+            }
+
+            @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+            public void onFinished() {
+                unityActivity.hideWaitDialog();
+            }
+
+            @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+            public void onStart() {
+            }
+
+            @Override // com.ubt.jimu.discover.CourseHelper.IUploadCourseListener
+            public void onSuccess(ActionResult actionResult) {
+                IAccomplishEventListener iAccomplishEventListener = new IAccomplishEventListener() { // from class: com.ubt.jimu.unity.bluetooth.MyUnityListener.2.1
+                    @Override // com.ubt.jimu.discover.IAccomplishEventListener
+                    public void onPlayAgain(Course course) {
+                    }
+
+                    @Override // com.ubt.jimu.discover.IAccomplishEventListener
+                    public void onPlayContinue(Course course) {
+                        AnonymousClass2 anonymousClass2 = AnonymousClass2.this;
+                        CourseListActivity.a(unityActivity, course, "AstroBot", str);
+                    }
+                };
+                AccomplishWithoutUserDialog a = AccomplishWithoutUserDialog.a(unityActivity.getCourse());
+                a.a(iAccomplishEventListener);
+                if (actionResult != null && actionResult.getCourse() != null && actionResult.getFlag() == 0) {
+                    a.show(unityActivity.getFragmentManager(), "course");
+                } else {
+                    CourseDbHandler.setCourseComplete(unityActivity.getCourse());
+                    AccomplishWithoutUserDialog.a(unityActivity.getCourse(), actionResult).a(unityActivity.getFragmentManager(), "course", actionResult);
+                }
+            }
+        }).a(unityActivity.getCourse().getId());
+    }
+
+    public void ActivationRobot(Activity activity, String str, String str2) {
+    }
+
+    public void BackThirdApp(UnityActivity unityActivity, int i, int i2) {
+        if (i == 1002) {
+            DiyFanActivity.start(unityActivity, DiyFanActivity.uuid);
+        }
+        if (i == 1016) {
+            ARouter.b().a("/game/list").t();
+            return;
+        }
+        switch (i) {
+            case 1004:
+                DiyFanActivity.start(unityActivity, DiyFanActivity.uuid);
+                break;
+            case 1005:
+                DiyBrowseActivity.start(unityActivity);
+                break;
+            case 1006:
+                DiyFanActivity.start(unityActivity, DiyFanActivity.uuid);
+                break;
+            case UnityActivity.CODE_BROWSE_PROGRAM /* 1007 */:
+                DiyBrowseActivity.start(unityActivity);
+                break;
+            default:
+                XLog.a("woo", "code: %d, back to main.", Integer.valueOf(i));
+                ARouter.b().a("/page/main").t();
+                break;
+        }
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    public boolean CallPlatformFunc(UnityActivity unityActivity, String str, String str2) {
+        char c;
+        switch (str.hashCode()) {
+            case -2050076729:
+                if (str.equals(POWER_STATUS_CHANGE)) {
+                    c = 7;
+                    break;
+                }
+                c = 65535;
+                break;
+            case -1919328147:
+                if (str.equals("ExitSetupSteeringEngineID")) {
+                    c = 0;
+                    break;
+                }
+                c = 65535;
+                break;
+            case -1888324428:
+                if (str.equals(CONNECT_HELP)) {
+                    c = 2;
+                    break;
+                }
+                c = 65535;
+                break;
+            case -1396674110:
+                if (str.equals(BACK_TO)) {
+                    c = 11;
+                    break;
+                }
+                c = 65535;
+                break;
+            case -1062118044:
+                if (str.equals("closeWaitingPage")) {
+                    c = 5;
+                    break;
+                }
+                c = 65535;
+                break;
+            case -472794318:
+                if (str.equals("diyServoSettingBack")) {
+                    c = '\t';
+                    break;
+                }
+                c = 65535;
+                break;
+            case -391605882:
+                if (str.equals(OPEN_CONTROLLER)) {
+                    c = 15;
+                    break;
+                }
+                c = 65535;
+                break;
+            case -224544655:
+                if (str.equals("setHardwareBack")) {
+                    c = '\b';
+                    break;
+                }
+                c = 65535;
+                break;
+            case -64738599:
+                if (str.equals(OPEN_BLUETOOTH_DISCONNECT_PAGE)) {
+                    c = '\r';
+                    break;
+                }
+                c = 65535;
+                break;
+            case 305771395:
+                if (str.equals(FUNCTION_NAME_REQUEST_CAMERA_PERMISSION)) {
+                    c = 16;
+                    break;
+                }
+                c = 65535;
+                break;
+            case 387715169:
+                if (str.equals("backCourseMenu")) {
+                    c = 4;
+                    break;
+                }
+                c = 65535;
+                break;
+            case 1238934579:
+                if (str.equals(OPEN_BLUETOOTH_CONNECT_PAGE)) {
+                    c = '\f';
+                    break;
+                }
+                c = 65535;
+                break;
+            case 1410900878:
+                if (str.equals("guideFinished")) {
+                    c = '\n';
+                    break;
+                }
+                c = 65535;
+                break;
+            case 1511122162:
+                if (str.equals("MobClickEvent")) {
+                    c = 1;
+                    break;
+                }
+                c = 65535;
+                break;
+            case 1549103980:
+                if (str.equals("playActionAudio")) {
+                    c = 3;
+                    break;
+                }
+                c = 65535;
+                break;
+            case 1623132324:
+                if (str.equals(DISCONNECT_BLE_CALLBACK)) {
+                    c = 6;
+                    break;
+                }
+                c = 65535;
+                break;
+            case 1687166567:
+                if (str.equals(ACTION_EDIT_BACK)) {
+                    c = 14;
+                    break;
+                }
+                c = 65535;
+                break;
+            default:
+                c = 65535;
+                break;
+        }
+        switch (c) {
+            case 0:
+                unityActivity.setIsBack(true);
+                onUnitySetupSteeringEngineID(unityActivity, str2);
+                return true;
+            case 1:
+                onMobClickEvent(unityActivity, str2);
+                return true;
+            case 2:
+                connectHelp(unityActivity, str2);
+                return true;
+            case 3:
+                playActionAudio(unityActivity, str2);
+                return true;
+            case 4:
+                backCourseMenu(unityActivity, str2);
+                return true;
+            case 5:
+                finishLoading(unityActivity);
+                return true;
+            case 6:
+                DiyFanActivity.startA(JimuApplication.l(), str2);
+                return true;
+            case 7:
+                onPowerStatusChange(unityActivity, str2);
+                return true;
+            case '\b':
+                LogUtils.d(str2);
+                unityActivity.setIsBack(true);
+                if (ExternalOverFroyoUtils.a(DiyFanActivity.uuid)) {
+                    DiyFanActivity.start(unityActivity, DiyFanActivity.uuid);
+                } else {
+                    ARouter.b().a("/diy/usercreatives").t();
+                }
+                return true;
+            case '\t':
+                DiyFanActivity.startA(unityActivity, str2);
+                return true;
+            case '\n':
+                LogUtils.d("guideFinished:" + str2);
+                if (str2.contains("build")) {
+                    SPUtils.b(Constant.NoviceGuide.GUIDANCE_KEY, 8);
+                }
+                if (str2.contains("action")) {
+                    SPUtils.b(Constant.NoviceGuide.GUIDANCE_KEY, 9);
+                }
+                return true;
+            case 11:
+                backToCaller(unityActivity, str2);
+                return true;
+            case '\f':
+                ALog.a("MyUnityListener").d("Unity open blue connect page");
+                unityActivity.setIsBack(true);
+                ConnectActivity.b(unityActivity, unityActivity.getCode(), true, new RobotLite(unityActivity.getModelServerId(), this.customModelId, this.modelName, unityActivity.getPicPath(), unityActivity.isDiy(), unityActivity.isCanEdit()));
+                return true;
+            case '\r':
+                ALog.a("MyUnityListener").d("Unity open blue disconnect page");
+                unityActivity.setIsBack(true);
+                ConnectActivity.c(unityActivity, unityActivity.getCode(), true, new RobotLite(unityActivity.getModelServerId(), this.customModelId, this.modelName, unityActivity.getPicPath(), unityActivity.isDiy(), unityActivity.isCanEdit()));
+                return true;
+            case 14:
+                unityActivity.setIsBack(true);
+                back2Controller(unityActivity, str2);
+                return true;
+            case 15:
+                unityActivity.setIsBack(true);
+                openController(unityActivity, str2);
+                return true;
+            case 16:
+                unityActivity.requestCameraPermission();
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public boolean CallPlatformFuncDiy(UnityActivity unityActivity, String str, String str2) {
+        char c;
+        int hashCode = str.hashCode();
+        if (hashCode == -1849946755) {
+            if (str.equals(EXIT_DIY_BROWSING)) {
+                c = 0;
+            }
+            c = 65535;
+        } else if (hashCode != -514160039) {
+            if (hashCode == 1685044430 && str.equals(DIY_JUMP_STEP)) {
+                c = 1;
+            }
+            c = 65535;
+        } else {
+            if (str.equals("deleteProgram")) {
+                c = 2;
+            }
+            c = 65535;
+        }
+        if (c == 0) {
+            unityActivity.setIsBack(true);
+            DiyBrowseActivity.start(unityActivity, -1);
+        } else if (c != 1) {
+            if (c != 2) {
+                return false;
+            }
+            deleteProgram(unityActivity, str2);
+        } else if (unityActivity.code != 1007) {
+            unityActivity.setIsBack(true);
+            jumpStep(unityActivity, str2);
+        }
+        return true;
+    }
+
+    public void back2Controller(UnityActivity unityActivity, String str) {
+        try {
+            String string = new JSONObject(str).getString(UnityActivity.KEY_ACTION_ID);
+            LogUtils.c("actionId:" + string);
+            Postcard a = ARouter.b().a("/controller/control");
+            a.a(UnityActivity.KEY_ACTION_ID, string);
+            a.t();
+        } catch (JSONException e) {
+            e.printStackTrace();
+            ARouter.b().a("/controller/control").t();
+        }
+    }
+}

sources/com/ubt/jimu/unity/bluetooth/UnityListener.java

@@ -0,0 +1,23 @@
+package com.ubt.jimu.unity.bluetooth;
+
+import android.app.Activity;
+import android.content.Context;
+import java.io.Serializable;
+
+@Deprecated
+/* loaded from: classes2.dex */
+public interface UnityListener extends Serializable {
+    void ActivationRobot(Activity activity, String str, String str2);
+
+    void BackThirdApp(Context context);
+
+    boolean CallPlatformFunc(UnityActivity unityActivity, String str, String str2);
+
+    void DelModel(String str);
+
+    void PublishModel(Context context, String str);
+
+    void SaveModel(String str, int i);
+
+    void SaveModelOrActions(String str);
+}