Initial commit

sources/com/ubt/jimu/controller/data/action/Action.java

@@ -0,0 +1,69 @@
+package com.ubt.jimu.controller.data.action;
+
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class Action {
+    private int a;
+    private int b;
+    private int c;
+    private Map<Integer, Integer> d;
+    private Map<Integer, TurnData> e;
+    private Map<Integer, MotorData> f;
+
+    public void a(int i) {
+        this.a = i;
+    }
+
+    public void a(List<Integer> list) {
+    }
+
+    public void b(int i) {
+        this.b = i;
+    }
+
+    public void c(int i) {
+        this.c = i;
+    }
+
+    public int d() {
+        return this.b;
+    }
+
+    public Map<Integer, TurnData> e() {
+        return this.e;
+    }
+
+    public int f() {
+        return this.c;
+    }
+
+    public String toString() {
+        return "Action{index=" + this.a + ", sportTime=" + this.b + ", waitTime=" + this.c + ", rotas=" + this.d + ", turns=" + this.e + ", motors=" + this.f + '}';
+    }
+
+    public void a(Map<Integer, MotorData> map) {
+        this.f = map;
+    }
+
+    public void b(Map<Integer, Integer> map) {
+        this.d = map;
+    }
+
+    public Map<Integer, Integer> c() {
+        return this.d;
+    }
+
+    public int a() {
+        return this.c + this.b;
+    }
+
+    public Map<Integer, MotorData> b() {
+        return this.f;
+    }
+
+    public void c(Map<Integer, TurnData> map) {
+        this.e = map;
+    }
+}

sources/com/ubt/jimu/controller/data/action/ActionIcon.java

@@ -0,0 +1,14 @@
+package com.ubt.jimu.controller.data.action;
+
+/* loaded from: classes.dex */
+public class ActionIcon {
+    private int a;
+
+    public ActionIcon(String str, int i) {
+        this.a = i;
+    }
+
+    public int a() {
+        return this.a;
+    }
+}

sources/com/ubt/jimu/controller/data/action/ActionSequence.java

@@ -0,0 +1,210 @@
+package com.ubt.jimu.controller.data.action;
+
+import android.text.TextUtils;
+import android.util.SparseArray;
+import com.ubt.jimu.base.data.Engine;
+import com.ubt.jimu.base.data.Motor;
+import com.ubt.jimu.base.data.Servo;
+import com.ubt.jimu.base.data.ServoMode;
+import com.ubt.jimu.controller.data.widget.JockstickDataConverter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class ActionSequence {
+    private static final HashMap<String, Integer> k = new HashMap<>();
+    private String a;
+    private String b;
+    private String c;
+    private List<Action> d;
+    private String e;
+    private SparseArray<String> f;
+    private long g;
+    private boolean h = false;
+    private int i;
+    private String j;
+
+    static {
+        k.put(Locale.CHINESE.getLanguage(), 0);
+        k.put("zh-hans", 0);
+        k.put(Locale.ENGLISH.getLanguage(), 1);
+        k.put(Locale.JAPANESE.getLanguage(), 2);
+        k.put(Locale.KOREAN.getLanguage(), 3);
+        k.put(Locale.GERMAN.getLanguage(), 4);
+        k.put(Locale.ITALIAN.getLanguage(), 5);
+        k.put(Locale.FRENCH.getLanguage(), 6);
+        k.put("es", 7);
+        k.put("pt", 8);
+        k.put("zh-hant", 9);
+        k.put("ar", 10);
+        k.put("ru", 11);
+        k.put("pl", 12);
+        k.put("tr", 13);
+        k.put("da", 14);
+        k.put("th", 15);
+        k.put(JockstickDataConverter.ID, 16);
+    }
+
+    public void a(int i) {
+        this.i = i;
+    }
+
+    public void b(String str) {
+        this.e = str;
+    }
+
+    public void c(String str) {
+        this.c = str;
+    }
+
+    public int d() {
+        return this.i;
+    }
+
+    public void e(String str) {
+        this.a = str;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ActionSequence)) {
+            return false;
+        }
+        ActionSequence actionSequence = (ActionSequence) obj;
+        String str = this.a;
+        if (str == null ? actionSequence.a != null : !str.equals(actionSequence.a)) {
+            return false;
+        }
+        String str2 = this.c;
+        String str3 = actionSequence.c;
+        return str2 != null ? str2.equals(str3) : str3 == null;
+    }
+
+    public void f(String str) {
+        this.b = str;
+    }
+
+    public String g() {
+        return this.j;
+    }
+
+    public String h() {
+        return this.a;
+    }
+
+    public int hashCode() {
+        String str = this.a;
+        int hashCode = (str != null ? str.hashCode() : 0) * 31;
+        String str2 = this.c;
+        return hashCode + (str2 != null ? str2.hashCode() : 0);
+    }
+
+    public List<Servo> i() {
+        List<Action> list = this.d;
+        if (list == null || list.size() <= 0) {
+            return null;
+        }
+        HashMap hashMap = new HashMap();
+        Iterator<Action> it = this.d.iterator();
+        while (it.hasNext()) {
+            Map<Integer, TurnData> e = it.next().e();
+            if (e != null && e.size() > 0) {
+                Iterator<Integer> it2 = e.keySet().iterator();
+                while (it2.hasNext()) {
+                    int intValue = it2.next().intValue();
+                    hashMap.put(Integer.valueOf(intValue), new Servo(intValue, ServoMode.SERVO_MODE_TURN));
+                }
+            }
+        }
+        if (hashMap.size() > 0) {
+            return new ArrayList(hashMap.values());
+        }
+        return null;
+    }
+
+    public boolean j() {
+        return this.h;
+    }
+
+    public String toString() {
+        return "ActionSequence{name='" + this.a + "', robotID='" + this.b + "', id='" + this.c + "', actions=" + this.d + ", icon='" + this.e + "', showName=" + this.f + ", createTime=" + this.g + ", isOfficial=" + this.h + ", iconResID=" + this.i + ", musicPath='" + this.j + "'}";
+    }
+
+    public List<Action> a() {
+        return this.d;
+    }
+
+    public long b() {
+        return this.g;
+    }
+
+    public String c() {
+        return this.e;
+    }
+
+    public void d(String str) {
+        this.j = str;
+    }
+
+    public String e() {
+        return this.c;
+    }
+
+    public List<Engine> f() {
+        List<Action> list = this.d;
+        if (list == null || list.size() <= 0) {
+            return null;
+        }
+        HashMap hashMap = new HashMap();
+        Iterator<Action> it = this.d.iterator();
+        while (it.hasNext()) {
+            Map<Integer, MotorData> b = it.next().b();
+            if (b != null && b.size() > 0) {
+                Iterator<Integer> it2 = b.keySet().iterator();
+                while (it2.hasNext()) {
+                    int intValue = it2.next().intValue();
+                    hashMap.put(Integer.valueOf(intValue), new Motor(intValue));
+                }
+            }
+        }
+        if (hashMap.size() > 0) {
+            return new ArrayList(hashMap.values());
+        }
+        return null;
+    }
+
+    public void a(Action action) {
+        if (this.d == null) {
+            this.d = new ArrayList();
+        }
+        this.d.add(action);
+    }
+
+    public void a(long j) {
+        this.g = j;
+    }
+
+    public void a(boolean z) {
+        this.h = z;
+    }
+
+    public void a(SparseArray<String> sparseArray) {
+        this.f = sparseArray;
+    }
+
+    public String a(String str) {
+        SparseArray<String> sparseArray;
+        Integer num = k.get(str);
+        if (num == null || (sparseArray = this.f) == null) {
+            return null;
+        }
+        String str2 = sparseArray.get(num.intValue());
+        return TextUtils.isEmpty(str2) ? this.f.get(k.get(Locale.ENGLISH.getLanguage()).intValue()) : str2;
+    }
+}

sources/com/ubt/jimu/controller/data/action/MotorData.java

@@ -0,0 +1,31 @@
+package com.ubt.jimu.controller.data.action;
+
+import com.twitter.sdk.android.core.TwitterAuthConfig;
+
+/* loaded from: classes.dex */
+public class MotorData extends TurnData {
+    private int c;
+
+    public MotorData(int i, int i2, int i3) {
+        super(i, i2);
+        this.c = i3;
+    }
+
+    public static int e() {
+        return TwitterAuthConfig.DEFAULT_AUTH_REQUEST_CODE;
+    }
+
+    @Override // com.ubt.jimu.controller.data.action.TurnData
+    public boolean d() {
+        return super.d() || this.c == 0;
+    }
+
+    public int f() {
+        return this.c;
+    }
+
+    @Override // com.ubt.jimu.controller.data.action.TurnData
+    public String toString() {
+        return super.toString() + " duration=" + this.c;
+    }
+}

sources/com/ubt/jimu/controller/data/action/RunningData.java

@@ -0,0 +1,77 @@
+package com.ubt.jimu.controller.data.action;
+
+import java.util.Iterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/* loaded from: classes.dex */
+public class RunningData {
+    private CopyOnWriteArrayList<RunningItem> a = new CopyOnWriteArrayList<>();
+
+    public synchronized void a(RunningItem runningItem) {
+        if (runningItem == null) {
+            return;
+        }
+        if (this.a.size() > 0) {
+            Iterator<RunningItem> it = this.a.iterator();
+            while (it.hasNext()) {
+                RunningItem next = it.next();
+                if (runningItem.b().equals(next.b()) && runningItem.a() == next.a()) {
+                    next.b(runningItem.c());
+                    return;
+                }
+            }
+        }
+        this.a.add(runningItem);
+    }
+
+    public synchronized boolean b(RunningItem runningItem) {
+        if (runningItem == null) {
+            return false;
+        }
+        int i = -1;
+        int i2 = 0;
+        while (true) {
+            if (i2 >= this.a.size()) {
+                break;
+            }
+            RunningItem runningItem2 = this.a.get(i2);
+            if (runningItem.b().equals(runningItem2.b()) && runningItem.a() == runningItem2.a()) {
+                i = i2;
+                break;
+            }
+            i2++;
+        }
+        if (i < 0) {
+            return false;
+        }
+        this.a.remove(i);
+        return true;
+    }
+
+    public synchronized boolean a(long j) {
+        boolean z;
+        z = true;
+        if (this.a != null && this.a.size() > 0) {
+            CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
+            Iterator<RunningItem> it = this.a.iterator();
+            while (it.hasNext()) {
+                RunningItem next = it.next();
+                if (next.a(j)) {
+                    copyOnWriteArrayList.add(next);
+                } else {
+                    z = false;
+                }
+            }
+            if (copyOnWriteArrayList.size() > 0) {
+                this.a.removeAll(copyOnWriteArrayList);
+            }
+        }
+        return z;
+    }
+
+    public synchronized void a() {
+        if (this.a != null) {
+            this.a.clear();
+        }
+    }
+}

sources/com/ubt/jimu/controller/data/action/RunningItem.java

@@ -0,0 +1,38 @@
+package com.ubt.jimu.controller.data.action;
+
+import com.ubt.jimu.base.data.CtrlMotionType;
+
+/* loaded from: classes.dex */
+public class RunningItem {
+    private int a;
+    private CtrlMotionType b;
+    private long c;
+    private long d;
+
+    public RunningItem(int i, CtrlMotionType ctrlMotionType, long j, long j2) {
+        this.a = i;
+        this.b = ctrlMotionType;
+        this.c = j;
+        this.d = j2;
+    }
+
+    public boolean a(long j) {
+        return j - this.d > this.c;
+    }
+
+    public CtrlMotionType b() {
+        return this.b;
+    }
+
+    public long c() {
+        return this.d;
+    }
+
+    public int a() {
+        return this.a;
+    }
+
+    public void b(long j) {
+        this.d = j;
+    }
+}

sources/com/ubt/jimu/controller/data/action/TurnData.java

@@ -0,0 +1,45 @@
+package com.ubt.jimu.controller.data.action;
+
+/* loaded from: classes.dex */
+public class TurnData {
+    private int a;
+    private int b;
+
+    public TurnData(int i, int i2) {
+        this.a = i;
+        this.b = i2;
+    }
+
+    public static int e() {
+        return 658;
+    }
+
+    public int a() {
+        if (b() == 0) {
+            return 0;
+        }
+        if (b() == 1) {
+            return c();
+        }
+        if (b() == -1) {
+            return -c();
+        }
+        return 0;
+    }
+
+    public int b() {
+        return this.a;
+    }
+
+    public int c() {
+        return this.b;
+    }
+
+    public boolean d() {
+        return this.b * this.a == 0;
+    }
+
+    public String toString() {
+        return "TurnData{direction=" + this.a + ", speed=" + this.b + '}';
+    }
+}

sources/com/ubt/jimu/controller/data/bean/AddDirectionItemBean.java

@@ -0,0 +1,41 @@
+package com.ubt.jimu.controller.data.bean;
+
+/* loaded from: classes.dex */
+public class AddDirectionItemBean {
+    private int a;
+    private String b;
+    private ItemType c;
+
+    public enum ItemType {
+        TOW_WHEEL,
+        FOUR_WHEEL,
+        H_SLIDER,
+        V_SLIDER,
+        ACCUMULATOR,
+        SIX_WHEEL
+    }
+
+    public int a() {
+        return this.a;
+    }
+
+    public String b() {
+        return this.b;
+    }
+
+    public ItemType c() {
+        return this.c;
+    }
+
+    public void a(int i) {
+        this.a = i;
+    }
+
+    public void a(String str) {
+        this.b = str;
+    }
+
+    public void a(ItemType itemType) {
+        this.c = itemType;
+    }
+}

sources/com/ubt/jimu/controller/data/command/AccumulatorGear.java

