Merge pull request #4760 from thingsboard/feature/lwm2m-refactoring-downlink

Lwm2m Refactoring Downlink

@@ -677,12 +677,11 @@ transport:
     timeout: "${LWM2M_TIMEOUT:120000}"
     timeout: "${LWM2M_TIMEOUT:120000}"
     recommended_ciphers: "${LWM2M_RECOMMENDED_CIPHERS:false}"
     recommended_ciphers: "${LWM2M_RECOMMENDED_CIPHERS:false}"
     recommended_supported_groups: "${LWM2M_RECOMMENDED_SUPPORTED_GROUPS:true}"
     recommended_supported_groups: "${LWM2M_RECOMMENDED_SUPPORTED_GROUPS:true}"
-    response_pool_size: "${LWM2M_RESPONSE_POOL_SIZE:100}"
-    registered_pool_size: "${LWM2M_REGISTERED_POOL_SIZE:10}"
+    uplink_pool_size: "${LWM2M_UPLINK_POOL_SIZE:10}"
+    downlink_pool_size: "${LWM2M_DOWNLINK_POOL_SIZE:10}"
+    ota_pool_size: "${LWM2M_OTA_POOL_SIZE:10}"
     registration_store_pool_size: "${LWM2M_REGISTRATION_STORE_POOL_SIZE:100}"
     registration_store_pool_size: "${LWM2M_REGISTRATION_STORE_POOL_SIZE:100}"
     clean_period_in_sec: "${LWM2M_CLEAN_PERIOD_IN_SEC:2}"
     clean_period_in_sec: "${LWM2M_CLEAN_PERIOD_IN_SEC:2}"
-    update_registered_pool_size: "${LWM2M_UPDATE_REGISTERED_POOL_SIZE:10}"
-    un_registered_pool_size: "${LWM2M_UN_REGISTERED_POOL_SIZE:10}"
     log_max_length: "${LWM2M_LOG_MAX_LENGTH:100}"
     log_max_length: "${LWM2M_LOG_MAX_LENGTH:100}"
     # Use redis for Security and Registration stores
     # Use redis for Security and Registration stores
     redis.enabled: "${LWM2M_REDIS_ENABLED:false}"
     redis.enabled: "${LWM2M_REDIS_ENABLED:false}"

