~wxr/HdlToLc.git

package com.common.openapi; 
 
import android.os.Message; 
 
import com.common.openapi.entity.DeviceAlarmStatusData; 
import com.common.openapi.entity.DeviceChannelInfoData; 
import com.common.openapi.entity.DeviceModifyNameData; 
import com.common.openapi.entity.DeviceUnBindData; 
import com.common.openapi.entity.DeviceVersionListData; 
import com.mm.android.deviceaddmodule.device_wifi.CurWifiInfo; 
import com.mm.android.deviceaddmodule.mobilecommon.AppConsume.BusinessException; 
import com.mm.android.deviceaddmodule.mobilecommon.AppConsume.BusinessRunnable; 
import com.mm.android.deviceaddmodule.mobilecommon.base.LCBusinessHandler; 
import com.mm.android.deviceaddmodule.mobilecommon.businesstip.BusinessErrorTip; 
import com.mm.android.deviceaddmodule.mobilecommon.businesstip.HandleMessageCode; 
import com.mm.android.deviceaddmodule.openapi.DeviceAddOpenApiManager; 
 
public class DeviceDetailService { 
 
 
    /** 
     * 获取设备版本和可升级信息 
     * 
     * @param deviceVersionListData 
     * @param deviceVersionCallBack 
     */ 
    public void deviceVersionList(final DeviceVersionListData deviceVersionListData, final IGetDeviceInfoCallBack.IDeviceVersionCallBack deviceVersionCallBack) { 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (deviceVersionCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    deviceVersionCallBack.deviceVersion((DeviceVersionListData.Response) msg.obj); 
                } else { 
                    //失败 
                    deviceVersionCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    DeviceVersionListData.Response response = DeviceInfoOpenApiManager.deviceVersionList(deviceVersionListData); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, response).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
    /** 
     * 修改设备或通道名称 
     * 
     * @param deviceModifyNameData 
     * @param modifyDeviceCallBack 
     */ 
    public void modifyDeviceName(final DeviceModifyNameData deviceModifyNameData, final IGetDeviceInfoCallBack.IModifyDeviceCallBack modifyDeviceCallBack) { 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (modifyDeviceCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    modifyDeviceCallBack.deviceModify((boolean) msg.obj); 
                } else { 
                    //失败 
                    modifyDeviceCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    boolean b = DeviceInfoOpenApiManager.modifyDeviceName(deviceModifyNameData); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, b).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
    /** 
     * 解绑设备 
     * 
     * @param deviceUnBindData 
     * @param unbindDeviceCallBack 
     */ 
    public void unBindDevice(final DeviceUnBindData deviceUnBindData, final IGetDeviceInfoCallBack.IUnbindDeviceCallBack unbindDeviceCallBack) { 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (unbindDeviceCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    unbindDeviceCallBack.unBindDevice((boolean) msg.obj); 
                } else { 
                    //失败 
                    unbindDeviceCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    boolean b = DeviceInfoOpenApiManager.unBindDevice(deviceUnBindData); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, b).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
    public void deletePermission(final String deviceId, final String channelId, final IGetDeviceInfoCallBack.IUnbindDeviceCallBack unbindDeviceCallBack){ 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (unbindDeviceCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    unbindDeviceCallBack.unBindDevice((boolean) msg.obj); 
                } else { 
                    //失败 
                    unbindDeviceCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    boolean b = DeviceInfoOpenApiManager.deletePermission(deviceId,channelId); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, b).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
    /** 
     * 单个设备通道的详细信息获取 
     * 
     * @param deviceChannelInfoData 
     * @param deviceChannelInfoCallBack 
     */ 
    public void bindDeviceChannelInfo(final DeviceChannelInfoData deviceChannelInfoData, final IGetDeviceInfoCallBack.IDeviceChannelInfoCallBack deviceChannelInfoCallBack) { 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (deviceChannelInfoCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    deviceChannelInfoCallBack.deviceChannelInfo((DeviceChannelInfoData.Response) msg.obj); 
                } else { 
                    //失败 
                    deviceChannelInfoCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    DeviceChannelInfoData.Response response = DeviceInfoOpenApiManager.bindDeviceChannelInfo(deviceChannelInfoData); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, response).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
    /** 
     * 设置动检开关 
     * 
     * @param deviceAlarmStatusData 
     * @param deviceAlarmStatusCallBack 
     */ 
    public void modifyDeviceAlarmStatus(final DeviceAlarmStatusData deviceAlarmStatusData, final IGetDeviceInfoCallBack.IDeviceAlarmStatusCallBack deviceAlarmStatusCallBack) { 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (deviceAlarmStatusCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    deviceAlarmStatusCallBack.deviceAlarmStatus((boolean) msg.obj); 
                } else { 
                    //失败 
                    deviceAlarmStatusCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    boolean b = DeviceInfoOpenApiManager.modifyDeviceAlarmStatus(deviceAlarmStatusData); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, b).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
    /** 
     * 设备升级 
     * 
     * @param deviceId 
     * @param deviceUpdateCallBack 
     */ 
    public void upgradeDevice(final String deviceId, final IGetDeviceInfoCallBack.IDeviceUpdateCallBack deviceUpdateCallBack) { 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (deviceUpdateCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    deviceUpdateCallBack.deviceUpdate((boolean) msg.obj); 
                } else { 
                    //失败 
                    deviceUpdateCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    boolean b = DeviceInfoOpenApiManager.upgradeDevice(deviceId); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, b).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
    /** 
     * 设备当前连接热点信息 
     * 
     * @param deviceId 
     * @param deviceCurrentWifiInfoCallBack 
     */ 
    public void currentDeviceWifi(final String deviceId, final IGetDeviceInfoCallBack.IDeviceCurrentWifiInfoCallBack deviceCurrentWifiInfoCallBack) { 
        final LCBusinessHandler handler = new LCBusinessHandler() { 
            @Override 
            public void handleBusiness(Message msg) { 
                if (deviceCurrentWifiInfoCallBack == null) { 
                    return; 
                } 
                if (msg.what == HandleMessageCode.HMC_SUCCESS) { 
                    //成功 
                    deviceCurrentWifiInfoCallBack.deviceCurrentWifiInfo((CurWifiInfo) msg.obj); 
                } else { 
                    //失败 
                    deviceCurrentWifiInfoCallBack.onError(BusinessErrorTip.throwError(msg)); 
                } 
            } 
        }; 
        new BusinessRunnable(handler) { 
            @Override 
            public void doBusiness() throws BusinessException { 
                try { 
                    CurWifiInfo curWifiInfo = DeviceAddOpenApiManager.currentDeviceWifi(deviceId); 
                    handler.obtainMessage(HandleMessageCode.HMC_SUCCESS, curWifiInfo).sendToTarget(); 
                } catch (BusinessException e) { 
                    throw e; 
                } 
            } 
        }; 
    } 
 
}