@@ -0,0 +1,42 @@
+package com.ubt.jimu.controller.data.command;
+
+/* loaded from: classes.dex */
+public class AccumulatorGear {
+    public static int a(float f, int i) {
+        float f2;
+        float f3;
+        float f4;
+        float f5;
+        float f6;
+        float f7;
+        if (f < 0.2f) {
+            return 0;
+        }
+        float f8 = 0.4f;
+        if (f >= 0.4f) {
+            if (0.4f > f || f >= 0.6f) {
+                f8 = 0.8f;
+                if (0.6f > f || f >= 0.8f) {
+                    f2 = i;
+                    f3 = 384.0f;
+                    f4 = 96.0f;
+                } else {
+                    f2 = i;
+                    f5 = 320.0f;
+                    f6 = (f - 0.6f) * 64.0f;
+                }
+            } else {
+                f2 = i;
+                f3 = 274.0f;
+                f4 = 46.0f;
+            }
+            f7 = (((f - f8) * f4) / 0.2f) + f3;
+            return (int) ((f2 / f7) * 1000.0f);
+        }
+        f2 = i;
+        f5 = 192.0f;
+        f6 = (f - 0.2f) * 82.0f;
+        f7 = (f6 / 0.2f) + f5;
+        return (int) ((f2 / f7) * 1000.0f);
+    }
+}

sources/com/ubt/jimu/controller/data/command/ActionSequenceTask.java