@@ -103,7 +103,9 @@ public class AbstractLwM2MIntegrationTest extends AbstractWebsocketTest {
             "    }\n" +
             "    }\n" +
             "  },\n" +
             "  },\n" +
             "  \"clientLwM2mSettings\": {\n" +
             "  \"clientLwM2mSettings\": {\n" +
-            "    \"clientOnlyObserveAfterConnect\": 1\n" +
+            "    \"clientOnlyObserveAfterConnect\": 1,\n" +
+            "    \"fwUpdateStrategy\": 1,\n" +
+            "    \"swUpdateStrategy\": 1\n" +
             "  }\n" +
             "  }\n" +
             "}";
             "}";
 
 

@@ -17,11 +17,14 @@ package org.thingsboard.server.transport.lwm2m;
 
 
 import org.eclipse.californium.core.network.config.NetworkConfig;
 import org.eclipse.californium.core.network.config.NetworkConfig;
 import org.eclipse.leshan.client.object.Security;
 import org.eclipse.leshan.client.object.Security;
-import org.jetbrains.annotations.NotNull;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.Test;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.test.web.servlet.request.MockMultipartHttpServletRequestBuilder;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.OtaPackageInfo;
 import org.thingsboard.server.common.data.device.credentials.lwm2m.NoSecClientCredentials;
 import org.thingsboard.server.common.data.device.credentials.lwm2m.NoSecClientCredentials;
 import org.thingsboard.server.common.data.query.EntityData;
 import org.thingsboard.server.common.data.query.EntityData;
 import org.thingsboard.server.common.data.query.EntityDataPageLink;
 import org.thingsboard.server.common.data.query.EntityDataPageLink;
@@ -43,6 +46,7 @@ import java.util.List;
 
 
 import static org.eclipse.leshan.client.object.Security.noSec;
 import static org.eclipse.leshan.client.object.Security.noSec;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.thingsboard.server.common.data.ota.OtaPackageType.FIRMWARE;
 
 
 public class NoSecLwM2MIntegrationTest extends AbstractLwM2MIntegrationTest {
 public class NoSecLwM2MIntegrationTest extends AbstractLwM2MIntegrationTest {
 
 
@@ -51,7 +55,6 @@ public class NoSecLwM2MIntegrationTest extends AbstractLwM2MIntegrationTest {
     private final NetworkConfig COAP_CONFIG = new NetworkConfig().setString("COAP_PORT", Integer.toString(PORT));
     private final NetworkConfig COAP_CONFIG = new NetworkConfig().setString("COAP_PORT", Integer.toString(PORT));
     private final String ENDPOINT = "deviceAEndpoint";
     private final String ENDPOINT = "deviceAEndpoint";
 
 
-    @NotNull
     private Device createDevice() throws Exception {
     private Device createDevice() throws Exception {
         Device device = new Device();
         Device device = new Device();
         device.setName("Device A");
         device.setName("Device A");
@@ -74,6 +77,29 @@ public class NoSecLwM2MIntegrationTest extends AbstractLwM2MIntegrationTest {
         return device;
         return device;
     }
     }
 
 
+    private OtaPackageInfo createFirmware() throws Exception {
+        String CHECKSUM = "4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a";
+
+        OtaPackageInfo firmwareInfo = new OtaPackageInfo();
+        firmwareInfo.setDeviceProfileId(deviceProfile.getId());
+        firmwareInfo.setType(FIRMWARE);
+        firmwareInfo.setTitle("My firmware");
+        firmwareInfo.setVersion("v1.0");
+
+        OtaPackageInfo savedFirmwareInfo = doPost("/api/otaPackage", firmwareInfo, OtaPackageInfo.class);
+
+        MockMultipartFile testData = new MockMultipartFile("file", "filename.txt", "text/plain", new byte[]{1});
+
+        return savaData("/api/otaPackage/" + savedFirmwareInfo.getId().getId().toString() + "?checksum={checksum}&checksumAlgorithm={checksumAlgorithm}", testData, CHECKSUM, "SHA256");
+    }
+
+    protected OtaPackageInfo savaData(String urlTemplate, MockMultipartFile content, String... params) throws Exception {
+        MockMultipartHttpServletRequestBuilder postRequest = MockMvcRequestBuilders.multipart(urlTemplate, params);
+        postRequest.file(content);
+        setJwtToken(postRequest);
+        return readResponse(mockMvc.perform(postRequest).andExpect(status().isOk()), OtaPackageInfo.class);
+    }
+
     @Test
     @Test
     public void testConnectAndObserveTelemetry() throws Exception {
     public void testConnectAndObserveTelemetry() throws Exception {
         createDeviceProfile(TRANSPORT_CONFIGURATION);
         createDeviceProfile(TRANSPORT_CONFIGURATION);
@@ -111,4 +137,53 @@ public class NoSecLwM2MIntegrationTest extends AbstractLwM2MIntegrationTest {
         client.destroy();
         client.destroy();
     }
     }
 
 
+    @Test
+    public void testFirmwareUpdateWithClientWithoutFirmwareInfo() throws Exception {
+        createDeviceProfile(TRANSPORT_CONFIGURATION);
+
+        Device device = createDevice();
+
+        OtaPackageInfo firmware = createFirmware();
+
+        LwM2MTestClient client = new LwM2MTestClient(executor, ENDPOINT);
+        client.init(SECURITY, COAP_CONFIG);
+
+        Thread.sleep(1000);
+
+        device.setFirmwareId(firmware.getId());
+
+        device = doPost("/api/device", device, Device.class);
+
+        Thread.sleep(1000);
+
+        SingleEntityFilter sef = new SingleEntityFilter();
+        sef.setSingleEntity(device.getId());
+        LatestValueCmd latestCmd = new LatestValueCmd();
+        latestCmd.setKeys(Collections.singletonList(new EntityKey(EntityKeyType.TIME_SERIES, "fw_state")));
+        EntityDataQuery edq = new EntityDataQuery(sef, new EntityDataPageLink(1, 0, null, null),
+                Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
+
+        EntityDataCmd cmd = new EntityDataCmd(1, edq, null, latestCmd, null);
+        TelemetryPluginCmdsWrapper wrapper = new TelemetryPluginCmdsWrapper();
+        wrapper.setEntityDataCmds(Collections.singletonList(cmd));
+
+        wsClient.send(mapper.writeValueAsString(wrapper));
+        wsClient.waitForReply();
+
+        wsClient.registerWaitForUpdate();
+
+        String msg = wsClient.waitForUpdate();
+
+        EntityDataUpdate update = mapper.readValue(msg, EntityDataUpdate.class);
+        Assert.assertEquals(1, update.getCmdId());
+        List<EntityData> eData = update.getUpdate();
+        Assert.assertNotNull(eData);
+        Assert.assertEquals(1, eData.size());
+        Assert.assertEquals(device.getId(), eData.get(0).getEntityId());
+        Assert.assertNotNull(eData.get(0).getLatest().get(EntityKeyType.TIME_SERIES));
+        var tsValue = eData.get(0).getLatest().get(EntityKeyType.TIME_SERIES).get("fw_state");
+        Assert.assertEquals("FAILED", tsValue.getValue());
+        client.destroy();
+    }
+
 }
 }

@@ -52,7 +52,6 @@ public class X509LwM2MIntegrationTest extends AbstractLwM2MIntegrationTest {
     private final String endpoint = "deviceAEndpoint";
     private final String endpoint = "deviceAEndpoint";
     private final String serverUri = "coaps://localhost:" + port;
     private final String serverUri = "coaps://localhost:" + port;
 
 
-    @NotNull
     private Device createDevice(X509ClientCredentials clientCredentials) throws Exception {
     private Device createDevice(X509ClientCredentials clientCredentials) throws Exception {
         Device device = new Device();
         Device device = new Device();
         device.setName("Device A");
         device.setName("Device A");

@@ -19,8 +19,10 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter;
 import com.fasterxml.jackson.annotation.JsonAnySetter;
 import com.fasterxml.jackson.annotation.JsonAnySetter;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.Data;
 import lombok.Data;
-import org.thingsboard.server.common.data.DeviceProfileType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.device.data.lwm2m.BootstrapConfiguration;
+import org.thingsboard.server.common.data.device.data.lwm2m.OtherConfiguration;
+import org.thingsboard.server.common.data.device.data.lwm2m.TelemetryMappingConfiguration;
 
 
 import java.util.HashMap;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map;

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.device.data.lwm2m;
+
+import lombok.Data;
+
+import java.util.Map;
+
+@Data
+public class BootstrapConfiguration {
+
+    //TODO: define the objects;
+    private Map<String, Object> servers;
+    private Map<String, Object> lwm2mServer;
+    private Map<String, Object> bootstrapServer;
+
+}

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.device.data.lwm2m;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import lombok.Data;
+
+@Data
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class ObjectAttributes {
+
+    private Long dim;
+    private String ver;
+    private Long pmin;
+    private Long pmax;
+    private Double gt;
+    private Double lt;
+    private Double st;
+
+}

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.device.data.lwm2m;
+
+import lombok.Data;
+
+@Data
+public class OtherConfiguration {
+
+    private Integer fwUpdateStrategy;
+    private Integer swUpdateStrategy;
+    private Integer clientOnlyObserveAfterConnect;
+    private String fwUpdateRecourse;
+    private String swUpdateRecourse;
+
+}

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.device.data.lwm2m;
+
+import lombok.Data;
+
+import java.util.Map;
+import java.util.Set;
+
+@Data
+public class TelemetryMappingConfiguration {
+
+    private Map<String, String> keyName;
+    private Set<String> observe;
+    private Set<String> attribute;
+    private Set<String> telemetry;
+    private Map<String, ObjectAttributes> attributeLwm2m;
+
+}

@@ -15,31 +15,20 @@
  */
  */
 package org.thingsboard.server.common.data.device.profile;
 package org.thingsboard.server.common.data.device.profile;
 
 
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.Data;
 import lombok.Data;
-import org.thingsboard.server.common.data.DeviceProfileType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.DeviceTransportType;
-
-import java.util.HashMap;
-import java.util.Map;
+import org.thingsboard.server.common.data.device.data.lwm2m.BootstrapConfiguration;
+import org.thingsboard.server.common.data.device.data.lwm2m.OtherConfiguration;
+import org.thingsboard.server.common.data.device.data.lwm2m.TelemetryMappingConfiguration;
 
 
 @Data
 @Data
 public class Lwm2mDeviceProfileTransportConfiguration implements DeviceProfileTransportConfiguration {
 public class Lwm2mDeviceProfileTransportConfiguration implements DeviceProfileTransportConfiguration {
 
 
-    @JsonIgnore
-    private Map<String, Object> properties = new HashMap<>();
-
-    @JsonAnyGetter
-    public Map<String, Object> properties() {
-        return this.properties;
-    }
+    private static final long serialVersionUID = 6257277825459600068L;
 
 
-    @JsonAnySetter
-    public void put(String name, Object value) {
-        this.properties.put(name, value);
-    }
+    private TelemetryMappingConfiguration observeAttr;
+    private BootstrapConfiguration bootstrap;
+    private OtherConfiguration clientLwM2mSettings;
 
 
     @Override
     @Override
     public DeviceTransportType getType() {
     public DeviceTransportType getType() {

@@ -134,8 +134,8 @@ public class OtaPackageTransportResource extends AbstractCoapTransportResource {
             response.setPayload(data);
             response.setPayload(data);
             if (exchange.getRequestOptions().getBlock2() != null) {
             if (exchange.getRequestOptions().getBlock2() != null) {
                 int chunkSize = exchange.getRequestOptions().getBlock2().getSzx();
                 int chunkSize = exchange.getRequestOptions().getBlock2().getSzx();
-                boolean moreFlag = data.length > chunkSize;
-                response.getOptions().setBlock2(chunkSize, moreFlag, 0);
+                boolean lastFlag = data.length > chunkSize;
+                response.getOptions().setBlock2(chunkSize, lastFlag, 0);
             }
             }
             exchange.respond(response);
             exchange.respond(response);
         }
         }

@@ -15,9 +15,6 @@
  */
  */
 package org.thingsboard.server.transport.lwm2m.bootstrap.secure;
 package org.thingsboard.server.transport.lwm2m.bootstrap.secure;
 
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.gson.JsonObject;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.leshan.core.SecurityMode;
 import org.eclipse.leshan.core.SecurityMode;
 import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.core.util.Hex;
@@ -29,6 +26,8 @@ import org.eclipse.leshan.server.security.BootstrapSecurityStore;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
+import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.common.data.device.data.lwm2m.BootstrapConfiguration;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MSecurityInfo;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MSecurityInfo;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2mCredentialsSecurityInfoValidator;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2mCredentialsSecurityInfoValidator;
@@ -43,12 +42,9 @@ import java.util.Collections;
 import java.util.Iterator;
 import java.util.Iterator;
 import java.util.UUID;
 import java.util.UUID;
 
 
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.BOOTSTRAP_SERVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_ERROR;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_INFO;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_TELEMETRY;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LWM2M_SERVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SERVERS;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LWM2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LWM2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LWM2M_TELEMETRY;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.getBootstrapParametersFromThingsboard;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.getBootstrapParametersFromThingsboard;
 
 
 @Slf4j
 @Slf4j
@@ -151,35 +147,30 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
     }
     }
 
 
     private LwM2MBootstrapConfig getParametersBootstrap(TbLwM2MSecurityInfo store) {
     private LwM2MBootstrapConfig getParametersBootstrap(TbLwM2MSecurityInfo store) {
-        try {
-            LwM2MBootstrapConfig lwM2MBootstrapConfig = store.getBootstrapCredentialConfig();
-            if (lwM2MBootstrapConfig != null) {
-                ObjectMapper mapper = new ObjectMapper();
-                JsonObject bootstrapObject = getBootstrapParametersFromThingsboard(store.getDeviceProfile());
-                lwM2MBootstrapConfig.servers = mapper.readValue(bootstrapObject.get(SERVERS).toString(), LwM2MBootstrapServers.class);
-                LwM2MServerBootstrap profileServerBootstrap = mapper.readValue(bootstrapObject.get(BOOTSTRAP_SERVER).toString(), LwM2MServerBootstrap.class);
-                LwM2MServerBootstrap profileLwm2mServer = mapper.readValue(bootstrapObject.get(LWM2M_SERVER).toString(), LwM2MServerBootstrap.class);
-                UUID sessionUUiD = UUID.randomUUID();
-                TransportProtos.SessionInfoProto sessionInfo = helper.getValidateSessionInfo(store.getMsg(), sessionUUiD.getMostSignificantBits(), sessionUUiD.getLeastSignificantBits());
-                context.getTransportService().registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(null, sessionInfo));
-                if (this.getValidatedSecurityMode(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap, lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer)) {
-                    lwM2MBootstrapConfig.bootstrapServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap);
-                    lwM2MBootstrapConfig.lwm2mServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer);
-                    String logMsg = String.format("%s: getParametersBootstrap: %s Access connect client with bootstrap server.", LOG_LW2M_INFO, store.getEndpoint());
-                    helper.sendParametersOnThingsboardTelemetry(helper.getKvStringtoThingsboard(LOG_LW2M_TELEMETRY, logMsg), sessionInfo);
-                    return lwM2MBootstrapConfig;
-                } else {
-                    log.error(" [{}] Different values SecurityMode between of client and profile.", store.getEndpoint());
-                    log.error("{} getParametersBootstrap: [{}] Different values SecurityMode between of client and profile.", LOG_LW2M_ERROR, store.getEndpoint());
-                    String logMsg = String.format("%s: getParametersBootstrap: %s Different values SecurityMode between of client and profile.", LOG_LW2M_ERROR, store.getEndpoint());
-                    helper.sendParametersOnThingsboardTelemetry(helper.getKvStringtoThingsboard(LOG_LW2M_TELEMETRY, logMsg), sessionInfo);
-                    return null;
-                }
+        LwM2MBootstrapConfig lwM2MBootstrapConfig = store.getBootstrapCredentialConfig();
+        if (lwM2MBootstrapConfig != null) {
+            BootstrapConfiguration bootstrapObject = getBootstrapParametersFromThingsboard(store.getDeviceProfile());
+            lwM2MBootstrapConfig.servers = JacksonUtil.fromString(JacksonUtil.toString(bootstrapObject.getServers()), LwM2MBootstrapServers.class);
+            LwM2MServerBootstrap profileServerBootstrap = JacksonUtil.fromString(JacksonUtil.toString(bootstrapObject.getBootstrapServer()), LwM2MServerBootstrap.class);
+            LwM2MServerBootstrap profileLwm2mServer = JacksonUtil.fromString(JacksonUtil.toString(bootstrapObject.getLwm2mServer()), LwM2MServerBootstrap.class);
+            UUID sessionUUiD = UUID.randomUUID();
+            TransportProtos.SessionInfoProto sessionInfo = helper.getValidateSessionInfo(store.getMsg(), sessionUUiD.getMostSignificantBits(), sessionUUiD.getLeastSignificantBits());
+            context.getTransportService().registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(null, null, null, sessionInfo));
+            if (this.getValidatedSecurityMode(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap, lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer)) {
+                lwM2MBootstrapConfig.bootstrapServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap);
+                lwM2MBootstrapConfig.lwm2mServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer);
+                String logMsg = String.format("%s: getParametersBootstrap: %s Access connect client with bootstrap server.", LOG_LWM2M_INFO, store.getEndpoint());
+                helper.sendParametersOnThingsboardTelemetry(helper.getKvStringtoThingsboard(LOG_LWM2M_TELEMETRY, logMsg), sessionInfo);
+                return lwM2MBootstrapConfig;
+            } else {
+                log.error(" [{}] Different values SecurityMode between of client and profile.", store.getEndpoint());
+                log.error("{} getParametersBootstrap: [{}] Different values SecurityMode between of client and profile.", LOG_LWM2M_ERROR, store.getEndpoint());
+                String logMsg = String.format("%s: getParametersBootstrap: %s Different values SecurityMode between of client and profile.", LOG_LWM2M_ERROR, store.getEndpoint());
+                helper.sendParametersOnThingsboardTelemetry(helper.getKvStringtoThingsboard(LOG_LWM2M_TELEMETRY, logMsg), sessionInfo);
+                return null;
             }
             }
-        } catch (JsonProcessingException e) {
-            log.error("Unable to decode Json or Certificate for [{}]  [{}]", store.getEndpoint(), e.getMessage());
-            return null;
         }
         }
+
         log.error("Unable to decode Json or Certificate for [{}]", store.getEndpoint());
         log.error("Unable to decode Json or Certificate for [{}]", store.getEndpoint());
         return null;
         return null;
     }
     }

@@ -57,30 +57,22 @@ public class LwM2MTransportServerConfig implements LwM2MSecureServerConfig {
     private boolean recommendedSupportedGroups;
     private boolean recommendedSupportedGroups;
 
 
     @Getter
     @Getter
-    @Value("${transport.lwm2m.response_pool_size:}")
-    private int responsePoolSize;
+    @Value("${transport.lwm2m.downlink_pool_size:}")
+    private int downlinkPoolSize;
 
 
     @Getter
     @Getter
-    @Value("${transport.lwm2m.registered_pool_size:}")
-    private int registeredPoolSize;
+    @Value("${transport.lwm2m.uplink_pool_size:}")
+    private int uplinkPoolSize;
 
 
     @Getter
     @Getter
-    @Value("${transport.lwm2m.registration_store_pool_size:}")
-    private int registrationStorePoolSize;
+    @Value("${transport.lwm2m.ota_pool_size:}")
+    private int otaPoolSize;
 
 
     @Getter
     @Getter
     @Value("${transport.lwm2m.clean_period_in_sec:}")
     @Value("${transport.lwm2m.clean_period_in_sec:}")
     private int cleanPeriodInSec;
     private int cleanPeriodInSec;
 
 
     @Getter
     @Getter
-    @Value("${transport.lwm2m.update_registered_pool_size:}")
-    private int updateRegisteredPoolSize;
-
-    @Getter
-    @Value("${transport.lwm2m.un_registered_pool_size:}")
-    private int unRegisteredPoolSize;
-
-    @Getter
     @Value("${transport.lwm2m.security.key_store_type:}")
     @Value("${transport.lwm2m.security.key_store_type:}")
     private String keyStoreType;
     private String keyStoreType;
 
 

-/**
- * Copyright © 2016-2021 The Thingsboard Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.thingsboard.server.transport.lwm2m.server;
-
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.reflect.TypeToken;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.eclipse.leshan.core.model.ObjectModel;
-import org.eclipse.leshan.core.model.ResourceModel;
-import org.eclipse.leshan.core.node.LwM2mObject;
-import org.eclipse.leshan.core.node.LwM2mObjectInstance;
-import org.eclipse.leshan.core.node.LwM2mPath;
-import org.eclipse.leshan.core.node.LwM2mResource;
-import org.eclipse.leshan.core.observation.Observation;
-import org.eclipse.leshan.core.request.WriteRequest;
-import org.eclipse.leshan.core.response.ReadResponse;
-import org.eclipse.leshan.server.registration.Registration;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Service;
-import org.thingsboard.common.util.JacksonUtil;
-import org.thingsboard.common.util.ThingsBoardExecutors;
-import org.thingsboard.server.cache.ota.OtaPackageDataCache;
-import org.thingsboard.server.common.data.Device;
-import org.thingsboard.server.common.data.DeviceProfile;
-import org.thingsboard.server.common.data.id.OtaPackageId;
-import org.thingsboard.server.common.data.ota.OtaPackageKey;
-import org.thingsboard.server.common.data.ota.OtaPackageType;
-import org.thingsboard.server.common.data.ota.OtaPackageUtil;
-import org.thingsboard.server.common.transport.TransportService;
-import org.thingsboard.server.common.transport.TransportServiceCallback;
-import org.thingsboard.server.common.transport.adaptor.AdaptorException;
-import org.thingsboard.server.common.transport.service.DefaultTransportService;
-import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.gen.transport.TransportProtos.AttributeUpdateNotificationMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.SessionEvent;
-import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
-import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
-import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
-import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper;
-import org.thingsboard.server.transport.lwm2m.server.adaptors.LwM2MJsonAdaptor;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClientState;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClientStateException;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientProfile;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientRpcRequest;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mFwSwUpdate;
-import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
-import org.thingsboard.server.transport.lwm2m.server.client.ResultsAddKeyValueProto;
-import org.thingsboard.server.transport.lwm2m.server.client.ResultsAnalyzerParameters;
-import org.thingsboard.server.transport.lwm2m.server.store.TbLwM2MDtlsSessionStore;
-import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
-
-import javax.annotation.PostConstruct;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Random;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-import static org.eclipse.californium.core.coap.CoAP.ResponseCode.BAD_REQUEST;
-import static org.eclipse.leshan.core.attributes.Attribute.OBJECT_VERSION;
-import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_PATH;
-import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.FAILED;
-import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.INITIATED;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportServerHelper.getValueFromKvProto;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.DEVICE_ATTRIBUTES_REQUEST;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_5_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_RESULT_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_STATE_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_ERROR;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_INFO;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_TELEMETRY;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_VALUE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_WARN;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.DISCOVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE_CANCEL;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE_CANCEL_ALL;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.READ;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_ATTRIBUTES;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_REPLACE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SW_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertJsonArrayToSet;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertOtaUpdateValueToString;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromIdVerToObjectId;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromObjectIdToIdVer;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.getAckCallback;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.isFwSwWords;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.setValidTypeOper;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.validateObjectVerFromKey;
-
-
-@Slf4j
-@Service
-@TbLwM2mTransportComponent
-public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler {
-
-    private ExecutorService registrationExecutor;
-    private ExecutorService updateRegistrationExecutor;
-    private ExecutorService unRegistrationExecutor;
-    public LwM2mValueConverterImpl converter;
-
-    private final TransportService transportService;
-    private final LwM2mTransportContext context;
-    public final LwM2MTransportServerConfig config;
-    public final OtaPackageDataCache otaPackageDataCache;
-    public final LwM2mTransportServerHelper helper;
-    private final LwM2MJsonAdaptor adaptor;
-    private final TbLwM2MDtlsSessionStore sessionStore;
-    public final LwM2mClientContext clientContext;
-    public final LwM2mTransportRequest lwM2mTransportRequest;
-    private final Map<UUID, Long> rpcSubscriptions;
-    public final Map<String, Integer> firmwareUpdateState;
-
-    public DefaultLwM2MTransportMsgHandler(TransportService transportService, LwM2MTransportServerConfig config, LwM2mTransportServerHelper helper,
-                                           LwM2mClientContext clientContext,
-                                           @Lazy LwM2mTransportRequest lwM2mTransportRequest,
-                                           OtaPackageDataCache otaPackageDataCache,
-                                           LwM2mTransportContext context, LwM2MJsonAdaptor adaptor, TbLwM2MDtlsSessionStore sessionStore) {
-        this.transportService = transportService;
-        this.config = config;
-        this.helper = helper;
-        this.clientContext = clientContext;
-        this.lwM2mTransportRequest = lwM2mTransportRequest;
-        this.otaPackageDataCache = otaPackageDataCache;
-        this.context = context;
-        this.adaptor = adaptor;
-        this.rpcSubscriptions = new ConcurrentHashMap<>();
-        this.firmwareUpdateState = new ConcurrentHashMap<>();
-        this.sessionStore = sessionStore;
-    }
-
-    @PostConstruct
-    public void init() {
-        this.context.getScheduler().scheduleAtFixedRate(this::reportActivity, new Random().nextInt((int) config.getSessionReportTimeout()), config.getSessionReportTimeout(), TimeUnit.MILLISECONDS);
-        this.registrationExecutor = ThingsBoardExecutors.newWorkStealingPool(this.config.getRegisteredPoolSize(), "LwM2M registration");
-        this.updateRegistrationExecutor = ThingsBoardExecutors.newWorkStealingPool(this.config.getUpdateRegisteredPoolSize(), "LwM2M update registration");
-        this.unRegistrationExecutor = ThingsBoardExecutors.newWorkStealingPool(this.config.getUnRegisteredPoolSize(), "LwM2M unRegistration");
-        this.converter = LwM2mValueConverterImpl.getInstance();
-    }
-
-    /**
-     * Start registration device
-     * Create session: Map<String <registrationId >, LwM2MClient>
-     * 1. replaceNewRegistration -> (solving the problem of incorrect termination of the previous session with this endpoint)
-     * 1.1 When we initialize the registration, we register the session by endpoint.
-     * 1.2 If the server has incomplete requests (canceling the registration of the previous session),
-     * delete the previous session only by the previous registration.getId
-     * 1.2 Add Model (Entity) for client (from registration & observe) by registration.getId
-     * 1.2 Remove from sessions Model by enpPoint
-     * Next ->  Create new LwM2MClient for current session -> setModelClient...
-     *
-     * @param registration         - Registration LwM2M Client
-     * @param previousObservations - may be null
-     */
-    public void onRegistered(Registration registration, Collection<Observation> previousObservations) {
-        registrationExecutor.submit(() -> {
-            LwM2mClient lwM2MClient = this.clientContext.getClientByEndpoint(registration.getEndpoint());
-            try {
-                log.warn("[{}] [{{}] Client: create after Registration", registration.getEndpoint(), registration.getId());
-                if (lwM2MClient != null) {
-                    this.clientContext.register(lwM2MClient, registration);
-                    this.sendLogsToThingsboard(lwM2MClient, LOG_LW2M_INFO + ": Client registered with registration id: " + registration.getId());
-                    SessionInfoProto sessionInfo = lwM2MClient.getSession();
-                    transportService.registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(this, sessionInfo));
-                    log.warn("40) sessionId [{}] Registering rpc subscription after Registration client", new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB()));
-                    TransportProtos.TransportToDeviceActorMsg msg = TransportProtos.TransportToDeviceActorMsg.newBuilder()
-                            .setSessionInfo(sessionInfo)
-                            .setSessionEvent(DefaultTransportService.getSessionEventMsg(SessionEvent.OPEN))
-                            .setSubscribeToAttributes(TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().setSessionType(TransportProtos.SessionType.ASYNC).build())
-                            .setSubscribeToRPC(TransportProtos.SubscribeToRPCMsg.newBuilder().setSessionType(TransportProtos.SessionType.ASYNC).build())
-                            .build();
-                    transportService.process(msg, null);
-                    this.getInfoFirmwareUpdate(lwM2MClient, null);
-                    this.getInfoSoftwareUpdate(lwM2MClient, null);
-                    this.initClientTelemetry(lwM2MClient);
-                } else {
-                    log.error("Client: [{}] onRegistered [{}] name [{}] lwM2MClient ", registration.getId(), registration.getEndpoint(), null);
-                }
-            } catch (LwM2MClientStateException stateException) {
-                if (LwM2MClientState.UNREGISTERED.equals(stateException.getState())) {
-                    log.info("[{}] retry registration due to race condition: [{}].", registration.getEndpoint(), stateException.getState());
-                    // Race condition detected and the client was in progress of unregistration while new registration arrived. Let's try again.
-                    onRegistered(registration, previousObservations);
-                } else {
-                    this.sendLogsToThingsboard(lwM2MClient, LOG_LW2M_WARN + ": Client registration failed due to invalid state: " + stateException.getState());
-                }
-            } catch (Throwable t) {
-                log.error("[{}] endpoint [{}] error Unable registration.", registration.getEndpoint(), t);
-                this.sendLogsToThingsboard(lwM2MClient, LOG_LW2M_WARN + ": Client registration failed due to: " + t.getMessage());
-            }
-        });
-    }
-
-    /**
-     * if sessionInfo removed from sessions, then new registerAsyncSession
-     *
-     * @param registration - Registration LwM2M Client
-     */
-    public void updatedReg(Registration registration) {
-        updateRegistrationExecutor.submit(() -> {
-            LwM2mClient lwM2MClient = clientContext.getClientByEndpoint(registration.getEndpoint());
-            try {
-                clientContext.updateRegistration(lwM2MClient, registration);
-                TransportProtos.SessionInfoProto sessionInfo = lwM2MClient.getSession();
-                this.reportActivityAndRegister(sessionInfo);
-                if (registration.usesQueueMode()) {
-                    LwM2mQueuedRequest request;
-                    while ((request = lwM2MClient.getQueuedRequests().poll()) != null) {
-                        request.send();
-                    }
-                }
-            } catch (LwM2MClientStateException stateException) {
-                if (LwM2MClientState.REGISTERED.equals(stateException.getState())) {
-                    log.info("[{}] update registration failed because client has different registration id: [{}] {}.", registration.getEndpoint(), stateException.getState(), stateException.getMessage());
-                } else {
-                    onRegistered(registration, Collections.emptyList());
-                }
-            } catch (Throwable t) {
-                log.error("[{}] endpoint [{}] error Unable update registration.", registration.getEndpoint(), t);
-                this.sendLogsToThingsboard(lwM2MClient, LOG_LW2M_ERROR + String.format(": Client update Registration, %s", t.getMessage()));
-            }
-        });
-    }
-
-    /**
-     * @param registration - Registration LwM2M Client
-     * @param observations - !!! Warn: if have not finishing unReg, then this operation will be finished on next Client`s connect
-     */
-    public void unReg(Registration registration, Collection<Observation> observations) {
-        unRegistrationExecutor.submit(() -> {
-            LwM2mClient client = clientContext.getClientByEndpoint(registration.getEndpoint());
-            try {
-                this.sendLogsToThingsboard(client, LOG_LW2M_INFO + ": Client unRegistration");
-                clientContext.unregister(client, registration);
-                SessionInfoProto sessionInfo = client.getSession();
-                if (sessionInfo != null) {
-                    this.doCloseSession(sessionInfo);
-                    transportService.deregisterSession(sessionInfo);
-                    sessionStore.remove(registration.getEndpoint());
-                    log.info("Client close session: [{}] unReg [{}] name  [{}] profile ", registration.getId(), registration.getEndpoint(), sessionInfo.getDeviceType());
-                } else {
-                    log.error("Client close session: [{}] unReg [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), null);
-                }
-            } catch (LwM2MClientStateException stateException) {
-                log.info("[{}] delete registration: [{}] {}.", registration.getEndpoint(), stateException.getState(), stateException.getMessage());
-            } catch (Throwable t) {
-                log.error("[{}] endpoint [{}] error Unable un registration.", registration.getEndpoint(), t);
-                this.sendLogsToThingsboard(client, LOG_LW2M_ERROR + String.format(": Client Unable un Registration, %s", t.getMessage()));
-            }
-        });
-    }
-
-    @Override
-    public void onSleepingDev(Registration registration) {
-        log.info("[{}] [{}] Received endpoint Sleeping version event", registration.getId(), registration.getEndpoint());
-        this.sendLogsToThingsboard(clientContext.getClientByEndpoint(registration.getEndpoint()), LOG_LW2M_INFO + ": Client is sleeping!");
-        //TODO: associate endpointId with device information.
-    }
-
-    /**
-     * Cancel observation for All objects for this registration
-     */
-    @Override
-    public void setCancelObservationsAll(Registration registration) {
-        if (registration != null) {
-            LwM2mClient client = clientContext.getClientByEndpoint(registration.getEndpoint());
-            if (client != null && client.getRegistration() != null && client.getRegistration().getId().equals(registration.getId())) {
-                this.lwM2mTransportRequest.sendAllRequest(client, null, OBSERVE_CANCEL_ALL,
-                        null, null, this.config.getTimeout(), null);
-            }
-        }
-    }
-
-    /**
-     * 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, LwM2mClientRpcRequest rpcRequest) {
-        if (response.getContent() != null) {
-            LwM2mClient lwM2MClient = clientContext.getClientByEndpoint(registration.getEndpoint());
-            ObjectModel objectModelVersion = lwM2MClient.getObjectModel(path, this.config.getModelProvider());
-            if (objectModelVersion != null) {
-                if (response.getContent() instanceof LwM2mObject) {
-                    LwM2mObject lwM2mObject = (LwM2mObject) response.getContent();
-                    this.updateObjectResourceValue(registration, lwM2mObject, path);
-                } else if (response.getContent() instanceof LwM2mObjectInstance) {
-                    LwM2mObjectInstance lwM2mObjectInstance = (LwM2mObjectInstance) response.getContent();
-                    this.updateObjectInstanceResourceValue(registration, lwM2mObjectInstance, path);
-                } else if (response.getContent() instanceof LwM2mResource) {
-                    LwM2mResource lwM2mResource = (LwM2mResource) response.getContent();
-                    this.updateResourcesValue(registration, lwM2mResource, path);
-                }
-            }
-            if (rpcRequest != null) {
-                this.sendRpcRequestAfterReadResponse(registration, lwM2MClient, path, response, rpcRequest);
-            }
-        }
-    }
-
-    private void sendRpcRequestAfterReadResponse(Registration registration, LwM2mClient lwM2MClient, String pathIdVer, ReadResponse response,
-                                                 LwM2mClientRpcRequest rpcRequest) {
-        Object value = null;
-        if (response.getContent() instanceof LwM2mObject) {
-            value = lwM2MClient.objectToString((LwM2mObject) response.getContent(), this.converter, pathIdVer);
-        } else if (response.getContent() instanceof LwM2mObjectInstance) {
-            value = lwM2MClient.instanceToString((LwM2mObjectInstance) response.getContent(), this.converter, pathIdVer);
-        } else if (response.getContent() instanceof LwM2mResource) {
-            value = lwM2MClient.resourceToString((LwM2mResource) response.getContent(), this.converter, pathIdVer);
-        }
-        String msg = String.format("%s: type operation %s path - %s value - %s", LOG_LW2M_INFO,
-                READ, pathIdVer, value);
-        this.sendLogsToThingsboard(lwM2MClient, msg);
-        rpcRequest.setValueMsg(String.format("%s", value));
-        this.sentRpcResponse(rpcRequest, response.getCode().getName(), (String) value, LOG_LW2M_VALUE);
-    }
-
-    /**
-     * Update - send request in change value resources in Client
-     * 1. FirmwareUpdate:
-     * - If msg.getSharedUpdatedList().forEach(tsKvProto -> {tsKvProto.getKv().getKey().indexOf(FIRMWARE_UPDATE_PREFIX, 0) == 0
-     * 2. Shared Other AttributeUpdate
-     * -- Path to resources from profile equal keyName or from ModelObject equal name
-     * -- Only for resources:  isWritable && isPresent as attribute in profile -> LwM2MClientProfile (format: CamelCase)
-     * 3. Delete - nothing
-     *
-     * @param msg -
-     */
-    @Override
-    public void onAttributeUpdate(AttributeUpdateNotificationMsg msg, TransportProtos.SessionInfoProto sessionInfo) {
-        LwM2mClient lwM2MClient = clientContext.getClientBySessionInfo(sessionInfo);
-        if (msg.getSharedUpdatedCount() > 0 && lwM2MClient != null) {
-            log.warn("2) OnAttributeUpdate, SharedUpdatedList() [{}]", msg.getSharedUpdatedList());
-            msg.getSharedUpdatedList().forEach(tsKvProto -> {
-                String pathName = tsKvProto.getKv().getKey();
-                String pathIdVer = this.getPresentPathIntoProfile(sessionInfo, pathName);
-                Object valueNew = getValueFromKvProto(tsKvProto.getKv());
-                if ((OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.VERSION).equals(pathName)
-                        && (!valueNew.equals(lwM2MClient.getFwUpdate().getCurrentVersion())))
-                        || (OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.TITLE).equals(pathName)
-                        && (!valueNew.equals(lwM2MClient.getFwUpdate().getCurrentTitle())))) {
-                    this.getInfoFirmwareUpdate(lwM2MClient, null);
-                } else if ((OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.VERSION).equals(pathName)
-                        && (!valueNew.equals(lwM2MClient.getSwUpdate().getCurrentVersion())))
-                        || (OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.TITLE).equals(pathName)
-                        && (!valueNew.equals(lwM2MClient.getSwUpdate().getCurrentTitle())))) {
-                    this.getInfoSoftwareUpdate(lwM2MClient, null);
-                }
-                if (pathIdVer != null) {
-                    ResourceModel resourceModel = lwM2MClient.getResourceModel(pathIdVer, this.config
-                            .getModelProvider());
-                    if (resourceModel != null && resourceModel.operations.isWritable()) {
-                        this.updateResourcesValueToClient(lwM2MClient, this.getResourceValueFormatKv(lwM2MClient, pathIdVer), valueNew, pathIdVer);
-                    } else {
-                        log.error("Resource path - [{}] value - [{}] is not Writable and cannot be updated", pathIdVer, valueNew);
-                        String logMsg = String.format("%s: attributeUpdate: Resource path - %s value - %s is not Writable and cannot be updated",
-                                LOG_LW2M_ERROR, pathIdVer, valueNew);
-                        this.sendLogsToThingsboard(lwM2MClient, logMsg);
-                    }
-                } else if (!isFwSwWords(pathName)) {
-                    log.error("Resource name name - [{}] value - [{}] is not present as attribute/telemetry in profile and cannot be updated", pathName, valueNew);
-                    String logMsg = String.format("%s: attributeUpdate: attribute name - %s value - %s is not present as attribute in profile and cannot be updated",
-                            LOG_LW2M_ERROR, pathName, valueNew);
-                    this.sendLogsToThingsboard(lwM2MClient, logMsg);
-                }
-
-            });
-        } else if (msg.getSharedDeletedCount() > 0 && lwM2MClient != null) {
-            msg.getSharedUpdatedList().forEach(tsKvProto -> {
-                String pathName = tsKvProto.getKv().getKey();
-                Object valueNew = getValueFromKvProto(tsKvProto.getKv());
-                if (OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.VERSION).equals(pathName) && !valueNew.equals(lwM2MClient.getFwUpdate().getCurrentVersion())) {
-                    lwM2MClient.getFwUpdate().setCurrentVersion((String) valueNew);
-                }
-            });
-            log.info("[{}] delete [{}]  onAttributeUpdate", msg.getSharedDeletedList(), sessionInfo);
-        } else if (lwM2MClient == null) {
-            log.error("OnAttributeUpdate, lwM2MClient is null");
-        }
-    }
-
-    /**
-     * @param sessionInfo   -
-     * @param deviceProfile -
-     */
-    @Override
-    public void onDeviceProfileUpdate(SessionInfoProto sessionInfo, DeviceProfile deviceProfile) {
-        List<LwM2mClient> clients = clientContext.getLwM2mClients()
-                .stream().filter(e -> e.getProfileId().equals(deviceProfile.getUuidId())).collect(Collectors.toList());
-        clients.forEach(client -> client.onDeviceProfileUpdate(deviceProfile));
-        if (clients.size() > 0) {
-            this.onDeviceProfileUpdate(clients, deviceProfile);
-        }
-    }
-
-    @Override
-    public void onDeviceUpdate(SessionInfoProto sessionInfo, Device device, Optional<DeviceProfile> deviceProfileOpt) {
-        //TODO: check, maybe device has multiple sessions/registrations? Is this possible according to the standard.
-        LwM2mClient client = clientContext.getClientByDeviceId(device.getUuidId());
-        if (client != null) {
-            this.onDeviceUpdate(client, device, deviceProfileOpt);
-        }
-    }
-
-    @Override
-    public void onResourceUpdate(Optional<TransportProtos.ResourceUpdateMsg> resourceUpdateMsgOpt) {
-        String idVer = resourceUpdateMsgOpt.get().getResourceKey();
-        clientContext.getLwM2mClients().forEach(e -> e.updateResourceModel(idVer, this.config.getModelProvider()));
-    }
-
-    @Override
-    public void onResourceDelete(Optional<TransportProtos.ResourceDeleteMsg> resourceDeleteMsgOpt) {
-        String pathIdVer = resourceDeleteMsgOpt.get().getResourceKey();
-        clientContext.getLwM2mClients().forEach(e -> e.deleteResources(pathIdVer, this.config.getModelProvider()));
-    }
-
-    /**
-     * #1 del from rpcSubscriptions by timeout
-     * #2 if not present in rpcSubscriptions by requestId: create new LwM2mClientRpcRequest, after success - add requestId, timeout
-     */
-    @Override
-    public void onToDeviceRpcRequest(TransportProtos.ToDeviceRpcRequestMsg toDeviceRpcRequestMsg, SessionInfoProto sessionInfo) {
-        // #1
-        this.checkRpcRequestTimeout();
-        log.warn("4) toDeviceRpcRequestMsg: [{}], sessionUUID: [{}]", toDeviceRpcRequestMsg, new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB()));
-        String bodyParams = StringUtils.trimToNull(toDeviceRpcRequestMsg.getParams()) != null ? toDeviceRpcRequestMsg.getParams() : "null";
-        LwM2mTypeOper lwM2mTypeOper = setValidTypeOper(toDeviceRpcRequestMsg.getMethodName());
-        UUID requestUUID = new UUID(toDeviceRpcRequestMsg.getRequestIdMSB(), toDeviceRpcRequestMsg.getRequestIdLSB());
-        if (!this.rpcSubscriptions.containsKey(requestUUID)) {
-            this.rpcSubscriptions.put(requestUUID, toDeviceRpcRequestMsg.getExpirationTime());
-            LwM2mClientRpcRequest lwm2mClientRpcRequest = null;
-            try {
-                LwM2mClient client = clientContext.getClientBySessionInfo(sessionInfo);
-                Registration registration = client.getRegistration();
-                if(registration != null) {
-                    lwm2mClientRpcRequest = new LwM2mClientRpcRequest(lwM2mTypeOper, bodyParams, toDeviceRpcRequestMsg.getRequestId(), sessionInfo, registration, this);
-                    if (lwm2mClientRpcRequest.getErrorMsg() != null) {
-                        lwm2mClientRpcRequest.setResponseCode(BAD_REQUEST.name());
-                        this.onToDeviceRpcResponse(lwm2mClientRpcRequest.getDeviceRpcResponseResultMsg(), sessionInfo);
-                    } else {
-                        lwM2mTransportRequest.sendAllRequest(client, lwm2mClientRpcRequest.getTargetIdVer(), lwm2mClientRpcRequest.getTypeOper(),
-                                null,
-                                lwm2mClientRpcRequest.getValue() == null ? lwm2mClientRpcRequest.getParams() : lwm2mClientRpcRequest.getValue(),
-                                this.config.getTimeout(), lwm2mClientRpcRequest);
-                    }
-                } else {
-                    this.sendErrorRpcResponse(lwm2mClientRpcRequest, "registration == null", sessionInfo);
-                }
-            } catch (Exception e) {
-                this.sendErrorRpcResponse(lwm2mClientRpcRequest, e.getMessage(), sessionInfo);
-            }
-        }
-    }
-
-    private void sendErrorRpcResponse(LwM2mClientRpcRequest lwm2mClientRpcRequest, String msgError, SessionInfoProto sessionInfo) {
-        if (lwm2mClientRpcRequest == null) {
-            lwm2mClientRpcRequest = new LwM2mClientRpcRequest();
-        }
-        lwm2mClientRpcRequest.setResponseCode(BAD_REQUEST.name());
-        if (lwm2mClientRpcRequest.getErrorMsg() == null) {
-            lwm2mClientRpcRequest.setErrorMsg(msgError);
-        }
-        this.onToDeviceRpcResponse(lwm2mClientRpcRequest.getDeviceRpcResponseResultMsg(), sessionInfo);
-    }
-
-    private void checkRpcRequestTimeout() {
-        log.warn("4.1) before rpcSubscriptions.size(): [{}]", rpcSubscriptions.size());
-        if (rpcSubscriptions.size() > 0) {
-            Set<UUID> rpcSubscriptionsToRemove = rpcSubscriptions.entrySet().stream().filter(kv -> System.currentTimeMillis() > kv.getValue()).map(Map.Entry::getKey).collect(Collectors.toSet());
-            log.warn("4.2) System.currentTimeMillis(): [{}]", System.currentTimeMillis());
-            log.warn("4.3) rpcSubscriptionsToRemove: [{}]", rpcSubscriptionsToRemove);
-            rpcSubscriptionsToRemove.forEach(rpcSubscriptions::remove);
-        }
-        log.warn("4.4) after rpcSubscriptions.size(): [{}]", rpcSubscriptions.size());
-    }
-
-    public void sentRpcResponse(LwM2mClientRpcRequest rpcRequest, String requestCode, String msg, String typeMsg) {
-        rpcRequest.setResponseCode(requestCode);
-        if (LOG_LW2M_ERROR.equals(typeMsg)) {
-            rpcRequest.setInfoMsg(null);
-            rpcRequest.setValueMsg(null);
-            if (rpcRequest.getErrorMsg() == null) {
-                msg = msg.isEmpty() ? null : msg;
-                rpcRequest.setErrorMsg(msg);
-            }
-        } else if (LOG_LW2M_INFO.equals(typeMsg)) {
-            if (rpcRequest.getInfoMsg() == null) {
-                rpcRequest.setInfoMsg(msg);
-            }
-        } else if (LOG_LW2M_VALUE.equals(typeMsg)) {
-            if (rpcRequest.getValueMsg() == null) {
-                rpcRequest.setValueMsg(msg);
-            }
-        }
-        this.onToDeviceRpcResponse(rpcRequest.getDeviceRpcResponseResultMsg(), rpcRequest.getSessionInfo());
-    }
-
-    @Override
-    public void onToDeviceRpcResponse(TransportProtos.ToDeviceRpcResponseMsg toDeviceResponse, SessionInfoProto sessionInfo) {
-        log.warn("5) onToDeviceRpcResponse: [{}], sessionUUID: [{}]", toDeviceResponse, new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB()));
-        transportService.process(sessionInfo, toDeviceResponse, null);
-    }
-
-    public void onToServerRpcResponse(TransportProtos.ToServerRpcResponseMsg toServerResponse) {
-        log.info("[{}] toServerRpcResponse", toServerResponse);
-    }
-
-    /**
-     * Deregister session in transport
-     *
-     * @param sessionInfo - lwm2m client
-     */
-    @Override
-    public void doDisconnect(SessionInfoProto sessionInfo) {
-        transportService.process(sessionInfo, DefaultTransportService.getSessionEventMsg(SessionEvent.CLOSED), null);
-        transportService.deregisterSession(sessionInfo);
-    }
-
-    /**
-     * Session device in thingsboard is closed
-     *
-     * @param sessionInfo - lwm2m client
-     */
-    private void doCloseSession(SessionInfoProto sessionInfo) {
-        TransportProtos.SessionEvent event = SessionEvent.CLOSED;
-        TransportProtos.SessionEventMsg msg = TransportProtos.SessionEventMsg.newBuilder()
-                .setSessionType(TransportProtos.SessionType.ASYNC)
-                .setEvent(event).build();
-        transportService.process(sessionInfo, msg, null);
-    }
-
-    /**
-     * Those methods are called by the protocol stage thread pool, this means that execution MUST be done in a short delay,
-     * * if you need to do long time processing use a dedicated thread pool.
-     *
-     * @param registration -
-     */
-    @Override
-    public void onAwakeDev(Registration registration) {
-        log.trace("[{}] [{}] Received endpoint Awake version event", registration.getId(), registration.getEndpoint());
-        this.sendLogsToThingsboard(clientContext.getClientByEndpoint(registration.getEndpoint()), LOG_LW2M_INFO + ": Client is awake!");
-        //TODO: associate endpointId with device information.
-    }
-
-    /**
-     * @param logMsg         - text msg
-     * @param registrationId - Id of Registration LwM2M Client
-     */
-    @Override
-    public void sendLogsToThingsboard(String registrationId, String logMsg) {
-        sendLogsToThingsboard(clientContext.getClientByRegistrationId(registrationId), logMsg);
-    }
-
-    @Override
-    public void sendLogsToThingsboard(LwM2mClient client, String logMsg) {
-        if (logMsg != null && client != null && client.getSession() != null) {
-            if (logMsg.length() > 1024) {
-                logMsg = logMsg.substring(0, 1024);
-            }
-            this.helper.sendParametersOnThingsboardTelemetry(this.helper.getKvStringtoThingsboard(LOG_LW2M_TELEMETRY, logMsg), client.getSession());
-        }
-    }
-
-    /**
-     * #1 clientOnlyObserveAfterConnect == true
-     * - Only Observe Request to the client marked as observe from the profile configuration.
-     * #2. clientOnlyObserveAfterConnect == false
-     * После регистрации отправляю запрос на read  всех ресурсов, которые после регистрации есть у клиента,
-     * а затем запрос на observe (edited)
-     * - Read Request to the client after registration to read all resource values for all objects
-     * - then Observe Request to the client marked as observe from the profile configuration.
-     *
-     * @param lwM2MClient - object with All parameters off client
-     */
-    private void initClientTelemetry(LwM2mClient lwM2MClient) {
-        LwM2mClientProfile lwM2MClientProfile = clientContext.getProfile(lwM2MClient.getProfileId());
-        Set<String> clientObjects = clientContext.getSupportedIdVerInClient(lwM2MClient);
-        if (clientObjects != null && clientObjects.size() > 0) {
-            if (LwM2mTransportUtil.LwM2MClientStrategy.CLIENT_STRATEGY_2.code == lwM2MClientProfile.getClientStrategy()) {
-                // #2
-                lwM2MClient.getPendingReadRequests().addAll(clientObjects);
-                clientObjects.forEach(path -> lwM2mTransportRequest.sendAllRequest(lwM2MClient, path, READ,
-                        null, this.config.getTimeout(), null));
-            }
-            // #1
-            this.initReadAttrTelemetryObserveToClient(lwM2MClient, READ, clientObjects);
-            this.initReadAttrTelemetryObserveToClient(lwM2MClient, OBSERVE, clientObjects);
-            this.initReadAttrTelemetryObserveToClient(lwM2MClient, WRITE_ATTRIBUTES, clientObjects);
-            this.initReadAttrTelemetryObserveToClient(lwM2MClient, DISCOVER, clientObjects);
-        }
-    }
-
-    /**
-     * @param registration -
-     * @param lwM2mObject  -
-     * @param pathIdVer    -
-     */
-    private void updateObjectResourceValue(Registration registration, LwM2mObject lwM2mObject, String pathIdVer) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer));
-        lwM2mObject.getInstances().forEach((instanceId, instance) -> {
-            String pathInstance = pathIds.toString() + "/" + instanceId;
-            this.updateObjectInstanceResourceValue(registration, instance, pathInstance);
-        });
-    }
-
-    /**
-     * @param registration        -
-     * @param lwM2mObjectInstance -
-     * @param pathIdVer           -
-     */
-    private void updateObjectInstanceResourceValue(Registration registration, LwM2mObjectInstance lwM2mObjectInstance, String pathIdVer) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer));
-        lwM2mObjectInstance.getResources().forEach((resourceId, resource) -> {
-            String pathRez = pathIds.toString() + "/" + resourceId;
-            this.updateResourcesValue(registration, resource, pathRez);
-        });
-    }
-
-    /**
-     * Sending observe value of resources to thingsboard
-     * #1 Return old Value Resource from LwM2MClient
-     * #2 Update new Resources (replace old Resource Value on new Resource Value)
-     * #3 If fr_update -> UpdateFirmware
-     * #4 updateAttrTelemetry
-     *
-     * @param registration  - Registration LwM2M Client
-     * @param lwM2mResource - LwM2mSingleResource response.getContent()
-     * @param path          - resource
-     */
-    private void updateResourcesValue(Registration registration, LwM2mResource lwM2mResource, String path) {
-        LwM2mClient lwM2MClient = clientContext.getClientByEndpoint(registration.getEndpoint());
-        if (lwM2MClient.saveResourceValue(path, lwM2mResource, this.config.getModelProvider())) {
-            /** version != null
-             * set setClient_fw_info... = value
-             **/
-            if (lwM2MClient.getFwUpdate() != null && lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
-                lwM2MClient.getFwUpdate().initReadValue(this, this.lwM2mTransportRequest, path);
-            }
-            if (lwM2MClient.getSwUpdate() != null && lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
-                lwM2MClient.getSwUpdate().initReadValue(this, this.lwM2mTransportRequest, path);
-            }
-
-            if ((convertPathFromObjectIdToIdVer(FW_RESULT_ID, registration).equals(path)) ||
-                    (convertPathFromObjectIdToIdVer(FW_STATE_ID, registration).equals(path))) {
-                LwM2mFwSwUpdate fwUpdate = lwM2MClient.getFwUpdate(clientContext);
-                log.warn("93) path: [{}] value: [{}]", path, lwM2mResource.getValue());
-                fwUpdate.updateStateOta(this, lwM2mTransportRequest, registration, path, ((Long) lwM2mResource.getValue()).intValue());
-            }
-            Set<String> paths = new HashSet<>();
-            paths.add(path);
-            this.updateAttrTelemetry(registration, paths);
-        } else {
-            log.error("Fail update Resource [{}]", lwM2mResource);
-        }
-    }
-
-
-    /**
-     * send Attribute and Telemetry to Thingsboard
-     * #1 - get AttrName/TelemetryName with value from LwM2MClient:
-     * -- resourceId == path from LwM2MClientProfile.postAttributeProfile/postTelemetryProfile/postObserveProfile
-     * -- AttrName/TelemetryName == resourceName from ModelObject.objectModel, value from ModelObject.instance.resource(resourceId)
-     * #2 - set Attribute/Telemetry
-     *
-     * @param registration - Registration LwM2M Client
-     */
-    private void updateAttrTelemetry(Registration registration, Set<String> paths) {
-        try {
-            ResultsAddKeyValueProto results = this.getParametersFromProfile(registration, paths);
-            SessionInfoProto sessionInfo = this.getSessionInfoOrCloseSession(registration);
-            if (results != null && sessionInfo != null) {
-                if (results.getResultAttributes().size() > 0) {
-                    this.helper.sendParametersOnThingsboardAttribute(results.getResultAttributes(), sessionInfo);
-                }
-                if (results.getResultTelemetries().size() > 0) {
-                    this.helper.sendParametersOnThingsboardTelemetry(results.getResultTelemetries(), sessionInfo);
-                }
-            }
-        } catch (Exception e) {
-            log.error("UpdateAttrTelemetry", e);
-        }
-    }
-
-    private void initReadAttrTelemetryObserveToClient(LwM2mClient lwM2MClient, LwM2mTypeOper typeOper, Set<String> clientObjects) {
-        LwM2mClientProfile lwM2MClientProfile = clientContext.getProfile(lwM2MClient.getProfileId());
-        Set<String> result = null;
-        ConcurrentHashMap<String, Object> params = null;
-        if (READ.equals(typeOper)) {
-            result = JacksonUtil.fromString(lwM2MClientProfile.getPostAttributeProfile().toString(),
-                    new TypeReference<>() {
-                    });
-            result.addAll(JacksonUtil.fromString(lwM2MClientProfile.getPostTelemetryProfile().toString(),
-                    new TypeReference<>() {
-                    }));
-        } else if (OBSERVE.equals(typeOper)) {
-            result = JacksonUtil.fromString(lwM2MClientProfile.getPostObserveProfile().toString(),
-                    new TypeReference<>() {
-                    });
-        } else if (DISCOVER.equals(typeOper)) {
-            result = this.getPathForWriteAttributes(lwM2MClientProfile.getPostAttributeLwm2mProfile()).keySet();
-        } else if (WRITE_ATTRIBUTES.equals(typeOper)) {
-            params = this.getPathForWriteAttributes(lwM2MClientProfile.getPostAttributeLwm2mProfile());
-            result = params.keySet();
-        }
-        sendRequestsToClient(lwM2MClient, typeOper, clientObjects, result, params);
-    }
-
-    private void sendRequestsToClient(LwM2mClient lwM2MClient, LwM2mTypeOper operationType, Set<String> supportedObjectIds, Set<String> desiredObjectIds, ConcurrentHashMap<String, Object> params) {
-        if (desiredObjectIds != null && !desiredObjectIds.isEmpty()) {
-            Set<String> targetObjectIds = desiredObjectIds.stream().filter(target -> isSupportedTargetId(supportedObjectIds, target)
-            ).collect(Collectors.toUnmodifiableSet());
-            if (!targetObjectIds.isEmpty()) {
-                //TODO: remove this side effect?
-                lwM2MClient.getPendingReadRequests().addAll(targetObjectIds);
-                targetObjectIds.forEach(target -> {
-                    Object additionalParams = params != null ? params.get(target) : null;
-                    lwM2mTransportRequest.sendAllRequest(lwM2MClient, target, operationType, additionalParams, this.config.getTimeout(), null);
-                });
-                if (OBSERVE.equals(operationType)) {
-                    lwM2MClient.initReadValue(this, null);
-                }
-            }
-        }
-    }
-
-    private boolean isSupportedTargetId(Set<String> supportedIds, String targetId) {
-        String[] targetIdParts = targetId.split(LWM2M_SEPARATOR_PATH);
-        if (targetIdParts.length <= 1) {
-            return false;
-        }
-        String targetIdSearch = targetIdParts[0];
-        for (int i = 1; i < targetIdParts.length; i++) {
-            targetIdSearch += "/" + targetIdParts[i];
-            if (supportedIds.contains(targetIdSearch)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private ConcurrentHashMap<String, Object> getPathForWriteAttributes(JsonObject objectJson) {
-        ConcurrentHashMap<String, Object> pathAttributes = new Gson().fromJson(objectJson.toString(),
-                new TypeToken<ConcurrentHashMap<String, Object>>() {
-                }.getType());
-        return pathAttributes;
-    }
-
-    private void onDeviceUpdate(LwM2mClient lwM2MClient, Device device, Optional<DeviceProfile> deviceProfileOpt) {
-        deviceProfileOpt.ifPresent(deviceProfile -> this.onDeviceProfileUpdate(Collections.singletonList(lwM2MClient), deviceProfile));
-        lwM2MClient.onDeviceUpdate(device, deviceProfileOpt);
-    }
-
-    /**
-     * //     * @param attributes   - new JsonObject
-     * //     * @param telemetry    - new JsonObject
-     *
-     * @param registration - Registration LwM2M Client
-     * @param path         -
-     */
-    private ResultsAddKeyValueProto getParametersFromProfile(Registration registration, Set<String> path) {
-        if (path != null && path.size() > 0) {
-            ResultsAddKeyValueProto results = new ResultsAddKeyValueProto();
-            LwM2mClientProfile lwM2MClientProfile = clientContext.getProfile(registration);
-            List<TransportProtos.KeyValueProto> resultAttributes = new ArrayList<>();
-            lwM2MClientProfile.getPostAttributeProfile().forEach(pathIdVer -> {
-                if (path.contains(pathIdVer.getAsString())) {
-                    TransportProtos.KeyValueProto kvAttr = this.getKvToThingsboard(pathIdVer.getAsString(), registration);
-                    if (kvAttr != null) {
-                        resultAttributes.add(kvAttr);
-                    }
-                }
-            });
-            List<TransportProtos.KeyValueProto> resultTelemetries = new ArrayList<>();
-            lwM2MClientProfile.getPostTelemetryProfile().forEach(pathIdVer -> {
-                if (path.contains(pathIdVer.getAsString())) {
-                    TransportProtos.KeyValueProto kvAttr = this.getKvToThingsboard(pathIdVer.getAsString(), registration);
-                    if (kvAttr != null) {
-                        resultTelemetries.add(kvAttr);
-                    }
-                }
-            });
-            if (resultAttributes.size() > 0) {
-                results.setResultAttributes(resultAttributes);
-            }
-            if (resultTelemetries.size() > 0) {
-                results.setResultTelemetries(resultTelemetries);
-            }
-            return results;
-        }
-        return null;
-    }
-
-    private TransportProtos.KeyValueProto getKvToThingsboard(String pathIdVer, Registration registration) {
-        LwM2mClient lwM2MClient = this.clientContext.getClientByEndpoint(registration.getEndpoint());
-        JsonObject names = clientContext.getProfiles().get(lwM2MClient.getProfileId()).getPostKeyNameProfile();
-        if (names != null && names.has(pathIdVer)) {
-            String resourceName = names.get(pathIdVer).getAsString();
-            if (resourceName != null && !resourceName.isEmpty()) {
-                try {
-                    LwM2mResource resourceValue = lwM2MClient != null ? getResourceValueFromLwM2MClient(lwM2MClient, pathIdVer) : null;
-                    if (resourceValue != null) {
-                        ResourceModel.Type currentType = resourceValue.getType();
-                        ResourceModel.Type expectedType = this.helper.getResourceModelTypeEqualsKvProtoValueType(currentType, pathIdVer);
-                        Object valueKvProto = null;
-                        if (resourceValue.isMultiInstances()) {
-                            valueKvProto = new JsonObject();
-                            Object finalvalueKvProto = valueKvProto;
-                            Gson gson = new GsonBuilder().create();
-                            ResourceModel.Type finalCurrentType = currentType;
-                            resourceValue.getInstances().forEach((k, v) -> {
-                                Object val = this.converter.convertValue(v, finalCurrentType, expectedType,
-                                        new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer)));
-                                JsonElement element = gson.toJsonTree(val, val.getClass());
-                                ((JsonObject) finalvalueKvProto).add(String.valueOf(k), element);
-                            });
-                            valueKvProto = gson.toJson(valueKvProto);
-                        } else {
-                            valueKvProto = this.converter.convertValue(resourceValue.getValue(), currentType, expectedType,
-                                    new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer)));
-                        }
-                        LwM2mOtaConvert lwM2mOtaConvert = convertOtaUpdateValueToString(pathIdVer, valueKvProto, currentType);
-                        valueKvProto = lwM2mOtaConvert.getValue();
-                        currentType = lwM2mOtaConvert.getCurrentType();
-                        return valueKvProto != null ? this.helper.getKvAttrTelemetryToThingsboard(currentType, resourceName, valueKvProto, resourceValue.isMultiInstances()) : null;
-                    }
-                } catch (Exception e) {
-                    log.error("Failed to add parameters.", e);
-                }
-            }
-        } else {
-            log.error("Failed to add parameters. path: [{}], names: [{}]", pathIdVer, names);
-        }
-        return null;
-    }
-
-    /**
-     * @param pathIdVer - path resource
-     * @return - value of Resource into format KvProto or null
-     */
-    private Object getResourceValueFormatKv(LwM2mClient lwM2MClient, String pathIdVer) {
-        LwM2mResource resourceValue = this.getResourceValueFromLwM2MClient(lwM2MClient, pathIdVer);
-        if (resourceValue != null) {
-            ResourceModel.Type currentType = resourceValue.getType();
-            ResourceModel.Type expectedType = this.helper.getResourceModelTypeEqualsKvProtoValueType(currentType, pathIdVer);
-            return this.converter.convertValue(resourceValue.getValue(), currentType, expectedType,
-                    new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer)));
-        } else {
-            return null;
-        }
-    }
-
-    /**
-     * @param lwM2MClient -
-     * @param path        -
-     * @return - return value of Resource by idPath
-     */
-    private LwM2mResource getResourceValueFromLwM2MClient(LwM2mClient lwM2MClient, String path) {
-        LwM2mResource lwm2mResourceValue = null;
-        ResourceValue resourceValue = lwM2MClient.getResources().get(path);
-        if (resourceValue != null) {
-            if (new LwM2mPath(convertPathFromIdVerToObjectId(path)).isResource()) {
-                lwm2mResourceValue = lwM2MClient.getResources().get(path).getLwM2mResource();
-            }
-        }
-        return lwm2mResourceValue;
-    }
-
-    /**
-     * Update resource (attribute) value  on thingsboard after update value in client
-     *
-     * @param registration -
-     * @param path         -
-     * @param request      -
-     */
-    public void onWriteResponseOk(Registration registration, String path, WriteRequest request) {
-        if (request.getNode() instanceof LwM2mResource) {
-            this.updateResourcesValue(registration, ((LwM2mResource) request.getNode()), path);
-        } else if (request.getNode() instanceof LwM2mObjectInstance) {
-            ((LwM2mObjectInstance) request.getNode()).getResources().forEach((resId, resource) -> {
-                this.updateResourcesValue(registration, resource, path + "/" + resId);
-            });
-        }
-
-    }
-
-    /**
-     * #1 Read new, old Value (Attribute, Telemetry, Observe, KeyName)
-     * #2 Update in lwM2MClient: ...Profile if changes from update device
-     * #3 Equivalence test: old <> new Value (Attribute, Telemetry, Observe, KeyName)
-     * #3.1 Attribute isChange (add&del)
-     * #3.2 Telemetry isChange (add&del)
-     * #3.3 KeyName isChange (add)
-     * #3.4 attributeLwm2m isChange (update WrightAttribute: add/update/del)
-     * #4 update
-     * #4.1 add If #3 isChange, then analyze and update Value in Transport form Client and send Value to thingsboard
-     * #4.2 del
-     * -- if  add attributes includes del telemetry - result del for observe
-     * #5
-     * #5.1 Observe isChange (add&del)
-     * #5.2 Observe.add
-     * -- path Attr/Telemetry includes newObserve and does not include oldObserve: send Request observe to Client
-     * #5.3 Observe.del
-     * -- different between newObserve and oldObserve: send Request cancel observe to client
-     * #6
-     * #6.1 - update WriteAttribute
-     * #6.2 - del WriteAttribute
-     *
-     * @param clients       -
-     * @param deviceProfile -
-     */
-    private void onDeviceProfileUpdate(List<LwM2mClient> clients, DeviceProfile deviceProfile) {
-        LwM2mClientProfile lwM2MClientProfileOld = clientContext.getProfiles().get(deviceProfile.getUuidId()).clone();
-        if (clientContext.profileUpdate(deviceProfile) != null) {
-            // #1
-            JsonArray attributeOld = lwM2MClientProfileOld.getPostAttributeProfile();
-            Set<String> attributeSetOld = convertJsonArrayToSet(attributeOld);
-            JsonArray telemetryOld = lwM2MClientProfileOld.getPostTelemetryProfile();
-            Set<String> telemetrySetOld = convertJsonArrayToSet(telemetryOld);
-            JsonArray observeOld = lwM2MClientProfileOld.getPostObserveProfile();
-            JsonObject keyNameOld = lwM2MClientProfileOld.getPostKeyNameProfile();
-            JsonObject attributeLwm2mOld = lwM2MClientProfileOld.getPostAttributeLwm2mProfile();
-
-            LwM2mClientProfile lwM2MClientProfileNew = clientContext.getProfiles().get(deviceProfile.getUuidId()).clone();
-            JsonArray attributeNew = lwM2MClientProfileNew.getPostAttributeProfile();
-            Set<String> attributeSetNew = convertJsonArrayToSet(attributeNew);
-            JsonArray telemetryNew = lwM2MClientProfileNew.getPostTelemetryProfile();
-            Set<String> telemetrySetNew = convertJsonArrayToSet(telemetryNew);
-            JsonArray observeNew = lwM2MClientProfileNew.getPostObserveProfile();
-            JsonObject keyNameNew = lwM2MClientProfileNew.getPostKeyNameProfile();
-            JsonObject attributeLwm2mNew = lwM2MClientProfileNew.getPostAttributeLwm2mProfile();
-
-            // #3
-            ResultsAnalyzerParameters sendAttrToThingsboard = new ResultsAnalyzerParameters();
-            // #3.1
-            if (!attributeOld.equals(attributeNew)) {
-                ResultsAnalyzerParameters postAttributeAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(attributeOld,
-                        new TypeToken<Set<String>>() {
-                        }.getType()), attributeSetNew);
-                sendAttrToThingsboard.getPathPostParametersAdd().addAll(postAttributeAnalyzer.getPathPostParametersAdd());
-                sendAttrToThingsboard.getPathPostParametersDel().addAll(postAttributeAnalyzer.getPathPostParametersDel());
-            }
-            // #3.2
-            if (!telemetryOld.equals(telemetryNew)) {
-                ResultsAnalyzerParameters postTelemetryAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(telemetryOld,
-                        new TypeToken<Set<String>>() {
-                        }.getType()), telemetrySetNew);
-                sendAttrToThingsboard.getPathPostParametersAdd().addAll(postTelemetryAnalyzer.getPathPostParametersAdd());
-                sendAttrToThingsboard.getPathPostParametersDel().addAll(postTelemetryAnalyzer.getPathPostParametersDel());
-            }
-            // #3.3
-            if (!keyNameOld.equals(keyNameNew)) {
-                ResultsAnalyzerParameters keyNameChange = this.getAnalyzerKeyName(new Gson().fromJson(keyNameOld.toString(),
-                        new TypeToken<ConcurrentHashMap<String, String>>() {
-                        }.getType()),
-                        new Gson().fromJson(keyNameNew.toString(), new TypeToken<ConcurrentHashMap<String, String>>() {
-                        }.getType()));
-                sendAttrToThingsboard.getPathPostParametersAdd().addAll(keyNameChange.getPathPostParametersAdd());
-            }
-
-            // #3.4, #6
-            if (!attributeLwm2mOld.equals(attributeLwm2mNew)) {
-                this.getAnalyzerAttributeLwm2m(clients, attributeLwm2mOld, attributeLwm2mNew);
-            }
-
-            // #4.1 add
-            if (sendAttrToThingsboard.getPathPostParametersAdd().size() > 0) {
-                // update value in Resources
-                clients.forEach(client -> {
-                    this.readObserveFromProfile(client, sendAttrToThingsboard.getPathPostParametersAdd(), READ);
-                });
-            }
-            // #4.2 del
-            if (sendAttrToThingsboard.getPathPostParametersDel().size() > 0) {
-                ResultsAnalyzerParameters sendAttrToThingsboardDel = this.getAnalyzerParameters(sendAttrToThingsboard.getPathPostParametersAdd(), sendAttrToThingsboard.getPathPostParametersDel());
-                sendAttrToThingsboard.setPathPostParametersDel(sendAttrToThingsboardDel.getPathPostParametersDel());
-            }
-
-            // #5.1
-            if (!observeOld.equals(observeNew)) {
-                Set<String> observeSetOld = new Gson().fromJson(observeOld, new TypeToken<Set<String>>() {
-                }.getType());
-                Set<String> observeSetNew = new Gson().fromJson(observeNew, new TypeToken<Set<String>>() {
-                }.getType());
-                //#5.2 add
-                //  path Attr/Telemetry includes newObserve
-                attributeSetOld.addAll(telemetrySetOld);
-                ResultsAnalyzerParameters sendObserveToClientOld = this.getAnalyzerParametersIn(attributeSetOld, observeSetOld); // add observe
-                attributeSetNew.addAll(telemetrySetNew);
-                ResultsAnalyzerParameters sendObserveToClientNew = this.getAnalyzerParametersIn(attributeSetNew, observeSetNew); // add observe
-                // does not include oldObserve
-                ResultsAnalyzerParameters postObserveAnalyzer = this.getAnalyzerParameters(sendObserveToClientOld.getPathPostParametersAdd(), sendObserveToClientNew.getPathPostParametersAdd());
-                //  send Request observe to Client
-                clients.forEach(client -> {
-                    Registration registration = client.getRegistration();
-                    if (postObserveAnalyzer.getPathPostParametersAdd().size() > 0) {
-                        this.readObserveFromProfile(client, postObserveAnalyzer.getPathPostParametersAdd(), OBSERVE);
-                    }
-                    // 5.3 del
-                    //  send Request cancel observe to Client
-                    if (postObserveAnalyzer.getPathPostParametersDel().size() > 0) {
-                        this.cancelObserveFromProfile(client, postObserveAnalyzer.getPathPostParametersDel());
-                    }
-                });
-            }
-        }
-    }
-
-    /**
-     * Compare old list with new list  after change AttrTelemetryObserve in config Profile
-     *
-     * @param parametersOld -
-     * @param parametersNew -
-     * @return ResultsAnalyzerParameters: add && new
-     */
-    private ResultsAnalyzerParameters getAnalyzerParameters(Set<String> parametersOld, Set<String> parametersNew) {
-        ResultsAnalyzerParameters analyzerParameters = null;
-        if (!parametersOld.equals(parametersNew)) {
-            analyzerParameters = new ResultsAnalyzerParameters();
-            analyzerParameters.setPathPostParametersAdd(parametersNew
-                    .stream().filter(p -> !parametersOld.contains(p)).collect(Collectors.toSet()));
-            analyzerParameters.setPathPostParametersDel(parametersOld
-                    .stream().filter(p -> !parametersNew.contains(p)).collect(Collectors.toSet()));
-        }
-        return analyzerParameters;
-    }
-
-    private ResultsAnalyzerParameters getAnalyzerParametersIn(Set<String> parametersObserve, Set<String> parameters) {
-        ResultsAnalyzerParameters analyzerParameters = new ResultsAnalyzerParameters();
-        analyzerParameters.setPathPostParametersAdd(parametersObserve
-                .stream().filter(parameters::contains).collect(Collectors.toSet()));
-        return analyzerParameters;
-    }
-
-    /**
-     * Update Resource value after change RezAttrTelemetry in config Profile
-     * send response Read to Client and add path to pathResAttrTelemetry in LwM2MClient.getAttrTelemetryObserveValue()
-     *
-     * @param targets - path Resources == [ "/2/0/0", "/2/0/1"]
-     */
-    private void readObserveFromProfile(LwM2mClient client, Set<String> targets, LwM2mTypeOper typeOper) {
-        targets.forEach(target -> {
-            LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(target));
-            if (pathIds.isResource()) {
-                if (READ.equals(typeOper)) {
-                    lwM2mTransportRequest.sendAllRequest(client, target, typeOper,
-                            null, this.config.getTimeout(), null);
-                } else if (OBSERVE.equals(typeOper)) {
-                    lwM2mTransportRequest.sendAllRequest(client, target, typeOper,
-                            null, this.config.getTimeout(), null);
-                }
-            }
-        });
-    }
-
-    private ResultsAnalyzerParameters getAnalyzerKeyName(ConcurrentHashMap<String, String> keyNameOld, ConcurrentHashMap<String, String> keyNameNew) {
-        ResultsAnalyzerParameters analyzerParameters = new ResultsAnalyzerParameters();
-        Set<String> paths = keyNameNew.entrySet()
-                .stream()
-                .filter(e -> !e.getValue().equals(keyNameOld.get(e.getKey())))
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)).keySet();
-        analyzerParameters.setPathPostParametersAdd(paths);
-        return analyzerParameters;
-    }
-
-    /**
-     * #3.4, #6
-     * #6
-     * #6.1 - send update WriteAttribute
-     * #6.2 - send empty WriteAttribute
-     *
-     * @param attributeLwm2mOld -
-     * @param attributeLwm2mNew -
-     * @return
-     */
-    private void getAnalyzerAttributeLwm2m(List<LwM2mClient> clients, JsonObject attributeLwm2mOld, JsonObject attributeLwm2mNew) {
-        ResultsAnalyzerParameters analyzerParameters = new ResultsAnalyzerParameters();
-        ConcurrentHashMap<String, Object> lwm2mAttributesOld = new Gson().fromJson(attributeLwm2mOld.toString(),
-                new TypeToken<ConcurrentHashMap<String, Object>>() {
-                }.getType());
-        ConcurrentHashMap<String, Object> lwm2mAttributesNew = new Gson().fromJson(attributeLwm2mNew.toString(),
-                new TypeToken<ConcurrentHashMap<String, Object>>() {
-                }.getType());
-        Set<String> pathOld = lwm2mAttributesOld.keySet();
-        Set<String> pathNew = lwm2mAttributesNew.keySet();
-        analyzerParameters.setPathPostParametersAdd(pathNew
-                .stream().filter(p -> !pathOld.contains(p)).collect(Collectors.toSet()));
-        analyzerParameters.setPathPostParametersDel(pathOld
-                .stream().filter(p -> !pathNew.contains(p)).collect(Collectors.toSet()));
-        Set<String> pathCommon = pathNew
-                .stream().filter(p -> pathOld.contains(p)).collect(Collectors.toSet());
-        Set<String> pathCommonChange = pathCommon
-                .stream().filter(p -> !lwm2mAttributesOld.get(p).equals(lwm2mAttributesNew.get(p))).collect(Collectors.toSet());
-        analyzerParameters.getPathPostParametersAdd().addAll(pathCommonChange);
-        // #6
-        // #6.2
-        if (analyzerParameters.getPathPostParametersAdd().size() > 0) {
-            clients.forEach(client -> {
-                Set<String> clientObjects = clientContext.getSupportedIdVerInClient(client);
-                Set<String> pathSend = analyzerParameters.getPathPostParametersAdd().stream().filter(target -> clientObjects.contains("/" + target.split(LWM2M_SEPARATOR_PATH)[1]))
-                        .collect(Collectors.toUnmodifiableSet());
-                if (!pathSend.isEmpty()) {
-                    ConcurrentHashMap<String, Object> finalParams = lwm2mAttributesNew;
-                    pathSend.forEach(target -> lwM2mTransportRequest.sendAllRequest(client, target, WRITE_ATTRIBUTES,
-                            finalParams.get(target), this.config.getTimeout(), null));
-                }
-            });
-        }
-        // #6.2
-        if (analyzerParameters.getPathPostParametersDel().size() > 0) {
-            clients.forEach(client -> {
-                Registration registration = client.getRegistration();
-                Set<String> clientObjects = clientContext.getSupportedIdVerInClient(client);
-                Set<String> pathSend = analyzerParameters.getPathPostParametersDel().stream().filter(target -> clientObjects.contains("/" + target.split(LWM2M_SEPARATOR_PATH)[1]))
-                        .collect(Collectors.toUnmodifiableSet());
-                if (!pathSend.isEmpty()) {
-                    pathSend.forEach(target -> {
-                        Map<String, Object> params = (Map<String, Object>) lwm2mAttributesOld.get(target);
-                        params.clear();
-                        params.put(OBJECT_VERSION, "");
-                        lwM2mTransportRequest.sendAllRequest(client, target, WRITE_ATTRIBUTES, params, this.config.getTimeout(), null);
-                    });
-                }
-            });
-        }
-
-    }
-
-    private void cancelObserveFromProfile(LwM2mClient lwM2mClient, Set<String> paramAnallyzer) {
-        paramAnallyzer.forEach(pathIdVer -> {
-                    if (this.getResourceValueFromLwM2MClient(lwM2mClient, pathIdVer) != null) {
-                        lwM2mTransportRequest.sendAllRequest(lwM2mClient, pathIdVer, OBSERVE_CANCEL, null, this.config.getTimeout(), null);
-                    }
-                }
-        );
-    }
-
-    private void updateResourcesValueToClient(LwM2mClient lwM2MClient, Object valueOld, Object valueNew, String path) {
-        if (valueNew != null && (valueOld == null || !valueNew.toString().equals(valueOld.toString()))) {
-            lwM2mTransportRequest.sendAllRequest(lwM2MClient, path, WRITE_REPLACE, valueNew, this.config.getTimeout(), null);
-        } else {
-            log.error("Failed update resource [{}] [{}]", path, valueNew);
-            String logMsg = String.format("%s: Failed update resource path - %s value - %s. Value is not changed or bad",
-                    LOG_LW2M_ERROR, path, valueNew);
-            this.sendLogsToThingsboard(lwM2MClient, logMsg);
-            log.info("Failed update resource [{}] [{}]", path, valueNew);
-        }
-    }
-
-    /**
-     * @param updateCredentials - Credentials include config only security Client (without config attr/telemetry...)
-     *                          config attr/telemetry... in profile
-     */
-    public void onToTransportUpdateCredentials(TransportProtos.ToTransportUpdateCredentialsProto updateCredentials) {
-        log.info("[{}] idList [{}] valueList updateCredentials", updateCredentials.getCredentialsIdList(), updateCredentials.getCredentialsValueList());
-    }
-
-    /**
-     * Get path to resource from profile equal keyName
-     *
-     * @param sessionInfo -
-     * @param name        -
-     * @return -
-     */
-    public String getPresentPathIntoProfile(TransportProtos.SessionInfoProto sessionInfo, String name) {
-        LwM2mClientProfile profile = clientContext.getProfile(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
-        LwM2mClient lwM2mClient = clientContext.getClientBySessionInfo(sessionInfo);
-        return profile.getPostKeyNameProfile().getAsJsonObject().entrySet().stream()
-                .filter(e -> e.getValue().getAsString().equals(name) && validateResourceInModel(lwM2mClient, e.getKey(), false)).findFirst().map(Map.Entry::getKey)
-                .orElse(null);
-    }
-
-    /**
-     * 1. FirmwareUpdate:
-     * - msg.getSharedUpdatedList().forEach(tsKvProto -> {tsKvProto.getKv().getKey().indexOf(FIRMWARE_UPDATE_PREFIX, 0) == 0
-     * 2. Update resource value on client: if there is a difference in values between the current resource values and the shared attribute values
-     * - Get path resource by result attributesResponse
-     *
-     * @param attributesResponse -
-     * @param sessionInfo        -
-     */
-    public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg attributesResponse, TransportProtos.SessionInfoProto sessionInfo) {
-        try {
-            List<TransportProtos.TsKvProto> tsKvProtos = attributesResponse.getSharedAttributeListList();
-            this.updateAttributeFromThingsboard(tsKvProtos, sessionInfo);
-        } catch (Exception e) {
-            log.error("", e);
-        }
-    }
-
-    /**
-     * #1.1 If two names have equal path => last time attribute
-     * #2.1 if there is a difference in values between the current resource values and the shared attribute values
-     * => send to client Request Update of value (new value from shared attribute)
-     * and LwM2MClient.delayedRequests.add(path)
-     * #2.1 if there is not a difference in values between the current resource values and the shared attribute values
-     *
-     * @param tsKvProtos
-     * @param sessionInfo
-     */
-    public void updateAttributeFromThingsboard(List<TransportProtos.TsKvProto> tsKvProtos, TransportProtos.SessionInfoProto sessionInfo) {
-        LwM2mClient lwM2MClient = clientContext.getClientBySessionInfo(sessionInfo);
-        if (lwM2MClient != null) {
-            log.warn("1) UpdateAttributeFromThingsboard, tsKvProtos [{}]", tsKvProtos);
-            tsKvProtos.forEach(tsKvProto -> {
-                String pathIdVer = this.getPresentPathIntoProfile(sessionInfo, tsKvProto.getKv().getKey());
-                if (pathIdVer != null) {
-                    // #1.1
-                    if (lwM2MClient.getDelayedRequests().containsKey(pathIdVer) && tsKvProto.getTs() > lwM2MClient.getDelayedRequests().get(pathIdVer).getTs()) {
-                        lwM2MClient.getDelayedRequests().put(pathIdVer, tsKvProto);
-                    } else if (!lwM2MClient.getDelayedRequests().containsKey(pathIdVer)) {
-                        lwM2MClient.getDelayedRequests().put(pathIdVer, tsKvProto);
-                    }
-                }
-            });
-            // #2.1
-            lwM2MClient.getDelayedRequests().forEach((pathIdVer, tsKvProto) -> {
-                this.updateResourcesValueToClient(lwM2MClient, this.getResourceValueFormatKv(lwM2MClient, pathIdVer),
-                        getValueFromKvProto(tsKvProto.getKv()), pathIdVer);
-            });
-        } else {
-            log.error("UpdateAttributeFromThingsboard, lwM2MClient is null");
-        }
-    }
-
-    /**
-     * @param lwM2MClient -
-     * @return SessionInfoProto -
-     */
-    private SessionInfoProto getSessionInfo(LwM2mClient lwM2MClient) {
-        if (lwM2MClient != null && lwM2MClient.getSession() != null) {
-            return lwM2MClient.getSession();
-        }
-        return null;
-    }
-
-    /**
-     * @param registration - Registration LwM2M Client
-     * @return - sessionInfo after access connect client
-     */
-    public SessionInfoProto getSessionInfoOrCloseSession(Registration registration) {
-        return getSessionInfo(clientContext.getClientByEndpoint(registration.getEndpoint()));
-    }
-
-    /**
-     * if sessionInfo removed from sessions, then new registerAsyncSession
-     *
-     * @param sessionInfo -
-     */
-    private void reportActivityAndRegister(SessionInfoProto sessionInfo) {
-        if (sessionInfo != null && transportService.reportActivity(sessionInfo) == null) {
-            transportService.registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(this, sessionInfo));
-            this.reportActivitySubscription(sessionInfo);
-        }
-    }
-
-    private void reportActivity() {
-        clientContext.getLwM2mClients().forEach(client -> reportActivityAndRegister(client.getSession()));
-    }
-
-    /**
-     * #1. !!!  sharedAttr === profileAttr  !!!
-     * - If there is a difference in values between the current resource values and the shared attribute values
-     * - when the client connects to the server
-     * #1.1 get attributes name from profile include name resources in ModelObject if resource  isWritable
-     * #1.2 #1 size > 0 => send Request getAttributes to thingsboard
-     * #2. FirmwareAttribute subscribe:
-     *
-     * @param lwM2MClient - LwM2M Client
-     */
-    public void putDelayedUpdateResourcesThingsboard(LwM2mClient lwM2MClient) {
-        SessionInfoProto sessionInfo = this.getSessionInfo(lwM2MClient);
-        if (sessionInfo != null) {
-            //#1.1
-            ConcurrentMap<String, String> keyNamesMap = this.getNamesFromProfileForSharedAttributes(lwM2MClient);
-            if (keyNamesMap.values().size() > 0) {
-                try {
-                    //#1.2
-                    TransportProtos.GetAttributeRequestMsg getAttributeMsg = adaptor.convertToGetAttributes(null, keyNamesMap.values());
-                    transportService.process(sessionInfo, getAttributeMsg, getAckCallback(lwM2MClient, getAttributeMsg.getRequestId(), DEVICE_ATTRIBUTES_REQUEST));
-                } catch (AdaptorException e) {
-                    log.trace("Failed to decode get attributes request", e);
-                }
-            }
-
-        }
-    }
-
-    public void getInfoFirmwareUpdate(LwM2mClient lwM2MClient, LwM2mClientRpcRequest rpcRequest) {
-        if (lwM2MClient.getRegistration().getSupportedVersion(FW_5_ID) != null) {
-            SessionInfoProto sessionInfo = this.getSessionInfo(lwM2MClient);
-            if (sessionInfo != null) {
-                DefaultLwM2MTransportMsgHandler handler = this;
-                this.transportService.process(sessionInfo, createOtaPackageRequestMsg(sessionInfo, OtaPackageType.FIRMWARE.name()),
-                        new TransportServiceCallback<>() {
-                            @Override
-                            public void onSuccess(TransportProtos.GetOtaPackageResponseMsg response) {
-                                if (TransportProtos.ResponseStatus.SUCCESS.equals(response.getResponseStatus())
-                                        && response.getType().equals(OtaPackageType.FIRMWARE.name())) {
-                                    LwM2mFwSwUpdate fwUpdate = lwM2MClient.getFwUpdate(clientContext);
-                                    if (rpcRequest != null) {
-                                        fwUpdate.setStateUpdate(INITIATED.name());
-                                    }
-                                    if (!FAILED.name().equals(fwUpdate.getStateUpdate())) {
-                                        log.warn("7) firmware start with ver: [{}]", response.getVersion());
-                                        fwUpdate.setRpcRequest(rpcRequest);
-                                        fwUpdate.setCurrentVersion(response.getVersion());
-                                        fwUpdate.setCurrentTitle(response.getTitle());
-                                        fwUpdate.setCurrentId(new UUID(response.getOtaPackageIdMSB(), response.getOtaPackageIdLSB()));
-                                        if (rpcRequest == null) {
-                                            fwUpdate.sendReadObserveInfo(lwM2mTransportRequest);
-                                        } else {
-                                            fwUpdate.writeFwSwWare(handler, lwM2mTransportRequest);
-                                        }
-                                    } else {
-                                        String msgError = String.format("OtaPackage device: %s, version: %s, stateUpdate: %s",
-                                                lwM2MClient.getDeviceName(), response.getVersion(), fwUpdate.getStateUpdate());
-                                        log.warn("7_1 [{}]", msgError);
-                                    }
-                                } else {
-                                    String msgError = String.format("OtaPackage device: %s, responseStatus: %s",
-                                            lwM2MClient.getDeviceName(), response.getResponseStatus().toString());
-                                    log.trace(msgError);
-                                    if (rpcRequest != null) {
-                                        sendErrorRpcResponse(rpcRequest, msgError, sessionInfo);
-                                    }
-                                }
-                            }
-
-                            @Override
-                            public void onError(Throwable e) {
-                                log.trace("Failed to process firmwareUpdate ", e);
-                            }
-                        });
-            }
-        }
-    }
-
-    public void getInfoSoftwareUpdate(LwM2mClient lwM2MClient, LwM2mClientRpcRequest rpcRequest) {
-        if (lwM2MClient.getRegistration().getSupportedVersion(SW_ID) != null) {
-            SessionInfoProto sessionInfo = this.getSessionInfo(lwM2MClient);
-            if (sessionInfo != null) {
-                DefaultLwM2MTransportMsgHandler handler = this;
-                transportService.process(sessionInfo, createOtaPackageRequestMsg(sessionInfo, OtaPackageType.SOFTWARE.name()),
-                        new TransportServiceCallback<>() {
-                            @Override
-                            public void onSuccess(TransportProtos.GetOtaPackageResponseMsg response) {
-                                if (TransportProtos.ResponseStatus.SUCCESS.equals(response.getResponseStatus())
-                                        && response.getType().equals(OtaPackageType.SOFTWARE.name())) {
-                                    lwM2MClient.getSwUpdate().setRpcRequest(rpcRequest);
-                                    lwM2MClient.getSwUpdate().setCurrentVersion(response.getVersion());
-                                    lwM2MClient.getSwUpdate().setCurrentTitle(response.getTitle());
-                                    lwM2MClient.getSwUpdate().setCurrentId(new OtaPackageId(new UUID(response.getOtaPackageIdMSB(), response.getOtaPackageIdLSB())).getId());
-                                    lwM2MClient.getSwUpdate().sendReadObserveInfo(lwM2mTransportRequest);
-                                    if (rpcRequest == null) {
-                                        lwM2MClient.getSwUpdate().sendReadObserveInfo(lwM2mTransportRequest);
-                                    } else {
-                                        lwM2MClient.getSwUpdate().writeFwSwWare(handler, lwM2mTransportRequest);
-                                    }
-                                } else {
-                                    log.trace("Software [{}] [{}]", lwM2MClient.getDeviceName(), response.getResponseStatus().toString());
-                                }
-                            }
-
-                            @Override
-                            public void onError(Throwable e) {
-                                log.trace("Failed to process softwareUpdate ", e);
-                            }
-                        });
-            }
-        }
-    }
-
-    private TransportProtos.GetOtaPackageRequestMsg createOtaPackageRequestMsg(SessionInfoProto sessionInfo, String nameFwSW) {
-        return TransportProtos.GetOtaPackageRequestMsg.newBuilder()
-                .setDeviceIdMSB(sessionInfo.getDeviceIdMSB())
-                .setDeviceIdLSB(sessionInfo.getDeviceIdLSB())
-                .setTenantIdMSB(sessionInfo.getTenantIdMSB())
-                .setTenantIdLSB(sessionInfo.getTenantIdLSB())
-                .setType(nameFwSW)
-                .build();
-    }
-
-    /**
-     * !!!  sharedAttr === profileAttr  !!!
-     * Get names or keyNames from profile:  resources IsWritable
-     *
-     * @param lwM2MClient -
-     * @return ArrayList  keyNames from profile profileAttr && IsWritable
-     */
-    private ConcurrentMap<String, String> getNamesFromProfileForSharedAttributes(LwM2mClient lwM2MClient) {
-
-        LwM2mClientProfile profile = clientContext.getProfile(lwM2MClient.getProfileId());
-        return new Gson().fromJson(profile.getPostKeyNameProfile().toString(),
-                new TypeToken<ConcurrentHashMap<String, String>>() {
-                }.getType());
-    }
-
-    private boolean validateResourceInModel(LwM2mClient lwM2mClient, String pathIdVer, boolean isWritableNotOptional) {
-        ResourceModel resourceModel = lwM2mClient.getResourceModel(pathIdVer, this.config
-                .getModelProvider());
-        Integer objectId = new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer)).getObjectId();
-        String objectVer = validateObjectVerFromKey(pathIdVer);
-        return resourceModel != null && (isWritableNotOptional ?
-                objectId != null && objectVer != null && objectVer.equals(lwM2mClient.getRegistration().getSupportedVersion(objectId)) && resourceModel.operations.isWritable() :
-                objectId != null && objectVer != null && objectVer.equals(lwM2mClient.getRegistration().getSupportedVersion(objectId)));
-    }
-
-    public LwM2MTransportServerConfig getConfig() {
-        return this.config;
-    }
-
-    private void reportActivitySubscription(TransportProtos.SessionInfoProto sessionInfo) {
-        transportService.process(sessionInfo, TransportProtos.SubscriptionInfoProto.newBuilder()
-                .setAttributeSubscription(true)
-                .setRpcSubscription(true)
-                .setLastActivityTime(System.currentTimeMillis())
-                .build(), TransportServiceCallback.EMPTY);
-    }
-}

