From 5d3efa4c93dde0cde474951e5310bb72ebbf4184 Mon Sep 17 00:00:00 2001 From: wjc <1243177876@qq.com> Date: 星期三, 07 五月 2025 15:18:26 +0800 Subject: [PATCH] 2025年05月07日15:18:20 1.2.0 --- app/src/main/java/com/hdl/photovoltaic/other/HdlUniLogic.java | 2437 +++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 files changed, 2,113 insertions(+), 324 deletions(-) diff --git a/app/src/main/java/com/hdl/photovoltaic/other/HdlUniLogic.java b/app/src/main/java/com/hdl/photovoltaic/other/HdlUniLogic.java index 9158911..e71edf3 100644 --- a/app/src/main/java/com/hdl/photovoltaic/other/HdlUniLogic.java +++ b/app/src/main/java/com/hdl/photovoltaic/other/HdlUniLogic.java @@ -1,56 +1,104 @@ package com.hdl.photovoltaic.other; +import android.Manifest; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.ServiceConnection; +import android.content.pm.PackageManager; +import android.location.Location; +import android.location.LocationManager; +import android.net.wifi.ScanResult; import android.os.IBinder; +import android.os.SystemClock; +import android.provider.Settings; import android.text.TextUtils; import android.util.Log; +import androidx.core.app.ActivityCompat; + import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.google.gson.reflect.TypeToken; +import com.hdl.link.error.HDLLinkCode; import com.hdl.linkpm.sdk.core.exception.HDLException; import com.hdl.linkpm.sdk.device.bean.DeviceOidInfoBean; import com.hdl.linkpm.sdk.ota.bean.CloudDeviceFirmwaresBean; import com.hdl.linkpm.sdk.ota.bean.CloudGatewayDriversBean; import com.hdl.linkpm.sdk.ota.bean.DeviceFirmwareBean; -import com.hdl.linkpm.sdk.ota.bean.DownloadUrlBean; import com.hdl.linkpm.sdk.ota.bean.GatewayDriverBean; +import com.hdl.linkpm.sdk.user.HDLLinkPMUser; import com.hdl.linkpm.sdk.utils.HDLMD5Utils; import com.hdl.photovoltaic.HDLApp; import com.hdl.photovoltaic.R; +import com.hdl.photovoltaic.bean.InverterBean; +import com.hdl.photovoltaic.bean.LocalResponse; import com.hdl.photovoltaic.bean.ModBusBean; +import com.hdl.photovoltaic.bean.PageNumberObject; +import com.hdl.photovoltaic.config.AppConfigManage; import com.hdl.photovoltaic.config.UserConfigManage; +import com.hdl.photovoltaic.internet.HttpClient; import com.hdl.photovoltaic.internet.HttpServer.MyNanoHttpServer; -import com.hdl.photovoltaic.internet.HttpServer.MyNanoHttpService; +import com.hdl.photovoltaic.internet.TcpClient; +import com.hdl.photovoltaic.internet.api.TopicApi; import com.hdl.photovoltaic.listener.CloudCallBeak; import com.hdl.photovoltaic.listener.LinkCallBack; +import com.hdl.photovoltaic.ui.bean.CUserInfo; import com.hdl.photovoltaic.ui.bean.CloudInverterDeviceBean; +import com.hdl.photovoltaic.ui.bean.DeviceInfoBean; import com.hdl.photovoltaic.ui.bean.DeviceTimeBean; +import com.hdl.photovoltaic.ui.bean.Geolocation; +import com.hdl.photovoltaic.ui.bean.HouseIdBean; +import com.hdl.photovoltaic.ui.bean.HouseInfoBean; +import com.hdl.photovoltaic.ui.bean.LinkBean; +import com.hdl.photovoltaic.ui.bean.MemberBean; +import com.hdl.photovoltaic.ui.bean.NotRunBean; import com.hdl.photovoltaic.ui.bean.OidBean; +import com.hdl.photovoltaic.ui.bean.QrcodeUrlBean; +import com.hdl.photovoltaic.ui.bean.StaffBean; +import com.hdl.photovoltaic.ui.bean.UnCountBean; +import com.hdl.photovoltaic.ui.bean.UserRightTypeBean; +import com.hdl.photovoltaic.ui.me.AsRegardsActivity; +import com.hdl.photovoltaic.ui.me.CPersonalDataActivity; +import com.hdl.photovoltaic.ui.me.SetActivity; +import com.hdl.photovoltaic.ui.newC.MessageCenterList; +import com.hdl.photovoltaic.ui.newC.PowerStationsListEdit; import com.hdl.photovoltaic.uni.HDLUniMP; import com.hdl.photovoltaic.uni.HDLUniMPSDKManager; -import com.hdl.photovoltaic.utils.AppManagerUtils; +import com.hdl.photovoltaic.utils.NetworkUtils; +import com.hdl.photovoltaic.utils.PermissionUtils; import com.hdl.photovoltaic.utils.WifiUtils; -import com.hdl.sdk.link.common.exception.HDLLinkCode; import com.hdl.sdk.link.common.exception.HDLLinkException; import com.hdl.sdk.link.core.bean.eventbus.BaseEventBus; import com.hdl.sdk.link.core.bean.gateway.GatewayBean; +import com.hdl.sdk.link.core.bean.response.BaseLocalResponse; import com.hdl.sdk.link.core.callback.GatewayCallBack; +import com.hdl.sdk.link.core.callback.HDLLinkCallBack; import com.hdl.sdk.link.core.callback.ModbusCallBack; +import com.hdl.sdk.link.core.config.HDLLinkConfig; import com.hdl.sdk.link.core.connect.HDLModBusConnect; +import com.hdl.sdk.link.core.connect.HDLUdpConnect; import com.hdl.sdk.link.gateway.HDLLinkLocalGateway; import org.greenrobot.eventbus.EventBus; +import org.json.JSONArray; import org.json.JSONObject; import java.io.File; +import java.io.InputStream; +import java.io.OutputStream; +import java.lang.reflect.Type; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.net.InetSocketAddress; +import java.net.Socket; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; import java.util.Objects; +import java.util.concurrent.atomic.AtomicInteger; import io.dcloud.feature.unimp.DCUniMPJSCallback; import okhttp3.ResponseBody; @@ -60,6 +108,8 @@ */ public class HdlUniLogic implements HDLUniMPSDKManager.IOnOtherUniMPEventCallBack { private static volatile HdlUniLogic sHdlUniLogic; + + public final static String separator = "---"; /** * 鑾峰彇褰撳墠瀵硅薄 @@ -85,224 +135,707 @@ * 鍘熺敓鎺ユ敹鍒皍ni鍙戞潵鐨勬暟鎹� * * @param appId -uni灏忕▼搴忔寚瀹氱殑appId - * @param event -uni灏忕▼搴忓彂鏉ユ暟鎹� + * @param topic -uni灏忕▼搴忓彂鏉ヤ富棰�(澶х被) * @param data JSONObject com.alibaba.fastjson瑙f瀽澶勭悊 * @param callback callback.invoke(JSONObject) 鐢╟om.alibaba.fastjson */ @Override - public void onOtherUniMPEventReceive(String appId, String event, Object data, DCUniMPJSCallback callback) { + public void onOtherUniMPEventReceive(String appId, String topic, Object data, DCUniMPJSCallback callback) { try { if (!HDLUniMP.UNI_APP_ID.equals(appId)) { return; } - String type = getKeyValue("type", data); - if (HDLUniMP.UNI_EVENT_REPLY_HOME_MODEL.equals(event)) { + long startTime = System.currentTimeMillis(); + Log.d("===寮�濮嬫椂闂�===", String.valueOf(startTime)); + String type = getKeyValue("type", data);//灏忕被 + String logTag = getKeyValue("logTag", data);//鏍囪uni鎸囦护 + String mode_type = "澶х被-" + topic + "---" + "灏忕被-" + type;//鐢ㄦ潵鎵撳嵃鐨� + HdlLogLogic.print(logTag + ":" + "uni---鍙戦��---" + mode_type + "---" + data, true); + if (HDLUniMP.UNI_EVENT_REPLY_USER_MODEL.equals(topic)) { + //鐢ㄦ埛妯″潡 + switch (type) { + //鐢ㄦ埛淇℃伅 + case HDLUniMP.UNI_EVENT_REPLY_USER_INFO: { + this.uniGetUserInfo(mode_type, data, callback); + } + break; + //鐢ㄦ埛澶村儚锛堟棫骞冲彴閫昏緫鏄ご鍍忓崟鐙幏鍙栦笅杞藉湴鍧�锛� + case HDLUniMP.UNI_EVENT_REPLY_USER_IMAGE: { + uniGetImageKey(mode_type, data, callback); + } + break; + //鐢ㄦ埛鏈湴缂撳瓨淇℃伅 + case HDLUniMP.UNI_EVENT_REPLY_USER_LOCAL_INFO: { + JsonObject jsonObject = new JsonObject(); + jsonObject.addProperty("user_name", UserConfigManage.getInstance().getUserName()); + jsonObject.addProperty("user_image_url", UserConfigManage.getInstance().getUserImageUrl()); + jsonObject.addProperty("user_account", UserConfigManage.getInstance().getAccount()); + jsonObject.addProperty("appLanguage", UserConfigManage.getInstance().getCurrentAppLanguage()); + jsonObject.addProperty("token", HDLLinkPMUser.getInstance().getAccessToken()); + jsonObject.addProperty("refreshToken", HDLLinkPMUser.getInstance().getRefreshToken()); + if (TextUtils.isEmpty(AppConfigManage.getUserRegionUrl())) { + AppConfigManage.setUserRegionUrl(HDLLinkPMUser.getInstance().getUserRegionUrl()); + } + jsonObject.addProperty("serverAddress", AppConfigManage.getUserRegionUrl()); + jsonObject.addProperty("appKey", AppConfigManage.getAppKey()); + jsonObject.addProperty("appSecret", AppConfigManage.getAppSecret()); + uniSuccessCallback(mode_type, jsonObject, callback); + HdlLogLogic.print("鑾峰彇鐢ㄦ埛鏈湴缂撳瓨淇℃伅----" + jsonObject.toString()); + } + break; + } + + } else if (HDLUniMP.UNI_EVENT_REPLY_HOME_MODEL.equals(topic)) { //浣忓畢妯″潡 switch (type) { + //鎵爜娣诲姞鐢电珯 + case HDLUniMP.UNI_EVENT_REPLY_HOME_ADD: { + String url = getKeyValue("url", getKeyValue("data", data)); + //EventBus浜嬩欢鍒嗗彂 + HdlCommonLogic.getInstance().postEventBusSticky(HDLUniMP.UNI_EVENT_REPLY_HOME_ADD, HDLUniMP.UNI_EVENT_REPLY_HOME_ADD, url); + + if (callback != null) { + uniSuccessCallback(type, null, callback); + } + } + break; + //璐﹀彿涓嬫槸鍚︽湁鐢电珯鍒楄〃 + case HDLUniMP.UNI_EVENT_REPLY_HOME_LIST: { + if (callback != null) { + uniSuccessCallback(type, HdlResidenceLogic.getInstance().getHouseIdList().size(), callback); + } + } + break; //鍒涘缓鐢电珯 case HDLUniMP.UNI_EVENT_REPLY_HOME_CREATION: { - //EventBus浜嬩欢鍒嗗彂 - BaseEventBus baseEventBus = new BaseEventBus(); - baseEventBus.setType(HDLUniMP.UNI_EVENT_REPLY_HOME_CREATION); - baseEventBus.setData(getKeyValue("data", data)); - EventBus.getDefault().post(baseEventBus); + HdlCommonLogic.getInstance().postEventBus(HDLUniMP.UNI_EVENT_REPLY_HOME_MODEL, HDLUniMP.UNI_EVENT_REPLY_HOME_CREATION, getKeyValue("data", data)); + if (callback != null) { + uniSuccessCallback(type, null, callback); + } } + break; //璇诲彇璇︽儏 case HDLUniMP.UNI_EVENT_REPLY_HOME_DETAILS: { - + if (callback != null) { + uniSuccessCallback(type, null, callback); + } + } + break; + //鐢电珯鍒犻櫎 + case HDLUniMP.UNI_EVENT_REPLY_HOME_DEl: { + this.uniGetDelResidence(mode_type, data, callback); } break; //鍏抽棴璇︽儏椤� case HDLUniMP.UNI_EVENT_REPLY_HOME_CLOSE_HOME_DETAILS_PAGE: { //EventBus浜嬩欢鍒嗗彂 - BaseEventBus baseEventBus = new BaseEventBus(); - baseEventBus.setType(HDLUniMP.UNI_EVENT_REPLY_HOME_CLOSE_HOME_DETAILS_PAGE); - baseEventBus.setData(getKeyValue("data", data)); - EventBus.getDefault().post(baseEventBus); + // todo 鍦℉DLUniMPSDKManager绫婚噷闈㈡湁鏂规硶()鐩戝惉鍒板皬绋嬪簭鍏抽棴锛岀劧鍚庡彂甯冭皟鐢‥ventBus鍙戝竷鍑哄幓; +// HdlCommonLogic.getInstance().postEventBus( +// HDLUniMP.UNI_EVENT_REPLY_HOME_CLOSE_HOME_DETAILS_PAGE, +// LowerTagType.power_station.toString(), +// getKeyValue("data", data)); + if (callback != null) { + uniSuccessCallback(type, null, callback); + } + } + break; + //浣忓畢銆愮數绔欍�戠紪杈� + case HDLUniMP.UNI_EVENT_REPLY_HOME_EDIT: { + //EventBus浜嬩欢鍒嗗彂 + HdlCommonLogic.getInstance().postEventBus(HDLUniMP.UNI_EVENT_REPLY_HOME_MODEL, HDLUniMP.UNI_EVENT_REPLY_HOME_EDIT, getKeyValue("data", data)); + if (callback != null) { + uniSuccessCallback(type, null, callback); + } + } + break; +// //鐢电珯鐨勪氦浠樹簩缁寸爜(瀹夎鍟�) +// case HDLUniMP.UNI_EVENT_REPLY_HOME_DELIVERYURLQRCODE: { +// uniGetDeliveryUrlQrcode(type, data, callback); +// } +// break; + //鐢电珯鐨勪氦浠楿RL(瀹夎鍟�) + case HDLUniMP.UNI_EVENT_REPLY_HOME_DELIVERYURLQRCODE: { + uniGetDeliveryUrl(type, data, callback); + } + break; + //鐢电珯鎵嬪姩浜や粯(瀹夎鍟�) + case HDLUniMP.UNI_EVENT_REPLY_HOME_DELIVERTOACCOUNT: { + uniGetDeliverToAccount(type, data, callback); + + } + break; + //鐢电珯鎺堟潈瀹夎鍟�(C绔�) + case HDLUniMP.UNI_EVENT_REPLY_HOME_UPDATEDEBUGPERM: { + uniHomeUpdateDebugPerm(type, data, callback); + } break; } - if (callback != null) { - uniCallbackData(null, callback); - } - } else if (HDLUniMP.UNI_EVENT_REPLY_DEVICE_MODEL.equals(event)) { + + } else if (HDLUniMP.UNI_EVENT_REPLY_DEVICE_MODEL.equals(topic)) { //璁惧妯″潡 switch (type) { + //modBus鍗忚涓撶敤 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_MODBUS_SEND: { + sendModBus(mode_type, data, callback); + } + break; //娣诲姞閫嗗彉鍣ㄥ埌浜戠 case HDLUniMP.UNI_EVENT_REPLY_DEVICE_ADD: { - this.uniAddInverterDeviceToCloud(data, callback); + this.uniAddInverterDeviceToCloud(mode_type, data, callback); + } + break; + //娣诲姞澶氫釜閫嗗彉鍣ㄥ埌浜戠 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_ADD_All: { + this.uniAddAllInverterDeviceToCloud(mode_type, data, callback); } break; //鍒犻櫎浜戠閫嗗彉鍣� case HDLUniMP.UNI_EVENT_REPLY_DEVICE_DEL: { - this.uniDelInverterDevice(data, callback); + this.uniDelInverterDevice(mode_type, data, callback); } break; //灞�鍩熺綉鎼滅储閫嗗彉鍣ㄥ垪琛� case HDLUniMP.UNI_EVENT_REPLY_DEVICE_NET_LIST: { - this.uniSearchGateway(callback); + this.uniSearchGateway(mode_type, callback); } break; //鑾峰彇閫嗗彉鍣ㄥ垪琛� case HDLUniMP.UNI_EVENT_REPLY_DEVICE_LIST: { - this.uniGetCurrentHomeLocalAndCloudGatewayList(callback); - } - break; - //modBus鍗忚涓撶敤 - case HDLUniMP.UNI_EVENT_REPLY_DEVICE_MODBUS_SEND: { - sendModBus(data, callback); + this.uniGetCurrentHomeLocalAndCloudGatewayList(mode_type, data, callback); } break; //鑾峰彇oid鍒楄〃 case HDLUniMP.UNI_EVENT_REPLY_DEVICE_OID: { - this.uniGetInverterOidList(data, callback); + this.uniGetInverterOidList(mode_type, data, callback); } break; //閫嗗彉鍣ㄦ椂闂磋鍙� case HDLUniMP.UNI_EVENT_REPLY_DEVICE_TIME: { - this.uniGetInverterTime(data, callback); + this.uniGetInverterTime(mode_type, data, callback); } - break; //閫嗗彉鍣ㄦ椂闂寸紪杈� case HDLUniMP.UNI_EVENT_REPLY_DEVICE_TIME_EDIT: { - this.uniEditInverterTime(data, callback); + this.uniEditInverterTime(mode_type, data, callback); } break; //閫嗗彉鍣ㄤ笂浼犳暟鎹埌浜戠 case HDLUniMP.UNI_EVENT_REPLY_DEVICE_UPLOADING_DATA: { - this.uniUploadDataToCloud(data, callback); + this.uniUploadDataToCloud(mode_type, data, callback); } break; //閫嗗彉鍣ㄦ竻绌轰綇瀹卛d case HDLUniMP.UNI_EVENT_REPLY_DEVICE_CLEAR_DATA: { - this.uniClearInverterHomeId(data, callback); + this.uniClearInverterHomeId(mode_type, data, callback); } break; - + //spk灞炴�х紪杈� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_Link_edit_SEND: { + this.uniLinkSpkAttributeEdit(mode_type, data, callback); + } + break; + //spk灞炴�ц鍙� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_Link_read_SEND: { + this.uniLinkSpkAttributeRead(mode_type, data, callback); + } + break; + //鑾峰彇鏈鐞�/鏈娑堟伅鏁伴噺 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_MESSAGE_NUMBER: { + this.uniGetMessageNumber(mode_type, data, callback); + } + break; + //鍒濆鍖栭�嗗彉鍣� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_INITIALIZEINVERTER: { + this.setInitializeGateway(mode_type, data, callback); + } + break; + //璇诲彇璁惧杩滅▼淇℃伅 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_REMOTEINFO: { + this.setInverterDeviceRemoteInfo(mode_type, data, callback); + } + break; + //璁惧鍚嶇О淇敼(淇敼鏄簯绔痮id鍚嶇О锛岃澶囦娇鐢╩odbus鍗忚淇敼) + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_EDIT_NAME: { + this.uniOidEditName(mode_type, data, callback); + } + break; + //鑾峰彇鏈繍琛岄�嗗彉鍣ㄥ垪琛� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_NOT_RUN_DEVICE_LIST: { + this.uniGetListNotRun(mode_type, data, callback); + } + break; + //蹇嵎寮�鍚�嗗彉鍣� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_OPEN_DEVICE_LIST: { + this.uniSetDeviceStartup(mode_type, data, callback); + } + break; + //鑾峰彇璁惧璇︽儏锛堜簯绔澶囷級 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_OPEN_DEVICE_info: { + this.uniGetDeviceInfo(mode_type, data, callback); + } + break; + //鑾峰彇閫嗗彉鍣ㄨ鎯咃紙鐗╃悊璁惧锛� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_OPEN_gateway_info: { + this.uniGetGatewayInfo(mode_type, data, callback); + } + break; } - } else if (HDLUniMP.UNI_EVENT_REPLY_WIFI_MODEL.equals(event)) { - WifiUtils wifiUtils = new WifiUtils(HDLApp.getInstance()); + } else if (HDLUniMP.UNI_EVENT_REPLY_WIFI_MODEL.equals(topic)) { + WifiUtils wifiUtils = WifiUtils.getInstance(); //wifi妯″潡 switch (type) { - //鑾峰彇wifi鍒楄〃 - case HDLUniMP.UNI_EVENT_REPLY_WIFI_LIST: { + //鑾峰彇浣嶇疆鏉冮檺 + case HDLUniMP.UNI_EVENT_REPLY_AUTHORIZATION_GET: { + boolean isLocalAuthor = PermissionUtils.checkPermission(HDLApp.getInstance(), Manifest.permission.ACCESS_FINE_LOCATION); if (callback != null) { - uniCallbackData(wifiUtils.getScanResult(), callback); + uniSuccessCallback(mode_type, isLocalAuthor, callback); } } break; - //褰撳墠wifi璇︽儏 - case HDLUniMP.UNI_EVENT_REPLY_WIFI_INFO: { + //鑾峰彇鎵嬫満wifi鍒楄〃 + case HDLUniMP.UNI_EVENT_REPLY_PHONE_WIFI_LIST: { if (callback != null) { - uniCallbackData(wifiUtils.getCurrentConnectWifiInfo(), callback); + uniSuccessCallback(mode_type, wifiUtils.getScanResult(), callback); } } break; - //wifi杩炴帴 - case HDLUniMP.UNI_EVENT_REPLY_WIFI_CONNECT: { - + //鑾峰彇鎵嬫満褰撳墠wifi璇︽儏 + case HDLUniMP.UNI_EVENT_REPLY_PHONE_WIFI_INFO: { + if (callback != null) { + uniSuccessCallback(mode_type, wifiUtils.getCurrentConnectWifiInfo(), callback); + } + } + break; + //鎵撳紑鎵嬫満Wifi璁剧疆鐣岄潰 + case HDLUniMP.UNI_EVENT_REPLY_PHONE_OPEN_WIFI_SETTINGS: { + Intent intent = new Intent(Settings.ACTION_WIFI_SETTINGS); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + HDLApp.getInstance().startActivity(intent); + } + //閫嗗彉鍣╓iFi淇℃伅閰嶇疆 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_WIFI_SET: { + uniGetAndSetNetwork(mode_type, data, TopicApi.DELETING_GATEWAY_WIFI_EDIT, callback); + } + break; + //閫嗗彉鍣╓iFi淇℃伅鑾峰彇 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_WIFI_GET: { + uniGetAndSetNetwork(mode_type, data, TopicApi.DELETING_GATEWAY_WIFI_GET, callback); + } + break; + //閫嗗彉鍣ㄧ儹鐐归厤缃� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_HOTSPOT_SET: { + uniGetAndSetNetwork(mode_type, data, TopicApi.DELETING_GATEWAY_HOTSPOT_EDIT, callback); + } + break; + //閫嗗彉鍣ㄧ儹鐐硅幏鍙� + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_HOTSPOT_GET: { + uniGetAndSetNetwork(mode_type, data, TopicApi.DELETING_GATEWAY_HOTSPOT_GET, callback); + } + break; + //閫嗗彉鍣ㄤ互澶綉閰嶇疆 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_ETHERNET_SET: { + if (callback != null) { + uniSuccessCallback(type, "", callback); + } + //uniGetAndSetNetwork(mode_type, data, TopicApi.DELETING_GATEWAY_ETHERNET_EDIT, callback); + } + break; + //閫嗗彉鍣ㄤ互澶綉鑾峰彇 + case HDLUniMP.UNI_EVENT_REPLY_DEVICE_ETHERNET_GET: { + uniGetAndSetNetwork(mode_type, data, TopicApi.DELETING_GATEWAY_ETHERNET_GET, callback); } break; } - } else if (HDLUniMP.UNI_EVENT_REPLY_OTA_MODEL.equals(event)) { + } else if (HDLUniMP.UNI_EVENT_REPLY_OTA_MODEL.equals(topic)) { //OTA鍗囩骇妯″潡 switch (type) { //鍚戜簯绔幏鍙杘id鍒楄〃 case HDLUniMP.UNI_EVENT_REPLY_OTA_CLOUD_OID_LIST: { - this.uniGetCloudOidList(data, callback); + this.uniGetCloudOidList(mode_type, data, callback); } break; //褰撳墠璁惧鍥轰欢鍒楄〃 case HDLUniMP.UNI_EVENT_REPLY_OTA_FIRMWARES_LIST: { - this.uniGetCurrentDeviceFirmwares(data, callback); + this.uniGetCurrentDeviceFirmwares(mode_type, data, callback); } break; //璁惧鏂板浐浠跺垪琛� case HDLUniMP.UNI_EVENT_REPLY_OTA_FIRMWARES_NEW_LIST: { - this.uniGetNewDeviceFirmwares(data, callback); + this.uniGetNewDeviceFirmwares(mode_type, data, callback); } break; //璁惧鏈湴鍥轰欢鍒楄〃 case HDLUniMP.UNI_EVENT_REPLY_OTA_FIRMWARES_LOCAL: { - this.uniGetLocalFirmwares(data, callback); + this.uniGetLocalFirmwares(mode_type, data, callback); } break; //璁惧鍥轰欢涓嬭浇 case HDLUniMP.UNI_EVENT_REPLY_OTA_FIRMWARES_DOWNLOAD: { - this.uniDeviceFirmwareDownload(data, callback); + this.uniDeviceFirmwareDownload(mode_type, data, callback); } break; //璁惧鍥轰欢鍗囩骇 case HDLUniMP.UNI_EVENT_REPLY_OTA_FIRMWARES_UPGRADE: { - this.uniUpgradeDeviceFirmware(data, callback); + this.uniUpgradeDeviceFirmware(mode_type, data, callback); } break; //褰撳墠璁惧椹卞姩鍒楄〃 case HDLUniMP.UNI_EVENT_REPLY_OTA_DRIVER_LIST: { - this.uniGetCurrentGatewayDrivers(data, callback); + this.uniGetCurrentGatewayDrivers(mode_type, data, callback); } break; //璁惧鏂伴┍鍔ㄥ垪琛� case HDLUniMP.UNI_EVENT_REPLY_OTA_DRIVER_NEW: { - this.uniGetNewGatewayDrivers(data, callback); + this.uniGetNewGatewayDrivers(mode_type, data, callback); } break; //璁惧鏈湴椹卞姩鍒楄〃 case HDLUniMP.UNI_EVENT_REPLY_OTA_DRIVER_LOCAL: { - this.uniGetLocalDrivers(data, callback); + this.uniGetLocalDrivers(mode_type, data, callback); } break; //璁惧椹卞姩涓嬭浇 case HDLUniMP.UNI_EVENT_REPLY_OTA_DRIVER_DOWNLOAD: { - this.uniGatewayDriverDownload(data, callback); + this.uniGatewayDriverDownload(mode_type, data, callback); } break; //璁惧椹卞姩鍗囩骇 case HDLUniMP.UNI_EVENT_REPLY_OTA_DRIVER_UPGRADE: { - this.uniUpgradeGatewayDriver(data, callback); + this.uniUpgradeGatewayDriver(mode_type, data, callback); } break; - //璁惧鍙栨秷涓嬭浇鍗囩骇鏂囦欢 + //璁惧鍙栨秷椹卞姩,鍥轰欢涓嬭浇鍗囩骇鏂囦欢 case HDLUniMP.UNI_EVENT_REPLY_OTA_DRIVER_CANCEL_DOWNLOAD: { - this.uniCancelDownloadingUpgradeFile(data, callback); + this.uniCancelDownloadingUpgradeFile(mode_type, data, callback); + } + break; + //璁惧椹卞姩,鍥轰欢鍙栨秷鍗囩骇 + case HDLUniMP.UNI_EVENT_REPLY_OTA_CANCEL_UPGRADE: { + this.uniCancelUpgrade(mode_type, data, callback); } break; //鎵撳紑鏈嶅姟 case HDLUniMP.UNI_EVENT_REPLY_OTA_OPEN_SERVICE: { - this.uniOpenService(data, callback); + this.uniOpenService(mode_type, data, callback); } break; //鍏抽棴鏈嶅姟 case HDLUniMP.UNI_EVENT_REPLY_OTA_CLOSE_SERVICE: { - this.uniCloseService(data, callback); + this.uniCloseService(mode_type, data, callback); } break; } - } else if (HDLUniMP.UNI_EVENT_REPLY_OTHER_MODEL.equals(event)) { + } else if (HDLUniMP.UNI_EVENT_REPLY_MINE_MODEL.equals(topic)) { + //鎴戠殑妯″潡 + switch (type) { + //璧勬枡缂栬緫 + case HDLUniMP.UNI_EVENT_REPLY_MINE_EDIT_USER_INFO: { + Intent intent = new Intent(); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.setClass(HDLApp.getInstance(), CPersonalDataActivity.class); + HDLApp.getInstance().startActivity(intent); + } + break; + //鐢电珯閫夋嫨 + case HDLUniMP.UNI_EVENT_REPLY_MINE_SELECTED_POWERSTATION: { + Intent intent = new Intent(); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.setClass(HDLApp.getInstance(), PowerStationsListEdit.class); + HDLApp.getInstance().startActivity(intent); + } + break; + //娑堟伅涓績 + case HDLUniMP.UNI_EVENT_REPLY_MINE_MESSAGE_CENTER: { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + String isShowFault = getKeyValue("isShowFault", getKeyValue("data", data)); + Intent intent = new Intent(); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.setClass(HDLApp.getInstance(), MessageCenterList.class); + if (!TextUtils.isEmpty(homeId)) { + intent.putExtra("homeId", homeId); + } + if (!TextUtils.isEmpty(isShowFault)) { + intent.putExtra("isShowFault", isShowFault); + } + HDLApp.getInstance().startActivity(intent); + } + break; + //鍏充簬 + case HDLUniMP.UNI_EVENT_REPLY_MINE_ABOUT: { + Intent intent = new Intent(); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.setClass(HDLApp.getInstance(), AsRegardsActivity.class); + HDLApp.getInstance().startActivity(intent); + } + break; + //璁剧疆 + case HDLUniMP.UNI_EVENT_REPLY_MINE_SETTING: { + Intent intent = new Intent(); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.setClass(HDLApp.getInstance(), SetActivity.class); + HDLApp.getInstance().startActivity(intent); + + } + break; + //涓嬭浇鎴愬憳锛堝瓙璐﹀彿锛夊ご鍍� + case HDLUniMP.UNI_EVENT_REPLY_DOWNLOAD_MEMBER_AVATAR: { + uniGetHeadPIortrait(type, data, callback); + + } + break; + //鎴愬憳鍒楄〃 + case HDLUniMP.UNI_EVENT_REPLY_MEMBER_LIST: { + uniGetMemberList(type, data, callback); + } + break; + //鎴愬憳娣诲姞 + case HDLUniMP.UNI_EVENT_REPLY_MEMBER_ADD: { + uniGetMemberAdd(type, data, callback); + } + break; + //鎴愬憳鍒犻櫎 + case HDLUniMP.UNI_EVENT_REPLY_MEMBER_DELETE: { + uniGetMemberDelete(type, data, callback); + } + break; + //鎴愬憳缂栬緫 + case HDLUniMP.UNI_EVENT_REPLY_MEMBER_EDIT: { + uniGetMemberEdit(type, data, callback); + + } + break; + //鑾峰彇鍛樺伐鍒楄〃 + case HDLUniMP.UNI_EVENT_REPLY_STAFF_LIST: { + uniGetStaffList(type, data, callback); + + } + break; + //鍛樺伐娣诲姞 + case HDLUniMP.UNI_EVENT_REPLY_STAFF_ADD: { + uniGetStaffAdd(type, data, callback); + + } + break; + //鍛樺伐璇︽儏鑾峰彇 + case HDLUniMP.UNI_EVENT_REPLY_STAFF_DETAIL: { + uniGetStaffInfo(type, data, callback); + + } + + break; + //鍛樺伐鍒犻櫎 + case HDLUniMP.UNI_EVENT_REPLY_STAFF_DELETE: { + + uniGetStaffDelete(type, data, callback); + + } + break; + //鍛樺伐缂栬緫 + case HDLUniMP.UNI_EVENT_REPLY_STAFF_EDIT: { + uniGetStaffEdit(type, data, callback); + + } + break; + //鑾峰彇褰撳墠璐﹀彿鍦ㄥ叕鍙哥殑韬唤 + case HDLUniMP.UNI_EVENT_REPLY_USERRIGHTTYP: { + uniGetUserRightType(type, data, callback); + + } + break; + + + } + } else if (HDLUniMP.UNI_EVENT_REPLY_OTHER_MODEL.equals(topic)) { //鍏跺畠妯″潡 switch (type) { + //鑾峰彇娓╁害鍗曚綅 case HDLUniMP.UNI_EVENT_REPLY_OTHER_UNIT: { - uniCallbackData(UserConfigManage.getInstance().getTemperature_unit(), callback); + uniSuccessCallback(mode_type, UserConfigManage.getInstance().getTemperature_unit(), callback); } break; //鑾峰彇褰撳墠app璇█ case HDLUniMP.UNI_EVENT_REPLY_OTHER_APP_LANGUAGE: { - uniCallbackData(UserConfigManage.getInstance().getCurrentAppLanguage(), callback); + uniSuccessCallback(mode_type, UserConfigManage.getInstance().getCurrentAppLanguage(), callback); + } + break; + //鑾峰彇浣嶇疆淇℃伅 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_LOCATION_INFO: { + this.uniGetLocationInfo(mode_type, data, callback); + } + break; + //搴旂敤鍐茬獊 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_APPLICATION_CONFLICT: { + if (callback != null) { + uniSuccessCallback(type, HDLUdpConnect.getInstance().isBindSuccess(), callback); + } + } + break; + //涓撻棬鏀堕泦uni鏃ュ織 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_UNI_LOG: { + String customizeContentFormat = getKeyValue("customizeContentFormat", getKeyValue("data", data)); + HdlLogLogic.print("uni---log---" + customizeContentFormat, true); + + } + break; + //uni涓婚〉鐐瑰嚮杩斿洖閫氱煡 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_BACK: { + //EventBus浜嬩欢鍒嗗彂 + HdlCommonLogic.getInstance().postEventBus(HDLUniMP.UNI_EVENT_REPLY_OTHER_MODEL, HDLUniMP.UNI_EVENT_REPLY_OTHER_BACK); + + } + break; + //uni閫氱煡鍘熺敓閫�鍑虹櫥褰� + case HDLUniMP.UNI_EVENT_REPLY_OTHER_LOGOUT: { + HdlLogLogic.print("uni閫氱煡鍘熺敓閫�鍑虹櫥褰�---", true); + HDLLinkPMUser.getInstance().logout(0); + } + break; + //鏈湴瀵嗛挜鑾峰彇 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_LOCAL_ENCRYPT_GET: { + String localSecret = HDLLinkConfig.getInstance().getLocalSecret(); + JsonObject jsonObject = new JsonObject(); + jsonObject.addProperty("local_encrypt", localSecret); + HdlLogLogic.print("uni---log---鏈湴瀵嗛挜鑾峰彇---" + localSecret, true); + if (callback != null) { + uniSuccessCallback(type, jsonObject, callback); + } + + } + break; + //鏈湴瀵嗛挜璁剧疆 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_LOCAL_ENCRYPT_SET: { + String local_encrypt = getKeyValue("local_encrypt", getKeyValue("data", data)); + if (!TextUtils.isEmpty(local_encrypt)) { + //閲嶆柊璁剧疆鏈湴閫氳绉橀挜 + UserConfigManage.getInstance().setLocalSecret(local_encrypt); + UserConfigManage.getInstance().Save(); + //閰嶇疆鏈湴閫氫俊鐨勪俊鎭� + HDLLinkConfig.getInstance().setLocalSecret(local_encrypt); + HdlLogLogic.print("uni---log---鏈湴瀵嗛挜璁剧疆---" + local_encrypt, true); + } + if (callback != null) { + uniSuccessCallback(type, true, callback); + } + } + break; + //link杩涜瀵嗙爜楠岃瘉 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_PASSWORD_VERIFIY: { + uniCheckPasswordVerification(mode_type, data, callback); + } + break; + //鏈湴json璧勬簮鏂囦欢鑾峰彇 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_GET_LOCAL_JSON: { +// String url = getKeyValue("url", getKeyValue("data", data)); + String fileName = getKeyValue("fileName", getKeyValue("data", data));//鍞竴鏍囪瘑 + String deviceType = getKeyValue("deviceType", getKeyValue("data", data));//璁惧绫诲瀷 + String deviceModel = getKeyValue("deviceModel", getKeyValue("data", data));//璁惧妯″瀷 + String language = getKeyValue("language", getKeyValue("data", data)); + String json = HdlESLocalJsonLogic.getInstance().readHdlESLocalJson(fileName + ".json", deviceModel); + if (TextUtils.isEmpty(json)) { + //鏈湴娌℃湁缂撳瓨 + HdlESLocalJsonLogic.getInstance().getHdlESLocalJson(fileName, deviceType, deviceModel, false, new CloudCallBeak<String>() { + @Override + public void onSuccess(String obj) { +// if (callback != null) { +// uniSuccessCallback(type, obj, callback); +// } + String s = HdlESLocalJsonLogic.getInstance().readHdlESLocalJson(fileName, deviceModel); + //鏈湴缂撳瓨鏁版嵁 + if (callback != null) { + try { + if (s.startsWith("{")) { + uniSuccessCallback(type, new Gson().fromJson(s, JsonObject.class), callback); + } else if (s.startsWith("[")) { + uniSuccessCallback(type, new Gson().fromJson(s, JsonArray.class), callback); + } else { + uniSuccessCallback(type, s, callback); + } + } catch (Exception e) { + uniSuccessCallback(type, s, callback); + } + } + } + + @Override + public void onFailure(HDLException e) { + if (callback != null) { + uniExceptionCallback(type, e, callback); + } + } + }); + } else { + //鏈湴缂撳瓨鏁版嵁 + if (callback != null) { + try { + if (json.startsWith("{")) { + uniSuccessCallback(type, new Gson().fromJson(json, JsonObject.class), callback); + } else if (json.startsWith("[")) { + uniSuccessCallback(type, new Gson().fromJson(json, JsonArray.class), callback); + } else { + uniSuccessCallback(type, json, callback); + } + } catch (Exception e) { + uniSuccessCallback(type, json, callback); + } + long endTime = System.currentTimeMillis() - startTime; + Log.d("====鑰楁椂鏃堕棿====", String.valueOf(endTime)); + } + } + } + break; + //uni鑾峰彇鍥剧墖 + case HDLUniMP.UNI_EVENT_REPLY_OTHER_GET_SELECTED_IMAGE: { + } break; } + } else if (HDLUniMP.UNI_EVENT_REPLY_UNI_SEND_TO_CLOUD.equals(topic)) { + //缃戠粶璇锋眰妯″潡 + JsonObject jObject = new JsonObject(); + String body = getKeyValue("data", data); + if (!TextUtils.isEmpty(body)) { + try { + jObject = new Gson().fromJson(body, JsonObject.class); + } catch (Exception ignored) { + } + } + HttpClient.getInstance().requestHttp(type, jObject.toString(), new CloudCallBeak<String>() { + @Override + public void onSuccess(String jsonStr) { + //鏈湴缂撳瓨鏁版嵁 + if (callback != null) { + try { + if (jsonStr.startsWith("{")) { + uniSuccessCallback(mode_type, new Gson().fromJson(jsonStr, JsonObject.class), callback); + } else if (jsonStr.startsWith("[")) { + uniSuccessCallback(mode_type, new Gson().fromJson(jsonStr, JsonArray.class), callback); + } else { + uniSuccessCallback(mode_type, jsonStr, callback); + } + } catch (Exception e) { + uniSuccessCallback(mode_type, jsonStr, callback); + } + } + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(mode_type, e, callback); + } + }); + } - HdlLogLogic.print("uni===鍘熺敓鎺ユ敹uni鍙戞潵鐨勬暟鎹�===" + event + "\r\n" + data, false); + } catch (Exception e) { - HdlLogLogic.print("uni===鍘熺敓鎺ユ敹uni鍙戞潵鐨勬暟鎹�===" + e.getMessage(), false); + HdlLogLogic.print("uni---鍙戦��---" + e.getMessage(), true); } } @@ -317,7 +850,7 @@ public void openUniMP(String path, JSONObject jsonObject) { JSONObject json = this.createdJSONObject(jsonObject, true); HDLUniMPSDKManager.getInstance().openUniMP(HDLUniMP.UNI_APP_ID, path, json, HdlUniLogic.this); - HdlLogLogic.print("uni===缁勮uni鍙戦�佹暟鎹牸寮�===" + json, false); +// HdlLogLogic.print("uni---缁勮uni鍙戦�佹暟鎹牸寮�---" + json, false); } /** @@ -331,7 +864,7 @@ try { HDLUniMPSDKManager.getInstance().sendUniMPEvent(HDLUniMP.UNI_APP_ID, topic, getJSONObject(callBackBaseBean)); } catch (Exception e) { - HdlLogLogic.print("uni===鍘熺敓涓诲姩鍚戝皬绋嬪簭鍙戦�侀�氱煡浜嬩欢===" + e.getMessage(), false); + HdlLogLogic.print("uni---鍘熺敓涓诲姩鍚戝皬绋嬪簭鍙戦�侀�氱煡浜嬩欢---" + e.getMessage(), false); } } @@ -346,21 +879,539 @@ //region ******uni鎺ュ彛鏂规硶****** /** + * link杩涜鏈湴瀵嗙爜鐧诲綍楠岃瘉 + */ + private void uniCheckPasswordVerification(String type, Object data, DCUniMPJSCallback callback) { + String password = getKeyValue("password", getKeyValue("data", data)); + String mac = getKeyValue("mac", getKeyValue("data", data)); + HdlDeviceLogic.getInstance().getPasswordVerification(mac, password, new LinkCallBack<LocalResponse>() { + @Override + public void onSuccess(LocalResponse obj) { + + if (callback != null) { + uniCallbackData(type, obj.getObjects(), obj.getCode(), obj.getMsg(), callback); + } + } + + @Override + public void onError(HDLLinkException e) { + + if (callback != null) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + } + }); + } + + /** + * 鐢电珯鍒犻櫎 + */ + private void uniGetDelResidence(String type, Object data, DCUniMPJSCallback callback) { + + + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + HdlResidenceLogic.getInstance().delResidence(homeId, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + if (callback != null) { + uniSuccessCallback(type, null, callback); + } + List<GatewayBean> list = HdlDeviceLogic.getInstance().getCurrentHomeGatewayList(homeId, null); + for (int i = 0; i < list.size(); i++) { + GatewayBean gatewayBean = list.get(i); + HdlDeviceLogic.getInstance().initializeInverter(gatewayBean.getDevice_mac(), null); + } + list.clear();//娓呯┖缂撳瓨; +// HDLLinkLocalGateway.getInstance().getGatewayList().clear(); + HdlResidenceLogic.getInstance().delHouseId(homeId);//鍒犻櫎鐢电珯缂撳瓨 + if (UserConfigManage.getInstance().isBAccount()) { + //B绔� + //鏀跺埌鎴愬姛缁撴灉鍝嶅簲鍚�,浼氳嚜鍔ㄥ叧闂皬绋嬪簭锛屽湪HDLUniMPSDKManager绫婚噷闈㈡湁鏂规硶()鐩戝惉鍒板皬绋嬪簭鍏抽棴锛岀洃鍚埌灏忕▼搴忓叧闂簨浠跺悗锛屼細閲嶆柊鑾峰彇鐢电珯鍒楄〃杩涜鍒风晫闈紱 + if (null != HDLUniMPSDKManager.getInstance().getUniMP()) { + HDLUniMPSDKManager.getInstance().getUniMP().closeUniMP(); + } + } else { + //C绔� + List<HouseIdBean> HouseIdList = HdlResidenceLogic.getInstance().getHouseIdList(); + if (HouseIdList.size() == 0) { + String path = HDLUniMP.UNI_EVENT_OPEN_HOME_Null_C; + HdlUniLogic.getInstance().openUniMP(path, null); + } else { + HouseIdBean houseIdBean = HouseIdList.get(0);//榛樿鎷跨涓�涓� + HdlResidenceLogic.getInstance().switchHouse(houseIdBean, true); + JsonObject jsonObject = new JsonObject(); + jsonObject.addProperty("homeId", houseIdBean.getHomeId()); + jsonObject.addProperty("homeName", houseIdBean.getHomeName()); + jsonObject.addProperty("powerStationStatus", houseIdBean.getPowerStationStatus() + ""); + HDLUniMP.UniCallBackBaseBean uniCallBackBaseBean = new HDLUniMP.UniCallBackBaseBean(); + uniCallBackBaseBean.setType(HDLUniMP.UNI_EVENT_NOTIFICATION_DEVICE_REFRESH_DETAILS); + uniCallBackBaseBean.setData(jsonObject); + HdlUniLogic.getInstance().sendUni(HDLUniMP.UNI_EVENT_NOTIFICATION_DEVICE_MODEL, uniCallBackBaseBean); + } + + + } + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鐢电珯鎺堟潈瀹夎鍟�(C绔�) + */ + private void uniHomeUpdateDebugPerm(String type, Object data, DCUniMPJSCallback callback) { + + + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + boolean debugPerm = Boolean.parseBoolean(getKeyValue("debugPerm", getKeyValue("data", data))); + HdlResidenceLogic.getInstance().homeUpdateDebugPerm(homeId, debugPerm, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + + } + + /** + * 鐢电珯鎵嬪姩浜や粯(瀹夎鍟�) + */ + private void uniGetDeliverToAccount(String type, Object data, DCUniMPJSCallback callback) { + + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + String account = getKeyValue("account", getKeyValue("data", data)); + HdlResidenceLogic.getInstance().getDeliverToAccount(homeId, account, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + //鏀跺埌鎴愬姛缁撴灉鍝嶅簲鍚�,浼氳嚜鍔ㄥ叧闂皬绋嬪簭锛屽湪HDLUniMPSDKManager绫婚噷闈㈡湁鏂规硶()鐩戝惉鍒板皬绋嬪簭鍏抽棴锛岀洃鍚埌灏忕▼搴忓叧闂簨浠跺悗锛屼細閲嶆柊鑾峰彇鐢电珯鍒楄〃杩涜鍒风晫闈紱 + if (null != HDLUniMPSDKManager.getInstance().getUniMP()) { + HDLUniMPSDKManager.getInstance().getUniMP().closeUniMP(); + } + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + + } + + /** + * 鐢电珯鐨勪氦浠樹簩缁寸爜(瀹夎鍟�) + */ + private void uniGetDeliveryUrlQrcode(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + HdlResidenceLogic.getInstance().getDeliveryUrlQrcode(homeId, new CloudCallBeak<String>() { + @Override + public void onSuccess(String obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + + } + + /** + * 鐢电珯鐨勪氦浠楿Rl(瀹夎鍟�) + */ + private void uniGetDeliveryUrl(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + HdlResidenceLogic.getInstance().getDeliveryUrl(homeId, new CloudCallBeak<String>() { + @Override + public void onSuccess(String obj) { + try { + Gson g = new Gson(); + QrcodeUrlBean qrcodeUrlBean = g.fromJson(obj, QrcodeUrlBean.class); + uniSuccessCallback(type, qrcodeUrlBean.getDeliveryUrl(), callback); + } catch (Exception ignored) { + uniSuccessCallback(type, obj, callback); + } + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + + } + + /** + * 鑾峰彇褰撳墠璐﹀彿鍦ㄥ叕鍙哥殑韬唤 + */ + private void uniGetUserRightType(String type, Object data, DCUniMPJSCallback callback) { + HdlMemberLogic.getInstance().getUserRightType(new CloudCallBeak<UserRightTypeBean>() { + @Override + public void onSuccess(UserRightTypeBean userRightTypeBean) { + uniSuccessCallback(type, userRightTypeBean, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鍛樺伐缂栬緫 + */ + private void uniGetStaffEdit(String type, Object data, DCUniMPJSCallback callback) { + StaffBean staffBean = new StaffBean(); + String staffInfo = getKeyValue("staffInfo", getKeyValue("data", data)); + if (!TextUtils.isEmpty(staffInfo)) { + try { + staffBean = new Gson().fromJson(staffInfo, StaffBean.class); + } catch (Exception ignored) { + } + } + HdlMemberLogic.getInstance().getStaffEdit(staffBean, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鍛樺伐鍒犻櫎 + */ + private void uniGetStaffDelete(String type, Object data, DCUniMPJSCallback callback) { + StaffBean staffBean = new StaffBean(); + String staffInfo = getKeyValue("staffInfo", getKeyValue("data", data)); + if (!TextUtils.isEmpty(staffInfo)) { + try { + staffBean = new Gson().fromJson(staffInfo, StaffBean.class); + } catch (Exception ignored) { + } + } + HdlMemberLogic.getInstance().getStaffDelete(staffBean, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鍛樺伐娣诲姞 + */ + private void uniGetStaffAdd(String type, Object data, DCUniMPJSCallback callback) { + StaffBean staffBean = new StaffBean(); + String staffInfo = getKeyValue("staffInfo", getKeyValue("data", data)); + if (!TextUtils.isEmpty(staffInfo)) { + try { + staffBean = new Gson().fromJson(staffInfo, StaffBean.class); + } catch (Exception ignored) { + } + } + HdlMemberLogic.getInstance().getStaffAdd(staffBean, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鑾峰彇鍛樺伐璇︽儏 + */ + private void uniGetStaffInfo(String type, Object data, DCUniMPJSCallback callback) { + String userId = getKeyValue("userId", getKeyValue("data", data)); + HdlMemberLogic.getInstance().getStaffInfo(userId, new CloudCallBeak<StaffBean>() { + @Override + public void onSuccess(StaffBean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鑾峰彇鍛樺伐鍒楄〃 + */ + private void uniGetStaffList(String type, Object data, DCUniMPJSCallback callback) { + long pageNo = Long.parseLong(getKeyValue("pageNo", getKeyValue("data", data))); + long pageSize = Long.parseLong(getKeyValue("pageSize", getKeyValue("data", data))); + HdlMemberLogic.getInstance().getStaffList(pageNo, pageSize, new CloudCallBeak<PageNumberObject<StaffBean>>() { + @Override + public void onSuccess(PageNumberObject<StaffBean> obj) { + uniSuccessCallback(type, obj.getList(), callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + + /** + * 鎴愬憳缂栬緫 + */ + private void uniGetMemberEdit(String type, Object data, DCUniMPJSCallback callback) { + MemberBean memberBean = new MemberBean(); + String memberInfo = getKeyValue("memberInfo", getKeyValue("data", data)); + if (!TextUtils.isEmpty(memberInfo)) { + try { + memberBean = new Gson().fromJson(memberInfo, MemberBean.class); + } catch (Exception ignored) { + } + } + HdlMemberLogic.getInstance().getMemberEdit(memberBean, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鎴愬憳鍒犻櫎 + */ + private void uniGetMemberDelete(String type, Object data, DCUniMPJSCallback callback) { + MemberBean memberBean = new MemberBean(); + String memberInfo = getKeyValue("memberInfo", getKeyValue("data", data)); + if (!TextUtils.isEmpty(memberInfo)) { + try { + memberBean = new Gson().fromJson(memberInfo, MemberBean.class); + } catch (Exception ignored) { + } + } + HdlMemberLogic.getInstance().getMemberDelete(memberBean, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鎴愬憳娣诲姞 + */ + private void uniGetMemberAdd(String type, Object data, DCUniMPJSCallback callback) { + MemberBean memberBean = new MemberBean(); + String memberInfo = getKeyValue("memberInfo", getKeyValue("data", data)); + if (!TextUtils.isEmpty(memberInfo)) { + try { + memberBean = new Gson().fromJson(memberInfo, MemberBean.class); + } catch (Exception ignored) { + } + } + HdlMemberLogic.getInstance().getMemberAdd(memberBean, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 涓嬭浇鎴愬憳锛堝瓙璐﹀彿锛夊ご鍍� + */ + private void uniGetHeadPIortrait(String type, Object data, DCUniMPJSCallback callback) { + MemberBean memberBean = new MemberBean(); + String memberInfo = getKeyValue("memberInfo", getKeyValue("data", data)); + if (!TextUtils.isEmpty(memberInfo)) { + try { + memberBean = new Gson().fromJson(memberInfo, MemberBean.class); + } catch (Exception ignored) { + } + } + + HdlMemberLogic.getInstance().getHeadPIortrait(memberBean, new CloudCallBeak<byte[]>() { + @Override + public void onSuccess(byte[] obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鑾峰彇鎴愬憳鍒楄〃 + */ + private void uniGetMemberList(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + MemberBean memberBean = new MemberBean(); + memberBean.setHomeId(homeId); + HdlMemberLogic.getInstance().getMemberList(memberBean, new CloudCallBeak<List<MemberBean>>() { + @Override + public void onSuccess(List<MemberBean> list) { + uniSuccessCallback(type, list, callback); + } + + @Override + public void onFailure(HDLException e) { + uniExceptionCallback(type, e, callback); + } + }); + } + + /** + * 鑾峰彇鎴栬�呴厤缃�嗗彉鍣ㄧ綉缁滐紙鍖呮嫭閫嗗彉鍣ㄧ儹鐐癸紝wifi锛屼互澶綉锛変俊鎭� + */ + private void uniGetAndSetNetwork(String type, Object data, String TopicApi, DCUniMPJSCallback callback) { + String mac = getKeyValue("mac", getKeyValue("data", data)); + JsonArray jsonArray = new JsonArray(); + JsonObject jObject = null; + String attribute_data = getKeyValue("attribute_data", getKeyValue("data", data)); + if (!TextUtils.isEmpty(attribute_data)) { + try { + jObject = new Gson().fromJson(attribute_data, JsonObject.class); + } catch (Exception ignored) { + jObject = new JsonObject(); + } + } + jsonArray.add(jObject); + //瑙e瘑璐熻浇鏁版嵁(鍐欏瘑閽ョ粰缃戝叧涓�瀹氭槸鏄庢枃锛屽洜涓洪偅鏃剁綉鍏宠繕娌℃湁瀵嗛挜) + TcpClient.getInstance().sendDataToLinkGateway(mac, false, TopicApi, jsonArray, "", new HDLLinkCallBack() { + @Override + public void onSuccess(String s) { + if (callback != null) { + try { + if (s.startsWith("{")) { + uniSuccessCallback(type, new Gson().fromJson(s, JsonObject.class), callback); + } else if (s.startsWith("[")) { + uniSuccessCallback(type, new Gson().fromJson(s, JsonArray.class), callback); + } else { + uniSuccessCallback(type, s, callback); + } + } catch (Exception e) { + uniSuccessCallback(type, s, callback); + } + } + } + + @Override + public void onError(HDLLinkException e) { + if (callback != null) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + } + }); + } + + + /** + * 鑾峰彇浣嶇疆淇℃伅,鍖呮嫭缁忕含搴� + */ + private void uniGetLocationInfo(String type, Object data, DCUniMPJSCallback callback) { + try { + // 鍒濆鍖朙ocationManager瀵硅薄 + LocationManager locationManager = (LocationManager) HDLApp.getInstance().getSystemService(Context.LOCATION_SERVICE); + Geolocation geolocation = new Geolocation(); + //INTERNET 鍏佽浣跨敤缃戠粶 + //ACCESS_FINE_LOCATION 鍏佽浣跨敤GPS瀹氫綅 + //ACCESS_COARSE_LOCATION 鍏佽浣跨敤WIFI鐑偣鎴栧熀绔欐潵鑾峰彇绮楃暐鐨勫畾浣� + if (ActivityCompat.checkSelfPermission(HDLApp.getInstance(), Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(HDLApp.getInstance(), Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { + geolocation.setResult(-2); + geolocation.setDes(HDLApp.getInstance().getAppLocaleContext().getString(R.string.exception_no_location_information_permission)); + uniSuccessCallback(type, geolocation, callback); + return; + } + // 鍒ゆ柇璁惧鏄惁鏀寔瀹氫綅鍔熻兘 + if (!locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) { + geolocation.setResult(-1); + geolocation.setDes(HDLApp.getInstance().getAppLocaleContext().getString(R.string.exception_the_location_function_is_not_enabled)); + //todo 鎻愮ず鐢ㄦ埛鎵撳紑瀹氫綅鍔熻兘鎴栬�呭紩瀵肩敤鎴峰幓绯荤粺璁剧疆椤甸潰鎵撳紑瀹氫綅鍔熻兘 + uniSuccessCallback(type, geolocation, callback); + return; + } + Location location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER); + if (location == null) { + geolocation.setResult(-3); + geolocation.setDes(HDLApp.getInstance().getAppLocaleContext().getString(R.string.exception_unable_location_move10_meters_later)); + uniSuccessCallback(type, geolocation, callback); + return; + } + geolocation.setResult(0); + geolocation.setDes(HDLApp.getInstance().getAppLocaleContext().getString(R.string.succeed)); + BigDecimal latitude = BigDecimal.valueOf(location.getLatitude());//缁忓害 + BigDecimal longitude = BigDecimal.valueOf(location.getLongitude());//绾害 + double lat = latitude.setScale(6, RoundingMode.HALF_DOWN).doubleValue(); + double lon = longitude.setScale(6, RoundingMode.HALF_DOWN).doubleValue(); + geolocation.setLatitude(lat);//缁忓害 + geolocation.setLongitude(lon);//绾害 + uniSuccessCallback(type, geolocation, callback); + } catch (Exception e) { + Geolocation geolocation = new Geolocation(); + geolocation.setResult(-4); + geolocation.setDes(e.getMessage()); + uniSuccessCallback(type, geolocation, callback); + } + } + + /** * 鍚戜簯绔幏鍙栭�嗗彉鍣╫id鍒楄〃 * 鍓嶆彁鏉′欢:瑕佷笂浼犻�嗗彉鍣╫id鍒楄〃缁欎簯绔� * * @param callback - */ - private void uniGetCloudOidList(Object data, DCUniMPJSCallback callback) { + private void uniGetCloudOidList(String type, Object data, DCUniMPJSCallback callback) { HdlOtaLogic.getInstance().getCloudOidList(new CloudCallBeak<List<DeviceOidInfoBean>>() { @Override public void onSuccess(List<DeviceOidInfoBean> obj) { - uniCallbackData(obj, callback); + uniSuccessCallback(type, obj, callback); } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -369,17 +1420,19 @@ * 鍚戜簯绔幏鍙栥�愬綋鍓嶈澶囧浐浠躲�戝垪琛� * 鍓嶆彁鏉′欢:璁惧鑷姩涓婃姤oid淇℃伅缁欎簯绔� */ - private void uniGetCurrentDeviceFirmwares(Object data, DCUniMPJSCallback callback) { + private void uniGetCurrentDeviceFirmwares(String type, Object data, DCUniMPJSCallback callback) { String deviceOidId = getKeyValue("deviceOidId", getKeyValue("data", data));//浜戠涓婅澶噄d - HdlOtaLogic.getInstance().getCurrentDeviceFirmwares(deviceOidId, new CloudCallBeak<List<DeviceFirmwareBean>>() { + String oid = getKeyValue("oid", getKeyValue("data", data));//璁惧oid + String homeId = getKeyValue("homeId", getKeyValue("data", data));//鐢电珯id + HdlOtaLogic.getInstance().getCurrentDeviceFirmwares(deviceOidId, oid, homeId, new CloudCallBeak<List<DeviceFirmwareBean>>() { @Override public void onSuccess(List<DeviceFirmwareBean> obj) { - uniCallbackData(obj, callback); + uniSuccessCallback(type, obj, callback); } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -388,18 +1441,18 @@ * 鍚戜簯绔幏鍙栥�愯澶囨柊鍥轰欢銆戝垪琛� * 鍓嶆彁鏉′欢:瑕侀�氳繃骞冲彴杞欢涓婁紶鏂板浐浠� */ - private void uniGetNewDeviceFirmwares(Object data, DCUniMPJSCallback callback) { + private void uniGetNewDeviceFirmwares(String type, Object data, DCUniMPJSCallback callback) { String hardwareModel = getKeyValue("hardwareModel", getKeyValue("data", data));//纭欢鍨嬪彿 String osImageId = getKeyValue("osImageId", getKeyValue("data", data));//绯荤粺闀滃儚id HdlOtaLogic.getInstance().getNewDeviceFirmwares(hardwareModel, osImageId, new CloudCallBeak<List<CloudDeviceFirmwaresBean>>() { @Override public void onSuccess(List<CloudDeviceFirmwaresBean> obj) { - uniCallbackData(obj, callback); + uniSuccessCallback(type, obj, callback); } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -407,11 +1460,11 @@ /** * 鑾峰彇銆愯澶囨湰鍦板浐浠躲�戝垪琛� */ - private void uniGetLocalFirmwares(Object data, DCUniMPJSCallback callback) { + private void uniGetLocalFirmwares(String type, Object data, DCUniMPJSCallback callback) { try { - String hardwareModel = getKeyValue("hardwareModel", getKeyValue("data", data));//纭欢鍨嬪彿 +// String hardwareModel = getKeyValue("hardwareModel", getKeyValue("data", data));//纭欢鍨嬪彿 String osImageId = getKeyValue("osImageId", getKeyValue("data", data));//绯荤粺闀滃儚id - String firmwareVersionId = getKeyValue("firmwareVersionId", getKeyValue("data", data));//鍥轰欢鐗堟湰id +// String firmwareVersionId = getKeyValue("firmwareVersionId", getKeyValue("data", data));//鍥轰欢鐗堟湰id // String oid = getKeyValue("oid", getKeyValue("data", data));//鍥轰欢oid List<DeviceFirmwareBean> list = new ArrayList<>(); String driverFileList = HdlFileLogic.getInstance().getFirmwareRootPath(); @@ -419,20 +1472,20 @@ if (file.list() != null) { for (int i = 0; i < Objects.requireNonNull(file.list()).length; i++) { String path = Objects.requireNonNull(file.list())[i]; -// if (!path.contains(oid)) { -// continue; -// } + if (!path.contains(osImageId)) { + continue; + } String[] ary = path.split("/"); String[] driverInfoAry = ary[ary.length - 1].split("_"); DeviceFirmwareBean deviceFirmwareBean = new DeviceFirmwareBean(); - deviceFirmwareBean.setOid(driverInfoAry[0]); + deviceFirmwareBean.setImageId(driverInfoAry[0]); deviceFirmwareBean.setVersion(driverInfoAry[1].replace(".zip", "")); - deviceFirmwareBean.setLocalUrl(HdlFileLogic.getInstance().getFirmwarePathFileName(deviceFirmwareBean.getOid(), deviceFirmwareBean.getVersion())); + deviceFirmwareBean.setLocalUrl(HdlFileLogic.getInstance().getFirmwarePathFileName(osImageId, deviceFirmwareBean.getVersion())); list.add(deviceFirmwareBean); } } if (callback != null) { - this.uniCallbackData(list, callback); + this.uniSuccessCallback(type, list, callback); } } catch (Exception ignored) { } @@ -441,8 +1494,8 @@ /** * 鍚戜簯绔彂璧枫�愯澶囧浐浠朵笅杞姐�戞寚浠� */ - private void uniDeviceFirmwareDownload(Object data, DCUniMPJSCallback callback) { - String deviceOidId = getKeyValue("deviceOidId", getKeyValue("data", data));//浜戠涓婅澶噄d + private void uniDeviceFirmwareDownload(String type, Object data, DCUniMPJSCallback callback) { +// String deviceOidId = getKeyValue("deviceOidId", getKeyValue("data", data));//浜戠涓婅澶噄d String oid = getKeyValue("oid", getKeyValue("data", data));//璇ュ浐浠剁殑oid String imageId = getKeyValue("imageId", getKeyValue("data", data));//鍥轰欢闀滃儚id String version = getKeyValue("version", getKeyValue("data", data));//鍥轰欢鐗堟湰 @@ -452,20 +1505,31 @@ HdlOtaLogic.getInstance().getDeviceUpgradeDownloadFile(url, new CloudCallBeak<ResponseBody>() { @Override public void onSuccess(ResponseBody responseBody) { - String firmwarePathFileName = HdlFileLogic.getInstance().getFirmwarePathFileName(oid, version); - boolean isBoolean = HdlOtaLogic.getInstance().disposeDownLoadFile(firmwarePathFileName, responseBody, md5, HdlOtaLogic.firmware_type); - if (isBoolean) { - HdlFileLogic.getInstance().deleteFile(localUrl);//涓嬭浇鎴愬姛,鍒犻櫎鏃у浐浠舵枃浠�; - } else { - HdlFileLogic.getInstance().deleteFile(firmwarePathFileName);//涓嬭浇澶辫触锛屽垹闄や笉瀹屾暣鍥轰欢鏂囦欢; - } - HdlLogLogic.print("鍐欏叆鏂板浐浠舵枃浠跺埌鍐呭瓨鎴愬姛.", false); + HdlThreadLogic.runSubThread(new Runnable() { + @Override + public void run() { + String firmwarePathFileName = HdlFileLogic.getInstance().getFirmwarePathFileName(imageId, version); + //涓嶅湪瀛愮嚎绋嬭娴佷細鍗℃涓荤嚎绋� + boolean isBoolean = HdlOtaLogic.getInstance().disposeDownLoadFile(firmwarePathFileName, responseBody, md5, HdlOtaLogic.firmware_type); + if (isBoolean) { + HdlFileLogic.getInstance().deleteFile(localUrl);//涓嬭浇鎴愬姛,鍒犻櫎鏃у浐浠舵枃浠�; + } else { + HdlFileLogic.getInstance().deleteFile(firmwarePathFileName);//涓嬭浇澶辫触锛屽垹闄や笉瀹屾暣鍥轰欢鏂囦欢; + } + + if (isBoolean) { + uniCallbackData(type, null, 0, HDLApp.getInstance().getAppLocaleContext().getString(R.string.writing_firmware_upgrade_memory_succeeded), callback); + } else { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.download_firmware_upgrade_file_failed), callback); + } + } + }); + } @Override public void onFailure(HDLException e) { - HdlLogLogic.print("涓嬭浇鍥轰欢鏂囦欢鍒板唴瀛樺け璐�.", false); - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -473,104 +1537,154 @@ /** * 鍚戜簯绔彂璧枫�愯澶囧浐浠躲�戝崌绾TA鎸囦护 */ - private void uniUpgradeDeviceFirmware(Object data, DCUniMPJSCallback callback) { + private void uniUpgradeDeviceFirmware(String type, Object data, DCUniMPJSCallback callback) { + String homeId = UserConfigManage.getInstance().getHomeId(); String deviceMac = getKeyValue("mac", getKeyValue("data", data));//閫嗗彉鍣ㄨ澶噈ac锛堟煡鎵緎ocket锛� String deviceOidId = getKeyValue("deviceOidId", getKeyValue("data", data));//浜戠涓婅澶噄d String oid = getKeyValue("oid", getKeyValue("data", data));//鍗囩骇鍥轰欢鐨刼id String firmwareVersionId = getKeyValue("firmwareVersionId", getKeyValue("data", data));//鍥轰欢鐗堟湰id String version = getKeyValue("version", getKeyValue("data", data));//鍥轰欢鐗堟湰 - String hardwareModel = getKeyValue("hardwareModel", getKeyValue("data", data));//浜戠涓婃枃浠禡D5 +// String hardwareModel = getKeyValue("hardwareModel", getKeyValue("data", data));//浜戠涓婃枃浠禡D5 + String imageId = getKeyValue("imageId", getKeyValue("data", data));//鍥轰欢闀滃儚id + String module = "FW#" + imageId;//妯″潡淇℃伅(HW锛氱‖浠�) //鍗囩骇鏈湴浼樺厛->浜戠鍗囩骇 - boolean isLocalConnect = HdlDeviceLogic.getInstance().isLocalConnect(deviceMac); - if (isLocalConnect) { - //鏈湴 - //1,寤虹珛鏈湴鏈嶅姟锛� - //2,鍛婅瘔缃戝叧鎵嬫満ip鍜岀鍙o紱 - //瀹炰緥鍖� 鑾峰彇ip 鍦板潃 - HdlOtaLogic.getInstance().startLocalService(new ServiceConnection() { - @Override - public void onServiceConnected(ComponentName name, IBinder service) { - //鏈湴鍗囩骇鍥轰欢鏂囦欢璺緞 - String firmwarePathFileName = HdlFileLogic.getInstance().getFirmwarePathFileName(oid, version); - String data = HdlFileLogic.getInstance().readFile(firmwarePathFileName); - String md5 = HDLMD5Utils.encodeMD5(data);//缃戝叧鍥轰欢闇�瑕� - //鍗囩骇鍥轰欢鏂囦欢鍦板潃 - String upgradeFileLocalPathUrl = AppManagerUtils.getAppManager().getIPAddress(HDLApp.getInstance()) + ":" + MyNanoHttpServer.HTTP_PORT + firmwarePathFileName; - //閫氱煡缁欑綉鍏冲崌绾у浐浠舵枃浠跺湴鍧�绛変俊鎭� - HdlOtaLogic.getInstance().pushUpgradePacketInfo(deviceMac, oid, hardwareModel, version, data.length() + "", upgradeFileLocalPathUrl, md5, new LinkCallBack<String>() { + HdlDeviceLogic.getInstance().isLocalConnect(homeId, deviceMac, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean b) { + if (b) { + HdlLogLogic.print("鏈湴鍗囩骇---", true); + //鏈湴 + //1,寤虹珛鏈湴鏈嶅姟锛� + //2,鍛婅瘔缃戝叧鎵嬫満ip鍜岀鍙o紱 + //瀹炰緥鍖� 鑾峰彇ip 鍦板潃 + HdlOtaLogic.getInstance().startLocalService(new ServiceConnection() { @Override - public void onSuccess(String obj) { - HdlLogLogic.print("閫氱煡缁欑綉鍏冲崌绾у浐浠舵枃浠跺湴鍧�鎴愬姛.", false); + public void onServiceConnected(ComponentName name, IBinder service) { + //鏈湴鍗囩骇鍥轰欢鏂囦欢璺緞 + String firmwarePathFileName = HdlFileLogic.getInstance().getFirmwarePathFileName(imageId, version); + byte[] data = HdlFileLogic.getInstance().readFileByte(firmwarePathFileName); + if (data == null || data.length == 0) { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.found_locally_firmware_upgrade_file), callback); + return; + } + String md5 = HDLMD5Utils.encodeMD5(data);//缃戝叧鍥轰欢闇�瑕� + //鍗囩骇鍥轰欢鏂囦欢鍦板潃 + String upgradeFileLocalPathUrl = "http://" + NetworkUtils.getIPAddress(HDLApp.getInstance()) + ":" + MyNanoHttpServer.HTTP_PORT + firmwarePathFileName; + //閫氱煡缁欑綉鍏冲崌绾у浐浠舵枃浠跺湴鍧�绛変俊鎭� + HdlOtaLogic.getInstance().pushUpgradePacketInfo(deviceMac, oid, module, version, data.length + "", upgradeFileLocalPathUrl, md5, new LinkCallBack<String>() { + @Override + public void onSuccess(String obj) { + HdlLogLogic.print("閫氱煡缁欑綉鍏冲崌绾у浐浠舵枃浠跺湴鍧�鎴愬姛.", true); + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.notify_gateway_firmware_upgrade_failed), callback); + } + }); } @Override - public void onError(HDLLinkException e) { - HdlLogLogic.print("閫氱煡缁欑綉鍏冲崌绾у浐浠舵枃浠跺湴鍧�澶辫触,鏃犳硶鍗囩骇.", false); - uniCallbackData(null, -2, "閫氱煡缁欑綉鍏冲崌绾у浐浠舵枃浠跺湴鍧�澶辫触,鏃犳硶鍗囩骇,", callback); + public void onServiceDisconnected(ComponentName name) { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.local_service_fails), callback); } }); - } - - @Override - public void onServiceDisconnected(ComponentName name) { - uniCallbackData(null, -2, "鏈湴鏈嶅姟鏈夊紓甯稿け璐�,鏃犳硶鍗囩骇,", callback); - } - }); - - } else { - //杩滅▼鍗囩骇闇�瑕佹娴嬪湪閫嗗彉鍣ㄦ湁娌℃湁杩炴帴涓婁簯 - HdlDeviceLogic.getInstance().checkInverterConnectedCloud(deviceMac, new CloudCallBeak<CloudInverterDeviceBean>() { - @Override - public void onSuccess(CloudInverterDeviceBean cloudInverterDeviceBean) { - //1锛氳繛鎺ヤ腑,2锛氭晠闅�,3锛氳繍琛�,4锛氱绾�,6:閫嗗彉鍣ㄨ繛涓嶄笂浜�(鑷畾涔�) - if (cloudInverterDeviceBean == null) { - uniCallbackData(null, 6, HDLApp.getInstance().getString(R.string.ota_binding_cloud_upgrade_fails), callback); - return; - } - if (cloudInverterDeviceBean.getDeviceStatus() != 3) { - uniCallbackData(null, cloudInverterDeviceBean.getDeviceStatus(), HDLApp.getInstance().getString(R.string.ota_not_cloud_upgrade_fails), callback); - return; - } - //4:杩愯 - HdlOtaLogic.getInstance().upgradeDeviceFirmware(deviceOidId, firmwareVersionId, new CloudCallBeak<Boolean>() { + } else { + HdlLogLogic.print("鍦ㄧ嚎鍗囩骇---", true); + //杩滅▼鍗囩骇闇�瑕佹娴嬪湪閫嗗彉鍣ㄦ湁娌℃湁杩炴帴涓婁簯 + HdlDeviceLogic.getInstance().checkInverterConnectedCloud(homeId, deviceMac, new CloudCallBeak<CloudInverterDeviceBean>() { @Override - public void onSuccess(Boolean obj) { - uniCallbackData(obj, callback); + public void onSuccess(CloudInverterDeviceBean cloudInverterDeviceBean) { + //1锛氳繛鎺ヤ腑,2锛氭晠闅�,3锛氳繍琛�,4锛氱绾�,6:閫嗗彉鍣ㄨ繛涓嶄笂浜�(鑷畾涔�) + if (cloudInverterDeviceBean == null) { + uniCallbackData(type, null, 6, HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_binding_cloud_upgrade_fails), callback); + return; + } + if (cloudInverterDeviceBean.getDeviceStatus() != 3) { + uniCallbackData(type, null, cloudInverterDeviceBean.getDeviceStatus(), HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_not_cloud_upgrade_fails), callback); + return; + } + //4:杩愯 + HdlOtaLogic.getInstance().upgradeDeviceFirmware(deviceOidId, firmwareVersionId, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); - } + } - @Override - public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); - } - }); + @Override + public void onFailure(HDLException e) { + HdlLogLogic.print("鍦ㄧ嚎鍗囩骇---", true); + //杩滅▼鍗囩骇闇�瑕佹娴嬪湪閫嗗彉鍣ㄦ湁娌℃湁杩炴帴涓婁簯 + HdlDeviceLogic.getInstance().checkInverterConnectedCloud(homeId, deviceMac, new CloudCallBeak<CloudInverterDeviceBean>() { + @Override + public void onSuccess(CloudInverterDeviceBean cloudInverterDeviceBean) { + //1锛氳繛鎺ヤ腑,2锛氭晠闅�,3锛氳繍琛�,4锛氱绾�,6:閫嗗彉鍣ㄨ繛涓嶄笂浜�(鑷畾涔�) + if (cloudInverterDeviceBean == null) { + uniCallbackData(type, null, 6, HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_binding_cloud_upgrade_fails), callback); + return; + } + if (cloudInverterDeviceBean.getDeviceStatus() != 3) { + uniCallbackData(type, null, cloudInverterDeviceBean.getDeviceStatus(), HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_not_cloud_upgrade_fails), callback); + return; + } + //4:杩愯 + HdlOtaLogic.getInstance().upgradeDeviceFirmware(deviceOidId, firmwareVersionId, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } - } + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + }); + } /** * 鍚戜簯绔幏鍙栥�愬綋鍓嶈澶囬┍鍔ㄣ�戝垪琛� * 鍓嶆彁鏉′欢:璁惧鑷姩涓婃姤oid淇℃伅缁欎簯绔� */ - private void uniGetCurrentGatewayDrivers(Object data, DCUniMPJSCallback callback) { + private void uniGetCurrentGatewayDrivers(String type, Object data, DCUniMPJSCallback callback) { String deviceOid = getKeyValue("oid", getKeyValue("data", data)); - HdlOtaLogic.getInstance().getCurrentGatewayDrivers(deviceOid, new CloudCallBeak<List<GatewayDriverBean>>() { + String homeId = getKeyValue("homeId", getKeyValue("data", data));//鐢电珯id + HdlOtaLogic.getInstance().getCurrentGatewayDrivers(deviceOid, homeId, new CloudCallBeak<List<GatewayDriverBean>>() { @Override public void onSuccess(List<GatewayDriverBean> obj) { - uniCallbackData(obj, callback); + uniSuccessCallback(type, obj, callback); } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -579,18 +1693,18 @@ * 鍚戜簯绔幏鍙栥�愯澶囨柊椹卞姩銆戝垪琛� * 鍓嶆彁鏉′欢:瑕侀�氳繃骞冲彴杞欢涓婁紶鏂伴┍鍔� */ - private void uniGetNewGatewayDrivers(Object data, DCUniMPJSCallback callback) { + private void uniGetNewGatewayDrivers(String type, Object data, DCUniMPJSCallback callback) { String driveCode = getKeyValue("driveCode", getKeyValue("data", data));//椹卞姩缂栧彿鎴栭┍鍔ㄥ悕绉� String osImageId = getKeyValue("osImageId", getKeyValue("data", data));//椹卞姩绫诲瀷id HdlOtaLogic.getInstance().getNewGatewayDrivers(driveCode, osImageId, new CloudCallBeak<CloudGatewayDriversBean>() { @Override public void onSuccess(CloudGatewayDriversBean obj) { - uniCallbackData(obj, callback); + uniSuccessCallback(type, obj, callback); } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -598,11 +1712,11 @@ /** * 鑾峰彇銆愯澶囨湰鍦伴┍鍔ㄣ�戝垪琛� */ - private void uniGetLocalDrivers(Object data, DCUniMPJSCallback callback) { + private void uniGetLocalDrivers(String type, Object data, DCUniMPJSCallback callback) { try { String driveCode = getKeyValue("driveCode", getKeyValue("data", data));//椹卞姩缂栧彿鎴栭┍鍔ㄥ悕绉� - String osImageId = getKeyValue("osImageId", getKeyValue("data", data));//椹卞姩绫诲瀷id - String driverVersionId = getKeyValue("driverVersionId", getKeyValue("data", data));//椹卞姩绫诲瀷id +// String osImageId = getKeyValue("osImageId", getKeyValue("data", data));//椹卞姩绫诲瀷id +// String driverVersionId = getKeyValue("driverVersionId", getKeyValue("data", data));//椹卞姩绫诲瀷id List<GatewayDriverBean> list = new ArrayList<>(); String driverFileList = HdlFileLogic.getInstance().getDriveRootPath(); File file = new File(driverFileList); @@ -621,10 +1735,10 @@ } } if (callback != null) { - this.uniCallbackData(list, callback); + this.uniSuccessCallback(type, list, callback); } } catch (Exception exception) { - this.uniCallbackData(new ArrayList<>(), callback); + this.uniSuccessCallback(type, new ArrayList<>(), callback); } } @@ -632,32 +1746,44 @@ /** * 鍚戜簯绔彂璧枫�愯澶囬┍鍔ㄤ笅杞姐�戞寚浠� */ - private void uniGatewayDriverDownload(Object data, DCUniMPJSCallback callback) { - String deviceOid = getKeyValue("oid", getKeyValue("data", data));//閫嗗彉鍣ㄨ澶噊id + private void uniGatewayDriverDownload(String type, Object data, DCUniMPJSCallback callback) { + +// String deviceOid = getKeyValue("oid", getKeyValue("data", data));//閫嗗彉鍣ㄨ澶噊id String driverCode = getKeyValue("driverCode", getKeyValue("data", data));//椹卞姩缂栫爜 - String imageId = getKeyValue("imageId", getKeyValue("data", data));//椹卞姩闀滃儚id +// String imageId = getKeyValue("imageId", getKeyValue("data", data));//椹卞姩闀滃儚id String version = getKeyValue("version", getKeyValue("data", data));//椹卞姩鐗堟湰 - String driverVersionId = getKeyValue("driverVersionId", getKeyValue("data", data));//椹卞姩鐗堟湰id +// String driverVersionId = getKeyValue("driverVersionId", getKeyValue("data", data));//椹卞姩鐗堟湰id String localUrl = getKeyValue("localUrl", getKeyValue("data", data));//鍌ㄥ瓨鍦ㄦ湰鍦伴┍鍔ㄦ枃浠惰矾寰� String url = getKeyValue("url", getKeyValue("data", data));//浜戠涓婃枃浠跺湴鍧� String md5 = getKeyValue("md5", getKeyValue("data", data));//浜戠涓婃枃浠禡D5 HdlOtaLogic.getInstance().getDeviceUpgradeDownloadFile(url, new CloudCallBeak<ResponseBody>() { @Override public void onSuccess(ResponseBody responseBody) { - String drivePathFileName = HdlFileLogic.getInstance().getDrivePathFileName(driverCode, version); - boolean isBoolean = HdlOtaLogic.getInstance().disposeDownLoadFile(drivePathFileName, responseBody, md5, HdlOtaLogic.driver_type); - if (isBoolean) { - HdlFileLogic.getInstance().deleteFile(localUrl);//涓嬭浇鎴愬姛,鍒犻櫎鏃ч┍鍔ㄦ枃浠�; - } else { - HdlFileLogic.getInstance().deleteFile(drivePathFileName);//涓嬭浇澶辫触锛屽垹闄や笉瀹屾暣椹卞姩鏂囦欢; - } - HdlLogLogic.print("鍐欏叆鏂伴┍鍔ㄦ枃浠跺埌鍐呭瓨鎴愬姛.", false); + HdlThreadLogic.runSubThread(new Runnable() { + @Override + public void run() { + + String drivePathFileName = HdlFileLogic.getInstance().getDrivePathFileName(driverCode, version); + //涓嶅湪瀛愮嚎绋嬭娴佷細鍗℃涓荤嚎绋� + boolean isBoolean = HdlOtaLogic.getInstance().disposeDownLoadFile(drivePathFileName, responseBody, md5, HdlOtaLogic.driver_type); + if (isBoolean) { + HdlFileLogic.getInstance().deleteFile(localUrl);//涓嬭浇鎴愬姛,鍒犻櫎鏃ч┍鍔ㄦ枃浠�; + } else { + HdlFileLogic.getInstance().deleteFile(drivePathFileName);//涓嬭浇澶辫触锛屽垹闄や笉瀹屾暣椹卞姩鏂囦欢; + } + if (isBoolean) { + uniCallbackData(type, null, 0, HDLApp.getInstance().getAppLocaleContext().getString(R.string.writing_drive_memory_succeeded), callback); + } else { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.download_drive_file_failed), callback); + } + } + }); + } @Override public void onFailure(HDLException e) { - HdlLogLogic.print("涓嬭浇椹卞姩鏂囦欢鍒板唴瀛樺け璐�.", false); - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -665,99 +1791,166 @@ /** * 鍚戜簯绔彂璧枫�愯澶囬┍鍔ㄣ�戝崌绾TA鎸囦护 */ - private void uniUpgradeGatewayDriver(Object data, DCUniMPJSCallback callback) { + private void uniUpgradeGatewayDriver(String type, Object data, DCUniMPJSCallback callback) { + String homeId = UserConfigManage.getInstance().getHomeId(); String deviceMac = getKeyValue("mac", getKeyValue("data", data));//閫嗗彉鍣ㄨ澶噈ac锛堟煡鎵緎ocket锛� String deviceOid = getKeyValue("oid", getKeyValue("data", data));//閫嗗彉鍣ㄨ澶噊id String driverVersionId = getKeyValue("driverVersionId", getKeyValue("data", data));//椹卞姩鐗堟湰id - String module = getKeyValue("module", getKeyValue("data", data));//妯″潡淇℃伅 String version = getKeyValue("version", getKeyValue("data", data));//椹卞姩鐗堟湰鍙� String driverCode = getKeyValue("driverCode", getKeyValue("data", data));//椹卞姩缂栫爜 + String imageId = getKeyValue("imageId", getKeyValue("data", data));//鍥轰欢闀滃儚id + String module = driverCode + "#" + imageId; //鍗囩骇鏈湴浼樺厛->浜戠鍗囩骇 - boolean isLocalConnect = HdlDeviceLogic.getInstance().isLocalConnect(deviceMac); - if (isLocalConnect) { - //鏈湴 - //1,寤虹珛鏈湴鏈嶅姟锛� - // 2锛屽憡璇夌綉鍏虫墜鏈篿p鍜岀鍙o紱 - //瀹炰緥鍖� 鑾峰彇ip 鍦板潃 - HdlOtaLogic.getInstance().startLocalService(new ServiceConnection() { - @Override - public void onServiceConnected(ComponentName name, IBinder service) { - //鏈湴鍗囩骇椹卞姩鏂囦欢璺緞 - String drivePathFileName = HdlFileLogic.getInstance().getDrivePathFileName(driverCode, version); - String data = HdlFileLogic.getInstance().readFile(drivePathFileName); - String md5 = HDLMD5Utils.encodeMD5(data);//缃戝叧椹卞姩闇�瑕� - //鍗囩骇椹卞姩鏂囦欢鍦板潃 - String upgradeFileLocalPathUrl = AppManagerUtils.getAppManager().getIPAddress(HDLApp.getInstance()) + ":" + MyNanoHttpServer.HTTP_PORT + drivePathFileName; - //閫氱煡缁欑綉鍏冲崌绾ч┍鍔ㄦ枃浠跺湴鍧�绛変俊鎭� - HdlOtaLogic.getInstance().pushUpgradePacketInfo(deviceMac, deviceOid, module, version, data.length() + "", upgradeFileLocalPathUrl, md5, new LinkCallBack<String>() { + HdlDeviceLogic.getInstance().isLocalConnect(homeId, deviceMac, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean b) { + if (b) { + HdlLogLogic.print("鏈湴鍗囩骇---", true); + //鏈湴 + //1,寤虹珛鏈湴鏈嶅姟锛� + // 2锛屽憡璇夌綉鍏虫墜鏈篿p鍜岀鍙o紱 + //瀹炰緥鍖� 鑾峰彇ip 鍦板潃 + HdlOtaLogic.getInstance().startLocalService(new ServiceConnection() { @Override - public void onSuccess(String obj) { - HdlLogLogic.print("閫氱煡缁欑綉鍏冲崌绾ч┍鍔ㄦ枃浠跺湴鍧�鎴愬姛.", false); + public void onServiceConnected(ComponentName name, IBinder service) { + //鏈湴鍗囩骇椹卞姩鏂囦欢璺緞 + String drivePathFileName = HdlFileLogic.getInstance().getDrivePathFileName(driverCode, version); + byte[] data = HdlFileLogic.getInstance().readFileByte(drivePathFileName); + if (data == null || data.length == 0) { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.found_locally_drive_file), callback); + return; + } + String md5 = HDLMD5Utils.encodeMD5(data);//缃戝叧椹卞姩闇�瑕� + //鍗囩骇椹卞姩鏂囦欢鍦板潃 + String upgradeFileLocalPathUrl = "http://" + NetworkUtils.getIPAddress(HDLApp.getInstance()) + ":" + MyNanoHttpServer.HTTP_PORT + drivePathFileName; + //閫氱煡缁欑綉鍏冲崌绾ч┍鍔ㄦ枃浠跺湴鍧�绛変俊鎭� + HdlOtaLogic.getInstance().pushUpgradePacketInfo(deviceMac, deviceOid, module, version, data.length + "", upgradeFileLocalPathUrl, md5, new LinkCallBack<String>() { + @Override + public void onSuccess(String obj) { + HdlLogLogic.print("閫氱煡缁欑綉鍏冲崌绾ч┍鍔ㄦ枃浠跺湴鍧�鎴愬姛.", true); + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.notify_gateway_drive_failed), callback); + } + }); } @Override - public void onError(HDLLinkException e) { - HdlLogLogic.print("閫氱煡缁欑綉鍏冲崌绾ч┍鍔ㄦ枃浠跺湴鍧�澶辫触,鏃犳硶鍗囩骇.", false); - uniCallbackData(null, -2, "閫氱煡缁欑綉鍏冲崌绾ч┍鍔ㄦ枃浠跺湴鍧�澶辫触,鏃犳硶鍗囩骇,", callback); + public void onServiceDisconnected(ComponentName name) { + uniCallbackData(type, null, -2, HDLApp.getInstance().getAppLocaleContext().getString(R.string.local_service_fails), callback); } }); - } - - @Override - public void onServiceDisconnected(ComponentName name) { - uniCallbackData(null, -2, "鏈湴鏈嶅姟鏈夊紓甯稿け璐�,鏃犳硶鍗囩骇,", callback); - } - }); - } else { - //杩滅▼鍗囩骇闇�瑕併�愭娴嬨�戝湪閫嗗彉鍣ㄦ湁娌℃湁杩炴帴涓婁簯 - HdlDeviceLogic.getInstance().checkInverterConnectedCloud(deviceMac, new CloudCallBeak<CloudInverterDeviceBean>() { - @Override - public void onSuccess(CloudInverterDeviceBean cloudInverterDeviceBean) { - //1锛氳繛鎺ヤ腑,2锛氭晠闅�,3锛氳繍琛�,4锛氱绾�,6:閫嗗彉鍣ㄨ繛涓嶄笂浜�(鑷畾涔�) - if (cloudInverterDeviceBean == null) { - uniCallbackData(null, 6, HDLApp.getInstance().getString(R.string.ota_binding_cloud_upgrade_fails), callback); - return; - } - if (cloudInverterDeviceBean.getDeviceStatus() != 3) { - uniCallbackData(null, cloudInverterDeviceBean.getDeviceStatus(), HDLApp.getInstance().getString(R.string.ota_not_cloud_upgrade_fails), callback); - return; - } - //4:杩愯 - HdlOtaLogic.getInstance().upgradeGatewayDriver(deviceOid, driverVersionId, new CloudCallBeak<Boolean>() { + } else { + HdlLogLogic.print("鍦ㄧ嚎鍗囩骇---", true); + //杩滅▼鍗囩骇闇�瑕併�愭娴嬨�戝湪閫嗗彉鍣ㄦ湁娌℃湁杩炴帴涓婁簯 + HdlDeviceLogic.getInstance().checkInverterConnectedCloud(homeId, deviceMac, new CloudCallBeak<CloudInverterDeviceBean>() { @Override - public void onSuccess(Boolean obj) { - uniCallbackData(obj, callback); + public void onSuccess(CloudInverterDeviceBean cloudInverterDeviceBean) { + //1锛氳繛鎺ヤ腑,2锛氭晠闅�,3锛氳繍琛�,4锛氱绾�,6:閫嗗彉鍣ㄨ繛涓嶄笂浜�(鑷畾涔�) + if (cloudInverterDeviceBean == null) { + uniCallbackData(type, null, 6, HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_binding_cloud_upgrade_fails), callback); + return; + } + if (cloudInverterDeviceBean.getDeviceStatus() != 3) { + uniCallbackData(type, null, cloudInverterDeviceBean.getDeviceStatus(), HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_not_cloud_upgrade_fails), callback); + return; + } + //4:杩愯 + HdlOtaLogic.getInstance().upgradeGatewayDriver(deviceOid, driverVersionId, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); - } + } - @Override - public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); - } - }); + @Override + public void onFailure(HDLException e) { + HdlLogLogic.print("鍦ㄧ嚎鍗囩骇---", true); + //杩滅▼鍗囩骇闇�瑕併�愭娴嬨�戝湪閫嗗彉鍣ㄦ湁娌℃湁杩炴帴涓婁簯 + HdlDeviceLogic.getInstance().checkInverterConnectedCloud(homeId, deviceMac, new CloudCallBeak<CloudInverterDeviceBean>() { + @Override + public void onSuccess(CloudInverterDeviceBean cloudInverterDeviceBean) { + //1锛氳繛鎺ヤ腑,2锛氭晠闅�,3锛氳繍琛�,4锛氱绾�,6:閫嗗彉鍣ㄨ繛涓嶄笂浜�(鑷畾涔�) + if (cloudInverterDeviceBean == null) { + uniCallbackData(type, null, 6, HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_binding_cloud_upgrade_fails), callback); + return; + } + if (cloudInverterDeviceBean.getDeviceStatus() != 3) { + uniCallbackData(type, null, cloudInverterDeviceBean.getDeviceStatus(), HDLApp.getInstance().getAppLocaleContext().getString(R.string.ota_not_cloud_upgrade_fails), callback); + return; + } + //4:杩愯 + HdlOtaLogic.getInstance().upgradeGatewayDriver(deviceOid, driverVersionId, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } - } + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + }); + } /** - * 鍙栨秷涓嬭浇鍗囩骇鏂囦欢 + * 鍙栨秷涓嬭浇銆愰┍鍔�,鍥轰欢銆戝崌绾ф枃浠� */ - private void uniCancelDownloadingUpgradeFile(Object data, DCUniMPJSCallback callback) { - HdlOtaLogic.getInstance().setStopDriversDownload(); + private void uniCancelDownloadingUpgradeFile(String type, Object data, DCUniMPJSCallback callback) { + HdlOtaLogic.getInstance().stopDownloadUpgradeFile(); + uniCallbackData(type, null, 0, HDLApp.getInstance().getAppLocaleContext().getString(R.string.cancel_download_successfully), callback); + } + + /** + * 鍙栨秷銆愰┍鍔�,鍥轰欢銆戝崌绾� + */ + private void uniCancelUpgrade(String type, Object data, DCUniMPJSCallback callback) { + HdlOtaLogic.getInstance().cancelUpgrade("", new LinkCallBack<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + + } + + @Override + public void onError(HDLLinkException e) { + + } + }); } /** * 寮�鍚湇鍔� */ - private void uniOpenService(Object data, DCUniMPJSCallback callback) { + private void uniOpenService(String type, Object data, DCUniMPJSCallback callback) { HdlOtaLogic.getInstance().startLocalService(new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { @@ -773,7 +1966,7 @@ /** * 鍏抽棴鏈嶅姟 */ - private void uniCloseService(Object data, DCUniMPJSCallback callback) { + private void uniCloseService(String type, Object data, DCUniMPJSCallback callback) { HdlOtaLogic.getInstance().unLocalService(); } @@ -785,13 +1978,13 @@ public String getDeviceStatusString(int deviceStatus) { switch (deviceStatus) { case 1: { - return HDLApp.getInstance().getString(R.string.my_power_station_connecting); + return HDLApp.getInstance().getAppLocaleContext().getString(R.string.my_power_station_connecting); } case 2: { - return HDLApp.getInstance().getString(R.string.my_power_station_malfunction); + return HDLApp.getInstance().getAppLocaleContext().getString(R.string.my_power_station_malfunction); } case 4: { - return HDLApp.getInstance().getString(R.string.my_power_station_off_line); + return HDLApp.getInstance().getAppLocaleContext().getString(R.string.my_power_station_off_line); } default: return ""; @@ -800,22 +1993,119 @@ } /** + * 鑾峰彇鐢ㄦ埛淇℃伅 + * + * @param data uni鏁版嵁 + * @param callback uni鍥炶皟 + */ + private void uniGetUserInfo(String type, Object data, DCUniMPJSCallback callback) { + HdlAccountLogic.getInstance().getMemberInfo_C(new CloudCallBeak<CUserInfo>() { + @Override + public void onSuccess(CUserInfo cUserInfo) { + if (cUserInfo == null) { + return; + } + + //鑾峰彇鐢ㄦ埛澶村儚璺緞 + if (cUserInfo.getMemberHeadIcon().contains("http")) { + //鏇存柊鐢ㄦ埛澶村儚 + uniSuccessCallback(type, cUserInfo, callback); + UserConfigManage.getInstance().setUserName(cUserInfo.getMemberName()); + UserConfigManage.getInstance().setBingPhone(cUserInfo.getMemberPhone()); + UserConfigManage.getInstance().setBingEmail(cUserInfo.getMemberEmail()); + UserConfigManage.getInstance().setUserImageUrl(cUserInfo.getMemberHeadIcon()); + UserConfigManage.getInstance().Save(); + HdlLogLogic.print("澶村儚璺緞---->>>" + cUserInfo.getMemberHeadIcon()); + } else { + HdlAccountLogic.getInstance().getImageKey_C(cUserInfo.getMemberHeadIcon(), new CloudCallBeak<String>() { + @Override + public void onSuccess(String url) { + cUserInfo.setMemberHeadIcon(url); + uniSuccessCallback(type, cUserInfo, callback); + UserConfigManage.getInstance().setUserName(cUserInfo.getMemberName()); + UserConfigManage.getInstance().setBingPhone(cUserInfo.getMemberPhone()); + UserConfigManage.getInstance().setBingEmail(cUserInfo.getMemberEmail()); + UserConfigManage.getInstance().setUserImageUrl(cUserInfo.getMemberHeadIcon()); + UserConfigManage.getInstance().Save(); + HdlLogLogic.print("澶村儚璺緞----" + cUserInfo.getMemberHeadIcon()); + } + + @Override + public void onFailure(HDLException e) { + uniSuccessCallback(type, cUserInfo, callback); + } + }); + } + + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 鑾峰彇鐢ㄦ埛澶村儚 + * + * @param data uni鏁版嵁 + * @param callback uni鍥炶皟 + */ + private void uniGetImageKey(String type, Object data, DCUniMPJSCallback callback) { + String imageKey = getKeyValue("imageKey", getKeyValue("data", data)); + HdlAccountLogic.getInstance().getImageKey_C(imageKey, new CloudCallBeak<String>() { + @Override + public void onSuccess(String url) { + uniSuccessCallback(type, url, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + + /** * 閫嗗彉鍣ㄦ竻绌轰綇瀹卛d * * @param data uni鏁版嵁 * @param callback uni鍥炶皟 */ - private void uniClearInverterHomeId(Object data, DCUniMPJSCallback callback) { + private void uniClearInverterHomeId(String type, Object data, DCUniMPJSCallback callback) { String mac = getKeyValue("mac", getKeyValue("data", data)); HdlDeviceLogic.getInstance().clearInverterHomeId(mac, new LinkCallBack<Boolean>() { @Override public void onSuccess(Boolean obj) { - uniCallbackData(null, callback); + uniSuccessCallback(type, null, callback); } @Override public void onError(HDLLinkException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 鑾峰彇鏈鐞�/鏈娑堟伅鏁伴噺 + * + * @param data uni鏁版嵁 + * @param callback uni鍥炶皟 + */ + private void uniGetMessageNumber(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + HdlMessageLogic.getInstance().getMessageUntreatedCount(homeId, new CloudCallBeak<UnCountBean>() { + @Override + public void onSuccess(UnCountBean data) { + uniSuccessCallback(type, data, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -826,9 +2116,13 @@ * @param data uni鏁版嵁 * @param callback uni鍥炶皟 */ - private void uniUploadDataToCloud(Object data, DCUniMPJSCallback callback) { + private void uniUploadDataToCloud(String type, Object data, DCUniMPJSCallback callback) { String mac = getKeyValue("mac", getKeyValue("data", data)); - HdlDeviceLogic.getInstance().uploadDataToCloud(mac, null); + List<GatewayBean> list = new ArrayList<>(); + GatewayBean gatewayBean = new GatewayBean(); + gatewayBean.setDevice_mac(mac); + list.add(gatewayBean); + HdlDeviceLogic.getInstance().uploadOidDataToCloud(UserConfigManage.getInstance().getHomeId(), list, true, null); } /** @@ -837,19 +2131,20 @@ * @param data uni鏁版嵁 * @param callback uni鍥炶皟 */ - private void uniEditInverterTime(Object data, DCUniMPJSCallback callback) { + private void uniEditInverterTime(String type, Object data, DCUniMPJSCallback callback) { String mac = getKeyValue("mac", getKeyValue("data", data)); String date = getKeyValue("date", getKeyValue("data", data)); String time = getKeyValue("time", getKeyValue("data", data)); - HdlDeviceLogic.getInstance().editGatewayTime(mac, date, time, new LinkCallBack<Boolean>() { + String timezone = getKeyValue("timezone", getKeyValue("data", data)); + HdlDeviceLogic.getInstance().editGatewayTime(mac, date, time, timezone, new LinkCallBack<Boolean>() { @Override public void onSuccess(Boolean obj) { - uniCallbackData(true, callback); + uniSuccessCallback(type, true, callback); } @Override public void onError(HDLLinkException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -860,19 +2155,19 @@ * @param data uni鏁版嵁 * @param callback uni鍥炶皟 */ - private void uniGetInverterTime(Object data, DCUniMPJSCallback callback) { + private void uniGetInverterTime(String type, Object data, DCUniMPJSCallback callback) { String mac = getKeyValue("mac", getKeyValue("data", data)); HdlDeviceLogic.getInstance().getGatewayTime(mac, new LinkCallBack<DeviceTimeBean>() { @Override public void onSuccess(DeviceTimeBean deviceTimeBean) { if (callback != null) { - uniCallbackData(deviceTimeBean, callback); + uniSuccessCallback(type, deviceTimeBean, callback); } } @Override public void onError(HDLLinkException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @@ -883,22 +2178,24 @@ * @param data uni鏁版嵁 * @param callback uni鍥炶皟 */ - private void uniGetInverterOidList(Object data, DCUniMPJSCallback callback) { + private void uniGetInverterOidList(String type, Object data, DCUniMPJSCallback callback) { String mac = getKeyValue("mac", getKeyValue("data", data)); HdlDeviceLogic.getInstance().getInverterOidList(mac, new LinkCallBack<List<OidBean>>() { @Override public void onSuccess(List<OidBean> list) { if (callback != null) { - uniCallbackData(list, callback); + uniSuccessCallback(type, list, callback); } } @Override public void onError(HDLLinkException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); + } + /** * 閫嗗彉鍣ㄦ坊鍔犲埌浜戠涓� @@ -906,9 +2203,10 @@ * @param data uni鏁版嵁 * @param callback uni鍥炶皟 */ - private void uniAddInverterDeviceToCloud(Object data, DCUniMPJSCallback callback) { + private void uniAddInverterDeviceToCloud(String type, Object data, DCUniMPJSCallback callback) { String mac = getKeyValue("mac", getKeyValue("data", data)); - HdlDeviceLogic.getInstance().setGatewayRemoteParam(mac, new LinkCallBack<Boolean>() { + String homeId = UserConfigManage.getInstance().getHomeId(); + HdlDeviceLogic.getInstance().setGatewayRemoteParam(homeId, mac, new LinkCallBack<Boolean>() { @Override public void onSuccess(Boolean obj) { HdlDeviceLogic.getInstance().editGatewayParam(mac, new LinkCallBack<Boolean>() { @@ -916,34 +2214,122 @@ public void onSuccess(Boolean obj) { GatewayBean gatewayBean = HDLLinkLocalGateway.getInstance().getLocalGateway(mac); if (gatewayBean == null) { - uniCallbackData(null, -100, "鏈湴鎵句笉鍒扮綉鍏�", callback); + uniCallbackData(type, null, -100, HDLApp.getInstance().getAppLocaleContext().getString(R.string.The_gateway_cannot_be_found_locally), callback); + return; } - HdlDeviceLogic.getInstance().addInverterDeviceToCloud(mac, gatewayBean.getGatewayType(), gatewayBean.getSid(), gatewayBean.getOid(), gatewayBean.getDevice_name(), new CloudCallBeak<Boolean>() { + HdlDeviceLogic.getInstance().addInverterDeviceToCloud(homeId, mac, gatewayBean.getGatewayType(), gatewayBean.getSid(), gatewayBean.getOid(), gatewayBean.getDevice_name(), new CloudCallBeak<Boolean>() { @Override public void onSuccess(Boolean obj) { - uniCallbackData(null, callback); + uniSuccessCallback(type, null, callback); } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @Override public void onError(HDLLinkException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); } @Override public void onError(HDLLinkException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } }); + } + + /** + * 澶氫釜閫嗗彉鍣ㄦ坊鍔犲埌浜戠涓� + * + * @param data uni鏁版嵁 + * @param callback uni鍥炶皟 + */ + private void uniAddAllInverterDeviceToCloud(String type, Object data, DCUniMPJSCallback callback) { +// com.alibaba.fastjson.JSONArray jsonArray = JSON.parseArray(data); + try { + String devices = getKeyValue("devices", getKeyValue("data", data)); + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + Gson gson = new Gson(); + Type typeOfT = new TypeToken<List<GatewayBean>>() { + }.getType(); + List<GatewayBean> list = gson.fromJson(devices, typeOfT); + if (list == null || list.size() == 0) { + uniCallbackData(type, null, -100, HDLApp.getInstance().getAppLocaleContext().getString(R.string.The_gateway_cannot_be_found_locally), callback); + return; + } + //璁板綍鏉℃暟 + AtomicInteger atomicInteger = new AtomicInteger(0); + final boolean[] is_boolean = {false}; + for (int i = 0; i < list.size(); i++) { + GatewayBean gatewayBean = list.get(i); + HdlDeviceLogic.getInstance().setGatewayRemoteParam(homeId, gatewayBean.getDevice_mac(), new LinkCallBack<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + HdlDeviceLogic.getInstance().editGatewayParam(gatewayBean.getDevice_mac(), new LinkCallBack<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + atomicInteger.set(atomicInteger.get() + 1); + //鏈�鍚庝竴鏉℃墠鍋氭坊鍔犻�嗗彉鍣ㄩ�昏緫澶勭悊 + if (atomicInteger.get() == list.size()) { + HdlDeviceLogic.getInstance().addAllInverterDeviceToCloud(homeId, list, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, null, callback); + } + + @Override + public void onFailure(HDLException e) { + //娣诲姞閫嗗彉鍣ㄥけ璐ュ悗鍒濆鍖栭�嗗彉鍣� + HdlLogLogic.print("娣诲姞閫嗗彉鍣ㄥけ璐ュ悗寮�濮嬪垵濮嬪寲閫嗗彉鍣�-->", true); + for (int i = 0; i < list.size(); i++) { + GatewayBean gatewayBean = list.get(i); + HdlDeviceLogic.getInstance().initializeInverter(gatewayBean.getDevice_mac(), new LinkCallBack<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + HdlLogLogic.print("鍒濆鍖栭�嗗彉鍣ㄦ垚鍔�-->mac:" + gatewayBean.getDevice_mac(), true); + } + + @Override + public void onError(HDLLinkException e) { + HdlLogLogic.print("鍒濆鍖栭�嗗彉鍣ㄥけ璐�-->mac:" + gatewayBean.getDevice_mac(), true); + } + }); + } + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + is_boolean[0] = true; + } + }); + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + is_boolean[0] = true; + } + }); + if (is_boolean[0]) { + //鍙湁涓棿鏈変竴鏉℃寚浠よ缃け璐�,榛樿鍏ㄩ儴澶辫触; + break; + } + } + } catch (Exception ignored) { + } } /** @@ -952,17 +2338,41 @@ * @param data uni鏁版嵁 * @param callback uni鍥炶皟 */ - private void uniDelInverterDevice(Object data, DCUniMPJSCallback callback) { + private void uniDelInverterDevice(String type, Object data, DCUniMPJSCallback callback) { String deviceId = getKeyValue("deviceId", getKeyValue("data", data)); - HdlDeviceLogic.getInstance().delInverterDevice(deviceId, new CloudCallBeak<Boolean>() { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + String mac = getKeyValue("mac", getKeyValue("data", data)); + HdlDeviceLogic.getInstance().delInverterDevice(homeId, deviceId, new CloudCallBeak<Boolean>() { @Override public void onSuccess(Boolean obj) { - uniCallbackData(null, callback); + //鍒濆鍖栭�嗗彉鍣ㄨ澶� + HdlDeviceLogic.getInstance().initializeInverter(mac, null); + //绉婚櫎鏈湴缂撳瓨 + HdlDeviceLogic.getInstance().removeLocalCacheMemoryGatewayToDeviceId(homeId, deviceId); + uniSuccessCallback(type, null, callback); } @Override public void onFailure(HDLException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + if (e.getCode() == 121005) { + //璁惧涓嶅瓨鍦紙121005锛夌姸鎬佺爜 + //鍒濆鍖栭�嗗彉鍣ㄨ澶� + HdlDeviceLogic.getInstance().initializeInverter(mac, new LinkCallBack<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + //绉婚櫎鏈湴缂撳瓨 + HdlDeviceLogic.getInstance().removeLocalCacheMemoryGatewayToDeviceId(homeId, deviceId); + uniSuccessCallback(type, null, callback); + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } else { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } } }); } @@ -973,17 +2383,20 @@ * * @param callback uni鍥炶皟 */ - private void uniSearchGateway(DCUniMPJSCallback callback) { - HdlDeviceLogic.getInstance().searchGateway(new GatewayCallBack() { + private void uniSearchGateway(String type, DCUniMPJSCallback callback) { + + + HdlDeviceLogic.getInstance().searchAllNetworkGateway(new GatewayCallBack() { @Override public void onSuccess(List<GatewayBean> gatewayBeanList) { - uniCallbackData(gatewayBeanList, callback); + uniSuccessCallback(type, gatewayBeanList, callback); } @Override public void onError(HDLLinkException e) { //鍙戦�佸け璐� - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } }); @@ -994,35 +2407,394 @@ * * @param callback uni鍥炶皟 */ - private void uniGetCurrentHomeLocalAndCloudGatewayList(DCUniMPJSCallback callback) { - HdlDeviceLogic.getInstance().getCurrentHomeLocalAndCloudGatewayList(new CloudCallBeak<List<GatewayBean>>() { + private void uniGetCurrentHomeLocalAndCloudGatewayList(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); +// UserConfigManage.getInstance().setHomeId(homeId); + HdlDeviceLogic.getInstance().getCurrentHomeLocalAndCloudGatewayList(homeId, new CloudCallBeak<List<GatewayBean>>() { @Override public void onSuccess(List<GatewayBean> list) { + List<GatewayBean> newList = sortLogic(list); if (callback != null) { - uniCallbackData(list, callback); - //EventBus浜嬩欢鍒嗗彂,杩涘叆浣忓畢寮�濮嬭闃呬富棰� - BaseEventBus baseEventBus = new BaseEventBus(); - baseEventBus.setType(HDLUniMP.UNI_EVENT_REPLY_DEVICE_LIST); - baseEventBus.setData(list); - EventBus.getDefault().post(baseEventBus); - GatewayBean gatewayBean = HdlDeviceLogic.getInstance().queryCurrentHomeMainGateway(list); - if (gatewayBean != null) { - //杩涙潵浣忓畢璇︽儏閮借涓婁紶涓�娆id鍒楄〃鍒颁簯绔�; - HdlDeviceLogic.getInstance().uploadDataToCloud(gatewayBean.getDevice_mac(), null); - } - - + uniSuccessCallback(type, newList, callback); } + //EventBus浜嬩欢鍒嗗彂,杩涘叆浣忓畢寮�濮嬭闃呬富棰� + BaseEventBus baseEventBus = new BaseEventBus(); + baseEventBus.setTopic(HDLUniMP.UNI_EVENT_REPLY_DEVICE_LIST); + baseEventBus.setType(HDLUniMP.UNI_EVENT_REPLY_DEVICE_LIST); + baseEventBus.setData(homeId); + EventBus.getDefault().post(baseEventBus); + //杩涙潵浣忓畢璇︽儏閮借涓婁紶涓�娆id鍒楄〃鍒颁簯绔�; + HdlDeviceLogic.getInstance().uploadOidDataToCloud(homeId, newList, false, null); } @Override public void onFailure(HDLException e) { if (callback != null) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); } } }); + } + + /** + * 杩涜鎺掑簭锛堥�嗗彉鍣�-璐熻浇涓績锛� + * + * @param list 婧愭暟鎹� + * @return 杩斿洖鍒楄〃 + */ + private List<GatewayBean> sortLogic(List<GatewayBean> list) { + if (list == null || list.size() == 0) { + return new ArrayList<>(); + } + List<GatewayBean> newList = new ArrayList<>(); + List<GatewayBean> inverterList = new ArrayList<>(); + List<GatewayBean> lcList = new ArrayList<>(); + for (int i = 0; i < list.size(); i++) { + if (list.get(i).getSpk().equals(HdlDeviceLogic.getInstance().INVERTER_DEVICE_SPK)) { + inverterList.add(list.get(i)); + } else { + lcList.add(list.get(i)); + } + } + newList.addAll(inverterList); + newList.addAll(lcList); + return newList; + } + + /** + * link spk 灞炴�х紪杈� + * + * @param data uni鏁版嵁 + * @param callback uni鍥炶皟 + */ + private void uniLinkSpkAttributeEdit(String type, Object data, DCUniMPJSCallback callback) { + String mac = getKeyValue("mac", getKeyValue("data", data)); + String attribute_data = getKeyValue("attribute_data", getKeyValue("data", data)); + JsonArray jay = new JsonArray(); + if (!TextUtils.isEmpty(attribute_data)) { + try { + Gson gson = new Gson(); + JsonObject jObject = gson.fromJson(attribute_data, JsonObject.class); + String objects = jObject.get("objects").toString(); + jay = gson.fromJson(objects, JsonArray.class); + } catch (Exception ignored) { + } + } + TcpClient.getInstance().sendDataToLinkGateway(mac, TopicApi.PROPERTY_DOWN, jay, "", new HDLLinkCallBack() { + @Override + public void onSuccess(String msg) { + uniSuccessCallback(type, msg, callback); + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * link spk 灞炴�ц鍙� + * + * @param data uni鏁版嵁 + * @param callback uni鍥炶皟 + */ + private void uniLinkSpkAttributeRead(String type, Object data, DCUniMPJSCallback callback) { + String mac = getKeyValue("mac", getKeyValue("data", data)); + String attribute_data = getKeyValue("attribute_data", getKeyValue("data", data)); + JsonArray jay = new JsonArray(); + if (!TextUtils.isEmpty(attribute_data)) { + try { + Gson gson = new Gson(); + JsonObject jObject = gson.fromJson(attribute_data, JsonObject.class); + String objects = jObject.get("objects").toString(); + jay = gson.fromJson(objects, JsonArray.class); + } catch (Exception ignored) { + } + + } + TcpClient.getInstance().sendDataToLinkGateway(mac, TopicApi.PROPERTY_READ, jay, "", new HDLLinkCallBack() { + @Override + public void onSuccess(String msg) { + try { + Gson gson = new Gson(); + Type typeOfT = new TypeToken<BaseLocalResponse<List<LinkBean>>>() { + }.getType(); + BaseLocalResponse<List<LinkBean>> baseLocalResponse = gson.fromJson(msg, typeOfT); + uniSuccessCallback(type, baseLocalResponse, callback); + } catch (Exception e) { + uniCallbackData(type, msg, -2, "", callback); + } + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + + /** + * 鍙戦�佽处鍙峰拰瀵嗙爜缁欓�嗗彉鍣� + * + * @param ssid 璐﹀彿 + * @param password 瀵嗙爜 + * @param callback uni鍥炶皟 + */ + public void startTcpThreadSendAccountAndPassword(String type, String ssid, String password, DCUniMPJSCallback callback) { + new Thread(() -> { + Socket socket = null; + OutputStream outputStreamTcp = null; + InputStream inputStreamTcp = null; + try { + socket = new Socket(); + socket.setTcpNoDelay(true); + socket.setSoTimeout(10 * 1000);//10绉掕秴鏃� + socket.connect(new InetSocketAddress("192.168.8.1", 8586)); + socket.setKeepAlive(true); +// logMessage("tcp杩炴帴鐘舵�佹垚鍔�", 0, ""); + outputStreamTcp = socket.getOutputStream(); + JsonObject jsonObject = new JsonObject(); + jsonObject.addProperty("id", "102030"); + jsonObject.addProperty("ssid", ssid); + jsonObject.addProperty("password", password); + jsonObject.addProperty("server_addr", HDLLinkPMUser.getInstance().getHomeRegionUrl()); + jsonObject.addProperty("homeId", UserConfigManage.getInstance().getHomeId()); + String sendData = "Topic:/user/id/custom/wifi/set\r\n"; + sendData += "Length:" + jsonObject.toString().getBytes().length + "\r\n\r\n"; + sendData += jsonObject.toString(); + outputStreamTcp.write(sendData.getBytes()); + outputStreamTcp.flush(); + Thread.sleep(200); + inputStreamTcp = socket.getInputStream(); + byte[] bytes = new byte[1204 * 2]; + int len = inputStreamTcp.read(bytes); + if (len != -1) { + String str = new String(bytes, 0, bytes.length); + String[] strings = str.split("\r\n\r\n"); + String[] topicAndLength = strings[0].split("\r\n"); + String topic = topicAndLength[0]; + JSONObject json = new JSONObject(strings[1]); +// logMessage("tcp鍥炲鏁版嵁", 0, strings[0] + "\r\n" + json.toString()); + if (topic.endsWith("wifi/set_reply") || topic.endsWith("wifi/result/notify")) { + if (callback != null) { + uniSuccessCallback(type, json, callback); + } + if (json.has("mac")) { //鍥炲鎴愬姛鍐嶆嬁璁惧mac +// this.device_mac = json.getString("mac"); +// this.isSucceedTcp = true;//琛ㄧず鎴愬姛 + } + } + } + + } catch (Exception ignored) { + } finally { + try { + if (outputStreamTcp != null) { + outputStreamTcp.close(); + outputStreamTcp = null; + } + if (inputStreamTcp != null) { + inputStreamTcp.close(); + inputStreamTcp = null; + } + if (socket != null) { + socket.close(); + socket = null; + } + + } catch (Exception ignored) { + } + } + }).start(); + } + + /** + * 鍒濆鍖栭�嗗彉鍣� + * + * @param type 绫诲瀷 + * @param data uni璇锋眰鏁版嵁 + * @param callback uni鍥炶皟 + */ + public void setInitializeGateway(String type, Object data, DCUniMPJSCallback callback) { + String mac = getKeyValue("mac", getKeyValue("data", data)); + HdlDeviceLogic.getInstance().initializeInverter(mac, new LinkCallBack<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 鍒濆鍖栭�嗗彉鍣� + * + * @param type 绫诲瀷 + * @param data uni璇锋眰鏁版嵁 + * @param callback uni鍥炶皟 + */ + public void setInverterDeviceRemoteInfo(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + String json = getKeyValue("list", getKeyValue("data", data)); + List<CloudInverterDeviceBean> newList = new ArrayList<>(); + try { + List<GatewayBean> list = new Gson().fromJson(json, new TypeToken<List<GatewayBean>>() { + }.getType()); + if (list != null && list.size() > 0) { + for (int i = 0; i < list.size(); i++) { + GatewayBean gatewayBean = list.get(i); + CloudInverterDeviceBean inverterDeviceBean = new CloudInverterDeviceBean(); + inverterDeviceBean.setCategorySecondName(gatewayBean.getCategorySecondName()); + inverterDeviceBean.setOsn(gatewayBean.getDevice_mac()); + inverterDeviceBean.setOmodel(gatewayBean.getDevice_model()); + inverterDeviceBean.setOid(gatewayBean.getOid()); + inverterDeviceBean.setAddresses(gatewayBean.getAddresses()); + inverterDeviceBean.setSid(gatewayBean.getSid()); + inverterDeviceBean.setDeviceId(gatewayBean.getDeviceId()); + inverterDeviceBean.setName(gatewayBean.getDevice_name()); + inverterDeviceBean.setDeviceStatus(gatewayBean.getDeviceStatus()); + inverterDeviceBean.setSpk(gatewayBean.getSpk()); + inverterDeviceBean.setDeviceType(gatewayBean.getDeviceType()); + newList.add(inverterDeviceBean); + } + } + } catch (Exception ignored) { + } + HdlDeviceLogic.getInstance().setDeviceRemoteInfo(newList, homeId, new CloudCallBeak<List<GatewayBean>>() { + @Override + public void onSuccess(List<GatewayBean> obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 淇敼璁惧鍚嶇О閫嗗彉鍣˙MS鐢垫睜鍖� + * + * @param type 绫诲瀷 + * @param data uni璇锋眰鏁版嵁 + * @param callback uni鍥炶皟 + */ + public void uniOidEditName(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + String deviceType = getKeyValue("deviceType", getKeyValue("data", data)); + String deviceId = getKeyValue("deviceId", getKeyValue("data", data)); + String name = getKeyValue("name", getKeyValue("data", data)); + HdlDeviceLogic.getInstance().setRename(homeId, deviceType, deviceId, name, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 鑾峰彇鏈繍琛岄�嗗彉鍣ㄥ垪琛� + * + * @param type 绫诲瀷 + * @param data uni璇锋眰鏁版嵁 + * @param callback uni鍥炶皟 + */ + public void uniGetListNotRun(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + HdlDeviceLogic.getInstance().getListNotRun(homeId, new CloudCallBeak<List<NotRunBean>>() { + @Override + public void onSuccess(List<NotRunBean> obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 閫嗗彉鍣ㄥ紑鏈� + * + * @param type 绫诲瀷 + * @param data uni璇锋眰鏁版嵁 + * @param callback uni鍥炶皟 + */ + public void uniSetDeviceStartup(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + String aryJson = getKeyValue("deviceIds", getKeyValue("data", data)); + JsonArray jsonArray = new Gson().fromJson(aryJson, JsonArray.class); + HdlDeviceLogic.getInstance().setDeviceStartup(homeId, jsonArray, new CloudCallBeak<Boolean>() { + @Override + public void onSuccess(Boolean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 鑾峰彇璁惧璇︽儏锛堜簯绔級 + * + * @param type 绫诲瀷 + * @param data uni璇锋眰鏁版嵁 + * @param callback uni鍥炶皟 + */ + public void uniGetDeviceInfo(String type, Object data, DCUniMPJSCallback callback) { + String homeId = getKeyValue("homeId", getKeyValue("data", data)); + String aryJson = getKeyValue("deviceIds", getKeyValue("data", data)); + JsonArray jsonArray = new Gson().fromJson(aryJson, JsonArray.class); + HdlDeviceLogic.getInstance().getDeviceInfo(homeId, jsonArray, new CloudCallBeak<List<DeviceInfoBean>>() { + @Override + public void onSuccess(List<DeviceInfoBean> list) { + uniSuccessCallback(type, list, callback); + } + + @Override + public void onFailure(HDLException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); + } + + /** + * 鑾峰彇閫嗗彉鍣ㄨ鎯� + * + * @param type 绫诲瀷 + * @param data uni璇锋眰鏁版嵁 + * @param callback uni鍥炶皟 + */ + public void uniGetGatewayInfo(String type, Object data, DCUniMPJSCallback callback) { + String mac = getKeyValue("mac", getKeyValue("data", data)); + HdlDeviceLogic.getInstance().getGatewayInfo(mac, new LinkCallBack<InverterBean>() { + @Override + public void onSuccess(InverterBean obj) { + uniSuccessCallback(type, obj, callback); + } + + @Override + public void onError(HDLLinkException e) { + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); + } + }); } @@ -1040,10 +2812,11 @@ * @param data modbus鏁版嵁 * @param callback 鍥炶皟 */ - private void sendModBus(Object data, DCUniMPJSCallback callback) { + private void sendModBus(String type, Object data, DCUniMPJSCallback callback) { String tempData = getKeyValue("data", data); if (TextUtils.isEmpty(tempData)) { - HdlLogLogic.print("data鍐呭涓虹┖", false); + uniCallbackData(type, null, -2, "data鍐呭涓虹┖", callback); + //HdlLogLogic.print("data鍐呭涓虹┖---", false); return; } ModBusBean modBusBean = new Gson().fromJson(tempData, ModBusBean.class); @@ -1054,22 +2827,27 @@ // modBusBean.setOid("0101050217BBC400"); // } if (modBusBean.getMac() == null || modBusBean.getData() == null) { - HdlLogLogic.print("鍐呭涓虹┖===oid=" + modBusBean.getMac() + " data=" + Arrays.toString(modBusBean.getData()), false); + uniCallbackData(type, null, -2, "鍙戦�佸け璐�,(mac鎴栬�卭id)涓虹┖", callback); + //HdlLogLogic.print("uni---鍙戦��---ModBus---鍙戦�佸け璐�,(mac鎴栬�卭id)涓虹┖." + Arrays.toString(modBusBean.getData()), true); return; } - + //HdlLogLogic.print("uni---鍙戦��---ModBus---" + Arrays.toString(modBusBean.getData()), true); //鍙戦�乵odbus鍗忚 - HDLModBusConnect.getInstance().Send(modBusBean.getMac(), modBusBean.getData(), new ModbusCallBack() { + long startTime = System.currentTimeMillis(); + HDLModBusConnect.getInstance().asyncSend(modBusBean.getMac(), modBusBean.getData(), new ModbusCallBack() { @Override public void onSuccess(int[] data) { - Log.d("data", Arrays.toString(data)); - uniCallbackData(data, callback); + uniSuccessCallback(type, data, callback); +// HdlLogLogic.print("uni---鎺ユ敹---ModBus---" + Arrays.toString(data), true); + long endTime = System.currentTimeMillis() - startTime; + Log.d("====Mobus鑰楁椂鏃堕棿====", String.valueOf(endTime)); } @Override public void onError(HDLLinkException e) { - uniCallbackData(null, e.getCode(), e.getMsg(), callback); + uniCallbackData(type, null, e.getCode(), e.getMsg(), callback); +// HdlLogLogic.print("uni---鎺ユ敹---ModBus---" + e.getMsg() + "(" + e.getCode() + ")", true); } }); } @@ -1091,56 +2869,67 @@ if (data == null) { data = new JSONObject(); } - if (isTokenAndRefreshToken) { - data.put("token", UserConfigManage.getInstance().getToken()); - data.put("refreshToken", UserConfigManage.getInstance().getRefreshToken()); - } +// if (isTokenAndRefreshToken) { +// //灏忕▼搴忛偅閲屾湁鑷繁鐨勮姹傛柟娉�,浣嗛渶瑕佸師鐢熸彁渚涜繖浜涙暟鎹� +// data.put("token", HDLLinkPMUser.getInstance().getAccessToken()); +// data.put("refreshToken", HDLLinkPMUser.getInstance().getRefreshToken()); +// if (TextUtils.isEmpty(AppConfigManage.getUserRegionUrl())) { +// AppConfigManage.setUserRegionUrl(HDLLinkPMUser.getInstance().getUserRegionUrl()); +// } +// data.put("serverAddress", AppConfigManage.getUserRegionUrl()); +// data.put("appKey", AppConfigManage.getAppKey()); +// data.put("appSecret", AppConfigManage.getAppSecret()); +// } + data.put("appLanguage", UserConfigManage.getInstance().getCurrentAppLanguage()); uniCallBackBaseBean.setData(data); return getJSONObject(uniCallBackBaseBean); } catch (Exception e) { - HdlLogLogic.print("uni===缁勮uni鍙戦�佹暟鎹牸寮�===" + e.getMessage(), false); + HdlLogLogic.print("uni---缁勮鍙戦�佺粰uni鏁版嵁鏍煎紡鏈夊紓甯�---" + e.getMessage(), false); } return new JSONObject(); } + private void uniSuccessCallback(String type, Object obj, DCUniMPJSCallback callback) { + uniCallbackData(type, obj, HDLLinkCode.HDL_SUCCESS.getCode(), HDLLinkCode.HDL_SUCCESS.getMsg(), callback); + } + + private void uniExceptionCallback(String type, HDLException hdlException, DCUniMPJSCallback callback) { + uniCallbackData(type, null, hdlException.getCode(), hdlException.getMsg(), callback); + } /** * 缁勮uni鍙戦�佹暟鎹牸寮� * 鍥炶皟鏁版嵁缁檜ni灏忕▼搴�,缁熶竴鍦ㄨ繖閲屽鐞�; * + * @param type 璇锋眰鐨勫皬绫� * @param obj 闄勫姞鏁版嵁 * @param code 鐘舵�佺爜-鎴愬姛锛�0锛夋垨鑰呭け璐ワ紙-2锛� * @param msg 缁撴灉鎻忚堪鐨勪俊鎭� * @param callback 鍥炶皟 */ - private void uniCallbackData(Object obj, int code, String msg, DCUniMPJSCallback callback) { + private void uniCallbackData(String type, Object obj, int code, String msg, DCUniMPJSCallback callback) { HDLUniMP.UniCallBackBaseBean uniCallBackBaseBean = new HDLUniMP.UniCallBackBaseBean(); try { uniCallBackBaseBean.setCode(code); - uniCallBackBaseBean.setMes(msg); + uniCallBackBaseBean.setMsg(msg); uniCallBackBaseBean.setData(obj); if (callback != null) { callback.invoke(getJSONObject(uniCallBackBaseBean)); -// callback.invoke(uniCallBackBaseBean); - + HdlLogLogic.print("鍥炲---uni---" + type + "---" + getJSONObject(uniCallBackBaseBean).toString(), true); } } catch (Exception e) { - HdlLogLogic.print("uni===缁勮uni鍙戦�佹暟鎹牸寮�===" + e.getMessage(), false); + HdlLogLogic.print("鍥炲---uni---" + type + "---" + e.getMessage(), true); } - } - private void uniCallbackData(Object obj, DCUniMPJSCallback callback) { - uniCallbackData(obj, HDLLinkCode.HDL_SUCCESS.getCode(), HDLLinkCode.HDL_SUCCESS.getMsg(), callback); - } /** * 褰撳墠瀵硅薄杞� JSONObject * * @return JSONObject */ - private JSONObject getJSONObject(Object obj) { + public JSONObject getJSONObject(Object obj) { try { if (obj == null) { return new JSONObject(); @@ -1169,7 +2958,7 @@ * @param obj - * @return value */ - private String getKeyValue(String key, Object obj) { + public String getKeyValue(String key, Object obj) { try { JSONObject jsonObject = this.getJSONObject(obj); if (jsonObject.has(key)) { -- Gitblit v1.8.0