@@ -0,0 +1,149 @@
+package com.ubt.jimu.controller.data.command;
+
+import android.media.MediaPlayer;
+import android.os.SystemClock;
+import android.text.TextUtils;
+import com.ubt.jimu.base.data.CtrlMotionType;
+import com.ubt.jimu.controller.data.action.Action;
+import com.ubt.jimu.controller.data.action.ActionSequence;
+import com.ubt.jimu.controller.data.action.MotorData;
+import com.ubt.jimu.controller.data.action.RunningData;
+import com.ubt.jimu.controller.data.action.RunningItem;
+import com.ubt.jimu.controller.data.action.TurnData;
+import com.ubt.jimu.controller.manager.ICommandExecutor;
+import com.ubtech.utils.XLog;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/* loaded from: classes.dex */
+public class ActionSequenceTask implements Runnable {
+    private ActionSequence a;
+    private ICommandExecutor b;
+    private MediaPlayer c;
+    private volatile boolean e = false;
+    private volatile boolean f = false;
+    private volatile boolean g = true;
+    private RunningData d = new RunningData();
+
+    public ActionSequenceTask(ActionSequence actionSequence, ICommandExecutor iCommandExecutor) {
+        this.a = actionSequence;
+        this.b = iCommandExecutor;
+    }
+
+    private void a(Map<Integer, ? extends TurnData> map) {
+        if (map == null || map.size() <= 0) {
+            return;
+        }
+        long elapsedRealtime = SystemClock.elapsedRealtime();
+        Iterator<Integer> it = map.keySet().iterator();
+        while (it.hasNext()) {
+            int intValue = it.next().intValue();
+            TurnData turnData = map.get(Integer.valueOf(intValue));
+            CtrlMotionType ctrlMotionType = CtrlMotionType.servo;
+            long j = Long.MAX_VALUE;
+            if (turnData instanceof MotorData) {
+                ctrlMotionType = CtrlMotionType.motor;
+                j = ((MotorData) turnData).f();
+            }
+            if (turnData.d()) {
+                this.d.b(new RunningItem(intValue, ctrlMotionType, j, elapsedRealtime));
+            } else {
+                this.d.a(new RunningItem(intValue, ctrlMotionType, j, elapsedRealtime));
+            }
+        }
+    }
+
+    private synchronized void b() {
+        if (this.c != null) {
+            this.c.stop();
+            this.c.release();
+            this.c = null;
+        }
+    }
+
+    public void cancel() {
+        this.g = false;
+        this.f = true;
+        b();
+        this.d.a();
+    }
+
+    public boolean g() {
+        boolean a = this.d.a(SystemClock.elapsedRealtime());
+        XLog.a("Controller", "mIsComplete:%b, mIsCancel:%b, runningData.isAllComplete:%b ", Boolean.valueOf(this.e), Boolean.valueOf(this.f), Boolean.valueOf(a));
+        return this.f || (this.e && a);
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        while (!this.f) {
+            if (!TextUtils.isEmpty(this.a.g())) {
+                a(this.a.g());
+            }
+            List<Action> a = this.a.a();
+            if (a != null && a.size() > 0) {
+                Iterator<Action> it = a.iterator();
+                while (true) {
+                    if (!it.hasNext()) {
+                        break;
+                    }
+                    Action next = it.next();
+                    if (!this.f) {
+                        Map<Integer, MotorData> b = next.b();
+                        if (b != null && b.size() > 0) {
+                            a(b);
+                            this.b.a(new TreeMap(b));
+                        }
+                        Map<Integer, TurnData> e = next.e();
+                        if (e != null && e.size() > 0) {
+                            a(e);
+                            this.b.b(new TreeMap(e));
+                        }
+                        Map<Integer, Integer> c = next.c();
+                        if (c != null && c.size() > 0 && this.b.a(new TreeMap(c), next.d(), next.f()) == -1) {
+                            this.f = true;
+                            this.g = false;
+                            break;
+                        } else {
+                            try {
+                                Thread.sleep(next.a());
+                            } catch (InterruptedException e2) {
+                                e2.printStackTrace();
+                                this.f = true;
+                                Thread.currentThread().interrupt();
+                            }
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+            if (!this.g) {
+                break;
+            }
+        }
+        this.e = true;
+    }
+
+    private synchronized void a(String str) {
+        this.c = new MediaPlayer();
+        try {
+            this.c.setDataSource(str);
+            this.c.prepare();
+            this.c.start();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void a(boolean z) {
+        this.g = z;
+    }
+
+    public ActionSequence a() {
+        return this.a;
+    }
+}

sources/com/ubt/jimu/controller/data/command/AngleCommand.java

@@ -0,0 +1,26 @@
+package com.ubt.jimu.controller.data.command;
+
+import com.ubt.jimu.controller.manager.ICommandExecutor;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class AngleCommand extends MoveCommand {
+    private Map<Integer, Integer> a;
+    private int b;
+    private int c;
+
+    public AngleCommand(Map<Integer, Integer> map, int i, int i2) {
+        this.c = i;
+        this.a = map;
+        this.b = i2;
+    }
+
+    public int a() {
+        return this.c;
+    }
+
+    @Override // com.ubt.jimu.controller.data.command.MoveCommand
+    public void a(ICommandExecutor iCommandExecutor) {
+        iCommandExecutor.a(this.a, a(), this.b);
+    }
+}

sources/com/ubt/jimu/controller/data/command/Gear.java

@@ -0,0 +1,36 @@
+package com.ubt.jimu.controller.data.command;
+
+import com.twitter.sdk.android.core.TwitterAuthConfig;
+import com.ubtrobot.jimu.robotapi.PeripheralType;
+
+/* loaded from: classes.dex */
+public enum Gear {
+    EMPTY(0, PeripheralType.SERVO, 0),
+    FIRST(1, 234, 60),
+    SECOND(2, 340, 80),
+    THIRD(3, 446, 100),
+    FOURTH(4, 552, 120),
+    FIFTH(5, 658, TwitterAuthConfig.DEFAULT_AUTH_REQUEST_CODE);
+
+    private int level;
+    private int motorSpeed;
+    private int turnSpeed;
+
+    Gear(int i, int i2, int i3) {
+        this.level = i;
+        this.turnSpeed = i2;
+        this.motorSpeed = i3;
+    }
+
+    public static int getCount() {
+        return 5;
+    }
+
+    public int getMotorSpeed() {
+        return this.motorSpeed;
+    }
+
+    public int getTurnSpeed() {
+        return this.turnSpeed;
+    }
+}

sources/com/ubt/jimu/controller/data/command/MotorCommand.java

@@ -0,0 +1,19 @@
+package com.ubt.jimu.controller.data.command;
+
+import com.ubt.jimu.controller.data.action.MotorData;
+import com.ubt.jimu.controller.manager.ICommandExecutor;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class MotorCommand extends MoveCommand {
+    private Map<Integer, MotorData> a;
+
+    public MotorCommand(Map<Integer, MotorData> map) {
+        this.a = map;
+    }
+
+    @Override // com.ubt.jimu.controller.data.command.MoveCommand
+    public void a(ICommandExecutor iCommandExecutor) {
+        iCommandExecutor.a(this.a);
+    }
+}

sources/com/ubt/jimu/controller/data/command/MoveCommand.java

@@ -0,0 +1,8 @@
+package com.ubt.jimu.controller.data.command;
+
+import com.ubt.jimu.controller.manager.ICommandExecutor;
+
+/* loaded from: classes.dex */
+public abstract class MoveCommand {
+    public abstract void a(ICommandExecutor iCommandExecutor);
+}

sources/com/ubt/jimu/controller/data/command/MoveTask.java

@@ -0,0 +1,19 @@
+package com.ubt.jimu.controller.data.command;
+
+import com.ubt.jimu.controller.manager.ICommandExecutor;
+
+/* loaded from: classes.dex */
+public class MoveTask implements Runnable {
+    private MoveCommand a;
+    private ICommandExecutor b;
+
+    public MoveTask(MoveCommand moveCommand, ICommandExecutor iCommandExecutor) {
+        this.a = moveCommand;
+        this.b = iCommandExecutor;
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        this.a.a(this.b);
+    }
+}

sources/com/ubt/jimu/controller/data/command/ShootCommand.java

@@ -0,0 +1,34 @@
+package com.ubt.jimu.controller.data.command;
+
+import com.ubt.jimu.controller.data.config.AccumulatorConfig;
+import com.ubt.jimu.controller.manager.ICommandExecutor;
+import java.util.HashMap;
+
+/* loaded from: classes.dex */
+public class ShootCommand extends MoveCommand {
+    private AccumulatorConfig a;
+    private int b;
+
+    public ShootCommand(AccumulatorConfig accumulatorConfig, int i) {
+        this.a = accumulatorConfig;
+        this.b = i;
+    }
+
+    @Override // com.ubt.jimu.controller.data.command.MoveCommand
+    public void a(ICommandExecutor iCommandExecutor) {
+        if (this.a != null) {
+            HashMap hashMap = new HashMap(1);
+            hashMap.put(Integer.valueOf(this.a.getServoID()), Integer.valueOf(this.a.getLaunchAngle() + 120));
+            if (iCommandExecutor.a(hashMap, this.b, 0) == 0) {
+                try {
+                    Thread.sleep(this.b);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                    Thread.currentThread().interrupt();
+                }
+                hashMap.put(Integer.valueOf(this.a.getServoID()), Integer.valueOf(this.a.getStartAngle() + 120));
+                iCommandExecutor.a(hashMap, 100, 0);
+            }
+        }
+    }
+}

sources/com/ubt/jimu/controller/data/command/TurnCommand.java

@@ -0,0 +1,19 @@
+package com.ubt.jimu.controller.data.command;
+
+import com.ubt.jimu.controller.data.action.TurnData;
+import com.ubt.jimu.controller.manager.ICommandExecutor;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class TurnCommand extends MoveCommand {
+    private Map<Integer, TurnData> a;
+
+    public TurnCommand(Map<Integer, TurnData> map) {
+        this.a = map;
+    }
+
+    @Override // com.ubt.jimu.controller.data.command.MoveCommand
+    public void a(ICommandExecutor iCommandExecutor) {
+        iCommandExecutor.b(this.a);
+    }
+}

sources/com/ubt/jimu/controller/data/config/AccumulatorConfig.java

@@ -0,0 +1,78 @@
+package com.ubt.jimu.controller.data.config;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.ubt.jimu.controller.data.widget.AccumulatorData;
+
+@XStreamAlias("XLSliderConfig")
+/* loaded from: classes.dex */
+public class AccumulatorConfig extends WidgetConfig<AccumulatorData> {
+    private int launchAngle;
+    private int servoID;
+    private int startAngle;
+
+    public AccumulatorConfig() {
+        this.startAngle = WidgetConfig.MIN_ANGLE;
+        this.launchAngle = 118;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof AccumulatorConfig)) {
+            return false;
+        }
+        AccumulatorConfig accumulatorConfig = (AccumulatorConfig) obj;
+        return this.servoID == accumulatorConfig.servoID && this.startAngle == accumulatorConfig.startAngle && this.launchAngle == accumulatorConfig.launchAngle;
+    }
+
+    public int getLaunchAngle() {
+        return this.launchAngle;
+    }
+
+    public int getServoID() {
+        return this.servoID;
+    }
+
+    public int getStartAngle() {
+        return this.startAngle;
+    }
+
+    public int hashCode() {
+        return (((this.servoID * 31) + this.startAngle) * 31) + this.launchAngle;
+    }
+
+    public void setLaunchAngle(int i) {
+        this.launchAngle = i;
+    }
+
+    public void setServoID(int i) {
+        this.servoID = i;
+    }
+
+    public void setStartAngle(int i) {
+        this.startAngle = i;
+    }
+
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public String toString() {
+        return "AccumulatorConfig{servoID=" + this.servoID + ", startAngle=" + this.startAngle + ", launchAngle=" + this.launchAngle + "} " + super.toString();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public AccumulatorData encapData() {
+        AccumulatorData accumulatorData = new AccumulatorData();
+        accumulatorData.setConfig(this);
+        return accumulatorData;
+    }
+
+    public AccumulatorConfig(String str, int i, int i2, int i3) {
+        super(str);
+        this.startAngle = WidgetConfig.MIN_ANGLE;
+        this.launchAngle = 118;
+        this.servoID = i;
+        this.startAngle = i2;
+        this.launchAngle = i3;
+    }
+}

sources/com/ubt/jimu/controller/data/config/HSliderConfig.java

@@ -0,0 +1,82 @@
+package com.ubt.jimu.controller.data.config;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.ubt.jimu.controller.data.widget.HSliderWidgetData;
+
+@XStreamAlias("HSliderConfig")
+/* loaded from: classes.dex */
+public class HSliderConfig extends WidgetConfig<HSliderWidgetData> {
+    private int maxAngle;
+    private int minAngle;
+    private int servoID;
+
+    public HSliderConfig() {
+        this.minAngle = WidgetConfig.MIN_ANGLE;
+        this.maxAngle = 118;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof HSliderConfig)) {
+            return false;
+        }
+        HSliderConfig hSliderConfig = (HSliderConfig) obj;
+        return this.servoID == hSliderConfig.servoID && this.minAngle == hSliderConfig.minAngle && this.maxAngle == hSliderConfig.maxAngle;
+    }
+
+    public int getMaxAngle() {
+        return this.maxAngle;
+    }
+
+    public int getMinAngle() {
+        return this.minAngle;
+    }
+
+    public int getServoID() {
+        return this.servoID;
+    }
+
+    public int hashCode() {
+        return (((this.servoID * 31) + this.minAngle) * 31) + this.maxAngle;
+    }
+
+    public void setMaxAngle(int i) {
+        this.maxAngle = i;
+    }
+
+    public void setMinAngle(int i) {
+        this.minAngle = i;
+    }
+
+    public void setServoID(int i) {
+        this.servoID = i;
+    }
+
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(" servoID=" + this.servoID);
+        sb.append(" minAngle=" + this.minAngle);
+        sb.append(" maxAngle=" + this.maxAngle);
+        return super.toString() + sb.toString();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public HSliderWidgetData encapData() {
+        HSliderWidgetData hSliderWidgetData = new HSliderWidgetData();
+        hSliderWidgetData.setConfig(this);
+        return hSliderWidgetData;
+    }
+
+    public HSliderConfig(String str, int i, int i2, int i3) {
+        super(str);
+        this.minAngle = WidgetConfig.MIN_ANGLE;
+        this.maxAngle = 118;
+        this.servoID = i;
+        this.minAngle = i2;
+        this.maxAngle = i3;
+    }
+}

sources/com/ubt/jimu/controller/data/config/JockstickConfig.java

@@ -0,0 +1,293 @@
+package com.ubt.jimu.controller.data.config;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamImplicit;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.base.data.CtrlMotionType;
+import com.ubt.jimu.controller.data.widget.JockstickData;
+import com.ubt.jimu.controller.data.widget.JockstickDataConverter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+@XStreamAlias("JockstickConfig")
+/* loaded from: classes.dex */
+public class JockstickConfig extends WidgetConfig<JockstickData> {
+    private int index;
+
+    @XStreamOmitField
+    private Map<Integer, Wheel> mTempWheelMap;
+    private CtrlMotionType motionType;
+    private JockType type;
+
+    @XStreamImplicit(itemFieldName = JockstickDataConverter.WHEEL)
+    private List<Wheel> wheelList;
+
+    public enum JockType {
+        twoServo,
+        treeServo,
+        fourServo,
+        sixServo,
+        none
+    }
+
+    public JockstickConfig() {
+        this.type = JockType.twoServo;
+        this.motionType = CtrlMotionType.servo;
+    }
+
+    static /* synthetic */ int a(Wheel wheel, Wheel wheel2) {
+        if (wheel == null && wheel2 == null) {
+            return 0;
+        }
+        if (wheel == null) {
+            return -1;
+        }
+        if (wheel2 == null) {
+            return 1;
+        }
+        return wheel.getPosition() - wheel2.getPosition();
+    }
+
+    private boolean checkValid(int i) {
+        List<Wheel> list = this.wheelList;
+        if (list == null || list.size() < i) {
+            return false;
+        }
+        for (Wheel wheel : this.wheelList) {
+            if (wheel == null || wheel.getId() <= 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void copyList2Map(List<Wheel> list, Map<Integer, Wheel> map) {
+        for (Wheel wheel : list) {
+            if (wheel != null) {
+                map.put(Integer.valueOf(wheel.getPosition()), wheel);
+            }
+        }
+    }
+
+    private void sortWheelList(List<Wheel> list) {
+        Collections.sort(list, new Comparator() { // from class: com.ubt.jimu.controller.data.config.a
+            @Override // java.util.Comparator
+            public final int compare(Object obj, Object obj2) {
+                return JockstickConfig.a((Wheel) obj, (Wheel) obj2);
+            }
+        });
+    }
+
+    public void checkEngineExist(int i) {
+        List<Wheel> list;
+        if (i == 0 || (list = this.wheelList) == null || list.size() <= 0) {
+            return;
+        }
+        for (Wheel wheel : new ArrayList(this.wheelList)) {
+            if (wheel != null && wheel.getId() == i) {
+                this.wheelList.remove(wheel);
+                this.mTempWheelMap.remove(Integer.valueOf(wheel.getPosition()));
+                return;
+            }
+        }
+    }
+
+    public JockstickConfig cloneJockstickConfig() {
+        JockstickConfig jockstickConfig = new JockstickConfig();
+        List<Wheel> list = this.wheelList;
+        if (list != null && list.size() > 0) {
+            ArrayList arrayList = new ArrayList(this.wheelList.size());
+            Iterator<Wheel> it = this.wheelList.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next());
+            }
+            jockstickConfig.setWheelList(arrayList);
+        }
+        jockstickConfig.setType(this.type);
+        jockstickConfig.setMotionType(this.motionType);
+        jockstickConfig.setIndex(this.index);
+        return jockstickConfig;
+    }
+
+    public void emptyWheelList() {
+        List<Wheel> list = this.wheelList;
+        if (list != null) {
+            list.clear();
+        }
+        Map<Integer, Wheel> map = this.mTempWheelMap;
+        if (map != null) {
+            map.clear();
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof JockstickConfig)) {
+            return false;
+        }
+        JockstickConfig jockstickConfig = (JockstickConfig) obj;
+        if (this.type != jockstickConfig.type || this.motionType != jockstickConfig.motionType) {
+            return false;
+        }
+        List<Wheel> list = this.wheelList;
+        if (list == null) {
+            return jockstickConfig.wheelList == null;
+        }
+        sortWheelList(list);
+        List<Wheel> list2 = jockstickConfig.wheelList;
+        if (list2 == null) {
+            return false;
+        }
+        sortWheelList(list2);
+        return this.wheelList.equals(jockstickConfig.wheelList);
+    }
+
+    public int getIndex() {
+        return this.index;
+    }
+
+    public CtrlMotionType getMotionType() {
+        return this.motionType;
+    }
+
+    public List<Integer> getServoList() {
+        ArrayList arrayList = new ArrayList();
+        List<Wheel> list = this.wheelList;
+        if (list != null && list.size() > 0) {
+            for (Wheel wheel : this.wheelList) {
+                if (wheel != null && wheel.getId() > 0) {
+                    arrayList.add(Integer.valueOf(wheel.getId()));
+                }
+            }
+        }
+        return arrayList;
+    }
+
+    public JockType getType() {
+        return this.type;
+    }
+
+    public Wheel getWheel(int i) {
+        Map<Integer, Wheel> map;
+        List<Wheel> list;
+        if (this.mTempWheelMap == null && (list = this.wheelList) != null && list.size() > 0) {
+            this.mTempWheelMap = new HashMap(this.wheelList.size());
+            copyList2Map(this.wheelList, this.mTempWheelMap);
+        }
+        if (i <= 0 || (map = this.mTempWheelMap) == null) {
+            return null;
+        }
+        return map.get(Integer.valueOf(i));
+    }
+
+    public List<Wheel> getWheelList() {
+        return this.wheelList;
+    }
+
+    public int hashCode() {
+        JockType jockType = this.type;
+        int hashCode = (jockType != null ? jockType.hashCode() : 0) * 31;
+        CtrlMotionType ctrlMotionType = this.motionType;
+        int hashCode2 = (hashCode + (ctrlMotionType != null ? ctrlMotionType.hashCode() : 0)) * 31;
+        List<Wheel> list = this.wheelList;
+        return hashCode2 + (list != null ? list.hashCode() : 0);
+    }
+
+    public boolean isOK() {
+        JockType jockType = this.type;
+        if (jockType == JockType.none) {
+            return false;
+        }
+        if (jockType == JockType.twoServo) {
+            return checkValid(2);
+        }
+        if (jockType == JockType.fourServo) {
+            return checkValid(4);
+        }
+        if (jockType == JockType.sixServo) {
+            return checkValid(6);
+        }
+        return false;
+    }
+
+    public void putWheel(int i, Wheel wheel) {
+        if (this.mTempWheelMap == null) {
+            this.mTempWheelMap = new HashMap();
+        }
+        if (this.wheelList == null) {
+            this.wheelList = new ArrayList();
+        }
+        if (i > 0) {
+            this.mTempWheelMap.put(Integer.valueOf(i), wheel);
+            List<Wheel> list = this.wheelList;
+            if (list != null && list.size() > 0) {
+                for (Wheel wheel2 : new ArrayList(this.wheelList)) {
+                    if (wheel2.getId() == wheel.getId() || wheel2.getPosition() == i) {
+                        this.wheelList.remove(wheel2);
+                    }
+                }
+            }
+            this.wheelList.add(wheel);
+        }
+    }
+
+    public void setIndex(int i) {
+        this.index = i;
+    }
+
+    public void setMotionType(CtrlMotionType ctrlMotionType) {
+        this.motionType = ctrlMotionType;
+    }
+
+    public void setType(JockType jockType) {
+        this.type = jockType;
+    }
+
+    public void setWheelList(List<Wheel> list) {
+        this.wheelList = list;
+        if (list == null || list.size() <= 0) {
+            Map<Integer, Wheel> map = this.mTempWheelMap;
+            if (map != null) {
+                map.clear();
+                return;
+            }
+            return;
+        }
+        if (this.mTempWheelMap == null) {
+            this.mTempWheelMap = new HashMap(list.size());
+            for (Wheel wheel : list) {
+                if (wheel != null) {
+                    this.mTempWheelMap.put(Integer.valueOf(wheel.getPosition()), wheel);
+                }
+            }
+        }
+    }
+
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public String toString() {
+        return "JockstickConfig{type=" + this.type + ", motionType=" + this.motionType + ", index=" + this.index + ", wheelList=" + this.wheelList + "} " + super.toString();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public JockstickData encapData() {
+        JockstickData jockstickData = new JockstickData();
+        jockstickData.setConfig(this);
+        return jockstickData;
+    }
+
+    public JockstickConfig(String str, JockType jockType, CtrlMotionType ctrlMotionType) {
+        super(str);
+        this.type = JockType.twoServo;
+        this.motionType = CtrlMotionType.servo;
+        this.motionType = ctrlMotionType;
+        this.type = jockType;
+    }
+}

sources/com/ubt/jimu/controller/data/config/SliderConfig.java

@@ -0,0 +1,84 @@
+package com.ubt.jimu.controller.data.config;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.ubt.jimu.base.data.CtrlMotionType;
+import com.ubt.jimu.controller.data.widget.SliderWidgetData;
+
+@XStreamAlias("SliderConfig")
+/* loaded from: classes.dex */
+public class SliderConfig extends WidgetConfig<SliderWidgetData> {
+    private boolean directionDisclock;
+    private CtrlMotionType motionType;
+    private int servoID;
+
+    public SliderConfig() {
+        this.motionType = CtrlMotionType.servo;
+        this.directionDisclock = false;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof SliderConfig)) {
+            return false;
+        }
+        SliderConfig sliderConfig = (SliderConfig) obj;
+        return this.servoID == sliderConfig.servoID && this.directionDisclock == sliderConfig.directionDisclock && this.motionType == sliderConfig.motionType;
+    }
+
+    public CtrlMotionType getMotionType() {
+        return this.motionType;
+    }
+
+    public int getServoID() {
+        return this.servoID;
+    }
+
+    public int hashCode() {
+        int i = this.servoID * 31;
+        CtrlMotionType ctrlMotionType = this.motionType;
+        return ((i + (ctrlMotionType != null ? ctrlMotionType.hashCode() : 0)) * 31) + (this.directionDisclock ? 1 : 0);
+    }
+
+    public boolean isDirectionDisclock() {
+        return this.directionDisclock;
+    }
+
+    public void setDirectionDisclock(boolean z) {
+        this.directionDisclock = z;
+    }
+
+    public void setMotionType(CtrlMotionType ctrlMotionType) {
+        this.motionType = ctrlMotionType;
+    }
+
+    public void setServoID(int i) {
+        this.servoID = i;
+    }
+
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(" servoID= " + getServoID());
+        sb.append(" motionType= " + getMotionType());
+        sb.append(" directionDisclock= " + isDirectionDisclock());
+        return super.toString() + sb.toString();
+    }
+
+    @Override // com.ubt.jimu.controller.data.config.WidgetConfig
+    public SliderWidgetData encapData() {
+        SliderWidgetData sliderWidgetData = new SliderWidgetData();
+        sliderWidgetData.setConfig(this);
+        return sliderWidgetData;
+    }
+
+    public SliderConfig(String str, CtrlMotionType ctrlMotionType, int i, boolean z) {
+        super(str);
+        this.motionType = CtrlMotionType.servo;
+        this.directionDisclock = false;
+        this.servoID = i;
+        this.motionType = ctrlMotionType;
+        this.directionDisclock = z;
+    }
+}

sources/com/ubt/jimu/controller/data/config/Wheel.java

@@ -0,0 +1,73 @@
+package com.ubt.jimu.controller.data.config;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
+import com.ubt.jimu.controller.data.widget.JockstickDataConverter;
+
+@XStreamAlias(JockstickDataConverter.WHEEL)
+/* loaded from: classes.dex */
+public class Wheel {
+
+    @XStreamAsAttribute
+    private int id;
+
+    @XStreamAsAttribute
+    private int position;
+
+    @XStreamAsAttribute
+    private boolean reverse;
+
+    public Wheel() {
+        this.reverse = false;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Wheel)) {
+            return false;
+        }
+        Wheel wheel = (Wheel) obj;
+        return this.id == wheel.id && this.position == wheel.position && this.reverse == wheel.reverse;
+    }
+
+    public int getId() {
+        return this.id;
+    }
+
+    public int getPosition() {
+        return this.position;
+    }
+
+    public int hashCode() {
+        return (((this.id * 31) + this.position) * 31) + (this.reverse ? 1 : 0);
+    }
+
+    public boolean isReverse() {
+        return this.reverse;
+    }
+
+    public void setId(int i) {
+        this.id = i;
+    }
+
+    public void setPosition(int i) {
+        this.position = i;
+    }
+
+    public void setReverse(boolean z) {
+        this.reverse = z;
+    }
+
+    public Wheel(int i, int i2) {
+        this.reverse = false;
+        this.id = i;
+        this.position = i2;
+    }
+
+    public Wheel(int i, int i2, boolean z) {
+        this(i, i2);
+        this.reverse = z;
+    }
+}