@@ -26,8 +26,8 @@ import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.californium.LeshanServerBuilder;
 import org.eclipse.leshan.server.californium.LeshanServerBuilder;
 import org.eclipse.leshan.server.californium.registration.CaliforniumRegistrationStore;
 import org.eclipse.leshan.server.californium.registration.CaliforniumRegistrationStore;
 import org.eclipse.leshan.server.model.LwM2mModelProvider;
 import org.eclipse.leshan.server.model.LwM2mModelProvider;
-import org.eclipse.leshan.server.security.EditableSecurityStore;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.cache.ota.OtaPackageDataCache;
 import org.thingsboard.server.common.data.StringUtils;
 import org.thingsboard.server.common.data.StringUtils;
 import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
 import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
@@ -35,8 +35,8 @@ import org.thingsboard.server.transport.lwm2m.secure.LWM2MGenerationPSkRPkECC;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MAuthorizer;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MAuthorizer;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MDtlsCertificateVerifier;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MDtlsCertificateVerifier;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
-import org.thingsboard.server.transport.lwm2m.server.store.TbEditableSecurityStore;
 import org.thingsboard.server.transport.lwm2m.server.store.TbSecurityStore;
 import org.thingsboard.server.transport.lwm2m.server.store.TbSecurityStore;
+import org.thingsboard.server.transport.lwm2m.server.uplink.DefaultLwM2MUplinkMsgHandler;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PostConstruct;
@@ -81,7 +81,8 @@ public class DefaultLwM2mTransportService implements LwM2MTransportService {
     private final LwM2mTransportContext context;
     private final LwM2mTransportContext context;
     private final LwM2MTransportServerConfig config;
     private final LwM2MTransportServerConfig config;
     private final LwM2mTransportServerHelper helper;
     private final LwM2mTransportServerHelper helper;
-    private final DefaultLwM2MTransportMsgHandler handler;
+    private final OtaPackageDataCache otaPackageDataCache;
+    private final DefaultLwM2MUplinkMsgHandler handler;
     private final CaliforniumRegistrationStore registrationStore;
     private final CaliforniumRegistrationStore registrationStore;
     private final TbSecurityStore securityStore;
     private final TbSecurityStore securityStore;
     private final LwM2mClientContext lwM2mClientContext;
     private final LwM2mClientContext lwM2mClientContext;
@@ -104,8 +105,7 @@ public class DefaultLwM2mTransportService implements LwM2MTransportService {
          * "coap://host:port/{path}/{token}/{nameFile}"
          * "coap://host:port/{path}/{token}/{nameFile}"
          */
          */
 
 
-
-        LwM2mTransportCoapResource otaCoapResource = new LwM2mTransportCoapResource(handler, FIRMWARE_UPDATE_COAP_RECOURSE);
+        LwM2mTransportCoapResource otaCoapResource = new LwM2mTransportCoapResource(otaPackageDataCache, FIRMWARE_UPDATE_COAP_RECOURSE);
         this.server.coap().getServer().add(otaCoapResource);
         this.server.coap().getServer().add(otaCoapResource);
         this.startLhServer();
         this.startLhServer();
         this.context.setServer(server);
         this.context.setServer(server);

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+public enum LwM2MFirmwareUpdateStrategy {
+    OBJ_5_BINARY(1, "ObjectId 5, Binary"),
+    OBJ_5_TEMP_URL(2, "ObjectId 5, URI"),
+    OBJ_19_BINARY(3, "ObjectId 19, Binary");
+
+    public int code;
+    public String type;
+
+    LwM2MFirmwareUpdateStrategy(int code, String type) {
+        this.code = code;
+        this.type = type;
+    }
+
+    public static LwM2MFirmwareUpdateStrategy fromStrategyFwByType(String type) {
+        for (LwM2MFirmwareUpdateStrategy to : LwM2MFirmwareUpdateStrategy.values()) {
+            if (to.type.equals(type)) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported FW State type  : %s", type));
+    }
+
+    public static LwM2MFirmwareUpdateStrategy fromStrategyFwByCode(int code) {
+        for (LwM2MFirmwareUpdateStrategy to : LwM2MFirmwareUpdateStrategy.values()) {
+            if (to.code == code) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported FW Strategy code : %s", code));
+    }
+}

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+public enum LwM2MSoftwareUpdateStrategy {
+    BINARY(1, "ObjectId 9, Binary"),
+    TEMP_URL(2, "ObjectId 9, URI");
+
+    public int code;
+    public String type;
+
+    LwM2MSoftwareUpdateStrategy(int code, String type) {
+        this.code = code;
+        this.type = type;
+    }
+
+    public static LwM2MSoftwareUpdateStrategy fromStrategySwByType(String type) {
+        for (LwM2MSoftwareUpdateStrategy to : LwM2MSoftwareUpdateStrategy.values()) {
+            if (to.type.equals(type)) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported SW Strategy type  : %s", type));
+    }
+
+    public static LwM2MSoftwareUpdateStrategy fromStrategySwByCode(int code) {
+        for (LwM2MSoftwareUpdateStrategy to : LwM2MSoftwareUpdateStrategy.values()) {
+            if (to.code == code) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported SW Strategy code : %s", code));
+    }
+
+}

@@ -84,10 +84,10 @@ public class LwM2mNetworkConfig {
          Create new instance of udp endpoint context matcher.
          Create new instance of udp endpoint context matcher.
          Params:
          Params:
          checkAddress
          checkAddress
-         – true with address check, (STRICT, UDP)
+         – true with address check, (STRICT, UDP) - if port Registration of client is changed - it is bad
          - false, without
          - false, without
          */
          */
-        coapConfig.setString(NetworkConfig.Keys.RESPONSE_MATCHING, "STRICT");
+        coapConfig.setString(NetworkConfig.Keys.RESPONSE_MATCHING, "RELAXED");
         /**
         /**
          https://tools.ietf.org/html/rfc7959#section-2.9.3
          https://tools.ietf.org/html/rfc7959#section-2.9.3
          The block size (number of bytes) to use when doing a blockwise transfer. \
          The block size (number of bytes) to use when doing a blockwise transfer. \
@@ -103,7 +103,7 @@ public class LwM2mNetworkConfig {
          */
          */
         coapConfig.setInt(NetworkConfig.Keys.MAX_MESSAGE_SIZE, 1024);
         coapConfig.setInt(NetworkConfig.Keys.MAX_MESSAGE_SIZE, 1024);
 
 
-        coapConfig.setInt(NetworkConfig.Keys.MAX_RETRANSMIT, 4);
+        coapConfig.setInt(NetworkConfig.Keys.MAX_RETRANSMIT, 10);
 
 
         return coapConfig;
         return coapConfig;
     }
     }

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+import lombok.Getter;
+
+/**
+ * Define the behavior of a write request.
+ */
+public enum LwM2mOperationType {
+
+    READ(0, "Read", true),
+    DISCOVER(1, "Discover", true),
+    DISCOVER_ALL(2, "DiscoverAll", false),
+    OBSERVE_READ_ALL(3, "ObserveReadAll", false),
+
+    OBSERVE(4, "Observe", true),
+    OBSERVE_CANCEL(5, "ObserveCancel", true),
+    OBSERVE_CANCEL_ALL(6, "ObserveCancelAll", false),
+    EXECUTE(7, "Execute", true),
+    /**
+     * Replaces the Object Instance or the Resource(s) with the new value provided in the “Write” operation. (see
+     * section 5.3.3 of the LW M2M spec).
+     * if all resources are to be replaced
+     */
+    WRITE_REPLACE(8, "WriteReplace", true),
+
+    /**
+     * Adds or updates Resources provided in the new value and leaves other existing Resources unchanged. (see section
+     * 5.3.3 of the LW M2M spec).
+     * if this is a partial update request
+     */
+    WRITE_UPDATE(9, "WriteUpdate", true),
+    WRITE_ATTRIBUTES(10, "WriteAttributes", true),
+    DELETE(11, "Delete", true),
+
+    // only for RPC
+    FW_UPDATE(12, "FirmwareUpdate", false);
+
+//        FW_READ_INFO(12, "FirmwareReadInfo"),
+//        SW_READ_INFO(15, "SoftwareReadInfo"),
+//        SW_UPDATE(16, "SoftwareUpdate"),
+//        SW_UNINSTALL(18, "SoftwareUninstall");
+
+    @Getter
+    private final int code;
+    @Getter
+    private final String type;
+    @Getter
+    private final boolean hasObjectId;
+
+    LwM2mOperationType(int code, String type, boolean hasObjectId) {
+        this.code = code;
+        this.type = type;
+        this.hasObjectId = hasObjectId;
+    }
+
+    public static LwM2mOperationType fromType(String type) {
+        for (LwM2mOperationType to : LwM2mOperationType.values()) {
+            if (to.type.equals(type)) {
+                return to;
+            }
+        }
+        return null;
+    }
+}

@@ -23,18 +23,18 @@ import org.eclipse.leshan.server.queue.PresenceListener;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.registration.RegistrationListener;
 import org.eclipse.leshan.server.registration.RegistrationListener;
 import org.eclipse.leshan.server.registration.RegistrationUpdate;
 import org.eclipse.leshan.server.registration.RegistrationUpdate;
+import org.thingsboard.server.transport.lwm2m.server.uplink.LwM2mUplinkMsgHandler;
 
 
 import java.util.Collection;
 import java.util.Collection;
 
 
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_INFO;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromObjectIdToIdVer;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertObjectIdToVersionedId;
 
 
 @Slf4j
 @Slf4j
 public class LwM2mServerListener {
 public class LwM2mServerListener {
 
 
-    private final LwM2mTransportMsgHandler service;
+    private final LwM2mUplinkMsgHandler service;
 
 
-    public LwM2mServerListener(LwM2mTransportMsgHandler service) {
+    public LwM2mServerListener(LwM2mUplinkMsgHandler service) {
         this.service = service;
         this.service = service;
     }
     }
 
 
@@ -86,30 +86,24 @@ public class LwM2mServerListener {
 
 
         @Override
         @Override
         public void cancelled(Observation observation) {
         public void cancelled(Observation observation) {
-            String msg = String.format("%s:  Canceled Observation  %s.", LOG_LW2M_INFO, observation.getPath());
-            service.sendLogsToThingsboard(observation.getRegistrationId(), msg);
-            log.warn(msg);
+            log.trace("Canceled Observation {}.", observation.getPath());
         }
         }
 
 
         @Override
         @Override
         public void onResponse(Observation observation, Registration registration, ObserveResponse response) {
         public void onResponse(Observation observation, Registration registration, ObserveResponse response) {
             if (registration != null) {
             if (registration != null) {
-                service.onUpdateValueAfterReadResponse(registration, convertPathFromObjectIdToIdVer(observation.getPath().toString(),
-                        registration), response, null);
+                service.onUpdateValueAfterReadResponse(registration, convertObjectIdToVersionedId(observation.getPath().toString(), registration), response);
             }
             }
         }
         }
 
 
         @Override
         @Override
         public void onError(Observation observation, Registration registration, Exception error) {
         public void onError(Observation observation, Registration registration, Exception error) {
-            log.error(String.format("Unable to handle notification of [%s:%s]", observation.getRegistrationId(), observation.getPath()), error);
+            log.error("Unable to handle notification of [{}:{}]", observation.getRegistrationId(), observation.getPath(), error);
         }
         }
 
 
         @Override
         @Override
         public void newObservation(Observation observation, Registration registration) {
         public void newObservation(Observation observation, Registration registration) {
-            String msg = String.format("%s: Successful start newObservation  %s.", LOG_LW2M_INFO,
-                    observation.getPath());
-            log.warn(msg);
-            service.sendLogsToThingsboard(registration.getId(), msg);
+            log.trace("Successful start newObservation {}.", observation.getPath());
         }
         }
     };
     };
 }
 }

@@ -17,6 +17,7 @@ package org.thingsboard.server.transport.lwm2m.server;
 
 
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.GenericFutureListener;
 import io.netty.util.concurrent.GenericFutureListener;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.NotNull;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
@@ -30,28 +31,29 @@ import org.thingsboard.server.gen.transport.TransportProtos.SessionCloseNotifica
 import org.thingsboard.server.gen.transport.TransportProtos.ToDeviceRpcRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToDeviceRpcRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToServerRpcResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToServerRpcResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportUpdateCredentialsProto;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportUpdateCredentialsProto;
+import org.thingsboard.server.transport.lwm2m.server.attributes.LwM2MAttributesService;
+import org.thingsboard.server.transport.lwm2m.server.rpc.LwM2MRpcRequestHandler;
+import org.thingsboard.server.transport.lwm2m.server.uplink.LwM2mUplinkMsgHandler;
 
 
 import java.util.Optional;
 import java.util.Optional;
 import java.util.UUID;
 import java.util.UUID;
 
 
 @Slf4j
 @Slf4j
+@RequiredArgsConstructor
 public class LwM2mSessionMsgListener implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
 public class LwM2mSessionMsgListener implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
-    private DefaultLwM2MTransportMsgHandler handler;
-    private TransportProtos.SessionInfoProto sessionInfo;
-
-    public LwM2mSessionMsgListener(DefaultLwM2MTransportMsgHandler handler, TransportProtos.SessionInfoProto sessionInfo) {
-        this.handler = handler;
-        this.sessionInfo = sessionInfo;
-    }
+    private final LwM2mUplinkMsgHandler handler;
+    private final LwM2MAttributesService attributesService;
+    private final LwM2MRpcRequestHandler rpcHandler;
+    private final TransportProtos.SessionInfoProto sessionInfo;
 
 
     @Override
     @Override
     public void onGetAttributesResponse(GetAttributeResponseMsg getAttributesResponse) {
     public void onGetAttributesResponse(GetAttributeResponseMsg getAttributesResponse) {
-        this.handler.onGetAttributesResponse(getAttributesResponse, this.sessionInfo);
+        this.attributesService.onGetAttributesResponse(getAttributesResponse, this.sessionInfo);
     }
     }
 
 
     @Override
     @Override
     public void onAttributeUpdate(AttributeUpdateNotificationMsg attributeUpdateNotification) {
     public void onAttributeUpdate(AttributeUpdateNotificationMsg attributeUpdateNotification) {
-        this.handler.onAttributeUpdate(attributeUpdateNotification, this.sessionInfo);
+        this.attributesService.onAttributesUpdate(attributeUpdateNotification, this.sessionInfo);
      }
      }
 
 
     @Override
     @Override
@@ -76,12 +78,12 @@ public class LwM2mSessionMsgListener implements GenericFutureListener<Future<? s
 
 
     @Override
     @Override
     public void onToDeviceRpcRequest(ToDeviceRpcRequestMsg toDeviceRequest) {
     public void onToDeviceRpcRequest(ToDeviceRpcRequestMsg toDeviceRequest) {
-        this.handler.onToDeviceRpcRequest(toDeviceRequest,this.sessionInfo);
+        this.rpcHandler.onToDeviceRpcRequest(toDeviceRequest,this.sessionInfo);
     }
     }
 
 
     @Override
     @Override
     public void onToServerRpcResponse(ToServerRpcResponseMsg toServerResponse) {
     public void onToServerRpcResponse(ToServerRpcResponseMsg toServerResponse) {
-        this.handler.onToServerRpcResponse(toServerResponse);
+        this.rpcHandler.onToServerRpcResponse(toServerResponse);
     }
     }
 
 
     @Override
     @Override

@@ -24,6 +24,9 @@ import org.eclipse.californium.core.observe.ObserveRelation;
 import org.eclipse.californium.core.server.resources.CoapExchange;
 import org.eclipse.californium.core.server.resources.CoapExchange;
 import org.eclipse.californium.core.server.resources.Resource;
 import org.eclipse.californium.core.server.resources.Resource;
 import org.eclipse.californium.core.server.resources.ResourceObserver;
 import org.eclipse.californium.core.server.resources.ResourceObserver;
+import org.thingsboard.server.cache.ota.OtaPackageDataCache;
+import org.thingsboard.server.transport.lwm2m.server.uplink.DefaultLwM2MUplinkMsgHandler;
+import org.thingsboard.server.transport.lwm2m.server.uplink.LwM2mUplinkMsgHandler;
 
 
 import java.util.UUID;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
@@ -37,11 +40,11 @@ import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.S
 public class LwM2mTransportCoapResource extends AbstractLwM2mTransportResource {
 public class LwM2mTransportCoapResource extends AbstractLwM2mTransportResource {
     private final ConcurrentMap<String, ObserveRelation> tokenToObserveRelationMap = new ConcurrentHashMap<>();
     private final ConcurrentMap<String, ObserveRelation> tokenToObserveRelationMap = new ConcurrentHashMap<>();
     private final ConcurrentMap<String, AtomicInteger> tokenToObserveNotificationSeqMap = new ConcurrentHashMap<>();
     private final ConcurrentMap<String, AtomicInteger> tokenToObserveNotificationSeqMap = new ConcurrentHashMap<>();
-    private final LwM2mTransportMsgHandler handler;
+    private final OtaPackageDataCache otaPackageDataCache;
 
 
-    public LwM2mTransportCoapResource(LwM2mTransportMsgHandler handler, String name) {
+    public LwM2mTransportCoapResource(OtaPackageDataCache otaPackageDataCache, String name) {
         super(name);
         super(name);
-        this.handler = handler;
+        this.otaPackageDataCache = otaPackageDataCache;
         this.setObservable(true); // enable observing
         this.setObservable(true); // enable observing
         this.addObserver(new CoapResourceObserver());
         this.addObserver(new CoapResourceObserver());
     }
     }
@@ -140,9 +143,9 @@ public class LwM2mTransportCoapResource extends AbstractLwM2mTransportResource {
             response.setPayload(fwData);
             response.setPayload(fwData);
             if (exchange.getRequestOptions().getBlock2() != null) {
             if (exchange.getRequestOptions().getBlock2() != null) {
                 int chunkSize = exchange.getRequestOptions().getBlock2().getSzx();
                 int chunkSize = exchange.getRequestOptions().getBlock2().getSzx();
-                boolean moreFlag = fwData.length > chunkSize;
-                response.getOptions().setBlock2(chunkSize, moreFlag, 0);
-                log.warn("92) with blokc2 Send currentId: [{}], length: [{}], chunkSize [{}], moreFlag [{}]", currentId.toString(), fwData.length, chunkSize, moreFlag);
+                boolean lastFlag = fwData.length > chunkSize;
+                response.getOptions().setBlock2(chunkSize, lastFlag, 0);
+                log.warn("92) with blokc2 Send currentId: [{}], length: [{}], chunkSize [{}], moreFlag [{}]", currentId.toString(), fwData.length, chunkSize, lastFlag);
             }
             }
             else {
             else {
                 log.warn("92) with block1 Send currentId: [{}], length: [{}], ", currentId.toString(), fwData.length);
                 log.warn("92) with block1 Send currentId: [{}], length: [{}], ", currentId.toString(), fwData.length);
@@ -152,7 +155,7 @@ public class LwM2mTransportCoapResource extends AbstractLwM2mTransportResource {
     }
     }
 
 
     private byte[] getOtaData(UUID currentId) {
     private byte[] getOtaData(UUID currentId) {
-        return ((DefaultLwM2MTransportMsgHandler) handler).otaPackageDataCache.get(currentId.toString());
+        return otaPackageDataCache.get(currentId.toString());
     }
     }
 
 
 }
 }

-/**
- * Copyright © 2016-2021 The Thingsboard Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.thingsboard.server.transport.lwm2m.server;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.eclipse.californium.core.coap.CoAP;
-import org.eclipse.californium.core.coap.Response;
-import org.eclipse.leshan.core.Link;
-import org.eclipse.leshan.core.model.ResourceModel;
-import org.eclipse.leshan.core.node.LwM2mNode;
-import org.eclipse.leshan.core.node.LwM2mObject;
-import org.eclipse.leshan.core.node.LwM2mObjectInstance;
-import org.eclipse.leshan.core.node.LwM2mPath;
-import org.eclipse.leshan.core.node.LwM2mResource;
-import org.eclipse.leshan.core.node.LwM2mSingleResource;
-import org.eclipse.leshan.core.node.ObjectLink;
-import org.eclipse.leshan.core.observation.Observation;
-import org.eclipse.leshan.core.request.ContentFormat;
-import org.eclipse.leshan.core.request.DeleteRequest;
-import org.eclipse.leshan.core.request.DiscoverRequest;
-import org.eclipse.leshan.core.request.ExecuteRequest;
-import org.eclipse.leshan.core.request.ObserveRequest;
-import org.eclipse.leshan.core.request.ReadRequest;
-import org.eclipse.leshan.core.request.SimpleDownlinkRequest;
-import org.eclipse.leshan.core.request.WriteAttributesRequest;
-import org.eclipse.leshan.core.request.WriteRequest;
-import org.eclipse.leshan.core.request.exception.ClientSleepingException;
-import org.eclipse.leshan.core.response.DeleteResponse;
-import org.eclipse.leshan.core.response.DiscoverResponse;
-import org.eclipse.leshan.core.response.ExecuteResponse;
-import org.eclipse.leshan.core.response.LwM2mResponse;
-import org.eclipse.leshan.core.response.ReadResponse;
-import org.eclipse.leshan.core.response.ResponseCallback;
-import org.eclipse.leshan.core.response.WriteAttributesResponse;
-import org.eclipse.leshan.core.response.WriteResponse;
-import org.eclipse.leshan.core.util.Hex;
-import org.eclipse.leshan.core.util.NamedThreadFactory;
-import org.eclipse.leshan.server.registration.Registration;
-import org.springframework.stereotype.Service;
-import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
-import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientRpcRequest;
-import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
-
-import javax.annotation.PostConstruct;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Date;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.stream.Collectors;
-
-import static org.eclipse.californium.core.coap.CoAP.ResponseCode.CONTENT;
-import static org.eclipse.leshan.core.ResponseCode.BAD_REQUEST;
-import static org.eclipse.leshan.core.ResponseCode.NOT_FOUND;
-import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.DOWNLOADED;
-import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.FAILED;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportServerHelper.getContentFormatByResourceModelType;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.DEFAULT_TIMEOUT;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_PACKAGE_5_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_UPDATE_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_ERROR;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_INFO;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_VALUE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.DISCOVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.EXECUTE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE_CANCEL;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE_READ_ALL;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_ATTRIBUTES;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_REPLACE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_UPDATE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.RESPONSE_REQUEST_CHANNEL;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SW_INSTALL_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SW_PACKAGE_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromIdVerToObjectId;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromObjectIdToIdVer;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.createWriteAttributeRequest;
-
-@Slf4j
-@Service
-@TbLwM2mTransportComponent
-@RequiredArgsConstructor
-public class LwM2mTransportRequest {
-    private ExecutorService responseRequestExecutor;
-
-    public LwM2mValueConverterImpl converter;
-
-    private final LwM2mTransportContext context;
-    private final LwM2MTransportServerConfig config;
-    private final LwM2mClientContext lwM2mClientContext;
-    private final DefaultLwM2MTransportMsgHandler handler;
-
-    @PostConstruct
-    public void init() {
-        this.converter = LwM2mValueConverterImpl.getInstance();
-        responseRequestExecutor = Executors.newFixedThreadPool(this.config.getResponsePoolSize(),
-                new NamedThreadFactory(String.format("LwM2M %s channel response after request", RESPONSE_REQUEST_CHANNEL)));
-    }
-
-    public void sendAllRequest(LwM2mClient lwM2MClient, String targetIdVer, LwM2mTypeOper typeOper, Object params, long timeoutInMs, LwM2mClientRpcRequest lwm2mClientRpcRequest) {
-        sendAllRequest(lwM2MClient, targetIdVer, typeOper, lwM2MClient.getDefaultContentFormat(), params, timeoutInMs, lwm2mClientRpcRequest);
-    }
-
-
-    public void sendAllRequest(LwM2mClient lwM2MClient, String targetIdVer, LwM2mTypeOper typeOper,
-                               ContentFormat contentFormat, Object params, long timeoutInMs, LwM2mClientRpcRequest lwm2mClientRpcRequest) {
-        Registration registration = lwM2MClient.getRegistration();
-        try {
-            String target = convertPathFromIdVerToObjectId(targetIdVer);
-            if(contentFormat == null){
-                contentFormat = ContentFormat.DEFAULT;
-            }
-            LwM2mPath resultIds = target != null ? new LwM2mPath(target) : null;
-            if (!OBSERVE_CANCEL.name().equals(typeOper.name()) && resultIds != null && registration != null && resultIds.getObjectId() >= 0 && lwM2MClient != null) {
-                if (lwM2MClient.isValidObjectVersion(targetIdVer)) {
-                    timeoutInMs = timeoutInMs > 0 ? timeoutInMs : DEFAULT_TIMEOUT;
-                    SimpleDownlinkRequest request = createRequest(registration, lwM2MClient, typeOper, contentFormat, target,
-                            targetIdVer, resultIds, params, lwm2mClientRpcRequest);
-                    if (request != null) {
-                        try {
-                            this.sendRequest(registration, lwM2MClient, request, timeoutInMs, lwm2mClientRpcRequest);
-                        } catch (ClientSleepingException e) {
-                            SimpleDownlinkRequest finalRequest = request;
-                            long finalTimeoutInMs = timeoutInMs;
-                            LwM2mClientRpcRequest finalRpcRequest = lwm2mClientRpcRequest;
-                            lwM2MClient.getQueuedRequests().add(() -> sendRequest(registration, lwM2MClient, finalRequest, finalTimeoutInMs, finalRpcRequest));
-                        } catch (Exception e) {
-                            log.error("[{}] [{}] [{}] Failed to send downlink.", registration.getEndpoint(), targetIdVer, typeOper.name(), e);
-                        }
-                    } else if (WRITE_UPDATE.name().equals(typeOper.name())) {
-                        if (lwm2mClientRpcRequest != null) {
-                            String errorMsg = String.format("Path %s params is not valid", targetIdVer);
-                            handler.sentRpcResponse(lwm2mClientRpcRequest, BAD_REQUEST.getName(), errorMsg, LOG_LW2M_ERROR);
-                        }
-                    } else if (WRITE_REPLACE.name().equals(typeOper.name()) || EXECUTE.name().equals(typeOper.name())) {
-                        if (lwm2mClientRpcRequest != null) {
-                            String errorMsg = String.format("Path %s object model  is absent", targetIdVer);
-                            handler.sentRpcResponse(lwm2mClientRpcRequest, BAD_REQUEST.getName(), errorMsg, LOG_LW2M_ERROR);
-                        }
-                    } else if (!OBSERVE_CANCEL.name().equals(typeOper.name())) {
-                        log.error("[{}], [{}] - [{}] error SendRequest", registration.getEndpoint(), typeOper.name(), targetIdVer);
-                        if (lwm2mClientRpcRequest != null) {
-                            ResourceModel resourceModel = lwM2MClient.getResourceModel(targetIdVer, this.config.getModelProvider());
-                            String errorMsg = resourceModel == null ? String.format("Path %s not found in object version", targetIdVer) : "SendRequest - null";
-                            handler.sentRpcResponse(lwm2mClientRpcRequest, NOT_FOUND.getName(), errorMsg, LOG_LW2M_ERROR);
-                        }
-                    }
-                } else if (lwm2mClientRpcRequest != null) {
-                    String errorMsg = String.format("Path %s not found in object version", targetIdVer);
-                    handler.sentRpcResponse(lwm2mClientRpcRequest, NOT_FOUND.getName(), errorMsg, LOG_LW2M_ERROR);
-                }
-            } else {
-                switch (typeOper) {
-                    case OBSERVE_READ_ALL:
-                    case DISCOVER_ALL:
-                        Set<String> paths;
-                        if (OBSERVE_READ_ALL.name().equals(typeOper.name())) {
-                            Set<Observation> observations = context.getServer().getObservationService().getObservations(registration);
-                            paths = observations.stream().map(observation -> observation.getPath().toString()).collect(Collectors.toUnmodifiableSet());
-                        } else {
-                            assert registration != null;
-                            Link[] objectLinks = registration.getSortedObjectLinks();
-                            paths = Arrays.stream(objectLinks).map(Link::toString).collect(Collectors.toUnmodifiableSet());
-                        }
-                        String msg = String.format("%s: type operation %s paths - %s", LOG_LW2M_INFO,
-                                typeOper.name(), paths);
-                        this.handler.sendLogsToThingsboard(lwM2MClient, msg);
-                        if (lwm2mClientRpcRequest != null) {
-                            String valueMsg = String.format("Paths - %s", paths);
-                            handler.sentRpcResponse(lwm2mClientRpcRequest, CONTENT.name(), valueMsg, LOG_LW2M_VALUE);
-                        }
-                        break;
-                    case OBSERVE_CANCEL:
-                    case OBSERVE_CANCEL_ALL:
-                        int observeCancelCnt = 0;
-                        String observeCancelMsg = null;
-                        if (OBSERVE_CANCEL.name().equals(typeOper)) {
-                            observeCancelCnt = context.getServer().getObservationService().cancelObservations(registration, target);
-                            observeCancelMsg = String.format("%s: type operation %s paths: %s count: %d", LOG_LW2M_INFO,
-                                    OBSERVE_CANCEL.name(), target, observeCancelCnt);
-                        } else {
-                            observeCancelCnt = context.getServer().getObservationService().cancelObservations(registration);
-                            observeCancelMsg = String.format("%s: type operation %s paths: All  count: %d", LOG_LW2M_INFO,
-                                    OBSERVE_CANCEL.name(), observeCancelCnt);
-                        }
-                        this.afterObserveCancel(lwM2MClient, observeCancelCnt, observeCancelMsg, lwm2mClientRpcRequest);
-                        break;
-                    // lwm2mClientRpcRequest != null
-                    case FW_UPDATE:
-                        handler.getInfoFirmwareUpdate(lwM2MClient, lwm2mClientRpcRequest);
-                        break;
-                }
-            }
-        } catch (Exception e) {
-            String msg = String.format("%s: type operation %s  %s", LOG_LW2M_ERROR,
-                    typeOper.name(), e.getMessage());
-            handler.sendLogsToThingsboard(lwM2MClient, msg);
-            if (lwm2mClientRpcRequest != null) {
-                String errorMsg = String.format("Path %s type operation %s  %s", targetIdVer, typeOper.name(), e.getMessage());
-                handler.sentRpcResponse(lwm2mClientRpcRequest, NOT_FOUND.getName(), errorMsg, LOG_LW2M_ERROR);
-            }
-        }
-    }
-
-    private SimpleDownlinkRequest createRequest(Registration registration, LwM2mClient lwM2MClient, LwM2mTypeOper typeOper,
-                                          ContentFormat contentFormat, String target, String targetIdVer,
-                                          LwM2mPath resultIds, Object params, LwM2mClientRpcRequest rpcRequest) {
-        SimpleDownlinkRequest request = null;
-        switch (typeOper) {
-            case READ:
-                request = new ReadRequest(contentFormat, target);
-                break;
-            case DISCOVER:
-                request = new DiscoverRequest(target);
-                break;
-            case OBSERVE:
-                String msg = String.format("%s: Send Observation  %s.", LOG_LW2M_INFO, targetIdVer);
-                log.warn(msg);
-                if (resultIds.isResource()) {
-                    Set<Observation> observations = context.getServer().getObservationService().getObservations(registration);
-                    Set<Observation> paths = observations.stream().filter(observation -> observation.getPath().equals(resultIds)).collect(Collectors.toSet());
-                    if (paths.size() == 0) {
-                        request = new ObserveRequest(contentFormat, resultIds.getObjectId(), resultIds.getObjectInstanceId(), resultIds.getResourceId());
-                    } else {
-                        request = new ReadRequest(contentFormat, target);
-                    }
-                } else if (resultIds.isObjectInstance()) {
-                    request = new ObserveRequest(contentFormat, resultIds.getObjectId(), resultIds.getObjectInstanceId());
-                } else if (resultIds.getObjectId() >= 0) {
-                    request = new ObserveRequest(contentFormat, resultIds.getObjectId());
-                }
-                break;
-            case EXECUTE:
-                ResourceModel resourceModelExecute = lwM2MClient.getResourceModel(targetIdVer, this.config.getModelProvider());
-                if (resourceModelExecute != null) {
-                    if (params != null && !resourceModelExecute.multiple) {
-                        request = new ExecuteRequest(target, (String) this.converter.convertValue(params, resourceModelExecute.type, ResourceModel.Type.STRING, resultIds));
-                    } else {
-                        request = new ExecuteRequest(target);
-                    }
-                }
-                break;
-            case WRITE_REPLACE:
-                /**
-                 * Request to write a <b>String Single-Instance Resource</b> using the TLV content format.
-                 * Type from resourceModel  -> STRING, INTEGER, FLOAT, BOOLEAN, OPAQUE, TIME, OBJLNK
-                 * contentFormat ->           TLV,     TLV,    TLV,   TLV,     OPAQUE, TLV,  LINK
-                 * JSON, TEXT;
-                 **/
-                ResourceModel resourceModelWrite = lwM2MClient.getResourceModel(targetIdVer, this.config.getModelProvider());
-                if (resourceModelWrite != null) {
-                    contentFormat = getContentFormatByResourceModelType(resourceModelWrite, contentFormat);
-                    request = this.getWriteRequestSingleResource(contentFormat, resultIds.getObjectId(),
-                            resultIds.getObjectInstanceId(), resultIds.getResourceId(), params, resourceModelWrite.type,
-                            lwM2MClient, rpcRequest);
-                }
-                break;
-            case WRITE_UPDATE:
-                if (resultIds.isResource()) {
-                    /**
-                     * send request: path = '/3/0' node == wM2mObjectInstance
-                     * with params == "\"resources\": {15: resource:{id:15. value:'+01'...}}
-                     **/
-                    Collection<LwM2mResource> resources = lwM2MClient.getNewResourceForInstance(
-                            targetIdVer, params,
-                            this.config.getModelProvider(),
-                            this.converter);
-                    contentFormat = getContentFormatByResourceModelType(lwM2MClient.getResourceModel(targetIdVer, this.config.getModelProvider()),
-                            contentFormat);
-                    request = new WriteRequest(WriteRequest.Mode.UPDATE, contentFormat, resultIds.getObjectId(),
-                            resultIds.getObjectInstanceId(), resources);
-                }
-                /**
-                 *  params = "{\"id\":0,\"resources\":[{\"id\":14,\"value\":\"+5\"},{\"id\":15,\"value\":\"+9\"}]}"
-                 *  int rscId = resultIds.getObjectInstanceId();
-                 *  contentFormat – Format of the payload (TLV or JSON).
-                 */
-                else if (resultIds.isObjectInstance()) {
-                    if (((ConcurrentHashMap) params).size() > 0) {
-                        Collection<LwM2mResource> resources = lwM2MClient.getNewResourcesForInstance(
-                                targetIdVer, params,
-                                this.config.getModelProvider(),
-                                this.converter);
-                        if (resources.size() > 0) {
-                            contentFormat = contentFormat.equals(ContentFormat.JSON) ? contentFormat : ContentFormat.TLV;
-                            request = new WriteRequest(WriteRequest.Mode.UPDATE, contentFormat, resultIds.getObjectId(),
-                                    resultIds.getObjectInstanceId(), resources);
-                        }
-                    }
-                } else if (resultIds.getObjectId() >= 0) {
-                    request = new ObserveRequest(resultIds.getObjectId());
-                }
-                break;
-            case WRITE_ATTRIBUTES:
-                request = createWriteAttributeRequest(target, params, this.handler);
-                break;
-            case DELETE:
-                request = new DeleteRequest(target);
-                break;
-        }
-        return request;
-    }
-
-    /**
-     * @param registration -
-     * @param request      -
-     * @param timeoutInMs  -
-     */
-
-    @SuppressWarnings({"error sendRequest"})
-    private void sendRequest(Registration registration, LwM2mClient lwM2MClient, SimpleDownlinkRequest request,
-                             long timeoutInMs, LwM2mClientRpcRequest rpcRequest) {
-        context.getServer().send(registration, request, timeoutInMs, (ResponseCallback<?>) response -> {
-
-            if (!lwM2MClient.isInit()) {
-                lwM2MClient.initReadValue(this.handler, convertPathFromObjectIdToIdVer(request.getPath().toString(), registration));
-            }
-            if (CoAP.ResponseCode.isSuccess(((Response) response.getCoapResponse()).getCode())) {
-                this.handleResponse(lwM2MClient, request.getPath().toString(), response, request, rpcRequest);
-            } else {
-                String msg = String.format("%s: SendRequest %s: CoapCode - %s Lwm2m code - %d name - %s Resource path - %s", LOG_LW2M_ERROR, request.getClass().getName().toString(),
-                        ((Response) response.getCoapResponse()).getCode(), response.getCode().getCode(), response.getCode().getName(), request.getPath().toString());
-                handler.sendLogsToThingsboard(lwM2MClient, msg);
-                log.error("[{}] [{}], [{}] - [{}] [{}] error SendRequest", request.getClass().getName().toString(), registration.getEndpoint(),
-                        ((Response) response.getCoapResponse()).getCode(), response.getCode(), request.getPath().toString());
-                if (!lwM2MClient.isInit()) {
-                    lwM2MClient.initReadValue(this.handler, convertPathFromObjectIdToIdVer(request.getPath().toString(), registration));
-                }
-                /** Not Found */
-                if (rpcRequest != null) {
-                    handler.sentRpcResponse(rpcRequest, response.getCode().getName(), response.getErrorMessage(), LOG_LW2M_ERROR);
-                }
-                /** Not Found
-                 set setClient_fw_info... = empty
-                 **/
-                if (lwM2MClient.getFwUpdate() != null && lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
-                    lwM2MClient.getFwUpdate().initReadValue(handler, this, request.getPath().toString());
-                }
-                if (lwM2MClient.getSwUpdate() != null && lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
-                    lwM2MClient.getSwUpdate().initReadValue(handler, this, request.getPath().toString());
-                }
-                if (request.getPath().toString().equals(FW_PACKAGE_5_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
-                    this.afterWriteFwSWUpdateError(registration, request, response.getErrorMessage());
-                }
-                if (request.getPath().toString().equals(FW_UPDATE_ID) || request.getPath().toString().equals(SW_INSTALL_ID)) {
-                    this.afterExecuteFwSwUpdateError(registration, request, response.getErrorMessage());
-                }
-            }
-        }, e -> {
-            /** version == null
-             set setClient_fw_info... = empty
-             **/
-            if (lwM2MClient.getFwUpdate() != null && lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
-                lwM2MClient.getFwUpdate().initReadValue(handler, this, request.getPath().toString());
-            }
-            if (lwM2MClient.getSwUpdate() != null && lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
-                lwM2MClient.getSwUpdate().initReadValue(handler, this, request.getPath().toString());
-            }
-            if (request.getPath().toString().equals(FW_PACKAGE_5_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
-                this.afterWriteFwSWUpdateError(registration, request, e.getMessage());
-            }
-            if (request.getPath().toString().equals(FW_UPDATE_ID) || request.getPath().toString().equals(SW_INSTALL_ID)) {
-                this.afterExecuteFwSwUpdateError(registration, request, e.getMessage());
-            }
-            if (!lwM2MClient.isInit()) {
-                lwM2MClient.initReadValue(this.handler, convertPathFromObjectIdToIdVer(request.getPath().toString(), registration));
-            }
-            String msg = String.format("%s: SendRequest %s: Resource path - %s msg error - %s",
-                    LOG_LW2M_ERROR, request.getClass().getName().toString(), request.getPath().toString(), e.getMessage());
-            handler.sendLogsToThingsboard(lwM2MClient, msg);
-            log.error("[{}] [{}] - [{}] error SendRequest", request.getClass().getName().toString(), request.getPath().toString(), e.toString());
-            if (rpcRequest != null) {
-                handler.sentRpcResponse(rpcRequest, CoAP.CodeClass.ERROR_RESPONSE.name(), e.getMessage(), LOG_LW2M_ERROR);
-            }
-        });
-    }
-
-    private WriteRequest getWriteRequestSingleResource(ContentFormat contentFormat, Integer objectId, Integer instanceId,
-                                                       Integer resourceId, Object value, ResourceModel.Type type,
-                                                       LwM2mClient client, LwM2mClientRpcRequest rpcRequest) {
-        try {
-            if (type != null) {
-                switch (type) {
-                    case STRING:    // String
-                        return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, value.toString()) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, value.toString());
-                    case INTEGER:   // Long
-                        final long valueInt = Integer.toUnsignedLong(Integer.parseInt(value.toString()));
-                        return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, valueInt) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, valueInt);
-                    case OBJLNK:    // ObjectLink
-                        return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, ObjectLink.fromPath(value.toString())) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, ObjectLink.fromPath(value.toString()));
-                    case BOOLEAN:   // Boolean
-                        return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, Boolean.parseBoolean(value.toString())) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, Boolean.parseBoolean(value.toString()));
-                    case FLOAT:     // Double
-                        return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, Double.parseDouble(value.toString())) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, Double.parseDouble(value.toString()));
-                    case TIME:      // Date
-                        Date date = new Date(Long.decode(value.toString()));
-                        return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, date) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, date);
-                    case OPAQUE:    // byte[] value, base64
-                        byte[] valueRequest = value instanceof byte[] ? (byte[]) value : Hex.decodeHex(value.toString().toCharArray());
-                        return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, valueRequest) :
-                                new WriteRequest(contentFormat, objectId, instanceId, resourceId, valueRequest);
-                    default:
-                }
-            }
-            if (rpcRequest != null) {
-                String patn = "/" + objectId + "/" + instanceId + "/" + resourceId;
-                String errorMsg = String.format("Bad ResourceModel Operations (E): Resource path - %s ResourceModel type - %s", patn, type);
-                rpcRequest.setErrorMsg(errorMsg);
-            }
-            return null;
-        } catch (NumberFormatException e) {
-            String patn = "/" + objectId + "/" + instanceId + "/" + resourceId;
-            String msg = String.format(LOG_LW2M_ERROR + ": NumberFormatException: Resource path - %s type - %s value - %s msg error - %s  SendRequest to Client",
-                    patn, type, value, e.toString());
-            handler.sendLogsToThingsboard(client, msg);
-            log.error("Path: [{}] type: [{}] value: [{}] errorMsg: [{}]]", patn, type, value, e.toString());
-            if (rpcRequest != null) {
-                String errorMsg = String.format("NumberFormatException: Resource path - %s type - %s value - %s", patn, type, value);
-                handler.sentRpcResponse(rpcRequest, BAD_REQUEST.getName(), errorMsg, LOG_LW2M_ERROR);
-            }
-            return null;
-        }
-    }
-
-    private void handleResponse(LwM2mClient lwM2mClient, final String path, LwM2mResponse response,
-                                SimpleDownlinkRequest request, LwM2mClientRpcRequest rpcRequest) {
-        responseRequestExecutor.submit(() -> {
-            try {
-                this.sendResponse(lwM2mClient, path, response, request, rpcRequest);
-            } catch (Exception e) {
-                log.error("[{}] endpoint [{}] path [{}] Exception Unable to after send response.", lwM2mClient.getRegistration().getEndpoint(), path, e);
-            }
-        });
-    }
-
-    /**
-     * processing a response from a client
-     *
-     * @param path         -
-     * @param response     -
-     */
-    private void sendResponse(LwM2mClient lwM2mClient, String path, LwM2mResponse response,
-                              SimpleDownlinkRequest request, LwM2mClientRpcRequest rpcRequest) {
-        Registration registration = lwM2mClient.getRegistration();
-        String pathIdVer = convertPathFromObjectIdToIdVer(path, registration);
-        String msgLog = "";
-        if (response instanceof ReadResponse) {
-            handler.onUpdateValueAfterReadResponse(registration, pathIdVer, (ReadResponse) response, rpcRequest);
-        } else if (response instanceof DeleteResponse) {
-            log.warn("11) [{}] Path [{}] DeleteResponse", pathIdVer, response);
-            if (rpcRequest != null) {
-                rpcRequest.setInfoMsg(null);
-                handler.sentRpcResponse(rpcRequest, response.getCode().getName(), null, null);
-            }
-        } else if (response instanceof DiscoverResponse) {
-            String discoverValue = Link.serialize(((DiscoverResponse) response).getObjectLinks());
-            msgLog = String.format("%s: type operation: %s path: %s value: %s",
-                    LOG_LW2M_INFO, DISCOVER.name(), request.getPath().toString(), discoverValue);
-            handler.sendLogsToThingsboard(lwM2mClient, msgLog);
-            log.warn("DiscoverResponse: [{}]", (DiscoverResponse) response);
-            if (rpcRequest != null) {
-                handler.sentRpcResponse(rpcRequest, response.getCode().getName(), discoverValue, LOG_LW2M_VALUE);
-            }
-        } else if (response instanceof ExecuteResponse) {
-            msgLog = String.format("%s: type operation: %s path: %s",
-                    LOG_LW2M_INFO, EXECUTE.name(), request.getPath().toString());
-            log.warn("9) [{}] ", msgLog);
-            handler.sendLogsToThingsboard(lwM2mClient, msgLog);
-            if (rpcRequest != null) {
-                msgLog = String.format("Start %s path: %S. Preparation finished: %s", EXECUTE.name(), path, rpcRequest.getInfoMsg());
-                rpcRequest.setInfoMsg(msgLog);
-                handler.sentRpcResponse(rpcRequest, response.getCode().getName(), path, LOG_LW2M_INFO);
-            }
-
-        } else if (response instanceof WriteAttributesResponse) {
-            msgLog = String.format("%s: type operation: %s path: %s value: %s",
-                    LOG_LW2M_INFO, WRITE_ATTRIBUTES.name(), request.getPath().toString(), ((WriteAttributesRequest) request).getAttributes().toString());
-            handler.sendLogsToThingsboard(lwM2mClient, msgLog);
-            log.warn("12) [{}] Path [{}] WriteAttributesResponse", pathIdVer, response);
-            if (rpcRequest != null) {
-                handler.sentRpcResponse(rpcRequest, response.getCode().getName(), response.toString(), LOG_LW2M_VALUE);
-            }
-        } else if (response instanceof WriteResponse) {
-            msgLog = String.format("Type operation: Write path: %s", pathIdVer);
-            log.warn("10) [{}] response: [{}]", msgLog, response);
-            this.infoWriteResponse(lwM2mClient, response, request, rpcRequest);
-            handler.onWriteResponseOk(registration, pathIdVer, (WriteRequest) request);
-        }
-    }
-
-    private void infoWriteResponse(LwM2mClient lwM2mClient, LwM2mResponse response, SimpleDownlinkRequest request, LwM2mClientRpcRequest rpcRequest) {
-        try {
-            Registration registration = lwM2mClient.getRegistration();
-            LwM2mNode node = ((WriteRequest) request).getNode();
-            String msg = null;
-            Object value;
-            if (node instanceof LwM2mObject) {
-                msg = String.format("%s: Update finished successfully: Lwm2m code - %d Source path: %s  value: %s",
-                        LOG_LW2M_INFO, response.getCode().getCode(), request.getPath().toString(), ((LwM2mObject) node).toString());
-            } else if (node instanceof LwM2mObjectInstance) {
-                msg = String.format("%s: Update finished successfully: Lwm2m code - %d Source path: %s  value: %s",
-                        LOG_LW2M_INFO, response.getCode().getCode(), request.getPath().toString(), ((LwM2mObjectInstance) node).prettyPrint());
-            } else if (node instanceof LwM2mSingleResource) {
-                LwM2mSingleResource singleResource = (LwM2mSingleResource) node;
-                if (singleResource.getType() == ResourceModel.Type.STRING || singleResource.getType() == ResourceModel.Type.OPAQUE) {
-                    int valueLength;
-                    if (singleResource.getType() == ResourceModel.Type.STRING) {
-                        valueLength = ((String) singleResource.getValue()).length();
-                        value = ((String) singleResource.getValue())
-                                .substring(Math.min(valueLength, config.getLogMaxLength())).trim();
-
-                    } else {
-                        valueLength = ((byte[]) singleResource.getValue()).length;
-                        value = new String(Arrays.copyOf(((byte[]) singleResource.getValue()),
-                                Math.min(valueLength, config.getLogMaxLength()))).trim();
-                    }
-                    value = valueLength > config.getLogMaxLength() ? value + "..." : value;
-                    msg = String.format("%s: Update finished successfully: Lwm2m code - %d Resource path: %s length: %s value: %s",
-                            LOG_LW2M_INFO, response.getCode().getCode(), request.getPath().toString(), valueLength, value);
-                } else {
-                    value = this.converter.convertValue(singleResource.getValue(),
-                            singleResource.getType(), ResourceModel.Type.STRING, request.getPath());
-                    msg = String.format("%s: Update finished successfully. Lwm2m code: %d Resource path: %s value: %s",
-                            LOG_LW2M_INFO, response.getCode().getCode(), request.getPath().toString(), value);
-                }
-            }
-            if (msg != null) {
-                handler.sendLogsToThingsboard(lwM2mClient, msg);
-                if (request.getPath().toString().equals(FW_PACKAGE_5_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
-                    this.afterWriteSuccessFwSwUpdate(registration, request);
-                    if (rpcRequest != null) {
-                        rpcRequest.setInfoMsg(msg);
-                    }
-                }
-                else if (rpcRequest != null) {
-                    handler.sentRpcResponse(rpcRequest, response.getCode().getName(), msg, LOG_LW2M_INFO);
-                }
-            }
-        } catch (Exception e) {
-            log.trace("Fail convert value from request to string. ", e);
-        }
-    }
-
-    /**
-     * After finish operation FwSwUpdate Write (success):
-     * fw_state/sw_state = DOWNLOADED
-     * send operation Execute
-     */
-    private void afterWriteSuccessFwSwUpdate(Registration registration, SimpleDownlinkRequest request) {
-        LwM2mClient lwM2MClient = this.lwM2mClientContext.getClientByRegistrationId(registration.getId());
-        if (request.getPath().toString().equals(FW_PACKAGE_5_ID) && lwM2MClient.getFwUpdate() != null) {
-            lwM2MClient.getFwUpdate().setStateUpdate(DOWNLOADED.name());
-            lwM2MClient.getFwUpdate().sendLogs(this.handler, WRITE_REPLACE.name(), LOG_LW2M_INFO, null);
-        }
-        if (request.getPath().toString().equals(SW_PACKAGE_ID) && lwM2MClient.getSwUpdate() != null) {
-            lwM2MClient.getSwUpdate().setStateUpdate(DOWNLOADED.name());
-            lwM2MClient.getSwUpdate().sendLogs(this.handler, WRITE_REPLACE.name(), LOG_LW2M_INFO, null);
-        }
-    }
-
-    /**
-     * After finish operation FwSwUpdate Write (error):  fw_state = FAILED
-     */
-    private void afterWriteFwSWUpdateError(Registration registration, SimpleDownlinkRequest request, String msgError) {
-        LwM2mClient lwM2MClient = this.lwM2mClientContext.getClientByRegistrationId(registration.getId());
-        if (request.getPath().toString().equals(FW_PACKAGE_5_ID) && lwM2MClient.getFwUpdate() != null) {
-            lwM2MClient.getFwUpdate().setStateUpdate(FAILED.name());
-            lwM2MClient.getFwUpdate().sendLogs(this.handler, WRITE_REPLACE.name(), LOG_LW2M_ERROR, msgError);
-        }
-        if (request.getPath().toString().equals(SW_PACKAGE_ID) && lwM2MClient.getSwUpdate() != null) {
-            lwM2MClient.getSwUpdate().setStateUpdate(FAILED.name());
-            lwM2MClient.getSwUpdate().sendLogs(this.handler, WRITE_REPLACE.name(), LOG_LW2M_ERROR, msgError);
-        }
-    }
-
-    private void afterExecuteFwSwUpdateError(Registration registration, SimpleDownlinkRequest request, String msgError) {
-        LwM2mClient lwM2MClient = this.lwM2mClientContext.getClientByRegistrationId(registration.getId());
-        if (request.getPath().toString().equals(FW_UPDATE_ID) && lwM2MClient.getFwUpdate() != null) {
-            lwM2MClient.getFwUpdate().sendLogs(this.handler, EXECUTE.name(), LOG_LW2M_ERROR, msgError);
-        }
-        if (request.getPath().toString().equals(SW_INSTALL_ID) && lwM2MClient.getSwUpdate() != null) {
-            lwM2MClient.getSwUpdate().sendLogs(this.handler, EXECUTE.name(), LOG_LW2M_ERROR, msgError);
-        }
-    }
-
-    private void afterObserveCancel(LwM2mClient lwM2mClient, int observeCancelCnt, String observeCancelMsg, LwM2mClientRpcRequest rpcRequest) {
-        handler.sendLogsToThingsboard(lwM2mClient, observeCancelMsg);
-        log.warn("[{}]", observeCancelMsg);
-        if (rpcRequest != null) {
-            rpcRequest.setInfoMsg(String.format("Count: %d", observeCancelCnt));
-            handler.sentRpcResponse(rpcRequest, CONTENT.name(), null, LOG_LW2M_INFO);
-        }
-    }
-}

