diff --git a/otgc/build.gradle b/otgc/build.gradle index a16868b1c50bf1a1bafc365d94233821312f897d..4e42a43883eb35bd53c213468df28c6915653784 100644 --- a/otgc/build.gradle +++ b/otgc/build.gradle @@ -30,7 +30,7 @@ android { minSdkVersion 21 targetSdkVersion 28 versionCode 13 - versionName "2.13.0" + versionName "3.0.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" compileOptions { diff --git a/otgc/src/main/java/org/openconnectivity/otgc/data/repository/CloudRepository.java b/otgc/src/main/java/org/openconnectivity/otgc/data/repository/CloudRepository.java index 6d617e75e464b4346a1bdad685ef1d314f7ab3e6..422b066df28d6c798d10c67bda463cd31f34296b 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/data/repository/CloudRepository.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/data/repository/CloudRepository.java @@ -1,21 +1,107 @@ package org.openconnectivity.otgc.data.repository; +import org.iotivity.CborEncoder; +import org.iotivity.OCClientResponse; import org.iotivity.OCCloud; import org.iotivity.OCCloudContext; +import org.iotivity.OCCloudHandler; +import org.iotivity.OCCloudStatusMask; +import org.iotivity.OCCoreRes; +import org.iotivity.OCDiscoveryAllHandler; +import org.iotivity.OCDiscoveryFlags; +import org.iotivity.OCEndpoint; +import org.iotivity.OCEndpointUtil; +import org.iotivity.OCMain; +import org.iotivity.OCQos; +import org.iotivity.OCRep; +import org.iotivity.OCRepresentation; +import org.iotivity.OCResponseHandler; +import org.iotivity.OCStatus; +import org.iotivity.OCUuid; +import org.iotivity.OCUuidUtil; +import org.openconnectivity.otgc.data.entity.DeviceEntity; +import org.openconnectivity.otgc.data.persistence.dao.DeviceDao; +import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.devicelist.DeviceType; import org.openconnectivity.otgc.domain.model.resource.cloud.OcCloudConfiguration; +import org.openconnectivity.otgc.domain.model.resource.virtual.d.OcDeviceInfo; +import org.openconnectivity.otgc.domain.model.resource.virtual.p.OcPlatformInfo; +import org.openconnectivity.otgc.domain.model.resource.virtual.res.OcEndpoint; +import org.openconnectivity.otgc.domain.model.resource.virtual.res.OcResource; +import org.openconnectivity.otgc.utils.constant.OcfResourceType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; import javax.inject.Inject; import javax.inject.Singleton; import io.reactivex.Completable; +import io.reactivex.Observable; import io.reactivex.Single; +import timber.log.Timber; @Singleton public class CloudRepository { + private final DeviceDao deviceDao; + private final PreferencesRepository preferencesRepository; + + private List devices = new ArrayList<>(); + private Map> resources = new HashMap<>(); + @Inject - public CloudRepository() { + public CloudRepository(PreferencesRepository preferencesRepository, + DeviceDao deviceDao) { + this.preferencesRepository = preferencesRepository; + this.deviceDao = deviceDao; + } + + private OCCloudHandler handler = (ctx, status) -> { + Timber.d("Cloud Manager Status:"); + if ((status & OCCloudStatusMask.OC_CLOUD_REGISTERED) == OCCloudStatusMask.OC_CLOUD_REGISTERED) { + Timber.d("\t\t-Registered"); + } + if ((status & OCCloudStatusMask.OC_CLOUD_TOKEN_EXPIRY) == OCCloudStatusMask.OC_CLOUD_TOKEN_EXPIRY) { + Timber.d("\t\t-Token Expiry: "); + if (ctx != null) { + Timber.d(this.retrieveTokenExpiry().blockingGet() + "\n"); + } + } + if ((status & OCCloudStatusMask.OC_CLOUD_FAILURE) == OCCloudStatusMask.OC_CLOUD_FAILURE) { + Timber.e("\t\t-Failure"); + } + if ((status & OCCloudStatusMask.OC_CLOUD_LOGGED_IN) == OCCloudStatusMask.OC_CLOUD_LOGGED_IN) { + Timber.d("\t\t-Logged In"); + } + if ((status & OCCloudStatusMask.OC_CLOUD_LOGGED_OUT) == OCCloudStatusMask.OC_CLOUD_LOGGED_OUT) { + Timber.d("\t\t-Logged Out"); + } + if ((status & OCCloudStatusMask.OC_CLOUD_DEREGISTERED) == OCCloudStatusMask.OC_CLOUD_DEREGISTERED) { + Timber.d("\t\t-DeRegistered"); + } + if ((status & OCCloudStatusMask.OC_CLOUD_REFRESHED_TOKEN) == OCCloudStatusMask.OC_CLOUD_REFRESHED_TOKEN) { + Timber.d("\t\t-Refreshed Token"); + } + }; + + public Completable initCloud() { + OCCloudContext ctx = OCCloud.getContext(0); + + if (ctx != null) { + String apn = ctx.getStore().getAuth_provider(); + String url = ctx.getStore().getCi_server(); + String at = ctx.getStore().getAccess_token(); + String uuid = ctx.getStore().getSid(); + + return provisionCloudConfiguration(apn, url, at, uuid); + } + return Completable.complete(); } public Single retrieveState() { @@ -42,8 +128,477 @@ public class CloudRepository { public Completable provisionCloudConfiguration(String authProvider, String cloudUrl, String accessToken, String cloudUuid) { return Completable.create(emitter -> { OCCloudContext ctx = OCCloud.getContext(0); - OCCloud.provisionConfResource(ctx, authProvider, cloudUrl, accessToken, cloudUuid); + if (ctx != null) { + OCCloud.managerStart(ctx, this.handler); + OCCloud.provisionConfResource(ctx, cloudUrl, accessToken, cloudUuid, authProvider); + } emitter.onComplete(); }); } + + public Completable register() { + return Completable.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + if (ctx == null) { + emitter.onError(new Exception("Cloud context is null")); + } + + int ret = OCCloud.registerCloud(ctx, this.handler); + if (ret < 0) { + String error = "Could not issue Cloud Register request."; + Timber.e(error); + emitter.onError(new Exception(error)); + } else { + Timber.d("Issued Cloud Register request."); + } + }) + .timeout(getDiscoveryTimeout(), TimeUnit.SECONDS) + .onErrorComplete(); + } + + public Completable deregister() { + return Completable.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + if (ctx == null) { + emitter.onError(new Exception("Cloud context is null")); + } + + int ret = OCCloud.deregisterCloud(ctx, this.handler); + if (ret < 0) { + String error = "Could not issue Cloud Deregister request."; + Timber.e(error); + emitter.onError(new Exception(error)); + } else { + Timber.d("Issued Cloud Deregister request."); + } + }) + .timeout(getDiscoveryTimeout(), TimeUnit.SECONDS) + .onErrorComplete(); + } + + public Completable login() { + return Completable.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + if (ctx == null) { + emitter.onError(new Exception("Cloud context is null")); + } + + int ret = OCCloud.login(ctx, this.handler); + if (ret < 0) { + String error = "Could not issue Cloud Login request."; + Timber.e(error); + emitter.onError(new Exception(error)); + } else { + Timber.d("Issued Cloud Login request."); + } + }) + .timeout(getDiscoveryTimeout(), TimeUnit.SECONDS) + .onErrorComplete(); + } + + public Completable logout() { + return Completable.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + if (ctx == null) { + emitter.onError(new Exception("Cloud context is null")); + } + + int ret = OCCloud.logout(ctx, this.handler); + if (ret < 0) { + String error = "Could not issue Cloud Logout request."; + Timber.e(error); + emitter.onError(new Exception(error)); + } else { + Timber.d("Issued Cloud Logout request."); + } + }) + .timeout(getDiscoveryTimeout(), TimeUnit.SECONDS) + .onErrorComplete(); + } + + public Completable retrieveTokenExpiry() { + return Completable.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + if (ctx == null) { + emitter.onError(new Exception("Cloud context is null")); + } + + OCCloud.getTokenExpiry(ctx); + emitter.onComplete(); + }); + } + + public Completable refreshToken() { + return Completable.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + if (ctx == null) { + emitter.onError(new Exception("Cloud context is null")); + } + + int ret = OCCloud.refreshToken(ctx, this.handler); + if (ret < 0) { + String error = "Could not issue refresh token request."; + Timber.e(error); + emitter.onError(new Exception(error)); + } else { + Timber.d("Issued refresh token request."); + } + }) + .timeout(getDiscoveryTimeout(), TimeUnit.SECONDS) + .onErrorComplete(); + } + + public Observable discoverDevices() { + return Completable.create(emitter -> { + devices.clear(); + + OCCloudContext ctx = OCCloud.getContext(0); + + OCDiscoveryAllHandler handler = + (String anchor, String uri, String[] types, int interfaceMask, OCEndpoint endpoints, + int resourcePropertiesMask, boolean more) -> { + String deviceId = anchor.substring(anchor.lastIndexOf('/') + 1); + + DeviceEntity device = deviceDao.findById(deviceId).blockingGet(); + if (device == null) { + deviceDao.insert(new DeviceEntity(deviceId, "", endpoints, DeviceType.CLOUD, Device.NOTHING_PERMITS)); + } + + Device device1 = new Device(DeviceType.CLOUD, deviceId, new OcDeviceInfo(), endpoints, Device.NOTHING_PERMITS); + if (!devices.contains(device1)) { + devices.add(device1); + } + + List uriList = new ArrayList<>(); + if (resources.containsKey(deviceId)) { + uriList = resources.get(deviceId); + } + uriList.add(uri); + resources.put(deviceId, uriList); + + if(!more) { + emitter.onComplete(); + return OCDiscoveryFlags.OC_STOP_DISCOVERY; + } + return OCDiscoveryFlags.OC_CONTINUE_DISCOVERY; + }; + + if (ctx == null){ + emitter.onComplete(); + } else if (OCCloud.discoverResources(ctx, handler) != 0) { + String error = "ERROR: could not issue discovery request"; + Timber.e(error); + emitter.onError(new Exception(error)); + } + }).timeout(getDiscoveryTimeout(), TimeUnit.SECONDS) + .onErrorComplete() + .andThen(Observable.fromIterable(devices)) + .filter(device -> !device.getDeviceId().equals(getDeviceId().blockingGet())); + } + + public Single> getResources(String deviceId) { + return Single.create(emitter -> { + if (resources.containsKey(deviceId)) { + emitter.onSuccess(resources.get(deviceId)); + } else { + emitter.onError(new Exception("Device UUID is not found")); + } + }); + } + + public Single retrieveUri(String deviceUuid, String resourceUri) { + return Single.create(emitter -> { + if (resources.containsKey(deviceUuid)) { + List uriList = resources.get(deviceUuid); + String res = ""; + for (String uri : uriList) { + if (uri.endsWith(resourceUri)) { + res = uri; + break; + } + } + + if (!res.isEmpty()) { + emitter.onSuccess(res); + } else { + emitter.onError(new Exception("URI is not found")); + } + } else { + emitter.onError(new Exception("Device UUID is not found")); + } + }); + } + + public Single retrieveEndpoint() { + return Single.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + emitter.onSuccess(ctx.getCloudEndpoint()); + }); + } + + public Single retrieveDeviceInfo(OCEndpoint endpoint, String uri) { + return Single.create(emitter -> { + OCResponseHandler handler = (OCClientResponse response) -> { + OCStatus code = response.getCode(); + if (code == OCStatus.OC_STATUS_OK) { + OcDeviceInfo deviceInfo = new OcDeviceInfo(); + deviceInfo.parseOCRepresentation(response.getPayload()); + emitter.onSuccess(deviceInfo); + } else { + emitter.onError(new Exception("Get device info error - code: " + code)); + } + }; + + if (!OCMain.doGet(uri, endpoint, null, handler, OCQos.HIGH_QOS)) { + emitter.onError(new Exception("Get device info error")); + } + }); + } + + public Single retrievePlatformInfo(OCEndpoint endpoint, String uri) { + return Single.create(emitter -> { + OCResponseHandler handler = (OCClientResponse response) -> { + OCStatus code = response.getCode(); + if (code == OCStatus.OC_STATUS_OK) { + OcPlatformInfo platformInfo = new OcPlatformInfo(); + platformInfo.setOCRepresentation(response.getPayload()); + emitter.onSuccess(platformInfo); + } else { + emitter.onError(new Exception("Get device info error - code: " + code)); + } + }; + + if (!OCMain.doGet(uri, endpoint, null, handler, OCQos.HIGH_QOS)) { + emitter.onError(new Exception("Get device info error")); + } + }); + } + + public Observable discoverAllResources(String deviceId) { + return Observable.create(emitter -> { + OCCloudContext ctx = OCCloud.getContext(0); + + OCDiscoveryAllHandler handler = + (String anchor, String uri, String[] types, int interfaceMask, OCEndpoint endpoints, + int resourcePropertiesMask, boolean more) -> { + String uuid = anchor.substring(anchor.lastIndexOf('/') + 1); + if (deviceId.equals(uuid)) { + OcResource resource = new OcResource(); + resource.setAnchor(anchor); + resource.setHref(uri); + + List epList = new ArrayList<>(); + OCEndpoint ep = endpoints; + while (ep != null) { + OcEndpoint endpoint = new OcEndpoint(); + endpoint.setEndpoint(OCEndpointUtil.toString(ep)); + epList.add(endpoint); + ep = ep.getNext(); + } + resource.setEndpoints(epList); + resource.setPropertiesMask((long)resourcePropertiesMask); + resource.setResourceTypes(Arrays.asList(types)); + emitter.onNext(resource); + } + + if(!more) { + emitter.onComplete(); + return OCDiscoveryFlags.OC_STOP_DISCOVERY; + } + return OCDiscoveryFlags.OC_CONTINUE_DISCOVERY; + }; + + if (ctx != null && OCCloud.discoverResources(ctx, handler) >= 0) + { + Timber.d("Successfully issued resource discovery request"); + } else { + String error = "ERROR issuing resource discovery request"; + Timber.e(error); + emitter.onError(new Exception(error)); + } + }); + } + + public Single> discoverVerticalResources(String deviceId) { + return discoverAllResources(deviceId) + .toList() + .map(resources -> { + List resourceList = new ArrayList<>(); + for (OcResource resource : resources) { + for (String resourceType : resource.getResourceTypes()) { + if (OcfResourceType.isVerticalResourceType(resourceType) + && !resourceType.startsWith("oic.d.")) { + resourceList.add(resource); + break; + } + } + } + + return resourceList; + }); + } + + public Single get(OCEndpoint endpoint, String uri, String deviceId) { + return Single.create(emitter -> { + OCUuid uuid = OCUuidUtil.stringToUuid(deviceId); + OCEndpointUtil.setDi(endpoint, uuid); + + OCResponseHandler handler = (OCClientResponse response) -> { + OCStatus code = response.getCode(); + if (code.equals(OCStatus.OC_STATUS_OK)) { + emitter.onSuccess(response.getPayload()); + } else { + emitter.onError(new Exception("GET request error - code: " + code)); + } + }; + + if (!OCMain.doGet(uri, endpoint, null, handler, OCQos.LOW_QOS)) { + emitter.onError(new Exception("Error in GET request")); + } + }); + } + + public Completable post(OCEndpoint endpoint, String uri, String deviceId, OCRepresentation rep, Object valueArray) { + return Completable.create(emitter -> { + OCUuid uuid = OCUuidUtil.stringToUuid(deviceId); + OCEndpointUtil.setDi(endpoint, uuid); + + OCResponseHandler handler = (OCClientResponse response) -> { + OCStatus code = response.getCode(); + if (code == OCStatus.OC_STATUS_OK + || code == OCStatus.OC_STATUS_CHANGED) { + emitter.onComplete(); + } else { + emitter.onError(new Exception("POST " + uri + " error - code: " + code)); + } + }; + + if (OCMain.initPost(uri, endpoint, null, handler, OCQos.HIGH_QOS)) { + CborEncoder root = OCRep.beginRootObject(); + parseOCRepresentionToCbor(root, rep, valueArray); + OCRep.endRootObject(); + + if (!OCMain.doPost()) { + emitter.onError(new Exception("Do POST " + uri + " error")); + } + } else { + emitter.onError(new Exception("Init POST " + uri + " error")); + } + }); + } + + public Completable post(OCEndpoint endpoint, String uri, String deviceId, Map values) { + return Completable.create(emitter -> { + OCUuid uuid = OCUuidUtil.stringToUuid(deviceId); + OCEndpointUtil.setDi(endpoint, uuid); + + OCResponseHandler handler = (OCClientResponse response) -> { + OCStatus code = response.getCode(); + if (code == OCStatus.OC_STATUS_OK + || code == OCStatus.OC_STATUS_CHANGED) { + emitter.onComplete(); + } else { + emitter.onError(new Exception("POST " + uri + " error - code: " + code)); + } + }; + + if (OCMain.initPost(uri, endpoint, null, handler, OCQos.HIGH_QOS)) { + CborEncoder root = OCRep.beginRootObject(); + parseOCRepresentionToCbor(root, values); + OCRep.endRootObject(); + + if (!OCMain.doPost()) { + emitter.onError(new Exception("Do POST " + uri + " error")); + } + } else { + emitter.onError(new Exception("Init POST " + uri + " error")); + } + }); + } + + private void parseOCRepresentionToCbor(CborEncoder parent, OCRepresentation rep, Object valueArray) { + while (rep != null) { + switch (rep.getType()) { + case OC_REP_BOOL: + OCRep.setBoolean(parent, rep.getName(), rep.getValue().getBool()); + break; + case OC_REP_INT: + OCRep.setLong(parent, rep.getName(), rep.getValue().getInteger()); + break; + case OC_REP_DOUBLE: + OCRep.setDouble(parent, rep.getName(), rep.getValue().getDouble()); + break; + case OC_REP_STRING: + OCRep.setTextString(parent, rep.getName(), rep.getValue().getString()); + break; + case OC_REP_INT_ARRAY: + OCRep.setLongArray(parent, rep.getName(), (long[])valueArray); + break; + case OC_REP_DOUBLE_ARRAY: + OCRep.setDoubleArray(parent, rep.getName(), (double[])valueArray); + break; + case OC_REP_STRING_ARRAY: + OCRep.setStringArray(parent, rep.getName(), (String[])valueArray); + break; + case OC_REP_BOOL_ARRAY: + OCRep.setBooleanArray(parent, rep.getName(), (boolean[])valueArray); + break; + default: + break; + } + + rep = rep.getNext(); + } + } + + private void parseOCRepresentionToCbor(CborEncoder parent, Map values) { + for (String key : values.keySet()) { + if (values.get(key) instanceof Boolean) { + OCRep.setBoolean(parent, key, (boolean)values.get(key)); + } else if (values.get(key) instanceof Integer) { + OCRep.setLong(parent, key, (Integer)values.get(key)); + } else if (values.get(key) instanceof Double) { + OCRep.setDouble(parent, key, (Double)values.get(key)); + } else if (values.get(key) instanceof String) { + OCRep.setTextString(parent, key, (String)values.get(key)); + } else if (values.get(key) instanceof List) { + if (((List) values.get(key)).get(0) instanceof String) { + String[] ret = new String[((List)values.get(key)).size()]; + for (int i=0; i< ((List)values.get(key)).size(); i++) { + ret[i] = ((List)values.get(key)).get(i); + } + OCRep.setStringArray(parent, key, ret); + } else if (((List) values.get(key)).get(0) instanceof Integer) { + long[] ret = new long[((List)values.get(key)).size()]; + for (int i=0; i< ((List)values.get(key)).size(); i++) { + ret[i] = ((List)values.get(key)).get(i); + } + OCRep.setLongArray(parent, key, ret); + } else if (((List) values.get(key)).get(0) instanceof Double) { + double[] ret = new double[((List)values.get(key)).size()]; + for (int i=0; i< ((List)values.get(key)).size(); i++) { + ret[i] = ((List)values.get(key)).get(i); + } + OCRep.setDoubleArray(parent, key, ret); + } else if (((List) values.get(key)).get(0) instanceof Boolean) { + boolean[] ret = new boolean[((List)values.get(key)).size()]; + for (int i=0; i< ((List)values.get(key)).size(); i++) { + ret[i] = ((List)values.get(key)).get(i); + } + OCRep.setBooleanArray(parent, key, ret); + } + } + } + } + + public Single getDeviceId() { + return Single.create(emitter -> { + OCUuid uuid = OCCoreRes.getDeviceId(0 /* First registered device */); + emitter.onSuccess(OCUuidUtil.uuidToString(uuid)); + }); + } + + public int getDiscoveryTimeout() { + return preferencesRepository.getDiscoveryTimeout(); + } } \ No newline at end of file diff --git a/otgc/src/main/java/org/openconnectivity/otgc/data/repository/IotivityRepository.java b/otgc/src/main/java/org/openconnectivity/otgc/data/repository/IotivityRepository.java index 604f92ac27eede1984eced4269ec1a013ae2ebda..d2639541a4fb35f8cc4f1b7bb22741c29dd3bf86 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/data/repository/IotivityRepository.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/data/repository/IotivityRepository.java @@ -27,6 +27,7 @@ import org.iotivity.CborEncoder; import org.iotivity.OCBufferSettings; import org.iotivity.OCClientResponse; import org.iotivity.OCCloud; +import org.iotivity.OCCloudContext; import org.iotivity.OCCoreRes; import org.iotivity.OCDiscoveryAllHandler; import org.iotivity.OCDiscoveryFlags; @@ -354,9 +355,9 @@ public class IotivityRepository { public Single getNonSecureEndpoint(Device device) { return Single.create(emitter -> { - String endpoint = device.getIpv6Host(); + String endpoint = device.getIpv6Host() != null ? device.getIpv6Host() : device.getIpv6TcpHost(); if (endpoint == null) { - endpoint = device.getIpv4Host(); + endpoint = device.getIpv4Host() != null ? device.getIpv4Host() : device.getIpv4TcpHost(); } emitter.onSuccess(endpoint); }); @@ -364,9 +365,9 @@ public class IotivityRepository { public Single getSecureEndpoint(Device device) { return Single.create(emitter -> { - String endpoint = device.getIpv6SecureHost(); + String endpoint = device.getIpv6SecureHost() != null ? device.getIpv6SecureHost() : device.getIpv6TcpSecureHost(); if (endpoint == null) { - endpoint = device.getIpv4SecureHost(); + endpoint = device.getIpv4SecureHost() != null ? device.getIpv4SecureHost() : device.getIpv4TcpSecureHost(); } emitter.onSuccess(endpoint); }); @@ -777,6 +778,12 @@ public class IotivityRepository { public void close() { Timber.d("Calling OCMain.mainShutdown()"); + + OCCloudContext ctx = OCCloud.getContext(0); + if (ctx != null) { + OCCloud.managerStop(ctx); + } + OCMain.mainShutdown(); OCObt.shutdown(); } diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/Device.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/Device.java index d9de8d1732a3993575289bf3bd6acf3087330c28..2afb7fab4f54a25af256742503e5a818bc089d6f 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/Device.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/Device.java @@ -44,9 +44,13 @@ public class Device implements Comparable, Serializable { private String deviceId; private transient OcDeviceInfo deviceInfo; private String ipv6SecureHost; + private String ipv6TcpSecureHost; private String ipv6Host; + private String ipv6TcpHost; private String ipv4SecureHost; + private String ipv4TcpSecureHost; private String ipv4Host; + private String ipv4TcpHost; private int permits; public Device() {} @@ -61,14 +65,26 @@ public class Device implements Comparable, Serializable { while(endpoints != null) { String endpointStr = OCEndpointUtil.toString(endpoints); - if (endpointStr.startsWith("coaps://") && endpointStr.contains(".")) { - ipv4SecureHost = endpointStr; - } else if (endpointStr.startsWith("coaps://")) { - ipv6SecureHost = endpointStr; - } else if (endpointStr.startsWith("coap://") && endpointStr.contains(".")) { - ipv4Host = endpointStr; - } else if (endpointStr.startsWith("coap://")){ - ipv6Host = endpointStr; + if (endpointStr.contains(".")) { + if (endpointStr.startsWith("coaps://")) { + ipv4SecureHost = endpointStr; + } else if (endpointStr.startsWith("coaps+tcp://")) { + ipv4TcpSecureHost = endpointStr; + } else if (endpointStr.startsWith("coap://")) { + ipv4Host = endpointStr; + } else if (endpointStr.startsWith("coap+tcp://")) { + ipv4TcpHost = endpointStr; + } + } else { + if (endpointStr.startsWith("coaps://")) { + ipv6SecureHost = endpointStr; + } else if (endpointStr.startsWith("coaps+tcp://")) { + ipv6TcpSecureHost = endpointStr; + } else if (endpointStr.startsWith("coap://")) { + ipv6Host = endpointStr; + } else if (endpointStr.startsWith("coap+tcp://")) { + ipv6TcpHost = endpointStr; + } } endpoints = endpoints.getNext(); @@ -83,14 +99,26 @@ public class Device implements Comparable, Serializable { this.permits = permits; for (String endpoint : endpoints) { - if (endpoint.startsWith("coaps://") && endpoint.contains(".")) { - ipv4SecureHost = endpoint; - } else if (endpoint.startsWith("coaps://")) { - ipv6SecureHost = endpoint; - } else if (endpoint.startsWith("coap://") && endpoint.contains(".")) { - ipv4Host = endpoint; - } else if (endpoint.startsWith("coap://")) { - ipv6Host = endpoint; + if (endpoint.contains(".")) { + if (endpoint.startsWith("coaps://")) { + ipv4SecureHost = endpoint; + } else if (endpoint.startsWith("coaps+tcp://")) { + ipv4TcpSecureHost = endpoint; + } else if (endpoint.startsWith("coap://")) { + ipv4Host = endpoint; + } else if (endpoint.startsWith("coap+tcp://")) { + ipv4TcpHost = endpoint; + } + } else { + if (endpoint.startsWith("coaps://")) { + ipv6SecureHost = endpoint; + } else if (endpoint.startsWith("coaps+tcp://")) { + ipv6TcpSecureHost = endpoint; + } else if (endpoint.startsWith("coap://")) { + ipv6Host = endpoint; + } else if (endpoint.startsWith("coap+tcp://")) { + ipv6TcpHost = endpoint; + } } } } @@ -135,6 +163,14 @@ public class Device implements Comparable, Serializable { this.ipv6Host = host; } + public String getIpv6TcpHost() { + return this.ipv6TcpHost; + } + + public void setIpv6TcpHost(String host) { + this.ipv6TcpHost = host; + } + public String getIpv6SecureHost() { return this.ipv6SecureHost; } @@ -143,6 +179,14 @@ public class Device implements Comparable, Serializable { this.ipv6SecureHost = host; } + public String getIpv6TcpSecureHost() { + return this.ipv6TcpSecureHost; + } + + public void setIpv6TcpSecureHost(String host) { + this.ipv6TcpSecureHost = host; + } + public String getIpv4Host() { return this.ipv4Host; } @@ -151,6 +195,14 @@ public class Device implements Comparable, Serializable { this.ipv4Host = host; } + public String getIpv4TcpHost() { + return this.ipv4TcpHost; + } + + public void setIpv4TcpHost(String host) { + this.ipv4TcpHost = host; + } + public String getIpv4SecureHost() { return this.ipv4SecureHost; } @@ -159,27 +211,55 @@ public class Device implements Comparable, Serializable { this.ipv4SecureHost = host; } + public String getIpv4TcpSecureHost() { + return this.ipv4SecureHost; + } + + public void setIpv4TcpSecureHost(String host) { + this.ipv4SecureHost = host; + } + public boolean equalsHosts(Device device) { if (this.getIpv6Host() != null && device.getIpv6Host() != null && !this.getIpv6Host().equals(device.getIpv6Host())) { return false; } + if (this.getIpv6TcpHost() != null && device.getIpv6TcpHost() != null + && !this.getIpv6TcpHost().equals(device.getIpv6TcpHost())) { + return false; + } + if (this.getIpv6SecureHost() != null && device.getIpv6SecureHost() != null && !this.getIpv6SecureHost().equals(device.getIpv6SecureHost())) { return false; } + if (this.getIpv6TcpSecureHost() != null && device.getIpv6TcpSecureHost() != null + && !this.getIpv6TcpSecureHost().equals(device.getIpv6TcpSecureHost())) { + return false; + } + if (this.getIpv4Host() != null && device.getIpv4Host() != null && !this.getIpv4Host().equals(device.getIpv4Host())) { return false; } + if (this.getIpv4TcpHost() != null && device.getIpv4TcpHost() != null + && !this.getIpv4TcpHost().equals(device.getIpv4TcpHost())) { + return false; + } + if (this.getIpv4SecureHost() != null && device.getIpv4SecureHost() != null && !this.getIpv4SecureHost().equals(device.getIpv4SecureHost())) { return false; } + if (this.getIpv4TcpSecureHost() != null && device.getIpv4TcpSecureHost() != null + && !this.getIpv4TcpSecureHost().equals(device.getIpv4TcpSecureHost())) { + return false; + } + return true; } diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/DeviceType.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/DeviceType.java index 6caa17240f042405a76c9997e5ce1e89d9455a70..d231760c0592cbc6b49622b72a5913fd95e6f4a5 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/DeviceType.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/model/devicelist/DeviceType.java @@ -25,5 +25,6 @@ public enum DeviceType { UNOWNED, OWNED_BY_SELF, OWNED_BY_OTHER, - OWNED_BY_OTHER_WITH_PERMITS + OWNED_BY_OTHER_WITH_PERMITS, + CLOUD } diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDeregisterUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDeregisterUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..8e78e09923f7b4c0630466a001586effd9f8a09e --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDeregisterUseCase.java @@ -0,0 +1,21 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; + +import javax.inject.Inject; + +import io.reactivex.Single; + +public class CloudDeregisterUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudDeregisterUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute() { + return cloudRepository.deregister() + .andThen(cloudRepository.retrieveState()); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDiscoverDevicesUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDiscoverDevicesUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..7c733837ac00659fc50c94a800bdb70996c6a143 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDiscoverDevicesUseCase.java @@ -0,0 +1,21 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; +import org.openconnectivity.otgc.domain.model.devicelist.Device; + +import javax.inject.Inject; + +import io.reactivex.Observable; + +public class CloudDiscoverDevicesUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudDiscoverDevicesUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Observable execute() { + return cloudRepository.discoverDevices(); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDiscoverResourcesUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDiscoverResourcesUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..fe86f02d092e12f0015d6becc0ce1773ad9c4127 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudDiscoverResourcesUseCase.java @@ -0,0 +1,49 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; +import org.openconnectivity.otgc.domain.model.client.SerializableResource; +import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.resource.virtual.res.OcResource; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.TimeUnit; + +import javax.inject.Inject; + +import io.reactivex.Completable; +import io.reactivex.Single; + +public class CloudDiscoverResourcesUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudDiscoverResourcesUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single> execute(Device device) { + return + Completable.complete() + .delay(1, TimeUnit.SECONDS) + .andThen(cloudRepository.discoverVerticalResources(device.getDeviceId()) + .map(ocResources -> { + List serializableResources = new ArrayList<>(); + for (OcResource resource : ocResources) { + SerializableResource serializableResource = new SerializableResource(); + serializableResource.setUri(resource.getHref()); + serializableResource.setResourceTypes(resource.getResourceTypes()); + serializableResource.setResourceInterfaces(resource.getInterfaces()); + serializableResource.setObservable(false); + + serializableResources.add(serializableResource); + } + + Collections.sort(serializableResources, + (r1, r2) -> r1.getUri().compareTo(r2.getUri())); + + return serializableResources; + })); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudGetResourceUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudGetResourceUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..afc9fc161c31da4d8e510b02a3964b38fca86953 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudGetResourceUseCase.java @@ -0,0 +1,26 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import io.reactivex.Single; +import org.openconnectivity.otgc.data.repository.CloudRepository; +import org.openconnectivity.otgc.domain.model.client.SerializableResource; +import org.openconnectivity.otgc.domain.model.devicelist.Device; + +import javax.inject.Inject; + +public class CloudGetResourceUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudGetResourceUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute(Device device, SerializableResource resource) { + return cloudRepository.retrieveEndpoint() + .flatMap(endpoint -> cloudRepository.get(endpoint, resource.getUri(), device.getDeviceId())) + .map(ocRepresentation -> { + resource.setProperties(ocRepresentation); + return resource; + }); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudLoginUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudLoginUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..137bd530bc7700f3990b220557106e2f46a1fda7 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudLoginUseCase.java @@ -0,0 +1,21 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; + +import javax.inject.Inject; + +import io.reactivex.Single; + +public class CloudLoginUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudLoginUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute() { + return cloudRepository.login() + .andThen(cloudRepository.retrieveState()); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudLogoutUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudLogoutUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..a8c5ec48a038bed4a6b72a2188e40580e2cad0a1 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudLogoutUseCase.java @@ -0,0 +1,21 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; + +import javax.inject.Inject; + +import io.reactivex.Single; + +public class CloudLogoutUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudLogoutUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute() { + return cloudRepository.logout() + .andThen(cloudRepository.retrieveState()); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudPostResourceUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudPostResourceUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..cb25bb20408651ed1c39dc3d3ab1a3dd16829ec0 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudPostResourceUseCase.java @@ -0,0 +1,29 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import io.reactivex.Completable; +import org.iotivity.OCRepresentation; +import org.openconnectivity.otgc.data.repository.CloudRepository; +import org.openconnectivity.otgc.domain.model.client.SerializableResource; +import org.openconnectivity.otgc.domain.model.devicelist.Device; + +import javax.inject.Inject; +import java.util.Map; + +public class CloudPostResourceUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudPostResourceUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Completable execute(Device device, SerializableResource resource, OCRepresentation rep, Object valueArray) { + return cloudRepository.retrieveEndpoint() + .flatMapCompletable(endpoint -> cloudRepository.post(endpoint, resource.getUri(), device.getDeviceId(), rep, valueArray)); + } + + public Completable execute(Device device, SerializableResource resource, Map values) { + return cloudRepository.retrieveEndpoint() + .flatMapCompletable(endpoint -> cloudRepository.post(endpoint, resource.getUri(), device.getDeviceId(), values)); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRefreshTokenUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRefreshTokenUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..e85d8a40bfced95abdf1da3e956b637beae4d053 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRefreshTokenUseCase.java @@ -0,0 +1,21 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; + +import javax.inject.Inject; + +import io.reactivex.Single; + +public class CloudRefreshTokenUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudRefreshTokenUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute() { + return cloudRepository.refreshToken() + .andThen(cloudRepository.retrieveState()); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRegisterUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRegisterUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..6b52bb97817f5a64877c76331e85f1afaae8e117 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRegisterUseCase.java @@ -0,0 +1,21 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; + +import javax.inject.Inject; + +import io.reactivex.Single; + +public class CloudRegisterUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudRegisterUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute() { + return cloudRepository.register() + .andThen(cloudRepository.retrieveState()); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrieveDeviceInfoUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrieveDeviceInfoUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..e1905877068af5e25c0f199e61e100b2ef29ca1a --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrieveDeviceInfoUseCase.java @@ -0,0 +1,24 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import io.reactivex.Single; +import org.openconnectivity.otgc.data.repository.CloudRepository; +import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.resource.virtual.d.OcDeviceInfo; +import org.openconnectivity.otgc.utils.constant.OcfResourceUri; + +import javax.inject.Inject; + +public class CloudRetrieveDeviceInfoUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudRetrieveDeviceInfoUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute(Device device) { + return cloudRepository.retrieveUri(device.getDeviceId(), OcfResourceUri.DEVICE_INFO_URI) + .flatMap(uri -> cloudRepository.retrieveEndpoint() + .flatMap(endpoint -> cloudRepository.retrieveDeviceInfo(endpoint, uri))); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrieveDeviceRoleUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrieveDeviceRoleUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..f56d44414e9a2d0d948f825f552fae21dd0b8076 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrieveDeviceRoleUseCase.java @@ -0,0 +1,35 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import io.reactivex.Single; +import org.openconnectivity.otgc.data.repository.CloudRepository; +import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.devicelist.DeviceRole; + +import javax.inject.Inject; + +public class CloudRetrieveDeviceRoleUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudRetrieveDeviceRoleUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute(Device device) { + return cloudRepository.getResources(device.getDeviceId()) + .map(ocRes -> { + DeviceRole deviceRole = DeviceRole.CLIENT; + for (String resource : ocRes) { + if (!resource.endsWith("/oic/cloud/s") + && !resource.endsWith("/oic/d") + && !resource.endsWith("/oic/p")) { + deviceRole = DeviceRole.SERVER; + } + + if (deviceRole.equals(DeviceRole.SERVER)) + break; + } + return deviceRole; + }); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrievePlatformInfoUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrievePlatformInfoUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..887f02ca475909dd50a0b3e932e0c12d106521d6 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/CloudRetrievePlatformInfoUseCase.java @@ -0,0 +1,24 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import io.reactivex.Single; +import org.openconnectivity.otgc.data.repository.CloudRepository; +import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.resource.virtual.p.OcPlatformInfo; +import org.openconnectivity.otgc.utils.constant.OcfResourceUri; + +import javax.inject.Inject; + +public class CloudRetrievePlatformInfoUseCase { + private final CloudRepository cloudRepository; + + @Inject + public CloudRetrievePlatformInfoUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Single execute(Device device) { + return cloudRepository.retrieveUri(device.getDeviceId(), OcfResourceUri.PLATFORM_INFO_URI) + .flatMap(uri -> cloudRepository.retrieveEndpoint() + .flatMap(endpoint -> cloudRepository.retrievePlatformInfo(endpoint, uri))); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/RetrieveTokenExpiryUseCase.java b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/RetrieveTokenExpiryUseCase.java new file mode 100644 index 0000000000000000000000000000000000000000..d5df0238c99a766a2c83266420d642dcc53d2667 --- /dev/null +++ b/otgc/src/main/java/org/openconnectivity/otgc/domain/usecase/cloud/RetrieveTokenExpiryUseCase.java @@ -0,0 +1,21 @@ +package org.openconnectivity.otgc.domain.usecase.cloud; + +import org.openconnectivity.otgc.data.repository.CloudRepository; + +import javax.inject.Inject; + +import io.reactivex.Completable; +import io.reactivex.Single; + +public class RetrieveTokenExpiryUseCase { + private final CloudRepository cloudRepository; + + @Inject + public RetrieveTokenExpiryUseCase(CloudRepository cloudRepository) { + this.cloudRepository = cloudRepository; + } + + public Completable execute() { + return cloudRepository.retrieveTokenExpiry(); + } +} diff --git a/otgc/src/main/java/org/openconnectivity/otgc/view/client/GenericClientActivity.java b/otgc/src/main/java/org/openconnectivity/otgc/view/client/GenericClientActivity.java index 08d0030f33f150f8832948fcee16eb47563e931b..dc60f3fbe4dcf5ad0ac5c2f689735833600bcb06 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/view/client/GenericClientActivity.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/view/client/GenericClientActivity.java @@ -44,6 +44,7 @@ import org.openconnectivity.otgc.R; import org.openconnectivity.otgc.domain.model.client.DynamicUiElement; import org.openconnectivity.otgc.domain.model.client.SerializableResource; import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.devicelist.DeviceType; import org.openconnectivity.otgc.domain.model.resource.virtual.d.OcDeviceInfo; import org.openconnectivity.otgc.domain.model.resource.virtual.p.OcPlatformInfo; import org.openconnectivity.otgc.viewmodel.GenericClientViewModel; @@ -92,7 +93,11 @@ public class GenericClientActivity extends AppCompatActivity implements HasSuppo mViewModel.loadDeviceName(mDevice.getDeviceId()); mViewModel.loadDeviceInfo(mDevice); mViewModel.loadPlatformInfo(mDevice); - mViewModel.introspect(mDevice); + if (mDevice.getDeviceType() != DeviceType.CLOUD) { + mViewModel.introspect(mDevice); + } else { + mViewModel.findResources(mDevice); + } } @Override diff --git a/otgc/src/main/java/org/openconnectivity/otgc/view/client/ResourceFragment.java b/otgc/src/main/java/org/openconnectivity/otgc/view/client/ResourceFragment.java index 7753c116ef695cfcc28ab78e1b04bee966a96a93..9a18555f26b8cc71d220823443fbaeca96d10f10 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/view/client/ResourceFragment.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/view/client/ResourceFragment.java @@ -50,6 +50,7 @@ import org.iotivity.OCValue; import org.openconnectivity.otgc.R; import org.openconnectivity.otgc.domain.model.client.SerializableResource; import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.devicelist.DeviceType; import org.openconnectivity.otgc.utils.constant.OcfResourceAttributeKey; import org.openconnectivity.otgc.viewmodel.ResourceViewModel; import org.openconnectivity.otgc.utils.constant.OcfInterface; @@ -119,7 +120,9 @@ public class ResourceFragment extends Fragment implements Injectable { super.onDestroy(); if (mResource.isObservable()) { - mViewModel.cancelObserveRequest(mResource); + if (mDevice.getDeviceType() != DeviceType.CLOUD) { + mViewModel.cancelObserveRequest(mResource); + } } } @@ -149,7 +152,9 @@ public class ResourceFragment extends Fragment implements Injectable { if (isChecked) { mViewModel.observeRequest(mDevice, mResource); } else { - mViewModel.cancelObserveRequest(mResource); + if (mDevice.getDeviceType() != DeviceType.CLOUD) { + mViewModel.cancelObserveRequest(mResource); + } } }); } else { diff --git a/otgc/src/main/java/org/openconnectivity/otgc/view/cloud/CloudActivity.java b/otgc/src/main/java/org/openconnectivity/otgc/view/cloud/CloudActivity.java index a78a5ed0bdbdd1a7770305671cfaa6264fa2a43d..e36cdeb0a3e26f6bf84dbf0db21a7d29980cd7cd 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/view/cloud/CloudActivity.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/view/cloud/CloudActivity.java @@ -135,36 +135,37 @@ public class CloudActivity extends AppCompatActivity implements Injectable { } private void processStatus(@NonNull Integer status) { - // Set value of status - switch(status) { - case OCCloudStatusMask.OC_CLOUD_INITIALIZED: - mLabelStatus.setText("Initialized"); - break; - case OCCloudStatusMask.OC_CLOUD_REGISTERED: - mLabelStatus.setText("Registered"); - break; - case OCCloudStatusMask.OC_CLOUD_LOGGED_IN: - mLabelStatus.setText("Logged in"); - break; - case OCCloudStatusMask.OC_CLOUD_TOKEN_EXPIRY: - mLabelStatus.setText("Token expiry"); - break; - case OCCloudStatusMask.OC_CLOUD_REFRESHED_TOKEN: - mLabelStatus.setText("Refresh token"); - break; - case OCCloudStatusMask.OC_CLOUD_LOGGED_OUT: - mLabelStatus.setText("Logged out"); - break; - case OCCloudStatusMask.OC_CLOUD_FAILURE: - mLabelStatus.setText("Failure"); - break; - case OCCloudStatusMask.OC_CLOUD_DEREGISTERED: - mLabelStatus.setText("Deregistered"); - break; - default: - mLabelStatus.setText("Unknown"); - break; + String value = ""; + if (status == OCCloudStatusMask.OC_CLOUD_INITIALIZED) { + value += "Initialized"; + } + if ((status & OCCloudStatusMask.OC_CLOUD_REGISTERED) == OCCloudStatusMask.OC_CLOUD_REGISTERED) { + value += "Registered"; } + if ((status & OCCloudStatusMask.OC_CLOUD_LOGGED_IN) == OCCloudStatusMask.OC_CLOUD_LOGGED_IN) { + value += ", logged in"; + } + if ((status & OCCloudStatusMask.OC_CLOUD_TOKEN_EXPIRY) == OCCloudStatusMask.OC_CLOUD_TOKEN_EXPIRY) { + value += ", token expiry"; + } + if ((status & OCCloudStatusMask.OC_CLOUD_REFRESHED_TOKEN) == OCCloudStatusMask.OC_CLOUD_REFRESHED_TOKEN) { + value += ", refresh token"; + } + if ((status & OCCloudStatusMask.OC_CLOUD_LOGGED_OUT) == OCCloudStatusMask.OC_CLOUD_LOGGED_OUT) { + value += ", logged out"; + } + if ((status & OCCloudStatusMask.OC_CLOUD_FAILURE) == OCCloudStatusMask.OC_CLOUD_FAILURE) { + value += ", failure"; + } + if ((status & OCCloudStatusMask.OC_CLOUD_DEREGISTERED) == OCCloudStatusMask.OC_CLOUD_DEREGISTERED) { + value += "Deregistered"; + } + + if (value.isEmpty()) { + value = "Unknown"; + } + + mLabelStatus.setText(value); } private void processCloudConfiguration(@NonNull OcCloudConfiguration cloudConf) { diff --git a/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DeviceListActivity.java b/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DeviceListActivity.java index 0bef29b67fc26198e2959174a0cc57f673ccc11a..f681a3af64cad2ed94dfa40be2840879857b639e 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DeviceListActivity.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DeviceListActivity.java @@ -32,11 +32,13 @@ import androidx.appcompat.widget.Toolbar; import android.view.ContextThemeWrapper; import android.view.Menu; import android.view.MenuItem; +import android.view.SubMenu; import android.view.View; import android.widget.EditText; import android.widget.ProgressBar; import android.widget.Toast; +import org.iotivity.OCCloudStatusMask; import org.iotivity.OCRandomPinHandler; import org.openconnectivity.otgc.utils.constant.OtgcMode; import org.openconnectivity.otgc.utils.handler.DisplayNotValidCertificateHandler; @@ -76,6 +78,12 @@ public class DeviceListActivity extends AppCompatActivity implements HasSupportF @BindView(R.id.progress_bar) ProgressBar mProgressBar; @BindView(R.id.toolbar) Toolbar mToolbar; + MenuItem cloudRegister; + MenuItem cloudDeregister; + MenuItem cloudLogin; + MenuItem cloudLogout; + MenuItem cloudRefreshToken; + private MenuItem obtMenuItem; private MenuItem clientMenuItem; @@ -180,6 +188,14 @@ public class DeviceListActivity extends AppCompatActivity implements HasSupportF clientMenuItem = item; } else if (title.contains(OtgcMode.OBT.toLowerCase())) { obtMenuItem = item; + } else if (title.equals("cloud")) { + SubMenu submenu = item.getSubMenu(); + + cloudRegister = submenu.findItem(R.id.menu_item_cloud_register); + cloudDeregister = submenu.findItem(R.id.menu_item_cloud_deregister); + cloudLogin = submenu.findItem(R.id.menu_item_cloud_login); + cloudLogout = submenu.findItem(R.id.menu_item_cloud_logout); + cloudRefreshToken = submenu.findItem(R.id.menu_item_cloud_refresh_token); } } @@ -207,9 +223,27 @@ public class DeviceListActivity extends AppCompatActivity implements HasSupportF case R.id.menu_item_trust_anchor: onTrustAnchorManagement(); break; + case R.id.menu_item_cloud: + onRetrieveCloudStatus(); + break; case R.id.menu_item_cloud_configuration: onCloudConfiguration(); break; + case R.id.menu_item_cloud_register: + onCloudRegister(); + break; + case R.id.menu_item_cloud_deregister: + onCloudDeregister(); + break; + case R.id.menu_item_cloud_login: + onCloudLogin(); + break; + case R.id.menu_item_cloud_logout: + onCloudLogout(); + break; + case R.id.menu_item_cloud_refresh_token: + onRefreshToken(); + break; case R.id.menu_item_log: onLogPressed(); break; @@ -245,6 +279,8 @@ public class DeviceListActivity extends AppCompatActivity implements HasSupportF private void initViews() { setSupportActionBar(mToolbar); + + } private void initViewModel() { @@ -264,6 +300,7 @@ public class DeviceListActivity extends AppCompatActivity implements HasSupportF mViewModel.getLogoutResponse().observe(this, this::processLogoutResponse); mViewModel.getConnectedResponse().observe(this, this::processConnectedResponse); mViewModel.getDeviceId().observe(this, mToolbar::setSubtitle); + mViewModel.getStatusResponse().observe(this, this::processStatusResponse); SharedViewModel sharedViewModel = ViewModelProviders.of(this, mViewModelFactory).get(SharedViewModel.class); sharedViewModel.getLoading().observe(this, this::processing); @@ -346,6 +383,82 @@ public class DeviceListActivity extends AppCompatActivity implements HasSupportF } } + private void processStatusResponse(Response response) { + switch (response.status) { + case LOADING: + mProgressBar.setVisibility(View.VISIBLE); + break; + case SUCCESS: + mProgressBar.setVisibility(View.GONE); + int status = response.data; + if (status == OCCloudStatusMask.OC_CLOUD_INITIALIZED) { + cloudRegister.setVisible(true); + cloudDeregister.setVisible(false); + cloudLogin.setVisible(false); + cloudLogout.setVisible(false); + cloudRefreshToken.setVisible(false); + } + if ((status & OCCloudStatusMask.OC_CLOUD_REGISTERED) == OCCloudStatusMask.OC_CLOUD_REGISTERED) { + cloudRegister.setVisible(false); + cloudDeregister.setVisible(true); + cloudLogin.setVisible(true); + cloudLogout.setVisible(false); + cloudRefreshToken.setVisible(true); + } + if ((status & OCCloudStatusMask.OC_CLOUD_LOGGED_IN) == OCCloudStatusMask.OC_CLOUD_LOGGED_IN) { + cloudLogin.setVisible(false); + cloudLogout.setVisible(true); + } + if ((status & OCCloudStatusMask.OC_CLOUD_TOKEN_EXPIRY) == OCCloudStatusMask.OC_CLOUD_TOKEN_EXPIRY) { + mViewModel.retrieveTokenExpiry(); + } + if ((status & OCCloudStatusMask.OC_CLOUD_REFRESHED_TOKEN) == OCCloudStatusMask.OC_CLOUD_REFRESHED_TOKEN) { + mViewModel.refreshToken(); + } + if ((status & OCCloudStatusMask.OC_CLOUD_LOGGED_OUT) == OCCloudStatusMask.OC_CLOUD_LOGGED_OUT) { + cloudLogin.setVisible(true); + cloudLogout.setVisible(false); + } + if ((status & OCCloudStatusMask.OC_CLOUD_DEREGISTERED) == OCCloudStatusMask.OC_CLOUD_DEREGISTERED) { + cloudRegister.setVisible(true); + cloudDeregister.setVisible(false); + cloudLogin.setVisible(false); + cloudLogout.setVisible(false); + cloudRefreshToken.setVisible(false); + } + + break; + default: + mProgressBar.setVisibility(View.GONE); + Toast.makeText(this, R.string.devices_error_cloud_status_failed, Toast.LENGTH_SHORT).show(); + break; + } + } + + private void onRetrieveCloudStatus() { + mViewModel.retrieveCloudStatus(); + } + + private void onCloudRegister() { + mViewModel.cloudRegister(); + } + + private void onCloudDeregister() { + mViewModel.cloudDeregister(); + } + + private void onCloudLogin() { + mViewModel.cloudLogin(); + } + + private void onCloudLogout() { + mViewModel.cloudLogout(); + } + + private void onRefreshToken() { + mViewModel.refreshToken(); + } + private void onSettingsPressed() { Intent settingsIntent = new Intent().setClass(DeviceListActivity.this, SettingsActivity.class); startActivity(settingsIntent); diff --git a/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DoxsListAdapter.java b/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DoxsListAdapter.java index f1cecf5b933b7bd9f444878321ec8822bc70dcfd..eb87c1b4de86c4c25ffec2b0a1a379096ab9ea23 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DoxsListAdapter.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/view/devicelist/DoxsListAdapter.java @@ -132,7 +132,16 @@ public class DoxsListAdapter extends RecyclerView.Adapter mProcessing.setValue(true)) - .doFinally(() -> mProcessing.setValue(false)) - .subscribe( - acl -> { - for (OcAce ace : acl.getAceList()) { - mAce.setValue(ace); - } - // if i can see ACL, i have some permits, so i have to update the DeviceType to OWNED_BY_OTHER_WITH_PERMITS - if (!device.hasACLpermit() - && (device.getDeviceType() == DeviceType.OWNED_BY_OTHER - || device.getDeviceType() == DeviceType.OWNED_BY_OTHER_WITH_PERMITS)) { - mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), - DeviceType.OWNED_BY_OTHER_WITH_PERMITS, - device.getPermits() | Device.ACL_PERMITS) - .subscribeOn(mSchedulersFacade.io()) - .observeOn(mSchedulersFacade.ui()) - .subscribe( - () -> {}, - throwable2 -> mError.setValue(new ViewModelError(Error.DB_ACCESS, null)) - )); + if (device.getDeviceType() != DeviceType.CLOUD) { + mDisposables.add(mRetrieveAclUseCase.execute(device) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .doOnSubscribe(__ -> mProcessing.setValue(true)) + .doFinally(() -> mProcessing.setValue(false)) + .subscribe( + acl -> { + for (OcAce ace : acl.getAceList()) { + mAce.setValue(ace); + } + // if i can see ACL, i have some permits, so i have to update the DeviceType to OWNED_BY_OTHER_WITH_PERMITS + if (!device.hasACLpermit() + && (device.getDeviceType() == DeviceType.OWNED_BY_OTHER + || device.getDeviceType() == DeviceType.OWNED_BY_OTHER_WITH_PERMITS)) { + mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), + DeviceType.OWNED_BY_OTHER_WITH_PERMITS, + device.getPermits() | Device.ACL_PERMITS) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .subscribe( + () -> { + }, + throwable2 -> mError.setValue(new ViewModelError(Error.DB_ACCESS, null)) + )); + } + }, + throwable -> { + mError.setValue(new ViewModelError(Error.RETRIEVE, null)); + + if (device.hasACLpermit()) { + mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), + DeviceType.OWNED_BY_OTHER, + device.getPermits() & ~Device.ACL_PERMITS) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .subscribe( + () -> { + }, + throwable2 -> mError.setValue(new ViewModelError(Error.DB_ACCESS, null)) + )); + } } - }, - throwable -> { - mError.setValue(new ViewModelError(Error.RETRIEVE, null)); - - if (device.hasACLpermit()) { - mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), - DeviceType.OWNED_BY_OTHER, - device.getPermits() & ~Device.ACL_PERMITS) - .subscribeOn(mSchedulersFacade.io()) - .observeOn(mSchedulersFacade.ui()) - .subscribe( - () -> {}, - throwable2 -> mError.setValue(new ViewModelError(Error.DB_ACCESS, null)) - )); - } - } - )); + )); + } } public void deleteAce(Device device, long aceId) { diff --git a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/AceViewModel.java b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/AceViewModel.java index c4aa167ec38afd19a44694203346c3300856be80..db6a318060c94ce3c4ec39887156528888be7a0d 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/AceViewModel.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/AceViewModel.java @@ -27,6 +27,7 @@ import androidx.lifecycle.MutableLiveData; import androidx.lifecycle.ViewModel; import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.devicelist.DeviceType; import org.openconnectivity.otgc.domain.usecase.accesscontrol.CreateAclUseCase; import org.openconnectivity.otgc.domain.usecase.RetrieveVerticalResourcesUseCase; import org.openconnectivity.otgc.utils.viewmodel.ViewModelError; @@ -87,17 +88,19 @@ public class AceViewModel extends ViewModel { } public void retrieveResources(Device device) { - mDisposables.add(mRetrieveVerticalResourcesUseCase.execute(device) - .subscribeOn(mSchedulersFacade.io()) - .observeOn(mSchedulersFacade.ui()) - .doOnSubscribe(__ -> mProcessing.setValue(true)) - .doFinally(() -> mProcessing.setValue(false)) - .subscribe( - mResources::setValue, - throwable -> { - mError.setValue(new ViewModelError(Error.RETRIEVE_RESOURCES, null)); - } - )); + if (device.getDeviceType() != DeviceType.CLOUD) { + mDisposables.add(mRetrieveVerticalResourcesUseCase.execute(device) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .doOnSubscribe(__ -> mProcessing.setValue(true)) + .doFinally(() -> mProcessing.setValue(false)) + .subscribe( + mResources::setValue, + throwable -> { + mError.setValue(new ViewModelError(Error.RETRIEVE_RESOURCES, null)); + } + )); + } } public void createAce(Device device, String subjectId, int permission, List resources) { diff --git a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/CredentialsViewModel.java b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/CredentialsViewModel.java index ae344a9572b06b7f2c9a3a338ce90648b08febd0..60005fb8b6c1a2e66e65ed849f0f4ceda59df63a 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/CredentialsViewModel.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/CredentialsViewModel.java @@ -76,46 +76,50 @@ public class CredentialsViewModel extends BaseViewModel { } public void retrieveCredentials(Device device) { - mDisposables.add(mRetrieveCredentialsUseCase.execute(device) - .subscribeOn(mSchedulersFacade.io()) - .observeOn(mSchedulersFacade.ui()) - .doOnSubscribe(__ -> mProcessing.setValue(true)) - .doFinally(() -> mProcessing.setValue(false)) - .subscribe( - credentials -> { - for (OcCredential cred : credentials.getCredList()) { - mCredential.setValue(cred); + if (device.getDeviceType() != DeviceType.CLOUD) { + mDisposables.add(mRetrieveCredentialsUseCase.execute(device) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .doOnSubscribe(__ -> mProcessing.setValue(true)) + .doFinally(() -> mProcessing.setValue(false)) + .subscribe( + credentials -> { + for (OcCredential cred : credentials.getCredList()) { + mCredential.setValue(cred); + } + + if (!device.hasCREDpermit() + && (device.getDeviceType() == DeviceType.OWNED_BY_OTHER + || device.getDeviceType() == DeviceType.OWNED_BY_OTHER_WITH_PERMITS)) { + mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), + DeviceType.OWNED_BY_OTHER_WITH_PERMITS, + device.getPermits() | Device.CRED_PERMITS) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .subscribe( + () -> { + }, + throwable -> mError.setValue(new ViewModelError(Error.DB_ERROR, null)) + )); + } + }, + throwable -> { + mError.setValue(new ViewModelError(Error.RETRIEVE_CREDS, null)); + if (device.hasCREDpermit()) { + mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), + DeviceType.OWNED_BY_OTHER, + device.getPermits() & ~Device.CRED_PERMITS) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .subscribe( + () -> { + }, + throwable2 -> mError.setValue(new ViewModelError(Error.DB_ERROR, null)) + )); + } } - - if (!device.hasCREDpermit() - && (device.getDeviceType() == DeviceType.OWNED_BY_OTHER - || device.getDeviceType() == DeviceType.OWNED_BY_OTHER_WITH_PERMITS)) { - mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), - DeviceType.OWNED_BY_OTHER_WITH_PERMITS, - device.getPermits() | Device.CRED_PERMITS) - .subscribeOn(mSchedulersFacade.io()) - .observeOn(mSchedulersFacade.ui()) - .subscribe( - () -> {}, - throwable -> mError.setValue(new ViewModelError(Error.DB_ERROR, null)) - )); - } - }, - throwable -> { - mError.setValue(new ViewModelError(Error.RETRIEVE_CREDS, null)); - if (device.hasCREDpermit()) { - mDisposables.add(mUpdateDeviceTypeUseCase.execute(device.getDeviceId(), - DeviceType.OWNED_BY_OTHER, - device.getPermits() & ~Device.CRED_PERMITS) - .subscribeOn(mSchedulersFacade.io()) - .observeOn(mSchedulersFacade.ui()) - .subscribe( - () -> {}, - throwable2 -> mError.setValue(new ViewModelError(Error.DB_ERROR, null)) - )); - } - } - )); + )); + } } public void deleteCredential(Device device, long credId) { diff --git a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DeviceListViewModel.java b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DeviceListViewModel.java index b8385b3ac3580fb2dca5fc0da6ad361d2ce96d9f..b5c520bd46c9ee7e916292f1f44f669ea6d79385 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DeviceListViewModel.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DeviceListViewModel.java @@ -35,6 +35,13 @@ import org.openconnectivity.otgc.domain.usecase.ResetClientModeUseCase; import org.openconnectivity.otgc.domain.usecase.ResetObtModeUseCase; import org.openconnectivity.otgc.domain.usecase.SetClientModeUseCase; import org.openconnectivity.otgc.domain.usecase.SetObtModeUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudDeregisterUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudLoginUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudLogoutUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudRefreshTokenUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudRegisterUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.RetrieveStatusUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.RetrieveTokenExpiryUseCase; import org.openconnectivity.otgc.domain.usecase.wifi.CheckConnectionUseCase; import org.openconnectivity.otgc.domain.usecase.InitializeIotivityUseCase; import org.openconnectivity.otgc.domain.usecase.login.LogoutUseCase; @@ -67,6 +74,13 @@ public class DeviceListViewModel extends ViewModel { private final ResetObtModeUseCase resetObtModeUseCase; private final CheckConnectionUseCase mCheckConnectionUseCase; private final GetDeviceIdUseCase mGetDeviceIdUseCase; + private final RetrieveStatusUseCase retrieveStatusUseCase; + private final CloudRegisterUseCase cloudRegisterUseCase; + private final CloudDeregisterUseCase cloudDeregisterUseCase; + private final CloudLoginUseCase cloudLoginUseCase; + private final CloudLogoutUseCase cloudLogoutUseCase; + private final CloudRefreshTokenUseCase refreshTokenUseCase; + private final RetrieveTokenExpiryUseCase retrieveTokenExpiryUseCase; private final SchedulersFacade schedulersFacade; @@ -81,6 +95,7 @@ public class DeviceListViewModel extends ViewModel { private final MutableLiveData> logoutResponse = new MutableLiveData<>(); private final MutableLiveData> connectedResponse = new MutableLiveData<>(); private final MutableLiveData mDeviceId = new MutableLiveData<>(); + private final MutableLiveData> statusResponse = new MutableLiveData<>(); @Inject DeviceListViewModel( @@ -96,6 +111,13 @@ public class DeviceListViewModel extends ViewModel { ResetObtModeUseCase resetObtModeUseCase, CheckConnectionUseCase checkConnectionUseCase, GetDeviceIdUseCase getDeviceIdUseCase, + RetrieveStatusUseCase retrieveStatusUseCase, + CloudRegisterUseCase cloudRegisterUseCase, + CloudDeregisterUseCase cloudDeregisterUseCase, + CloudLoginUseCase cloudLoginUseCase, + CloudLogoutUseCase cloudLogoutUseCase, + CloudRefreshTokenUseCase refreshTokenUseCase, + RetrieveTokenExpiryUseCase retrieveTokenExpiryUseCase, SchedulersFacade schedulersFacade) { this.mInitializeIotivityUseCase = initializeIotivityUseCase; this.mGetModeUseCase = getModeUseCase; @@ -109,6 +131,13 @@ public class DeviceListViewModel extends ViewModel { this.resetObtModeUseCase = resetObtModeUseCase; this.mCheckConnectionUseCase = checkConnectionUseCase; this.mGetDeviceIdUseCase = getDeviceIdUseCase; + this.retrieveStatusUseCase = retrieveStatusUseCase; + this.cloudRegisterUseCase = cloudRegisterUseCase; + this.cloudDeregisterUseCase = cloudDeregisterUseCase; + this.cloudLoginUseCase = cloudLoginUseCase; + this.cloudLogoutUseCase = cloudLogoutUseCase; + this.refreshTokenUseCase = refreshTokenUseCase; + this.retrieveTokenExpiryUseCase = retrieveTokenExpiryUseCase; this.schedulersFacade = schedulersFacade; } @@ -150,6 +179,10 @@ public class DeviceListViewModel extends ViewModel { return mDeviceId; } + public LiveData> getStatusResponse() { + return statusResponse; + } + public void initializeIotivityStack(Context context, DisplayNotValidCertificateHandler displayNotValidCertificateHandler) { disposables.add(mInitializeIotivityUseCase.execute(context, displayNotValidCertificateHandler) .subscribeOn(schedulersFacade.io()) @@ -172,6 +205,76 @@ public class DeviceListViewModel extends ViewModel { )); } + public void retrieveCloudStatus() { + disposables.add(retrieveStatusUseCase.execute() + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .subscribe( + status -> statusResponse.setValue(Response.success(status)), + throwable -> statusResponse.setValue(Response.error(throwable)) + )); + } + + public void cloudRegister() { + disposables.add(cloudRegisterUseCase.execute() + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .subscribe( + status -> statusResponse.setValue(Response.success(status)), + throwable -> statusResponse.setValue(Response.error(throwable)) + )); + } + + public void cloudDeregister() { + disposables.add(cloudDeregisterUseCase.execute() + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .subscribe( + status -> statusResponse.setValue(Response.success(status)), + throwable -> statusResponse.setValue(Response.error(throwable)) + )); + } + + public void cloudLogin() { + disposables.add(cloudLoginUseCase.execute() + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .subscribe( + status -> statusResponse.setValue(Response.success(status)), + throwable -> statusResponse.setValue(Response.error(throwable)) + )); + } + + public void cloudLogout() { + disposables.add(cloudLogoutUseCase.execute() + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .subscribe( + status -> statusResponse.setValue(Response.success(status)), + throwable -> statusResponse.setValue(Response.error(throwable)) + )); + } + + public void retrieveTokenExpiry() { + disposables.add(retrieveTokenExpiryUseCase.execute() + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .subscribe( + () -> {}, + throwable -> {} + )); + } + + public void refreshToken() { + disposables.add(refreshTokenUseCase.execute() + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .subscribe( + status -> statusResponse.setValue(Response.success(status)), + throwable -> statusResponse.setValue(Response.error(throwable)) + )); + } + public void closeIotivityStack() { closeIotivityUseCase.execute(); } diff --git a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DoxsViewModel.java b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DoxsViewModel.java index 0734824549e7a6a807412464eca8ac57bbaa130b..e2ea5eaf54889099741f80911e859f223d090dcd 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DoxsViewModel.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/DoxsViewModel.java @@ -30,6 +30,9 @@ import org.openconnectivity.otgc.domain.usecase.GetDeviceIdUseCase; import org.openconnectivity.otgc.domain.usecase.GetModeUseCase; import org.openconnectivity.otgc.domain.usecase.OnboardDevicesUseCase; import org.openconnectivity.otgc.domain.usecase.accesscontrol.CreateAclUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudDiscoverDevicesUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudRetrieveDeviceInfoUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudRetrieveDeviceRoleUseCase; import org.openconnectivity.otgc.domain.usecase.wifi.CheckConnectionUseCase; import org.openconnectivity.otgc.domain.usecase.GetDeviceInfoUseCase; import org.openconnectivity.otgc.domain.model.exception.NetworkDisconnectedException; @@ -59,9 +62,12 @@ import org.openconnectivity.otgc.domain.usecase.wifi.ScanWiFiNetworksUseCase; import java.util.Arrays; import java.util.List; +import java.util.concurrent.TimeUnit; import javax.inject.Inject; +import io.reactivex.Observable; + public class DoxsViewModel extends BaseViewModel { private final CheckConnectionUseCase mCheckConnectionUseCase; @@ -82,6 +88,9 @@ public class DoxsViewModel extends BaseViewModel { private final UnlinkDevicesUseCase mUnlinkDevicesUseCase; private final GetDeviceDatabaseUseCase mGetDeviceDatabaseUseCase; private final GetDeviceIdUseCase mGetDeviceIdUseCase; + private final CloudDiscoverDevicesUseCase cloudDiscoverDevicesUseCase; + private final CloudRetrieveDeviceInfoUseCase cloudRetrieveDeviceInfoUseCase; + private final CloudRetrieveDeviceRoleUseCase cloudRetrieveDeviceRoleUseCase; private final SchedulersFacade mSchedulersFacade; @@ -125,7 +134,10 @@ public class DoxsViewModel extends BaseViewModel { UnlinkDevicesUseCase unlinkDevicesUseCase, GetDeviceDatabaseUseCase getDeviceDatabaseUseCase, GetDeviceIdUseCase getDeviceIdUseCase, - SchedulersFacade schedulersFacade) { + SchedulersFacade schedulersFacade, + CloudDiscoverDevicesUseCase cloudDiscoverDevicesUseCase, + CloudRetrieveDeviceInfoUseCase cloudRetrieveDeviceInfoUseCase, + CloudRetrieveDeviceRoleUseCase cloudRetrieveDeviceRoleUseCase) { this.mCheckConnectionUseCase = checkConnectionUseCase; this.mGetModeUseCase = getModeUseCase; this.mScanDevicesUseCase = scanDevicesUseCase; @@ -144,6 +156,9 @@ public class DoxsViewModel extends BaseViewModel { this.mUnlinkDevicesUseCase = unlinkDevicesUseCase; this.mGetDeviceDatabaseUseCase = getDeviceDatabaseUseCase; this.mGetDeviceIdUseCase = getDeviceIdUseCase; + this.cloudDiscoverDevicesUseCase = cloudDiscoverDevicesUseCase; + this.cloudRetrieveDeviceInfoUseCase = cloudRetrieveDeviceInfoUseCase; + this.cloudRetrieveDeviceRoleUseCase = cloudRetrieveDeviceRoleUseCase; this.mSchedulersFacade = schedulersFacade; @@ -217,28 +232,40 @@ public class DoxsViewModel extends BaseViewModel { } public void onScanRequested() { - mDisposables.add(mCheckConnectionUseCase.executeCompletable() - .andThen(mScanDevicesUseCase.execute() - .map(device -> { - device.setDeviceInfo(mGetDeviceInfoUseCase.execute(device).blockingGet()); - return device; - }) - .map(device -> { - device.setDeviceRole( - mGetDeviceRoleUseCase.execute(device).blockingGet()); - return device; - }) - .map(device -> { - if (device.getDeviceType().equals(DeviceType.OWNED_BY_SELF)) { - String storedDeviceName = mGetDeviceNameUseCase.execute(device.getDeviceId()).blockingGet(); - if (storedDeviceName != null && !storedDeviceName.isEmpty()) { - device.getDeviceInfo().setName(storedDeviceName); - } - } + Observable localScan = mScanDevicesUseCase.execute() + .map(device -> { + device.setDeviceInfo(mGetDeviceInfoUseCase.execute(device).blockingGet()); + return device; + }) + .map(device -> { + device.setDeviceRole( + mGetDeviceRoleUseCase.execute(device).blockingGet()); + return device; + }) + .map(device -> { + if (device.getDeviceType().equals(DeviceType.OWNED_BY_SELF)) { + String storedDeviceName = mGetDeviceNameUseCase.execute(device.getDeviceId()).blockingGet(); + if (storedDeviceName != null && !storedDeviceName.isEmpty()) { + device.getDeviceInfo().setName(storedDeviceName); + } + } + + return device; + }); + + Observable cloudScan = cloudDiscoverDevicesUseCase.execute() + .delay(5, TimeUnit.SECONDS) + .map(device -> { + device.setDeviceInfo(cloudRetrieveDeviceInfoUseCase.execute(device).blockingGet()); + return device; + }) + .map(device -> { + device.setDeviceRole(cloudRetrieveDeviceRoleUseCase.execute(device).blockingGet()); + return device; + }); - return device; - }) - ) + mDisposables.add(mCheckConnectionUseCase.executeCompletable() + .andThen(Observable.concat(localScan, cloudScan)) .subscribeOn(mSchedulersFacade.io()) .observeOn(mSchedulersFacade.ui()) .doOnSubscribe(__ -> mProcessing.setValue(true)) diff --git a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/GenericClientViewModel.java b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/GenericClientViewModel.java index 43e280987fc14c882ec338374cec800ead316edb..f7c20aab04ca000e06279f2bdf690dc235da8b34 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/GenericClientViewModel.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/GenericClientViewModel.java @@ -27,6 +27,7 @@ import androidx.lifecycle.MutableLiveData; import org.openconnectivity.otgc.domain.model.client.DynamicUiElement; import org.openconnectivity.otgc.domain.model.client.SerializableResource; import org.openconnectivity.otgc.domain.model.devicelist.Device; +import org.openconnectivity.otgc.domain.model.devicelist.DeviceType; import org.openconnectivity.otgc.domain.model.resource.virtual.d.OcDeviceInfo; import org.openconnectivity.otgc.domain.model.resource.virtual.p.OcPlatformInfo; import org.openconnectivity.otgc.domain.usecase.GetDeviceInfoUseCase; @@ -35,6 +36,11 @@ import org.openconnectivity.otgc.domain.usecase.GetResourcesUseCase; import org.openconnectivity.otgc.domain.usecase.client.IntrospectUseCase; import org.openconnectivity.otgc.domain.usecase.client.UiFromSwaggerUseCase; import org.openconnectivity.otgc.domain.usecase.GetDeviceNameUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudDiscoverResourcesUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudGetResourceUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudPostResourceUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudRetrieveDeviceInfoUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudRetrievePlatformInfoUseCase; import org.openconnectivity.otgc.utils.viewmodel.BaseViewModel; import org.openconnectivity.otgc.utils.viewmodel.ViewModelError; import org.openconnectivity.otgc.utils.viewmodel.ViewModelErrorType; @@ -44,6 +50,8 @@ import java.util.List; import javax.inject.Inject; +import io.reactivex.Single; + public class GenericClientViewModel extends BaseViewModel { private final GetDeviceNameUseCase mGetDeviceNameUseCase; @@ -52,6 +60,9 @@ public class GenericClientViewModel extends BaseViewModel { private final GetResourcesUseCase mGetResourcesUseCase; private final IntrospectUseCase mIntrospectUseCase; private final UiFromSwaggerUseCase mUiFromSwaggerUseCase; + private final CloudRetrieveDeviceInfoUseCase cloudRetrieveDeviceInfoUseCase; + private final CloudRetrievePlatformInfoUseCase cloudRetrievePlatformInfoUseCase; + private final CloudDiscoverResourcesUseCase cloudDiscoverResourcesUseCase; private final SchedulersFacade schedulersFacade; @@ -69,7 +80,10 @@ public class GenericClientViewModel extends BaseViewModel { GetResourcesUseCase getResourcesUseCase, IntrospectUseCase introspectUseCase, UiFromSwaggerUseCase uiFromSwaggerUseCase, - SchedulersFacade schedulersFacade) { + SchedulersFacade schedulersFacade, + CloudRetrieveDeviceInfoUseCase cloudRetrieveDeviceInfoUseCase, + CloudRetrievePlatformInfoUseCase cloudRetrievePlatformInfoUseCase, + CloudDiscoverResourcesUseCase cloudDiscoverResourcesUseCase) { this.mGetDeviceNameUseCase = getDeviceNameUseCase; this.mGetDeviceInfoUseCase = getDeviceInfoUseCase; this.mGetPlatformInfoUseCase = getPlatformInfoUseCase; @@ -77,6 +91,9 @@ public class GenericClientViewModel extends BaseViewModel { this.mIntrospectUseCase = introspectUseCase; this.mUiFromSwaggerUseCase = uiFromSwaggerUseCase; this.schedulersFacade = schedulersFacade; + this.cloudRetrieveDeviceInfoUseCase = cloudRetrieveDeviceInfoUseCase; + this.cloudRetrievePlatformInfoUseCase = cloudRetrievePlatformInfoUseCase; + this.cloudDiscoverResourcesUseCase = cloudDiscoverResourcesUseCase; } public LiveData getDeviceName() { @@ -112,7 +129,11 @@ public class GenericClientViewModel extends BaseViewModel { } public void loadDeviceInfo(Device device) { - mDisposables.add(mGetDeviceInfoUseCase.execute(device) + Single deviceInfoSingle = device.getDeviceType() != DeviceType.CLOUD + ? mGetDeviceInfoUseCase.execute(device) + : cloudRetrieveDeviceInfoUseCase.execute(device); + + mDisposables.add(deviceInfoSingle .subscribeOn(schedulersFacade.io()) .observeOn(schedulersFacade.ui()) .doOnSubscribe(__ -> mProcessing.setValue(true)) @@ -124,7 +145,11 @@ public class GenericClientViewModel extends BaseViewModel { } public void loadPlatformInfo(Device device) { - mDisposables.add(mGetPlatformInfoUseCase.execute(device) + Single platformInfoSingle = device.getDeviceType() != DeviceType.CLOUD + ? mGetPlatformInfoUseCase.execute(device) + : cloudRetrievePlatformInfoUseCase.execute(device); + + mDisposables.add(platformInfoSingle .subscribeOn(schedulersFacade.io()) .observeOn(schedulersFacade.ui()) .doOnSubscribe(__ -> mProcessing.setValue(true)) @@ -136,20 +161,26 @@ public class GenericClientViewModel extends BaseViewModel { } public void introspect(Device device) { - mDisposables.add(mIntrospectUseCase.execute(device) - .flatMap(mUiFromSwaggerUseCase::execute) - .subscribeOn(schedulersFacade.io()) - .observeOn(schedulersFacade.ui()) - .doOnSubscribe(__ -> mProcessing.setValue(true)) - .subscribe( - mIntrospection::setValue, - throwable -> mError.setValue( - new ViewModelError(Error.INTROSPECTION, null)) - )); + if (device.getDeviceType() != DeviceType.CLOUD) { + mDisposables.add(mIntrospectUseCase.execute(device) + .flatMap(mUiFromSwaggerUseCase::execute) + .subscribeOn(schedulersFacade.io()) + .observeOn(schedulersFacade.ui()) + .doOnSubscribe(__ -> mProcessing.setValue(true)) + .subscribe( + mIntrospection::setValue, + throwable -> mError.setValue( + new ViewModelError(Error.INTROSPECTION, null)) + )); + } } public void findResources(Device device) { - mDisposables.add(mGetResourcesUseCase.execute(device) + Single> discoverResourcesSingle = device.getDeviceType() != DeviceType.CLOUD + ? mGetResourcesUseCase.execute(device) + : cloudDiscoverResourcesUseCase.execute(device); + + mDisposables.add(discoverResourcesSingle .subscribeOn(schedulersFacade.io()) .observeOn(schedulersFacade.ui()) .doOnSubscribe(__ -> mProcessing.setValue(true)) diff --git a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/ResourceViewModel.java b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/ResourceViewModel.java index e29d2e64e78439555b38112ccbf2f271add0a4c3..d6f957cc0ccb067b41377cfa3962ae253c1d0c35 100644 --- a/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/ResourceViewModel.java +++ b/otgc/src/main/java/org/openconnectivity/otgc/viewmodel/ResourceViewModel.java @@ -34,6 +34,8 @@ import org.openconnectivity.otgc.domain.usecase.client.CancelObserveResourceUseC import org.openconnectivity.otgc.domain.usecase.client.GetRequestUseCase; import org.openconnectivity.otgc.domain.usecase.client.ObserveResourceUseCase; import org.openconnectivity.otgc.domain.usecase.client.PostRequestUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudGetResourceUseCase; +import org.openconnectivity.otgc.domain.usecase.cloud.CloudPostResourceUseCase; import org.openconnectivity.otgc.utils.viewmodel.ViewModelError; import org.openconnectivity.otgc.utils.viewmodel.ViewModelErrorType; import org.openconnectivity.otgc.utils.rx.SchedulersFacade; @@ -43,6 +45,8 @@ import java.util.Map; import javax.inject.Inject; +import io.reactivex.Completable; +import io.reactivex.Single; import io.reactivex.disposables.CompositeDisposable; public class ResourceViewModel extends ViewModel { @@ -52,6 +56,8 @@ public class ResourceViewModel extends ViewModel { private final ObserveResourceUseCase mObserveResource; private final CancelObserveResourceUseCase mCancelObserveResourceUseCase; private final UpdateDeviceTypeUseCase mUpdateDeviceTypeUseCase; + private final CloudGetResourceUseCase cloudGetResourceUseCase; + private final CloudPostResourceUseCase cloudPostResourceUseCase; private final SchedulersFacade mSchedulersFacade; @@ -69,12 +75,16 @@ public class ResourceViewModel extends ViewModel { ObserveResourceUseCase observeResource, CancelObserveResourceUseCase cancelObserveResourceUseCase, UpdateDeviceTypeUseCase updateDeviceTypeUseCase, - SchedulersFacade schedulersFacade) { + SchedulersFacade schedulersFacade, + CloudGetResourceUseCase cloudGetResourceUseCase, + CloudPostResourceUseCase cloudPostResourceUseCase) { this.mGetRequestUseCase = getRequestUseCase; this.mPostRequestUseCase = postRequestUseCase; this.mObserveResource = observeResource; this.mCancelObserveResourceUseCase = cancelObserveResourceUseCase; this.mUpdateDeviceTypeUseCase = updateDeviceTypeUseCase; + this.cloudGetResourceUseCase = cloudGetResourceUseCase; + this.cloudPostResourceUseCase = cloudPostResourceUseCase; this.mSchedulersFacade = schedulersFacade; } @@ -97,7 +107,11 @@ public class ResourceViewModel extends ViewModel { } public void getRequest(Device device, SerializableResource resource) { - disposables.add(mGetRequestUseCase.execute(device, resource) + Single getResourceSingle = device.getDeviceType() != DeviceType.CLOUD + ? mGetRequestUseCase.execute(device, resource) + : cloudGetResourceUseCase.execute(device, resource); + + disposables.add(getResourceSingle .subscribeOn(mSchedulersFacade.io()) .observeOn(mSchedulersFacade.ui()) .subscribe( @@ -136,13 +150,15 @@ public class ResourceViewModel extends ViewModel { } public void observeRequest(Device device, SerializableResource resource) { - disposables.add(mObserveResource.execute(device, resource) - .subscribeOn(mSchedulersFacade.io()) - .observeOn(mSchedulersFacade.ui()) - .subscribe( - mResponse::setValue, - throwable -> mError.setValue(new ViewModelError(Error.OBSERVE, null)) - )); + if (device.getDeviceType() != DeviceType.CLOUD) { + disposables.add(mObserveResource.execute(device, resource) + .subscribeOn(mSchedulersFacade.io()) + .observeOn(mSchedulersFacade.ui()) + .subscribe( + mResponse::setValue, + throwable -> mError.setValue(new ViewModelError(Error.OBSERVE, null)) + )); + } } public void cancelObserveRequest(SerializableResource resource) { @@ -156,7 +172,11 @@ public class ResourceViewModel extends ViewModel { } public void postRequest(Device device, SerializableResource resource, OCRepresentation rep, Object valueArray) { - disposables.add(mPostRequestUseCase.execute(device, resource, rep, valueArray) + Completable postResourceCompletable = device.getDeviceType() != DeviceType.CLOUD + ? mPostRequestUseCase.execute(device, resource, rep, valueArray) + : cloudPostResourceUseCase.execute(device, resource, rep, valueArray); + + disposables.add(postResourceCompletable .subscribeOn(mSchedulersFacade.io()) .observeOn(mSchedulersFacade.ui()) .subscribe( @@ -169,7 +189,11 @@ public class ResourceViewModel extends ViewModel { } public void postRequest(Device device, SerializableResource resource, Map values) { - disposables.add(mPostRequestUseCase.execute(device, resource, values) + Completable postResourceCompletable = device.getDeviceType() != DeviceType.CLOUD + ? mPostRequestUseCase.execute(device, resource, values) + : cloudPostResourceUseCase.execute(device, resource, values); + + disposables.add(postResourceCompletable .subscribeOn(mSchedulersFacade.io()) .observeOn(mSchedulersFacade.ui()) .subscribe( diff --git a/otgc/src/main/res/layout/fragment_resource.xml b/otgc/src/main/res/layout/fragment_resource.xml index ff8e43a77c98d4b15d5de7aafce2047d4c224e31..4153a28bdfcefbc2218a0b67aaed0662d381b706 100644 --- a/otgc/src/main/res/layout/fragment_resource.xml +++ b/otgc/src/main/res/layout/fragment_resource.xml @@ -55,7 +55,7 @@ + + + + + Modo OBT Gestión de certificados Configuración + Registrar + Desregistrar + Iniciar sesión + Cerrar sesión + Refrescar Token + Error al recuperar el estado del cloud Mostrar trazas Ajustes Sin nombre diff --git a/otgc/src/main/res/values/colors.xml b/otgc/src/main/res/values/colors.xml index 1a5c9a5bac14af631822b61b141caa3a94277a94..f82580f765223d5cd74c5a9d9085618928019fa4 100644 --- a/otgc/src/main/res/values/colors.xml +++ b/otgc/src/main/res/values/colors.xml @@ -42,6 +42,7 @@ #f58220 #fcc509 + #8e44ad #717271 #78777a diff --git a/otgc/src/main/res/values/strings.xml b/otgc/src/main/res/values/strings.xml index 08e9d22e943546e63ebbf3278958fc9d00e956b0..faa6a2f73c8235adbdab42220d2b3abb4da1f6ad 100644 --- a/otgc/src/main/res/values/strings.xml +++ b/otgc/src/main/res/values/strings.xml @@ -135,6 +135,12 @@ Certificate Management Cloud Configuration + Register + Deregister + Log in + Log out + Refresh Token + Retrieve cloud status has failed Show log Settings Sign out