sources/com/ubt/jimu/controller/data/config/WidgetConfig.java

@@ -0,0 +1,76 @@
+package com.ubt.jimu.controller.data.config;
+
+import android.text.TextUtils;
+import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
+import com.ubt.jimu.controller.data.widget.MoveBaseData;
+import com.ubt.jimu.controller.util.IDGenerator;
+import java.io.Serializable;
+
+/* loaded from: classes.dex */
+public abstract class WidgetConfig<D extends MoveBaseData> implements Serializable {
+    public static final int CUSTOM = 2;
+    public static final int MAX_ANGLE = 118;
+    public static final int MIN_ANGLE = -118;
+    public static final int OFFICIAL = 1;
+
+    @XStreamAsAttribute
+    private String configID;
+
+    @XStreamAsAttribute
+    private int configType = 2;
+
+    @XStreamAsAttribute
+    private long updateTime;
+
+    public WidgetConfig() {
+        init();
+    }
+
+    private void init() {
+        long currentTimeMillis = System.currentTimeMillis();
+        this.configID = IDGenerator.a(currentTimeMillis);
+        this.updateTime = currentTimeMillis;
+    }
+
+    public abstract D encapData();
+
+    public String getConfigID() {
+        return this.configID;
+    }
+
+    public int getConfigType() {
+        return this.configType;
+    }
+
+    public long getUpdateTime() {
+        return this.updateTime;
+    }
+
+    public void setConfigID(String str) {
+        this.configID = str;
+    }
+
+    public void setConfigType(int i) {
+        this.configType = i;
+    }
+
+    public void setUpdateTime(long j) {
+        this.updateTime = j;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(" configID=" + this.configID);
+        sb.append(" configType=" + this.configType);
+        sb.append(" updateTime=" + this.updateTime);
+        return sb.toString();
+    }
+
+    public WidgetConfig(String str) {
+        if (TextUtils.isEmpty(str)) {
+            init();
+        } else {
+            this.configID = str;
+        }
+    }
+}

sources/com/ubt/jimu/controller/data/keymap/ButtonKey.java

@@ -0,0 +1,19 @@
+package com.ubt.jimu.controller.data.keymap;
+
+import com.ubt.jimu.controller.data.keymap.entity.Key;
+
+/* loaded from: classes.dex */
+public class ButtonKey extends Key {
+    public ButtonKey(String str) {
+        super(str, 1);
+    }
+
+    public static ButtonKey a(int i) {
+        for (PhysicalButton physicalButton : PhysicalButton.values()) {
+            if (physicalButton.getKeyCode() == i) {
+                return new ButtonKey(physicalButton.getName());
+            }
+        }
+        return null;
+    }
+}

sources/com/ubt/jimu/controller/data/keymap/JoyStick.java

@@ -0,0 +1,10 @@
+package com.ubt.jimu.controller.data.keymap;
+
+import com.ubt.jimu.controller.data.keymap.entity.Key;
+
+/* loaded from: classes.dex */
+public class JoyStick extends Key {
+    public JoyStick(String str) {
+        super(str, 2);
+    }
+}

sources/com/ubt/jimu/controller/data/keymap/KeyMap.java

@@ -0,0 +1,50 @@
+package com.ubt.jimu.controller.data.keymap;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.controller.data.keymap.entity.Key;
+
+@XStreamAlias("KeyMap")
+/* loaded from: classes.dex */
+public class KeyMap {
+
+    @XStreamAlias("ActionId")
+    private String a;
+
+    @XStreamAlias("Key")
+    private String b;
+
+    @XStreamOmitField
+    private int c;
+
+    public KeyMap() {
+        this.c = 1;
+    }
+
+    public String a() {
+        return this.a;
+    }
+
+    public String b() {
+        return this.b;
+    }
+
+    public int c() {
+        return this.c;
+    }
+
+    public String toString() {
+        return "keyName:" + this.b + " actionId:" + this.a + "keyType:" + this.c;
+    }
+
+    public void a(int i) {
+        this.c = i;
+    }
+
+    public KeyMap(Key key, String str) {
+        this.c = 1;
+        this.b = key.a();
+        this.c = key.b();
+        this.a = str;
+    }
+}

sources/com/ubt/jimu/controller/data/keymap/PhysicalButton.java

@@ -0,0 +1,40 @@
+package com.ubt.jimu.controller.data.keymap;
+
+/* loaded from: classes.dex */
+public enum PhysicalButton {
+    A(96),
+    B(97),
+    X(99),
+    Y(100),
+    L1(102),
+    L2(104),
+    R1(103),
+    R2(105),
+    DPAD_UP(19),
+    DPAD_DOWN(20),
+    DPAD_LEFT(21),
+    DPAD_RIGHT(22);
+
+    private int keyCode;
+
+    PhysicalButton(int i) {
+        this.keyCode = i;
+    }
+
+    public static PhysicalButton fromKeyCode(int i) {
+        for (PhysicalButton physicalButton : values()) {
+            if (physicalButton.getKeyCode() == i) {
+                return physicalButton;
+            }
+        }
+        return null;
+    }
+
+    public int getKeyCode() {
+        return this.keyCode;
+    }
+
+    public String getName() {
+        return toString();
+    }
+}

sources/com/ubt/jimu/controller/data/keymap/entity/GameControllerConfigData.java

@@ -0,0 +1,22 @@
+package com.ubt.jimu.controller.data.keymap.entity;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamImplicit;
+import java.util.ArrayList;
+import java.util.List;
+
+@XStreamAlias("GameControllerConfigData")
+/* loaded from: classes.dex */
+public class GameControllerConfigData {
+
+    @XStreamImplicit
+    private List<KeyMapData> a = new ArrayList();
+
+    public List<KeyMapData> a() {
+        return this.a;
+    }
+
+    public void a(List<KeyMapData> list) {
+        this.a = list;
+    }
+}

sources/com/ubt/jimu/controller/data/keymap/entity/Key.java

@@ -0,0 +1,21 @@
+package com.ubt.jimu.controller.data.keymap.entity;
+
+/* loaded from: classes.dex */
+public class Key {
+    private int a;
+    private String b;
+
+    public Key(String str, int i) {
+        this.a = 1;
+        this.b = str;
+        this.a = i;
+    }
+
+    public String a() {
+        return this.b;
+    }
+
+    public int b() {
+        return this.a;
+    }
+}

sources/com/ubt/jimu/controller/data/keymap/entity/KeyMapData.java

