Examples with LwM2mClient org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient used on opensource projects

Example 6 with LwM2mClient

use of org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient in project thingsboard by thingsboard.

the class LwM2MTestClient method awaitClientAfterStartConnectLw.

private void awaitClientAfterStartConnectLw() {
    LwM2mClient lwM2MClient = this.clientContext.getClientByEndpoint(endpoint);
    CountDownLatch latch = new CountDownLatch(1);
    Mockito.doAnswer(invocation -> {
        latch.countDown();
        return null;
    }).when(defaultLwM2mUplinkMsgHandlerTest).initAttributes(lwM2MClient, true);
    try {
        if (!latch.await(1, TimeUnit.SECONDS)) {
            throw new RuntimeException("Failed to await TimeOut lwm2m client initialization!");
        }
    } catch (InterruptedException e) {
        throw new RuntimeException("Exception Failed to await lwm2m client initialization! ", e);
    }
}

Example 7 with LwM2mClient

use of org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient in project thingsboard by thingsboard.

the class LwM2MClientSerDes method deserialize.

@SneakyThrows
public static LwM2mClient deserialize(byte[] data) {
    JsonObject o = Json.parse(new String(data)).asObject();
    LwM2mClient lwM2mClient = new LwM2mClient(o.get("nodeId").asString(), o.get("endpoint").asString());
    o.get("resources").asObject().forEach(entry -> {
        JsonObject resource = entry.getValue().asObject();
        LwM2mResource lwM2mResource = parseLwM2mResource(resource.get("lwM2mResource").asObject());
        ResourceModel resourceModel = parseResourceModel(resource.get("resourceModel").asObject());
        ResourceValue resourceValue = new ResourceValue(lwM2mResource, resourceModel);
        lwM2mClient.getResources().put(entry.getName(), resourceValue);
    });
    for (JsonObject.Member entry : o.get("sharedAttributes").asObject()) {
        TransportProtos.TsKvProto.Builder builder = TransportProtos.TsKvProto.newBuilder();
        JsonFormat.parser().merge(entry.getValue().asString(), builder);
        lwM2mClient.getSharedAttributes().put(entry.getName(), builder.build());
    }
    o.get("keyTsLatestMap").asObject().forEach(entry -> {
        lwM2mClient.getKeyTsLatestMap().put(entry.getName(), new AtomicLong(entry.getValue().asLong()));
    });
    lwM2mClient.setState(LwM2MClientState.valueOf(o.get("state").asString()));
    Class<LwM2mClient> lwM2mClientClass = LwM2mClient.class;
    JsonValue session = o.get("session");
    if (session != null) {
        TransportProtos.SessionInfoProto.Builder builder = TransportProtos.SessionInfoProto.newBuilder();
        JsonFormat.parser().merge(session.asString(), builder);
        Field sessionField = lwM2mClientClass.getDeclaredField("session");
        sessionField.setAccessible(true);
        sessionField.set(lwM2mClient, builder.build());
    }
    JsonValue tenantId = o.get("tenantId");
    if (tenantId != null) {
        Field tenantIdField = lwM2mClientClass.getDeclaredField("tenantId");
        tenantIdField.setAccessible(true);
        tenantIdField.set(lwM2mClient, new TenantId(UUID.fromString(tenantId.asString())));
    }
    JsonValue deviceId = o.get("deviceId");
    if (tenantId != null) {
        Field deviceIdField = lwM2mClientClass.getDeclaredField("deviceId");
        deviceIdField.setAccessible(true);
        deviceIdField.set(lwM2mClient, UUID.fromString(deviceId.asString()));
    }
    JsonValue profileId = o.get("profileId");
    if (tenantId != null) {
        Field profileIdField = lwM2mClientClass.getDeclaredField("profileId");
        profileIdField.setAccessible(true);
        profileIdField.set(lwM2mClient, UUID.fromString(profileId.asString()));
    }
    JsonValue powerMode = o.get("powerMode");
    if (powerMode != null) {
        Field powerModeField = lwM2mClientClass.getDeclaredField("powerMode");
        powerModeField.setAccessible(true);
        powerModeField.set(lwM2mClient, PowerMode.valueOf(powerMode.asString()));
    }
    JsonValue edrxCycle = o.get("edrxCycle");
    if (edrxCycle != null) {
        Field edrxCycleField = lwM2mClientClass.getDeclaredField("edrxCycle");
        edrxCycleField.setAccessible(true);
        edrxCycleField.set(lwM2mClient, edrxCycle.asLong());
    }
    JsonValue psmActivityTimer = o.get("psmActivityTimer");
    if (psmActivityTimer != null) {
        Field psmActivityTimerField = lwM2mClientClass.getDeclaredField("psmActivityTimer");
        psmActivityTimerField.setAccessible(true);
        psmActivityTimerField.set(lwM2mClient, psmActivityTimer.asLong());
    }
    JsonValue pagingTransmissionWindow = o.get("pagingTransmissionWindow");
    if (pagingTransmissionWindow != null) {
        Field pagingTransmissionWindowField = lwM2mClientClass.getDeclaredField("pagingTransmissionWindow");
        pagingTransmissionWindowField.setAccessible(true);
        pagingTransmissionWindowField.set(lwM2mClient, pagingTransmissionWindow.asLong());
    }
    JsonValue registration = o.get("registration");
    if (registration != null) {
        lwM2mClient.setRegistration(RegistrationSerDes.deserialize(registration.asObject()));
    }
    lwM2mClient.setAsleep(o.get("asleep").asBoolean());
    Field lastUplinkTimeField = lwM2mClientClass.getDeclaredField("lastUplinkTime");
    lastUplinkTimeField.setAccessible(true);
    lastUplinkTimeField.setLong(lwM2mClient, o.get("lastUplinkTime").asLong());
    Field firstEdrxDownlinkField = lwM2mClientClass.getDeclaredField("firstEdrxDownlink");
    firstEdrxDownlinkField.setAccessible(true);
    firstEdrxDownlinkField.setBoolean(lwM2mClient, o.get("firstEdrxDownlink").asBoolean());
    lwM2mClient.getRetryAttempts().set(o.get("retryAttempts").asInt());
    JsonValue lastSentRpcId = o.get("lastSentRpcId");
    if (lastSentRpcId != null) {
        lwM2mClient.setLastSentRpcId(UUID.fromString(lastSentRpcId.asString()));
    }
    return lwM2mClient;
}