@@ -37,6 +37,8 @@ import org.eclipse.leshan.core.model.DefaultDDFFileValidator;
 import org.eclipse.leshan.core.model.InvalidDDFFileException;
 import org.eclipse.leshan.core.model.InvalidDDFFileException;
 import org.eclipse.leshan.core.model.ObjectModel;
 import org.eclipse.leshan.core.model.ObjectModel;
 import org.eclipse.leshan.core.model.ResourceModel;
 import org.eclipse.leshan.core.model.ResourceModel;
+import org.eclipse.leshan.core.node.LwM2mPath;
+import org.eclipse.leshan.core.node.LwM2mResource;
 import org.eclipse.leshan.core.node.codec.CodecException;
 import org.eclipse.leshan.core.node.codec.CodecException;
 import org.eclipse.leshan.core.request.ContentFormat;
 import org.eclipse.leshan.core.request.ContentFormat;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
@@ -48,6 +50,8 @@ import org.thingsboard.server.gen.transport.TransportProtos.PostTelemetryMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.transport.lwm2m.server.adaptors.LwM2MJsonAdaptor;
 import org.thingsboard.server.transport.lwm2m.server.adaptors.LwM2MJsonAdaptor;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
+import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
 
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.IOException;
@@ -57,6 +61,7 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicInteger;
 
 
 import static org.thingsboard.server.gen.transport.TransportProtos.KeyValueType.BOOLEAN_V;
 import static org.thingsboard.server.gen.transport.TransportProtos.KeyValueType.BOOLEAN_V;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.fromVersionedIdToObjectId;
 
 
 @Slf4j
 @Slf4j
 @Component
 @Component
