fis_lib_jsonrpc/lib/services/device.dart

import 'dart:core';

import 'package:fis_jsonrpc/client_base.dart';
import 'package:fis_common/json_convert.dart';

import 'device.m.dart';

import 'notification.m.dart';
import 'liveConsultation.m.dart';


class DeviceService extends JsonRpcClientBase {
	DeviceService(
		String host, {
		String serviceName = "IDeviceService",
		Map<String, String>? headers,
		int? timeout,
	}) : super(
						host,
						serviceName,
						headers: headers,
						timeout: timeout,
				) {
		/// 注册响应实体反序列化处理器
		FJsonConvert.setDecoder((map) => DevicePrinterParameterDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<DeviceExtendInfoDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => DeviceExtendInfoDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<SelectItemDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => SelectItemDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => DeviceInfoDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<DeviceInfoDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => DictionaryDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => DeviceServerSettingResult.fromJson(map));
		FJsonConvert.setDecoder((map) => DiagnosisModuleDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ReportVideoDeviceInfoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => JoinDeviceLiveRoomResult.fromJson(map));
		FJsonConvert.setDecoder((map) => CreateLiveShareInfoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => JoinDeviceLiveRoomByShareResult.fromJson(map));
		FJsonConvert.setDecoder((map) => CreateLiveRoomInfoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => DeviceControlParameterDataDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => BrandModelOutputConfigDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<DevicePatchDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => DevicePatchDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => DevicePatchVersionDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => DevicePrinterVersionDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<DevicePrinterDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => DevicePrinterDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => DeviceConnectStateResult.fromJson(map));
		FJsonConvert.setDecoder((map) => ProbeApplicationSettingInfoDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => RemoteConnectsRequest.fromJson(map));
	}