Example 8 with LwM2mClient

use of org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient in project thingsboard by thingsboard.

the class DefaultLwM2mUplinkMsgHandler method onUpdateValueAfterReadCompositeResponse.

public void onUpdateValueAfterReadCompositeResponse(Registration registration, ReadCompositeResponse response) {
    log.trace("ReadCompositeResponse: [{}]", response);
    if (response.getContent() != null) {
        LwM2mClient lwM2MClient = clientContext.getClientByEndpoint(registration.getEndpoint());
        response.getContent().forEach((k, v) -> {
            if (v != null) {
                int responseCode = response.getCode().getCode();
                if (v instanceof LwM2mObject) {
                    this.updateObjectResourceValue(lwM2MClient, (LwM2mObject) v, k.toString(), responseCode);
                } else if (v instanceof LwM2mObjectInstance) {
                    this.updateObjectInstanceResourceValue(lwM2MClient, (LwM2mObjectInstance) v, k.toString(), responseCode);
                } else if (v instanceof LwM2mResource) {
                    this.updateResourcesValue(lwM2MClient, (LwM2mResource) v, k.toString(), Mode.UPDATE, responseCode);
                }
            }
        });
        clientContext.update(lwM2MClient);
        if (clientContext.awake(lwM2MClient)) {
            // clientContext.awake calls clientContext.update
            log.debug("[{}] Device is awake", lwM2MClient.getEndpoint());
        } else {
            clientContext.update(lwM2MClient);
        }
    }
}

Example 9 with LwM2mClient

use of org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient in project thingsboard by thingsboard.

the class DefaultLwM2mUplinkMsgHandler method onUpdateValueAfterReadResponse.

/**
 * Sending observe value to thingsboard from ObservationListener.onResponse: object, instance, SingleResource or MultipleResource
 *
 * @param registration - Registration LwM2M Client
 * @param path         - observe
 * @param response     - observe
 */
@Override
public void onUpdateValueAfterReadResponse(Registration registration, String path, ReadResponse response) {
    LwM2mNode content = response.getContent();
    if (content != null) {
        LwM2mClient lwM2MClient = clientContext.getClientByEndpoint(registration.getEndpoint());
        ObjectModel objectModelVersion = lwM2MClient.getObjectModel(path, modelProvider);
        if (objectModelVersion != null) {
            int responseCode = response.getCode().getCode();
            if (content instanceof LwM2mObject) {
                LwM2mObject lwM2mObject = (LwM2mObject) content;
                this.updateObjectResourceValue(lwM2MClient, lwM2mObject, path, responseCode);
            } else if (content instanceof LwM2mObjectInstance) {
                LwM2mObjectInstance lwM2mObjectInstance = (LwM2mObjectInstance) content;
                this.updateObjectInstanceResourceValue(lwM2MClient, lwM2mObjectInstance, path, responseCode);
            } else if (content instanceof LwM2mResource) {
                LwM2mResource lwM2mResource = (LwM2mResource) content;
                this.updateResourcesValue(lwM2MClient, lwM2mResource, path, Mode.UPDATE, responseCode);
            }
        }
        if (clientContext.awake(lwM2MClient)) {
            // clientContext.awake calls clientContext.update
            log.debug("[{}] Device is awake", lwM2MClient.getEndpoint());
        } else {
            clientContext.update(lwM2MClient);
        }
    }
}

Example 10 with LwM2mClient

use of org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient in project thingsboard by thingsboard.

the class DefaultLwM2mUplinkMsgHandler method onDeviceProfileUpdate.