@@ -67,37 +72,15 @@ public class LwM2mTransportServerHelper {
     private final LwM2mTransportContext context;
     private final LwM2mTransportContext context;
     private final AtomicInteger atomicTs = new AtomicInteger(0);
     private final AtomicInteger atomicTs = new AtomicInteger(0);
 
 
-
     public long getTS() {
     public long getTS() {
         return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()) * 1000L + (atomicTs.getAndIncrement() % 1000);
         return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()) * 1000L + (atomicTs.getAndIncrement() % 1000);
     }
     }
 
 
-    /**
-     * send to Thingsboard Attribute || Telemetry
-     *
-     * @param msg - JsonObject: [{name: value}]
-     * @return - dummyWriteReplace {\"targetIdVer\":\"/19_1.0/0/0\",\"value\":0082}
-     */
-    private <T> TransportServiceCallback<Void> getPubAckCallbackSendAttrTelemetry(final T msg) {
-        return new TransportServiceCallback<>() {
-            @Override
-            public void onSuccess(Void dummy) {
-                log.trace("Success to publish msg: {}, dummy: {}", msg, dummy);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                log.trace("[{}] Failed to publish msg: {}", msg, e);
-            }
-        };
-    }
-
     public void sendParametersOnThingsboardAttribute(List<TransportProtos.KeyValueProto> result, SessionInfoProto sessionInfo) {
     public void sendParametersOnThingsboardAttribute(List<TransportProtos.KeyValueProto> result, SessionInfoProto sessionInfo) {
         PostAttributeMsg.Builder request = PostAttributeMsg.newBuilder();
         PostAttributeMsg.Builder request = PostAttributeMsg.newBuilder();
         request.addAllKv(result);
         request.addAllKv(result);
         PostAttributeMsg postAttributeMsg = request.build();
         PostAttributeMsg postAttributeMsg = request.build();
-        TransportServiceCallback call = this.getPubAckCallbackSendAttrTelemetry(postAttributeMsg);
-        context.getTransportService().process(sessionInfo, postAttributeMsg, this.getPubAckCallbackSendAttrTelemetry(call));
+        context.getTransportService().process(sessionInfo, postAttributeMsg, TransportServiceCallback.EMPTY);
     }
     }
 
 
     public void sendParametersOnThingsboardTelemetry(List<TransportProtos.KeyValueProto> result, SessionInfoProto sessionInfo) {
     public void sendParametersOnThingsboardTelemetry(List<TransportProtos.KeyValueProto> result, SessionInfoProto sessionInfo) {
@@ -107,8 +90,7 @@ public class LwM2mTransportServerHelper {
         builder.addAllKv(result);
         builder.addAllKv(result);
         request.addTsKvList(builder.build());
         request.addTsKvList(builder.build());
         PostTelemetryMsg postTelemetryMsg = request.build();
         PostTelemetryMsg postTelemetryMsg = request.build();
-        TransportServiceCallback call = this.getPubAckCallbackSendAttrTelemetry(postTelemetryMsg);
-        context.getTransportService().process(sessionInfo, postTelemetryMsg, this.getPubAckCallbackSendAttrTelemetry(call));
+        context.getTransportService().process(sessionInfo, postTelemetryMsg, TransportServiceCallback.EMPTY);
     }
     }
 
 
     /**
     /**
@@ -210,28 +192,6 @@ public class LwM2mTransportServerHelper {
         throw new CodecException("Invalid ResourceModel_Type for resource %s, got %s", resourcePath, currentType);
         throw new CodecException("Invalid ResourceModel_Type for resource %s, got %s", resourcePath, currentType);
     }
     }
 
 
-    public static ContentFormat convertResourceModelTypeToContentFormat(ResourceModel.Type type) {
-        switch (type) {
-            case BOOLEAN:
-            case STRING:
-            case TIME:
-            case INTEGER:
-            case FLOAT:
-                return ContentFormat.TLV;
-            case OPAQUE:
-                return ContentFormat.OPAQUE;
-            case OBJLNK:
-                return ContentFormat.LINK;
-            default:
-        }
-        throw new CodecException("Invalid ResourceModel_Type for %s ContentFormat.", type);
-    }
-
-    public static ContentFormat getContentFormatByResourceModelType(ResourceModel resourceModel, ContentFormat contentFormat) {
-        return contentFormat.equals(ContentFormat.TLV) ? convertResourceModelTypeToContentFormat(resourceModel.type) :
-                contentFormat;
-    }
-
     public static Object getValueFromKvProto(TransportProtos.KeyValueProto kv) {
     public static Object getValueFromKvProto(TransportProtos.KeyValueProto kv) {
         switch (kv.getType()) {
         switch (kv.getType()) {
             case BOOLEAN_V:
             case BOOLEAN_V:
@@ -247,4 +207,5 @@ public class LwM2mTransportServerHelper {
         }
         }
         return null;
         return null;
     }
     }
+
 }
 }

@@ -16,13 +16,9 @@
 package org.thingsboard.server.transport.lwm2m.server;
 package org.thingsboard.server.transport.lwm2m.server;
 
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.Sets;
-import com.google.gson.Gson;
-import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
 import com.google.gson.JsonParser;
 import com.google.gson.JsonSyntaxException;
 import com.google.gson.JsonSyntaxException;
-import com.google.gson.reflect.TypeToken;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.eclipse.leshan.core.attributes.Attribute;
 import org.eclipse.leshan.core.attributes.Attribute;
@@ -34,6 +30,7 @@ import org.eclipse.leshan.core.node.LwM2mNode;
 import org.eclipse.leshan.core.node.LwM2mObject;
 import org.eclipse.leshan.core.node.LwM2mObject;
 import org.eclipse.leshan.core.node.LwM2mObjectInstance;
 import org.eclipse.leshan.core.node.LwM2mObjectInstance;
 import org.eclipse.leshan.core.node.LwM2mPath;
 import org.eclipse.leshan.core.node.LwM2mPath;
+import org.eclipse.leshan.core.node.LwM2mResource;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
 import org.eclipse.leshan.core.node.codec.CodecException;
 import org.eclipse.leshan.core.node.codec.CodecException;
 import org.eclipse.leshan.core.request.SimpleDownlinkRequest;
 import org.eclipse.leshan.core.request.SimpleDownlinkRequest;
@@ -42,17 +39,19 @@ import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.registration.Registration;
 import org.nustaq.serialization.FSTConfiguration;
 import org.nustaq.serialization.FSTConfiguration;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.device.data.lwm2m.BootstrapConfiguration;
+import org.thingsboard.server.common.data.device.profile.DeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
-import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.ota.OtaPackageKey;
 import org.thingsboard.server.common.data.ota.OtaPackageKey;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus;
 import org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus;
 import org.thingsboard.server.common.data.ota.OtaPackageUtil;
 import org.thingsboard.server.common.data.ota.OtaPackageUtil;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientProfile;
+import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
+import org.thingsboard.server.transport.lwm2m.server.uplink.DefaultLwM2MUplinkMsgHandler;
 
 
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.Date;
@@ -60,7 +59,6 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.List;
 import java.util.Map;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Optional;
-import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 
 
 import static org.eclipse.leshan.core.attributes.Attribute.DIMENSION;
 import static org.eclipse.leshan.core.attributes.Attribute.DIMENSION;
@@ -115,33 +113,17 @@ public class LwM2mTransportUtil {
 
 
     public static final long DEFAULT_TIMEOUT = 2 * 60 * 1000L; // 2min in ms
     public static final long DEFAULT_TIMEOUT = 2 * 60 * 1000L; // 2min in ms
 
 
-    public static final String LOG_LW2M_TELEMETRY = "logLwm2m";
-    public static final String LOG_LW2M_INFO = "info";
-    public static final String LOG_LW2M_ERROR = "error";
-    public static final String LOG_LW2M_WARN = "warn";
-    public static final String LOG_LW2M_VALUE = "value";
+    public static final String LOG_LWM2M_TELEMETRY = "logLwm2m";
+    public static final String LOG_LWM2M_INFO = "info";
+    public static final String LOG_LWM2M_ERROR = "error";
+    public static final String LOG_LWM2M_WARN = "warn";
+    public static final String LOG_LWM2M_VALUE = "value";
 
 
     public static final String CLIENT_NOT_AUTHORIZED = "Client not authorized";
     public static final String CLIENT_NOT_AUTHORIZED = "Client not authorized";
     public static final String LWM2M_VERSION_DEFAULT = "1.0";
     public static final String LWM2M_VERSION_DEFAULT = "1.0";
 
 
-    // RPC
-    public static final String TYPE_OPER_KEY = "typeOper";
-    public static final String TARGET_ID_VER_KEY = "targetIdVer";
-    public static final String KEY_NAME_KEY = "key";
-    public static final String VALUE_KEY = "value";
-    public static final String PARAMS_KEY = "params";
-    public static final String SEPARATOR_KEY = ":";
-    public static final String FINISH_VALUE_KEY = ",";
-    public static final String START_JSON_KEY = "{";
-    public static final String FINISH_JSON_KEY = "}";
-    public static final String INFO_KEY = "info";
-    public static final String RESULT_KEY = "result";
-    public static final String ERROR_KEY = "error";
-    public static final String METHOD_KEY = "methodName";
-
-
     // Firmware
     // Firmware
-    public static final String FIRMWARE_UPDATE_COAP_RECOURSE = "firmwareUpdateCoapRecourse";
+    public static final String FIRMWARE_UPDATE_COAP_RECOURSE = "tbfw";
     public static final String FW_UPDATE = "Firmware update";
     public static final String FW_UPDATE = "Firmware update";
     public static final Integer FW_5_ID = 5;
     public static final Integer FW_5_ID = 5;
     public static final Integer FW_19_ID = 19;
     public static final Integer FW_19_ID = 19;
@@ -155,10 +137,14 @@ public class LwM2mTransportUtil {
     public static final String FW_STATE_ID = "/5/0/3";
     public static final String FW_STATE_ID = "/5/0/3";
     // Update Result R
     // Update Result R
     public static final String FW_RESULT_ID = "/5/0/5";
     public static final String FW_RESULT_ID = "/5/0/5";
+
+    public static final String FW_DELIVERY_METHOD = "/5/0/9";
+
     // PkgName R
     // PkgName R
     public static final String FW_NAME_ID = "/5/0/6";
     public static final String FW_NAME_ID = "/5/0/6";
     // PkgVersion R
     // PkgVersion R
     public static final String FW_5_VER_ID = "/5/0/7";
     public static final String FW_5_VER_ID = "/5/0/7";
+
     /**
     /**
      * Quectel@Hi15RM1-HLB_V1.0@BC68JAR01A10,V150R100C20B300SP7,V150R100C20B300SP7@8
      * Quectel@Hi15RM1-HLB_V1.0@BC68JAR01A10,V150R100C20B300SP7,V150R100C20B300SP7@8
      * BC68JAR01A10
      * BC68JAR01A10
@@ -215,192 +201,12 @@ public class LwM2mTransportUtil {
         }
         }
     }
     }
 
 
-    /**
-     * Define the behavior of a write request.
-     */
-    public enum LwM2mTypeOper {
-        /**
-         * GET
-         */
-        READ(0, "Read"),
-        DISCOVER(1, "Discover"),
-        DISCOVER_ALL(2, "DiscoverAll"),
-        OBSERVE_READ_ALL(3, "ObserveReadAll"),
-        /**
-         * POST
-         */
-        OBSERVE(4, "Observe"),
-        OBSERVE_CANCEL(5, "ObserveCancel"),
-        OBSERVE_CANCEL_ALL(6, "ObserveCancelAll"),
-        EXECUTE(7, "Execute"),
-        /**
-         * Replaces the Object Instance or the Resource(s) with the new value provided in the “Write” operation. (see
-         * section 5.3.3 of the LW M2M spec).
-         * if all resources are to be replaced
-         */
-        WRITE_REPLACE(8, "WriteReplace"),
-        /*
-          PUT
-         */
-        /**
-         * Adds or updates Resources provided in the new value and leaves other existing Resources unchanged. (see section
-         * 5.3.3 of the LW M2M spec).
-         * if this is a partial update request
-         */
-        WRITE_UPDATE(9, "WriteUpdate"),
-        WRITE_ATTRIBUTES(10, "WriteAttributes"),
-        DELETE(11, "Delete"),
-
-        // only for RPC
-        FW_UPDATE(12, "FirmwareUpdate");
-//        FW_READ_INFO(12, "FirmwareReadInfo"),
-
-//        SW_READ_INFO(15, "SoftwareReadInfo"),
-//        SW_UPDATE(16, "SoftwareUpdate"),
-//        SW_UNINSTALL(18, "SoftwareUninstall");
-
-        public int code;
-        public String type;
-
-        LwM2mTypeOper(int code, String type) {
-            this.code = code;
-            this.type = type;
-        }
-
-        public static LwM2mTypeOper fromLwLwM2mTypeOper(String type) {
-            for (LwM2mTypeOper to : LwM2mTypeOper.values()) {
-                if (to.type.equals(type)) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported typeOper type  : %s", type));
-        }
-    }
-
-    /**
-     * /** State R
-     * 0: Idle (before downloading or after successful updating)
-     * 1: Downloading (The data sequence is on the way)
-     * 2: Downloaded
-     * 3: Updating
-     */
-    public enum StateFw {
-        IDLE(0, "Idle"),
-        DOWNLOADING(1, "Downloading"),
-        DOWNLOADED(2, "Downloaded"),
-        UPDATING(3, "Updating");
-
-        public int code;
-        public String type;
-
-        StateFw(int code, String type) {
-            this.code = code;
-            this.type = type;
-        }
-
-        public static StateFw fromStateFwByType(String type) {
-            for (StateFw to : StateFw.values()) {
-                if (to.type.equals(type)) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported FW State type  : %s", type));
-        }
-
-        public static StateFw fromStateFwByCode(int code) {
-            for (StateFw to : StateFw.values()) {
-                if (to.code == code) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported FW State code : %s", code));
-        }
-    }
-
-    /**
-     * FW Update Result
-     * 0: Initial value. Once the updating process is initiated (Download /Update), this Resource MUST be reset to Initial value.
-     * 1: Firmware updated successfully.
-     * 2: Not enough flash memory for the new firmware package.
-     * 3: Out of RAM during downloading process.
-     * 4: Connection lost during downloading process.
-     * 5: Integrity check failure for new downloaded package.
-     * 6: Unsupported package type.
-     * 7: Invalid URI.
-     * 8: Firmware update failed.
-     * 9: Unsupported protocol.
-     */
-    public enum UpdateResultFw {
-        INITIAL(0, "Initial value", false),
-        UPDATE_SUCCESSFULLY(1, "Firmware updated successfully", false),
-        NOT_ENOUGH(2, "Not enough flash memory for the new firmware package", false),
-        OUT_OFF_MEMORY(3, "Out of RAM during downloading process", false),
-        CONNECTION_LOST(4, "Connection lost during downloading process", true),
-        INTEGRITY_CHECK_FAILURE(5, "Integrity check failure for new downloaded package", true),
-        UNSUPPORTED_TYPE(6, "Unsupported package type", false),
-        INVALID_URI(7, "Invalid URI", false),
-        UPDATE_FAILED(8, "Firmware update failed", false),
-        UNSUPPORTED_PROTOCOL(9, "Unsupported protocol", false);
-
-        public int code;
-        public String type;
-        public boolean isAgain;
-
-        UpdateResultFw(int code, String type, boolean isAgain) {
-            this.code = code;
-            this.type = type;
-            this.isAgain = isAgain;
-        }
-
-        public static UpdateResultFw fromUpdateResultFwByType(String type) {
-            for (UpdateResultFw to : UpdateResultFw.values()) {
-                if (to.type.equals(type)) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported FW Update Result type  : %s", type));
-        }
-
-        public static UpdateResultFw fromUpdateResultFwByCode(int code) {
-            for (UpdateResultFw to : UpdateResultFw.values()) {
-                if (to.code == code) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported FW Update Result code  : %s", code));
-        }
-    }
-
-    /**
-     * FirmwareUpdateStatus {
-     * DOWNLOADING, DOWNLOADED, VERIFIED, UPDATING, UPDATED, FAILED
-     */
-    public static OtaPackageUpdateStatus equalsFwSateFwResultToFirmwareUpdateStatus(StateFw stateFw, UpdateResultFw updateResultFw) {
-        switch (updateResultFw) {
-            case INITIAL:
-                return equalsFwSateToFirmwareUpdateStatus(stateFw);
-             case UPDATE_SUCCESSFULLY:
-                return UPDATED;
-            case NOT_ENOUGH:
-            case OUT_OFF_MEMORY:
-            case CONNECTION_LOST:
-            case INTEGRITY_CHECK_FAILURE:
-            case UNSUPPORTED_TYPE:
-            case INVALID_URI:
-            case UPDATE_FAILED:
-            case UNSUPPORTED_PROTOCOL:
-                return FAILED;
-            default:
-                throw new CodecException("Invalid value stateFw %s   %s for FirmwareUpdateStatus.", stateFw.name(), updateResultFw.name());
-        }
-    }
-
-    public static OtaPackageUpdateStatus equalsFwResultToFirmwareUpdateStatus(UpdateResultFw updateResultFw) {
+    public static Optional<OtaPackageUpdateStatus> toOtaPackageUpdateStatus(UpdateResultFw updateResultFw) {
         switch (updateResultFw) {
         switch (updateResultFw) {
             case INITIAL:
             case INITIAL:
-                return VERIFIED;
-             case UPDATE_SUCCESSFULLY:
-                return UPDATED;
+                return Optional.empty();
+            case UPDATE_SUCCESSFULLY:
+                return Optional.of(UPDATED);
             case NOT_ENOUGH:
             case NOT_ENOUGH:
             case OUT_OFF_MEMORY:
             case OUT_OFF_MEMORY:
             case CONNECTION_LOST:
             case CONNECTION_LOST:
@@ -409,24 +215,24 @@ public class LwM2mTransportUtil {
             case INVALID_URI:
             case INVALID_URI:
             case UPDATE_FAILED:
             case UPDATE_FAILED:
             case UNSUPPORTED_PROTOCOL:
             case UNSUPPORTED_PROTOCOL:
-                return FAILED;
+                return Optional.of(FAILED);
             default:
             default:
                 throw new CodecException("Invalid value stateFw %s for FirmwareUpdateStatus.", updateResultFw.name());
                 throw new CodecException("Invalid value stateFw %s for FirmwareUpdateStatus.", updateResultFw.name());
         }
         }
     }
     }
 
 
-    public static OtaPackageUpdateStatus equalsFwSateToFirmwareUpdateStatus(StateFw stateFw) {
-        switch (stateFw) {
+    public static Optional<OtaPackageUpdateStatus> toOtaPackageUpdateStatus(UpdateStateFw updateStateFw) {
+        switch (updateStateFw) {
             case IDLE:
             case IDLE:
-                return VERIFIED;
+                return Optional.empty();
             case DOWNLOADING:
             case DOWNLOADING:
-                return DOWNLOADING;
+                return Optional.of(DOWNLOADING);
             case DOWNLOADED:
             case DOWNLOADED:
-                return DOWNLOADED;
+                return Optional.of(DOWNLOADED);
             case UPDATING:
             case UPDATING:
-                return UPDATING;
+                return Optional.of(UPDATING);
             default:
             default:
-                throw new CodecException("Invalid value stateFw %d for FirmwareUpdateStatus.", stateFw);
+                throw new CodecException("Invalid value stateFw %d for FirmwareUpdateStatus.", updateStateFw);
         }
         }
     }
     }
 
 
@@ -574,70 +380,6 @@ public class LwM2mTransportUtil {
         }
         }
     }
     }
 
 
-    public enum LwM2MFirmwareUpdateStrategy {
-        OBJ_5_BINARY(1, "ObjectId 5, Binary"),
-        OBJ_5_TEMP_URL(2, "ObjectId 5, URI"),
-        OBJ_19_BINARY(3, "ObjectId 19, Binary");
-
-        public int code;
-        public String type;
-
-        LwM2MFirmwareUpdateStrategy(int code, String type) {
-            this.code = code;
-            this.type = type;
-        }
-
-        public static LwM2MFirmwareUpdateStrategy fromStrategyFwByType(String type) {
-            for (LwM2MFirmwareUpdateStrategy to : LwM2MFirmwareUpdateStrategy.values()) {
-                if (to.type.equals(type)) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported FW State type  : %s", type));
-        }
-
-        public static LwM2MFirmwareUpdateStrategy fromStrategyFwByCode(int code) {
-            for (LwM2MFirmwareUpdateStrategy to : LwM2MFirmwareUpdateStrategy.values()) {
-                if (to.code == code) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported FW Strategy code : %s", code));
-        }
-    }
-
-    public enum LwM2MSoftwareUpdateStrategy {
-        BINARY(1, "ObjectId 9, Binary"),
-        TEMP_URL(2, "ObjectId 9, URI");
-
-        public int code;
-        public String type;
-
-        LwM2MSoftwareUpdateStrategy(int code, String type) {
-            this.code = code;
-            this.type = type;
-        }
-
-        public static LwM2MSoftwareUpdateStrategy fromStrategySwByType(String type) {
-            for (LwM2MSoftwareUpdateStrategy to : LwM2MSoftwareUpdateStrategy.values()) {
-                if (to.type.equals(type)) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported SW Strategy type  : %s", type));
-        }
-
-        public static LwM2MSoftwareUpdateStrategy fromStrategySwByCode(int code) {
-            for (LwM2MSoftwareUpdateStrategy to : LwM2MSoftwareUpdateStrategy.values()) {
-                if (to.code == code) {
-                    return to;
-                }
-            }
-            throw new IllegalArgumentException(String.format("Unsupported SW Strategy code : %s", code));
-        }
-
-    }
-
     /**
     /**
      * FirmwareUpdateStatus {
      * FirmwareUpdateStatus {
      * DOWNLOADING, DOWNLOADED, VERIFIED, UPDATING, UPDATED, FAILED
      * DOWNLOADING, DOWNLOADED, VERIFIED, UPDATING, UPDATED, FAILED
@@ -695,26 +437,23 @@ public class LwM2mTransportUtil {
         }
         }
     }
     }
 
 
-    public static LwM2mOtaConvert convertOtaUpdateValueToString (String pathIdVer, Object value, ResourceModel.Type currentType) {
-        String path = convertPathFromIdVerToObjectId(pathIdVer);
+    public static LwM2mOtaConvert convertOtaUpdateValueToString(String pathIdVer, Object value, ResourceModel.Type currentType) {
+        String path = fromVersionedIdToObjectId(pathIdVer);
         LwM2mOtaConvert lwM2mOtaConvert = new LwM2mOtaConvert();
         LwM2mOtaConvert lwM2mOtaConvert = new LwM2mOtaConvert();
         if (path != null) {
         if (path != null) {
             if (FW_STATE_ID.equals(path)) {
             if (FW_STATE_ID.equals(path)) {
                 lwM2mOtaConvert.setCurrentType(STRING);
                 lwM2mOtaConvert.setCurrentType(STRING);
-                lwM2mOtaConvert.setValue(StateFw.fromStateFwByCode(((Long) value).intValue()).type);
+                lwM2mOtaConvert.setValue(UpdateStateFw.fromStateFwByCode(((Long) value).intValue()).type);
                 return lwM2mOtaConvert;
                 return lwM2mOtaConvert;
-            }
-            else if (FW_RESULT_ID.equals(path)) {
+            } else if (FW_RESULT_ID.equals(path)) {
                 lwM2mOtaConvert.setCurrentType(STRING);
                 lwM2mOtaConvert.setCurrentType(STRING);
-                lwM2mOtaConvert.setValue(UpdateResultFw.fromUpdateResultFwByCode(((Long) value).intValue()).type);
+                lwM2mOtaConvert.setValue(UpdateResultFw.fromUpdateResultFwByCode(((Long) value).intValue()).getType());
                 return lwM2mOtaConvert;
                 return lwM2mOtaConvert;
-            }
-            else if (SW_UPDATE_STATE_ID.equals(path)) {
+            } else if (SW_UPDATE_STATE_ID.equals(path)) {
                 lwM2mOtaConvert.setCurrentType(STRING);
                 lwM2mOtaConvert.setCurrentType(STRING);
                 lwM2mOtaConvert.setValue(UpdateStateSw.fromUpdateStateSwByCode(((Long) value).intValue()).type);
                 lwM2mOtaConvert.setValue(UpdateStateSw.fromUpdateStateSwByCode(((Long) value).intValue()).type);
                 return lwM2mOtaConvert;
                 return lwM2mOtaConvert;
-            }
-            else if (SW_RESULT_ID.equals(path)) {
+            } else if (SW_RESULT_ID.equals(path)) {
                 lwM2mOtaConvert.setCurrentType(STRING);
                 lwM2mOtaConvert.setCurrentType(STRING);
                 lwM2mOtaConvert.setValue(UpdateResultSw.fromUpdateResultSwByCode(((Long) value).intValue()).type);
                 lwM2mOtaConvert.setValue(UpdateResultSw.fromUpdateResultSwByCode(((Long) value).intValue()).type);
                 return lwM2mOtaConvert;
                 return lwM2mOtaConvert;
@@ -738,112 +477,32 @@ public class LwM2mTransportUtil {
         return null;
         return null;
     }
     }
 
 
-
-    public static LwM2mClientProfile getNewProfileParameters(JsonObject profilesConfigData, TenantId tenantId) {
-        LwM2mClientProfile lwM2MClientProfile = new LwM2mClientProfile();
-        lwM2MClientProfile.setTenantId(tenantId);
-        lwM2MClientProfile.setPostClientLwM2mSettings(profilesConfigData.get(CLIENT_LWM2M_SETTINGS).getAsJsonObject());
-        lwM2MClientProfile.setPostKeyNameProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(KEY_NAME).getAsJsonObject());
-        lwM2MClientProfile.setPostAttributeProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE).getAsJsonArray());
-        lwM2MClientProfile.setPostTelemetryProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(TELEMETRY).getAsJsonArray());
-        lwM2MClientProfile.setPostObserveProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(OBSERVE_LWM2M).getAsJsonArray());
-        lwM2MClientProfile.setPostAttributeLwm2mProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE_LWM2M).getAsJsonObject());
-        return lwM2MClientProfile;
-    }
-
-    /**
-     * @return deviceProfileBody with Observe&Attribute&Telemetry From Thingsboard
-     * Example:
-     * property: {"clientLwM2mSettings": {
-     * clientUpdateValueAfterConnect: false;
-     * }
-     * property: "observeAttr"
-     * {"keyName": {
-     * "/3/0/1": "modelNumber",
-     * "/3/0/0": "manufacturer",
-     * "/3/0/2": "serialNumber"
-     * },
-     * "attribute":["/2/0/1","/3/0/9"],
-     * "telemetry":["/1/0/1","/2/0/1","/6/0/1"],
-     * "observe":["/2/0","/2/0/0","/4/0/2"]}
-     * "attributeLwm2m": {"/3_1.0": {"ver": "currentTimeTest11"},
-     * "/3_1.0/0": {"gt": 17},
-     * "/3_1.0/0/9": {"pmax": 45}, "/3_1.2": {ver": "3_1.2"}}
-     */
-    public static LwM2mClientProfile toLwM2MClientProfile(DeviceProfile deviceProfile) {
-        if (((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties().size() > 0) {
-            Object profile = ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties();
-            try {
-                ObjectMapper mapper = new ObjectMapper();
-                String profileStr = mapper.writeValueAsString(profile);
-                JsonObject profileJson = (profileStr != null) ? validateJson(profileStr) : null;
-                return getValidateCredentialsBodyFromThingsboard(profileJson) ? LwM2mTransportUtil.getNewProfileParameters(profileJson, deviceProfile.getTenantId()) : null;
-            } catch (IOException e) {
-                log.error("", e);
-            }
-        }
-        return null;
-    }
-
-    public static JsonObject getBootstrapParametersFromThingsboard(DeviceProfile deviceProfile) {
-        if (deviceProfile != null && ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties().size() > 0) {
-            Object bootstrap = ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties();
-            try {
-                ObjectMapper mapper = new ObjectMapper();
-                String bootstrapStr = mapper.writeValueAsString(bootstrap);
-                JsonObject objectMsg = (bootstrapStr != null) ? validateJson(bootstrapStr) : null;
-                return (getValidateBootstrapProfileFromThingsboard(objectMsg)) ? objectMsg.get(BOOTSTRAP).getAsJsonObject() : null;
-            } catch (IOException e) {
-                log.error("", e);
-            }
+//    public static LwM2mClientProfile getNewProfileParameters(JsonObject profilesConfigData, TenantId tenantId) {
+//        LwM2mClientProfile lwM2MClientProfile = new LwM2mClientProfile();
+//        lwM2MClientProfile.setTenantId(tenantId);
+//        lwM2MClientProfile.setPostClientLwM2mSettings(profilesConfigData.get(CLIENT_LWM2M_SETTINGS).getAsJsonObject());
+//        lwM2MClientProfile.setPostKeyNameProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(KEY_NAME).getAsJsonObject());
+//        lwM2MClientProfile.setPostAttributeProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE).getAsJsonArray());
+//        lwM2MClientProfile.setPostTelemetryProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(TELEMETRY).getAsJsonArray());
+//        lwM2MClientProfile.setPostObserveProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(OBSERVE_LWM2M).getAsJsonArray());
+//        lwM2MClientProfile.setPostAttributeLwm2mProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE_LWM2M).getAsJsonObject());
+//        return lwM2MClientProfile;
+//    }
+
+    public static Lwm2mDeviceProfileTransportConfiguration toLwM2MClientProfile(DeviceProfile deviceProfile) {
+        DeviceProfileTransportConfiguration transportConfiguration = deviceProfile.getProfileData().getTransportConfiguration();
+        if (transportConfiguration.getType().equals(DeviceTransportType.LWM2M)) {
+            return (Lwm2mDeviceProfileTransportConfiguration) transportConfiguration;
+        } else {
+            log.warn("[{}] Received profile with invalid transport configuration: {}", deviceProfile.getId(), deviceProfile.getProfileData().getTransportConfiguration());
+            throw new IllegalArgumentException("Received profile with invalid transport configuration: " + transportConfiguration.getType());
         }
         }
-        return null;
-    }
-
-    private static boolean getValidateCredentialsBodyFromThingsboard(JsonObject objectMsg) {
-        return (objectMsg != null &&
-                !objectMsg.isJsonNull() &&
-                objectMsg.has(CLIENT_LWM2M_SETTINGS) &&
-                !objectMsg.get(CLIENT_LWM2M_SETTINGS).isJsonNull() &&
-                objectMsg.get(CLIENT_LWM2M_SETTINGS).isJsonObject() &&
-                objectMsg.has(OBSERVE_ATTRIBUTE_TELEMETRY) &&
-                !objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).isJsonNull() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).isJsonObject() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().has(KEY_NAME) &&
-                !objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(KEY_NAME).isJsonNull() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(KEY_NAME).isJsonObject() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().has(ATTRIBUTE) &&
-                !objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE).isJsonNull() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE).isJsonArray() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().has(TELEMETRY) &&
-                !objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(TELEMETRY).isJsonNull() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(TELEMETRY).isJsonArray() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().has(OBSERVE_LWM2M) &&
-                !objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(OBSERVE_LWM2M).isJsonNull() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(OBSERVE_LWM2M).isJsonArray() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().has(ATTRIBUTE_LWM2M) &&
-                !objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE_LWM2M).isJsonNull() &&
-                objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE_LWM2M).isJsonObject());
     }
     }
 
 
-    private static boolean getValidateBootstrapProfileFromThingsboard(JsonObject objectMsg) {
-        return (objectMsg != null &&
-                !objectMsg.isJsonNull() &&
-                objectMsg.has(BOOTSTRAP) &&
-                objectMsg.get(BOOTSTRAP).isJsonObject() &&
-                !objectMsg.get(BOOTSTRAP).isJsonNull() &&
-                objectMsg.get(BOOTSTRAP).getAsJsonObject().has(SERVERS) &&
-                !objectMsg.get(BOOTSTRAP).getAsJsonObject().get(SERVERS).isJsonNull() &&
-                objectMsg.get(BOOTSTRAP).getAsJsonObject().get(SERVERS).isJsonObject() &&
-                objectMsg.get(BOOTSTRAP).getAsJsonObject().has(BOOTSTRAP_SERVER) &&
-                !objectMsg.get(BOOTSTRAP).getAsJsonObject().get(BOOTSTRAP_SERVER).isJsonNull() &&
-                objectMsg.get(BOOTSTRAP).getAsJsonObject().get(BOOTSTRAP_SERVER).isJsonObject() &&
-                objectMsg.get(BOOTSTRAP).getAsJsonObject().has(LWM2M_SERVER) &&
-                !objectMsg.get(BOOTSTRAP).getAsJsonObject().get(LWM2M_SERVER).isJsonNull() &&
-                objectMsg.get(BOOTSTRAP).getAsJsonObject().get(LWM2M_SERVER).isJsonObject());
+    public static BootstrapConfiguration getBootstrapParametersFromThingsboard(DeviceProfile deviceProfile) {
+        return toLwM2MClientProfile(deviceProfile).getBootstrap();
     }
     }
 
 
-
     public static JsonObject validateJson(String jsonStr) {
     public static JsonObject validateJson(String jsonStr) {
         JsonObject object = null;
         JsonObject object = null;
         if (jsonStr != null && !jsonStr.isEmpty()) {
         if (jsonStr != null && !jsonStr.isEmpty()) {
@@ -900,8 +559,11 @@ public class LwM2mTransportUtil {
         };
         };
     }
     }
 
 
-    public static String convertPathFromIdVerToObjectId(String pathIdVer) {
+    public static String fromVersionedIdToObjectId(String pathIdVer) {
         try {
         try {
+            if (pathIdVer == null) {
+                return null;
+            }
             String[] keyArray = pathIdVer.split(LWM2M_SEPARATOR_PATH);
             String[] keyArray = pathIdVer.split(LWM2M_SEPARATOR_PATH);
             if (keyArray.length > 1 && keyArray[1].split(LWM2M_SEPARATOR_KEY).length == 2) {
             if (keyArray.length > 1 && keyArray[1].split(LWM2M_SEPARATOR_KEY).length == 2) {
                 keyArray[1] = keyArray[1].split(LWM2M_SEPARATOR_KEY)[0];
                 keyArray[1] = keyArray[1].split(LWM2M_SEPARATOR_KEY)[0];
@@ -910,7 +572,8 @@ public class LwM2mTransportUtil {
                 return pathIdVer;
                 return pathIdVer;
             }
             }
         } catch (Exception e) {
         } catch (Exception e) {
-            return null;
+            log.warn("Issue converting path with version [{}] to path without version: ", pathIdVer, e);
+            throw new RuntimeException(e);
         }
         }
     }
     }
 
 
@@ -941,12 +604,12 @@ public class LwM2mTransportUtil {
                 return pathIdVer;
                 return pathIdVer;
             } else {
             } else {
                 LwM2mPath pathObjId = new LwM2mPath(pathIdVer);
                 LwM2mPath pathObjId = new LwM2mPath(pathIdVer);
-                return convertPathFromObjectIdToIdVer(pathIdVer, registration);
+                return convertObjectIdToVersionedId(pathIdVer, registration);
             }
             }
         }
         }
     }
     }
 
 