	Future<List<DevicePrinterParameterDTO>> getDevicePrintersForUploadAsync(GetDevicePrintersForUploadRequest request) async {
		var rpcRst = await call("GetDevicePrintersForUploadAsync", request);
		var result = (rpcRst as List).map((e)=>DevicePrinterParameterDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<String>> getDevicePatchTypeListAsync(TokenRequest request) async {
		var rpcRst = await call("GetDevicePatchTypeListAsync", request);
		var result = (rpcRst as List).cast<String>().toList();
		return result;
	}

	Future<bool> existsDevicePrinterAsync(ExistsDevicePrinterRequest request) async {
		var rpcRst = await call("ExistsDevicePrinterAsync", request);
		return rpcRst;
	}

	Future<bool> batchInsertDevicePrintersDataAsync(MigrateDevicePrinterRequest request) async {
		var rpcRst = await call("BatchInsertDevicePrintersDataAsync", request);
		return rpcRst;
	}

	Future<bool> batchInsertDevicePatchsDataAsync(MigrateDevicePatchRequest request) async {
		var rpcRst = await call("BatchInsertDevicePatchsDataAsync", request);
		return rpcRst;
	}

	Future<PageCollection<DeviceExtendInfoDTO>> getOrganizationDeviceListAsync(GetPersonDeviceRequest request) async {
		var rpcRst = await call("GetOrganizationDeviceListAsync", request);
		var result = PageCollection<DeviceExtendInfoDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageCollection<SelectItemDTO>> getPersonDeviceDropdownPageAsync(GetPersonDeviceDropdownPageRequest request) async {
		var rpcRst = await call("GetPersonDeviceDropdownPageAsync", request);
		var result = PageCollection<SelectItemDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> heartRateAsync(TokenRequest request) async {
		var rpcRst = await call("HeartRateAsync", request);
		return rpcRst;
	}

	Future<DeviceInfoDTO> createDeviceInfoAsync(CreateDeviceRequest request) async {
		var rpcRst = await call("CreateDeviceInfoAsync", request);
		var result = DeviceInfoDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<DeviceExtendInfoDTO> getDeviceInfoAsync(GetDeviceRequest request) async {
		var rpcRst = await call("GetDeviceInfoAsync", request);
		var result = DeviceExtendInfoDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<DeviceExtendInfoDTO> getDeviceByShortCodeAsync(GetDeviceByShortCodeRequest request) async {
		var rpcRst = await call("GetDeviceByShortCodeAsync", request);
		var result = DeviceExtendInfoDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageCollection<DeviceInfoDTO>> getDeviceInfoPageAsync(PageFilterRequest request) async {
		var rpcRst = await call("GetDeviceInfoPageAsync", request);
		var result = PageCollection<DeviceInfoDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> bindDeviceAsync(BindDeviceRequest request) async {
		var rpcRst = await call("BindDeviceAsync", request);
		return rpcRst;
	}

	Future<bool> modifyDeviceAsync(ModifyDeviceRequest request) async {
		var rpcRst = await call("ModifyDeviceAsync", request);
		return rpcRst;
	}

	Future<String> createDictionaryItemAsync(CreateDictionaryItemRequest request) async {
		var rpcRst = await call("CreateDictionaryItemAsync", request);
		return rpcRst;
	}

	Future<List<DictionaryDTO>> findDeviceModelItemsAsync(FindDeviceModelItemsRequest request) async {
		var rpcRst = await call("FindDeviceModelItemsAsync", request);
		var result = (rpcRst as List).map((e)=>DictionaryDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<DictionaryDTO>> findDeviceTypeItemsAsync(FindDeviceTypeItemsRequest request) async {
		var rpcRst = await call("FindDeviceTypeItemsAsync", request);
		var result = (rpcRst as List).map((e)=>DictionaryDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> createShareDeviceToUserAsync(CreateShareDeviceToUserRequest request) async {
		var rpcRst = await call("CreateShareDeviceToUserAsync", request);
		return rpcRst;
	}

	Future<bool> deleteShareDeviceToUserAsync(DeleteShareDeviceToUserRequest request) async {
		var rpcRst = await call("DeleteShareDeviceToUserAsync", request);
		return rpcRst;
	}

	Future<bool> removeDeviceRelevancyAsync(RemoveDeviceRelevancyRequest request) async {
		var rpcRst = await call("RemoveDeviceRelevancyAsync", request);
		return rpcRst;
	}

	Future<PageCollection<DeviceExtendInfoDTO>> getPersonDeviceListAsync(GetPersonDeviceRequest request) async {
		var rpcRst = await call("GetPersonDeviceListAsync", request);
		var result = PageCollection<DeviceExtendInfoDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageCollection<DeviceInfoDTO>> getDeviceListByPersonRoleAsync(GetPersonRoleDeviceRequest request) async {
		var rpcRst = await call("GetDeviceListByPersonRoleAsync", request);
		var result = PageCollection<DeviceInfoDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<DeviceExtendInfoDTO>> findDevicesByOrganizationCodeAsync(FindDevicesByOrganizationCodeRequest request) async {
		var rpcRst = await call("FindDevicesByOrganizationCodeAsync", request);
		var result = (rpcRst as List).map((e)=>DeviceExtendInfoDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<SelectItemDTO>> getPersonDeviceDropdownListAsync(TokenRequest request) async {
		var rpcRst = await call("GetPersonDeviceDropdownListAsync", request);
		var result = (rpcRst as List).map((e)=>SelectItemDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<DeviceServerSettingResult> queryServerConfigAsync(TokenRequest request) async {
		var rpcRst = await call("QueryServerConfigAsync", request);
		var result = DeviceServerSettingResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> addDeviceToOrgAsync(AddDeviceToOrgRequest request) async {
		var rpcRst = await call("AddDeviceToOrgAsync", request);
		return rpcRst;
	}

	Future<List<String>> getDeviceBindUsersCodesAsync(GetDeviceRequest request) async {
		var rpcRst = await call("GetDeviceBindUsersCodesAsync", request);
		var result = (rpcRst as List).cast<String>().toList();
		return result;
	}

	Future<List<DiagnosisModuleDTO>> findDeviceDiagnosisModulesAsync(FindDeviceDiagnosisModulesRequest request) async {
		var rpcRst = await call("FindDeviceDiagnosisModulesAsync", request);
		var result = (rpcRst as List).map((e)=>DiagnosisModuleDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> modifyDeviceDiagnosisModuleStateAsync(ModifyDeviceDiagnosisModuleStateRequest request) async {
		var rpcRst = await call("ModifyDeviceDiagnosisModuleStateAsync", request);
		return rpcRst;
	}

	Future<ReportVideoDeviceInfoResult> reportVideoDeviceInfoAsync(ReportVideoDeviceInfoRequest request) async {
		var rpcRst = await call("ReportVideoDeviceInfoAsync", request);
		var result = ReportVideoDeviceInfoResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<int> getActiveDeviceCount() async {
		var rpcRst = await call("GetActiveDeviceCount", );
		return rpcRst;
	}

	Future<bool> sendControlParameterByDeviceAsync(SendControlParameterByDeviceRequest request) async {
		var rpcRst = await call("SendControlParameterByDeviceAsync", request);
		return rpcRst;
	}

	Future<JoinDeviceLiveRoomResult> joinDeviceLiveRoomAsync(JoinDeviceLiveRoomRequest request) async {
		var rpcRst = await call("JoinDeviceLiveRoomAsync", request);
		var result = JoinDeviceLiveRoomResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> leaveDeviceLiveRoomAsync(LeaveDeviceLiveRoomRequest request) async {
		var rpcRst = await call("LeaveDeviceLiveRoomAsync", request);
		return rpcRst;
	}

	Future<bool> reportLiveViewStateAsync(ReportLiveViewStateRequest request) async {
		var rpcRst = await call("ReportLiveViewStateAsync", request);
		return rpcRst;
	}

	Future<CreateLiveShareInfoResult> createLiveShareInfoAsync(CreateLiveShareInfoRequest request) async {
		var rpcRst = await call("CreateLiveShareInfoAsync", request);
		var result = CreateLiveShareInfoResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<JoinDeviceLiveRoomByShareResult> joinDeviceLiveRoomByShareAsync(JoinDeviceLiveRoomByShareRequest request) async {
		var rpcRst = await call("JoinDeviceLiveRoomByShareAsync", request);
		var result = JoinDeviceLiveRoomByShareResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> leaveDeviceLiveRoomByShareAsync(LeaveDeviceLiveRoomByShareRequest request) async {
		var rpcRst = await call("LeaveDeviceLiveRoomByShareAsync", request);
		return rpcRst;
	}

	Future<bool> reportLiveViewStateByShareAsync(ReportLiveViewStateByShareRequest request) async {
		var rpcRst = await call("ReportLiveViewStateByShareAsync", request);
		return rpcRst;
	}

	Future<bool> reportLiveStateAsync(ReportLiveStateRequest request) async {
		var rpcRst = await call("ReportLiveStateAsync", request);
		return rpcRst;
	}

	Future<CreateLiveRoomInfoResult> createLiveRoomInfoAsync(CreateLiveRoomInfoRequest request) async {
		var rpcRst = await call("CreateLiveRoomInfoAsync", request);
		var result = CreateLiveRoomInfoResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> uploadConsultationDataAsync(UploadConsultationDataRequest request) async {
		var rpcRst = await call("UploadConsultationDataAsync", request);
		return rpcRst;
	}

	Future<DeviceControlParameterDataDTO> getControlParametersAsync(GetControlParametersRequest request) async {
		var rpcRst = await call("GetControlParametersAsync", request);
		var result = DeviceControlParameterDataDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> applyRemoteConnectionAsync(ControlDeviceConnectRequest request) async {
		var rpcRst = await call("ApplyRemoteConnectionAsync", request);
		return rpcRst;
	}

	Future<bool> acceptRemoteConnnectionAsync(ControlDeviceResponseRequest request) async {
		var rpcRst = await call("AcceptRemoteConnnectionAsync", request);
		return rpcRst;
	}

	Future<bool> applyRemoteControlAsync(ControlDeviceParameterRequest request) async {
		var rpcRst = await call("ApplyRemoteControlAsync", request);
		return rpcRst;
	}

	Future<bool> getRemoteLogAsync(GetRemoteLogRequest request) async {
		var rpcRst = await call("GetRemoteLogAsync", request);
		return rpcRst;
	}

	Future<bool> responseRemoteLogAsync(RemoteLogResponseRequest request) async {
		var rpcRst = await call("ResponseRemoteLogAsync", request);
		return rpcRst;
	}

	Future<bool> scanBindDeviceAsync(ScanBindDeviceRequest request) async {
		var rpcRst = await call("ScanBindDeviceAsync", request);
		return rpcRst;
	}

	Future<bool> reportBrandModelOutputConfigAsync(ReportBrandModelOutputConfigRequest request) async {
		var rpcRst = await call("ReportBrandModelOutputConfigAsync", request);
		return rpcRst;
	}

	Future<List<BrandModelOutputConfigDTO>> syncBrandModelOutputConfigAsync(SyncBrandModelOutputConfigRequest request) async {
		var rpcRst = await call("SyncBrandModelOutputConfigAsync", request);
		var result = (rpcRst as List).map((e)=>BrandModelOutputConfigDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<String>> getBrandsAsync(GetBrandsRequest request) async {
		var rpcRst = await call("GetBrandsAsync", request);
		var result = (rpcRst as List).cast<String>().toList();
		return result;
	}

	Future<List<String>> getModelsAsync(GetModelsRequest request) async {
		var rpcRst = await call("GetModelsAsync", request);
		var result = (rpcRst as List).cast<String>().toList();
		return result;
	}

	Future<bool> addDevicePatchAsync(AddDevicePatchRequest request) async {
		var rpcRst = await call("AddDevicePatchAsync", request);
		return rpcRst;
	}

	Future<PageResult<DevicePatchDTO>> findDevicePatchPagesAsync(FindDevicePatchPageRequest request) async {
		var rpcRst = await call("FindDevicePatchPagesAsync", request);
		var result = PageResult<DevicePatchDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> deletePatchByCodeAsync(DeleteDevicePatchByCodeRequest request) async {
		var rpcRst = await call("DeletePatchByCodeAsync", request);
		return rpcRst;
	}

	Future<bool> updateDevicePatchAsync(UpdateDevicePatchRequest request) async {
		var rpcRst = await call("UpdateDevicePatchAsync", request);
		return rpcRst;
	}

	Future<bool> pushDevicePatchAsync(PushDevicePatchRequest request) async {
		var rpcRst = await call("PushDevicePatchAsync", request);
		return rpcRst;
	}

	Future<PageResult<DevicePatchDTO>> findPushDevicePatchPagesAsync(FindPushDevicePatchPageRequest request) async {
		var rpcRst = await call("FindPushDevicePatchPagesAsync", request);
		var result = PageResult<DevicePatchDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> uploadDeviceDownloadPatchProgressToUserAsync(UploadDeviceDownloadPatchProgressToUserRequest request) async {
		var rpcRst = await call("UploadDeviceDownloadPatchProgressToUserAsync", request);
		return rpcRst;
	}

	Future<bool> addDevicePatchVersionAsync(AddDevicePatchVersionRequest request) async {
		var rpcRst = await call("AddDevicePatchVersionAsync", request);
		return rpcRst;
	}

	Future<List<DevicePatchVersionDTO>> findDevicePatchVersionListAsync(FindDevicePatchListRequest request) async {
		var rpcRst = await call("FindDevicePatchVersionListAsync", request);
		var result = (rpcRst as List).map((e)=>DevicePatchVersionDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> deleteDevicePatchVersionAsync(DeleteDevicePatchVersionRequest request) async {
		var rpcRst = await call("DeleteDevicePatchVersionAsync", request);
		return rpcRst;
	}

	Future<bool> addDevicePrinterVersionAsync(AddDevicePrinterVersionRequest request) async {
		var rpcRst = await call("AddDevicePrinterVersionAsync", request);
		return rpcRst;
	}

	Future<List<DevicePrinterVersionDTO>> findDevicePrinterVersionListAsync(FindDevicePrinterVersionListRequest request) async {
		var rpcRst = await call("FindDevicePrinterVersionListAsync", request);
		var result = (rpcRst as List).map((e)=>DevicePrinterVersionDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> deleteDevicePrinterVersionAsync(DeleteDevicePrinterVersionRequest request) async {
		var rpcRst = await call("DeleteDevicePrinterVersionAsync", request);
		return rpcRst;
	}

	Future<bool> addDevicePrinterAsync(AddDevicePrinterRequest request) async {
		var rpcRst = await call("AddDevicePrinterAsync", request);
		return rpcRst;
	}

	Future<PageResult<DevicePrinterDTO>> findDevicePrinterPagesAsync(FindDevicePrinterPageRequest request) async {
		var rpcRst = await call("FindDevicePrinterPagesAsync", request);
		var result = PageResult<DevicePrinterDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> deletePrinterByCodeAsync(DeleteDevicePrinterByCodeRequest request) async {
		var rpcRst = await call("DeletePrinterByCodeAsync", request);
		return rpcRst;
	}

	Future<bool> updateDevicePrinterAsync(UpdateDevicePrinterRequest request) async {
		var rpcRst = await call("UpdateDevicePrinterAsync", request);
		return rpcRst;
	}

	Future<bool> setDevicePrinterAsync(SetDevicePrinterRequest request) async {
		var rpcRst = await call("SetDevicePrinterAsync", request);
		return rpcRst;
	}

	Future<bool> uploadDevicePrinterAsync(UploadDevicePrinterRequest request) async {
		var rpcRst = await call("UploadDevicePrinterAsync", request);
		return rpcRst;
	}

	Future<bool> restartDeviceAsync(RestartDeviceRequest request) async {
		var rpcRst = await call("RestartDeviceAsync", request);
		return rpcRst;
	}

	Future<bool> modifyEmergencyDeviceCodeAsync(ModifyEmergencyDeviceCodeRequest request) async {
		var rpcRst = await call("ModifyEmergencyDeviceCodeAsync", request);
		return rpcRst;
	}

	Future<String> sendCommandToDeviceAsync(SendCommandToDeviceRequest request) async {
		var rpcRst = await call("SendCommandToDeviceAsync", request);
		return rpcRst;
	}

	Future<String> sendResultToClientAsync(SendResultToClientRequest request) async {
		var rpcRst = await call("SendResultToClientAsync", request);
		return rpcRst;
	}

	Future<String> getResultFromServerAsync(GetResultFromServerRequest request) async {
		var rpcRst = await call("GetResultFromServerAsync", request);
		return rpcRst;
	}

	Future<bool> disconnectRemoteControl(RemoteConnectStautsRequest request) async {
		var rpcRst = await call("DisconnectRemoteControl", request);
		return rpcRst;
	}

	Future<bool> remoteConnectHeartRateAsync(RemoteConnectHeartRateRequest request) async {
		var rpcRst = await call("RemoteConnectHeartRateAsync", request);
		return rpcRst;
	}

	Future<bool> checkDeviceIsIdleAsync(GetDeviceRequest request) async {
		var rpcRst = await call("CheckDeviceIsIdleAsync", request);
		return rpcRst;
	}

	Future<String> checkUserIsExistRoomIdAsync(GetDeviceRequest request) async {
		var rpcRst = await call("CheckUserIsExistRoomIdAsync", request);
		return rpcRst;
	}

	Future<bool> addUserRemoteConnectAsync(AddUserRemoteConnectRequest request) async {
		var rpcRst = await call("AddUserRemoteConnectAsync", request);
		return rpcRst;
	}

	Future<bool> closeUserRemoteConnectAsync(GetDeviceRequest request) async {
		var rpcRst = await call("CloseUserRemoteConnectAsync", request);
		return rpcRst;
	}

	Future<bool> userCancelLogDownloadAsync(GetDeviceRequest request) async {
		var rpcRst = await call("UserCancelLogDownloadAsync", request);
		return rpcRst;
	}

	Future<List<DeviceConnectStateResult>> getDeviceStateListByTokenAsync(GetDeviceStateListRequest request) async {
		var rpcRst = await call("GetDeviceStateListByTokenAsync", request);
		var result = (rpcRst as List).map((e)=>DeviceConnectStateResult.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> deviceCancelLogDownloadAsync(DeivceCancelLogDownloadRequest request) async {
		var rpcRst = await call("DeviceCancelLogDownloadAsync", request);
		return rpcRst;
	}

	Future<bool> deviceRemoteConnectHeartRateAsync(RemoteConnectHeartRateRequest request) async {
		var rpcRst = await call("DeviceRemoteConnectHeartRateAsync", request);
		return rpcRst;
	}

	Future<bool> applyProbeApplicationSettingAsync(ProbeApplicationSettingRequest request) async {
		var rpcRst = await call("ApplyProbeApplicationSettingAsync", request);
		return rpcRst;
	}

	Future<bool> responseProbeApplicationSettingAsync(ProbeApplicationSettingResultRequest request) async {
		var rpcRst = await call("ResponseProbeApplicationSettingAsync", request);
		return rpcRst;
	}

	Future<ProbeApplicationSettingInfoDTO> getProbeApplicationSettingAsync(GetControlParametersRequest request) async {
		var rpcRst = await call("GetProbeApplicationSettingAsync", request);
		var result = ProbeApplicationSettingInfoDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<RemoteConnectsRequest> findConnectingDeviceListAsync(GetDeviceRequest request) async {
		var rpcRst = await call("FindConnectingDeviceListAsync", request);
		var result = RemoteConnectsRequest.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> closeConnectingDeviceListAsync(GetDeviceRequest request) async {
		var rpcRst = await call("CloseConnectingDeviceListAsync", request);
		return rpcRst;
	}

}