Initial commit

sources/com/ubt/jimu/sync/CreationModelListener.java

@@ -0,0 +1,10 @@
+package com.ubt.jimu.sync;
+
+import com.ubt.jimu.base.db.diy.DiyDBModel;
+
+/* loaded from: classes2.dex */
+public interface CreationModelListener {
+    void a();
+
+    void a(DiyDBModel diyDBModel);
+}

sources/com/ubt/jimu/sync/OfflineBlockProgramUpload.java

@@ -0,0 +1,212 @@
+package com.ubt.jimu.sync;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.http.ApiResponse;
+import com.ubt.jimu.blockly.bean.BlocklyProgramsReturnBean;
+import com.ubt.jimu.blockly.bean.BlocklyProject;
+import com.ubt.jimu.blockly.bean.BlocklyProjectParameter;
+import com.ubt.jimu.blockly.dao.BlocklyProjectDbHandler;
+import com.ubt.jimu.blockly.networkSync.utils.QiNiuUtils;
+import com.ubt.jimu.transport3.api.DiyTransportServiceProxy;
+import com.ubt.jimu.transport3.bean.request.UploadModelProgramBean;
+import com.ubt.jimu.upload.DataUploadProxy;
+import com.ubt.jimu.upload.SimpleUploadCallback;
+import com.ubt.jimu.upload.UploadFilePathUtils;
+import com.ubt.jimu.upload.UploadRequest;
+import com.ubt.jimu.upload.UploadResponse;
+import com.ubt.jimu.utils.LogUtils;
+import com.ubt.jimu.utils.SystemUtils;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.functions.Consumer;
+import io.reactivex.schedulers.Schedulers;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class OfflineBlockProgramUpload {
+    private String a;
+    private BlocklyProjectDbHandler b;
+    private DiyTransportServiceProxy c;
+
+    public OfflineBlockProgramUpload(DiyTransportServiceProxy diyTransportServiceProxy) {
+        this.c = diyTransportServiceProxy;
+        if (this.b == null) {
+            this.b = BlocklyProjectDbHandler.getInstance();
+        }
+    }
+
+    public void b() {
+        List<BlocklyProject> serviceBlocklyProject = this.b.getServiceBlocklyProject();
+        if (serviceBlocklyProject == null || serviceBlocklyProject.size() == 0) {
+            return;
+        }
+        Iterator<BlocklyProject> it = serviceBlocklyProject.iterator();
+        while (it.hasNext()) {
+            b(1, it.next());
+        }
+    }
+
+    public void c() {
+        List<BlocklyProject> qiNiuBlocklyProject = this.b.getQiNiuBlocklyProject();
+        if (qiNiuBlocklyProject == null || qiNiuBlocklyProject.size() == 0) {
+            return;
+        }
+        Iterator<BlocklyProject> it = qiNiuBlocklyProject.iterator();
+        while (it.hasNext()) {
+            a(1, it.next());
+        }
+    }
+
+    public void a(int i, BlocklyProject blocklyProject) {
+        String userId = TextUtils.isEmpty(Cache.getInstance().getUserId()) ? "local" : Cache.getInstance().getUserId();
+        if ("local".equals(userId) || TextUtils.isEmpty(userId)) {
+            return;
+        }
+        c(i, blocklyProject);
+    }
+
+    private void c(final int i, final BlocklyProject blocklyProject) {
+        String str = QiNiuUtils.getAndroidSystemRootPath() + QiNiuUtils.getProgrammingLocalPath(blocklyProject);
+        LogUtils.c("本地文件路径：" + str);
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        if (!new File(str).exists()) {
+            LogUtils.c("offline blockly file not exists");
+            return;
+        }
+        UploadRequest uploadRequest = new UploadRequest();
+        uploadRequest.b(str);
+        uploadRequest.a(UploadFilePathUtils.a(str));
+        DataUploadProxy.c().a(uploadRequest, new SimpleUploadCallback() { // from class: com.ubt.jimu.sync.OfflineBlockProgramUpload.1
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadFaulted(UploadRequest uploadRequest2, Exception exc) {
+                OfflineBlockProgramUpload.this.b.setQiNiuUplaodState(blocklyProject.getXmlId(), false);
+            }
+
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadSucceed(UploadResponse uploadResponse) {
+                OfflineBlockProgramUpload.this.b.setQiNiuUplaodState(blocklyProject.getXmlId(), true);
+                blocklyProject.setFileUrl(uploadResponse.c());
+                OfflineBlockProgramUpload.this.b(i, blocklyProject);
+            }
+        });
+    }
+
+    public void b(final int i, final BlocklyProject blocklyProject) {
+        String str = blocklyProject.getModelId() + "";
+        String customModelId = blocklyProject.getCustomModelId();
+        BlocklyProjectParameter blocklyProjectParameter = new BlocklyProjectParameter();
+        blocklyProjectParameter.setXmlId(blocklyProject.getXmlId());
+        blocklyProjectParameter.setIsDeleted("0");
+        blocklyProjectParameter.setFileName(blocklyProject.getXmlName());
+        blocklyProjectParameter.setCustomModelId(blocklyProject.getCustomModelId());
+        blocklyProjectParameter.setBlocklyVersion(blocklyProject.getBlocklyVersion());
+        blocklyProjectParameter.setBlocklyType(blocklyProject.getBlocklyType());
+        blocklyProjectParameter.setLastUploadTime(blocklyProject.getLastUploadTime());
+        blocklyProjectParameter.setModelId(blocklyProject.getModelId() + "");
+        blocklyProjectParameter.setModelType(blocklyProject.getModelType());
+        blocklyProjectParameter.setFileUrl(blocklyProject.getFileUrl());
+        ArrayList arrayList = new ArrayList();
+        this.a = Cache.getInstance().getUserToken();
+        UploadModelProgramBean uploadModelProgramBean = new UploadModelProgramBean(this.a, str, customModelId);
+        if (i == 1) {
+            arrayList.add(blocklyProjectParameter);
+            uploadModelProgramBean.setAddPrograms(arrayList);
+        } else if (i == 0) {
+            arrayList.add(blocklyProjectParameter);
+            uploadModelProgramBean.setUpdatePrograms(arrayList);
+        } else if (i == -1) {
+            blocklyProjectParameter.setLastUploadTime(SystemUtils.a());
+            arrayList.add(blocklyProjectParameter);
+            uploadModelProgramBean.setDeletePrograms(arrayList);
+        }
+        this.c.uploadPrograms(uploadModelProgramBean).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<Object>>() { // from class: com.ubt.jimu.sync.OfflineBlockProgramUpload.2
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<Object> apiResponse) throws Exception {
+                if (apiResponse != null && apiResponse.isStatus()) {
+                    LogUtils.c("上传到公司服务器成功：" + blocklyProject.getDefaultName());
+                    int i2 = i;
+                    if (i2 != 1 && i2 != 0) {
+                        OfflineBlockProgramUpload.this.b.deleteBlocklyProject(blocklyProject.getXmlId());
+                        return;
+                    }
+                    OfflineBlockProgramUpload.this.b.setServiceUplaodState(blocklyProject.getXmlId(), true);
+                    OfflineBlockProgramUpload.this.b.isFirs(blocklyProject.getXmlId(), 1);
+                    OfflineBlockProgramUpload.this.b.setQiNiuUplaodState(blocklyProject.getXmlId(), true);
+                    OfflineBlockProgramUpload.this.b.setsetModifyState(blocklyProject.getXmlId(), false);
+                }
+            }
+        });
+    }
+
+    public void a() {
+        List<BlocklyProject> modifyBlocklyOfflineData;
+        if (this.c == null || (modifyBlocklyOfflineData = this.b.getModifyBlocklyOfflineData()) == null || modifyBlocklyOfflineData.size() == 0) {
+            return;
+        }
+        Iterator<BlocklyProject> it = modifyBlocklyOfflineData.iterator();
+        while (it.hasNext()) {
+            a(it.next());
+        }
+    }
+
+    public void a(final BlocklyProject blocklyProject) {
+        if (blocklyProject == null || blocklyProject.getModelId() <= 0) {
+            return;
+        }
+        this.a = Cache.getInstance().getUserToken();
+        this.c.programs(this.a, blocklyProject.getModelId()).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<BlocklyProgramsReturnBean>() { // from class: com.ubt.jimu.sync.OfflineBlockProgramUpload.3
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(BlocklyProgramsReturnBean blocklyProgramsReturnBean) throws Exception {
+                List<BlocklyProgramsReturnBean.ModelsBean> models;
+                if (blocklyProgramsReturnBean == null || !blocklyProgramsReturnBean.isStatus() || (models = blocklyProgramsReturnBean.getModels()) == null || models.size() == 0) {
+                    return;
+                }
+                OfflineBlockProgramUpload.this.a(models, blocklyProject);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void a(List<BlocklyProgramsReturnBean.ModelsBean> list, BlocklyProject blocklyProject) {
+        for (BlocklyProgramsReturnBean.ModelsBean modelsBean : list) {
+            String xmlId = modelsBean.getXmlId();
+            String xmlId2 = blocklyProject.getXmlId();
+            if (!TextUtils.isEmpty(xmlId2) && xmlId2.equals(xmlId)) {
+                String isDeleted = blocklyProject.getIsDeleted();
+                String isDeleted2 = modelsBean.getIsDeleted();
+                if ("1".equals(isDeleted) && !"1".equals(isDeleted2)) {
+                    blocklyProject.setFileUrl(modelsBean.getFileUrl());
+                    b(-1, blocklyProject);
+                } else if ("1".equals(isDeleted2)) {
+                    this.b.deleteBlocklyProject(blocklyProject.getXmlId());
+                } else {
+                    long lastUploadTime = blocklyProject.getLastUploadTime();
+                    long lastUploadTime2 = modelsBean.getLastUploadTime();
+                    if (lastUploadTime != lastUploadTime2) {
+                        boolean isUploadQiNiu = blocklyProject.getIsUploadQiNiu();
+                        boolean isUploadService = blocklyProject.getIsUploadService();
+                        if (lastUploadTime > lastUploadTime2 && !isUploadQiNiu) {
+                            blocklyProject.setFileUrl(modelsBean.getFileUrl());
+                            blocklyProject.setLocalFilePath(modelsBean.getLoaclFilePath());
+                            a(0, blocklyProject);
+                        } else if (lastUploadTime > lastUploadTime2 && isUploadQiNiu && !isUploadService) {
+                            blocklyProject.setFileUrl(modelsBean.getFileUrl());
+                            b(0, blocklyProject);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void a(String str, int i) {
+        this.b.uploadUserIdAndModelId(str, i);
+    }
+}

sources/com/ubt/jimu/sync/OfflineDataUploadTool.java

@@ -0,0 +1,139 @@
+package com.ubt.jimu.sync;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.db.diy.DiyDBModel;
+import com.ubt.jimu.base.db.user.UserDbHandler;
+import com.ubt.jimu.base.entities.User;
+import com.ubt.jimu.transport3.api.DiyTransportServiceProxy;
+import com.ubt.jimu.utils.LogUtils;
+
+/* loaded from: classes2.dex */
+public class OfflineDataUploadTool implements CreationModelListener {
+    private static OfflineDataUploadTool i;
+    private OfflineDiyDBModelUpload a;
+    private OfflineUploadAction b;
+    private OfflineBlockProgramUpload c;
+    private OfflineSoundUpload d;
+    private OfflineModelFilesUpload e;
+    private OfflineMotionUpload f;
+    private String g;
+    private DiyTransportServiceProxy h;
+
+    private OfflineDataUploadTool() {
+        this.g = Cache.getInstance().getUserId();
+        if (TextUtils.isEmpty(this.g)) {
+            this.g = "local";
+        }
+        Cache.getInstance().getUserToken();
+        if (this.h == null) {
+            this.h = new DiyTransportServiceProxy();
+        }
+        if (this.a == null) {
+            this.a = new OfflineDiyDBModelUpload(this.h);
+        }
+        if (this.b == null) {
+            this.b = new OfflineUploadAction(this.h);
+        }
+        if (this.c == null) {
+            this.c = new OfflineBlockProgramUpload(this.h);
+        }
+        if (this.d == null) {
+            this.d = new OfflineSoundUpload(this.h);
+        }
+        if (this.f == null) {
+            this.f = new OfflineMotionUpload(this.h);
+        }
+        if (this.e == null) {
+            this.e = new OfflineModelFilesUpload(this.h);
+        }
+    }
+
+    public static OfflineDataUploadTool h() {
+        if (i == null) {
+            i = new OfflineDataUploadTool();
+        }
+        return i;
+    }
+
+    @Override // com.ubt.jimu.sync.CreationModelListener
+    public void a(DiyDBModel diyDBModel) {
+        if (diyDBModel == null || TextUtils.isEmpty(diyDBModel.getCustomModelId()) || diyDBModel.getModelId().intValue() <= 0) {
+            return;
+        }
+        this.e.a(diyDBModel.getCustomModelId(), diyDBModel.getModelId().intValue());
+        this.b.a(diyDBModel.getCustomModelId(), diyDBModel.getModelId().intValue());
+        this.f.a(diyDBModel.getCustomModelId(), diyDBModel.getModelId().intValue());
+        this.c.a(diyDBModel.getCustomModelId(), diyDBModel.getModelId().intValue());
+    }
+
+    public void b() {
+        if (Cache.getInstance().getUserId().equals("local")) {
+            return;
+        }
+        this.b.c();
+        this.b.b();
+        this.b.a();
+    }
+
+    public void c() {
+        this.c.c();
+        this.c.b();
+        this.c.a();
+    }
+
+    public synchronized void d() {
+        String userId = Cache.getInstance().getUserId();
+        Cache.getInstance().getUserToken();
+        if (!TextUtils.isEmpty(userId) && !"local".equals(userId)) {
+            this.a.a(this);
+            this.a.b();
+        }
+    }
+
+    public void e() {
+        User user = UserDbHandler.getUser();
+        if (user != null && user.getUserId() > 0) {
+            String token = user.getToken();
+            this.e.b(this.g, token);
+            this.e.c(this.g, token);
+            this.e.d(this.g, token);
+            this.e.e(this.g, token);
+            this.e.f(this.g, token);
+            this.e.g(this.g, token);
+            this.e.a(this.g, token);
+        }
+    }
+
+    public void f() {
+        String userId = Cache.getInstance().getUserId();
+        if (TextUtils.isEmpty(userId) || "local".equals(userId)) {
+            return;
+        }
+        this.f.a();
+        this.f.b();
+    }
+
+    public void g() {
+        this.d.c();
+        this.d.b();
+        this.d.a();
+    }
+
+    @Override // com.ubt.jimu.sync.CreationModelListener
+    public void a() {
+        LogUtils.c("所有模型创建完毕，执行上传动作、编程、等");
+        String userId = Cache.getInstance().getUserId();
+        if (TextUtils.isEmpty(userId) || "local".equals(userId)) {
+            return;
+        }
+        this.a.c();
+        this.a.a();
+        this.a.d();
+        e();
+        b();
+        f();
+        c();
+        g();
+    }
+}

sources/com/ubt/jimu/sync/OfflineDiyDBModelUpload.java

@@ -0,0 +1,240 @@
+package com.ubt.jimu.sync;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.db.diy.DiyDBModel;
+import com.ubt.jimu.base.http.ApiResponse;
+import com.ubt.jimu.blockly.networkSync.utils.QiNiuUtils;
+import com.ubt.jimu.transport3.api.DiyTransportServiceProxy;
+import com.ubt.jimu.transport3.bean.PageResultBean;
+import com.ubt.jimu.transport3.bean.response.DiyModelBean;
+import com.ubt.jimu.transport3.bean.response.SaveOrUpdateModelBean;
+import com.ubt.jimu.transport3.dao.DiyDBModelDBHandler;
+import com.ubt.jimu.upload.DataUploadProxy;
+import com.ubt.jimu.upload.SimpleUploadCallback;
+import com.ubt.jimu.upload.UploadFilePathUtils;
+import com.ubt.jimu.upload.UploadRequest;
+import com.ubt.jimu.upload.UploadResponse;
+import com.ubt.jimu.utils.LogUtils;
+import io.reactivex.Observer;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.functions.Consumer;
+import io.reactivex.schedulers.Schedulers;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class OfflineDiyDBModelUpload {
+    private String a;
+    private String b;
+    private DiyDBModelDBHandler c;
+    private DiyTransportServiceProxy d;
+    private CreationModelListener e;
+    private List<String> f;
+
+    public OfflineDiyDBModelUpload(DiyTransportServiceProxy diyTransportServiceProxy) {
+        this.d = diyTransportServiceProxy;
+        if (this.c == null) {
+            this.c = DiyDBModelDBHandler.getInstance();
+        }
+        this.f = new ArrayList();
+    }
+
+    public void a() {
+        List<DiyDBModel> deletedModelDB = this.c.getDeletedModelDB();
+        if (deletedModelDB == null || deletedModelDB.size() == 0) {
+            return;
+        }
+        ArrayList arrayList = new ArrayList();
+        for (DiyDBModel diyDBModel : deletedModelDB) {
+            HashMap<String, Object> hashMap = new HashMap<>();
+            hashMap.put("lastUploadTime", Long.valueOf(diyDBModel.getLastUploadTime()));
+            hashMap.put("modelId", diyDBModel.getModelId());
+            arrayList.add(hashMap);
+        }
+        a(arrayList, deletedModelDB);
+    }
+
+    public void b() {
+        List<DiyDBModel> qiNiuDefeatModelDB = this.c.getQiNiuDefeatModelDB();
+        if (qiNiuDefeatModelDB == null || qiNiuDefeatModelDB.size() == 0) {
+            CreationModelListener creationModelListener = this.e;
+            if (creationModelListener != null) {
+                creationModelListener.a();
+                return;
+            }
+            return;
+        }
+        for (DiyDBModel diyDBModel : qiNiuDefeatModelDB) {
+            this.f.add(diyDBModel.getCustomModelId());
+            a(1, diyDBModel);
+        }
+    }
+
+    public void c() {
+        List<DiyDBModel> ubtServiceDefeatModelDB = this.c.getUbtServiceDefeatModelDB();
+        if (ubtServiceDefeatModelDB == null || ubtServiceDefeatModelDB.size() == 0) {
+            return;
+        }
+        Iterator<DiyDBModel> it = ubtServiceDefeatModelDB.iterator();
+        while (it.hasNext()) {
+            a(it.next());
+        }
+    }
+
+    public void d() {
+        if (this.d == null) {
+            return;
+        }
+        this.f.clear();
+        Cache.getInstance().getUserToken();
+        String userId = Cache.getInstance().getUserId();
+        String userToken = Cache.getInstance().getUserToken();
+        if (TextUtils.isEmpty(userId) || "local".equals(userId)) {
+            return;
+        }
+        this.d.getModels(userId, userToken).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<PageResultBean<DiyModelBean>>>() { // from class: com.ubt.jimu.sync.OfflineDiyDBModelUpload.4
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<PageResultBean<DiyModelBean>> apiResponse) throws Exception {
+                PageResultBean<DiyModelBean> models;
+                List<DiyModelBean> data;
+                if (apiResponse == null || !apiResponse.isStatus() || (models = apiResponse.getModels()) == null || (data = models.getData()) == null || data.size() == 0) {
+                    return;
+                }
+                OfflineDiyDBModelUpload.this.a(data);
+            }
+        });
+    }
+
+    private void b(final DiyDBModel diyDBModel) {
+        String str = QiNiuUtils.getAndroidSystemRootPath() + QiNiuUtils.getDiyModelQiNiuPath(diyDBModel);
+        LogUtils.c("本地文件路径：" + str);
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        if (!new File(str).exists()) {
+            LogUtils.c("Diy file not exists");
+            return;
+        }
+        UploadRequest uploadRequest = new UploadRequest();
+        uploadRequest.a(UploadFilePathUtils.a(str));
+        uploadRequest.b(str);
+        DataUploadProxy.c().a(uploadRequest, new SimpleUploadCallback() { // from class: com.ubt.jimu.sync.OfflineDiyDBModelUpload.1
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadFaulted(UploadRequest uploadRequest2, Exception exc) {
+                boolean remove = OfflineDiyDBModelUpload.this.f.remove(diyDBModel.getCustomModelId());
+                if (OfflineDiyDBModelUpload.this.f.size() == 0 && remove && OfflineDiyDBModelUpload.this.e != null) {
+                    OfflineDiyDBModelUpload.this.e.a();
+                }
+            }
+
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadSucceed(UploadResponse uploadResponse) {
+                diyDBModel.setCompressImagePath(uploadResponse.c());
+                if (OfflineDiyDBModelUpload.this.c.updateQiNiuUrl(diyDBModel)) {
+                    OfflineDiyDBModelUpload.this.a(diyDBModel);
+                    return;
+                }
+                boolean remove = OfflineDiyDBModelUpload.this.f.remove(diyDBModel.getCustomModelId());
+                if (OfflineDiyDBModelUpload.this.f.size() == 0 && remove && OfflineDiyDBModelUpload.this.e != null) {
+                    OfflineDiyDBModelUpload.this.e.a();
+                }
+            }
+        });
+    }
+
+    public void a(int i, DiyDBModel diyDBModel) {
+        String userId = Cache.getInstance().getUserId();
+        this.b = Cache.getInstance().getUserToken();
+        if ("local".equals(userId) || TextUtils.isEmpty(userId)) {
+            return;
+        }
+        b(diyDBModel);
+    }
+
+    public void a(final DiyDBModel diyDBModel) {
+        if (this.d == null) {
+            return;
+        }
+        this.b = Cache.getInstance().getUserToken();
+        this.d.saveOrUpdateModel(diyDBModel, this.b).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Observer<ApiResponse<SaveOrUpdateModelBean>>() { // from class: com.ubt.jimu.sync.OfflineDiyDBModelUpload.2
+            @Override // io.reactivex.Observer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void onNext(ApiResponse<SaveOrUpdateModelBean> apiResponse) {
+                SaveOrUpdateModelBean models;
+                if (apiResponse == null || !apiResponse.isStatus() || (models = apiResponse.getModels()) == null) {
+                    return;
+                }
+                diyDBModel.setModelId(Integer.valueOf(models.getModelId()));
+                diyDBModel.setModify(false);
+                diyDBModel.setLastUploadTime(models.getLastUploadTime());
+                OfflineDiyDBModelUpload.this.c.insertOrUpdate(diyDBModel);
+                if (OfflineDiyDBModelUpload.this.e != null) {
+                    OfflineDiyDBModelUpload.this.e.a(diyDBModel);
+                }
+            }
+
+            @Override // io.reactivex.Observer
+            public void onComplete() {
+                boolean remove = OfflineDiyDBModelUpload.this.f.remove(diyDBModel.getCustomModelId());
+                if (OfflineDiyDBModelUpload.this.f.size() == 0 && remove && OfflineDiyDBModelUpload.this.e != null) {
+                    OfflineDiyDBModelUpload.this.e.a();
+                    LogUtils.c("本次创建模型逻辑完成-" + OfflineDiyDBModelUpload.this.a + OfflineDiyDBModelUpload.this.f.size());
+                }
+            }
+
+            @Override // io.reactivex.Observer
+            public void onError(Throwable th) {
+                diyDBModel.setModify(true);
+                OfflineDiyDBModelUpload.this.c.insertOrUpdate(diyDBModel);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onSubscribe(Disposable disposable) {
+            }
+        });
+    }
+
+    public void a(List<HashMap<String, Object>> list, final List<DiyDBModel> list2) {
+        if (list == null || list.size() == 0 || this.d == null) {
+            return;
+        }
+        this.b = Cache.getInstance().getUserToken();
+        this.a = Cache.getInstance().getUserId();
+        this.d.deleteModels(this.a, this.b, list).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<Object>>() { // from class: com.ubt.jimu.sync.OfflineDiyDBModelUpload.3
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<Object> apiResponse) throws Exception {
+                if (apiResponse == null || !apiResponse.isStatus()) {
+                    return;
+                }
+                OfflineDiyDBModelUpload.this.c.deleteModels(list2);
+            }
+        });
+    }
+
+    public void a(List<DiyModelBean> list) {
+        if (this.c == null) {
+            return;
+        }
+        for (DiyModelBean diyModelBean : list) {
+            DiyDBModel diyDBModelByModelId = this.c.getDiyDBModelByModelId(diyModelBean.getModelId());
+            if (diyDBModelByModelId != null) {
+                if (diyModelBean.getIsDelete() == 1) {
+                    this.c.deleteDiyDBModelByModelId(diyModelBean.getModelId());
+                } else if (diyDBModelByModelId.getLastUploadTime() > diyModelBean.getLastUploadTime()) {
+                    a(0, diyDBModelByModelId);
+                }
+            }
+        }
+    }
+
+    public void a(CreationModelListener creationModelListener) {
+        this.e = creationModelListener;
+    }
+}

sources/com/ubt/jimu/sync/OfflineModelFilesUpload.java

@@ -0,0 +1,223 @@
+package com.ubt.jimu.sync;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.http.ApiResponse;
+import com.ubt.jimu.blockly.networkSync.utils.QiNiuUtils;
+import com.ubt.jimu.transport.model.TransportFile;
+import com.ubt.jimu.transport3.api.DiyTransportServiceProxy;
+import com.ubt.jimu.transport3.bean.request.UploadModelFileBean;
+import com.ubt.jimu.transport3.bean.response.TransportFileBean;
+import com.ubt.jimu.transport3.dao.TransportFileDbHandler2;
+import com.ubt.jimu.upload.DataUploadProxy;
+import com.ubt.jimu.upload.SimpleUploadCallback;
+import com.ubt.jimu.upload.UploadFilePathUtils;
+import com.ubt.jimu.upload.UploadRequest;
+import com.ubt.jimu.upload.UploadResponse;
+import com.ubt.jimu.utils.LogUtils;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.functions.Consumer;
+import io.reactivex.schedulers.Schedulers;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class OfflineModelFilesUpload {
+    private String a;
+    private DiyTransportServiceProxy b;
+    private TransportFileDbHandler2 c;
+
+    public OfflineModelFilesUpload(DiyTransportServiceProxy diyTransportServiceProxy) {
+        this.b = diyTransportServiceProxy;
+        if (this.c == null) {
+            this.c = TransportFileDbHandler2.getInstance();
+        }
+    }
+
+    public void b(String str, String str2) {
+        a(str, str2, this.c.getOfflineController());
+    }
+
+    public void c(String str, String str2) {
+        a(str, str2, this.c.getOfflineControllerMenuList());
+    }
+
+    public void d(String str, String str2) {
+        a(str, str2, this.c.getOfflineDesc());
+    }
+
+    public void e(String str, String str2) {
+        a(str, str2, this.c.getOfflineServosFile());
+    }
+
+    public void f(String str, String str2) {
+        a(str, str2, this.c.getOfflineVideo());
+    }
+
+    public void g(String str, String str2) {
+        a(str, str2, this.c.getOfflineVideoCover());
+    }
+
+    private void c(final int i, final TransportFile transportFile) {
+        String modelFileLocal = QiNiuUtils.getModelFileLocal(transportFile);
+        LogUtils.c("localPath:" + modelFileLocal);
+        if (TextUtils.isEmpty(modelFileLocal)) {
+            return;
+        }
+        if (!new File(modelFileLocal).exists()) {
+            LogUtils.c("Diy file not exists");
+            return;
+        }
+        UploadRequest uploadRequest = new UploadRequest();
+        uploadRequest.a(UploadFilePathUtils.a(modelFileLocal));
+        uploadRequest.b(modelFileLocal);
+        DataUploadProxy.c().a(uploadRequest, new SimpleUploadCallback() { // from class: com.ubt.jimu.sync.OfflineModelFilesUpload.2
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadFaulted(UploadRequest uploadRequest2, Exception exc) {
+                transportFile.setUploaded(false);
+                try {
+                    OfflineModelFilesUpload.this.c.insertOrUpdate2(transportFile);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadSucceed(UploadResponse uploadResponse) {
+                transportFile.setUploaded(true);
+                transportFile.setFileUrl(uploadResponse.c());
+                try {
+                    OfflineModelFilesUpload.this.c.insertOrUpdate2(transportFile);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                OfflineModelFilesUpload.this.b(i, transportFile);
+            }
+        });
+    }
+
+    public void a(String str, String str2) {
+        a(str, str2, this.c.getOfflineBgFile());
+    }
+
+    public void b(int i, final TransportFile transportFile) {
+        this.a = Cache.getInstance().getUserToken();
+        UploadModelFileBean uploadModelFileBean = new UploadModelFileBean(transportFile.getUserId(), this.a, (int) transportFile.getModelId(), transportFile.getCustomModelId());
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(transportFile);
+        if (i == 1) {
+            uploadModelFileBean.setAddFiles(arrayList);
+        } else if (i == 0) {
+            uploadModelFileBean.setUpdateFiles(arrayList);
+        } else if (i == -1) {
+            uploadModelFileBean.setDeleteFiles(arrayList);
+        }
+        this.b.uploadModelFiles(uploadModelFileBean).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<Object>>() { // from class: com.ubt.jimu.sync.OfflineModelFilesUpload.3
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<Object> apiResponse) throws Exception {
+                if (apiResponse == null || !apiResponse.isStatus()) {
+                    return;
+                }
+                transportFile.setId(1L);
+                transportFile.setIsModify(false);
+                OfflineModelFilesUpload.this.c.insertOrUpdate(transportFile);
+            }
+        });
+    }
+
+    private void a(String str, String str2, List<TransportFile> list) {
+        if (list == null || list.size() == 0) {
+            return;
+        }
+        for (final TransportFile transportFile : list) {
+            long modelId = transportFile.getModelId();
+            if (modelId != 0) {
+                LogUtils.c("token:" + str2);
+                this.b.getModelFiles(str, (int) modelId, str2).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<List<TransportFileBean>>>() { // from class: com.ubt.jimu.sync.OfflineModelFilesUpload.1
+                    @Override // io.reactivex.functions.Consumer
+                    /* renamed from: a, reason: merged with bridge method [inline-methods] */
+                    public void accept(ApiResponse<List<TransportFileBean>> apiResponse) throws Exception {
+                        TransportFileBean a = OfflineModelFilesUpload.this.a(apiResponse, transportFile);
+                        if (a == null || !a.isOutTime()) {
+                            if ("1".equals(transportFile.getModelType())) {
+                                if (a == null) {
+                                    OfflineModelFilesUpload.this.a(1, transportFile);
+                                    return;
+                                } else {
+                                    if (a.isOutTime()) {
+                                        return;
+                                    }
+                                    OfflineModelFilesUpload.this.a(0, transportFile);
+                                    return;
+                                }
+                            }
+                            boolean uploaded = transportFile.getUploaded();
+                            long id = transportFile.getId();
+                            if (uploaded) {
+                                if (id == 0) {
+                                    OfflineModelFilesUpload.this.b(1, transportFile);
+                                    return;
+                                } else {
+                                    OfflineModelFilesUpload.this.b(0, transportFile);
+                                    return;
+                                }
+                            }
+                            if (id == 0) {
+                                OfflineModelFilesUpload.this.a(1, transportFile);
+                            } else {
+                                OfflineModelFilesUpload.this.a(0, transportFile);
+                            }
+                        }
+                    }
+                });
+            }
+        }
+    }
+
+    public void a(int i, TransportFile transportFile) {
+        String userId = Cache.getInstance().getUserId();
+        this.a = Cache.getInstance().getUserToken();
+        if ("local".equals(userId) || TextUtils.isEmpty(userId)) {
+            return;
+        }
+        c(i, transportFile);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public TransportFileBean a(ApiResponse<List<TransportFileBean>> apiResponse, TransportFile transportFile) {
+        List<TransportFileBean> models;
+        if (apiResponse != null && apiResponse.getModels() != null && apiResponse.getModels().size() != 0 && (models = apiResponse.getModels()) != null && models.size() > 0) {
+            for (int i = 0; i < models.size(); i++) {
+                TransportFileBean transportFileBean = models.get(i);
+                String customModelId = transportFileBean.getCustomModelId();
+                String fileName = transportFileBean.getFileName();
+                String fileType = transportFileBean.getFileType();
+                long lastUploadTime = transportFileBean.getLastUploadTime();
+                int isDeleted = transportFileBean.getIsDeleted();
+                String customModelId2 = transportFile.getCustomModelId();
+                String fileName2 = transportFile.getFileName();
+                String fileType2 = transportFile.getFileType();
+                long lastUploadTime2 = transportFile.getLastUploadTime();
+                if (customModelId.equals(customModelId2) && fileName.equals(fileName2) && fileType.equals(fileType2)) {
+                    LogUtils.c("离线数据同步：" + fileName2 + " " + fileName);
+                    if (lastUploadTime >= lastUploadTime2) {
+                        transportFileBean.setOutTime(true);
+                    } else {
+                        transportFileBean.setOutTime(false);
+                    }
+                    if (isDeleted == 1) {
+                        transportFileBean.setOutTime(true);
+                    }
+                    return transportFileBean;
+                }
+            }
+        }
+        return null;
+    }
+
+    public void a(String str, int i) {
+        this.c.uploadUserIdAndModelId(str, i);
+    }
+}

sources/com/ubt/jimu/sync/OfflineMotionUpload.java

@@ -0,0 +1,169 @@
+package com.ubt.jimu.sync;
+
+import android.text.TextUtils;
+import com.google.gson.reflect.TypeToken;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.http.ApiResponse;
+import com.ubt.jimu.blockly.bean.JimuMotion;
+import com.ubt.jimu.blockly.bean.JimuMotionParameter;
+import com.ubt.jimu.blockly.bean.JimuMotionReturnBean;
+import com.ubt.jimu.blockly.dao.JimuMotionDbHandler;
+import com.ubt.jimu.transport3.api.DiyTransportServiceProxy;
+import com.ubt.jimu.transport3.bean.request.UploadModelMotionBean;
+import com.ubt.jimu.utils.JsonHelper;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.functions.Consumer;
+import io.reactivex.schedulers.Schedulers;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class OfflineMotionUpload {
+    private String a;
+    private String b;
+    private JimuMotionDbHandler c;
+    private DiyTransportServiceProxy d;
+
+    public OfflineMotionUpload(DiyTransportServiceProxy diyTransportServiceProxy) {
+        this.d = diyTransportServiceProxy;
+        if (this.c == null) {
+            this.c = JimuMotionDbHandler.getInstance();
+        }
+    }
+
+    public void b() {
+        List<JimuMotion> syncModelMotions = this.c.getSyncModelMotions();
+        if (syncModelMotions == null || syncModelMotions.size() == 0) {
+            return;
+        }
+        Iterator<JimuMotion> it = syncModelMotions.iterator();
+        while (it.hasNext()) {
+            a(1, it.next());
+        }
+    }
+
+    public void a() {
+        List<JimuMotion> syncAmendMotions = this.c.getSyncAmendMotions();
+        if (this.d == null || syncAmendMotions == null || syncAmendMotions.size() == 0) {
+            return;
+        }
+        Iterator<JimuMotion> it = syncAmendMotions.iterator();
+        while (it.hasNext()) {
+            a(it.next());
+        }
+    }
+
+    private void a(final JimuMotion jimuMotion) {
+        if (jimuMotion == null) {
+            return;
+        }
+        this.b = Cache.getInstance().getUserToken();
+        this.d.postures(this.b, jimuMotion.getModelId() + "").subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<JimuMotionReturnBean>() { // from class: com.ubt.jimu.sync.OfflineMotionUpload.1
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(JimuMotionReturnBean jimuMotionReturnBean) throws Exception {
+                List<JimuMotionReturnBean.ModelsBean> models;
+                if (!jimuMotionReturnBean.isStatus() || (models = jimuMotionReturnBean.getModels()) == null || models.size() == 0) {
+                    return;
+                }
+                OfflineMotionUpload.this.a(models, jimuMotion);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void a(List<JimuMotionReturnBean.ModelsBean> list, JimuMotion jimuMotion) {
+        for (JimuMotionReturnBean.ModelsBean modelsBean : list) {
+            String postureId = modelsBean.getPostureId();
+            String actionID = jimuMotion.getActionID();
+            if (!TextUtils.isEmpty(postureId) && postureId.equals(actionID)) {
+                if ("1".equals(modelsBean.getIsDeleted())) {
+                    this.c.delete(jimuMotion);
+                } else {
+                    long lastUploadTime = modelsBean.getLastUploadTime();
+                    long lastUploadTime2 = jimuMotion.getLastUploadTime();
+                    if (lastUploadTime2 != lastUploadTime) {
+                        if ("1".equals(jimuMotion.getIsDeleted()) && "0".equals(modelsBean.getIsDeleted())) {
+                            JimuMotion a = a(modelsBean);
+                            a.setLastUploadTime(lastUploadTime2);
+                            a(-1, a);
+                        } else if (lastUploadTime2 > lastUploadTime) {
+                            JimuMotion a2 = a(modelsBean);
+                            a2.setLastUploadTime(lastUploadTime2);
+                            a(0, a2);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void a(final int i, final JimuMotion jimuMotion) {
+        if (jimuMotion == null || this.d == null) {
+            return;
+        }
+        this.b = Cache.getInstance().getUserToken();
+        ArrayList arrayList = new ArrayList();
+        UploadModelMotionBean uploadModelMotionBean = new UploadModelMotionBean(this.b, jimuMotion.getModelId() + "", jimuMotion.getCustomModelId());
+        JimuMotionParameter jimuMotionParameter = new JimuMotionParameter();
+        jimuMotionParameter.setCustomModelId(jimuMotion.getCustomModelId());
+        jimuMotionParameter.setIsDeleted("0");
+        jimuMotionParameter.setModelId(jimuMotion.getModelId() + "");
+        jimuMotionParameter.setLastUploadTime(jimuMotion.getLastUploadTime());
+        jimuMotionParameter.setModelType(jimuMotion.getModelType());
+        jimuMotionParameter.setPostureCmd(JsonHelper.a(jimuMotion.getActionData()));
+        jimuMotionParameter.setPostureId(jimuMotion.getActionID());
+        jimuMotionParameter.setPostureName(jimuMotion.getActionName());
+        arrayList.add(jimuMotionParameter);
+        if (i == -1) {
+            uploadModelMotionBean.setDeletePostures(arrayList);
+        } else if (i == 0) {
+            uploadModelMotionBean.setUpdatePostures(arrayList);
+        } else if (i == 1) {
+            uploadModelMotionBean.setAddPostures(arrayList);
+        }
+        this.d.uploadPostures(uploadModelMotionBean).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<Object>>() { // from class: com.ubt.jimu.sync.OfflineMotionUpload.2
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<Object> apiResponse) throws Exception {
+                if (apiResponse == null || !apiResponse.isStatus()) {
+                    return;
+                }
+                int i2 = i;
+                if (i2 != 1 && i2 != 0) {
+                    OfflineMotionUpload.this.c.deleteJimuMotionByModeelId(jimuMotion.getActionID());
+                    return;
+                }
+                jimuMotion.setIsFirst(1);
+                jimuMotion.setIsUploadService(true);
+                OfflineMotionUpload.this.c.insertOrUpdate(jimuMotion);
+            }
+        });
+    }
+
+    private JimuMotion a(JimuMotionReturnBean.ModelsBean modelsBean) {
+        this.a = Cache.getInstance().getUserId();
+        JimuMotion jimuMotion = new JimuMotion();
+        Type type = new TypeToken<ArrayList<JimuMotion.JimuServo>>(this) { // from class: com.ubt.jimu.sync.OfflineMotionUpload.3
+        }.getType();
+        if (TextUtils.isEmpty(modelsBean.getPostureCmd())) {
+            return null;
+        }
+        jimuMotion.setActionData((ArrayList) JsonHelper.a(modelsBean.getPostureCmd(), type));
+        jimuMotion.setActionID(modelsBean.getPostureId());
+        jimuMotion.setActionName(modelsBean.getPostureName());
+        jimuMotion.setIsDeleted("0");
+        jimuMotion.setCustomModelId(modelsBean.getCustomModelId());
+        jimuMotion.setUserId(this.a);
+        jimuMotion.setModelId(modelsBean.getModelId());
+        jimuMotion.setModelType(modelsBean.getModelType());
+        jimuMotion.setLastUploadTime(modelsBean.getLastUploadTime());
+        return jimuMotion;
+    }
+
+    public void a(String str, int i) {
+        this.c.uploadUserIdAndModelId(str, i);
+    }
+}

sources/com/ubt/jimu/sync/OfflineSoundUpload.java

@@ -0,0 +1,176 @@
+package com.ubt.jimu.sync;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.http.ApiResponse;
+import com.ubt.jimu.blockly.bean.JimuSound;
+import com.ubt.jimu.blockly.bean.JimuSoundParameter;
+import com.ubt.jimu.blockly.dao.JimuSoundDbHandler;
+import com.ubt.jimu.blockly.networkSync.utils.QiNiuUtils;
+import com.ubt.jimu.transport3.api.DiyTransportServiceProxy;
+import com.ubt.jimu.transport3.bean.request.UploadAudioBean;
+import com.ubt.jimu.upload.DataUploadProxy;
+import com.ubt.jimu.upload.SimpleUploadCallback;
+import com.ubt.jimu.upload.UploadFilePathUtils;
+import com.ubt.jimu.upload.UploadRequest;
+import com.ubt.jimu.upload.UploadResponse;
+import com.ubt.jimu.utils.LogUtils;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.functions.Consumer;
+import io.reactivex.schedulers.Schedulers;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class OfflineSoundUpload {
+    private String a;
+    private String b;
+    private JimuSoundDbHandler c;
+    private DiyTransportServiceProxy d;
+
+    public OfflineSoundUpload(DiyTransportServiceProxy diyTransportServiceProxy) {
+        this.d = diyTransportServiceProxy;
+        if (this.c == null) {
+            this.c = JimuSoundDbHandler.getInstance();
+        }
+    }
+
+    public void b() {
+        List<JimuSound> offlineQiNiuFile = this.c.getOfflineQiNiuFile();
+        if (offlineQiNiuFile == null || offlineQiNiuFile.size() == 0) {
+            return;
+        }
+        Iterator<JimuSound> it = offlineQiNiuFile.iterator();
+        while (it.hasNext()) {
+            a(1, it.next());
+        }
+    }
+
+    public void c() {
+        List<JimuSound> offlineServiceFile = this.c.getOfflineServiceFile();
+        if (offlineServiceFile == null || offlineServiceFile.size() == 0) {
+            return;
+        }
+        for (JimuSound jimuSound : offlineServiceFile) {
+            if ("1".equals(jimuSound.getIsDeleted())) {
+                b(-1, jimuSound);
+            } else {
+                b(1, jimuSound);
+            }
+        }
+    }
+
+    public void a(int i, JimuSound jimuSound) {
+        String userId = Cache.getInstance().getUserId();
+        this.b = Cache.getInstance().getUserToken();
+        if ("local".equals(userId) || TextUtils.isEmpty(userId)) {
+            return;
+        }
+        c(i, jimuSound);
+    }
+
+    public void b(final int i, final JimuSound jimuSound) {
+        DiyTransportServiceProxy diyTransportServiceProxy = new DiyTransportServiceProxy();
+        this.a = Cache.getInstance().getUserId();
+        this.b = Cache.getInstance().getUserToken();
+        UploadAudioBean uploadAudioBean = new UploadAudioBean(this.b, this.a);
+        ArrayList arrayList = new ArrayList();
+        JimuSoundParameter jimuSoundParameter = new JimuSoundParameter();
+        jimuSoundParameter.setAudioId(jimuSound.getKey());
+        jimuSoundParameter.setLastUploadTime(jimuSound.getLastUploadTime());
+        jimuSoundParameter.setUserId(this.a);
+        jimuSoundParameter.setDescription(jimuSound.getDescription());
+        jimuSoundParameter.setDuration(jimuSound.getDuration());
+        jimuSoundParameter.setFileUrl(UploadFilePathUtils.a() + "/" + QiNiuUtils.getJimuSoundQiNiuKey(jimuSound));
+        jimuSoundParameter.setType(jimuSound.getType());
+        if (i == -1) {
+            jimuSoundParameter.setIsDeleted(1);
+            arrayList.add(jimuSoundParameter);
+            uploadAudioBean.setDeleteAudios(arrayList);
+        } else if (i == 0) {
+            jimuSoundParameter.setIsDeleted(0);
+            arrayList.add(jimuSoundParameter);
+            uploadAudioBean.setUpdateAudios(arrayList);
+        } else if (i == 1) {
+            jimuSoundParameter.setIsDeleted(0);
+            arrayList.add(jimuSoundParameter);
+            uploadAudioBean.setAddAudios(arrayList);
+        }
+        diyTransportServiceProxy.uploadAudios(uploadAudioBean).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<Object>>() { // from class: com.ubt.jimu.sync.OfflineSoundUpload.2
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<Object> apiResponse) throws Exception {
+                if (apiResponse == null || !apiResponse.isStatus()) {
+                    return;
+                }
+                int i2 = i;
+                if (i2 == 1 || i2 == 0) {
+                    OfflineSoundUpload.this.c.updateJimuSoundUbtServiceState(jimuSound, true);
+                } else {
+                    OfflineSoundUpload.this.c.deleteJimuSound(jimuSound);
+                }
+            }
+        });
+    }
+
+    public void a() {
+        DiyTransportServiceProxy diyTransportServiceProxy;
+        this.a = Cache.getInstance().getUserId();
+        this.b = Cache.getInstance().getUserToken();
+        if (TextUtils.isEmpty(this.a) || "local".equals(this.a) || (diyTransportServiceProxy = this.d) == null) {
+            return;
+        }
+        diyTransportServiceProxy.audios(this.b, this.a).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<List<JimuSound>>>() { // from class: com.ubt.jimu.sync.OfflineSoundUpload.3
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<List<JimuSound>> apiResponse) throws Exception {
+                List<JimuSound> models;
+                if (!apiResponse.isStatus() || (models = apiResponse.getModels()) == null || models.size() == 0) {
+                    return;
+                }
+                OfflineSoundUpload.this.a(models);
+            }
+        });
+    }
+
+    private void c(final int i, final JimuSound jimuSound) {
+        String localJimuSoundFilePath = QiNiuUtils.getLocalJimuSoundFilePath(jimuSound);
+        LogUtils.c("本地录音文件路径：" + localJimuSoundFilePath);
+        if (TextUtils.isEmpty(localJimuSoundFilePath)) {
+            return;
+        }
+        if (!new File(localJimuSoundFilePath).exists()) {
+            LogUtils.c(" Sound file not exists");
+            return;
+        }
+        UploadRequest uploadRequest = new UploadRequest();
+        uploadRequest.b(localJimuSoundFilePath);
+        uploadRequest.a(UploadFilePathUtils.a(localJimuSoundFilePath));
+        DataUploadProxy.c().a(uploadRequest, new SimpleUploadCallback() { // from class: com.ubt.jimu.sync.OfflineSoundUpload.1
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadFaulted(UploadRequest uploadRequest2, Exception exc) {
+                LogUtils.c("上传录音文件失败：");
+                OfflineSoundUpload.this.c.updateQiNiuSyncState(jimuSound, false);
+            }
+
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadSucceed(UploadResponse uploadResponse) {
+                OfflineSoundUpload.this.c.updateQiNiuSyncState(jimuSound, true);
+                OfflineSoundUpload.this.b(i, jimuSound);
+                LogUtils.c("上传录音文件成功：" + uploadResponse.c());
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void a(List<JimuSound> list) {
+        for (JimuSound jimuSound : list) {
+            JimuSound jimuSound2 = this.c.getJimuSound(jimuSound);
+            if (jimuSound2 != null && "1".equals(jimuSound.getIsDeleted())) {
+                this.c.deleteJimuSound(jimuSound2);
+            }
+        }
+    }
+}

sources/com/ubt/jimu/sync/OfflineUploadAction.java

@@ -0,0 +1,186 @@
+package com.ubt.jimu.sync;
+
+import android.text.TextUtils;
+import com.ubt.jimu.base.cache.Cache;
+import com.ubt.jimu.base.http.ApiResponse;
+import com.ubt.jimu.blockly.networkSync.utils.QiNiuUtils;
+import com.ubt.jimu.transport3.api.DiyTransportServiceProxy;
+import com.ubt.jimu.transport3.bean.request.UploadModelActionBean;
+import com.ubt.jimu.transport3.dao.DiyModelActionDBHandler;
+import com.ubt.jimu.transport3.model.DiyModelAction;
+import com.ubt.jimu.upload.DataUploadProxy;
+import com.ubt.jimu.upload.SimpleUploadCallback;
+import com.ubt.jimu.upload.UploadFilePathUtils;
+import com.ubt.jimu.upload.UploadRequest;
+import com.ubt.jimu.upload.UploadResponse;
+import com.ubt.jimu.utils.LogUtils;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.functions.Consumer;
+import io.reactivex.schedulers.Schedulers;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class OfflineUploadAction {
+    private String a;
+    private DiyModelActionDBHandler b;
+    private DiyTransportServiceProxy c;
+
+    public OfflineUploadAction(DiyTransportServiceProxy diyTransportServiceProxy) {
+        if (this.b == null) {
+            this.b = DiyModelActionDBHandler.getInstance();
+        }
+        this.c = diyTransportServiceProxy;
+    }
+
+    public void b() {
+        List<DiyModelAction> syncServiceActionDB = this.b.getSyncServiceActionDB();
+        if (syncServiceActionDB == null || syncServiceActionDB.size() == 0) {
+            return;
+        }
+        for (DiyModelAction diyModelAction : syncServiceActionDB) {
+            LogUtils.c("serviceActionDB:" + diyModelAction.getFileName());
+            b(1, diyModelAction);
+        }
+    }
+
+    public void c() {
+        List<DiyModelAction> qiNiuActionDB = this.b.getQiNiuActionDB();
+        if (qiNiuActionDB == null || qiNiuActionDB.size() == 0) {
+            return;
+        }
+        Iterator<DiyModelAction> it = qiNiuActionDB.iterator();
+        while (it.hasNext()) {
+            a(1, it.next());
+        }
+    }
+
+    public void a() {
+        List<DiyModelAction> allOfflineUpdateBean;
+        if (this.c == null || (allOfflineUpdateBean = this.b.getAllOfflineUpdateBean()) == null || allOfflineUpdateBean.size() == 0) {
+            return;
+        }
+        Iterator<DiyModelAction> it = allOfflineUpdateBean.iterator();
+        while (it.hasNext()) {
+            a(it.next());
+        }
+    }
+
+    private void c(final int i, final DiyModelAction diyModelAction) {
+        String str = QiNiuUtils.getAndroidSystemRootPath() + QiNiuUtils.getDiyActionLoaclPath(diyModelAction);
+        LogUtils.c("本地文件路径：" + str);
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        if (!new File(str).exists()) {
+            LogUtils.c("Action file not exists");
+            return;
+        }
+        UploadRequest uploadRequest = new UploadRequest();
+        uploadRequest.b(str);
+        uploadRequest.a(UploadFilePathUtils.a(str));
+        DataUploadProxy.c().a(uploadRequest, new SimpleUploadCallback() { // from class: com.ubt.jimu.sync.OfflineUploadAction.2
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadFaulted(UploadRequest uploadRequest2, Exception exc) {
+            }
+
+            @Override // com.ubt.jimu.upload.IUploadCallback
+            public void uploadSucceed(UploadResponse uploadResponse) {
+                diyModelAction.setFileUrl(uploadResponse.c());
+                diyModelAction.setUploaded(true);
+                LogUtils.c("离线动作上传成功：" + uploadResponse.c());
+                OfflineUploadAction.this.b.updateQiNiuState(diyModelAction);
+                OfflineUploadAction.this.b(i, diyModelAction);
+            }
+        });
+    }
+
+    public void b(int i, final DiyModelAction diyModelAction) {
+        int modelId = diyModelAction.getModelId();
+        if (modelId <= 0) {
+            return;
+        }
+        String customModelId = diyModelAction.getCustomModelId();
+        DiyTransportServiceProxy diyTransportServiceProxy = new DiyTransportServiceProxy();
+        this.a = Cache.getInstance().getUserToken();
+        UploadModelActionBean uploadModelActionBean = new UploadModelActionBean(this.a, modelId, customModelId);
+        UploadModelActionBean.UploadModelAction fromDiyModelAction = UploadModelActionBean.fromDiyModelAction(diyModelAction);
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(fromDiyModelAction);
+        if (i == -1) {
+            uploadModelActionBean.setDeleteActions(arrayList);
+        } else if (i == 0) {
+            uploadModelActionBean.setUpdateActions(arrayList);
+        } else if (i == 1) {
+            uploadModelActionBean.setAddActions(arrayList);
+        }
+        diyTransportServiceProxy.uploadActions(uploadModelActionBean).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<Object>>() { // from class: com.ubt.jimu.sync.OfflineUploadAction.3
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<Object> apiResponse) throws Exception {
+                if (apiResponse == null || !apiResponse.isStatus()) {
+                    return;
+                }
+                LogUtils.c("上传到本公司服务器成功");
+                diyModelAction.setServerId(1L);
+                diyModelAction.setModify(false);
+                OfflineUploadAction.this.b.insertOrUpdate(diyModelAction);
+            }
+        });
+    }
+
+    private void a(final DiyModelAction diyModelAction) {
+        this.a = Cache.getInstance().getUserToken();
+        this.c.actions(diyModelAction.getModelId(), this.a).subscribeOn(Schedulers.b()).observeOn(AndroidSchedulers.a()).subscribe(new Consumer<ApiResponse<List<DiyModelAction>>>() { // from class: com.ubt.jimu.sync.OfflineUploadAction.1
+            @Override // io.reactivex.functions.Consumer
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void accept(ApiResponse<List<DiyModelAction>> apiResponse) throws Exception {
+                List<DiyModelAction> models;
+                if (apiResponse == null || !apiResponse.isStatus() || (models = apiResponse.getModels()) == null || models.size() == 0) {
+                    return;
+                }
+                OfflineUploadAction.this.a(models, diyModelAction);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void a(List<DiyModelAction> list, DiyModelAction diyModelAction) {
+        for (DiyModelAction diyModelAction2 : list) {
+            if (diyModelAction == null) {
+                return;
+            }
+            String fileName = diyModelAction.getFileName();
+            String fileName2 = diyModelAction2.getFileName();
+            if (!TextUtils.isEmpty(fileName) && !TextUtils.isEmpty(fileName2) && fileName.equals(fileName2)) {
+                if (diyModelAction2.getIsDeleted() == 1) {
+                    this.b.deleteModelAction(diyModelAction);
+                } else {
+                    long lastUploadTime = diyModelAction.getLastUploadTime();
+                    long lastUploadTime2 = diyModelAction2.getLastUploadTime();
+                    if (lastUploadTime > lastUploadTime2 && lastUploadTime > lastUploadTime2) {
+                        boolean uploaded = diyModelAction.getUploaded();
+                        if (diyModelAction.getIsDeleted() == 1) {
+                            b(-1, diyModelAction);
+                        } else if (!uploaded) {
+                            a(0, diyModelAction);
+                        } else {
+                            b(0, diyModelAction);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void a(int i, DiyModelAction diyModelAction) {
+        LogUtils.c("获取七牛Key成功：" + QiNiuUtils.getDiyActionQiNiuKey(diyModelAction));
+        c(i, diyModelAction);
+    }
+
+    public void a(String str, int i) {
+        this.b.uploadUserIdAndModelId(str, i);
+    }
+}