// TODO: review and optimize the logic to minimize number of the requests to device.
private void onDeviceProfileUpdate(List<LwM2mClient> clients, Lwm2mDeviceProfileTransportConfiguration oldProfile, DeviceProfile deviceProfile) {
    if (clientContext.profileUpdate(deviceProfile) != null) {
        TelemetryMappingConfiguration oldTelemetryParams = oldProfile.getObserveAttr();
        Set<String> attributeSetOld = oldTelemetryParams.getAttribute();
        Set<String> telemetrySetOld = oldTelemetryParams.getTelemetry();
        Set<String> observeOld = oldTelemetryParams.getObserve();
        Map<String, String> keyNameOld = oldTelemetryParams.getKeyName();
        Map<String, ObjectAttributes> attributeLwm2mOld = oldTelemetryParams.getAttributeLwm2m();
        var newProfile = clientContext.getProfile(deviceProfile.getUuidId());
        TelemetryMappingConfiguration newTelemetryParams = newProfile.getObserveAttr();
        Set<String> attributeSetNew = newTelemetryParams.getAttribute();
        Set<String> telemetrySetNew = newTelemetryParams.getTelemetry();
        Set<String> observeNew = newTelemetryParams.getObserve();
        Map<String, String> keyNameNew = newTelemetryParams.getKeyName();
        Map<String, ObjectAttributes> attributeLwm2mNew = newTelemetryParams.getAttributeLwm2m();
        Set<String> observeToAdd = diffSets(observeOld, observeNew);
        Set<String> observeToRemove = diffSets(observeNew, observeOld);
        Set<String> newObjectsToRead = new HashSet<>();
        Set<String> newObjectsToCancelRead = new HashSet<>();
        if (!attributeSetOld.equals(attributeSetNew)) {
            newObjectsToRead.addAll(diffSets(attributeSetOld, attributeSetNew));
            newObjectsToCancelRead.addAll(diffSets(attributeSetNew, attributeSetOld));
        }
        if (!telemetrySetOld.equals(telemetrySetNew)) {
            newObjectsToRead.addAll(diffSets(telemetrySetOld, telemetrySetNew));
            newObjectsToCancelRead.addAll(diffSets(telemetrySetNew, telemetrySetOld));
        }
        if (!keyNameOld.equals(keyNameNew)) {
            ParametersAnalyzeResult keyNameChange = this.getAnalyzerKeyName(keyNameOld, keyNameNew);
            newObjectsToRead.addAll(keyNameChange.getPathPostParametersAdd());
        }
        ParametersAnalyzeResult analyzerParameters = getAttributesAnalyzer(attributeLwm2mOld, attributeLwm2mNew);
        clients.forEach(client -> {
            LwM2MModelConfig modelConfig = new LwM2MModelConfig(client.getEndpoint());
            modelConfig.getToRead().addAll(diffSets(observeToAdd, newObjectsToRead));
            modelConfig.getToCancelRead().addAll(newObjectsToCancelRead);
            modelConfig.getToCancelObserve().addAll(observeToRemove);
            modelConfig.getToObserve().addAll(observeToAdd);
            Set<String> clientObjects = clientContext.getSupportedIdVerInClient(client);
            Set<String> pathToAdd = analyzerParameters.getPathPostParametersAdd().stream().filter(target -> clientObjects.contains("/" + target.split(LWM2M_SEPARATOR_PATH)[1])).collect(Collectors.toUnmodifiableSet());
            modelConfig.getAttributesToAdd().putAll(pathToAdd.stream().collect(Collectors.toMap(t -> t, attributeLwm2mNew::get)));
            Set<String> pathToRemove = analyzerParameters.getPathPostParametersDel().stream().filter(target -> clientObjects.contains("/" + target.split(LWM2M_SEPARATOR_PATH)[1])).collect(Collectors.toUnmodifiableSet());
            modelConfig.getAttributesToRemove().addAll(pathToRemove);
            modelConfigService.sendUpdates(client, modelConfig);
        });
        // update value in fwInfo
        OtherConfiguration newLwM2mSettings = newProfile.getClientLwM2mSettings();
        OtherConfiguration oldLwM2mSettings = oldProfile.getClientLwM2mSettings();
        if (!newLwM2mSettings.getFwUpdateStrategy().equals(oldLwM2mSettings.getFwUpdateStrategy()) || (StringUtils.isNotEmpty(newLwM2mSettings.getFwUpdateResource()) && !newLwM2mSettings.getFwUpdateResource().equals(oldLwM2mSettings.getFwUpdateResource()))) {
            clients.forEach(lwM2MClient -> otaService.onFirmwareStrategyUpdate(lwM2MClient, newLwM2mSettings));
        }
        if (!newLwM2mSettings.getSwUpdateStrategy().equals(oldLwM2mSettings.getSwUpdateStrategy()) || (StringUtils.isNotEmpty(newLwM2mSettings.getSwUpdateResource()) && !newLwM2mSettings.getSwUpdateResource().equals(oldLwM2mSettings.getSwUpdateResource()))) {
            clients.forEach(lwM2MClient -> otaService.onCurrentSoftwareStrategyUpdate(lwM2MClient, newLwM2mSettings));
        }
    }
}