-    public static String convertPathFromObjectIdToIdVer(String path, Registration registration) {
+    public static String convertObjectIdToVersionedId(String path, Registration registration) {
         String ver = registration.getSupportedObject().get(new LwM2mPath(path).getObjectId());
         String ver = registration.getSupportedObject().get(new LwM2mPath(path).getObjectId());
         ver = ver != null ? ver : LWM2M_VERSION_DEFAULT;
         ver = ver != null ? ver : LWM2M_VERSION_DEFAULT;
         try {
         try {
@@ -1001,12 +664,12 @@ public class LwM2mTransportUtil {
      * Attribute pmax = new Attribute(MAXIMUM_PERIOD, "60");
      * Attribute pmax = new Attribute(MAXIMUM_PERIOD, "60");
      * Attribute [] attrs = {gt, st};
      * Attribute [] attrs = {gt, st};
      */
      */
-    public static SimpleDownlinkRequest createWriteAttributeRequest(String target, Object params, DefaultLwM2MTransportMsgHandler serviceImpl) {
+    public static SimpleDownlinkRequest createWriteAttributeRequest(String target, Object params, DefaultLwM2MUplinkMsgHandler serviceImpl) {
         AttributeSet attrSet = new AttributeSet(createWriteAttributes(params, serviceImpl, target));
         AttributeSet attrSet = new AttributeSet(createWriteAttributes(params, serviceImpl, target));
         return attrSet.getAttributes().size() > 0 ? new WriteAttributesRequest(target, attrSet) : null;
         return attrSet.getAttributes().size() > 0 ? new WriteAttributesRequest(target, attrSet) : null;
     }
     }
 
 
-    private static Attribute[] createWriteAttributes(Object params, DefaultLwM2MTransportMsgHandler serviceImpl, String target) {
+    private static Attribute[] createWriteAttributes(Object params, DefaultLwM2MUplinkMsgHandler serviceImpl, String target) {
         List<Attribute> attributeLists = new ArrayList<>();
         List<Attribute> attributeLists = new ArrayList<>();
         ObjectMapper oMapper = new ObjectMapper();
         ObjectMapper oMapper = new ObjectMapper();
         Map<String, Object> map = oMapper.convertValue(params, ConcurrentHashMap.class);
         Map<String, Object> map = oMapper.convertValue(params, ConcurrentHashMap.class);
@@ -1024,12 +687,6 @@ public class LwM2mTransportUtil {
         return attributeLists.toArray(Attribute[]::new);
         return attributeLists.toArray(Attribute[]::new);
     }
     }
 
 
-    public static Set<String> convertJsonArrayToSet(JsonArray jsonArray) {
-        List<String> attributeListOld = new Gson().fromJson(jsonArray, new TypeToken<List<String>>() {
-        }.getType());
-        return Sets.newConcurrentHashSet(attributeListOld);
-    }
-
     public static ResourceModel.Type equalsResourceTypeGetSimpleName(Object value) {
     public static ResourceModel.Type equalsResourceTypeGetSimpleName(Object value) {
         switch (value.getClass().getSimpleName()) {
         switch (value.getClass().getSimpleName()) {
             case "Double":
             case "Double":
@@ -1051,15 +708,7 @@ public class LwM2mTransportUtil {
         }
         }
     }
     }
 
 
-    public static LwM2mTypeOper setValidTypeOper(String typeOper) {
-        try {
-            return LwM2mTransportUtil.LwM2mTypeOper.fromLwLwM2mTypeOper(typeOper);
-        } catch (Exception e) {
-            return null;
-        }
-    }
-
-    public static Object convertWriteAttributes(String type, Object value, DefaultLwM2MTransportMsgHandler serviceImpl, String target) {
+    public static Object convertWriteAttributes(String type, Object value, DefaultLwM2MUplinkMsgHandler serviceImpl, String target) {
         switch (type) {
         switch (type) {
             /** Integer [0:255]; */
             /** Integer [0:255]; */
             case DIMENSION:
             case DIMENSION:
@@ -1106,4 +755,20 @@ public class LwM2mTransportUtil {
                 || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.CHECKSUM_ALGORITHM).equals(pathName)
                 || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.CHECKSUM_ALGORITHM).equals(pathName)
                 || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.SIZE).equals(pathName);
                 || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.SIZE).equals(pathName);
     }
     }
+
+    /**
+     * @param lwM2MClient -
+     * @param path        -
+     * @return - return value of Resource by idPath
+     */
+    public static LwM2mResource getResourceValueFromLwM2MClient(LwM2mClient lwM2MClient, String path) {
+        LwM2mResource lwm2mResourceValue = null;
+        ResourceValue resourceValue = lwM2MClient.getResources().get(path);
+        if (resourceValue != null) {
+            if (new LwM2mPath(fromVersionedIdToObjectId(path)).isResource()) {
+                lwm2mResourceValue = lwM2MClient.getResources().get(path).getLwM2mResource();
+            }
+        }
+        return lwm2mResourceValue;
+    }
 }
 }

@@ -72,7 +72,7 @@ public class LwM2mVersionedModelProvider implements LwM2mModelProvider {
 
 
         public DynamicModel(Registration registration) {
         public DynamicModel(Registration registration) {
             this.registration = registration;
             this.registration = registration;
-            this.tenantId = lwM2mClientContext.getProfile(registration).getTenantId();
+            this.tenantId = lwM2mClientContext.getClientByEndpoint(registration.getEndpoint()).getTenantId();
         }
         }
 
 
         @Override
         @Override

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+import lombok.Getter;
+
+/**
+ * FW Update Result
+ * 0: Initial value. Once the updating process is initiated (Download /Update), this Resource MUST be reset to Initial value.
+ * 1: Firmware updated successfully.
+ * 2: Not enough flash memory for the new firmware package.
+ * 3: Out of RAM during downloading process.
+ * 4: Connection lost during downloading process.
+ * 5: Integrity check failure for new downloaded package.
+ * 6: Unsupported package type.
+ * 7: Invalid URI.
+ * 8: Firmware update failed.
+ * 9: Unsupported protocol.
+ */
+public enum UpdateResultFw {
+    INITIAL(0, "Initial value", false),
+    UPDATE_SUCCESSFULLY(1, "Firmware updated successfully", false),
+    NOT_ENOUGH(2, "Not enough flash memory for the new firmware package", false),
+    OUT_OFF_MEMORY(3, "Out of RAM during downloading process", false),
+    CONNECTION_LOST(4, "Connection lost during downloading process", true),
+    INTEGRITY_CHECK_FAILURE(5, "Integrity check failure for new downloaded package", true),
+    UNSUPPORTED_TYPE(6, "Unsupported package type", false),
+    INVALID_URI(7, "Invalid URI", false),
+    UPDATE_FAILED(8, "Firmware update failed", false),
+    UNSUPPORTED_PROTOCOL(9, "Unsupported protocol", false);
+
+    @Getter
+    private int code;
+    @Getter
+    private String type;
+    @Getter
+    private boolean again;
+
+    UpdateResultFw(int code, String type, boolean isAgain) {
+        this.code = code;
+        this.type = type;
+        this.again = isAgain;
+    }
+
+    public static UpdateResultFw fromUpdateResultFwByType(String type) {
+        for (UpdateResultFw to : UpdateResultFw.values()) {
+            if (to.type.equals(type)) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported FW Update Result type  : %s", type));
+    }
+
+    public static UpdateResultFw fromUpdateResultFwByCode(int code) {
+        for (UpdateResultFw to : UpdateResultFw.values()) {
+            if (to.code == code) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported FW Update Result code  : %s", code));
+    }
+}

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+/**
+ * /** State R
+ * 0: Idle (before downloading or after successful updating)
+ * 1: Downloading (The data sequence is on the way)
+ * 2: Downloaded
+ * 3: Updating
+ */
+public enum UpdateStateFw {
+    IDLE(0, "Idle"),
+    DOWNLOADING(1, "Downloading"),
+    DOWNLOADED(2, "Downloaded"),
+    UPDATING(3, "Updating");
+
+    public int code;
+    public String type;
+
+    UpdateStateFw(int code, String type) {
+        this.code = code;
+        this.type = type;
+    }
+
+    public static UpdateStateFw fromStateFwByType(String type) {
+        for (UpdateStateFw to : UpdateStateFw.values()) {
+            if (to.type.equals(type)) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported FW State type  : %s", type));
+    }
+
+    public static UpdateStateFw fromStateFwByCode(int code) {
+        for (UpdateStateFw to : UpdateStateFw.values()) {
+            if (to.code == code) {
+                return to;
+            }
+        }
+        throw new IllegalArgumentException(String.format("Unsupported FW State code : %s", code));
+    }
+}

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server.attributes;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.leshan.core.model.ResourceModel;
+import org.eclipse.leshan.core.node.LwM2mPath;
+import org.eclipse.leshan.core.node.LwM2mResource;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.ota.OtaPackageKey;
+import org.thingsboard.server.common.data.ota.OtaPackageType;
+import org.thingsboard.server.common.data.ota.OtaPackageUtil;
+import org.thingsboard.server.common.transport.TransportService;
+import org.thingsboard.server.common.transport.TransportServiceCallback;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeResponseMsg;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
+import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportServerHelper;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
+import org.thingsboard.server.transport.lwm2m.server.downlink.LwM2mDownlinkMsgHandler;
+import org.thingsboard.server.transport.lwm2m.server.downlink.TbLwM2MWriteReplaceRequest;
+import org.thingsboard.server.transport.lwm2m.server.downlink.TbLwM2MWriteResponseCallback;
+import org.thingsboard.server.transport.lwm2m.server.log.LwM2MTelemetryLogService;
+import org.thingsboard.server.transport.lwm2m.server.ota.DefaultLwM2MOtaUpdateService;
+import org.thingsboard.server.transport.lwm2m.server.ota.LwM2MOtaUpdateService;
+import org.thingsboard.server.transport.lwm2m.server.uplink.LwM2mUplinkMsgHandler;
+import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportServerHelper.getValueFromKvProto;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LWM2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.fromVersionedIdToObjectId;
+
+@Slf4j
+@Service
+@TbLwM2mTransportComponent
+@RequiredArgsConstructor
+public class DefaultLwM2MAttributesService implements LwM2MAttributesService {
+
+    //TODO: add timeout logic
+    private final AtomicInteger reqIdSeq = new AtomicInteger();
+    private final Map<Integer, SettableFuture<List<TransportProtos.TsKvProto>>> futures;
+
+    private final TransportService transportService;
+    private final LwM2mTransportServerHelper helper;
+    private final LwM2mClientContext clientContext;
+    private final LwM2MTransportServerConfig config;
+    private final LwM2mUplinkMsgHandler uplinkHandler;
+    private final LwM2mDownlinkMsgHandler downlinkHandler;
+    private final LwM2MTelemetryLogService logService;
+    private final LwM2MOtaUpdateService otaUpdateService;
+
+    @Override
+    public ListenableFuture<List<TransportProtos.TsKvProto>> getSharedAttributes(LwM2mClient client, Collection<String> keys) {
+        SettableFuture<List<TransportProtos.TsKvProto>> future = SettableFuture.create();
+        int requestId = reqIdSeq.incrementAndGet();
+        futures.put(requestId, future);
+        transportService.process(client.getSession(), TransportProtos.GetAttributeRequestMsg.newBuilder().setRequestId(requestId).
+                addAllSharedAttributeNames(keys).build(), new TransportServiceCallback<Void>() {
+            @Override
+            public void onSuccess(Void msg) {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                SettableFuture<List<TransportProtos.TsKvProto>> callback = futures.remove(requestId);
+                if (callback != null) {
+                    callback.setException(e);
+                }
+            }
+        });
+        return future;
+    }
+
+    @Override
+    public void onGetAttributesResponse(GetAttributeResponseMsg getAttributesResponse, TransportProtos.SessionInfoProto sessionInfo) {
+        var callback = futures.remove(getAttributesResponse.getRequestId());
+        if (callback != null) {
+            callback.set(getAttributesResponse.getSharedAttributeListList());
+        }
+    }
+
+    /**
+     * Update - send request in change value resources in Client
+     * 1. FirmwareUpdate:
+     * - If msg.getSharedUpdatedList().forEach(tsKvProto -> {tsKvProto.getKv().getKey().indexOf(FIRMWARE_UPDATE_PREFIX, 0) == 0
+     * 2. Shared Other AttributeUpdate
+     * -- Path to resources from profile equal keyName or from ModelObject equal name
+     * -- Only for resources:  isWritable && isPresent as attribute in profile -> LwM2MClientProfile (format: CamelCase)
+     * 3. Delete - nothing
+     *
+     * @param msg -
+     */
+    @Override
+    public void onAttributesUpdate(TransportProtos.AttributeUpdateNotificationMsg msg, TransportProtos.SessionInfoProto sessionInfo) {
+        LwM2mClient lwM2MClient = clientContext.getClientBySessionInfo(sessionInfo);
+        if (msg.getSharedUpdatedCount() > 0 && lwM2MClient != null) {
+            String newFirmwareTitle = null;
+            String newFirmwareVersion = null;
+            String newFirmwareUrl = null;
+            String newSoftwareTitle = null;
+            String newSoftwareVersion = null;
+            List<TransportProtos.TsKvProto> otherAttributes = new ArrayList<>();
+            for (TransportProtos.TsKvProto tsKvProto : msg.getSharedUpdatedList()) {
+                String attrName = tsKvProto.getKv().getKey();
+                if (DefaultLwM2MOtaUpdateService.FIRMWARE_TITLE.equals(attrName)) {
+                    newFirmwareTitle = getStrValue(tsKvProto);
+                } else if (DefaultLwM2MOtaUpdateService.FIRMWARE_VERSION.equals(attrName)) {
+                    newFirmwareVersion = getStrValue(tsKvProto);
+                } else if (DefaultLwM2MOtaUpdateService.FIRMWARE_URL.equals(attrName)) {
+                    newFirmwareUrl = getStrValue(tsKvProto);
+                } else if (DefaultLwM2MOtaUpdateService.SOFTWARE_TITLE.equals(attrName)) {
+                    newSoftwareTitle = getStrValue(tsKvProto);
+                } else if (DefaultLwM2MOtaUpdateService.SOFTWARE_VERSION.equals(attrName)) {
+                    newSoftwareVersion = getStrValue(tsKvProto);
+                } else {
+                    otherAttributes.add(tsKvProto);
+                }
+            }
+            if (newFirmwareTitle != null || newFirmwareVersion != null) {
+                otaUpdateService.onTargetFirmwareUpdate(lwM2MClient, newFirmwareTitle, newFirmwareVersion, Optional.ofNullable(newFirmwareUrl));
+            }
+            if (newSoftwareTitle != null || newSoftwareVersion != null) {
+                otaUpdateService.onTargetSoftwareUpdate(lwM2MClient, newSoftwareTitle, newSoftwareVersion);
+            }
+            if (!otherAttributes.isEmpty()) {
+                onAttributesUpdate(lwM2MClient, otherAttributes);
+            }
+        } else if (lwM2MClient == null) {
+            log.error("OnAttributeUpdate, lwM2MClient is null");
+        }
+    }
+
+    /**
+     * #1.1 If two names have equal path => last time attribute
+     * #2.1 if there is a difference in values between the current resource values and the shared attribute values
+     * => send to client Request Update of value (new value from shared attribute)
+     * and LwM2MClient.delayedRequests.add(path)
+     * #2.1 if there is not a difference in values between the current resource values and the shared attribute values
+     *
+     */
+    @Override
+    public void onAttributesUpdate(LwM2mClient lwM2MClient, List<TransportProtos.TsKvProto> tsKvProtos) {
+        log.trace("[{}] onAttributesUpdate [{}]", lwM2MClient.getEndpoint(), tsKvProtos);
+        tsKvProtos.forEach(tsKvProto -> {
+            String pathIdVer = clientContext.getObjectIdByKeyNameFromProfile(lwM2MClient, tsKvProto.getKv().getKey());
+            if (pathIdVer != null) {
+                // #1.1
+                if (lwM2MClient.getSharedAttributes().containsKey(pathIdVer)) {
+                    if (tsKvProto.getTs() > lwM2MClient.getSharedAttributes().get(pathIdVer).getTs()) {
+                        lwM2MClient.getSharedAttributes().put(pathIdVer, tsKvProto);
+                    }
+                } else {
+                    lwM2MClient.getSharedAttributes().put(pathIdVer, tsKvProto);
+                }
+            }
+        });
+        // #2.1
+        lwM2MClient.getSharedAttributes().forEach((pathIdVer, tsKvProto) -> {
+            this.pushUpdateToClientIfNeeded(lwM2MClient, this.getResourceValueFormatKv(lwM2MClient, pathIdVer),
+                    getValueFromKvProto(tsKvProto.getKv()), pathIdVer);
+        });
+    }
+
+    private void pushUpdateToClientIfNeeded(LwM2mClient lwM2MClient, Object valueOld, Object newValue, String versionedId) {
+        if (newValue != null && (valueOld == null || !newValue.toString().equals(valueOld.toString()))) {
+            TbLwM2MWriteReplaceRequest request = TbLwM2MWriteReplaceRequest.builder().versionedId(versionedId).value(newValue).timeout(this.config.getTimeout()).build();
+            downlinkHandler.sendWriteReplaceRequest(lwM2MClient, request, new TbLwM2MWriteResponseCallback(uplinkHandler, logService, lwM2MClient, versionedId));
+        } else {
+            log.error("Failed update resource [{}] [{}]", versionedId, newValue);
+            String logMsg = String.format("%s: Failed update resource versionedId - %s value - %s. Value is not changed or bad",
+                    LOG_LWM2M_ERROR, versionedId, newValue);
+            logService.log(lwM2MClient, logMsg);
+            log.info("Failed update resource [{}] [{}]", versionedId, newValue);
+        }
+    }
+
+    /**
+     * @param pathIdVer - path resource
+     * @return - value of Resource into format KvProto or null
+     */
+    private Object getResourceValueFormatKv(LwM2mClient lwM2MClient, String pathIdVer) {
+        LwM2mResource resourceValue = LwM2mTransportUtil.getResourceValueFromLwM2MClient(lwM2MClient, pathIdVer);
+        if (resourceValue != null) {
+            ResourceModel.Type currentType = resourceValue.getType();
+            ResourceModel.Type expectedType = helper.getResourceModelTypeEqualsKvProtoValueType(currentType, pathIdVer);
+            return LwM2mValueConverterImpl.getInstance().convertValue(resourceValue.getValue(), currentType, expectedType,
+                    new LwM2mPath(fromVersionedIdToObjectId(pathIdVer)));
+        } else {
+            return null;
+        }
+    }
+
+    private String getStrValue(TransportProtos.TsKvProto tsKvProto) {
+        return tsKvProto.getKv().getStringV();
+    }
+}

+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server.attributes;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface LwM2MAttributesService {
+
+    ListenableFuture<List<TransportProtos.TsKvProto>> getSharedAttributes(LwM2mClient client, Collection<String> keys);
+
+    void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg getAttributesResponse, TransportProtos.SessionInfoProto sessionInfo);
+
+    void onAttributesUpdate(TransportProtos.AttributeUpdateNotificationMsg attributeUpdateNotification, TransportProtos.SessionInfoProto sessionInfo);
+
+    void onAttributesUpdate(LwM2mClient lwM2MClient, List<TransportProtos.TsKvProto> tsKvProtos);
+}

@@ -20,28 +20,27 @@ import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.leshan.core.model.ObjectModel;
 import org.eclipse.leshan.core.model.ObjectModel;
 import org.eclipse.leshan.core.model.ResourceModel;
 import org.eclipse.leshan.core.model.ResourceModel;
-import org.eclipse.leshan.core.node.LwM2mMultipleResource;
 import org.eclipse.leshan.core.node.LwM2mObject;
 import org.eclipse.leshan.core.node.LwM2mObject;
 import org.eclipse.leshan.core.node.LwM2mObjectInstance;
 import org.eclipse.leshan.core.node.LwM2mObjectInstance;
 import org.eclipse.leshan.core.node.LwM2mPath;
 import org.eclipse.leshan.core.node.LwM2mPath;
 import org.eclipse.leshan.core.node.LwM2mResource;
 import org.eclipse.leshan.core.node.LwM2mResource;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
+import org.eclipse.leshan.core.node.codec.LwM2mValueConverter;
 import org.eclipse.leshan.core.request.ContentFormat;
 import org.eclipse.leshan.core.request.ContentFormat;
 import org.eclipse.leshan.server.model.LwM2mModelProvider;
 import org.eclipse.leshan.server.model.LwM2mModelProvider;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
 import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
 import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
-import org.thingsboard.server.transport.lwm2m.server.DefaultLwM2MTransportMsgHandler;
 import org.thingsboard.server.transport.lwm2m.server.LwM2mQueuedRequest;
 import org.thingsboard.server.transport.lwm2m.server.LwM2mQueuedRequest;
-import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
+import org.thingsboard.server.transport.lwm2m.server.uplink.LwM2mUplinkMsgHandler;
 
 
 import java.util.Collection;
 import java.util.Collection;
-import java.util.List;
 import java.util.Map;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Queue;
@@ -49,18 +48,15 @@ import java.util.Set;
 import java.util.UUID;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
-import static org.eclipse.leshan.core.model.ResourceModel.Type.OPAQUE;
-import static org.eclipse.leshan.core.model.ResourceModel.Type.STRING;
 import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_PATH;
 import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_PATH;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.TRANSPORT_DEFAULT_LWM2M_VERSION;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.TRANSPORT_DEFAULT_LWM2M_VERSION;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromIdVerToObjectId;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromObjectIdToIdVer;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertObjectIdToVersionedId;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.equalsResourceTypeGetSimpleName;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.equalsResourceTypeGetSimpleName;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.fromVersionedIdToObjectId;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.getVerFromPathIdVerOrId;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.getVerFromPathIdVerOrId;
 
 
 @Slf4j
 @Slf4j
@@ -76,9 +72,7 @@ public class LwM2mClient implements Cloneable {
     @Getter
     @Getter
     private final Map<String, ResourceValue> resources;
     private final Map<String, ResourceValue> resources;
     @Getter
     @Getter
-    private final Map<String, TsKvProto> delayedRequests;
-    @Getter
-    private final List<String> pendingReadRequests;
+    private final Map<String, TsKvProto> sharedAttributes;
     @Getter
     @Getter
     private final Queue<LwM2mQueuedRequest> queuedRequests;
     private final Queue<LwM2mQueuedRequest> queuedRequests;
 
 
@@ -92,6 +86,8 @@ public class LwM2mClient implements Cloneable {
     @Getter
     @Getter
     private SecurityInfo securityInfo;
     private SecurityInfo securityInfo;
     @Getter
     @Getter
+    private TenantId tenantId;
+    @Getter
     private UUID deviceId;
     private UUID deviceId;
     @Getter
     @Getter
     private SessionInfoProto session;
     private SessionInfoProto session;
@@ -99,19 +95,10 @@ public class LwM2mClient implements Cloneable {
     private UUID profileId;
     private UUID profileId;
     @Getter
     @Getter
     @Setter
     @Setter
-    private volatile LwM2mFwSwUpdate fwUpdate;
-    @Getter
-    @Setter
-    private volatile LwM2mFwSwUpdate swUpdate;
-    @Getter
-    @Setter
     private Registration registration;
     private Registration registration;
 
 
     private ValidateDeviceCredentialsResponse credentials;
     private ValidateDeviceCredentialsResponse credentials;
 
 
-    @Getter
-    private boolean init;
-
     public Object clone() throws CloneNotSupportedException {
     public Object clone() throws CloneNotSupportedException {
         return super.clone();
         return super.clone();
     }
     }
@@ -120,26 +107,22 @@ public class LwM2mClient implements Cloneable {
         this.nodeId = nodeId;
         this.nodeId = nodeId;
         this.endpoint = endpoint;
         this.endpoint = endpoint;
         this.lock = new ReentrantLock();
         this.lock = new ReentrantLock();
-        this.delayedRequests = new ConcurrentHashMap<>();
-        this.pendingReadRequests = new CopyOnWriteArrayList<>();
+        this.sharedAttributes = new ConcurrentHashMap<>();
         this.resources = new ConcurrentHashMap<>();
         this.resources = new ConcurrentHashMap<>();
         this.queuedRequests = new ConcurrentLinkedQueue<>();
         this.queuedRequests = new ConcurrentLinkedQueue<>();
         this.state = LwM2MClientState.CREATED;
         this.state = LwM2MClientState.CREATED;
     }
     }
 
 
-    public void init(String identity, SecurityInfo securityInfo, ValidateDeviceCredentialsResponse credentials, UUID profileId, UUID sessionId) {
+    public void init(String identity, SecurityInfo securityInfo, ValidateDeviceCredentialsResponse credentials, UUID sessionId) {
         this.identity = identity;
         this.identity = identity;
         this.securityInfo = securityInfo;
         this.securityInfo = securityInfo;
         this.credentials = credentials;
         this.credentials = credentials;
-        this.profileId = profileId;
-        this.init = false;
-        if (this.credentials != null && this.credentials.hasDeviceInfo()) {
-            this.session = createSession(nodeId, sessionId, credentials);
-            this.deviceId = new UUID(session.getDeviceIdMSB(), session.getDeviceIdLSB());
-            this.profileId = new UUID(session.getDeviceProfileIdMSB(), session.getDeviceProfileIdLSB());
-            this.deviceName = session.getDeviceName();
-            this.deviceProfileName = session.getDeviceType();
-        }
+        this.session = createSession(nodeId, sessionId, credentials);
+        this.tenantId = new TenantId(new UUID(session.getTenantIdMSB(), session.getTenantIdLSB()));
+        this.deviceId = new UUID(session.getDeviceIdMSB(), session.getDeviceIdLSB());
+        this.profileId = new UUID(session.getDeviceProfileIdMSB(), session.getDeviceProfileIdLSB());
+        this.deviceName = session.getDeviceName();
+        this.deviceProfileName = session.getDeviceType();
     }
     }
 
 
     public void lock() {
     public void lock() {
@@ -198,7 +181,7 @@ public class LwM2mClient implements Cloneable {
             this.resources.get(pathRezIdVer).setLwM2mResource(rez);
             this.resources.get(pathRezIdVer).setLwM2mResource(rez);
             return true;
             return true;
         } else {
         } else {
-            LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathRezIdVer));
+            LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathRezIdVer));
             ResourceModel resourceModel = modelProvider.getObjectModel(registration).getResourceModel(pathIds.getObjectId(), pathIds.getResourceId());
             ResourceModel resourceModel = modelProvider.getObjectModel(registration).getResourceModel(pathIds.getObjectId(), pathIds.getResourceId());
             if (resourceModel != null) {
             if (resourceModel != null) {
                 this.resources.put(pathRezIdVer, new ResourceValue(rez, resourceModel));
                 this.resources.put(pathRezIdVer, new ResourceValue(rez, resourceModel));
@@ -210,7 +193,7 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     public Object getResourceValue(String pathRezIdVer, String pathRezId) {
     public Object getResourceValue(String pathRezIdVer, String pathRezId) {
-        String pathRez = pathRezIdVer == null ? convertPathFromObjectIdToIdVer(pathRezId, this.registration) : pathRezIdVer;
+        String pathRez = pathRezIdVer == null ? convertObjectIdToVersionedId(pathRezId, this.registration) : pathRezIdVer;
         if (this.resources.get(pathRez) != null) {
         if (this.resources.get(pathRez) != null) {
             return this.resources.get(pathRez).getLwM2mResource().getValue();
             return this.resources.get(pathRez).getLwM2mResource().getValue();
         }
         }
@@ -218,7 +201,7 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     public Object getResourceNameByRezId(String pathRezIdVer, String pathRezId) {
     public Object getResourceNameByRezId(String pathRezIdVer, String pathRezId) {
-        String pathRez = pathRezIdVer == null ? convertPathFromObjectIdToIdVer(pathRezId, this.registration) : pathRezIdVer;
+        String pathRez = pathRezIdVer == null ? convertObjectIdToVersionedId(pathRezId, this.registration) : pathRezIdVer;
         if (this.resources.get(pathRez) != null) {
         if (this.resources.get(pathRez) != null) {
             return this.resources.get(pathRez).getResourceModel().name;
             return this.resources.get(pathRez).getResourceModel().name;
         }
         }
@@ -226,7 +209,7 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     public String getRezIdByResourceNameAndObjectInstanceId(String resourceName, String pathObjectInstanceIdVer, LwM2mModelProvider modelProvider) {
     public String getRezIdByResourceNameAndObjectInstanceId(String resourceName, String pathObjectInstanceIdVer, LwM2mModelProvider modelProvider) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathObjectInstanceIdVer));
+        LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathObjectInstanceIdVer));
         if (pathIds.isObjectInstance()) {
         if (pathIds.isObjectInstance()) {
             Set<Integer> rezIds = modelProvider.getObjectModel(registration)
             Set<Integer> rezIds = modelProvider.getObjectModel(registration)
                     .getObjectModel(pathIds.getObjectId()).resources.entrySet()
                     .getObjectModel(pathIds.getObjectId()).resources.entrySet()
@@ -240,7 +223,7 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     public ResourceModel getResourceModel(String pathIdVer, LwM2mModelProvider modelProvider) {
     public ResourceModel getResourceModel(String pathIdVer, LwM2mModelProvider modelProvider) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer));
+        LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathIdVer));
         String verSupportedObject = registration.getSupportedObject().get(pathIds.getObjectId());
         String verSupportedObject = registration.getSupportedObject().get(pathIds.getObjectId());
         String verRez = getVerFromPathIdVerOrId(pathIdVer);
         String verRez = getVerFromPathIdVerOrId(pathIdVer);
         return verRez == null || verRez.equals(verSupportedObject) ? modelProvider.getObjectModel(registration)
         return verRez == null || verRez.equals(verSupportedObject) ? modelProvider.getObjectModel(registration)
@@ -248,14 +231,14 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     public ObjectModel getObjectModel(String pathIdVer, LwM2mModelProvider modelProvider) {
     public ObjectModel getObjectModel(String pathIdVer, LwM2mModelProvider modelProvider) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer));
+        LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathIdVer));
         String verSupportedObject = registration.getSupportedObject().get(pathIds.getObjectId());
         String verSupportedObject = registration.getSupportedObject().get(pathIds.getObjectId());
         String verRez = getVerFromPathIdVerOrId(pathIdVer);
         String verRez = getVerFromPathIdVerOrId(pathIdVer);
         return verRez == null || verRez.equals(verSupportedObject) ? modelProvider.getObjectModel(registration)
         return verRez == null || verRez.equals(verSupportedObject) ? modelProvider.getObjectModel(registration)
                 .getObjectModel(pathIds.getObjectId()) : null;
                 .getObjectModel(pathIds.getObjectId()) : null;
     }
     }
 
 
-    public String objectToString(LwM2mObject lwM2mObject, LwM2mValueConverterImpl converter, String pathIdVer) {
+    public String objectToString(LwM2mObject lwM2mObject, LwM2mValueConverter converter, String pathIdVer) {
         StringBuilder builder = new StringBuilder();
         StringBuilder builder = new StringBuilder();
         builder.append("LwM2mObject [id=").append(lwM2mObject.getId()).append(", instances={");
         builder.append("LwM2mObject [id=").append(lwM2mObject.getId()).append(", instances={");
         lwM2mObject.getInstances().forEach((instId, inst) -> {
         lwM2mObject.getInstances().forEach((instId, inst) -> {
@@ -269,7 +252,7 @@ public class LwM2mClient implements Cloneable {
         return builder.toString();
         return builder.toString();
     }
     }
 
 
-    public String instanceToString(LwM2mObjectInstance objectInstance, LwM2mValueConverterImpl converter, String pathIdVer) {
+    public String instanceToString(LwM2mObjectInstance objectInstance, LwM2mValueConverter converter, String pathIdVer) {
         StringBuilder builder = new StringBuilder();
         StringBuilder builder = new StringBuilder();
         builder.append("LwM2mObjectInstance [id=").append(objectInstance.getId()).append(", resources={");
         builder.append("LwM2mObjectInstance [id=").append(objectInstance.getId()).append(", resources={");
         objectInstance.getResources().forEach((resId, res) -> {
         objectInstance.getResources().forEach((resId, res) -> {
@@ -283,25 +266,18 @@ public class LwM2mClient implements Cloneable {
         return builder.toString();
         return builder.toString();
     }
     }
 
 
-    public String resourceToString(LwM2mResource lwM2mResource, LwM2mValueConverterImpl converter, String pathIdVer) {
-        if (!OPAQUE.equals(lwM2mResource.getType())) {
-            return lwM2mResource.isMultiInstances() ? ((LwM2mMultipleResource) lwM2mResource).toString() :
-                    ((LwM2mSingleResource) lwM2mResource).toString();
-        } else {
-            return String.format("LwM2mSingleResource [id=%s, value=%s, type=%s]", lwM2mResource.getId(),
-                    converter.convertValue(lwM2mResource.getValue(),
-                            OPAQUE, STRING, new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer))), lwM2mResource.getType().name());
-        }
+    public String resourceToString(LwM2mResource lwM2mResource, LwM2mValueConverter converter, String pathIdVer) {
+        return lwM2mResource.getValue().toString();
     }
     }
 
 
     public Collection<LwM2mResource> getNewResourceForInstance(String pathRezIdVer, Object params, LwM2mModelProvider modelProvider,
     public Collection<LwM2mResource> getNewResourceForInstance(String pathRezIdVer, Object params, LwM2mModelProvider modelProvider,
-                                                               LwM2mValueConverterImpl converter) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathRezIdVer));
+                                                               LwM2mValueConverter converter) {
+        LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathRezIdVer));
         Collection<LwM2mResource> resources = ConcurrentHashMap.newKeySet();
         Collection<LwM2mResource> resources = ConcurrentHashMap.newKeySet();
         Map<Integer, ResourceModel> resourceModels = modelProvider.getObjectModel(registration)
         Map<Integer, ResourceModel> resourceModels = modelProvider.getObjectModel(registration)
                 .getObjectModel(pathIds.getObjectId()).resources;
                 .getObjectModel(pathIds.getObjectId()).resources;
         resourceModels.forEach((resId, resourceModel) -> {
         resourceModels.forEach((resId, resourceModel) -> {
-            if (resId == pathIds.getResourceId()) {
+            if (resId.equals(pathIds.getResourceId())) {
                 resources.add(LwM2mSingleResource.newResource(resId, converter.convertValue(params,
                 resources.add(LwM2mSingleResource.newResource(resId, converter.convertValue(params,
                         equalsResourceTypeGetSimpleName(params), resourceModel.type, pathIds), resourceModel.type));
                         equalsResourceTypeGetSimpleName(params), resourceModel.type, pathIds), resourceModel.type));
 
 
@@ -311,14 +287,14 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     public Collection<LwM2mResource> getNewResourcesForInstance(String pathRezIdVer, Object params, LwM2mModelProvider modelProvider,
     public Collection<LwM2mResource> getNewResourcesForInstance(String pathRezIdVer, Object params, LwM2mModelProvider modelProvider,
-                                                                LwM2mValueConverterImpl converter) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathRezIdVer));
+                                                                LwM2mValueConverter converter) {
+        LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathRezIdVer));
         Collection<LwM2mResource> resources = ConcurrentHashMap.newKeySet();
         Collection<LwM2mResource> resources = ConcurrentHashMap.newKeySet();
         Map<Integer, ResourceModel> resourceModels = modelProvider.getObjectModel(registration)
         Map<Integer, ResourceModel> resourceModels = modelProvider.getObjectModel(registration)
                 .getObjectModel(pathIds.getObjectId()).resources;
                 .getObjectModel(pathIds.getObjectId()).resources;
         resourceModels.forEach((resId, resourceModel) -> {
         resourceModels.forEach((resId, resourceModel) -> {
-            if (((ConcurrentHashMap) params).containsKey(String.valueOf(resId))) {
-                Object value = ((ConcurrentHashMap) params).get((String.valueOf(resId)));
+            if (((Map) params).containsKey(String.valueOf(resId))) {
+                Object value = ((Map) params).get((String.valueOf(resId)));
                 resources.add(LwM2mSingleResource.newResource(resId,
                 resources.add(LwM2mSingleResource.newResource(resId,
                         converter.convertValue(value, equalsResourceTypeGetSimpleName(value), resourceModel.type, pathIds), resourceModel.type));
                         converter.convertValue(value, equalsResourceTypeGetSimpleName(value), resourceModel.type, pathIds), resourceModel.type));
 
 
@@ -328,7 +304,7 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     public boolean isValidObjectVersion(String path) {
     public boolean isValidObjectVersion(String path) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(path));
+        LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(path));
         String verSupportedObject = registration.getSupportedObject().get(pathIds.getObjectId());
         String verSupportedObject = registration.getSupportedObject().get(pathIds.getObjectId());
         String verRez = getVerFromPathIdVerOrId(path);
         String verRez = getVerFromPathIdVerOrId(path);
         return verRez == null ? TRANSPORT_DEFAULT_LWM2M_VERSION.equals(verSupportedObject) : verRez.equals(verSupportedObject);
         return verRez == null ? TRANSPORT_DEFAULT_LWM2M_VERSION.equals(verSupportedObject) : verRez.equals(verSupportedObject);
@@ -341,7 +317,7 @@ public class LwM2mClient implements Cloneable {
     public void deleteResources(String pathIdVer, LwM2mModelProvider modelProvider) {
     public void deleteResources(String pathIdVer, LwM2mModelProvider modelProvider) {
         Set<String> key = getKeysEqualsIdVer(pathIdVer);
         Set<String> key = getKeysEqualsIdVer(pathIdVer);
         key.forEach(pathRez -> {
         key.forEach(pathRez -> {
-            LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathRez));
+            LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathRez));
             ResourceModel resourceModel = modelProvider.getObjectModel(registration).getResourceModel(pathIds.getObjectId(), pathIds.getResourceId());
             ResourceModel resourceModel = modelProvider.getObjectModel(registration).getResourceModel(pathIds.getObjectId(), pathIds.getResourceId());
             if (resourceModel != null) {
             if (resourceModel != null) {
                 this.resources.get(pathRez).setResourceModel(resourceModel);
                 this.resources.get(pathRez).setResourceModel(resourceModel);
@@ -361,7 +337,7 @@ public class LwM2mClient implements Cloneable {
     }
     }
 
 
     private void saveResourceModel(String pathRez, LwM2mModelProvider modelProvider) {
     private void saveResourceModel(String pathRez, LwM2mModelProvider modelProvider) {
-        LwM2mPath pathIds = new LwM2mPath(convertPathFromIdVerToObjectId(pathRez));
+        LwM2mPath pathIds = new LwM2mPath(fromVersionedIdToObjectId(pathRez));
         ResourceModel resourceModel = modelProvider.getObjectModel(registration).getResourceModel(pathIds.getObjectId(), pathIds.getResourceId());
         ResourceModel resourceModel = modelProvider.getObjectModel(registration).getResourceModel(pathIds.getObjectId(), pathIds.getResourceId());
         this.resources.get(pathRez).setResourceModel(resourceModel);
         this.resources.get(pathRez).setResourceModel(resourceModel);
     }
     }
@@ -373,16 +349,6 @@ public class LwM2mClient implements Cloneable {
                 .collect(Collectors.toSet());
                 .collect(Collectors.toSet());
     }
     }
 
 
-    public void initReadValue(DefaultLwM2MTransportMsgHandler serviceImpl, String path) {
-        if (path != null) {
-            this.pendingReadRequests.remove(path);
-        }
-        if (this.pendingReadRequests.size() == 0) {
-            this.init = true;
-            serviceImpl.putDelayedUpdateResourcesThingsboard(this);
-        }
-    }
-
     public ContentFormat getDefaultContentFormat() {
     public ContentFormat getDefaultContentFormat() {
         if (registration == null) {
         if (registration == null) {
             return ContentFormat.DEFAULT;
             return ContentFormat.DEFAULT;
@@ -393,21 +359,5 @@ public class LwM2mClient implements Cloneable {
         }
         }
     }
     }
 
 
-    public LwM2mFwSwUpdate  getFwUpdate (LwM2mClientContext clientContext) {
-        if (this.fwUpdate == null) {
-            LwM2mClientProfile lwM2mClientProfile = clientContext.getProfile(this.getProfileId());
-            this.fwUpdate = new LwM2mFwSwUpdate(this, OtaPackageType.FIRMWARE, lwM2mClientProfile.getFwUpdateStrategy());
-        }
-        return this.fwUpdate;
-    }
-
-    public LwM2mFwSwUpdate  getSwUpdate (LwM2mClientContext clientContext) {
-        if (this.swUpdate == null) {
-            LwM2mClientProfile lwM2mClientProfile = clientContext.getProfile(this.getProfileId());
-            this.swUpdate = new LwM2mFwSwUpdate(this, OtaPackageType.SOFTWARE, lwM2mClientProfile.getSwUpdateStrategy());
-        }
-        return this.fwUpdate;
-    }
-
 }
 }
 
 

@@ -17,11 +17,12 @@ package org.thingsboard.server.transport.lwm2m.server.client;
 
 
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.registration.Registration;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
 import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
 
 
 import java.util.Collection;
 import java.util.Collection;
-import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.Set;
 import java.util.UUID;
 import java.util.UUID;
 
 
@@ -33,7 +34,7 @@ public interface LwM2mClientContext {
 
 
     LwM2mClient getClientBySessionInfo(TransportProtos.SessionInfoProto sessionInfo);
     LwM2mClient getClientBySessionInfo(TransportProtos.SessionInfoProto sessionInfo);
 
 
-    void register(LwM2mClient lwM2MClient, Registration registration) throws LwM2MClientStateException;
+    Optional<TransportProtos.SessionInfoProto> register(LwM2mClient lwM2MClient, Registration registration) throws LwM2MClientStateException;
 
 
     void updateRegistration(LwM2mClient client, Registration registration) throws LwM2MClientStateException;
     void updateRegistration(LwM2mClient client, Registration registration) throws LwM2MClientStateException;
 
 
@@ -41,21 +42,21 @@ public interface LwM2mClientContext {
 
 
     Collection<LwM2mClient> getLwM2mClients();
     Collection<LwM2mClient> getLwM2mClients();
 
 
-    Map<UUID, LwM2mClientProfile> getProfiles();
+    //TODO: replace UUID with DeviceProfileId
+    Lwm2mDeviceProfileTransportConfiguration getProfile(UUID profileUuId);
 
 
-    LwM2mClientProfile getProfile(UUID profileUuId);
+    Lwm2mDeviceProfileTransportConfiguration getProfile(Registration registration);
 
 
-    LwM2mClientProfile getProfile(Registration registration);
-
-    Map<UUID, LwM2mClientProfile> setProfiles(Map<UUID, LwM2mClientProfile> profiles);
-
-    LwM2mClientProfile profileUpdate(DeviceProfile deviceProfile);
+    Lwm2mDeviceProfileTransportConfiguration profileUpdate(DeviceProfile deviceProfile);
 
 
     Set<String> getSupportedIdVerInClient(LwM2mClient registration);
     Set<String> getSupportedIdVerInClient(LwM2mClient registration);
 
 
     LwM2mClient getClientByDeviceId(UUID deviceId);
     LwM2mClient getClientByDeviceId(UUID deviceId);
 
 
-    void registerClient(Registration registration, ValidateDeviceCredentialsResponse credentials);
+    String getObjectIdByKeyNameFromProfile(TransportProtos.SessionInfoProto sessionInfo, String keyName);
 
 
+    String getObjectIdByKeyNameFromProfile(LwM2mClient lwM2mClient, String keyName);
+
+    void registerClient(Registration registration, ValidateDeviceCredentialsResponse credentials);
 
 
 }
 }

@@ -17,13 +17,16 @@ package org.thingsboard.server.transport.lwm2m.server.client;
 
 
 import lombok.RequiredArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
+import org.eclipse.leshan.core.model.ResourceModel;
 import org.eclipse.leshan.core.node.LwM2mPath;
 import org.eclipse.leshan.core.node.LwM2mPath;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.registration.Registration;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
 import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
+import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MSecurityInfo;
 import org.thingsboard.server.transport.lwm2m.secure.TbLwM2MSecurityInfo;
 import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportContext;
 import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportContext;
 import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil;
 import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil;
@@ -39,7 +42,9 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Predicate;
 import java.util.function.Predicate;
 
 
 import static org.eclipse.leshan.core.SecurityMode.NO_SEC;
 import static org.eclipse.leshan.core.SecurityMode.NO_SEC;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromObjectIdToIdVer;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertObjectIdToVersionedId;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.fromVersionedIdToObjectId;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.validateObjectVerFromKey;
 
 
 @Slf4j
 @Slf4j
 @Service
 @Service
@@ -48,10 +53,11 @@ import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.c
 public class LwM2mClientContextImpl implements LwM2mClientContext {
 public class LwM2mClientContextImpl implements LwM2mClientContext {
 
 
     private final LwM2mTransportContext context;
     private final LwM2mTransportContext context;
+    private final LwM2MTransportServerConfig config;
     private final TbEditableSecurityStore securityStore;
     private final TbEditableSecurityStore securityStore;
     private final Map<String, LwM2mClient> lwM2mClientsByEndpoint = new ConcurrentHashMap<>();
     private final Map<String, LwM2mClient> lwM2mClientsByEndpoint = new ConcurrentHashMap<>();
     private final Map<String, LwM2mClient> lwM2mClientsByRegistrationId = new ConcurrentHashMap<>();
     private final Map<String, LwM2mClient> lwM2mClientsByRegistrationId = new ConcurrentHashMap<>();
-    private Map<UUID, LwM2mClientProfile> profiles = new ConcurrentHashMap<>();
+    private final Map<UUID, Lwm2mDeviceProfileTransportConfiguration> profiles = new ConcurrentHashMap<>();
 
 
     @Override
     @Override
     public LwM2mClient getClientByEndpoint(String endpoint) {
     public LwM2mClient getClientByEndpoint(String endpoint) {
@@ -59,20 +65,22 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
     }
     }
 
 
     @Override
     @Override
-    public void register(LwM2mClient lwM2MClient, Registration registration) throws LwM2MClientStateException {
+    public Optional<TransportProtos.SessionInfoProto> register(LwM2mClient lwM2MClient, Registration registration) throws LwM2MClientStateException {
+        TransportProtos.SessionInfoProto oldSession = null;
         lwM2MClient.lock();
         lwM2MClient.lock();
         try {
         try {
             if (LwM2MClientState.UNREGISTERED.equals(lwM2MClient.getState())) {
             if (LwM2MClientState.UNREGISTERED.equals(lwM2MClient.getState())) {
                 throw new LwM2MClientStateException(lwM2MClient.getState(), "Client is in invalid state.");
                 throw new LwM2MClientStateException(lwM2MClient.getState(), "Client is in invalid state.");
             }
             }
+            oldSession = lwM2MClient.getSession();
             TbLwM2MSecurityInfo securityInfo = securityStore.getTbLwM2MSecurityInfoByEndpoint(lwM2MClient.getEndpoint());
             TbLwM2MSecurityInfo securityInfo = securityStore.getTbLwM2MSecurityInfoByEndpoint(lwM2MClient.getEndpoint());
             if (securityInfo.getSecurityMode() != null) {
             if (securityInfo.getSecurityMode() != null) {
                 if (securityInfo.getDeviceProfile() != null) {
                 if (securityInfo.getDeviceProfile() != null) {
-                    UUID profileUuid = profileUpdate(securityInfo.getDeviceProfile()) != null ? securityInfo.getDeviceProfile().getUuidId() : null;
+                    profileUpdate(securityInfo.getDeviceProfile());
                     if (securityInfo.getSecurityInfo() != null) {
                     if (securityInfo.getSecurityInfo() != null) {
-                        lwM2MClient.init(securityInfo.getSecurityInfo().getIdentity(), securityInfo.getSecurityInfo(), securityInfo.getMsg(), profileUuid, UUID.randomUUID());
+                        lwM2MClient.init(securityInfo.getSecurityInfo().getIdentity(), securityInfo.getSecurityInfo(), securityInfo.getMsg(), UUID.randomUUID());
                     } else if (NO_SEC.equals(securityInfo.getSecurityMode())) {
                     } else if (NO_SEC.equals(securityInfo.getSecurityMode())) {
-                        lwM2MClient.init(null, null, securityInfo.getMsg(), profileUuid, UUID.randomUUID());
+                        lwM2MClient.init(null, null, securityInfo.getMsg(), UUID.randomUUID());
                     } else {
                     } else {
                         throw new RuntimeException(String.format("Registration failed: device %s not found.", lwM2MClient.getEndpoint()));
                         throw new RuntimeException(String.format("Registration failed: device %s not found.", lwM2MClient.getEndpoint()));
                     }
                     }
@@ -88,6 +96,7 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
         } finally {
         } finally {
             lwM2MClient.unlock();
             lwM2MClient.unlock();
         }
         }
+        return Optional.ofNullable(oldSession);
     }
     }
 
 
     @Override
     @Override
@@ -156,6 +165,28 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
         return lwM2mClient;
         return lwM2mClient;
     }
     }
 
 
+    /**
+     * Get path to resource from profile equal keyName
+     *
+     * @param sessionInfo -
+     * @param keyName     -
+     * @return -
+     */
+    @Override
+    public String getObjectIdByKeyNameFromProfile(TransportProtos.SessionInfoProto sessionInfo, String keyName) {
+        return getObjectIdByKeyNameFromProfile(getClientBySessionInfo(sessionInfo), keyName);
+    }
+
+    @Override
+    public String getObjectIdByKeyNameFromProfile(LwM2mClient lwM2mClient, String keyName) {
+        Lwm2mDeviceProfileTransportConfiguration profile = getProfile(lwM2mClient.getProfileId());
+
+        return profile.getObserveAttr().getKeyName().entrySet().stream()
+                .filter(e -> e.getValue().equals(keyName) && validateResourceInModel(lwM2mClient, e.getKey(), false)).findFirst().orElseThrow(
+                        () -> new IllegalArgumentException(keyName + " is not configured in the device profile!")
+                ).getKey();
+    }
+
     public Registration getRegistration(String registrationId) {
     public Registration getRegistration(String registrationId) {
         return this.lwM2mClientsByRegistrationId.get(registrationId).getRegistration();
         return this.lwM2mClientsByRegistrationId.get(registrationId).getRegistration();
     }
     }
@@ -163,7 +194,7 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
     @Override
     @Override
     public void registerClient(Registration registration, ValidateDeviceCredentialsResponse credentials) {
     public void registerClient(Registration registration, ValidateDeviceCredentialsResponse credentials) {
         LwM2mClient client = getClientByEndpoint(registration.getEndpoint());
         LwM2mClient client = getClientByEndpoint(registration.getEndpoint());
-        client.init(null, null, credentials, credentials.getDeviceProfile().getUuidId(), UUID.randomUUID());
+        client.init(null, null, credentials, UUID.randomUUID());
         lwM2mClientsByRegistrationId.put(registration.getId(), client);
         lwM2mClientsByRegistrationId.put(registration.getId(), client);
         profileUpdate(credentials.getDeviceProfile());
         profileUpdate(credentials.getDeviceProfile());
     }
     }
@@ -174,35 +205,20 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
     }
     }
 
 
     @Override
     @Override
-    public Map<UUID, LwM2mClientProfile> getProfiles() {
-        return profiles;
-    }
-
-    @Override
-    public LwM2mClientProfile getProfile(UUID profileId) {
+    public Lwm2mDeviceProfileTransportConfiguration getProfile(UUID profileId) {
         return profiles.get(profileId);
         return profiles.get(profileId);
     }
     }
 
 
     @Override
     @Override
-    public LwM2mClientProfile getProfile(Registration registration) {
-        return this.getProfiles().get(getClientByEndpoint(registration.getEndpoint()).getProfileId());
-    }
-
-    @Override
-    public Map<UUID, LwM2mClientProfile> setProfiles(Map<UUID, LwM2mClientProfile> profiles) {
-        return this.profiles = profiles;
+    public Lwm2mDeviceProfileTransportConfiguration getProfile(Registration registration) {
+        return profiles.get(getClientByEndpoint(registration.getEndpoint()).getProfileId());
     }
     }
 
 
     @Override
     @Override
-    public LwM2mClientProfile profileUpdate(DeviceProfile deviceProfile) {
-        LwM2mClientProfile lwM2MClientProfile = deviceProfile != null ?
-                LwM2mTransportUtil.toLwM2MClientProfile(deviceProfile) : null;
-        if (lwM2MClientProfile != null) {
-            profiles.put(deviceProfile.getUuidId(), lwM2MClientProfile);
-            return lwM2MClientProfile;
-        } else {
-            return null;
-        }
+    public Lwm2mDeviceProfileTransportConfiguration profileUpdate(DeviceProfile deviceProfile) {
+        Lwm2mDeviceProfileTransportConfiguration lwM2MClientProfile = LwM2mTransportUtil.toLwM2MClientProfile(deviceProfile);
+        profiles.put(deviceProfile.getUuidId(), lwM2MClientProfile);
+        return lwM2MClientProfile;
     }
     }
 
 
     @Override
     @Override
@@ -211,7 +227,7 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
         Arrays.stream(client.getRegistration().getObjectLinks()).forEach(link -> {
         Arrays.stream(client.getRegistration().getObjectLinks()).forEach(link -> {
             LwM2mPath pathIds = new LwM2mPath(link.getUrl());
             LwM2mPath pathIds = new LwM2mPath(link.getUrl());
             if (!pathIds.isRoot()) {
             if (!pathIds.isRoot()) {
-                clientObjects.add(convertPathFromObjectIdToIdVer(link.getUrl(), client.getRegistration()));
+                clientObjects.add(convertObjectIdToVersionedId(link.getUrl(), client.getRegistration()));
             }
             }
         });
         });
         return (clientObjects.size() > 0) ? clientObjects : null;
         return (clientObjects.size() > 0) ? clientObjects : null;
@@ -222,4 +238,14 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
         return lwM2mClientsByRegistrationId.values().stream().filter(e -> deviceId.equals(e.getDeviceId())).findFirst().orElse(null);
         return lwM2mClientsByRegistrationId.values().stream().filter(e -> deviceId.equals(e.getDeviceId())).findFirst().orElse(null);
     }
     }
 
 
+    private boolean validateResourceInModel(LwM2mClient lwM2mClient, String pathIdVer, boolean isWritableNotOptional) {
+        ResourceModel resourceModel = lwM2mClient.getResourceModel(pathIdVer, this.config
+                .getModelProvider());
+        Integer objectId = new LwM2mPath(fromVersionedIdToObjectId(pathIdVer)).getObjectId();
+        String objectVer = validateObjectVerFromKey(pathIdVer);
+        return resourceModel != null && (isWritableNotOptional ?
+                objectId != null && objectVer != null && objectVer.equals(lwM2mClient.getRegistration().getSupportedVersion(objectId)) && resourceModel.operations.isWritable() :
+                objectId != null && objectVer != null && objectVer.equals(lwM2mClient.getRegistration().getSupportedVersion(objectId)));
+    }
+
 }
 }

-/**
- * Copyright © 2016-2021 The Thingsboard Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.thingsboard.server.transport.lwm2m.server.client;
-
-import com.google.gson.Gson;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
-import lombok.Data;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MClientStrategy;
-import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy;
-import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MSoftwareUpdateStrategy;
-
-@Data
-public class LwM2mClientProfile {
-    private final String clientStrategyStr = "clientStrategy";
-    private final String fwUpdateStrategyStr = "fwUpdateStrategy";
-    private final String swUpdateStrategyStr = "swUpdateStrategy";
-
-    private TenantId tenantId;
-    /**
-     *   "clientLwM2mSettings": {
-     *     "fwUpdateStrategy": "1",
-     *     "swUpdateStrategy": "1",
-     *     "clientStrategy": "1"
-     *   }
-     **/
-    private JsonObject postClientLwM2mSettings;
-
-    /**
-     * {"keyName": {
-     *       "/3_1.0/0/1": "modelNumber",
-     *       "/3_1.0/0/0": "manufacturer",
-     *       "/3_1.0/0/2": "serialNumber"
-     *       }
-     **/
-    private JsonObject postKeyNameProfile;
-
-    /**
-     * [ "/3_1.0/0/0", "/3_1.0/0/1"]
-     */
-    private JsonArray postAttributeProfile;
-
-    /**
-     * [ "/3_1.0/0/0", "/3_1.0/0/2"]
-     */
-    private JsonArray postTelemetryProfile;
-
-    /**
-     * [ "/3_1.0/0", "/3_1.0/0/1, "/3_1.0/0/2"]
-     */
-    private JsonArray postObserveProfile;
-
-    /**
-     * "attributeLwm2m": {"/3_1.0": {"ver": "currentTimeTest11"},
-     *                    "/3_1.0/0": {"gt": 17},
-     *                    "/3_1.0/0/9": {"pmax": 45}, "/3_1.2": {ver": "3_1.2"}}
-     */
-    private JsonObject postAttributeLwm2mProfile;
-
-    public LwM2mClientProfile clone() {
-        LwM2mClientProfile lwM2mClientProfile = new LwM2mClientProfile();
-        lwM2mClientProfile.postClientLwM2mSettings = this.deepCopy(this.postClientLwM2mSettings, JsonObject.class);
-        lwM2mClientProfile.postKeyNameProfile = this.deepCopy(this.postKeyNameProfile, JsonObject.class);
-        lwM2mClientProfile.postAttributeProfile = this.deepCopy(this.postAttributeProfile, JsonArray.class);
-        lwM2mClientProfile.postTelemetryProfile = this.deepCopy(this.postTelemetryProfile, JsonArray.class);
-        lwM2mClientProfile.postObserveProfile = this.deepCopy(this.postObserveProfile, JsonArray.class);
-        lwM2mClientProfile.postAttributeLwm2mProfile = this.deepCopy(this.postAttributeLwm2mProfile, JsonObject.class);
-        return lwM2mClientProfile;
-    }
-
-
-    private <T> T deepCopy(T elements, Class<T> type) {
-        try {
-            Gson gson = new Gson();
-            return gson.fromJson(gson.toJson(elements), type);
-        } catch (Exception e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-    public int getClientStrategy() {
-        return this.postClientLwM2mSettings.getAsJsonObject().has(this.clientStrategyStr) ?
-                Integer.parseInt(this.postClientLwM2mSettings.getAsJsonObject().get(this.clientStrategyStr).getAsString()) :
-                LwM2MClientStrategy.CLIENT_STRATEGY_1.code;
-    }
-
-    public int getFwUpdateStrategy() {
-        return this.postClientLwM2mSettings.getAsJsonObject().has(this.fwUpdateStrategyStr) ?
-                Integer.parseInt(this.postClientLwM2mSettings.getAsJsonObject().get(this.fwUpdateStrategyStr).getAsString()) :
-                LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY.code;
-    }
-
-    public int getSwUpdateStrategy() {
-        return this.postClientLwM2mSettings.getAsJsonObject().has(this.swUpdateStrategyStr) ?
-                Integer.parseInt(this.postClientLwM2mSettings.getAsJsonObject().get(this.swUpdateStrategyStr).getAsString()) :
-                LwM2MSoftwareUpdateStrategy.BINARY.code;
-    }
-}