@@ -0,0 +1,38 @@
+package com.ubt.jimu.controller.data.keymap.entity;
+
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.ubt.jimu.controller.data.keymap.KeyMap;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+@XStreamAlias("KeyMapData")
+/* loaded from: classes.dex */
+public class KeyMapData {
+
+    @XStreamAlias("ButtonKeyMap")
+    private List<KeyMap> a = new ArrayList();
+
+    @XStreamAlias("JoystickKeyMap")
+    private List<KeyMap> b = new ArrayList();
+
+    public List<KeyMap> a() {
+        return this.a;
+    }
+
+    public List<KeyMap> b() {
+        Iterator<KeyMap> it = this.b.iterator();
+        while (it.hasNext()) {
+            it.next().a(2);
+        }
+        return this.b;
+    }
+
+    public void a(List<KeyMap> list) {
+        this.a = list;
+    }
+
+    public void b(List<KeyMap> list) {
+        this.b = list;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/AccumulatorData.java

@@ -0,0 +1,52 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import com.thoughtworks.xstream.annotations.XStreamConverter;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.R;
+import com.ubt.jimu.controller.data.config.AccumulatorConfig;
+
+@XStreamConverter(priority = 9999, value = AccumulatorDataConverter.class)
+/* loaded from: classes.dex */
+public class AccumulatorData extends MoveBaseData<AccumulatorConfig> {
+
+    @XStreamOmitField
+    private AccumulatorConfig config;
+
+    public AccumulatorData() {
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public String getShowName(Context context) {
+        return String.format(context.getResources().getString(R.string.servo_mode_servo_index), Integer.valueOf(getConfig().getServoID()));
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String getWidgetInfo(Context context) {
+        return String.format(context.getResources().getString(R.string.servo_mode_servo_index), Integer.valueOf(this.config.getServoID())) + "(" + this.config.getStartAngle() + "°~" + this.config.getLaunchAngle() + "°)";
+    }
+
+    public AccumulatorData(String str) {
+        super(str);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public AccumulatorConfig getConfig() {
+        return this.config;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public void setConfig(AccumulatorConfig accumulatorConfig) {
+        super.setConfig((AccumulatorData) accumulatorConfig);
+        this.config = accumulatorConfig;
+    }
+
+    public AccumulatorData(String str, float f, float f2) {
+        super(str, f, f2);
+    }
+
+    public AccumulatorData(String str, byte b, int i, int i2, float f, float f2) {
+        super(str, f, f2);
+    }
+}

sources/com/ubt/jimu/controller/data/widget/AccumulatorDataConverter.java

@@ -0,0 +1,112 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.text.TextUtils;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.ubt.jimu.controller.data.config.AccumulatorConfig;
+import com.ubtech.utils.XLog;
+
+/* loaded from: classes.dex */
+public class AccumulatorDataConverter implements Converter {
+    public static final String CONFIG_ID = "configID";
+    public static final String MAX_ANGLE = "max_angle";
+    public static final String MIN_ANGLE = "min_angle";
+    public static final String SERVO_ID = "servoID";
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return AccumulatorData.class.equals(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        AccumulatorData accumulatorData = (AccumulatorData) obj;
+        if (!TextUtils.isEmpty(accumulatorData.getWidgetId())) {
+            hierarchicalStreamWriter.addAttribute("widgetId", accumulatorData.getWidgetId());
+        }
+        AccumulatorConfig config = accumulatorData.getConfig();
+        if (config != null && !TextUtils.isEmpty(config.getConfigID())) {
+            hierarchicalStreamWriter.addAttribute("configID", config.getConfigID());
+        }
+        hierarchicalStreamWriter.startNode("pos_x");
+        hierarchicalStreamWriter.setValue(String.valueOf(accumulatorData.getPosX()));
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("pos_y");
+        hierarchicalStreamWriter.setValue(String.valueOf(accumulatorData.getPosY()));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String attribute = hierarchicalStreamReader.getAttribute("widgetId");
+        if (TextUtils.isEmpty(attribute)) {
+            attribute = hierarchicalStreamReader.getAttribute("widgetID");
+        }
+        AccumulatorData accumulatorData = new AccumulatorData(attribute);
+        AccumulatorConfig accumulatorConfig = new AccumulatorConfig();
+        String attribute2 = hierarchicalStreamReader.getAttribute("configID");
+        if (!TextUtils.isEmpty(attribute2)) {
+            accumulatorConfig.setConfigID(attribute2);
+        }
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String nodeName = hierarchicalStreamReader.getNodeName();
+            char c = 65535;
+            switch (nodeName.hashCode()) {
+                case -251140552:
+                    if (nodeName.equals("max_angle")) {
+                        c = 4;
+                        break;
+                    }
+                    break;
+                case 106854733:
+                    if (nodeName.equals("pos_x")) {
+                        c = 0;
+                        break;
+                    }
+                    break;
+                case 106854734:
+                    if (nodeName.equals("pos_y")) {
+                        c = 1;
+                        break;
+                    }
+                    break;
+                case 521338022:
+                    if (nodeName.equals("min_angle")) {
+                        c = 3;
+                        break;
+                    }
+                    break;
+                case 1984158196:
+                    if (nodeName.equals("servoID")) {
+                        c = 2;
+                        break;
+                    }
+                    break;
+            }
+            if (c == 0) {
+                accumulatorData.setPosX(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 1) {
+                accumulatorData.setPosY(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 2) {
+                Integer valueOf = Integer.valueOf(hierarchicalStreamReader.getValue());
+                if (valueOf != null && valueOf.intValue() > 0) {
+                    accumulatorConfig.setServoID(valueOf.intValue());
+                }
+            } else if (c == 3) {
+                accumulatorConfig.setStartAngle(Integer.valueOf(hierarchicalStreamReader.getValue()).intValue());
+            } else if (c != 4) {
+                XLog.b("woo", "Unknown node name : %s", hierarchicalStreamReader.getNodeName());
+            } else {
+                accumulatorConfig.setLaunchAngle(Integer.valueOf(hierarchicalStreamReader.getValue()).intValue());
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        accumulatorData.setConfig(accumulatorConfig);
+        return accumulatorData;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/ActionDataConverter.java

@@ -0,0 +1,105 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.text.TextUtils;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.ubt.jimu.unity.bluetooth.UnityActivity;
+import com.ubtech.utils.XLog;
+
+/* loaded from: classes.dex */
+public class ActionDataConverter implements Converter {
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return ActionWidgetData.class.equals(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        ActionWidgetData actionWidgetData = (ActionWidgetData) obj;
+        if (!TextUtils.isEmpty(actionWidgetData.getWidgetId())) {
+            hierarchicalStreamWriter.addAttribute("widgetId", actionWidgetData.getWidgetId());
+        }
+        hierarchicalStreamWriter.startNode("pos_x");
+        hierarchicalStreamWriter.setValue(String.valueOf(actionWidgetData.getPosX()));
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("pos_y");
+        hierarchicalStreamWriter.setValue(String.valueOf(actionWidgetData.getPosY()));
+        hierarchicalStreamWriter.endNode();
+        if (!TextUtils.isEmpty(actionWidgetData.getActionID())) {
+            hierarchicalStreamWriter.startNode(ActionWidgetData.ACTION_ID);
+            hierarchicalStreamWriter.setValue(String.valueOf(actionWidgetData.getActionID()));
+            hierarchicalStreamWriter.endNode();
+        }
+        if (TextUtils.isEmpty(actionWidgetData.getActionNm())) {
+            return;
+        }
+        hierarchicalStreamWriter.startNode(ActionWidgetData.ACTION_NM);
+        hierarchicalStreamWriter.setValue(String.valueOf(actionWidgetData.getActionNm()));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String attribute = hierarchicalStreamReader.getAttribute("widgetId");
+        if (TextUtils.isEmpty(attribute)) {
+            attribute = hierarchicalStreamReader.getAttribute("widgetID");
+        }
+        ActionWidgetData actionWidgetData = new ActionWidgetData(attribute);
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String nodeName = hierarchicalStreamReader.getNodeName();
+            char c = 65535;
+            switch (nodeName.hashCode()) {
+                case -1656172079:
+                    if (nodeName.equals(ActionWidgetData.ACTION_ID)) {
+                        c = 2;
+                        break;
+                    }
+                    break;
+                case -1656172047:
+                    if (nodeName.equals(UnityActivity.KEY_ACTION_ID)) {
+                        c = 3;
+                        break;
+                    }
+                    break;
+                case -1656171883:
+                    if (nodeName.equals(ActionWidgetData.ACTION_NM)) {
+                        c = 4;
+                        break;
+                    }
+                    break;
+                case 106854733:
+                    if (nodeName.equals("pos_x")) {
+                        c = 0;
+                        break;
+                    }
+                    break;
+                case 106854734:
+                    if (nodeName.equals("pos_y")) {
+                        c = 1;
+                        break;
+                    }
+                    break;
+            }
+            if (c == 0) {
+                actionWidgetData.setPosX(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 1) {
+                actionWidgetData.setPosY(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 2) {
+                actionWidgetData.setActionID(hierarchicalStreamReader.getValue());
+            } else if (c == 3) {
+                actionWidgetData.setActionID(hierarchicalStreamReader.getValue());
+            } else if (c != 4) {
+                XLog.b("woo", "Unknown node name : %s", hierarchicalStreamReader.getNodeName());
+            } else {
+                actionWidgetData.setActionNm(hierarchicalStreamReader.getValue());
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        return actionWidgetData;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/ActionWidgetData.java

@@ -0,0 +1,101 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import android.text.TextUtils;
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamConverter;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.R;
+import com.ubt.jimu.controller.data.action.ActionSequence;
+import com.ubt.jimu.utils.LocaleUtils;
+
+@XStreamAlias("actionData")
+@XStreamConverter(ActionDataConverter.class)
+/* loaded from: classes.dex */
+public class ActionWidgetData extends ItemBaseData {
+    public static final String ACTION_ID = "actionID";
+    public static final String ACTION_NM = "actionNm";
+    private String actionID;
+    private String actionNm;
+
+    @XStreamOmitField
+    private ActionSequence actionSequence;
+
+    public ActionWidgetData() {
+    }
+
+    public String getActionID() {
+        return this.actionID;
+    }
+
+    public String getActionNm() {
+        return this.actionNm;
+    }
+
+    public ActionSequence getActionSequence() {
+        return this.actionSequence;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public int getImageViewId() {
+        int d;
+        ActionSequence actionSequence = this.actionSequence;
+        return (actionSequence == null || (d = actionSequence.d()) <= 0) ? R.drawable.icon_loudly : d;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String getShowName(String str) {
+        ActionSequence actionSequence = this.actionSequence;
+        if (actionSequence != null) {
+            String a = actionSequence.a(str);
+            if (!TextUtils.isEmpty(a)) {
+                return a;
+            }
+        }
+        return this.actionNm;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String getWidgetInfo(Context context) {
+        return getShowName(LocaleUtils.b());
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public boolean isOfficial() {
+        ActionSequence actionSequence = this.actionSequence;
+        if (actionSequence != null) {
+            return actionSequence.j();
+        }
+        return false;
+    }
+
+    public void setActionID(String str) {
+        this.actionID = str;
+    }
+
+    public void setActionNm(String str) {
+        this.actionNm = str;
+    }
+
+    public void setActionSequence(ActionSequence actionSequence) {
+        this.actionSequence = actionSequence;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String toString() {
+        StringBuilder sb = new StringBuilder("ActionWidgetData: ");
+        sb.append(" actionID: " + this.actionID);
+        sb.append(" actionNm: " + this.actionNm);
+        return super.toString() + " " + sb.toString();
+    }
+
+    public ActionWidgetData(String str) {
+        super(str);
+    }
+
+    public ActionWidgetData(String str, String str2, String str3, float f, float f2) {
+        super(str, f, f2);
+        this.actionID = str2;
+        this.actionNm = str3;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/AddViewData.java

@@ -0,0 +1,27 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import com.ubt.jimu.controller.data.config.WidgetConfig;
+
+/* loaded from: classes.dex */
+public class AddViewData extends MoveBaseData {
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public WidgetConfig getConfig() {
+        return null;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public String getShowName(Context context) {
+        return null;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String getWidgetInfo(Context context) {
+        return "";
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData, com.ubt.jimu.controller.data.widget.ItemBaseData
+    public boolean isOfficial() {
+        return false;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/ControllerData.java

@@ -0,0 +1,399 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.text.TextUtils;
+import android.util.Log;
+import android.util.Size;
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
+import com.thoughtworks.xstream.annotations.XStreamImplicit;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.controller.data.config.AccumulatorConfig;
+import com.ubt.jimu.controller.data.config.HSliderConfig;
+import com.ubt.jimu.controller.data.config.JockstickConfig;
+import com.ubt.jimu.controller.data.config.SliderConfig;
+import com.ubt.jimu.transport.model.TransportFile;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+@XStreamAlias(TransportFile.MODEL_CONTROLLER_DIR)
+/* loaded from: classes.dex */
+public class ControllerData {
+    public static final int DEFAULT_SCREEN_HEIGHT = 750;
+    public static final int DEFAULT_SCREEN_WIDTH = 1334;
+
+    @XStreamImplicit(itemFieldName = "xlsliderData")
+    private List<AccumulatorData> accumulatorData;
+
+    @XStreamImplicit(itemFieldName = "actionData")
+    private List<ActionWidgetData> actionData;
+
+    @XStreamAsAttribute
+    private String controllerID;
+
+    @XStreamOmitField
+    private Size displaySize;
+
+    @XStreamImplicit(itemFieldName = "hsliderData")
+    private List<HSliderWidgetData> hsliderData;
+
+    @XStreamImplicit(itemFieldName = "jockstickData")
+    private List<JockstickData> jockstickData;
+
+    @XStreamAlias("ScreenHeight")
+    @XStreamAsAttribute
+    private int screenHeight;
+
+    @XStreamAlias("ScreenWidth")
+    @XStreamAsAttribute
+    private int screenWidth;
+
+    @XStreamImplicit(itemFieldName = "sliderData")
+    private List<SliderWidgetData> sliderData;
+
+    @XStreamOmitField
+    private Size xmlSize;
+
+    public ControllerData() {
+        this.screenWidth = DEFAULT_SCREEN_WIDTH;
+        this.screenHeight = DEFAULT_SCREEN_HEIGHT;
+        this.actionData = new ArrayList();
+        this.sliderData = new ArrayList();
+        this.hsliderData = new ArrayList();
+        this.jockstickData = new ArrayList();
+        this.accumulatorData = new ArrayList();
+    }
+
+    private boolean hasMoveWidget() {
+        List<HSliderWidgetData> list;
+        List<JockstickData> list2;
+        List<SliderWidgetData> list3 = this.sliderData;
+        return (list3 != null && list3.size() > 0) || ((list = this.hsliderData) != null && list.size() > 0) || ((list2 = this.jockstickData) != null && list2.size() > 0);
+    }
+
+    private boolean removeItem(String str, List<? extends ItemBaseData> list) {
+        if (!TextUtils.isEmpty(str) && list != null && list.size() > 0) {
+            for (int i = 0; i < list.size(); i++) {
+                if (str.equals(list.get(i).getWidgetId())) {
+                    return list.remove(i) != null;
+                }
+            }
+        }
+        return false;
+    }
+
+    private void transformInternal(List<? extends ItemBaseData> list, Size size, Size size2) {
+        if (list == null || list.size() <= 0) {
+            return;
+        }
+        for (ItemBaseData itemBaseData : list) {
+            itemBaseData.setDisplaySize(size, size2);
+            itemBaseData.transform();
+        }
+    }
+
+    public void addAccumulatorData(AccumulatorData accumulatorData) {
+        List<AccumulatorData> list = this.accumulatorData;
+        if (list != null) {
+            list.add(accumulatorData);
+        }
+    }
+
+    public void addActionData(ActionWidgetData actionWidgetData) {
+        List<ActionWidgetData> list = this.actionData;
+        if (list == null || actionWidgetData == null) {
+            return;
+        }
+        list.add(actionWidgetData);
+    }
+
+    public void addData(ItemBaseData itemBaseData) {
+        if (itemBaseData == null) {
+            return;
+        }
+        if (itemBaseData instanceof JockstickData) {
+            Log.e("Test", "JockstickData:" + itemBaseData);
+            addJockstickData((JockstickData) itemBaseData);
+        }
+        if (itemBaseData instanceof HSliderWidgetData) {
+            addHsliderData((HSliderWidgetData) itemBaseData);
+            Log.e("Test", "moveBaseData:" + itemBaseData);
+        }
+        if (itemBaseData instanceof SliderWidgetData) {
+            addSliderData((SliderWidgetData) itemBaseData);
+        }
+        if (itemBaseData instanceof ActionWidgetData) {
+            Log.e("Test", "保存动作");
+            addActionData((ActionWidgetData) itemBaseData);
+        }
+        if (itemBaseData instanceof AccumulatorData) {
+            addAccumulatorData((AccumulatorData) itemBaseData);
+        }
+    }
+
+    public void addHsliderData(HSliderWidgetData hSliderWidgetData) {
+        List<HSliderWidgetData> list = this.hsliderData;
+        if (list != null) {
+            list.add(hSliderWidgetData);
+        }
+    }
+
+    public void addJockstickData(JockstickData jockstickData) {
+        List<JockstickData> list = this.jockstickData;
+        if (list != null) {
+            list.add(jockstickData);
+        }
+    }
+
+    public void addSliderData(SliderWidgetData sliderWidgetData) {
+        List<SliderWidgetData> list = this.sliderData;
+        if (list == null || sliderWidgetData == null) {
+            return;
+        }
+        list.add(sliderWidgetData);
+    }
+
+    public boolean clearEmptyWidget() {
+        List<JockstickData> list = this.jockstickData;
+        boolean z = false;
+        if (list != null && list.size() > 0) {
+            for (JockstickData jockstickData : new ArrayList(this.jockstickData)) {
+                JockstickConfig config = jockstickData.getConfig();
+                if (config == null || config.getType() == JockstickConfig.JockType.none || config.getWheelList() == null || config.getWheelList().isEmpty()) {
+                    this.jockstickData.remove(jockstickData);
+                    z = true;
+                }
+            }
+        }
+        List<SliderWidgetData> list2 = this.sliderData;
+        if (list2 != null && list2.size() > 0) {
+            for (SliderWidgetData sliderWidgetData : new ArrayList(this.sliderData)) {
+                SliderConfig config2 = sliderWidgetData.getConfig();
+                if (config2 == null || config2.getServoID() <= 0) {
+                    this.sliderData.remove(sliderWidgetData);
+                    z = true;
+                }
+            }
+        }
+        List<HSliderWidgetData> list3 = this.hsliderData;
+        if (list3 != null && list3.size() > 0) {
+            for (HSliderWidgetData hSliderWidgetData : new ArrayList(this.hsliderData)) {
+                HSliderConfig config3 = hSliderWidgetData.getConfig();
+                if (config3 == null || config3.getServoID() <= 0) {
+                    this.hsliderData.remove(hSliderWidgetData);
+                    z = true;
+                }
+            }
+        }
+        List<AccumulatorData> list4 = this.accumulatorData;
+        if (list4 != null && list4.size() > 0) {
+            for (AccumulatorData accumulatorData : new ArrayList(this.accumulatorData)) {
+                AccumulatorConfig config4 = accumulatorData.getConfig();
+                if (config4 == null || config4.getServoID() <= 0) {
+                    this.accumulatorData.remove(accumulatorData);
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    public List<AccumulatorData> getAccumulatorData() {
+        return this.accumulatorData;
+    }
+
+    public List<ActionWidgetData> getActionData() {
+        return this.actionData;
+    }
+
+    public String getControllerID() {
+        return this.controllerID;
+    }
+
+    public List<HSliderWidgetData> getHsliderData() {
+        return this.hsliderData;
+    }
+
+    public List<JockstickData> getJockstickData() {
+        return this.jockstickData;
+    }
+
+    public MoveWidgetData getMoveConfig() {
+        MoveWidgetData moveWidgetData;
+        List<SliderWidgetData> list = this.sliderData;
+        if (list == null || list.size() <= 0) {
+            moveWidgetData = null;
+        } else {
+            ArrayList arrayList = new ArrayList(this.sliderData.size());
+            Iterator<SliderWidgetData> it = this.sliderData.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next().getConfig());
+            }
+            moveWidgetData = new MoveWidgetData();
+            moveWidgetData.setSliderConfigList(arrayList);
+        }
+        List<HSliderWidgetData> list2 = this.hsliderData;
+        if (list2 != null && list2.size() > 0) {
+            ArrayList arrayList2 = new ArrayList(this.hsliderData.size());
+            Iterator<HSliderWidgetData> it2 = this.hsliderData.iterator();
+            while (it2.hasNext()) {
+                arrayList2.add(it2.next().getConfig());
+            }
+            if (moveWidgetData == null) {
+                moveWidgetData = new MoveWidgetData();
+            }
+            moveWidgetData.setHSliderConfigList(arrayList2);
+        }
+        List<JockstickData> list3 = this.jockstickData;
+        if (list3 != null && list3.size() > 0) {
+            ArrayList arrayList3 = new ArrayList(this.jockstickData.size());
+            Iterator<JockstickData> it3 = this.jockstickData.iterator();
+            while (it3.hasNext()) {
+                arrayList3.add(it3.next().getConfig());
+            }
+            if (moveWidgetData == null) {
+                moveWidgetData = new MoveWidgetData();
+            }
+            moveWidgetData.setJockstickConfigList(arrayList3);
+        }
+        List<AccumulatorData> list4 = this.accumulatorData;
+        if (list4 != null && list4.size() > 0) {
+            ArrayList arrayList4 = new ArrayList(this.accumulatorData.size());
+            Iterator<AccumulatorData> it4 = this.accumulatorData.iterator();
+            while (it4.hasNext()) {
+                arrayList4.add(it4.next().getConfig());
+            }
+            if (moveWidgetData == null) {
+                moveWidgetData = new MoveWidgetData();
+            }
+            moveWidgetData.setAccumulatorConfigList(arrayList4);
+        }
+        return moveWidgetData;
+    }
+
+    public int getScreenHeight() {
+        return this.screenHeight;
+    }
+
+    public int getScreenWidth() {
+        return this.screenWidth;
+    }
+
+    public List<SliderWidgetData> getSliderData() {
+        return this.sliderData;
+    }
+
+    public float getTransformRatio() {
+        return 1.0f;
+    }
+
+    public boolean hasAction() {
+        return getActionData() != null && getActionData().size() > 0;
+    }
+
+    public boolean removeAccumulatorData(String str) {
+        return removeItem(str, this.accumulatorData);
+    }
+
+    public boolean removeActionData(String str) {
+        return removeItem(str, this.actionData);
+    }
+
+    public boolean removeHsliderData(String str) {
+        return removeItem(str, this.hsliderData);
+    }
+
+    public boolean removeJockstickData(String str) {
+        return removeItem(str, this.jockstickData);
+    }
+
+    public boolean removeSliderData(String str) {
+        return removeItem(str, this.sliderData);
+    }
+
+    public void setAccumulatorData(List<AccumulatorData> list) {
+        this.accumulatorData = list;
+    }
+
+    public void setActionData(List<ActionWidgetData> list) {
+        this.actionData = list;
+    }
+
+    public void setControllerID(String str) {
+        this.controllerID = str;
+    }
+
+    public void setHsliderData(List<HSliderWidgetData> list) {
+        this.hsliderData = list;
+    }
+
+    public void setJockstickData(List<JockstickData> list) {
+        this.jockstickData = list;
+    }
+
+    public void setScreenHeight(int i) {
+        this.screenHeight = i;
+    }
+
+    public void setScreenWidth(int i) {
+        this.screenWidth = i;
+    }
+
+    public void setSliderData(List<SliderWidgetData> list) {
+        this.sliderData = list;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder("ControllerData: ");
+        sb.append(" controllerID : " + this.controllerID);
+        sb.append(" screenWidth: " + this.screenWidth);
+        sb.append(" screenHeight" + this.screenHeight);
+        StringBuilder sb2 = new StringBuilder();
+        sb2.append(" actionData: ");
+        List<ActionWidgetData> list = this.actionData;
+        sb2.append(list != null ? list.toString() : "null");
+        sb.append(sb2.toString());
+        StringBuilder sb3 = new StringBuilder();
+        sb3.append(" sliderData: ");
+        List<SliderWidgetData> list2 = this.sliderData;
+        sb3.append(list2 != null ? list2.toString() : "null");
+        sb.append(sb3.toString());
+        StringBuilder sb4 = new StringBuilder();
+        sb4.append(" hsliderData: ");
+        List<HSliderWidgetData> list3 = this.hsliderData;
+        sb4.append(list3 != null ? list3.toString() : "null");
+        sb.append(sb4.toString());
+        StringBuilder sb5 = new StringBuilder();
+        sb5.append(" jockstickData: ");
+        List<JockstickData> list4 = this.jockstickData;
+        sb5.append(list4 != null ? list4.toString() : "null");
+        sb.append(sb5.toString());
+        StringBuilder sb6 = new StringBuilder();
+        sb6.append(" accumulatorData: ");
+        List<AccumulatorData> list5 = this.accumulatorData;
+        sb6.append(list5 != null ? list5.toString() : "null");
+        sb.append(sb6.toString());
+        return sb.toString();
+    }
+
+    public void transform(Size size, Size size2) {
+        transformInternal(this.actionData, size, size2);
+        transformInternal(this.jockstickData, size, size2);
+        transformInternal(this.sliderData, size, size2);
+        transformInternal(this.hsliderData, size, size2);
+        transformInternal(this.accumulatorData, size, size2);
+    }
+
+    public boolean removeActionData(ActionWidgetData actionWidgetData) {
+        List<ActionWidgetData> list = this.actionData;
+        if (list == null || list.size() <= 0) {
+            return false;
+        }
+        return this.actionData.remove(actionWidgetData);
+    }
+
+    public ControllerData(String str) {
+        this();
+        this.controllerID = str;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/HSliderDataConverter.java

@@ -0,0 +1,112 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.text.TextUtils;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.ubt.jimu.controller.data.config.HSliderConfig;
+import com.ubtech.utils.XLog;
+
+/* loaded from: classes.dex */
+public class HSliderDataConverter implements Converter {
+    public static final String CONFIG_ID = "configID";
+    public static final String MAX_ANGLE = "max_angle";
+    public static final String MIN_ANGLE = "min_angle";
+    public static final String SERVO_ID = "servoID";
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return HSliderWidgetData.class.equals(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        HSliderWidgetData hSliderWidgetData = (HSliderWidgetData) obj;
+        if (!TextUtils.isEmpty(hSliderWidgetData.getWidgetId())) {
+            hierarchicalStreamWriter.addAttribute("widgetId", hSliderWidgetData.getWidgetId());
+        }
+        HSliderConfig config = hSliderWidgetData.getConfig();
+        if (config != null && !TextUtils.isEmpty(config.getConfigID())) {
+            hierarchicalStreamWriter.addAttribute("configID", config.getConfigID());
+        }
+        hierarchicalStreamWriter.startNode("pos_x");
+        hierarchicalStreamWriter.setValue(String.valueOf(hSliderWidgetData.getPosX()));
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("pos_y");
+        hierarchicalStreamWriter.setValue(String.valueOf(hSliderWidgetData.getPosY()));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String attribute = hierarchicalStreamReader.getAttribute("widgetId");
+        if (TextUtils.isEmpty(attribute)) {
+            attribute = hierarchicalStreamReader.getAttribute("widgetID");
+        }
+        HSliderWidgetData hSliderWidgetData = new HSliderWidgetData(attribute);
+        HSliderConfig hSliderConfig = new HSliderConfig();
+        String attribute2 = hierarchicalStreamReader.getAttribute("configID");
+        if (!TextUtils.isEmpty(attribute2)) {
+            hSliderConfig.setConfigID(attribute2);
+        }
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String nodeName = hierarchicalStreamReader.getNodeName();
+            char c = 65535;
+            switch (nodeName.hashCode()) {
+                case -251140552:
+                    if (nodeName.equals("max_angle")) {
+                        c = 4;
+                        break;
+                    }
+                    break;
+                case 106854733:
+                    if (nodeName.equals("pos_x")) {
+                        c = 0;
+                        break;
+                    }
+                    break;
+                case 106854734:
+                    if (nodeName.equals("pos_y")) {
+                        c = 1;
+                        break;
+                    }
+                    break;
+                case 521338022:
+                    if (nodeName.equals("min_angle")) {
+                        c = 3;
+                        break;
+                    }
+                    break;
+                case 1984158196:
+                    if (nodeName.equals("servoID")) {
+                        c = 2;
+                        break;
+                    }
+                    break;
+            }
+            if (c == 0) {
+                hSliderWidgetData.setPosX(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 1) {
+                hSliderWidgetData.setPosY(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 2) {
+                Integer valueOf = Integer.valueOf(hierarchicalStreamReader.getValue());
+                if (valueOf != null && valueOf.intValue() > 0) {
+                    hSliderConfig.setServoID(valueOf.intValue());
+                }
+            } else if (c == 3) {
+                hSliderConfig.setMinAngle(Integer.valueOf(hierarchicalStreamReader.getValue()).intValue());
+            } else if (c != 4) {
+                XLog.b("woo", "Unknown node name : %s", hierarchicalStreamReader.getNodeName());
+            } else {
+                hSliderConfig.setMaxAngle(Integer.valueOf(hierarchicalStreamReader.getValue()).intValue());
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        hSliderWidgetData.setConfig(hSliderConfig);
+        return hSliderWidgetData;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/HSliderWidgetData.java

@@ -0,0 +1,62 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import com.thoughtworks.xstream.annotations.XStreamConverter;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.R;
+import com.ubt.jimu.controller.data.config.HSliderConfig;
+
+@XStreamConverter(priority = 9999, value = HSliderDataConverter.class)
+/* loaded from: classes.dex */
+public class HSliderWidgetData extends MoveBaseData<HSliderConfig> {
+
+    @XStreamOmitField
+    private HSliderConfig config;
+
+    public HSliderWidgetData() {
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public String getShowName(Context context) {
+        return String.format(context.getResources().getString(R.string.servo_mode_servo_index), Integer.valueOf(getConfig().getServoID()));
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String getWidgetInfo(Context context) {
+        HSliderConfig config = getConfig();
+        if (config == null) {
+            return "";
+        }
+        return String.format(context.getResources().getString(R.string.servo_mode_servo_index), Integer.valueOf(config.getServoID())) + "(" + config.getMinAngle() + "°~" + config.getMaxAngle() + "°)";
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String toString() {
+        return super.toString() + " " + getConfig().toString();
+    }
+
+    public HSliderWidgetData(String str) {
+        super(str);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public HSliderConfig getConfig() {
+        return this.config;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public void setConfig(HSliderConfig hSliderConfig) {
+        super.setConfig((HSliderWidgetData) hSliderConfig);
+        this.config = hSliderConfig;
+    }
+
+    public HSliderWidgetData(String str, float f, float f2) {
+        super(str, f, f2);
+    }
+
+    @Deprecated
+    public HSliderWidgetData(String str, byte b, int i, int i2, float f, float f2) {
+        super(str, f, f2);
+    }
+}

sources/com/ubt/jimu/controller/data/widget/ItemBaseData.java

@@ -0,0 +1,169 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import android.util.Size;
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.controller.util.IDGenerator;
+
+/* loaded from: classes.dex */
+public abstract class ItemBaseData {
+    static final String ALIAS_POS_X = "pos_x";
+    static final String ALIAS_POS_Y = "pos_y";
+    static final String ALIAS_WIDGET_ID = "widgetId";
+
+    @XStreamOmitField
+    private int ImageViewId;
+
+    @XStreamOmitField
+    private float currentX;
+
+    @XStreamOmitField
+    private float currentY;
+
+    @XStreamOmitField
+    private Size displaySize;
+
+    @XStreamAlias(ALIAS_POS_X)
+    private float posX;
+
+    @XStreamAlias(ALIAS_POS_Y)
+    private float posY;
+
+    @XStreamOmitField
+    private String showName;
+
+    @XStreamAsAttribute
+    private String widgetId;
+
+    @XStreamOmitField
+    private Size xmlSize;
+
+    public ItemBaseData() {
+        this.widgetId = IDGenerator.a(System.currentTimeMillis());
+    }
+
+    private float getDisplayRatio() {
+        float height = this.displaySize.getHeight() / this.xmlSize.getHeight();
+        float width = this.displaySize.getWidth() / this.xmlSize.getWidth();
+        return width > height ? height : width;
+    }
+
+    private float getSaveRatio() {
+        float height = this.xmlSize.getHeight() / this.displaySize.getHeight();
+        float width = this.xmlSize.getWidth() / this.displaySize.getWidth();
+        return width < height ? height : width;
+    }
+
+    private void transformX(float f) {
+        if (Math.abs(f) > 1.0E-6f) {
+            if (this.displaySize == null || this.xmlSize == null) {
+                this.posX = f;
+            } else {
+                this.posX = (f - (r0.getWidth() / 2.0f)) * getSaveRatio();
+            }
+        }
+    }
+
+    private void transformY(float f) {
+        if (Math.abs(f) > 1.0E-6f) {
+            if (this.displaySize == null || this.xmlSize == null) {
+                this.posY = f;
+            } else {
+                this.posY = ((r0.getHeight() / 2.0f) - f) * getSaveRatio();
+            }
+        }
+    }
+
+    public float getCurrentX() {
+        if (Math.abs(this.currentX) < 1.0E-6f && this.displaySize != null && this.xmlSize != null) {
+            this.currentX = (this.posX * getDisplayRatio()) + (this.displaySize.getWidth() / 2.0f);
+        }
+        return this.currentX;
+    }
+
+    public float getCurrentY() {
+        if (Math.abs(this.currentY) < 1.0E-6f && this.displaySize != null && this.xmlSize != null) {
+            this.currentY = (this.displaySize.getHeight() / 2.0f) - (this.posY * getDisplayRatio());
+        }
+        return this.currentY;
+    }
+
+    public int getImageViewId() {
+        return this.ImageViewId;
+    }
+
+    public float getPosX() {
+        return this.posX;
+    }
+
+    public float getPosY() {
+        return this.posY;
+    }
+
+    public String getShowName(String str) {
+        return this.showName;
+    }
+
+    public String getWidgetId() {
+        return this.widgetId;
+    }
+
+    public abstract String getWidgetInfo(Context context);
+
+    public abstract boolean isOfficial();
+
+    public void setCurrentPos(float f, float f2) {
+        setCurrentX(f);
+        setCurrentY(f2);
+    }
+
+    public void setCurrentX(float f) {
+        this.currentX = f;
+    }
+
+    public void setCurrentY(float f) {
+        this.currentY = f;
+    }
+
+    protected void setDisplaySize(Size size, Size size2) {
+        this.displaySize = size;
+        this.xmlSize = size2;
+    }
+
+    public void setImageViewId(int i) {
+        this.ImageViewId = i;
+    }
+
+    protected void setPosX(float f) {
+        this.posX = f;
+    }
+
+    protected void setPosY(float f) {
+        this.posY = f;
+    }
+
+    public void setShowName(String str) {
+        this.showName = str;
+    }
+
+    public String toString() {
+        return "ItemBaseData{widgetId='" + this.widgetId + "', posX=" + this.posX + ", posY=" + this.posY + ", ImageViewId=" + getImageViewId() + ", showName='" + this.showName + "', displaySize=" + this.displaySize + ", xmlSize=" + this.xmlSize + ", currentX=" + getCurrentX() + ", currentY=" + getCurrentY() + '}';
+    }
+
+    protected void transform() {
+        transformX(this.currentX);
+        transformY(this.currentY);
+    }
+
+    public ItemBaseData(String str) {
+        this.widgetId = str;
+    }
+
+    public ItemBaseData(String str, float f, float f2) {
+        this(str);
+        this.posX = f;
+        this.posY = f2;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/JockstickData.java

@@ -0,0 +1,64 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import com.thoughtworks.xstream.annotations.XStreamConverter;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.R;
+import com.ubt.jimu.controller.data.config.JockstickConfig;
+
+@XStreamConverter(priority = 9999, value = JockstickDataConverter.class)
+/* loaded from: classes.dex */
+public class JockstickData extends MoveBaseData<JockstickConfig> {
+
+    @XStreamOmitField
+    private JockstickConfig config;
+
+    public JockstickData() {
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public String getShowName(Context context) {
+        String string = context.getResources().getString(R.string.control_two_engine);
+        if (getConfig().getType() == JockstickConfig.JockType.fourServo) {
+            string = context.getResources().getString(R.string.control_four_engine);
+        }
+        if (getConfig().getType() == JockstickConfig.JockType.sixServo) {
+            string = context.getResources().getString(R.string.control_six_engine);
+        }
+        int index = getConfig().getIndex();
+        if (index <= 1) {
+            return string;
+        }
+        return string + index;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String getWidgetInfo(Context context) {
+        return getShowName(context);
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String toString() {
+        return super.toString() + " " + getConfig().toString();
+    }
+
+    public JockstickData(String str) {
+        super(str);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public JockstickConfig getConfig() {
+        return this.config;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public void setConfig(JockstickConfig jockstickConfig) {
+        super.setConfig((JockstickData) jockstickConfig);
+        this.config = jockstickConfig;
+    }
+
+    public JockstickData(String str, float f, float f2) {
+        super(str, f, f2);
+    }
+}

sources/com/ubt/jimu/controller/data/widget/JockstickDataConverter.java

@@ -0,0 +1,156 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.text.TextUtils;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.ubt.jimu.base.data.CtrlMotionType;
+import com.ubt.jimu.controller.data.config.JockstickConfig;
+import com.ubt.jimu.controller.data.config.Wheel;
+import com.ubt.jimu.transport.model.TransportFile;
+import com.ubtech.utils.XLog;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class JockstickDataConverter implements Converter {
+    public static final String CONFIG_ID = "configID";
+    public static final String ID = "id";
+    public static final String MOTION_TYPE = "motionType";
+    public static final String POS = "pos";
+    public static final String REVERSE = "reverse";
+    public static final String TYPE = "type";
+    public static final String WHEEL = "wheel";
+
+    private void marshalConfig(HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext, JockstickConfig jockstickConfig) {
+        if (jockstickConfig != null) {
+            JockstickConfig.JockType type = jockstickConfig.getType();
+            if (type != null) {
+                hierarchicalStreamWriter.startNode("type");
+                hierarchicalStreamWriter.setValue(type.name());
+                hierarchicalStreamWriter.endNode();
+            }
+            CtrlMotionType motionType = jockstickConfig.getMotionType();
+            if (motionType != null) {
+                hierarchicalStreamWriter.startNode("motionType");
+                hierarchicalStreamWriter.setValue(motionType.name());
+                hierarchicalStreamWriter.endNode();
+            }
+            List<Wheel> wheelList = jockstickConfig.getWheelList();
+            if (wheelList == null || wheelList.size() <= 0) {
+                return;
+            }
+            for (Wheel wheel : wheelList) {
+                hierarchicalStreamWriter.startNode(WHEEL);
+                marshallingContext.convertAnother(wheel);
+                hierarchicalStreamWriter.endNode();
+            }
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return JockstickData.class.equals(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        JockstickData jockstickData = (JockstickData) obj;
+        if (!TextUtils.isEmpty(jockstickData.getWidgetId())) {
+            hierarchicalStreamWriter.addAttribute("widgetId", jockstickData.getWidgetId());
+        }
+        JockstickConfig config = jockstickData.getConfig();
+        if (config != null && !TextUtils.isEmpty(config.getConfigID())) {
+            hierarchicalStreamWriter.addAttribute("configID", config.getConfigID());
+        }
+        hierarchicalStreamWriter.startNode("pos_x");
+        hierarchicalStreamWriter.setValue(String.valueOf(jockstickData.getPosX()));
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("pos_y");
+        hierarchicalStreamWriter.setValue(String.valueOf(jockstickData.getPosY()));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String attribute = hierarchicalStreamReader.getAttribute("widgetId");
+        if (TextUtils.isEmpty(attribute)) {
+            attribute = hierarchicalStreamReader.getAttribute("widgetID");
+        }
+        JockstickData jockstickData = new JockstickData(attribute);
+        JockstickConfig jockstickConfig = new JockstickConfig();
+        String attribute2 = hierarchicalStreamReader.getAttribute("configID");
+        if (!TextUtils.isEmpty(attribute2)) {
+            jockstickConfig.setConfigID(attribute2);
+        }
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            switch (hierarchicalStreamReader.getNodeName()) {
+                case "pos_x":
+                    jockstickData.setPosX(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+                    break;
+                case "pos_y":
+                    jockstickData.setPosY(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+                    break;
+                case "type":
+                    try {
+                        jockstickConfig.setType((JockstickConfig.JockType) unmarshallingContext.convertAnother(jockstickData, JockstickConfig.JockType.class));
+                        break;
+                    } catch (Exception e) {
+                        XLog.b(TransportFile.TYPE_CONTROLLER, "unknown JockType");
+                        e.printStackTrace();
+                        jockstickConfig.setType(JockstickConfig.JockType.twoServo);
+                        break;
+                    }
+                case "motionType":
+                    try {
+                        jockstickConfig.setMotionType((CtrlMotionType) unmarshallingContext.convertAnother(jockstickData, CtrlMotionType.class));
+                        break;
+                    } catch (Exception e2) {
+                        e2.printStackTrace();
+                        jockstickConfig.setMotionType(CtrlMotionType.servo);
+                        break;
+                    }
+                case "leftUpID":
+                    Integer valueOf = Integer.valueOf(hierarchicalStreamReader.getValue());
+                    if (valueOf != null && valueOf.intValue() > 0) {
+                        jockstickConfig.putWheel(1, new Wheel(valueOf.intValue(), 1));
+                        break;
+                    }
+                    break;
+                case "rightUpID":
+                    Integer valueOf2 = Integer.valueOf(hierarchicalStreamReader.getValue());
+                    if (valueOf2 != null && valueOf2.intValue() > 0) {
+                        jockstickConfig.putWheel(2, new Wheel(valueOf2.intValue(), 2));
+                        break;
+                    }
+                    break;
+                case "leftBottomID":
+                    Integer valueOf3 = Integer.valueOf(hierarchicalStreamReader.getValue());
+                    if (valueOf3 != null && valueOf3.intValue() > 0) {
+                        jockstickConfig.putWheel(3, new Wheel(valueOf3.intValue(), 3));
+                        break;
+                    }
+                    break;
+                case "rightBottomID":
+                    Integer valueOf4 = Integer.valueOf(hierarchicalStreamReader.getValue());
+                    if (valueOf4 != null && valueOf4.intValue() > 0) {
+                        jockstickConfig.putWheel(4, new Wheel(valueOf4.intValue(), 4));
+                        break;
+                    }
+                    break;
+                case "wheel":
+                    Wheel wheel = (Wheel) unmarshallingContext.convertAnother(jockstickData, Wheel.class);
+                    jockstickConfig.putWheel(wheel.getPosition(), wheel);
+                    break;
+                default:
+                    XLog.b("woo", "Unknown node name : %s", hierarchicalStreamReader.getNodeName());
+                    break;
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        jockstickData.setConfig(jockstickConfig);
+        return jockstickData;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/MoveBaseData.java

@@ -0,0 +1,48 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
+import com.ubt.jimu.controller.data.config.WidgetConfig;
+
+/* loaded from: classes.dex */
+public abstract class MoveBaseData<C extends WidgetConfig> extends ItemBaseData {
+
+    @XStreamAsAttribute
+    private String configID;
+
+    public MoveBaseData() {
+    }
+
+    public abstract C getConfig();
+
+    public String getConfigID() {
+        return this.configID;
+    }
+
+    public abstract String getShowName(Context context);
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public boolean isOfficial() {
+        return getConfig() != null && getConfig().getConfigType() == 1;
+    }
+
+    public void setConfig(C c) {
+        this.configID = c.getConfigID();
+    }
+
+    public void setConfigID(String str) {
+        this.configID = str;
+    }
+
+    public void updateConfig(C c) {
+        setConfig(c);
+    }
+
+    public MoveBaseData(String str) {
+        super(str);
+    }
+
+    public MoveBaseData(String str, float f, float f2) {
+        super(str, f, f2);
+    }
+}

sources/com/ubt/jimu/controller/data/widget/MoveWidgetData.java

@@ -0,0 +1,250 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.text.TextUtils;
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamImplicit;
+import com.ubt.jimu.controller.data.config.AccumulatorConfig;
+import com.ubt.jimu.controller.data.config.HSliderConfig;
+import com.ubt.jimu.controller.data.config.JockstickConfig;
+import com.ubt.jimu.controller.data.config.SliderConfig;
+import com.ubt.jimu.controller.data.config.WidgetConfig;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+@XStreamAlias("MoveWidgetData")
+/* loaded from: classes.dex */
+public class MoveWidgetData {
+
+    @XStreamImplicit
+    private List<AccumulatorConfig> accumulatorConfigList;
+
+    @XStreamImplicit
+    private List<HSliderConfig> hSliderConfigList;
+
+    @XStreamImplicit
+    private List<JockstickConfig> jockstickConfigList;
+
+    @XStreamImplicit
+    private List<SliderConfig> sliderConfigList;
+
+    static /* synthetic */ int a(WidgetConfig widgetConfig, WidgetConfig widgetConfig2) {
+        return widgetConfig2.getConfigType() != widgetConfig.getConfigType() ? widgetConfig2.getConfigType() - widgetConfig.getConfigType() : widgetConfig2.getConfigID().compareTo(widgetConfig.getConfigID());
+    }
+
+    private boolean isExclusive(List<? extends WidgetConfig> list, WidgetConfig widgetConfig) {
+        for (WidgetConfig widgetConfig2 : list) {
+            if (widgetConfig2.equals(widgetConfig)) {
+                widgetConfig.setConfigID(widgetConfig2.getConfigID());
+                return false;
+            }
+            if (!TextUtils.isEmpty(widgetConfig.getConfigID()) && widgetConfig2.getConfigID().equals(widgetConfig.getConfigID())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean addAccumulatorConfig(AccumulatorConfig accumulatorConfig) {
+        List<AccumulatorConfig> list = this.accumulatorConfigList;
+        if (list == null) {
+            this.accumulatorConfigList = new ArrayList();
+            this.accumulatorConfigList.add(accumulatorConfig);
+            return true;
+        }
+        if (!isExclusive(list, accumulatorConfig)) {
+            return false;
+        }
+        this.accumulatorConfigList.add(accumulatorConfig);
+        return true;
+    }
+
+    public boolean addHSliderConfig(HSliderConfig hSliderConfig) {
+        List<HSliderConfig> list = this.hSliderConfigList;
+        if (list == null) {
+            this.hSliderConfigList = new ArrayList();
+            this.hSliderConfigList.add(hSliderConfig);
+            return true;
+        }
+        if (!isExclusive(list, hSliderConfig)) {
+            return false;
+        }
+        this.hSliderConfigList.add(hSliderConfig);
+        return true;
+    }
+
+    public boolean addJockstickConfig(JockstickConfig jockstickConfig) {
+        List<JockstickConfig> list = this.jockstickConfigList;
+        if (list == null) {
+            this.jockstickConfigList = new ArrayList();
+            this.jockstickConfigList.add(jockstickConfig);
+            return true;
+        }
+        if (!isExclusive(list, jockstickConfig)) {
+            return false;
+        }
+        this.jockstickConfigList.add(jockstickConfig);
+        return true;
+    }
+
+    public boolean addSliderConfig(SliderConfig sliderConfig) {
+        List<SliderConfig> list = this.sliderConfigList;
+        if (list == null) {
+            this.sliderConfigList = new ArrayList();
+            this.sliderConfigList.add(sliderConfig);
+            return true;
+        }
+        if (!isExclusive(list, sliderConfig)) {
+            return false;
+        }
+        this.sliderConfigList.add(sliderConfig);
+        return true;
+    }
+
+    public List<AccumulatorConfig> getAccumulatorConfigList() {
+        return this.accumulatorConfigList;
+    }
+
+    public List<WidgetConfig> getConfigList() {
+        ArrayList arrayList = new ArrayList();
+        List<JockstickConfig> list = this.jockstickConfigList;
+        if (list != null && list.size() > 0) {
+            arrayList.addAll(this.jockstickConfigList);
+        }
+        List<SliderConfig> list2 = this.sliderConfigList;
+        if (list2 != null && list2.size() > 0) {
+            arrayList.addAll(this.sliderConfigList);
+        }
+        List<HSliderConfig> list3 = this.hSliderConfigList;
+        if (list3 != null && list3.size() > 0) {
+            arrayList.addAll(this.hSliderConfigList);
+        }
+        List<AccumulatorConfig> list4 = this.accumulatorConfigList;
+        if (list4 != null && list4.size() > 0) {
+            arrayList.addAll(this.accumulatorConfigList);
+        }
+        Collections.sort(arrayList, new Comparator() { // from class: com.ubt.jimu.controller.data.widget.a
+            @Override // java.util.Comparator
+            public final int compare(Object obj, Object obj2) {
+                return MoveWidgetData.a((WidgetConfig) obj, (WidgetConfig) obj2);
+            }
+        });
+        return arrayList;
+    }
+
+    public List<HSliderConfig> getHSliderConfigList() {
+        return this.hSliderConfigList;
+    }
+
+    public List<JockstickConfig> getJockstickConfigList() {
+        return this.jockstickConfigList;
+    }
+
+    public List<SliderConfig> getSliderConfigList() {
+        return this.sliderConfigList;
+    }
+
+    public boolean merge(ControllerData controllerData) {
+        boolean z = false;
+        if (controllerData != null) {
+            List<SliderWidgetData> sliderData = controllerData.getSliderData();
+            if (sliderData != null && sliderData.size() > 0) {
+                for (SliderWidgetData sliderWidgetData : sliderData) {
+                    SliderConfig config = sliderWidgetData.getConfig();
+                    if (addSliderConfig(config)) {
+                        z = true;
+                    } else {
+                        sliderWidgetData.setConfig(config);
+                    }
+                }
+            }
+            List<HSliderWidgetData> hsliderData = controllerData.getHsliderData();
+            if (hsliderData != null && hsliderData.size() > 0) {
+                for (HSliderWidgetData hSliderWidgetData : hsliderData) {
+                    HSliderConfig config2 = hSliderWidgetData.getConfig();
+                    if (addHSliderConfig(config2)) {
+                        z = true;
+                    } else {
+                        hSliderWidgetData.setConfig(config2);
+                    }
+                }
+            }
+            List<JockstickData> jockstickData = controllerData.getJockstickData();
+            if (jockstickData != null && jockstickData.size() > 0) {
+                for (JockstickData jockstickData2 : jockstickData) {
+                    JockstickConfig config3 = jockstickData2.getConfig();
+                    if (addJockstickConfig(config3)) {
+                        z = true;
+                    } else {
+                        jockstickData2.setConfig(config3);
+                    }
+                }
+            }
+            List<AccumulatorData> accumulatorData = controllerData.getAccumulatorData();
+            if (accumulatorData != null && accumulatorData.size() > 0) {
+                for (AccumulatorData accumulatorData2 : accumulatorData) {
+                    AccumulatorConfig config4 = accumulatorData2.getConfig();
+                    if (addAccumulatorConfig(config4)) {
+                        z = true;
+                    } else {
+                        accumulatorData2.setConfig(config4);
+                    }
+                }
+            }
+        }
+        return z;
+    }
+
+    public boolean removeAccumulatorConfig(AccumulatorConfig accumulatorConfig) {
+        List<AccumulatorConfig> list;
+        if (accumulatorConfig == null || (list = this.accumulatorConfigList) == null || list.size() <= 0) {
+            return true;
+        }
+        return this.accumulatorConfigList.remove(accumulatorConfig);
+    }
+
+    public boolean removeHSliderconfig(HSliderConfig hSliderConfig) {
+        List<HSliderConfig> list;
+        if (hSliderConfig == null || (list = this.hSliderConfigList) == null || list.size() <= 0) {
+            return true;
+        }
+        return this.hSliderConfigList.remove(hSliderConfig);
+    }
+
+    public boolean removeJockstickConfig(JockstickConfig jockstickConfig) {
+        List<JockstickConfig> list;
+        if (jockstickConfig == null || (list = this.jockstickConfigList) == null || list.size() <= 0) {
+            return true;
+        }
+        return this.jockstickConfigList.remove(jockstickConfig);
+    }
+
+    public boolean removeSliderconfig(SliderConfig sliderConfig) {
+        List<SliderConfig> list;
+        if (sliderConfig == null || (list = this.sliderConfigList) == null || list.size() <= 0) {
+            return true;
+        }
+        return this.sliderConfigList.remove(sliderConfig);
+    }
+
+    public void setAccumulatorConfigList(List<AccumulatorConfig> list) {
+        this.accumulatorConfigList = list;
+    }
+
+    public void setHSliderConfigList(List<HSliderConfig> list) {
+        this.hSliderConfigList = list;
+    }
+
+    public void setJockstickConfigList(List<JockstickConfig> list) {
+        this.jockstickConfigList = list;
+    }
+
+    public void setSliderConfigList(List<SliderConfig> list) {
+        this.sliderConfigList = list;
+    }
+
+    public String toString() {
+        return "MoveWidgetData{sliderConfigList=" + this.sliderConfigList + ", hSliderConfigList=" + this.hSliderConfigList + ", jockstickConfigList=" + this.jockstickConfigList + ", accumulatorConfigList=" + this.accumulatorConfigList + '}';
+    }
+}

sources/com/ubt/jimu/controller/data/widget/SliderDataConverter.java

@@ -0,0 +1,113 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.text.TextUtils;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.ubt.jimu.base.data.CtrlMotionType;
+import com.ubt.jimu.controller.data.config.SliderConfig;
+import com.ubtech.utils.XLog;
+
+/* loaded from: classes.dex */
+public class SliderDataConverter implements Converter {
+    public static final String CONFIG_ID = "configID";
+    public static final String DIRECTION = "directionDisclock";
+    public static final String MOTION_TYPE = "motionType";
+    public static final String SERVO_ID = "servoID";
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return SliderWidgetData.class.equals(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        SliderWidgetData sliderWidgetData = (SliderWidgetData) obj;
+        if (!TextUtils.isEmpty(sliderWidgetData.getWidgetId())) {
+            hierarchicalStreamWriter.addAttribute("widgetId", sliderWidgetData.getWidgetId());
+        }
+        SliderConfig config = sliderWidgetData.getConfig();
+        if (config != null && !TextUtils.isEmpty(config.getConfigID())) {
+            hierarchicalStreamWriter.addAttribute("configID", config.getConfigID());
+        }
+        hierarchicalStreamWriter.startNode("pos_x");
+        hierarchicalStreamWriter.setValue(String.valueOf(sliderWidgetData.getPosX()));
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("pos_y");
+        hierarchicalStreamWriter.setValue(String.valueOf(sliderWidgetData.getPosY()));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String attribute = hierarchicalStreamReader.getAttribute("widgetId");
+        if (TextUtils.isEmpty(attribute)) {
+            attribute = hierarchicalStreamReader.getAttribute("widgetID");
+        }
+        SliderWidgetData sliderWidgetData = new SliderWidgetData(attribute);
+        SliderConfig sliderConfig = new SliderConfig();
+        String attribute2 = hierarchicalStreamReader.getAttribute("configID");
+        if (!TextUtils.isEmpty(attribute2)) {
+            sliderConfig.setConfigID(attribute2);
+        }
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String nodeName = hierarchicalStreamReader.getNodeName();
+            char c = 65535;
+            switch (nodeName.hashCode()) {
+                case -1480753953:
+                    if (nodeName.equals(DIRECTION)) {
+                        c = 4;
+                        break;
+                    }
+                    break;
+                case -720898032:
+                    if (nodeName.equals("motionType")) {
+                        c = 2;
+                        break;
+                    }
+                    break;
+                case 106854733:
+                    if (nodeName.equals("pos_x")) {
+                        c = 0;
+                        break;
+                    }
+                    break;
+                case 106854734:
+                    if (nodeName.equals("pos_y")) {
+                        c = 1;
+                        break;
+                    }
+                    break;
+                case 1984158196:
+                    if (nodeName.equals("servoID")) {
+                        c = 3;
+                        break;
+                    }
+                    break;
+            }
+            if (c == 0) {
+                sliderWidgetData.setPosX(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 1) {
+                sliderWidgetData.setPosY(Float.valueOf(hierarchicalStreamReader.getValue()).floatValue());
+            } else if (c == 2) {
+                sliderConfig.setMotionType((CtrlMotionType) unmarshallingContext.convertAnother(sliderWidgetData, CtrlMotionType.class));
+            } else if (c == 3) {
+                Integer valueOf = Integer.valueOf(hierarchicalStreamReader.getValue());
+                if (valueOf != null && valueOf.intValue() > 0) {
+                    sliderConfig.setServoID(valueOf.intValue());
+                }
+            } else if (c != 4) {
+                XLog.b("woo", "Unknown node name : %s", hierarchicalStreamReader.getNodeName());
+            } else {
+                sliderConfig.setDirectionDisclock(Boolean.valueOf(hierarchicalStreamReader.getValue()).booleanValue());
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        sliderWidgetData.setConfig(sliderConfig);
+        return sliderWidgetData;
+    }
+}

sources/com/ubt/jimu/controller/data/widget/SliderWidgetData.java

@@ -0,0 +1,70 @@
+package com.ubt.jimu.controller.data.widget;
+
+import android.content.Context;
+import com.thoughtworks.xstream.annotations.XStreamConverter;
+import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.ubt.jimu.R;
+import com.ubt.jimu.base.data.CtrlMotionType;
+import com.ubt.jimu.controller.data.config.SliderConfig;
+
+@XStreamConverter(priority = 9999, value = SliderDataConverter.class)
+/* loaded from: classes.dex */
+public class SliderWidgetData extends MoveBaseData<SliderConfig> {
+
+    @XStreamOmitField
+    private SliderConfig config;
+
+    public SliderWidgetData() {
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public String getShowName(Context context) {
+        String string = context.getResources().getString(R.string.servo_mode_servo_index);
+        if (getConfig().getMotionType() == CtrlMotionType.motor) {
+            string = context.getResources().getString(R.string.control_motor_index);
+        }
+        return String.format(string, Integer.valueOf(getConfig().getServoID()));
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String getWidgetInfo(Context context) {
+        if (this.config == null) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder(String.format(context.getResources().getString(R.string.servo_mode_servo_index), Integer.valueOf(this.config.getServoID())));
+        sb.append("(");
+        sb.append(this.config.isDirectionDisclock() ? context.getResources().getString(R.string.engine_rotate_anticlockwise) : context.getResources().getString(R.string.engine_rotate_clockwise));
+        sb.append(")");
+        return sb.toString();
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.ItemBaseData
+    public String toString() {
+        return super.toString() + " " + getConfig().toString();
+    }
+
+    public SliderWidgetData(String str) {
+        super(str);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public SliderConfig getConfig() {
+        return this.config;
+    }
+
+    @Override // com.ubt.jimu.controller.data.widget.MoveBaseData
+    public void setConfig(SliderConfig sliderConfig) {
+        super.setConfig((SliderWidgetData) sliderConfig);
+        this.config = sliderConfig;
+    }
+
+    public SliderWidgetData(String str, float f, float f2) {
+        super(str, f, f2);
+    }
+
+    @Deprecated
+    public SliderWidgetData(String str, CtrlMotionType ctrlMotionType, byte b, boolean z, float f, float f2) {
+        super(str, f, f2);
+    }
+}