Merge pull request #3840 from thingsboard/lwm2m_tests

[3.3] Lwm2m tests

@@ -278,7 +278,6 @@ public class DeviceController extends BaseController {
         try {
         try {
             Device device = checkDeviceId(deviceCredentials.getDeviceId(), Operation.WRITE_CREDENTIALS);
             Device device = checkDeviceId(deviceCredentials.getDeviceId(), Operation.WRITE_CREDENTIALS);
             DeviceCredentials result = checkNotNull(deviceCredentialsService.updateDeviceCredentials(getCurrentUser().getTenantId(), deviceCredentials));
             DeviceCredentials result = checkNotNull(deviceCredentialsService.updateDeviceCredentials(getCurrentUser().getTenantId(), deviceCredentials));
-            //log.info("0 LwM2M CredentialsUpdate start)
             tbClusterService.pushMsgToCore(new DeviceCredentialsUpdateNotificationMsg(getCurrentUser().getTenantId(), deviceCredentials.getDeviceId(), result), null);
             tbClusterService.pushMsgToCore(new DeviceCredentialsUpdateNotificationMsg(getCurrentUser().getTenantId(), deviceCredentials.getDeviceId(), result), null);
             logEntityAction(device.getId(), device,
             logEntityAction(device.getId(), device,
                     device.getCustomerId(),
                     device.getCustomerId(),

@@ -15,17 +15,32 @@
  */
  */
 package org.thingsboard.server.controller;
 package org.thingsboard.server.controller;
 
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.thingsboard.rule.engine.api.msg.DeviceNameOrTypeUpdateMsg;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.lwm2m.LwM2mObject;
 import org.thingsboard.server.common.data.lwm2m.LwM2mObject;
 import org.thingsboard.server.common.data.lwm2m.ServerSecurityConfig;
 import org.thingsboard.server.common.data.lwm2m.ServerSecurityConfig;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
+import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.security.permission.Resource;
 
 
 import java.util.List;
 import java.util.List;
+import java.util.Map;
 
 
 @Slf4j
 @Slf4j
 @RestController
 @RestController
@@ -33,13 +48,16 @@ import java.util.List;
 @RequestMapping("/api")
 @RequestMapping("/api")
 public class DeviceLwm2mController extends BaseController {
 public class DeviceLwm2mController extends BaseController {
 
 
-
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
-    @RequestMapping(value = "/lwm2m/deviceProfile/{objectIds}", method = RequestMethod.GET)
+    @RequestMapping(value = "/lwm2m/deviceProfile",  params = {"sortOrder", "sortProperty"},  method = RequestMethod.GET)
     @ResponseBody
     @ResponseBody
-    public List<LwM2mObject> getLwm2mListObjects(@PathVariable("objectIds") int[] objectIds) throws ThingsboardException {
+    public List<LwM2mObject> getLwm2mListObjects(@RequestParam String sortOrder,
+                                                 @RequestParam String sortProperty,
+                                                 @RequestParam(required = false) int[] objectIds,
+                                                 @RequestParam(required = false) String searchText)
+                                                 throws ThingsboardException {
         try {
         try {
-            return lwM2MModelsRepository.getLwm2mObjects(objectIds, null);
+            return lwM2MModelsRepository.getLwm2mObjects(objectIds, searchText, sortProperty, sortOrder);
         } catch (Exception e) {
         } catch (Exception e) {
             throw handleException(e);
             throw handleException(e);
         }
         }
@@ -50,11 +68,11 @@ public class DeviceLwm2mController extends BaseController {
     @ResponseBody
     @ResponseBody
     public PageData<LwM2mObject> getLwm2mListObjects(@RequestParam int pageSize,
     public PageData<LwM2mObject> getLwm2mListObjects(@RequestParam int pageSize,
                                                      @RequestParam int page,
                                                      @RequestParam int page,
-                                                     @RequestParam(required = false) String textSearch,
+                                                     @RequestParam(required = false) String searchText,
                                                      @RequestParam(required = false) String sortProperty,
                                                      @RequestParam(required = false) String sortProperty,
                                                      @RequestParam(required = false) String sortOrder) throws ThingsboardException {
                                                      @RequestParam(required = false) String sortOrder) throws ThingsboardException {
         try {
         try {
-            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            PageLink pageLink = createPageLink(pageSize, page, searchText, sortProperty, sortOrder);
             return checkNotNull(lwM2MModelsRepository.findDeviceLwm2mObjects(getTenantId(), pageLink));
             return checkNotNull(lwM2MModelsRepository.findDeviceLwm2mObjects(getTenantId(), pageLink));
         } catch (Exception e) {
         } catch (Exception e) {
             throw handleException(e);
             throw handleException(e);
@@ -72,4 +90,40 @@ public class DeviceLwm2mController extends BaseController {
             throw handleException(e);
             throw handleException(e);
         }
         }
     }
     }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/lwm2m/device-credentials", method = RequestMethod.POST)
+    @ResponseBody
+    public Device saveDeviceWithCredentials(@RequestBody (required=false) Map<Class<?>, Object> deviceWithDeviceCredentials) throws ThingsboardException {
+        ObjectMapper mapper = new ObjectMapper();
+        Device device = checkNotNull(mapper.convertValue(deviceWithDeviceCredentials.get(Device.class), Device.class));
+        DeviceCredentials credentials = checkNotNull(mapper.convertValue( deviceWithDeviceCredentials.get(DeviceCredentials.class), DeviceCredentials.class));
+        try {
+            device.setTenantId(getCurrentUser().getTenantId());
+            checkEntity(device.getId(), device, Resource.DEVICE);
+            Device savedDevice = deviceService.saveDeviceWithCredentials(device, credentials);
+            checkNotNull(savedDevice);
+
+            tbClusterService.onDeviceChange(savedDevice, null);
+            tbClusterService.pushMsgToCore(new DeviceNameOrTypeUpdateMsg(savedDevice.getTenantId(),
+                    savedDevice.getId(), savedDevice.getName(), savedDevice.getType()), null);
+            tbClusterService.onEntityStateChange(savedDevice.getTenantId(), savedDevice.getId(),
+                    device.getId() == null ? ComponentLifecycleEvent.CREATED : ComponentLifecycleEvent.UPDATED);
+
+            logEntityAction(savedDevice.getId(), savedDevice,
+                    savedDevice.getCustomerId(),
+                    device.getId() == null ? ActionType.ADDED : ActionType.UPDATED, null);
+
+            if (device.getId() == null) {
+                deviceStateService.onDeviceAdded(savedDevice);
+            } else {
+                deviceStateService.onDeviceUpdated(savedDevice);
+            }
+            return savedDevice;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.DEVICE), device,
+                    null, device.getId() == null ? ActionType.ADDED : ActionType.UPDATED, e);
+            throw handleException(e);
+        }
+    }
 }
 }

@@ -23,8 +23,11 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.PageImpl;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
-import org.thingsboard.server.common.data.lwm2m.*;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.lwm2m.LwM2mInstance;
+import org.thingsboard.server.common.data.lwm2m.LwM2mObject;
+import org.thingsboard.server.common.data.lwm2m.LwM2mResource;
+import org.thingsboard.server.common.data.lwm2m.ServerSecurityConfig;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.transport.lwm2m.LwM2MTransportConfigBootstrap;
 import org.thingsboard.server.common.transport.lwm2m.LwM2MTransportConfigBootstrap;
@@ -33,17 +36,24 @@ import org.thingsboard.server.dao.service.Validator;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 
 
 import java.math.BigInteger;
 import java.math.BigInteger;
-import java.security.*;
+import java.security.AlgorithmParameters;
+import java.security.GeneralSecurityException;
+import java.security.KeyFactory;
+import java.security.KeyStoreException;
+import java.security.PublicKey;
 import java.security.cert.CertificateEncodingException;
 import java.security.cert.CertificateEncodingException;
 import java.security.cert.X509Certificate;
 import java.security.cert.X509Certificate;
 import java.security.spec.ECGenParameterSpec;
 import java.security.spec.ECGenParameterSpec;
 import java.security.spec.ECParameterSpec;
 import java.security.spec.ECParameterSpec;
-import java.security.spec.ECPublicKeySpec;
 import java.security.spec.ECPoint;
 import java.security.spec.ECPoint;
+import java.security.spec.ECPublicKeySpec;
 import java.security.spec.KeySpec;
 import java.security.spec.KeySpec;
-import java.util.List;
 import java.util.ArrayList;
 import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
 import java.util.function.Predicate;
+import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.IntStream;
 
 
@@ -70,22 +80,32 @@ public class LwM2MModelsRepository {
      * Filter by Predicate (uses objectIds, if objectIds is null then it uses textSearch,
      * Filter by Predicate (uses objectIds, if objectIds is null then it uses textSearch,
      * if textSearch is null then it uses AllList from  List<ObjectModel>)
      * if textSearch is null then it uses AllList from  List<ObjectModel>)
      */
      */
-    public List<LwM2mObject> getLwm2mObjects(int[] objectIds, String textSearch) {
-        return getLwm2mObjects((objectIds != null && objectIds.length > 0) ?
-                (ObjectModel element) -> IntStream.of(objectIds).anyMatch(x -> x == element.id) :
-                (textSearch != null && !textSearch.isEmpty()) ? (ObjectModel element) -> element.name.contains(textSearch) : null);
+    public List<LwM2mObject> getLwm2mObjects(int[] objectIds, String textSearch, String sortProperty, String sortOrder) {
+        if (objectIds == null && textSearch != null && !textSearch.isEmpty()) {
+             objectIds = getObjectIdFromTextSearch(textSearch);
+        }
+        int[] finalObjectIds = objectIds;
+        return getLwm2mObjects((objectIds != null && objectIds.length > 0  && textSearch != null && !textSearch.isEmpty()) ?
+                        (ObjectModel element) -> IntStream.of(finalObjectIds).anyMatch(x -> x == element.id) || element.name.toLowerCase().contains(textSearch.toLowerCase()) :
+                        (objectIds != null && objectIds.length > 0) ?
+                                (ObjectModel element) -> IntStream.of(finalObjectIds).anyMatch(x -> x == element.id) :
+                                (textSearch != null && !textSearch.isEmpty()) ?
+                                        (ObjectModel element) -> element.name.contains(textSearch) :
+                                        null,
+                sortProperty, sortOrder);
     }
     }
 
 
     /**
     /**
      * @param predicate
      * @param predicate
      * @return list of LwM2mObject
      * @return list of LwM2mObject
      */
      */
-    private List<LwM2mObject> getLwm2mObjects(Predicate<? super ObjectModel> predicate) {
+    private List<LwM2mObject> getLwm2mObjects(Predicate<? super ObjectModel> predicate, String sortProperty, String sortOrder) {
         List<LwM2mObject> lwM2mObjects = new ArrayList<>();
         List<LwM2mObject> lwM2mObjects = new ArrayList<>();
         List<ObjectModel> listObjects = (predicate == null) ? this.contextServer.getModelsValue() :
         List<ObjectModel> listObjects = (predicate == null) ? this.contextServer.getModelsValue() :
                 contextServer.getModelsValue().stream()
                 contextServer.getModelsValue().stream()
                         .filter(predicate)
                         .filter(predicate)
                         .collect(Collectors.toList());
                         .collect(Collectors.toList());
+
         listObjects.forEach(obj -> {
         listObjects.forEach(obj -> {
             LwM2mObject lwM2mObject = new LwM2mObject();
             LwM2mObject lwM2mObject = new LwM2mObject();
             lwM2mObject.setId(obj.id);
             lwM2mObject.setId(obj.id);
@@ -105,6 +125,29 @@ public class LwM2MModelsRepository {
             lwM2mObject.setInstances(new LwM2mInstance[]{instance});
             lwM2mObject.setInstances(new LwM2mInstance[]{instance});
             lwM2mObjects.add(lwM2mObject);
             lwM2mObjects.add(lwM2mObject);
         });
         });
+        return lwM2mObjects.size() > 1 ? this.sortList (lwM2mObjects, sortProperty, sortOrder) : lwM2mObjects;
+    }
+
+    private List<LwM2mObject> sortList (List<LwM2mObject> lwM2mObjects, String sortProperty, String sortOrder) {
+        switch (sortProperty) {
+            case "name":
+                switch (sortOrder) {
+                    case "ASC":
+                        lwM2mObjects.sort((o1, o2) -> o1.getName().compareTo(o2.getName()));
+                        break;
+                    case "DESC":
+                        lwM2mObjects.stream().sorted(Comparator.comparing(LwM2mObject::getName).reversed());
+                        break;
+                }
+            case "id":
+                switch (sortOrder) {
+                    case "ASC":
+                        lwM2mObjects.sort((o1, o2) -> Long.compare(o1.getId(), o2.getId()));
+                        break;
+                    case "DESC":
+                        lwM2mObjects.sort((o1, o2) -> Long.compare(o2.getId(), o1.getId()));
+                }
+        }
         return lwM2mObjects;
         return lwM2mObjects;
     }
     }
 
 
@@ -126,13 +169,32 @@ public class LwM2MModelsRepository {
      * PageNumber = 1, PageSize = List<LwM2mObject>.size()
      * PageNumber = 1, PageSize = List<LwM2mObject>.size()
      */
      */
     public PageData<LwM2mObject> findLwm2mListObjects(PageLink pageLink) {
     public PageData<LwM2mObject> findLwm2mListObjects(PageLink pageLink) {
-        PageImpl page = new PageImpl(getLwm2mObjects(null, pageLink.getTextSearch()));
+        PageImpl page = new PageImpl(getLwm2mObjects(getObjectIdFromTextSearch(pageLink.getTextSearch()),
+                                                                               pageLink.getTextSearch(),
+                                                                               pageLink.getSortOrder().getProperty(),
+                                                                               pageLink.getSortOrder().getDirection().name()));
         PageData pageData = new PageData(page.getContent(), page.getTotalPages(), page.getTotalElements(), page.hasNext());
         PageData pageData = new PageData(page.getContent(), page.getTotalPages(), page.getTotalElements(), page.hasNext());
         return pageData;
         return pageData;
     }
     }
 
 
     /**
     /**
-     *
+     * Filter for id Object
+     * @param textSearch -
+     * @return - return Object id only first chartAt in textSearch
+     */
+    private int[] getObjectIdFromTextSearch(String textSearch) {
+        String filtered = null;
+        if (textSearch !=null && !textSearch.isEmpty()) {
+            AtomicInteger a = new AtomicInteger();
+            filtered = textSearch.chars ()
+                    .mapToObj(chr -> (char) chr)
+                    .filter(i -> Character.isDigit(i) && textSearch.charAt(a.getAndIncrement()) == i)
+                    .collect(Collector.of(StringBuilder::new, StringBuilder::append, StringBuilder::append, StringBuilder::toString));
+        }
+        return (filtered != null && !filtered.isEmpty()) ? new int[]{Integer.parseInt(filtered)} : new int[0];
+    }
+
+    /**
      * @param securityMode
      * @param securityMode
      * @param bootstrapServerIs
      * @param bootstrapServerIs
      * @return ServerSecurityConfig more value is default: Important - port, host, publicKey
      * @return ServerSecurityConfig more value is default: Important - port, host, publicKey
@@ -143,60 +205,60 @@ public class LwM2MModelsRepository {
     }
     }
 
 
     /**
     /**
-     *
      * @param bootstrapServerIs
      * @param bootstrapServerIs
      * @param mode
      * @param mode
      * @return ServerSecurityConfig more value is default: Important - port, host, publicKey
      * @return ServerSecurityConfig more value is default: Important - port, host, publicKey
      */
      */
     private ServerSecurityConfig getBootstrapServer(boolean bootstrapServerIs, LwM2MSecurityMode mode) {
     private ServerSecurityConfig getBootstrapServer(boolean bootstrapServerIs, LwM2MSecurityMode mode) {
         ServerSecurityConfig bsServ = new ServerSecurityConfig();
         ServerSecurityConfig bsServ = new ServerSecurityConfig();
+        bsServ.setBootstrapServerIs(bootstrapServerIs);
         if (bootstrapServerIs) {
         if (bootstrapServerIs) {
+            bsServ.setServerId(contextBootStrap.getBootstrapServerId());
             switch (mode) {
             switch (mode) {
                 case NO_SEC:
                 case NO_SEC:
                     bsServ.setHost(contextBootStrap.getBootstrapHost());
                     bsServ.setHost(contextBootStrap.getBootstrapHost());
-                    bsServ.setPort(contextBootStrap.getBootstrapPort());
+                    bsServ.setPort(contextBootStrap.getBootstrapPortNoSecPsk());
                     bsServ.setServerPublicKey("");
                     bsServ.setServerPublicKey("");
                     break;
                     break;
                 case PSK:
                 case PSK:
                     bsServ.setHost(contextBootStrap.getBootstrapSecureHost());
                     bsServ.setHost(contextBootStrap.getBootstrapSecureHost());
-                    bsServ.setPort(contextBootStrap.getBootstrapSecurePort());
+                    bsServ.setPort(contextBootStrap.getBootstrapSecurePortPsk());
                     bsServ.setServerPublicKey("");
                     bsServ.setServerPublicKey("");
                     break;
                     break;
                 case RPK:
                 case RPK:
                     bsServ.setHost(contextBootStrap.getBootstrapSecureHost());
                     bsServ.setHost(contextBootStrap.getBootstrapSecureHost());
-                    bsServ.setPort(contextBootStrap.getBootstrapSecurePort());
+                    bsServ.setPort(contextBootStrap.getBootstrapSecurePortRpk());
                     bsServ.setServerPublicKey(getRPKPublicKey(this.contextBootStrap.getBootstrapPublicX(), this.contextBootStrap.getBootstrapPublicY()));
                     bsServ.setServerPublicKey(getRPKPublicKey(this.contextBootStrap.getBootstrapPublicX(), this.contextBootStrap.getBootstrapPublicY()));
                     break;
                     break;
                 case X509:
                 case X509:
                     bsServ.setHost(contextBootStrap.getBootstrapSecureHost());
                     bsServ.setHost(contextBootStrap.getBootstrapSecureHost());
-                    bsServ.setPort(contextBootStrap.getBootstrapSecurePortCert());
+                    bsServ.setPort(contextBootStrap.getBootstrapSecurePortX509());
                     bsServ.setServerPublicKey(getServerPublicKeyX509(contextBootStrap.getBootstrapAlias()));
                     bsServ.setServerPublicKey(getServerPublicKeyX509(contextBootStrap.getBootstrapAlias()));
                     break;
                     break;
                 default:
                 default:
                     break;
                     break;
             }
             }
         } else {
         } else {
-            bsServ.setBootstrapServerIs(bootstrapServerIs);
-            bsServ.setServerId(123);
+            bsServ.setServerId(contextServer.getServerId());
             switch (mode) {
             switch (mode) {
                 case NO_SEC:
                 case NO_SEC:
                     bsServ.setHost(contextServer.getServerHost());
                     bsServ.setHost(contextServer.getServerHost());
-                    bsServ.setPort(contextServer.getServerPort());
+                    bsServ.setPort(contextServer.getServerPortNoSecPsk());
                     bsServ.setServerPublicKey("");
                     bsServ.setServerPublicKey("");
                     break;
                     break;
                 case PSK:
                 case PSK:
                     bsServ.setHost(contextServer.getServerSecureHost());
                     bsServ.setHost(contextServer.getServerSecureHost());
-                    bsServ.setPort(contextServer.getServerSecurePort());
+                    bsServ.setPort(contextServer.getServerPortPsk());
                     bsServ.setServerPublicKey("");
                     bsServ.setServerPublicKey("");
                     break;
                     break;
                 case RPK:
                 case RPK:
                     bsServ.setHost(contextServer.getServerSecureHost());
                     bsServ.setHost(contextServer.getServerSecureHost());
-                    bsServ.setPort(contextServer.getServerSecurePort());
+                    bsServ.setPort(contextServer.getServerPortRpk());
                     bsServ.setServerPublicKey(getRPKPublicKey(this.contextServer.getServerPublicX(), this.contextServer.getServerPublicY()));
                     bsServ.setServerPublicKey(getRPKPublicKey(this.contextServer.getServerPublicX(), this.contextServer.getServerPublicY()));
                     break;
                     break;
                 case X509:
                 case X509:
                     bsServ.setHost(contextServer.getServerSecureHost());
                     bsServ.setHost(contextServer.getServerSecureHost());
-                    bsServ.setPort(contextServer.getServerSecurePortCert());
+                    bsServ.setPort(contextServer.getServerPortX509());
                     bsServ.setServerPublicKey(getServerPublicKeyX509(contextServer.getServerAlias()));
                     bsServ.setServerPublicKey(getServerPublicKeyX509(contextServer.getServerAlias()));
                     break;
                     break;
                 default:
                 default:
@@ -207,25 +269,23 @@ public class LwM2MModelsRepository {
     }
     }
 
 
     /**
     /**
-     *
      * @param alias
      * @param alias
      * @return PublicKey format HexString or null
      * @return PublicKey format HexString or null
      */
      */
-    private String getServerPublicKeyX509 (String alias) {
+    private String getServerPublicKeyX509(String alias) {
         try {
         try {
-            X509Certificate  serverCertificate = (X509Certificate) contextServer.getKeyStoreValue().getCertificate(alias);
-            return  Hex.encodeHexString(serverCertificate.getEncoded());
+            X509Certificate serverCertificate = (X509Certificate) contextServer.getKeyStoreValue().getCertificate(alias);
+            return Hex.encodeHexString(serverCertificate.getEncoded());
         } catch (CertificateEncodingException | KeyStoreException e) {
         } catch (CertificateEncodingException | KeyStoreException e) {
             e.printStackTrace();
             e.printStackTrace();
         }
         }
-        return  null;
+        return null;
     }
     }
 
 
     /**
     /**
-     *
      * @param publicServerX
      * @param publicServerX
      * @param publicServerY
      * @param publicServerY
-     * @return  PublicKey format HexString or null
+     * @return PublicKey format HexString or null
      */
      */
     private String getRPKPublicKey(String publicServerX, String publicServerY) {
     private String getRPKPublicKey(String publicServerX, String publicServerY) {
         try {
         try {
@@ -241,9 +301,9 @@ public class LwM2MModelsRepository {
                 KeySpec publicKeySpec = new ECPublicKeySpec(new ECPoint(new BigInteger(publicX), new BigInteger(publicY)),
                 KeySpec publicKeySpec = new ECPublicKeySpec(new ECPoint(new BigInteger(publicX), new BigInteger(publicY)),
                         parameterSpec);
                         parameterSpec);
                 /** Get keys */
                 /** Get keys */
-                PublicKey  publicKey = KeyFactory.getInstance("EC").generatePublic(publicKeySpec);
-                if (publicKey != null && publicKey.getEncoded().length > 0 ) {
-                   return Hex.encodeHexString(publicKey.getEncoded());
+                PublicKey publicKey = KeyFactory.getInstance("EC").generatePublic(publicKeySpec);
+                if (publicKey != null && publicKey.getEncoded().length > 0) {
+                    return Hex.encodeHexString(publicKey.getEncoded());
                 }
                 }
             }
             }
         } catch (GeneralSecurityException | IllegalArgumentException e) {
         } catch (GeneralSecurityException | IllegalArgumentException e) {

@@ -49,34 +49,31 @@ import org.thingsboard.server.common.transport.util.DataDecodingEncodingService;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceProvisionService;
 import org.thingsboard.server.dao.device.DeviceProvisionService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.device.DeviceService;
+import org.thingsboard.server.dao.device.provision.ProvisionFailedException;
 import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 import org.thingsboard.server.dao.device.provision.ProvisionResponse;
 import org.thingsboard.server.dao.device.provision.ProvisionResponse;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.relation.RelationService;
+import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.dao.util.mapping.JacksonUtil;
 import org.thingsboard.server.dao.util.mapping.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.gen.transport.TransportProtos.DeviceCredentialsProto;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
-import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayRequestMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceRequestMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceResponseMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceResponseMsgOrBuilder;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionResponseStatus;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionResponseStatus;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceLwM2MCredentialsRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceTokenRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceTokenRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceX509CertRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceX509CertRequestMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceLwM2MCredentialsRequestMsg;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.queue.util.TbCoreComponent;
-import org.thingsboard.server.dao.device.provision.ProvisionFailedException;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
 import org.thingsboard.server.service.executors.DbCallbackExecutorService;
 import org.thingsboard.server.service.executors.DbCallbackExecutorService;
 import org.thingsboard.server.service.profile.TbDeviceProfileCache;
 import org.thingsboard.server.service.profile.TbDeviceProfileCache;
-import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.service.queue.TbClusterService;
 import org.thingsboard.server.service.queue.TbClusterService;
 import org.thingsboard.server.service.state.DeviceStateService;
 import org.thingsboard.server.service.state.DeviceStateService;
 
 
@@ -326,6 +323,7 @@ public class DefaultTransportApiService implements TransportApiService {
                 break;
                 break;
             case MQTT_BASIC:
             case MQTT_BASIC:
             case X509_CERTIFICATE:
             case X509_CERTIFICATE:
+            case LWM2M_CREDENTIALS:
                 provisionResponse.setCredentialsValue(deviceCredentials.getCredentialsValue());
                 provisionResponse.setCredentialsValue(deviceCredentials.getCredentialsValue());
                 break;
                 break;
         }
         }

@@ -575,7 +575,13 @@ transport:
     timeout: "${LWM2M_TIMEOUT:120000}"
     timeout: "${LWM2M_TIMEOUT:120000}"
 #    model_path_file: "${LWM2M_MODEL_PATH_FILE:./common/transport/lwm2m/src/main/resources/models/}"
 #    model_path_file: "${LWM2M_MODEL_PATH_FILE:./common/transport/lwm2m/src/main/resources/models/}"
     model_path_file: "${LWM2M_MODEL_PATH_FILE:}"
     model_path_file: "${LWM2M_MODEL_PATH_FILE:}"
-    support_deprecated_ciphers_enable: "${LWM2M_SUPPORT_DEPRECATED_CIPHERS_ENABLED:true}"
+    recommended_ciphers: "${LWM2M_RECOMMENDED_CIPHERS:false}"
+    recommended_supported_groups: "${LWM2M_RECOMMENDED_SUPPORTED_GROUPS:false}"
+    request_pool_size: "${LWM2M_REQUEST_POOL_SIZE:100}"
+    request_error_pool_size: "${LWM2M_REQUEST_ERROR_POOL_SIZE:10}"
+    registered_pool_size: "${LWM2M_REGISTERED_POOL_SIZE:10}"
+    update_registered_pool_size: "${LWM2M_UPDATE_REGISTERED_POOL_SIZE:10}"
+    un_registered_pool_size: "${LWM2M_UN_REGISTERED_POOL_SIZE:10}"
     secure:
     secure:
       # Only Certificate_x509:
       # Only Certificate_x509:
       # To get helps about files format and how to generate it, see: https://github.com/eclipse/leshan/wiki/Credential-files-format
       # To get helps about files format and how to generate it, see: https://github.com/eclipse/leshan/wiki/Credential-files-format
@@ -588,24 +594,19 @@ transport:
       root_alias: "${LWM2M_SERVER_ROOT_CA:rootca}"
       root_alias: "${LWM2M_SERVER_ROOT_CA:rootca}"
       enable_gen_psk_rpk: "${ENABLE_GEN_PSK_RPK:true}"
       enable_gen_psk_rpk: "${ENABLE_GEN_PSK_RPK:true}"
     server:
     server:
+      id: "${LWM2M_SERVER_ID:123}"
       bind_address: "${LWM2M_BIND_ADDRESS:0.0.0.0}"
       bind_address: "${LWM2M_BIND_ADDRESS:0.0.0.0}"
-      bind_port: "${LWM2M_BIND_PORT:5685}"
-      bind_port_cert: "${LWM2M_BIND_PORT_CERT:5687}"
+      bind_port_no_sec_psk: "${LWM2M_BIND_PORT_NO_SEC_PSK:5685}"
+      bind_port_no_sec_rpk: "${LWM2M_BIND_PORT_NO_SEC_RPK:5687}"
+      bind_port_no_sec_x509: "${LWM2M_BIND_PORT_NO_SEC_X509:5689}"
       secure:
       secure:
-        start_all: "${START_SERVER_ALL:true}"
-        #leshan.core (V1_1)
-        #DTLS security modes:
-        #0: Pre-Shared Key mode
-        #1: Raw Public Key mode
-        #2: Certificate mode X509
-        #3: NoSec mode  *
-        #OMA-TS-LightweightM2M_Core-V1_1_1-20190617-A (add)
-        #4: Certificate mode X509 with EST
-        # If only startAll == false
-        dtls_mode: "${LWM2M_SECURITY_MODE:1}"
         bind_address: "${LWM2M_BIND_ADDRESS:0.0.0.0}"
         bind_address: "${LWM2M_BIND_ADDRESS:0.0.0.0}"
-        bind_port: "${LWM2M_BIND_PORT_SEC:5686}"
-        bind_port_cert: "${LWM2M_BIND_PORT_SEC_CERT:5688}"
+        start_psk: "${START_SERVER_PSK:true}"
+        start_rpk: "${START_SERVER_RPK:true}"
+        start_x509: "${START_SERVER_X509:true}"
+        bind_port_psk: "${LWM2M_BIND_PORT_SEC_PSK:5686}"
+        bind_port_rpk: "${LWM2M_BIND_PORT_SEC_RPK:5688}"
+        bind_port_x509: "${LWM2M_BIND_PORT_SEC_X509:5690}"
         # Only RPK: Public & Private Key
         # Only RPK: Public & Private Key
 #        create_rpk: "${CREATE_RPK:}"
 #        create_rpk: "${CREATE_RPK:}"
         public_x: "${LWM2M_SERVER_PUBLIC_X:405354ea8893471d9296afbc8b020a5c6201b0bb25812a53b849d4480fa5f069}"
         public_x: "${LWM2M_SERVER_PUBLIC_X:405354ea8893471d9296afbc8b020a5c6201b0bb25812a53b849d4480fa5f069}"
@@ -615,23 +616,26 @@ transport:
         alias: "${LWM2M_KEYSTORE_ALIAS_SERVER:server}"
         alias: "${LWM2M_KEYSTORE_ALIAS_SERVER:server}"
     bootstrap:
     bootstrap:
       enable: "${BOOTSTRAP:true}"
       enable: "${BOOTSTRAP:true}"
+      id: "${LWM2M_SERVER_ID:111}"
       bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
       bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
-      bind_port: "${LWM2M_BIND_PORT_BS:5689}"
-      bind_port_cert: "${LWM2M_BIND_PORT_SER_BS:5691}"
+      bind_port_no_sec_psk: "${LWM2M_BIND_PORT_NO_SEC_BS:5691}"
+      bind_port_no_sec_rpk: "${LWM2M_BIND_PORT_NO_SEC_BS:5693}"
+      bind_port_no_sec_x509: "${LWM2M_BIND_PORT_NO_SEC_BS:5695}"
       secure:
       secure:
-        start_all: "${START_BOOTSTRAP_ALL:true}"
-        # If only startAll == false
-        dtls_mode: "${LWM2M_SECURITY_MODE_BS:1}"
         bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
         bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
-        bind_port: "${LWM2M_BIND_PORT_SEC_BS:5690}"
-        bind_port_cert: "${LWM2M_BIND_PORT_SEC_CERT_BS:5692}"
+        start_psk: "${START_SERVER_PSK_BS:true}"
+        start_rpk: "${START_SERVER_RPK_BS:true}"
+        start_x509: "${START_SERVER_X509_BS:true}"
+        bind_port_psk: "${LWM2M_BIND_PORT_SEC_PSK_BS:5692}"
+        bind_port_rpk: "${LWM2M_BIND_PORT_SER_RPK_BS:5694}"
+        bind_port_x509: "${LWM2M_BIND_PORT_SEC_X509_BS:5696}"
         # Only RPK: Public & Private Key
         # Only RPK: Public & Private Key
         public_x: "${LWM2M_SERVER_PUBLIC_X_BS:993ef2b698c6a9c0c1d8be78b13a9383c0854c7c7c7a504d289b403794648183}"
         public_x: "${LWM2M_SERVER_PUBLIC_X_BS:993ef2b698c6a9c0c1d8be78b13a9383c0854c7c7c7a504d289b403794648183}"
         public_y: "${LWM2M_SERVER_PUBLIC_Y_BS:267412d5fc4e5ceb2257cb7fd7f76ebdac2fa9aa100afb162e990074cc0bfaa2}"
         public_y: "${LWM2M_SERVER_PUBLIC_Y_BS:267412d5fc4e5ceb2257cb7fd7f76ebdac2fa9aa100afb162e990074cc0bfaa2}"
         private_s: "${LWM2M_SERVER_PRIVATE_S_BS:9dbdbb073fc63570693a9aaf1013414e261c571f27e27fc6a8c1c2ad9347875a}"
         private_s: "${LWM2M_SERVER_PRIVATE_S_BS:9dbdbb073fc63570693a9aaf1013414e261c571f27e27fc6a8c1c2ad9347875a}"
         # Only Certificate_x509:
         # Only Certificate_x509:
         alias: "${LWM2M_KEYSTORE_ALIAS_BOOTSTRAP:bootstrap}"
         alias: "${LWM2M_KEYSTORE_ALIAS_BOOTSTRAP:bootstrap}"
-      # Redis
+    # Redis
     redis_url: "${LWM2M_REDIS_URL:''}"
     redis_url: "${LWM2M_REDIS_URL:''}"
 
 
 swagger:
 swagger:

@@ -27,6 +27,7 @@ import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 
 
 import java.util.List;
 import java.util.List;
@@ -45,6 +46,8 @@ public interface DeviceService {
 
 
     Device saveDeviceWithAccessToken(Device device, String accessToken);
     Device saveDeviceWithAccessToken(Device device, String accessToken);
 
 
+    Device saveDeviceWithCredentials(Device device, DeviceCredentials deviceCredentials);
+
     Device assignDeviceToCustomer(TenantId tenantId, DeviceId deviceId, CustomerId customerId);
     Device assignDeviceToCustomer(TenantId tenantId, DeviceId deviceId, CustomerId customerId);
 
 
     Device unassignDeviceFromCustomer(TenantId tenantId, DeviceId deviceId);
     Device unassignDeviceFromCustomer(TenantId tenantId, DeviceId deviceId);

@@ -20,7 +20,6 @@ import com.fasterxml.jackson.core.JsonProcessingException;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.thingsboard.server.common.data.device.data.DeviceData;
 import org.thingsboard.server.common.data.device.data.DeviceData;
-import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
@@ -64,6 +63,17 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
         this.setDeviceData(device.getDeviceData());
         this.setDeviceData(device.getDeviceData());
     }
     }
 
 
+    public Device updateDevice(Device device) {
+        this.tenantId = device.getTenantId();
+        this.customerId = device.getCustomerId();
+        this.name = device.getName();
+        this.type = device.getType();
+        this.label = device.getLabel();
+        this.deviceProfileId = device.getDeviceProfileId();
+        this.setDeviceData(device.getDeviceData());
+        return this;
+    }
+
     public TenantId getTenantId() {
     public TenantId getTenantId() {
         return tenantId;
         return tenantId;
     }
     }

@@ -21,6 +21,4 @@ public enum DeviceCredentialsType {
     X509_CERTIFICATE,
     X509_CERTIFICATE,
     MQTT_BASIC,
     MQTT_BASIC,
     LWM2M_CREDENTIALS
     LWM2M_CREDENTIALS
-
-
 }
 }

@@ -77,6 +77,7 @@ enum CredentialsType {
   ACCESS_TOKEN = 0;
   ACCESS_TOKEN = 0;
   X509_CERTIFICATE = 1;
   X509_CERTIFICATE = 1;
   MQTT_BASIC = 2;
   MQTT_BASIC = 2;
+  LWM2M_CREDENTIALS = 3;
 }
 }
 
 
 message KeyValueProto {
 message KeyValueProto {

@@ -65,15 +65,10 @@
             <groupId>ch.qos.logback</groupId>
             <groupId>ch.qos.logback</groupId>
             <artifactId>logback-classic</artifactId>
             <artifactId>logback-classic</artifactId>
         </dependency>
         </dependency>
-        <!--  lechan start -->
         <dependency>
         <dependency>
             <groupId>org.eclipse.leshan</groupId>
             <groupId>org.eclipse.leshan</groupId>
             <artifactId>leshan-server-cf</artifactId>
             <artifactId>leshan-server-cf</artifactId>
         </dependency>
         </dependency>
-<!--        <dependency>-->
-<!--            <groupId>org.eclipse.leshan</groupId>-->
-<!--            <artifactId>leshan-server-cf</artifactId>-->
-<!--        </dependency>   -->
         <dependency>
         <dependency>
             <groupId>org.eclipse.leshan</groupId>
             <groupId>org.eclipse.leshan</groupId>
             <artifactId>leshan-client-cf</artifactId>
             <artifactId>leshan-client-cf</artifactId>
@@ -83,12 +78,6 @@
             <groupId>org.eclipse.leshan</groupId>
             <groupId>org.eclipse.leshan</groupId>
             <artifactId>leshan-server-redis</artifactId>
             <artifactId>leshan-server-redis</artifactId>
         </dependency>
         </dependency>
-<!--        <dependency>-->
-<!--            <groupId>org.eclipse.californium</groupId>-->
-<!--            <artifactId>californium-core</artifactId>-->
-<!--        </dependency>-->
-        <!--  leshan finish -->
-
         <dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <artifactId>spring-boot-starter-test</artifactId>
@@ -107,14 +96,20 @@
         <dependency>
         <dependency>
             <groupId>org.eclipse.californium</groupId>
             <groupId>org.eclipse.californium</groupId>
             <artifactId>californium-core</artifactId>
             <artifactId>californium-core</artifactId>
-            <version>${californium.version}</version>
-            <type>test-jar</type>
+             <type>test-jar</type>
             <scope>test</scope>
             <scope>test</scope>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
             <groupId>org.eclipse.californium</groupId>
             <groupId>org.eclipse.californium</groupId>
+            <artifactId>californium-core</artifactId>
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.eclipse.californium</groupId>-->
+<!--            <artifactId>scandium</artifactId>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.eclipse.californium</groupId>
             <artifactId>element-connector</artifactId>
             <artifactId>element-connector</artifactId>
-            <version>${californium.version}</version>
             <type>test-jar</type>
             <type>test-jar</type>
             <scope>test</scope>
             <scope>test</scope>
         </dependency>
         </dependency>

@@ -18,6 +18,7 @@ package org.thingsboard.server.transport.lwm2m.bootstrap;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.californium.scandium.config.DtlsConnectorConfig;
 import org.eclipse.californium.scandium.config.DtlsConnectorConfig;
 import org.eclipse.leshan.core.model.StaticModel;
 import org.eclipse.leshan.core.model.StaticModel;
+import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.server.bootstrap.BootstrapSessionManager;
 import org.eclipse.leshan.server.bootstrap.BootstrapSessionManager;
 import org.eclipse.leshan.server.californium.bootstrap.LeshanBootstrapServer;
 import org.eclipse.leshan.server.californium.bootstrap.LeshanBootstrapServer;
 import org.eclipse.leshan.server.californium.bootstrap.LeshanBootstrapServerBuilder;
 import org.eclipse.leshan.server.californium.bootstrap.LeshanBootstrapServerBuilder;
@@ -28,18 +29,42 @@ import org.springframework.context.annotation.Primary;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2MBootstrapSecurityStore;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2MBootstrapSecurityStore;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2MInMemoryBootstrapConfigStore;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2MInMemoryBootstrapConfigStore;
-import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2MSetSecurityStoreBootstrap;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2mDefaultBootstrapSessionManager;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2mDefaultBootstrapSessionManager;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportContextServer;
 import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportContextServer;
-import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.X509;
+
+import java.math.BigInteger;
+import java.security.AlgorithmParameters;
+import java.security.GeneralSecurityException;
+import java.security.KeyFactory;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.X509Certificate;
+import java.security.interfaces.ECPublicKey;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.ECParameterSpec;
+import java.security.spec.ECPoint;
+import java.security.spec.ECPrivateKeySpec;
+import java.security.spec.ECPublicKeySpec;
+import java.security.spec.KeySpec;
+import java.util.Arrays;
+
+import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CBC_SHA256;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.NO_SEC;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.PSK;
 import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.RPK;
 import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.RPK;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.X509;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getCoapConfig;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getCoapConfig;
 
 
 @Slf4j
 @Slf4j
 @Component
 @Component
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true'&& '${transport.lwm2m.bootstrap.enable:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true'&& '${transport.lwm2m.bootstrap.enable}'=='true')")
+@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true'&& '${transport.lwm2m.bootstrap.enable:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled:false}'=='true'&& '${transport.lwm2m.bootstrap.enable:false}'=='true')")
 public class LwM2MTransportBootstrapServerConfiguration {
 public class LwM2MTransportBootstrapServerConfiguration {
+    private PublicKey publicKey;
+    private PrivateKey privateKey;
 
 
     @Autowired
     @Autowired
     private LwM2MTransportContextBootstrap contextBs;
     private LwM2MTransportContextBootstrap contextBs;
@@ -53,27 +78,35 @@ public class LwM2MTransportBootstrapServerConfiguration {
     @Autowired
     @Autowired
     private LwM2MInMemoryBootstrapConfigStore lwM2MInMemoryBootstrapConfigStore;
     private LwM2MInMemoryBootstrapConfigStore lwM2MInMemoryBootstrapConfigStore;
 
 
-
     @Primary
     @Primary
-    @Bean(name = "leshanBootstrapCert")
-    public LeshanBootstrapServer getLeshanBootstrapServerCert() {
-        log.info("Prepare and start BootstrapServerCert... PostConstruct");
-        return getLeshanBootstrapServer(this.contextBs.getCtxBootStrap().getBootstrapPortCert(), this.contextBs.getCtxBootStrap().getBootstrapSecurePortCert(), X509);
+    @Bean(name = "leshanBootstrapX509")
+    @ConditionalOnExpression("('${transport.lwm2m.bootstrap.secure.start_x509:false}'=='true')")
+    public LeshanBootstrapServer getLeshanBootstrapServerX509() {
+        log.info("Prepare and start BootstrapServerX509... PostConstruct");
+        return getLeshanBootstrapServer(this.contextBs.getCtxBootStrap().getBootstrapPortNoSecX509(), this.contextBs.getCtxBootStrap().getBootstrapSecurePortX509(), X509);
+    }
+
+    @Bean(name = "leshanBootstrapPsk")
+    @ConditionalOnExpression("('${transport.lwm2m.bootstrap.secure.start_psk:false}'=='true')")
+    public LeshanBootstrapServer getLeshanBootstrapServerPsk() {
+        log.info("Prepare and start BootstrapServerRsk... PostConstruct");
+        return getLeshanBootstrapServer(this.contextBs.getCtxBootStrap().getBootstrapPortNoSecPsk(), this.contextBs.getCtxBootStrap().getBootstrapSecurePortPsk(), PSK);
     }
     }
 
 
-    @Bean(name = "leshanBootstrapRPK")
-    public LeshanBootstrapServer getLeshanBootstrapServerRPK() {
-        log.info("Prepare and start BootstrapServerRPK... PostConstruct");
-        return getLeshanBootstrapServer(this.contextBs.getCtxBootStrap().getBootstrapPort(), this.contextBs.getCtxBootStrap().getBootstrapSecurePort(), RPK);
+    @Bean(name = "leshanBootstrapRpk")
+    @ConditionalOnExpression("('${transport.lwm2m.bootstrap.secure.start_rpk:false}'=='true')")
+    public LeshanBootstrapServer getLeshanBootstrapServerRpk() {
+        log.info("Prepare and start BootstrapServerRpk... PostConstruct");
+        return getLeshanBootstrapServer(this.contextBs.getCtxBootStrap().getBootstrapPortNoSecRpk(), this.contextBs.getCtxBootStrap().getBootstrapSecurePortRpk(), RPK);
     }
     }
 
 
-    public LeshanBootstrapServer getLeshanBootstrapServer(Integer bootstrapPort, Integer bootstrapSecurePort, LwM2MSecurityMode dtlsMode) {
+    public LeshanBootstrapServer getLeshanBootstrapServer(Integer bootstrapPortNoSec, Integer bootstrapSecurePort, LwM2MSecurityMode dtlsMode) {
         LeshanBootstrapServerBuilder builder = new LeshanBootstrapServerBuilder();
         LeshanBootstrapServerBuilder builder = new LeshanBootstrapServerBuilder();
-        builder.setLocalAddress(this.contextBs.getCtxBootStrap().getBootstrapHost(), bootstrapPort);
+        builder.setLocalAddress(this.contextBs.getCtxBootStrap().getBootstrapHost(), bootstrapPortNoSec);
         builder.setLocalSecureAddress(this.contextBs.getCtxBootStrap().getBootstrapSecureHost(), bootstrapSecurePort);
         builder.setLocalSecureAddress(this.contextBs.getCtxBootStrap().getBootstrapSecureHost(), bootstrapSecurePort);
 
 
         /** Create CoAP Config */
         /** Create CoAP Config */
-        builder.setCoapConfig(getCoapConfig ());
+        builder.setCoapConfig(getCoapConfig (bootstrapPortNoSec, bootstrapSecurePort));
 
 
         /**  ConfigStore */
         /**  ConfigStore */
         builder.setConfigStore(lwM2MInMemoryBootstrapConfigStore);
         builder.setConfigStore(lwM2MInMemoryBootstrapConfigStore);
@@ -84,13 +117,22 @@ public class LwM2MTransportBootstrapServerConfiguration {
         /** Define model provider (Create Models )*/
         /** Define model provider (Create Models )*/
         builder.setModel(new StaticModel(contextS.getCtxServer().getModelsValue()));
         builder.setModel(new StaticModel(contextS.getCtxServer().getModelsValue()));
 
 
+        /**  Create credentials */
+        LwM2MSetSecurityStoreBootstrap(builder, dtlsMode);
+
         /** Create and Set DTLS Config */
         /** Create and Set DTLS Config */
         DtlsConnectorConfig.Builder dtlsConfig = new DtlsConnectorConfig.Builder();
         DtlsConnectorConfig.Builder dtlsConfig = new DtlsConnectorConfig.Builder();
-        dtlsConfig.setRecommendedCipherSuitesOnly(contextS.getCtxServer().isSupportDeprecatedCiphersEnable());
+        if (dtlsMode==PSK) {
+            dtlsConfig.setRecommendedCipherSuitesOnly(this.contextS.getCtxServer().isRecommendedCiphers());
+            dtlsConfig.setRecommendedSupportedGroupsOnly(this.contextS.getCtxServer().isRecommendedSupportedGroups());
+            dtlsConfig.setSupportedCipherSuites(TLS_PSK_WITH_AES_128_CBC_SHA256);
+        }
+        else  {
+            dtlsConfig.setRecommendedCipherSuitesOnly(this.contextS.getCtxServer().isRecommendedCiphers());
+//            dtlsConfig.setRecommendedSupportedGroupsOnly(false);
+        }
         builder.setDtlsConfig(dtlsConfig);
         builder.setDtlsConfig(dtlsConfig);
 
 
-        /**  Create credentials */
-        new LwM2MSetSecurityStoreBootstrap(builder, contextBs, contextS, dtlsMode);
 
 
         BootstrapSessionManager sessionManager = new LwM2mDefaultBootstrapSessionManager(lwM2MBootstrapSecurityStore);
         BootstrapSessionManager sessionManager = new LwM2mDefaultBootstrapSessionManager(lwM2MBootstrapSecurityStore);
         builder.setSessionManager(sessionManager);
         builder.setSessionManager(sessionManager);
@@ -98,4 +140,151 @@ public class LwM2MTransportBootstrapServerConfiguration {
         /** Create BootstrapServer */
         /** Create BootstrapServer */
         return builder.build();
         return builder.build();
     }
     }
+
+    public void LwM2MSetSecurityStoreBootstrap(LeshanBootstrapServerBuilder builder, LwM2MSecurityMode dtlsMode) {
+
+        /** Set securityStore with new registrationStore */
+
+        switch (dtlsMode) {
+            /** Use No_Sec only */
+            case NO_SEC:
+                setServerWithX509Cert(builder, NO_SEC.code);
+                break;
+            /** Use PSK/RPK  */
+            case PSK:
+                break;
+            case RPK:
+                setRPK(builder);
+                break;
+            case X509:
+                setServerWithX509Cert(builder, X509.code);
+                break;
+            /** Use X509_EST only */
+            case X509_EST:
+                // TODO support sentinel pool and make pool configurable
+                break;
+            /** Use ather X509, PSK,  No_Sec ?? */
+            default:
+                break;
+        }
+    }
+
+    private void setRPK(LeshanBootstrapServerBuilder builder) {
+        try {
+            /** Get Elliptic Curve Parameter spec for secp256r1 */
+            AlgorithmParameters algoParameters = AlgorithmParameters.getInstance("EC");
+            algoParameters.init(new ECGenParameterSpec("secp256r1"));
+            ECParameterSpec parameterSpec = algoParameters.getParameterSpec(ECParameterSpec.class);
+            if (this.contextBs.getCtxBootStrap().getBootstrapPublicX() != null && !this.contextBs.getCtxBootStrap().getBootstrapPublicX().isEmpty() && this.contextBs.getCtxBootStrap().getBootstrapPublicY() != null && !this.contextBs.getCtxBootStrap().getBootstrapPublicY().isEmpty()) {
+                /** Get point values */
+                byte[] publicX = Hex.decodeHex(this.contextBs.getCtxBootStrap().getBootstrapPublicX().toCharArray());
+                byte[] publicY = Hex.decodeHex(this.contextBs.getCtxBootStrap().getBootstrapPublicY().toCharArray());
+                /** Create key specs */
+                KeySpec publicKeySpec = new ECPublicKeySpec(new ECPoint(new BigInteger(publicX), new BigInteger(publicY)),
+                        parameterSpec);
+                /** Get keys */
+                this.publicKey = KeyFactory.getInstance("EC").generatePublic(publicKeySpec);
+            }
+            if (this.contextBs.getCtxBootStrap().getBootstrapPrivateS() != null && !this.contextBs.getCtxBootStrap().getBootstrapPrivateS().isEmpty()) {
+                /** Get point values */
+                byte[] privateS = Hex.decodeHex(this.contextBs.getCtxBootStrap().getBootstrapPrivateS().toCharArray());
+                /** Create key specs */
+                KeySpec privateKeySpec = new ECPrivateKeySpec(new BigInteger(privateS), parameterSpec);
+                /** Get keys */
+                this.privateKey = KeyFactory.getInstance("EC").generatePrivate(privateKeySpec);
+            }
+            if (this.publicKey != null && this.publicKey.getEncoded().length > 0 &&
+                    this.privateKey != null && this.privateKey.getEncoded().length > 0) {
+                builder.setPublicKey(this.publicKey);
+                builder.setPrivateKey(this.privateKey);
+                this.contextBs.getCtxBootStrap().setBootstrapPublicKey(this.publicKey);
+                getParamsRPK();
+            }
+        } catch (GeneralSecurityException | IllegalArgumentException e) {
+            log.error("[{}] Failed generate Server PSK/RPK", e.getMessage());
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void setServerWithX509Cert(LeshanBootstrapServerBuilder builder, int securityModeCode) {
+        try {
+            if (this.contextS.getCtxServer().getKeyStoreValue() != null) {
+                KeyStore keyStoreServer = this.contextS.getCtxServer().getKeyStoreValue();
+                setBuilderX509(builder);
+                X509Certificate rootCAX509Cert = (X509Certificate) keyStoreServer.getCertificate(this.contextS.getCtxServer().getRootAlias());
+                if (rootCAX509Cert != null && securityModeCode == X509.code) {
+                    X509Certificate[] trustedCertificates = new X509Certificate[1];
+                    trustedCertificates[0] = rootCAX509Cert;
+                    builder.setTrustedCertificates(trustedCertificates);
+                } else {
+                    /** by default trust all */
+                    builder.setTrustedCertificates(new X509Certificate[0]);
+                }
+            }
+            else {
+                /** by default trust all */
+                builder.setTrustedCertificates(new X509Certificate[0]);
+                log.error("Unable to load X509 files for BootStrapServer");
+            }
+        } catch (KeyStoreException ex) {
+            log.error("[{}] Unable to load X509 files server", ex.getMessage());
+        }
+
+    }
+
+    private void setBuilderX509(LeshanBootstrapServerBuilder builder) {
+        /**
+         * For deb => KeyStorePathFile == yml or commandline: KEY_STORE_PATH_FILE
+         * For idea => KeyStorePathResource == common/transport/lwm2m/src/main/resources/credentials: in LwM2MTransportContextServer: credentials/serverKeyStore.jks
+         */
+        try {
+            X509Certificate serverCertificate = (X509Certificate) this.contextS.getCtxServer().getKeyStoreValue().getCertificate(this.contextBs.getCtxBootStrap().getBootstrapAlias());
+            this.privateKey = (PrivateKey) this.contextS.getCtxServer().getKeyStoreValue().getKey(this.contextBs.getCtxBootStrap().getBootstrapAlias(), this.contextS.getCtxServer().getKeyStorePasswordServer() == null ? null : this.contextS.getCtxServer().getKeyStorePasswordServer().toCharArray());
+            if (this.privateKey != null && this.privateKey.getEncoded().length > 0) {
+                builder.setPrivateKey(this.privateKey);
+            }
+            if (serverCertificate != null) {
+                builder.setCertificateChain(new X509Certificate[]{serverCertificate});
+                this.infoParamsX509(serverCertificate);
+            }
+        } catch (Exception ex) {
+            log.error("[{}] Unable to load KeyStore  files server", ex.getMessage());
+        }
+    }
+
+    private void getParamsRPK() {
+        if (this.publicKey instanceof ECPublicKey) {
+            /** Get x coordinate */
+            byte[] x = ((ECPublicKey) this.publicKey).getW().getAffineX().toByteArray();
+            if (x[0] == 0)
+                x = Arrays.copyOfRange(x, 1, x.length);
+
+            /** Get Y coordinate */
+            byte[] y = ((ECPublicKey) this.publicKey).getW().getAffineY().toByteArray();
+            if (y[0] == 0)
+                y = Arrays.copyOfRange(y, 1, y.length);
+
+            /** Get Curves params */
+            String params = ((ECPublicKey) this.publicKey).getParams().toString();
+            log.info(
+                    " \nBootstrap uses RPK : \n Elliptic Curve parameters  : [{}] \n Public x coord : [{}] \n Public y coord : [{}] \n Public Key (Hex): [{}] \n Private Key (Hex): [{}]",
+                    params, Hex.encodeHexString(x), Hex.encodeHexString(y),
+                    Hex.encodeHexString(this.publicKey.getEncoded()),
+                    Hex.encodeHexString(this.privateKey.getEncoded()));
+        } else {
+            throw new IllegalStateException("Unsupported Public Key Format (only ECPublicKey supported).");
+        }
+    }
+
+    private void infoParamsX509(X509Certificate certificate) {
+        try {
+            log.info("BootStrap uses X509 : \n X509 Certificate (Hex): [{}] \n Private Key (Hex): [{}]",
+                    Hex.encodeHexString(certificate.getEncoded()),
+                    Hex.encodeHexString(this.privateKey.getEncoded()));
+        } catch (CertificateEncodingException e) {
+            log.error("", e);
+        }
+    }
+
+
 }
 }

@@ -14,57 +14,56 @@
  * limitations under the License.
  * limitations under the License.
  */
  */
 package org.thingsboard.server.transport.lwm2m.bootstrap;
 package org.thingsboard.server.transport.lwm2m.bootstrap;
+
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.leshan.server.californium.bootstrap.LeshanBootstrapServer;
 import org.eclipse.leshan.server.californium.bootstrap.LeshanBootstrapServer;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Qualifier;
 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.server.transport.lwm2m.secure.LwM2MSecurityMode;
 
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.annotation.PreDestroy;
 
 
 @Slf4j
 @Slf4j
 @Service
 @Service
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled}'=='true'&& '${transport.lwm2m.bootstrap.enable}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true'&& '${transport.lwm2m.bootstrap.enable}'=='true')")
+@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true'&& '${transport.lwm2m.bootstrap.enable:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled:false}'=='true'&& '${transport.lwm2m.bootstrap.enable:false}'=='true')")
 public class LwM2MTransportBootstrapServerInitializer {
 public class LwM2MTransportBootstrapServerInitializer {
 
 
-    @Autowired
-    @Qualifier("leshanBootstrapCert")
+    @Autowired(required = false)
+    @Qualifier("leshanBootstrapX509")
     private LeshanBootstrapServer lhBServerCert;
     private LeshanBootstrapServer lhBServerCert;
 
 
-    @Autowired
-    @Qualifier("leshanBootstrapRPK")
-    private LeshanBootstrapServer lhBServerRPK;
+    @Autowired(required = false)
+    @Qualifier("leshanBootstrapPsk")
+    private LeshanBootstrapServer lhBServerPsk;
+
+    @Autowired(required = false)
+    @Qualifier("leshanBootstrapRpk")
+    private LeshanBootstrapServer lhBServerRpk;
 
 
     @Autowired
     @Autowired
     private LwM2MTransportContextBootstrap contextBS;
     private LwM2MTransportContextBootstrap contextBS;
 
 
     @PostConstruct
     @PostConstruct
     public void init() {
     public void init() {
-        if (this.contextBS.getCtxBootStrap().isBootstrapStartAll()) {
-            this.lhBServerCert.start();
-            this.lhBServerRPK.start();
+        if (this.contextBS.getCtxBootStrap().getBootstrapStartPsk()) {
+            this.lhBServerPsk.start();
+        }
+        if (this.contextBS.getCtxBootStrap().getBootstrapStartRpk()) {
+            this.lhBServerRpk.start();
         }
         }
-        else {
-            if (this.contextBS.getCtxBootStrap().getBootStrapDtlsMode() == LwM2MSecurityMode.X509.code) {
-                this.lhBServerCert.start();
-            }
-            else {
-                this.lhBServerRPK.start();
-            }
+        if (this.contextBS.getCtxBootStrap().getBootstrapStartX509()) {
+            this.lhBServerCert.start();
         }
         }
     }
     }
 
 
     @PreDestroy
     @PreDestroy
     public void shutdown() throws InterruptedException {
     public void shutdown() throws InterruptedException {
         log.info("Stopping LwM2M transport Bootstrap Server!");
         log.info("Stopping LwM2M transport Bootstrap Server!");
-        try {
-            lhBServerCert.destroy();
-            lhBServerRPK.destroy();
-        } finally {
-        }
+        lhBServerPsk.destroy();
+        lhBServerRpk.destroy();
+        lhBServerCert.destroy();
         log.info("LwM2M transport Bootstrap Server stopped!");
         log.info("LwM2M transport Bootstrap Server stopped!");
     }
     }
 }
 }

@@ -29,28 +29,41 @@ import org.eclipse.leshan.server.security.BootstrapSecurityStore;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
-import org.springframework.stereotype.Component;
-import org.thingsboard.server.transport.lwm2m.secure.LwM2MGetSecurityInfo;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
+import org.thingsboard.server.transport.lwm2m.secure.LwM2mCredentialsSecurityInfoValidator;
 import org.thingsboard.server.transport.lwm2m.secure.ReadResultSecurityStore;
 import org.thingsboard.server.transport.lwm2m.secure.ReadResultSecurityStore;
+import org.thingsboard.server.transport.lwm2m.server.LwM2MSessionMsgListener;
+import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportContextServer;
+import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler;
 import org.thingsboard.server.transport.lwm2m.utils.TypeServer;
 import org.thingsboard.server.transport.lwm2m.utils.TypeServer;
 
 
 import java.io.IOException;
 import java.io.IOException;
 import java.security.GeneralSecurityException;
 import java.security.GeneralSecurityException;
 import java.util.Arrays;
 import java.util.Arrays;
 import java.util.List;
 import java.util.List;
+import java.util.UUID;
 
 
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.*;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.BOOTSTRAP_SERVER;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LWM2M_SERVER;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.SERVERS;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getBootstrapParametersFromThingsboard;
 
 
 @Slf4j
 @Slf4j
-@Component("LwM2MBootstrapSecurityStore")
+@Service("LwM2MBootstrapSecurityStore")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' && '${transport.lwm2m.bootstrap.enable:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true' && '${transport.lwm2m.bootstrap.enable}'=='true')")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' && '${transport.lwm2m.bootstrap.enable:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true' && '${transport.lwm2m.bootstrap.enable}'=='true')")
 public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
 public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
 
 
     private final EditableBootstrapConfigStore bootstrapConfigStore;
     private final EditableBootstrapConfigStore bootstrapConfigStore;
 
 
     @Autowired
     @Autowired
-    LwM2MGetSecurityInfo lwM2MGetSecurityInfo;
+    LwM2mCredentialsSecurityInfoValidator lwM2MCredentialsSecurityInfoValidator;
+
+    @Autowired
+    public LwM2MTransportContextServer context;
 
 
     public LwM2MBootstrapSecurityStore(EditableBootstrapConfigStore bootstrapConfigStore) {
     public LwM2MBootstrapSecurityStore(EditableBootstrapConfigStore bootstrapConfigStore) {
         this.bootstrapConfigStore = bootstrapConfigStore;
         this.bootstrapConfigStore = bootstrapConfigStore;
@@ -59,8 +72,8 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
     @Override
     @Override
     public List<SecurityInfo> getAllByEndpoint(String endPoint) {
     public List<SecurityInfo> getAllByEndpoint(String endPoint) {
         String endPointKey = endPoint;
         String endPointKey = endPoint;
-        ReadResultSecurityStore store = lwM2MGetSecurityInfo.getSecurityInfo(endPointKey, TypeServer.BOOTSTRAP);
-        if (store.getBootstrapJsonCredential() != null) {
+        ReadResultSecurityStore store = lwM2MCredentialsSecurityInfoValidator.createAndValidateCredentialsSecurityInfo(endPointKey, TypeServer.BOOTSTRAP);
+        if (store.getBootstrapJsonCredential() != null && store.getSecurityMode() < LwM2MSecurityMode.DEFAULT_MODE.code) {
             /** add value to store  from BootstrapJson */
             /** add value to store  from BootstrapJson */
             this.setBootstrapConfigScurityInfo(store);
             this.setBootstrapConfigScurityInfo(store);
             BootstrapConfig bsConfigNew = store.getBootstrapConfig();
             BootstrapConfig bsConfigNew = store.getBootstrapConfig();
@@ -73,7 +86,7 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
                     }
                     }
                     bootstrapConfigStore.add(endPoint, bsConfigNew);
                     bootstrapConfigStore.add(endPoint, bsConfigNew);
                 } catch (InvalidConfigurationException e) {
                 } catch (InvalidConfigurationException e) {
-                    e.printStackTrace();
+                    log.error("", e);
                 }
                 }
                 return store.getSecurityInfo() == null ? null : Arrays.asList(store.getSecurityInfo());
                 return store.getSecurityInfo() == null ? null : Arrays.asList(store.getSecurityInfo());
             }
             }
@@ -83,17 +96,16 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
 
 
     @Override
     @Override
     public SecurityInfo getByIdentity(String identity) {
     public SecurityInfo getByIdentity(String identity) {
-        ReadResultSecurityStore store = lwM2MGetSecurityInfo.getSecurityInfo(identity, TypeServer.BOOTSTRAP);
-        /** add value to store  from BootstrapJson */
-        this.setBootstrapConfigScurityInfo(store);
-
-        if (store.getSecurityMode() < LwM2MSecurityMode.DEFAULT_MODE.code) {
+        ReadResultSecurityStore store = lwM2MCredentialsSecurityInfoValidator.createAndValidateCredentialsSecurityInfo(identity, TypeServer.BOOTSTRAP);
+        if (store.getBootstrapJsonCredential() != null && store.getSecurityMode() < LwM2MSecurityMode.DEFAULT_MODE.code) {
+            /** add value to store  from BootstrapJson */
+            this.setBootstrapConfigScurityInfo(store);
             BootstrapConfig bsConfig = store.getBootstrapConfig();
             BootstrapConfig bsConfig = store.getBootstrapConfig();
             if (bsConfig.security != null) {
             if (bsConfig.security != null) {
                 try {
                 try {
                     bootstrapConfigStore.add(store.getEndPoint(), bsConfig);
                     bootstrapConfigStore.add(store.getEndPoint(), bsConfig);
                 } catch (InvalidConfigurationException e) {
                 } catch (InvalidConfigurationException e) {
-                    e.printStackTrace();
+                    log.error("", e);
                 }
                 }
                 return store.getSecurityInfo();
                 return store.getSecurityInfo();
             }
             }
@@ -141,28 +153,36 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
     private LwM2MBootstrapConfig getParametersBootstrap(ReadResultSecurityStore store) {
     private LwM2MBootstrapConfig getParametersBootstrap(ReadResultSecurityStore store) {
         try {
         try {
             JsonObject bootstrapJsonCredential = store.getBootstrapJsonCredential();
             JsonObject bootstrapJsonCredential = store.getBootstrapJsonCredential();
-            ObjectMapper mapper = new ObjectMapper();
-            LwM2MBootstrapConfig lwM2MBootstrapConfig = mapper.readValue(bootstrapJsonCredential.toString(), LwM2MBootstrapConfig.class);
-            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);
-            if (getValidatedSecurityMode(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap, lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer)) {
-                lwM2MBootstrapConfig.bootstrapServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap);
-                lwM2MBootstrapConfig.lwm2mServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer);
-                return lwM2MBootstrapConfig;
-            }
-            else {
-                log.error(" [{}] Different values SecurityMode between of client and profile.", store.getEndPoint());
-                log.error(LOG_LW2M_ERROR + " getParametersBootstrap: [{}] Different values SecurityMode between of client and profile.", store.getEndPoint());
-                String logMsg = String.format(LOG_LW2M_ERROR + " getParametersBootstrap: %s Different values SecurityMode between of client and profile.", store.getEndPoint());
-//                sentLogsToThingsboard(logMsg, store.getEndPoint());
-                return null;
+            if (bootstrapJsonCredential != null) {
+                ObjectMapper mapper = new ObjectMapper();
+                LwM2MBootstrapConfig lwM2MBootstrapConfig = mapper.readValue(bootstrapJsonCredential.toString(), LwM2MBootstrapConfig.class);
+                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 = context.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(LOG_LW2M_INFO + ": getParametersBootstrap: %s Access connect client with bootstrap server.", store.getEndPoint());
+                    context.sentParametersOnThingsboard(context.getTelemetryMsgObject(logMsg), LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC, sessionInfo);
+                    return lwM2MBootstrapConfig;
+                } else {
+                    log.error(" [{}] Different values SecurityMode between of client and profile.", store.getEndPoint());
+                    log.error(LOG_LW2M_ERROR + " getParametersBootstrap: [{}] Different values SecurityMode between of client and profile.", store.getEndPoint());
+                    String logMsg = String.format(LOG_LW2M_ERROR + ": getParametersBootstrap: %s Different values SecurityMode between of client and profile.", store.getEndPoint());
+                    context.sentParametersOnThingsboard(context.getTelemetryMsgObject(logMsg), LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC, sessionInfo);
+                    return null;
+                }
             }
             }
         } catch (JsonProcessingException e) {
         } catch (JsonProcessingException e) {
             log.error("Unable to decode Json or Certificate for [{}]  [{}]", store.getEndPoint(), e.getMessage());
             log.error("Unable to decode Json or Certificate for [{}]  [{}]", store.getEndPoint(), e.getMessage());
             return null;
             return null;
         }
         }
+        log.error("Unable to decode Json or Certificate for [{}]", store.getEndPoint());
+        return null;
     }
     }
 
 
     /**
     /**
@@ -175,7 +195,7 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
      * @return false if not sync between SecurityMode of Bootstrap credential and profile
      * @return false if not sync between SecurityMode of Bootstrap credential and profile
      */
      */
     private boolean getValidatedSecurityMode(LwM2MServerBootstrap bootstrapFromCredential, LwM2MServerBootstrap profileServerBootstrap, LwM2MServerBootstrap lwm2mFromCredential, LwM2MServerBootstrap profileLwm2mServer) {
     private boolean getValidatedSecurityMode(LwM2MServerBootstrap bootstrapFromCredential, LwM2MServerBootstrap profileServerBootstrap, LwM2MServerBootstrap lwm2mFromCredential, LwM2MServerBootstrap profileLwm2mServer) {
-        return  (bootstrapFromCredential.getSecurityMode().equals(profileServerBootstrap.getSecurityMode()) &&
+        return (bootstrapFromCredential.getSecurityMode().equals(profileServerBootstrap.getSecurityMode()) &&
                 lwm2mFromCredential.getSecurityMode().equals(profileLwm2mServer.getSecurityMode()));
                 lwm2mFromCredential.getSecurityMode().equals(profileLwm2mServer.getSecurityMode()));
     }
     }
 }
 }

-/**
- * Copyright © 2016-2020 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.bootstrap.secure;
-
-import lombok.Data;
-import lombok.extern.slf4j.Slf4j;
-import org.eclipse.leshan.core.util.Hex;
-import org.eclipse.leshan.server.californium.bootstrap.LeshanBootstrapServerBuilder;
-import org.eclipse.leshan.server.security.EditableSecurityStore;
-import org.thingsboard.server.transport.lwm2m.bootstrap.LwM2MTransportContextBootstrap;
-import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportContextServer;
-
-import java.math.BigInteger;
-import java.security.AlgorithmParameters;
-import java.security.KeyStore;
-import java.security.PublicKey;
-import java.security.PrivateKey;
-import java.security.KeyFactory;
-import java.security.GeneralSecurityException;
-import java.security.KeyStoreException;
-import java.security.cert.X509Certificate;
-import java.security.interfaces.ECPublicKey;
-import java.security.spec.ECGenParameterSpec;
-import java.security.spec.ECParameterSpec;
-import java.security.spec.ECPublicKeySpec;
-import java.security.spec.ECPoint;
-import java.security.spec.KeySpec;
-import java.security.spec.ECPrivateKeySpec;
-import java.util.Arrays;
-
-import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.NO_SEC;
-import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.X509;
-
-@Slf4j
-@Data
-public class LwM2MSetSecurityStoreBootstrap {
-
-    private KeyStore keyStore;
-    private PublicKey publicKey;
-    private PrivateKey privateKey;
-    private LwM2MTransportContextBootstrap contextBs;
-    private LwM2MTransportContextServer contextS;
-    private LeshanBootstrapServerBuilder builder;
-    EditableSecurityStore securityStore;
-
-    public LwM2MSetSecurityStoreBootstrap(LeshanBootstrapServerBuilder builder, LwM2MTransportContextBootstrap contextBs, LwM2MTransportContextServer contextS, LwM2MSecurityMode dtlsMode) {
-        this.builder = builder;
-        this.contextBs = contextBs;
-        this.contextS = contextS;
-        /** Set securityStore with new registrationStore */
-
-        switch (dtlsMode) {
-            /** Use No_Sec only */
-            case NO_SEC:
-                setServerWithX509Cert(NO_SEC.code);
-                break;
-            /** Use PSK/RPK  */
-            case PSK:
-            case RPK:
-                setRPK();
-                break;
-            case X509:
-                setServerWithX509Cert(X509.code);
-                break;
-            /** Use X509_EST only */
-            case X509_EST:
-                // TODO support sentinel pool and make pool configurable
-                break;
-            /** Use ather X509, PSK,  No_Sec ?? */
-            default:
-                break;
-        }
-    }
-
-    private void setRPK() {
-        try {
-            /** Get Elliptic Curve Parameter spec for secp256r1 */
-            AlgorithmParameters algoParameters = AlgorithmParameters.getInstance("EC");
-            algoParameters.init(new ECGenParameterSpec("secp256r1"));
-            ECParameterSpec parameterSpec = algoParameters.getParameterSpec(ECParameterSpec.class);
-            if (this.contextBs.getCtxBootStrap().getBootstrapPublicX() != null && !this.contextBs.getCtxBootStrap().getBootstrapPublicX().isEmpty() && this.contextBs.getCtxBootStrap().getBootstrapPublicY() != null && !this.contextBs.getCtxBootStrap().getBootstrapPublicY().isEmpty()) {
-                /** Get point values */
-                byte[] publicX = Hex.decodeHex(this.contextBs.getCtxBootStrap().getBootstrapPublicX().toCharArray());
-                byte[] publicY = Hex.decodeHex(this.contextBs.getCtxBootStrap().getBootstrapPublicY().toCharArray());
-                /** Create key specs */
-                KeySpec publicKeySpec = new ECPublicKeySpec(new ECPoint(new BigInteger(publicX), new BigInteger(publicY)),
-                        parameterSpec);
-                /** Get keys */
-                this.publicKey = KeyFactory.getInstance("EC").generatePublic(publicKeySpec);
-            }
-            if (this.contextBs.getCtxBootStrap().getBootstrapPrivateS() != null && !this.contextBs.getCtxBootStrap().getBootstrapPrivateS().isEmpty()) {
-                /** Get point values */
-                byte[] privateS = Hex.decodeHex(this.contextBs.getCtxBootStrap().getBootstrapPrivateS().toCharArray());
-                /** Create key specs */
-                KeySpec privateKeySpec = new ECPrivateKeySpec(new BigInteger(privateS), parameterSpec);
-                /** Get keys */
-                this.privateKey = KeyFactory.getInstance("EC").generatePrivate(privateKeySpec);
-            }
-            if (this.publicKey != null && this.publicKey.getEncoded().length > 0 &&
-                    this.privateKey != null && this.privateKey.getEncoded().length > 0) {
-                this.builder.setPublicKey(this.publicKey);
-                this.builder.setPrivateKey(this.privateKey);
-                this.contextBs.getCtxBootStrap().setBootstrapPublicKey(this.publicKey);
-                getParamsRPK();
-            }
-        } catch (GeneralSecurityException | IllegalArgumentException e) {
-            log.error("[{}] Failed generate Server PSK/RPK", e.getMessage());
-            throw new RuntimeException(e);
-        }
-    }
-
-    private void setServerWithX509Cert(int securityModeCode) {
-        try {
-            if (this.contextS.getCtxServer().getKeyStoreValue() != null) {
-                KeyStore keyStoreServer = this.contextS.getCtxServer().getKeyStoreValue();
-                setBuilderX509();
-                X509Certificate rootCAX509Cert = (X509Certificate) keyStoreServer.getCertificate(this.contextS.getCtxServer().getRootAlias());
-                if (rootCAX509Cert != null && securityModeCode == X509.code) {
-                    X509Certificate[] trustedCertificates = new X509Certificate[1];
-                    trustedCertificates[0] = rootCAX509Cert;
-                    this.builder.setTrustedCertificates(trustedCertificates);
-                } else {
-                    /** by default trust all */
-                    this.builder.setTrustedCertificates(new X509Certificate[0]);
-                }
-            }
-            else {
-                /** by default trust all */
-                this.builder.setTrustedCertificates(new X509Certificate[0]);
-                log.error("Unable to load X509 files for BootStrapServer");
-            }
-        } catch (KeyStoreException ex) {
-            log.error("[{}] Unable to load X509 files server", ex.getMessage());
-        }
-
-    }
-
-    private void setBuilderX509() {
-        /**
-         * For deb => KeyStorePathFile == yml or commandline: KEY_STORE_PATH_FILE
-         * For idea => KeyStorePathResource == common/transport/lwm2m/src/main/resources/credentials: in LwM2MTransportContextServer: credentials/serverKeyStore.jks
-         */
-        try {
-            X509Certificate serverCertificate = (X509Certificate) this.contextS.getCtxServer().getKeyStoreValue().getCertificate(this.contextBs.getCtxBootStrap().getBootstrapAlias());
-            this.privateKey = (PrivateKey) this.contextS.getCtxServer().getKeyStoreValue().getKey(this.contextBs.getCtxBootStrap().getBootstrapAlias(), this.contextS.getCtxServer().getKeyStorePasswordServer() == null ? null : this.contextS.getCtxServer().getKeyStorePasswordServer().toCharArray());
-            if (this.privateKey != null && this.privateKey.getEncoded().length > 0) {
-                this.builder.setPrivateKey(this.privateKey);
-            }
-            if (serverCertificate != null) {
-                this.builder.setCertificateChain(new X509Certificate[]{serverCertificate});
-                this.contextBs.getCtxBootStrap().setBootstrapCertificate(serverCertificate);
-            }
-        } catch (Exception ex) {
-            log.error("[{}] Unable to load KeyStore  files server", ex.getMessage());
-        }
-    }
-
-    private void getParamsRPK() {
-        if (this.publicKey instanceof ECPublicKey) {
-            /** Get x coordinate */
-            byte[] x = ((ECPublicKey) this.publicKey).getW().getAffineX().toByteArray();
-            if (x[0] == 0)
-                x = Arrays.copyOfRange(x, 1, x.length);
-
-            /** Get Y coordinate */
-            byte[] y = ((ECPublicKey) this.publicKey).getW().getAffineY().toByteArray();
-            if (y[0] == 0)
-                y = Arrays.copyOfRange(y, 1, y.length);
-
-            /** Get Curves params */
-            String params = ((ECPublicKey) this.publicKey).getParams().toString();
-            log.info(
-                    " \nBootstrap uses RPK : \n Elliptic Curve parameters  : [{}] \n Public x coord : [{}] \n Public y coord : [{}] \n Public Key (Hex): [{}] \n Private Key (Hex): [{}]",
-                    params, Hex.encodeHexString(x), Hex.encodeHexString(y),
-                    Hex.encodeHexString(this.publicKey.getEncoded()),
-                    Hex.encodeHexString(this.privateKey.getEncoded()));
-        } else {
-            throw new IllegalStateException("Unsupported Public Key Format (only ECPublicKey supported).");
-        }
-    }
-
-//    private void getParamsX509() {
-//        try {
-//            log.info("BootStrap uses X509 : \n X509 Certificate (Hex): [{}] \n Private Key (Hex): [{}]",
-//                    Hex.encodeHexString(this.certificate.getEncoded()),
-//                    Hex.encodeHexString(this.privateKey.getEncoded()));
-//        } catch (CertificateEncodingException e) {
-//            e.printStackTrace();
-//        }
-//    }
-}

@@ -49,7 +49,6 @@ public class LwM2mDefaultBootstrapSessionManager extends DefaultBootstrapSession
         this.securityChecker = securityChecker;
         this.securityChecker = securityChecker;
     }
     }
 
 
-    @Override
     public BootstrapSession begin(String endpoint, Identity clientIdentity) {
     public BootstrapSession begin(String endpoint, Identity clientIdentity) {
         boolean authorized;
         boolean authorized;
         if (bsSecurityStore != null) {
         if (bsSecurityStore != null) {

@@ -73,15 +73,15 @@ public class LWM2MGenerationPSkRPkECC {
         try {
         try {
             kpg = KeyPairGenerator.getInstance(algorithm, provider);
             kpg = KeyPairGenerator.getInstance(algorithm, provider);
         } catch (NoSuchAlgorithmException e) {
         } catch (NoSuchAlgorithmException e) {
-            e.printStackTrace();
+            log.error("", e);
         } catch (NoSuchProviderException e) {
         } catch (NoSuchProviderException e) {
-            e.printStackTrace();
+            log.error("", e);
         }
         }
         ECGenParameterSpec ecsp = new ECGenParameterSpec(nameParameterSpec);
         ECGenParameterSpec ecsp = new ECGenParameterSpec(nameParameterSpec);
         try {
         try {
             kpg.initialize(ecsp);
             kpg.initialize(ecsp);
         } catch (InvalidAlgorithmParameterException e) {
         } catch (InvalidAlgorithmParameterException e) {
-            e.printStackTrace();
+            log.error("", e);
         }
         }
 
 
         KeyPair kp = kpg.genKeyPair();
         KeyPair kp = kpg.genKeyPair();

@@ -39,12 +39,15 @@ import java.util.Optional;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeUnit;
 
 
-import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.*;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.NO_SEC;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.PSK;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.RPK;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.X509;
 
 
 @Slf4j
 @Slf4j
 @Component("LwM2MGetSecurityInfo")
 @Component("LwM2MGetSecurityInfo")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MGetSecurityInfo {
+public class LwM2mCredentialsSecurityInfoValidator {
 
 
     @Autowired
     @Autowired
     public LwM2MTransportContextServer contextS;
     public LwM2MTransportContextServer contextS;
@@ -53,7 +56,13 @@ public class LwM2MGetSecurityInfo {
     public LwM2MTransportContextBootstrap contextBS;
     public LwM2MTransportContextBootstrap contextBS;
 
 
 
 
-    public ReadResultSecurityStore getSecurityInfo(String endPoint, TypeServer keyValue) {
+    /**
+     * Request to thingsboard Response from thingsboard ValidateDeviceLwM2MCredentials
+     * @param endPoint -
+     * @param keyValue -
+     * @return ValidateDeviceCredentialsResponseMsg and SecurityInfo
+     */
+    public ReadResultSecurityStore createAndValidateCredentialsSecurityInfo(String endPoint, TypeServer keyValue) {
         CountDownLatch latch = new CountDownLatch(1);
         CountDownLatch latch = new CountDownLatch(1);
         final ReadResultSecurityStore[] resultSecurityStore = new ReadResultSecurityStore[1];
         final ReadResultSecurityStore[] resultSecurityStore = new ReadResultSecurityStore[1];
         contextS.getTransportService().process(ValidateDeviceLwM2MCredentialsRequestMsg.newBuilder().setCredentialsId(endPoint).build(),
         contextS.getTransportService().process(ValidateDeviceLwM2MCredentialsRequestMsg.newBuilder().setCredentialsId(endPoint).build(),
@@ -61,7 +70,7 @@ public class LwM2MGetSecurityInfo {
                     @Override
                     @Override
                     public void onSuccess(ValidateDeviceCredentialsResponseMsg msg) {
                     public void onSuccess(ValidateDeviceCredentialsResponseMsg msg) {
                         String credentialsBody = msg.getCredentialsBody();
                         String credentialsBody = msg.getCredentialsBody();
-                        resultSecurityStore[0] = putSecurityInfo(endPoint, msg.getDeviceInfo().getDeviceName(), credentialsBody, keyValue);
+                        resultSecurityStore[0] = createSecurityInfo(endPoint, credentialsBody, keyValue);
                         resultSecurityStore[0].setMsg(msg);
                         resultSecurityStore[0].setMsg(msg);
                         Optional<DeviceProfile> deviceProfileOpt = LwM2MTransportHandler.decode(msg.getProfileBody().toByteArray());
                         Optional<DeviceProfile> deviceProfileOpt = LwM2MTransportHandler.decode(msg.getProfileBody().toByteArray());
                         deviceProfileOpt.ifPresent(profile -> resultSecurityStore[0].setDeviceProfile(profile));
                         deviceProfileOpt.ifPresent(profile -> resultSecurityStore[0].setDeviceProfile(profile));
@@ -70,20 +79,27 @@ public class LwM2MGetSecurityInfo {
 
 
                     @Override
                     @Override
                     public void onError(Throwable e) {
                     public void onError(Throwable e) {
-                        log.trace("[{}] Failed to process credentials PSK: {}", endPoint, e);
-                        resultSecurityStore[0] = putSecurityInfo(endPoint, null, null, null);
+                        log.trace("[{}] [{}] Failed to process credentials ", endPoint, e);
+                        resultSecurityStore[0] = createSecurityInfo(endPoint, null, null);
                         latch.countDown();
                         latch.countDown();
                     }
                     }
                 });
                 });
         try {
         try {
             latch.await(contextS.getCtxServer().getTimeout(), TimeUnit.MILLISECONDS);
             latch.await(contextS.getCtxServer().getTimeout(), TimeUnit.MILLISECONDS);
         } catch (InterruptedException e) {
         } catch (InterruptedException e) {
-            e.printStackTrace();
+            log.error("Failed to await credentials!", e);
         }
         }
         return resultSecurityStore[0];
         return resultSecurityStore[0];
     }
     }
 
 
-    private ReadResultSecurityStore putSecurityInfo(String endPoint, String deviceName, String jsonStr, TypeServer keyValue) {
+    /**
+     * Create new SecurityInfo
+     * @param endPoint -
+     * @param jsonStr -
+     * @param keyValue -
+     * @return SecurityInfo
+     */
+    private ReadResultSecurityStore createSecurityInfo(String endPoint, String jsonStr, TypeServer keyValue) {
         ReadResultSecurityStore result = new ReadResultSecurityStore();
         ReadResultSecurityStore result = new ReadResultSecurityStore();
         JsonObject objectMsg = LwM2MTransportHandler.validateJson(jsonStr);
         JsonObject objectMsg = LwM2MTransportHandler.validateJson(jsonStr);
         if (objectMsg != null && !objectMsg.isJsonNull()) {
         if (objectMsg != null && !objectMsg.isJsonNull()) {
@@ -99,20 +115,21 @@ public class LwM2MGetSecurityInfo {
                 if (keyValue.equals(TypeServer.BOOTSTRAP)) {
                 if (keyValue.equals(TypeServer.BOOTSTRAP)) {
                     result.setBootstrapJsonCredential(object);
                     result.setBootstrapJsonCredential(object);
                     result.setEndPoint(endPoint);
                     result.setEndPoint(endPoint);
+                    result.setSecurityMode(LwM2MSecurityMode.fromSecurityMode(object.get("bootstrapServer").getAsJsonObject().get("securityMode").getAsString().toLowerCase()).code);
                 } else {
                 } else {
                     LwM2MSecurityMode lwM2MSecurityMode = LwM2MSecurityMode.fromSecurityMode(object.get("securityConfigClientMode").getAsString().toLowerCase());
                     LwM2MSecurityMode lwM2MSecurityMode = LwM2MSecurityMode.fromSecurityMode(object.get("securityConfigClientMode").getAsString().toLowerCase());
                     switch (lwM2MSecurityMode) {
                     switch (lwM2MSecurityMode) {
                         case NO_SEC:
                         case NO_SEC:
-                            getClientSecurityInfoNoSec(result);
+                            createClientSecurityInfoNoSec(result);
                             break;
                             break;
                         case PSK:
                         case PSK:
-                            getClientSecurityInfoPSK(result, endPoint, object);
+                            createClientSecurityInfoPSK(result, endPoint, object);
                             break;
                             break;
                         case RPK:
                         case RPK:
-                            getClientSecurityInfoRPK(result, endPoint, object);
+                            createClientSecurityInfoRPK(result, endPoint, object);
                             break;
                             break;
                         case X509:
                         case X509:
-                            getClientSecurityInfoX509(result, endPoint);
+                            createClientSecurityInfoX509(result, endPoint);
                             break;
                             break;
                         default:
                         default:
                             break;
                             break;
@@ -123,12 +140,12 @@ public class LwM2MGetSecurityInfo {
         return result;
         return result;
     }
     }
 
 
-    private void getClientSecurityInfoNoSec(ReadResultSecurityStore result) {
+    private void createClientSecurityInfoNoSec(ReadResultSecurityStore result) {
         result.setSecurityInfo(null);
         result.setSecurityInfo(null);
         result.setSecurityMode(NO_SEC.code);
         result.setSecurityMode(NO_SEC.code);
     }
     }
 
 
-    private void getClientSecurityInfoPSK(ReadResultSecurityStore result, String endPoint, JsonObject object) {
+    private void createClientSecurityInfoPSK(ReadResultSecurityStore result, String endPoint, JsonObject object) {
         /** PSK Deserialization */
         /** PSK Deserialization */
         String identity = (object.has("identity") && object.get("identity").isJsonPrimitive()) ? object.get("identity").getAsString() : null;
         String identity = (object.has("identity") && object.get("identity").isJsonPrimitive()) ? object.get("identity").getAsString() : null;
         if (identity != null && !identity.isEmpty()) {
         if (identity != null && !identity.isEmpty()) {
@@ -148,7 +165,7 @@ public class LwM2MGetSecurityInfo {
         }
         }
     }
     }
 
 
-    private void getClientSecurityInfoRPK(ReadResultSecurityStore result, String endpoint, JsonObject object) {
+    private void createClientSecurityInfoRPK(ReadResultSecurityStore result, String endpoint, JsonObject object) {
         try {
         try {
             if (object.has("key") && object.get("key").isJsonPrimitive()) {
             if (object.has("key") && object.get("key").isJsonPrimitive()) {
                 byte[] rpkkey = Hex.decodeHex(object.get("key").getAsString().toLowerCase().toCharArray());
                 byte[] rpkkey = Hex.decodeHex(object.get("key").getAsString().toLowerCase().toCharArray());
@@ -163,7 +180,7 @@ public class LwM2MGetSecurityInfo {
         }
         }
     }
     }
 
 
-    private void getClientSecurityInfoX509(ReadResultSecurityStore result, String endpoint) {
+    private void createClientSecurityInfoX509(ReadResultSecurityStore result, String endpoint) {
         result.setSecurityInfo(SecurityInfo.newX509CertInfo(endpoint));
         result.setSecurityInfo(SecurityInfo.newX509CertInfo(endpoint));
         result.setSecurityMode(X509.code);
         result.setSecurityMode(X509.code);
     }
     }

@@ -33,17 +33,17 @@ import java.util.Optional;
 
 
 @Slf4j
 @Slf4j
 public class LwM2MSessionMsgListener implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
 public class LwM2MSessionMsgListener implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
-    private LwM2MTransportService service;
+    private LwM2MTransportServiceImpl service;
     private TransportProtos.SessionInfoProto sessionInfo;
     private TransportProtos.SessionInfoProto sessionInfo;
 
 
-    LwM2MSessionMsgListener(LwM2MTransportService service, TransportProtos.SessionInfoProto sessionInfo) {
+    public LwM2MSessionMsgListener(LwM2MTransportServiceImpl service, TransportProtos.SessionInfoProto sessionInfo) {
         this.service = service;
         this.service = service;
         this.sessionInfo = sessionInfo;
         this.sessionInfo = sessionInfo;
     }
     }
 
 
     @Override
     @Override
     public void onGetAttributesResponse(GetAttributeResponseMsg getAttributesResponse) {
     public void onGetAttributesResponse(GetAttributeResponseMsg getAttributesResponse) {
-        log.info("[{}] attributesResponse", getAttributesResponse);
+        this.service.onGetAttributesResponse(getAttributesResponse, this.sessionInfo);
     }
     }
 
 
     @Override
     @Override

@@ -30,15 +30,26 @@ package org.thingsboard.server.transport.lwm2m.server;
  * limitations under the License.
  * limitations under the License.
  */
  */
 
 
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.transport.TransportContext;
 import org.thingsboard.server.common.transport.TransportContext;
+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.lwm2m.LwM2MTransportConfigServer;
 import org.thingsboard.server.common.transport.lwm2m.LwM2MTransportConfigServer;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.transport.lwm2m.server.adaptors.LwM2MJsonAdaptor;
+import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
 
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PostConstruct;
 
 
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_TELEMETRY;
+
 @Slf4j
 @Slf4j
 @Component
 @Component
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
@@ -47,14 +58,87 @@ public class LwM2MTransportContextServer extends TransportContext {
     private LwM2MTransportConfigServer ctxServer;
     private LwM2MTransportConfigServer ctxServer;
 
 
     @Autowired
     @Autowired
-    LwM2MTransportConfigServer lwM2MTransportConfigServer;
+    protected LwM2MTransportConfigServer lwM2MTransportConfigServer;
+
+    @Autowired
+    private TransportService transportService;
+
+    @Getter
+    @Autowired
+    private LwM2MJsonAdaptor adaptor;
+
+    @Autowired
+    LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
 
 
     @PostConstruct
     @PostConstruct
     public void init() {
     public void init() {
         this.ctxServer = lwM2MTransportConfigServer;
         this.ctxServer = lwM2MTransportConfigServer;
     }
     }
 
 
-    public LwM2MTransportConfigServer getCtxServer () {
+    public LwM2MTransportConfigServer getCtxServer() {
         return this.ctxServer;
         return this.ctxServer;
     }
     }
+
+    /**
+     * Sent to Thingsboard Attribute || Telemetry
+     *
+     * @param msg   - JsonObject: [{name: value}]
+     * @return - dummy
+     */
+    private <T> TransportServiceCallback<Void> getPubAckCallbackSentAttrTelemetry(final T msg) {
+        return new TransportServiceCallback<Void>() {
+            @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 sentParametersOnThingsboard(JsonElement msg, String topicName, TransportProtos.SessionInfoProto sessionInfo) {
+        try {
+            if (topicName.equals(LwM2MTransportHandler.DEVICE_ATTRIBUTES_TOPIC)) {
+                TransportProtos.PostAttributeMsg postAttributeMsg = adaptor.convertToPostAttributes(msg);
+                TransportServiceCallback call = this.getPubAckCallbackSentAttrTelemetry(postAttributeMsg);
+                transportService.process(sessionInfo, postAttributeMsg, this.getPubAckCallbackSentAttrTelemetry(call));
+            } else if (topicName.equals(LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC)) {
+                TransportProtos.PostTelemetryMsg postTelemetryMsg = adaptor.convertToPostTelemetry(msg);
+                TransportServiceCallback call = this.getPubAckCallbackSentAttrTelemetry(postTelemetryMsg);
+                transportService.process(sessionInfo, postTelemetryMsg, this.getPubAckCallbackSentAttrTelemetry(call));
+            }
+        } catch (AdaptorException e) {
+            log.error("[{}] Failed to process publish msg [{}]", topicName, e);
+            log.info("[{}] Closing current session due to invalid publish", topicName);
+        }
+    }
+
+    public JsonObject getTelemetryMsgObject(String logMsg) {
+        JsonObject telemetries = new JsonObject();
+        telemetries.addProperty(LOG_LW2M_TELEMETRY, logMsg);
+        return telemetries;
+    }
+
+    /**
+     * @return - sessionInfo after access connect client
+     */
+    public TransportProtos.SessionInfoProto getValidateSessionInfo(TransportProtos.ValidateDeviceCredentialsResponseMsg msg, long mostSignificantBits, long leastSignificantBits) {
+        return TransportProtos.SessionInfoProto.newBuilder()
+                .setNodeId(this.getNodeId())
+                .setSessionIdMSB(mostSignificantBits)
+                .setSessionIdLSB(leastSignificantBits)
+                .setDeviceIdMSB(msg.getDeviceInfo().getDeviceIdMSB())
+                .setDeviceIdLSB(msg.getDeviceInfo().getDeviceIdLSB())
+                .setTenantIdMSB(msg.getDeviceInfo().getTenantIdMSB())
+                .setTenantIdLSB(msg.getDeviceInfo().getTenantIdLSB())
+                .setDeviceName(msg.getDeviceInfo().getDeviceName())
+                .setDeviceType(msg.getDeviceInfo().getDeviceType())
+                .setDeviceProfileIdLSB(msg.getDeviceInfo().getDeviceProfileIdLSB())
+                .setDeviceProfileIdMSB(msg.getDeviceInfo().getDeviceProfileIdMSB())
+                .build();
+    }
+
 }
 }

@@ -16,7 +16,6 @@
 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.gson.Gson;
 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;
@@ -24,57 +23,60 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.eclipse.californium.core.network.config.NetworkConfig;
 import org.eclipse.californium.core.network.config.NetworkConfig;
 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.LwM2mNode;
 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.LwM2mSingleResource;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
-import org.eclipse.leshan.core.node.LwM2mMultipleResource;
+import org.eclipse.leshan.core.node.codec.CodecException;
 import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.core.util.Hex;
-import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.californium.LeshanServerBuilder;
 import org.eclipse.leshan.server.californium.LeshanServerBuilder;
 import org.nustaq.serialization.FSTConfiguration;
 import org.nustaq.serialization.FSTConfiguration;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
-import org.springframework.stereotype.Component;
 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.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.transport.lwm2m.server.client.AttrTelemetryObserveValue;
 import org.thingsboard.server.transport.lwm2m.server.client.AttrTelemetryObserveValue;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
 
 
-import javax.annotation.PostConstruct;
 import java.io.File;
 import java.io.File;
 import java.io.IOException;
 import java.io.IOException;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.Optional;
-import java.util.Map;
 import java.util.Arrays;
 import java.util.Arrays;
-import java.util.List;
-import java.util.ArrayList;
+import java.util.Date;
 import java.util.LinkedList;
 import java.util.LinkedList;
-import java.util.Collections;
+import java.util.Optional;
 
 
 @Slf4j
 @Slf4j
-@Component("LwM2MTransportHandler")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' )|| ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportHandler{
+//@Component("LwM2MTransportHandler")
+//@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' )|| ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
+public class LwM2MTransportHandler {
 
 
     // We choose a default timeout a bit higher to the MAX_TRANSMIT_WAIT(62-93s) which is the time from starting to
     // We choose a default timeout a bit higher to the MAX_TRANSMIT_WAIT(62-93s) which is the time from starting to
     // send a Confirmable message to the time when an acknowledgement is no longer expected.
     // send a Confirmable message to the time when an acknowledgement is no longer expected.
-    public static final long DEFAULT_TIMEOUT = 2 * 60 * 1000l; // 2min in ms
-    public static final String OBSERVE_ATTRIBUTE_TELEMETRY = "observeAttr";
-    public static final String KEYNAME = "keyName";
+
+    public static final String BASE_DEVICE_API_TOPIC = "v1/devices/me";
     public static final String ATTRIBUTE = "attribute";
     public static final String ATTRIBUTE = "attribute";
     public static final String TELEMETRY = "telemetry";
     public static final String TELEMETRY = "telemetry";
+    private static final String REQUEST = "/request";
+    private static final String RESPONSE = "/response";
+    private static final String ATTRIBUTES = "/" + ATTRIBUTE;
+    public static final String TELEMETRIES = "/" + TELEMETRY;
+    public static final String ATTRIBUTES_RESPONSE = ATTRIBUTES + RESPONSE;
+    public static final String ATTRIBUTES_REQUEST = ATTRIBUTES + REQUEST;
+    public static final String DEVICE_ATTRIBUTES_RESPONSE = ATTRIBUTES_RESPONSE + "/";
+    public static final String DEVICE_ATTRIBUTES_REQUEST = ATTRIBUTES_REQUEST + "/";
+    public static final String DEVICE_ATTRIBUTES_TOPIC = BASE_DEVICE_API_TOPIC + ATTRIBUTES;
+    public static final String DEVICE_TELEMETRY_TOPIC = BASE_DEVICE_API_TOPIC + TELEMETRIES;
+
+    public static final long DEFAULT_TIMEOUT = 2 * 60 * 1000L; // 2min in ms
+    public static final String OBSERVE_ATTRIBUTE_TELEMETRY = "observeAttr";
+    public static final String KEYNAME = "keyName";
     public static final String OBSERVE = "observe";
     public static final String OBSERVE = "observe";
     public static final String BOOTSTRAP = "bootstrap";
     public static final String BOOTSTRAP = "bootstrap";
     public static final String SERVERS = "servers";
     public static final String SERVERS = "servers";
     public static final String LWM2M_SERVER = "lwm2mServer";
     public static final String LWM2M_SERVER = "lwm2mServer";
     public static final String BOOTSTRAP_SERVER = "bootstrapServer";
     public static final String BOOTSTRAP_SERVER = "bootstrapServer";
-    public static final String BASE_DEVICE_API_TOPIC = "v1/devices/me";
-    public static final String DEVICE_ATTRIBUTES_TOPIC = BASE_DEVICE_API_TOPIC + "/attributes";
-    public static final String DEVICE_TELEMETRY_TOPIC = BASE_DEVICE_API_TOPIC + "/telemetry";
+
     public static final String LOG_LW2M_TELEMETRY = "logLwm2m";
     public static final String LOG_LW2M_TELEMETRY = "logLwm2m";
     public static final String LOG_LW2M_INFO = "info";
     public static final String LOG_LW2M_INFO = "info";
     public static final String LOG_LW2M_ERROR = "error";
     public static final String LOG_LW2M_ERROR = "error";
@@ -91,44 +93,55 @@ public class LwM2MTransportHandler{
     /**
     /**
      * Replaces the Object Instance or the Resource(s) with the new value provided in the “Write” operation. (see
      * 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).
      * section 5.3.3 of the LW M2M spec).
+     * if all resources are to be replaced
      */
      */
     public static final String POST_TYPE_OPER_WRITE_REPLACE = "replace";
     public static final String POST_TYPE_OPER_WRITE_REPLACE = "replace";
     /**
     /**
      * Adds or updates Resources provided in the new value and leaves other existing Resources unchanged. (see section
      * 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).
      * 5.3.3 of the LW M2M spec).
+     * if this is a partial update request
      */
      */
     public static final String PUT_TYPE_OPER_WRITE_UPDATE = "update";
     public static final String PUT_TYPE_OPER_WRITE_UPDATE = "update";
     public static final String PUT_TYPE_OPER_WRITE_ATTRIBUTES = "wright-attributes";
     public static final String PUT_TYPE_OPER_WRITE_ATTRIBUTES = "wright-attributes";
 
 
     public static final String EVENT_AWAKE = "AWAKE";
     public static final String EVENT_AWAKE = "AWAKE";
+    public static final String SERVICE_CHANNEL = "SERVICE";
+    public static final String RESPONSE_CHANNEL = "RESP";
 
 
-    private static Gson gson = null;
+//    @Autowired
+//    @Qualifier("LeshanServerCert")
+//    private LeshanServer lhServerCert;
+//
+//    @Autowired
+//    @Qualifier("LeshanServerNoSecPskRpk")
+//    private LeshanServer lhServerNoSecPskRpk;
 
 
-    @Autowired
-    @Qualifier("LeshanServerCert")
-    private LeshanServer lhServerCert;
+//    @Autowired
+//    @Qualifier("ServerListenerCert")
+//    private LwM2mServerListener serverListenerCert;
+//
+//    @Autowired
+//    @Qualifier("ServerListenerNoSecPskRpk")
+//    private LwM2mServerListener serverListenerNoSecPskRpk;
 
 
-    @Autowired
-    @Qualifier("leshanServerNoSecPskRpk")
-    private LeshanServer lhServerNoSecPskRpk;
 
 
-    @Autowired
-    private LwM2MTransportService service;
+//    @PostConstruct
+//    public void init() {
+//        try {
+//            serverListenerCert.init(lhServerCert);
+//            this.lhServerCert.getRegistrationService().addListener(serverListenerCert.registrationListener);
+//            this.lhServerCert.getPresenceService().addListener(serverListenerCert.presenceListener);
+//            this.lhServerCert.getObservationService().addListener(serverListenerCert.observationListener);
+//            serverListenerNoSecPskRpk.init(lhServerNoSecPskRpk);
+//            this.lhServerNoSecPskRpk.getRegistrationService().addListener(serverListenerNoSecPskRpk.registrationListener);
+//            this.lhServerNoSecPskRpk.getPresenceService().addListener(serverListenerNoSecPskRpk.presenceListener);
+//            this.lhServerNoSecPskRpk.getObservationService().addListener(serverListenerNoSecPskRpk.observationListener);
+//        } catch (Exception e) {
+//            log.error("init [{}]", e.toString());
+//        }
+//    }
 
 
-
-    @PostConstruct
-    public void init() {
-        LwM2mServerListener lwM2mServerListener = new LwM2mServerListener(lhServerCert, service);
-        this.lhServerCert.getRegistrationService().addListener(lwM2mServerListener.registrationListener);
-        this.lhServerCert.getPresenceService().addListener(lwM2mServerListener.presenceListener);
-        this.lhServerCert.getObservationService().addListener(lwM2mServerListener.observationListener);
-        lwM2mServerListener = new LwM2mServerListener(lhServerNoSecPskRpk, service);
-        this.lhServerNoSecPskRpk.getRegistrationService().addListener(lwM2mServerListener.registrationListener);
-        this.lhServerNoSecPskRpk.getPresenceService().addListener(lwM2mServerListener.presenceListener);
-        this.lhServerNoSecPskRpk.getObservationService().addListener(lwM2mServerListener.observationListener);
-    }
-
-    public static NetworkConfig getCoapConfig() {
+    public static NetworkConfig getCoapConfig(Integer serverPortNoSec, Integer serverSecurePort) {
         NetworkConfig coapConfig;
         NetworkConfig coapConfig;
         File configFile = new File(NetworkConfig.DEFAULT_FILE_NAME);
         File configFile = new File(NetworkConfig.DEFAULT_FILE_NAME);
         if (configFile.isFile()) {
         if (configFile.isFile()) {
@@ -138,28 +151,26 @@ public class LwM2MTransportHandler{
             coapConfig = LeshanServerBuilder.createDefaultNetworkConfig();
             coapConfig = LeshanServerBuilder.createDefaultNetworkConfig();
             coapConfig.store(configFile);
             coapConfig.store(configFile);
         }
         }
+        coapConfig.setString("COAP_PORT", Integer.toString(serverPortNoSec));
+        coapConfig.setString("COAP_SECURE_PORT", Integer.toString(serverSecurePort));
         return coapConfig;
         return coapConfig;
     }
     }
 
 
-    public static String getValueTypeToString (Object value, ResourceModel.Type type) {
+    public static boolean equalsResourceValue(Object valueOld, Object valueNew, ResourceModel.Type type, LwM2mPath resourcePath) throws CodecException {
         switch (type) {
         switch (type) {
-            case STRING:    // String
-            case OBJLNK:    // ObjectLink
-                return value.toString();
-            case INTEGER:   // Long
-                return Long.toString((long) value);
-            case BOOLEAN:   // Boolean
-                return Boolean.toString((Boolean) value);
-            case FLOAT:     // Double
-                return Double.toString((Float)value);
-            case TIME:      // Date
-                String DATE_FORMAT = "MMM d, yyyy HH:mm a";
-                DateFormat formatter = new SimpleDateFormat(DATE_FORMAT);
-                return formatter.format(new Date((Long) Integer.toUnsignedLong(Integer.valueOf((Integer) value))));
-            case OPAQUE:    // byte[] value, base64
-                return Hex.encodeHexString((byte[])value);
+            case BOOLEAN:
+            case INTEGER:
+            case FLOAT:
+                return String.valueOf(valueOld).equals(String.valueOf(valueNew));
+            case TIME:
+                return ((Date) valueOld).getTime() == ((Date) valueNew).getTime();
+            case STRING:
+            case OBJLNK:
+                return valueOld.equals(valueNew);
+            case OPAQUE:
+                return Hex.decodeHex(((String) valueOld).toCharArray()).equals(Hex.decodeHex(((String) valueNew).toCharArray()));
             default:
             default:
-                return null;
+                throw new CodecException("Invalid value type for resource %s, type %s", resourcePath, type);
         }
         }
     }
     }
 
 
@@ -182,26 +193,25 @@ public class LwM2MTransportHandler{
         attrTelemetryObserveValue.setPostAttributeProfile(profilesConfigData.get(ATTRIBUTE).getAsJsonArray());
         attrTelemetryObserveValue.setPostAttributeProfile(profilesConfigData.get(ATTRIBUTE).getAsJsonArray());
         attrTelemetryObserveValue.setPostTelemetryProfile(profilesConfigData.get(TELEMETRY).getAsJsonArray());
         attrTelemetryObserveValue.setPostTelemetryProfile(profilesConfigData.get(TELEMETRY).getAsJsonArray());
         attrTelemetryObserveValue.setPostObserveProfile(profilesConfigData.get(OBSERVE).getAsJsonArray());
         attrTelemetryObserveValue.setPostObserveProfile(profilesConfigData.get(OBSERVE).getAsJsonArray());
-        return  attrTelemetryObserveValue;
+        return attrTelemetryObserveValue;
     }
     }
 
 
     /**
     /**
-
      * @return deviceProfileBody with Observe&Attribute&Telemetry From Thingsboard
      * @return deviceProfileBody with Observe&Attribute&Telemetry From Thingsboard
      * Example: with pathResource (use only pathResource)
      * Example: with pathResource (use only pathResource)
      * property: "observeAttr"
      * property: "observeAttr"
      * {"keyName": {
      * {"keyName": {
-     *       "/3/0/1": "modelNumber",
-     *       "/3/0/0": "manufacturer",
-     *       "/3/0/2": "serialNumber"
-     *       },
+     * "/3/0/1": "modelNumber",
+     * "/3/0/0": "manufacturer",
+     * "/3/0/2": "serialNumber"
+     * },
      * "attribute":["/2/0/1","/3/0/9"],
      * "attribute":["/2/0/1","/3/0/9"],
      * "telemetry":["/1/0/1","/2/0/1","/6/0/1"],
      * "telemetry":["/1/0/1","/2/0/1","/6/0/1"],
      * "observe":["/2/0","/2/0/0","/4/0/2"]}
      * "observe":["/2/0","/2/0/0","/4/0/2"]}
      */
      */
     public static JsonObject getObserveAttrTelemetryFromThingsboard(DeviceProfile deviceProfile) {
     public static JsonObject getObserveAttrTelemetryFromThingsboard(DeviceProfile deviceProfile) {
         if (deviceProfile != null && ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties().size() > 0) {
         if (deviceProfile != null && ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties().size() > 0) {
-            Lwm2mDeviceProfileTransportConfiguration lwm2mDeviceProfileTransportConfiguration = (Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration();
+//            Lwm2mDeviceProfileTransportConfiguration lwm2mDeviceProfileTransportConfiguration = (Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration();
             Object observeAttr = ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties();
             Object observeAttr = ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties();
             try {
             try {
                 ObjectMapper mapper = new ObjectMapper();
                 ObjectMapper mapper = new ObjectMapper();
@@ -209,7 +219,7 @@ public class LwM2MTransportHandler{
                 JsonObject objectMsg = (observeAttrStr != null) ? validateJson(observeAttrStr) : null;
                 JsonObject objectMsg = (observeAttrStr != null) ? validateJson(observeAttrStr) : null;
                 return (getValidateCredentialsBodyFromThingsboard(objectMsg)) ? objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject() : null;
                 return (getValidateCredentialsBodyFromThingsboard(objectMsg)) ? objectMsg.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject() : null;
             } catch (IOException e) {
             } catch (IOException e) {
-                e.printStackTrace();
+                log.error("", e);
             }
             }
         }
         }
         return null;
         return null;
@@ -217,7 +227,6 @@ public class LwM2MTransportHandler{
 
 
     public static JsonObject getBootstrapParametersFromThingsboard(DeviceProfile deviceProfile) {
     public static JsonObject getBootstrapParametersFromThingsboard(DeviceProfile deviceProfile) {
         if (deviceProfile != null && ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties().size() > 0) {
         if (deviceProfile != null && ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties().size() > 0) {
-            Lwm2mDeviceProfileTransportConfiguration lwm2mDeviceProfileTransportConfiguration = (Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration();
             Object bootstrap = ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties();
             Object bootstrap = ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties();
             try {
             try {
                 ObjectMapper mapper = new ObjectMapper();
                 ObjectMapper mapper = new ObjectMapper();
@@ -225,7 +234,7 @@ public class LwM2MTransportHandler{
                 JsonObject objectMsg = (bootstrapStr != null) ? validateJson(bootstrapStr) : null;
                 JsonObject objectMsg = (bootstrapStr != null) ? validateJson(bootstrapStr) : null;
                 return (getValidateBootstrapProfileFromThingsboard(objectMsg)) ? objectMsg.get(BOOTSTRAP).getAsJsonObject() : null;
                 return (getValidateBootstrapProfileFromThingsboard(objectMsg)) ? objectMsg.get(BOOTSTRAP).getAsJsonObject() : null;
             } catch (IOException e) {
             } catch (IOException e) {
-                e.printStackTrace();
+                log.error("", e);
             }
             }
         }
         }
         return null;
         return null;
@@ -276,7 +285,7 @@ public class LwM2MTransportHandler{
             jsonValidFlesh = jsonValidFlesh.replaceAll("\n", "");
             jsonValidFlesh = jsonValidFlesh.replaceAll("\n", "");
             jsonValidFlesh = jsonValidFlesh.replaceAll("\t", "");
             jsonValidFlesh = jsonValidFlesh.replaceAll("\t", "");
             jsonValidFlesh = jsonValidFlesh.replaceAll(" ", "");
             jsonValidFlesh = jsonValidFlesh.replaceAll(" ", "");
-            String jsonValid = (jsonValidFlesh.substring(0, 1).equals("\"") && jsonValidFlesh.substring(jsonValidFlesh.length() - 1).equals("\"")) ? jsonValidFlesh.substring(1, jsonValidFlesh.length() - 1) : jsonValidFlesh;
+            String jsonValid = (jsonValidFlesh.charAt(0) == '"' && jsonValidFlesh.charAt(jsonValidFlesh.length() - 1) == '"') ? jsonValidFlesh.substring(1, jsonValidFlesh.length() - 1) : jsonValidFlesh;
             try {
             try {
                 object = new JsonParser().parse(jsonValid).getAsJsonObject();
                 object = new JsonParser().parse(jsonValid).getAsJsonObject();
             } catch (JsonSyntaxException e) {
             } catch (JsonSyntaxException e) {
@@ -288,7 +297,7 @@ public class LwM2MTransportHandler{
 
 
     public static <T> Optional<T> decode(byte[] byteArray) {
     public static <T> Optional<T> decode(byte[] byteArray) {
         try {
         try {
-            FSTConfiguration config = FSTConfiguration.createDefaultConfiguration();;
+            FSTConfiguration config = FSTConfiguration.createDefaultConfiguration();
             T msg = (T) config.asObject(byteArray);
             T msg = (T) config.asObject(byteArray);
             return Optional.ofNullable(msg);
             return Optional.ofNullable(msg);
         } catch (IllegalArgumentException e) {
         } catch (IllegalArgumentException e) {
@@ -297,37 +306,29 @@ public class LwM2MTransportHandler{
         }
         }
     }
     }
 
 
-    /**
-     * Equals to Map for values
-     * @param map1
-     * @param map2
-     * @param <V>
-     * @return
-     */
-    public static <V extends Comparable<V>>  boolean mapsEquals(Map<?,V> map1, Map<?,V> map2) {
-        List<V> values1 = new ArrayList<V>(map1.values());
-        List<V> values2 = new ArrayList<V>(map2.values());
-        Collections.sort(values1);
-        Collections.sort(values2);
-        return values1.equals(values2);
-    }
-
-    public static String convertCamelCase (String str) {
-        str = str.toLowerCase().replace("/[^a-z ]+/g", " ");
-        str = str.replace("/^(.)|\\s(.)/g", "$1");
-        str = str.replace("/[^a-zA-Z]+/g", "");
-        return str;
-    }
-
-    public static String splitCamelCaseString(String s){
-        LinkedList<String> linkedListOut = new LinkedList<String>();
+    public static String splitCamelCaseString(String s) {
+        LinkedList<String> linkedListOut = new LinkedList<>();
         LinkedList<String> linkedList = new LinkedList<String>((Arrays.asList(s.split(" "))));
         LinkedList<String> linkedList = new LinkedList<String>((Arrays.asList(s.split(" "))));
-        linkedList.stream().forEach(str-> {
+        linkedList.forEach(str -> {
             String strOut = str.replaceAll("\\W", "").replaceAll("_", "").toUpperCase();
             String strOut = str.replaceAll("\\W", "").replaceAll("_", "").toUpperCase();
-            if (strOut.length()>1) linkedListOut.add(strOut.substring(0, 1) + strOut.substring(1).toLowerCase());
+            if (strOut.length() > 1) linkedListOut.add(strOut.charAt(0) + strOut.substring(1).toLowerCase());
             else linkedListOut.add(strOut);
             else linkedListOut.add(strOut);
         });
         });
         linkedListOut.set(0, (linkedListOut.get(0).substring(0, 1).toLowerCase() + linkedListOut.get(0).substring(1)));
         linkedListOut.set(0, (linkedListOut.get(0).substring(0, 1).toLowerCase() + linkedListOut.get(0).substring(1)));
         return StringUtils.join(linkedListOut, "");
         return StringUtils.join(linkedListOut, "");
     }
     }
+
+    public static <T> TransportServiceCallback<Void> getAckCallback(LwM2MClient lwM2MClient, int requestId, String typeTopic) {
+        return new TransportServiceCallback<Void>() {
+            @Override
+            public void onSuccess(Void dummy) {
+                log.trace("[{}] [{}] - requestId [{}] - EndPoint  , Access AckCallback", typeTopic, requestId, lwM2MClient.getEndPoint());
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                log.trace("[{}] Failed to publish msg", e.toString());
+            }
+        };
+    }
 }
 }

@@ -20,26 +20,28 @@ import org.eclipse.californium.core.coap.Response;
 import org.eclipse.leshan.core.attributes.Attribute;
 import org.eclipse.leshan.core.attributes.Attribute;
 import org.eclipse.leshan.core.attributes.AttributeSet;
 import org.eclipse.leshan.core.attributes.AttributeSet;
 import org.eclipse.leshan.core.model.ResourceModel;
 import org.eclipse.leshan.core.model.ResourceModel;
+import org.eclipse.leshan.core.node.LwM2mNode;
+import org.eclipse.leshan.core.node.LwM2mPath;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
 import org.eclipse.leshan.core.node.ObjectLink;
 import org.eclipse.leshan.core.node.ObjectLink;
 import org.eclipse.leshan.core.observation.Observation;
 import org.eclipse.leshan.core.observation.Observation;
+import org.eclipse.leshan.core.request.CancelObservationRequest;
 import org.eclipse.leshan.core.request.ContentFormat;
 import org.eclipse.leshan.core.request.ContentFormat;
-import org.eclipse.leshan.core.request.WriteRequest;
 import org.eclipse.leshan.core.request.DiscoverRequest;
 import org.eclipse.leshan.core.request.DiscoverRequest;
 import org.eclipse.leshan.core.request.DownlinkRequest;
 import org.eclipse.leshan.core.request.DownlinkRequest;
+import org.eclipse.leshan.core.request.ExecuteRequest;
 import org.eclipse.leshan.core.request.ObserveRequest;
 import org.eclipse.leshan.core.request.ObserveRequest;
-import org.eclipse.leshan.core.request.CancelObservationRequest;
 import org.eclipse.leshan.core.request.ReadRequest;
 import org.eclipse.leshan.core.request.ReadRequest;
-import org.eclipse.leshan.core.request.ExecuteRequest;
 import org.eclipse.leshan.core.request.WriteAttributesRequest;
 import org.eclipse.leshan.core.request.WriteAttributesRequest;
-import org.eclipse.leshan.core.response.ResponseCallback;
-import org.eclipse.leshan.core.response.LwM2mResponse;
-import org.eclipse.leshan.core.response.ObserveResponse;
-import org.eclipse.leshan.core.response.ReadResponse;
+import org.eclipse.leshan.core.request.WriteRequest;
 import org.eclipse.leshan.core.response.CancelObservationResponse;
 import org.eclipse.leshan.core.response.CancelObservationResponse;
 import org.eclipse.leshan.core.response.DeleteResponse;
 import org.eclipse.leshan.core.response.DeleteResponse;
-import org.eclipse.leshan.core.response.ExecuteResponse;
 import org.eclipse.leshan.core.response.DiscoverResponse;
 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.ObserveResponse;
+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.WriteAttributesResponse;
 import org.eclipse.leshan.core.response.WriteResponse;
 import org.eclipse.leshan.core.response.WriteResponse;
 import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.core.util.Hex;
@@ -50,6 +52,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 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.server.transport.lwm2m.server.client.LwM2MClient;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
+import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PostConstruct;
 import java.util.ArrayList;
 import java.util.ArrayList;
@@ -65,32 +68,36 @@ import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandle
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_DISCOVER;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_DISCOVER;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_OBSERVE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_OBSERVE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_READ;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_READ;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.PUT_TYPE_OPER_WRITE_ATTRIBUTES;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.PUT_TYPE_OPER_WRITE_UPDATE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_INFO;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_EXECUTE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_EXECUTE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_OBSERVE_CANCEL;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_OBSERVE_CANCEL;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_WRITE_REPLACE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_WRITE_REPLACE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_ERROR;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.PUT_TYPE_OPER_WRITE_ATTRIBUTES;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.PUT_TYPE_OPER_WRITE_UPDATE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.RESPONSE_CHANNEL;
 
 
 @Slf4j
 @Slf4j
 @Service("LwM2MTransportRequest")
 @Service("LwM2MTransportRequest")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 public class LwM2MTransportRequest {
 public class LwM2MTransportRequest {
-    private final ExecutorService executorService;
-    private static final String RESPONSE_CHANNEL = "THINGSBOARD_RESP";
+    private ExecutorService executorResponse;
+    private ExecutorService executorResponseError;
+    private LwM2mValueConverterImpl converter;
 
 
     @Autowired
     @Autowired
-    LwM2MTransportService service;
-
-    public LwM2MTransportRequest() {
-        executorService = Executors.newCachedThreadPool(
-                new NamedThreadFactory(String.format("LwM2M %s channel response", RESPONSE_CHANNEL)));
-    }
+    LwM2MTransportServiceImpl service;
 
 
+    @Autowired
+    public LwM2MTransportContextServer context;
 
 
     @PostConstruct
     @PostConstruct
     public void init() {
     public void init() {
+        this.converter = LwM2mValueConverterImpl.getInstance();
+        executorResponse = Executors.newFixedThreadPool(this.context.getCtxServer().getRequestPoolSize(),
+                new NamedThreadFactory(String.format("LwM2M %s channel response", RESPONSE_CHANNEL)));
+        executorResponseError =  Executors.newFixedThreadPool(this.context.getCtxServer().getRequestErrorPoolSize(),
+                new NamedThreadFactory(String.format("LwM2M %s channel response Error", RESPONSE_CHANNEL)));
     }
     }
 
 
     public Collection<Registration> doGetRegistrations(LeshanServer lwServer) {
     public Collection<Registration> doGetRegistrations(LeshanServer lwServer) {
@@ -113,16 +120,13 @@ public class LwM2MTransportRequest {
      * @param lwM2MClient
      * @param lwM2MClient
      * @param observation
      * @param observation
      */
      */
-    public void sendAllRequest(LeshanServer lwServer, Registration registration, String target, String typeOper,
-                               String contentFormatParam, LwM2MClient lwM2MClient, Observation observation, Object params, long timeoutInMs) {
-        ResultIds resultIds = new ResultIds(target);
+    public void sendAllRequest(LeshanServer lwServer, Registration registration, String target, String typeOper, String contentFormatParam,
+                               LwM2MClient lwM2MClient, Observation observation, Object params, long timeoutInMs, boolean isDelayedUpdate) {
+        LwM2mPath resultIds = new LwM2mPath(target);
         if (registration != null && resultIds.getObjectId() >= 0) {
         if (registration != null && resultIds.getObjectId() >= 0) {
             DownlinkRequest request = null;
             DownlinkRequest request = null;
             ContentFormat contentFormat = contentFormatParam != null ? ContentFormat.fromName(contentFormatParam.toUpperCase()) : null;
             ContentFormat contentFormat = contentFormatParam != null ? ContentFormat.fromName(contentFormatParam.toUpperCase()) : null;
-            ResourceModel resource = (resultIds.resourceId >= 0) ? (lwM2MClient != null) ?
-                    lwM2MClient.getModelObjects().get(resultIds.getObjectId()).getObjectModel().resources.get(resultIds.resourceId) : null : null;
-            ResourceModel.Type resType = (resource == null) ? null : resource.type;
-            boolean resMultiple = (resource == null) ? false : resource.multiple;
+            ResourceModel resource = service.context.getCtxServer().getResourceModel(registration, resultIds);
             timeoutInMs = timeoutInMs > 0 ? timeoutInMs : DEFAULT_TIMEOUT;
             timeoutInMs = timeoutInMs > 0 ? timeoutInMs : DEFAULT_TIMEOUT;
             switch (typeOper) {
             switch (typeOper) {
                 case GET_TYPE_OPER_READ:
                 case GET_TYPE_OPER_READ:
@@ -132,10 +136,10 @@ public class LwM2MTransportRequest {
                     request = new DiscoverRequest(target);
                     request = new DiscoverRequest(target);
                     break;
                     break;
                 case GET_TYPE_OPER_OBSERVE:
                 case GET_TYPE_OPER_OBSERVE:
-                    if (resultIds.getResourceId() >= 0) {
-                        request = new ObserveRequest(resultIds.getObjectId(), resultIds.getInstanceId(), resultIds.getResourceId());
-                    } else if (resultIds.getInstanceId() >= 0) {
-                        request = new ObserveRequest(resultIds.getObjectId(), resultIds.getInstanceId());
+                    if (resultIds.isResource()) {
+                        request = new ObserveRequest(resultIds.getObjectId(), resultIds.getObjectInstanceId(), resultIds.getResourceId());
+                    } else if (resultIds.isObjectInstance()) {
+                        request = new ObserveRequest(resultIds.getObjectId(), resultIds.getObjectInstanceId());
                     } else if (resultIds.getObjectId() >= 0) {
                     } else if (resultIds.getObjectId() >= 0) {
                         request = new ObserveRequest(resultIds.getObjectId());
                         request = new ObserveRequest(resultIds.getObjectId());
                     }
                     }
@@ -144,27 +148,30 @@ public class LwM2MTransportRequest {
                     request = new CancelObservationRequest(observation);
                     request = new CancelObservationRequest(observation);
                     break;
                     break;
                 case POST_TYPE_OPER_EXECUTE:
                 case POST_TYPE_OPER_EXECUTE:
-                    if (params != null && !resMultiple) {
-                        request = new ExecuteRequest(target, LwM2MTransportHandler.getValueTypeToString(params, resType));
+                    if (params != null && resource != null && !resource.multiple) {
+                        request = new ExecuteRequest(target, (String) this.converter.convertValue(params, resource.type, ResourceModel.Type.STRING, resultIds));
                     } else {
                     } else {
                         request = new ExecuteRequest(target);
                         request = new ExecuteRequest(target);
                     }
                     }
                     break;
                     break;
                 case POST_TYPE_OPER_WRITE_REPLACE:
                 case POST_TYPE_OPER_WRITE_REPLACE:
                     // Request to write a <b>String Single-Instance Resource</b> using the TLV content format.
                     // Request to write a <b>String Single-Instance Resource</b> using the TLV content format.
-                    if (contentFormat.equals(ContentFormat.TLV) && !resMultiple) {
-                        request = this.getWriteRequestSingleResource(null, resultIds.getObjectId(), resultIds.getInstanceId(), resultIds.getResourceId(), params, resType);
-                    }
-                    // Mode.REPLACE && Request to write a <b>String Single-Instance Resource</b> using the given content format (TEXT, TLV, JSON)
-                    else if (!contentFormat.equals(ContentFormat.TLV) && !resMultiple) {
-                        request = this.getWriteRequestSingleResource(contentFormat, resultIds.getObjectId(), resultIds.getInstanceId(), resultIds.getResourceId(), params, resType);
+                    if (resource != null) {
+                        if (contentFormat.equals(ContentFormat.TLV) && !resource.multiple) {
+                            request = this.getWriteRequestSingleResource(null, resultIds.getObjectId(), resultIds.getObjectInstanceId(), resultIds.getResourceId(), params, resource.type, registration);
+                        }
+                        // Mode.REPLACE && Request to write a <b>String Single-Instance Resource</b> using the given content format (TEXT, TLV, JSON)
+                        else if (!contentFormat.equals(ContentFormat.TLV) && !resource.multiple) {
+                            request = this.getWriteRequestSingleResource(contentFormat, resultIds.getObjectId(), resultIds.getObjectInstanceId(), resultIds.getResourceId(), params, resource.type, registration);
+                        }
                     }
                     }
                     break;
                     break;
                 case PUT_TYPE_OPER_WRITE_UPDATE:
                 case PUT_TYPE_OPER_WRITE_UPDATE:
                     if (resultIds.getResourceId() >= 0) {
                     if (resultIds.getResourceId() >= 0) {
                         ResourceModel resourceModel = lwServer.getModelProvider().getObjectModel(registration).getObjectModel(resultIds.getObjectId()).resources.get(resultIds.getResourceId());
                         ResourceModel resourceModel = lwServer.getModelProvider().getObjectModel(registration).getObjectModel(resultIds.getObjectId()).resources.get(resultIds.getResourceId());
                         ResourceModel.Type typeRes = resourceModel.type;
                         ResourceModel.Type typeRes = resourceModel.type;
-//                        request = getWriteRequestResource(resultIds.getObjectId(), resultIds.getInstanceId(), resultIds.getResourceId(), params, typeRes);
+                        LwM2mNode node = LwM2mSingleResource.newStringResource(resultIds.getResourceId(), (String) this.converter.convertValue(params, resource.type, ResourceModel.Type.STRING, resultIds));
+                        request = new WriteRequest(WriteRequest.Mode.UPDATE, contentFormat, target, node);
                     }
                     }
                     break;
                     break;
                 case PUT_TYPE_OPER_WRITE_ATTRIBUTES:
                 case PUT_TYPE_OPER_WRITE_ATTRIBUTES:
@@ -202,55 +209,76 @@ public class LwM2MTransportRequest {
                     Attribute pmin = new Attribute(MINIMUM_PERIOD, Integer.toUnsignedLong(Integer.valueOf("1")));
                     Attribute pmin = new Attribute(MINIMUM_PERIOD, Integer.toUnsignedLong(Integer.valueOf("1")));
                     Attribute[] attrs = {pmin};
                     Attribute[] attrs = {pmin};
                     AttributeSet attrSet = new AttributeSet(attrs);
                     AttributeSet attrSet = new AttributeSet(attrs);
-                    if (resultIds.getResourceId() >= 0) {
-                        request = new WriteAttributesRequest(resultIds.getObjectId(), resultIds.getInstanceId(), resultIds.getResourceId(), attrSet);
-                    } else if (resultIds.getInstanceId() >= 0) {
-                        request = new WriteAttributesRequest(resultIds.getObjectId(), resultIds.getInstanceId(), attrSet);
+                    if (resultIds.isResource()) {
+                        request = new WriteAttributesRequest(resultIds.getObjectId(), resultIds.getObjectInstanceId(), resultIds.getResourceId(), attrSet);
+                    } else if (resultIds.isObjectInstance()) {
+                        request = new WriteAttributesRequest(resultIds.getObjectId(), resultIds.getObjectInstanceId(), attrSet);
                     } else if (resultIds.getObjectId() >= 0) {
                     } else if (resultIds.getObjectId() >= 0) {
                         request = new WriteAttributesRequest(resultIds.getObjectId(), attrSet);
                         request = new WriteAttributesRequest(resultIds.getObjectId(), attrSet);
                     }
                     }
                     break;
                     break;
                 default:
                 default:
             }
             }
-            if (request != null) sendRequest(lwServer, registration, request, lwM2MClient, timeoutInMs);
+
+            if (request != null) {
+                this.sendRequest(lwServer, registration, request, lwM2MClient, timeoutInMs, isDelayedUpdate);
+            } else if (isDelayedUpdate) {
+                String msg = String.format(LOG_LW2M_ERROR + ": sendRequest: Resource path - %s msg  No  SendRequest to Client", target);
+                service.sentLogsToThingsboard(msg, registration);
+                log.error("[{}] - [{}] No SendRequest", target);
+                this.handleResponseError(registration, target, lwM2MClient, isDelayedUpdate);
+
+            }
         }
         }
     }
     }
 
 
     /**
     /**
      *
      *
-     * @param lwServer
-     * @param registration
-     * @param request
-     * @param lwM2MClient
-     * @param timeoutInMs
+     * @param lwServer -
+     * @param registration -
+     * @param request -
+     * @param lwM2MClient -
+     * @param timeoutInMs -
      */
      */
-    private void sendRequest(LeshanServer lwServer, Registration registration, DownlinkRequest request, LwM2MClient lwM2MClient, long timeoutInMs) {
+
+    private void sendRequest(LeshanServer lwServer, Registration registration, DownlinkRequest request, LwM2MClient lwM2MClient, long timeoutInMs, boolean isDelayedUpdate) {
         lwServer.send(registration, request, timeoutInMs, (ResponseCallback<?>) response -> {
         lwServer.send(registration, request, timeoutInMs, (ResponseCallback<?>) response -> {
-            if  (isSuccess(((Response)response.getCoapResponse()).getCode())) {
-                this.handleResponse(registration, request.getPath().toString(), response, request, lwM2MClient);
+            if (isSuccess(((Response) response.getCoapResponse()).getCode())) {
+                this.handleResponse(registration, request.getPath().toString(), response, request, lwM2MClient, isDelayedUpdate);
                 if (request instanceof WriteRequest && ((WriteRequest) request).isReplaceRequest()) {
                 if (request instanceof WriteRequest && ((WriteRequest) request).isReplaceRequest()) {
-                    String msg = String.format(LOG_LW2M_INFO + " sendRequest Replace: CoapCde - %s Lwm2m code - %d name - %s Resource path - %s value - %s SendRequest to Client",
-                            ((Response)response.getCoapResponse()).getCode(), response.getCode().getCode(), response.getCode().getName(), request.getPath().toString(),
-                            ((LwM2mSingleResource)((WriteRequest) request).getNode()).getValue().toString());
-                    service.sentLogsToThingsboard(msg, registration.getId());
-                    log.info("[{}] - [{}] [{}] [{}] Update SendRequest", ((Response)response.getCoapResponse()).getCode(), response.getCode(),  request.getPath().toString(), ((LwM2mSingleResource)((WriteRequest) request).getNode()).getValue());
+                    String delayedUpdateStr = "";
+                    if (isDelayedUpdate) {
+                        delayedUpdateStr = " (delayedUpdate) ";
+                    }
+                    String msg = String.format(LOG_LW2M_INFO + ": sendRequest Replace%s: CoapCde - %s Lwm2m code - %d name - %s Resource path - %s value - %s SendRequest to Client",
+                            delayedUpdateStr, ((Response) response.getCoapResponse()).getCode(), response.getCode().getCode(), response.getCode().getName(), request.getPath().toString(),
+                            ((LwM2mSingleResource) ((WriteRequest) request).getNode()).getValue().toString());
+                    service.sentLogsToThingsboard(msg, registration);
+                    log.info("[{}] - [{}] [{}] [{}] Update SendRequest[{}]", ((Response) response.getCoapResponse()).getCode(), response.getCode(), request.getPath().toString(),
+                            ((LwM2mSingleResource) ((WriteRequest) request).getNode()).getValue(), delayedUpdateStr);
+                }
+            } else {
+                String msg = String.format(LOG_LW2M_ERROR + ": sendRequest: CoapCode - %s Lwm2m code - %d name - %s Resource path - %s  SendRequest to Client",
+                        ((Response) response.getCoapResponse()).getCode(), response.getCode().getCode(), response.getCode().getName(), request.getPath().toString());
+                service.sentLogsToThingsboard(msg, registration);
+                log.error("[{}] - [{}] [{}] error SendRequest", ((Response) response.getCoapResponse()).getCode(), response.getCode(), request.getPath().toString());
+                if (request instanceof WriteRequest && ((WriteRequest) request).isReplaceRequest() && isDelayedUpdate) {
+                    this.handleResponseError(registration, request.getPath().toString(), lwM2MClient, isDelayedUpdate);
                 }
                 }
             }
             }
-            else {
-                String msg = String.format(LOG_LW2M_ERROR + " sendRequest: CoapCde - %s Lwm2m code - %d name - %s Resource path - %s  SendRequest to Client",
-                        ((Response)response.getCoapResponse()).getCode(), response.getCode().getCode(), response.getCode().getName(), request.getPath().toString());
-                service.sentLogsToThingsboard(msg, registration.getId());
-                log.error("[{}] - [{}] [{}] error SendRequest", ((Response)response.getCoapResponse()).getCode(), response.getCode(),  request.getPath().toString());
-            }
+
         }, e -> {
         }, e -> {
-            String msg = String.format(LOG_LW2M_ERROR + " sendRequest: Resource path - %s msg error - %s  SendRequest to Client",
+            String msg = String.format(LOG_LW2M_ERROR + ": sendRequest: Resource path - %s msg error - %s  SendRequest to Client",
                     request.getPath().toString(), e.toString());
                     request.getPath().toString(), e.toString());
-            service.sentLogsToThingsboard(msg, registration.getId());
-            log.error("[{}] - [{}] error SendRequest",  request.getPath().toString(), e.toString());
+            service.sentLogsToThingsboard(msg, registration);
+            log.error("[{}] - [{}] error SendRequest", request.getPath().toString(), e.toString());
+            if (request instanceof WriteRequest && ((WriteRequest) request).isReplaceRequest() && isDelayedUpdate) {
+                this.handleResponseError(registration, request.getPath().toString(), lwM2MClient, isDelayedUpdate);
+            }
         });
         });
     }
     }
 
 
-    private WriteRequest getWriteRequestSingleResource(ContentFormat contentFormat, Integer objectId, Integer instanceId, Integer resourceId, Object value, ResourceModel.Type type) {
+    private WriteRequest getWriteRequestSingleResource(ContentFormat contentFormat, Integer objectId, Integer instanceId, Integer resourceId, Object value, ResourceModel.Type type, Registration registration) {
         try {
         try {
             switch (type) {
             switch (type) {
                 case STRING:    // String
                 case STRING:    // String
@@ -264,29 +292,38 @@ public class LwM2MTransportRequest {
                 case FLOAT:     // Double
                 case FLOAT:     // Double
                     return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, Double.valueOf(value.toString())) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, Double.valueOf(value.toString()));
                     return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, Double.valueOf(value.toString())) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, Double.valueOf(value.toString()));
                 case TIME:      // Date
                 case TIME:      // Date
-                    return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, new Date((Long) Integer.toUnsignedLong(Integer.valueOf(value.toString())))) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, new Date((Long) Integer.toUnsignedLong(Integer.valueOf(value.toString()))));
+                    return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, new Date(Long.decode(value.toString()))) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, new Date((Long) Integer.toUnsignedLong(Integer.valueOf(value.toString()))));
                 case OPAQUE:    // byte[] value, base64
                 case OPAQUE:    // byte[] value, base64
                     return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, Hex.decodeHex(value.toString().toCharArray())) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, Hex.decodeHex(value.toString().toCharArray()));
                     return (contentFormat == null) ? new WriteRequest(objectId, instanceId, resourceId, Hex.decodeHex(value.toString().toCharArray())) : new WriteRequest(contentFormat, objectId, instanceId, resourceId, Hex.decodeHex(value.toString().toCharArray()));
                 default:
                 default:
             }
             }
             return null;
             return null;
         } catch (NumberFormatException e) {
         } catch (NumberFormatException e) {
-            String patn = "/" + objectId + "/" +  instanceId + "/" +  resourceId;
-            log.error("Path: [{}] type: [{}] value: [{}] errorMsg: [{}]]",   patn, type, value, e.toString());
-            return  null;
+            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());
+            service.sentLogsToThingsboard(msg, registration);
+            log.error("Path: [{}] type: [{}] value: [{}] errorMsg: [{}]]", patn, type, value, e.toString());
+            return null;
         }
         }
     }
     }
 
 
-    private void handleResponse(Registration registration, final String path, LwM2mResponse response, DownlinkRequest request, LwM2MClient lwM2MClient) {
-        executorService.submit(new Runnable() {
-            @Override
-            public void run() {
+    private void handleResponse(Registration registration, final String path, LwM2mResponse response, DownlinkRequest request, LwM2MClient lwM2MClient, boolean isDelayedUpdate) {
+        executorResponse.submit(() -> {
+            try {
+                sendResponse(registration, path, response, request, lwM2MClient, isDelayedUpdate);
+            } catch (Exception e) {
+                log.error("[{}] endpoint [{}] path [{}] Exception Unable to after send response.", registration.getEndpoint(), path, e);
+            }
+        });
+    }
 
 
-                try {
-                    sendResponse(registration, path, response, request, lwM2MClient);
-                } catch (RuntimeException t) {
-                    log.error("[{}] endpoint [{}] path [{}] error Unable to after send response.", registration.getEndpoint(), path, t.toString());
-                }
+    private void handleResponseError(Registration registration, final String path, LwM2MClient lwM2MClient, boolean isDelayedUpdate) {
+        executorResponseError.submit(() -> {
+            try {
+                if (isDelayedUpdate) lwM2MClient.onSuccessOrErrorDelayedRequests(path);
+            } catch (RuntimeException t) {
+                log.error("[{}] endpoint [{}] path [{}] RuntimeException Unable to after send response.", registration.getEndpoint(), path, t);
             }
             }
         });
         });
     }
     }
@@ -298,7 +335,7 @@ public class LwM2MTransportRequest {
      * @param response -
      * @param response -
      * @param lwM2MClient -
      * @param lwM2MClient -
      */
      */
-    private void sendResponse(Registration registration, String path, LwM2mResponse response, DownlinkRequest request, LwM2MClient lwM2MClient) {
+    private void sendResponse(Registration registration, String path, LwM2mResponse response, DownlinkRequest request, LwM2MClient lwM2MClient, boolean isDelayedUpdate) {
         if (response instanceof ObserveResponse) {
         if (response instanceof ObserveResponse) {
             service.onObservationResponse(registration, path, (ReadResponse) response);
             service.onObservationResponse(registration, path, (ReadResponse) response);
         } else if (response instanceof CancelObservationResponse) {
         } else if (response instanceof CancelObservationResponse) {
@@ -329,7 +366,7 @@ public class LwM2MTransportRequest {
             log.info("[{}] Path [{}] WriteAttributesResponse 8_Send", path, response);
             log.info("[{}] Path [{}] WriteAttributesResponse 8_Send", path, response);
         } else if (response instanceof WriteResponse) {
         } else if (response instanceof WriteResponse) {
             log.info("[{}] Path [{}] WriteAttributesResponse 9_Send", path, response);
             log.info("[{}] Path [{}] WriteAttributesResponse 9_Send", path, response);
-            service.onAttributeUpdateOk(registration, path, (WriteRequest) request);
+            service.onAttributeUpdateOk(registration, path, (WriteRequest) request, isDelayedUpdate);
         }
         }
     }
     }
 }
 }

@@ -20,10 +20,16 @@ import org.eclipse.californium.scandium.config.DtlsConnectorConfig;
 import org.eclipse.leshan.core.node.codec.DefaultLwM2mNodeDecoder;
 import org.eclipse.leshan.core.node.codec.DefaultLwM2mNodeDecoder;
 import org.eclipse.leshan.core.node.codec.DefaultLwM2mNodeEncoder;
 import org.eclipse.leshan.core.node.codec.DefaultLwM2mNodeEncoder;
 import org.eclipse.leshan.core.node.codec.LwM2mNodeDecoder;
 import org.eclipse.leshan.core.node.codec.LwM2mNodeDecoder;
+import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.server.californium.LeshanServer;
 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.model.LwM2mModelProvider;
 import org.eclipse.leshan.server.model.LwM2mModelProvider;
 import org.eclipse.leshan.server.model.VersionedModelProvider;
 import org.eclipse.leshan.server.model.VersionedModelProvider;
+import org.eclipse.leshan.server.redis.RedisRegistrationStore;
+import org.eclipse.leshan.server.redis.RedisSecurityStore;
+import org.eclipse.leshan.server.security.DefaultAuthorizer;
+import org.eclipse.leshan.server.security.EditableSecurityStore;
+import org.eclipse.leshan.server.security.SecurityChecker;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Bean;
@@ -31,11 +37,36 @@ import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 import org.springframework.context.annotation.Primary;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
-import org.thingsboard.server.transport.lwm2m.server.secure.LwM2MSetSecurityStoreServer;
 import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
 import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
-import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.X509;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.util.Pool;
+
+import java.math.BigInteger;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.AlgorithmParameters;
+import java.security.GeneralSecurityException;
+import java.security.KeyFactory;
+import java.security.KeyStoreException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.X509Certificate;
+import java.security.interfaces.ECPublicKey;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.ECParameterSpec;
+import java.security.spec.ECPoint;
+import java.security.spec.ECPrivateKeySpec;
+import java.security.spec.ECPublicKeySpec;
+import java.security.spec.KeySpec;
+import java.util.Arrays;
+
+import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CBC_SHA256;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.PSK;
 import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.RPK;
 import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.RPK;
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.X509;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getCoapConfig;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getCoapConfig;
 
 
 
 
@@ -45,6 +76,8 @@ import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandle
 @Configuration("LwM2MTransportServerConfiguration")
 @Configuration("LwM2MTransportServerConfiguration")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 public class LwM2MTransportServerConfiguration {
 public class LwM2MTransportServerConfiguration {
+    private PublicKey publicKey;
+    private PrivateKey privateKey;
 
 
     @Autowired
     @Autowired
     private LwM2MTransportContextServer context;
     private LwM2MTransportContextServer context;
@@ -53,50 +86,257 @@ public class LwM2MTransportServerConfiguration {
     private LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
     private LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
 
 
     @Primary
     @Primary
-    @Bean(name = "LeshanServerCert")
-    public LeshanServer getLeshanServerCert() {
-        log.info("Starting LwM2M transport ServerCert... PostConstruct");
-        return getLeshanServer(this.context.getCtxServer().getServerPortCert(), this.context.getCtxServer().getServerSecurePortCert(), X509);
+    @Bean(name = "leshanServerPsk")
+    @ConditionalOnExpression("('${transport.lwm2m.server.secure.start_psk:false}'=='true')")
+    public LeshanServer getLeshanServerPsk() {
+        log.info("Starting LwM2M transport ServerPsk... PostConstruct");
+        return getLeshanServer(this.context.getCtxServer().getServerPortNoSecPsk(), this.context.getCtxServer().getServerPortPsk(), PSK);
     }
     }
 
 
-    @Bean(name = "leshanServerNoSecPskRpk")
-    public LeshanServer getLeshanServerNoSecPskRpk() {
-        log.info("Starting LwM2M transport ServerNoSecPskRpk... PostConstruct");
-        return getLeshanServer(this.context.getCtxServer().getServerPort(), this.context.getCtxServer().getServerSecurePort(), RPK);
+    @Bean(name = "leshanServerRpk")
+    @ConditionalOnExpression("('${transport.lwm2m.server.secure.start_rpk:false}'=='true')")
+    public LeshanServer getLeshanServerRpk() {
+        log.info("Starting LwM2M transport ServerRpk... PostConstruct");
+        return getLeshanServer(this.context.getCtxServer().getServerPortNoSecRpk(), this.context.getCtxServer().getServerPortRpk(), RPK);
     }
     }
 
 
-    private LeshanServer getLeshanServer(Integer serverPort, Integer serverSecurePort, LwM2MSecurityMode dtlsMode) {
+    @Bean(name = "leshanServerX509")
+    @ConditionalOnExpression("('${transport.lwm2m.server.secure.start_x509:false}'=='true')")
+    public LeshanServer getLeshanServerX509() {
+        log.info("Starting LwM2M transport ServerX509... PostConstruct");
+        return getLeshanServer(this.context.getCtxServer().getServerPortNoSecX509(), this.context.getCtxServer().getServerPortX509(), X509);
+    }
 
 
+    private LeshanServer getLeshanServer(Integer serverPortNoSec, Integer serverSecurePort, LwM2MSecurityMode dtlsMode) {
         LeshanServerBuilder builder = new LeshanServerBuilder();
         LeshanServerBuilder builder = new LeshanServerBuilder();
-        builder.setLocalAddress(this.context.getCtxServer().getServerHost(), serverPort);
+        builder.setLocalAddress(this.context.getCtxServer().getServerHost(), serverPortNoSec);
         builder.setLocalSecureAddress(this.context.getCtxServer().getServerSecureHost(), serverSecurePort);
         builder.setLocalSecureAddress(this.context.getCtxServer().getServerSecureHost(), serverSecurePort);
         builder.setEncoder(new DefaultLwM2mNodeEncoder());
         builder.setEncoder(new DefaultLwM2mNodeEncoder());
         LwM2mNodeDecoder decoder = new DefaultLwM2mNodeDecoder();
         LwM2mNodeDecoder decoder = new DefaultLwM2mNodeDecoder();
         builder.setDecoder(decoder);
         builder.setDecoder(decoder);
-        builder.setEncoder(new DefaultLwM2mNodeEncoder(new LwM2mValueConverterImpl()));
+        builder.setEncoder(new DefaultLwM2mNodeEncoder(LwM2mValueConverterImpl.getInstance()));
 
 
         /** Create CoAP Config */
         /** Create CoAP Config */
-        builder.setCoapConfig(getCoapConfig());
+        builder.setCoapConfig(getCoapConfig(serverPortNoSec, serverSecurePort));
 
 
         /** Define model provider (Create Models )*/
         /** Define model provider (Create Models )*/
         LwM2mModelProvider modelProvider = new VersionedModelProvider(this.context.getCtxServer().getModelsValue());
         LwM2mModelProvider modelProvider = new VersionedModelProvider(this.context.getCtxServer().getModelsValue());
         builder.setObjectModelProvider(modelProvider);
         builder.setObjectModelProvider(modelProvider);
 
 
+        /**  Create DTLS security mode
+         * There can be only one DTLS security mode
+         */
+        this.LwM2MSetSecurityStoreServer(builder, dtlsMode);
+
         /** Create DTLS Config */
         /** Create DTLS Config */
         DtlsConnectorConfig.Builder dtlsConfig = new DtlsConnectorConfig.Builder();
         DtlsConnectorConfig.Builder dtlsConfig = new DtlsConnectorConfig.Builder();
-        dtlsConfig.setRecommendedCipherSuitesOnly(this.context.getCtxServer().isSupportDeprecatedCiphersEnable());
+        if (dtlsMode==PSK) {
+            dtlsConfig.setRecommendedCipherSuitesOnly(this.context.getCtxServer().isRecommendedCiphers());
+            dtlsConfig.setRecommendedSupportedGroupsOnly(this.context.getCtxServer().isRecommendedSupportedGroups());
+            dtlsConfig.setSupportedCipherSuites(TLS_PSK_WITH_AES_128_CBC_SHA256);
+        }
+        else  {
+            dtlsConfig.setRecommendedSupportedGroupsOnly(!this.context.getCtxServer().isRecommendedSupportedGroups());
+            dtlsConfig.setRecommendedCipherSuitesOnly(!this.context.getCtxServer().isRecommendedCiphers());
+        }
         /** Set DTLS Config */
         /** Set DTLS Config */
         builder.setDtlsConfig(dtlsConfig);
         builder.setDtlsConfig(dtlsConfig);
 
 
         /** Use a magic converter to support bad type send by the UI. */
         /** Use a magic converter to support bad type send by the UI. */
-        builder.setEncoder(new DefaultLwM2mNodeEncoder(new LwM2mValueConverterImpl()));
+        builder.setEncoder(new DefaultLwM2mNodeEncoder(LwM2mValueConverterImpl.getInstance()));
 
 
-        /**  Create DTLS security mode
-         * There can be only one DTLS security mode
-         */
-        new LwM2MSetSecurityStoreServer(builder, context, lwM2mInMemorySecurityStore, dtlsMode);
 
 
         /** Create LWM2M server */
         /** Create LWM2M server */
         return builder.build();
         return builder.build();
     }
     }
+
+    private void  LwM2MSetSecurityStoreServer(LeshanServerBuilder builder, LwM2MSecurityMode dtlsMode) {
+        /** Set securityStore with new registrationStore */
+        EditableSecurityStore securityStore = lwM2mInMemorySecurityStore;
+        switch (dtlsMode) {
+            /** Use PSK only */
+            case PSK:
+                generatePSK_RPK();
+                infoParamsPSK();
+                break;
+            /** Use RPK only */
+            case RPK:
+                generatePSK_RPK();
+                if (this.publicKey != null && this.publicKey.getEncoded().length > 0 &&
+                        this.privateKey != null && this.privateKey.getEncoded().length > 0) {
+                    builder.setPublicKey(this.publicKey);
+                    builder.setPrivateKey(this.privateKey);
+                    infoParamsRPK();
+                }
+                break;
+            /** Use x509 only */
+            case X509:
+                setServerWithX509Cert(builder);
+                break;
+            /** No security */
+            case NO_SEC:
+                builder.setTrustedCertificates(new X509Certificate[0]);
+                break;
+            /** Use x509 with EST */
+            case X509_EST:
+                // TODO support sentinel pool and make pool configurable
+                break;
+            case REDIS:
+                /**
+                 * Set securityStore with new registrationStore (if use redis store)
+                 * Connect to redis
+                 */
+                Pool<Jedis> jedis = null;
+                try {
+                    jedis = new JedisPool(new URI(this.context.getCtxServer().getRedisUrl()));
+                    securityStore = new RedisSecurityStore(jedis);
+                    builder.setRegistrationStore(new RedisRegistrationStore(jedis));
+                } catch (URISyntaxException e) {
+                    log.error("", e);
+                }
+                break;
+            default:
+        }
+
+        /** Set securityStore with registrationStore (if x509)*/
+        if (dtlsMode == X509) {
+            builder.setAuthorizer(new DefaultAuthorizer(securityStore, new SecurityChecker() {
+                @Override
+                protected boolean matchX509Identity(String endpoint, String receivedX509CommonName,
+                                                    String expectedX509CommonName) {
+                    return endpoint.startsWith(expectedX509CommonName);
+                }
+            }));
+        }
+
+        /** Set securityStore with new registrationStore */
+        builder.setSecurityStore(securityStore);
+    }
+
+    private void generatePSK_RPK() {
+        try {
+            /** Get Elliptic Curve Parameter spec for secp256r1 */
+            AlgorithmParameters algoParameters = AlgorithmParameters.getInstance("EC");
+            algoParameters.init(new ECGenParameterSpec("secp256r1"));
+            ECParameterSpec parameterSpec = algoParameters.getParameterSpec(ECParameterSpec.class);
+            if (this.context.getCtxServer().getServerPublicX() != null && !this.context.getCtxServer().getServerPublicX().isEmpty() && this.context.getCtxServer().getServerPublicY() != null && !this.context.getCtxServer().getServerPublicY().isEmpty()) {
+                /** Get point values */
+                byte[] publicX = Hex.decodeHex(this.context.getCtxServer().getServerPublicX().toCharArray());
+                byte[] publicY = Hex.decodeHex(this.context.getCtxServer().getServerPublicY().toCharArray());
+                /** Create key specs */
+                KeySpec publicKeySpec = new ECPublicKeySpec(new ECPoint(new BigInteger(publicX), new BigInteger(publicY)),
+                        parameterSpec);
+                /** Get keys */
+                this.publicKey = KeyFactory.getInstance("EC").generatePublic(publicKeySpec);
+            }
+            if (this.context.getCtxServer().getServerPrivateS() != null && !this.context.getCtxServer().getServerPrivateS().isEmpty()) {
+                /** Get point values */
+                byte[] privateS = Hex.decodeHex(this.context.getCtxServer().getServerPrivateS().toCharArray());
+                /** Create key specs */
+                KeySpec privateKeySpec = new ECPrivateKeySpec(new BigInteger(privateS), parameterSpec);
+                /** Get keys */
+                this.privateKey = KeyFactory.getInstance("EC").generatePrivate(privateKeySpec);
+            }
+        } catch (GeneralSecurityException | IllegalArgumentException e) {
+            log.error("[{}] Failed generate Server PSK/RPK", e.getMessage());
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void infoParamsPSK() {
+        log.info("\nServer uses PSK -> private key : \n security key : [{}] \n serverSecureURI : [{}]",
+                Hex.encodeHexString(this.privateKey.getEncoded()),
+                this.context.getCtxServer().getServerSecureHost() + ":" + Integer.toString(this.context.getCtxServer().getServerPortPsk()));
+    }
+
+    private void infoParamsRPK() {
+        if (this.publicKey instanceof ECPublicKey) {
+            /** Get x coordinate */
+            byte[] x = ((ECPublicKey) this.publicKey).getW().getAffineX().toByteArray();
+            if (x[0] == 0)
+                x = Arrays.copyOfRange(x, 1, x.length);
+
+            /** Get Y coordinate */
+            byte[] y = ((ECPublicKey) this.publicKey).getW().getAffineY().toByteArray();
+            if (y[0] == 0)
+                y = Arrays.copyOfRange(y, 1, y.length);
+
+            /** Get Curves params */
+            String params = ((ECPublicKey) this.publicKey).getParams().toString();
+            log.info(
+                    " \nServer uses RPK : \n Elliptic Curve parameters  : [{}] \n Public x coord : [{}] \n Public y coord : [{}] \n Public Key (Hex): [{}] \n Private Key (Hex): [{}]",
+                    params, Hex.encodeHexString(x), Hex.encodeHexString(y),
+                    Hex.encodeHexString(this.publicKey.getEncoded()),
+                    Hex.encodeHexString(this.privateKey.getEncoded()));
+        } else {
+            throw new IllegalStateException("Unsupported Public Key Format (only ECPublicKey supported).");
+        }
+    }
+
+
+    private void setServerWithX509Cert(LeshanServerBuilder builder) {
+        try {
+            if (this.context.getCtxServer().getKeyStoreValue() != null) {
+                setBuilderX509(builder);
+                X509Certificate rootCAX509Cert = (X509Certificate) this.context.getCtxServer().getKeyStoreValue().getCertificate(this.context.getCtxServer().getRootAlias());
+                if (rootCAX509Cert != null) {
+                    X509Certificate[] trustedCertificates = new X509Certificate[1];
+                    trustedCertificates[0] = rootCAX509Cert;
+                    builder.setTrustedCertificates(trustedCertificates);
+                } else {
+                    /** by default trust all */
+                    builder.setTrustedCertificates(new X509Certificate[0]);
+                }
+            } else {
+                /** by default trust all */
+                builder.setTrustedCertificates(new X509Certificate[0]);
+                log.error("Unable to load X509 files for LWM2MServer");
+            }
+        } catch (KeyStoreException ex) {
+            log.error("[{}] Unable to load X509 files server", ex.getMessage());
+        }
+    }
+
+    private void setBuilderX509(LeshanServerBuilder builder) {
+        /**
+         * For deb => KeyStorePathFile == yml or commandline: KEY_STORE_PATH_FILE
+         * For idea => KeyStorePathResource == common/transport/lwm2m/src/main/resources/credentials: in LwM2MTransportContextServer: credentials/serverKeyStore.jks
+         */
+        try {
+            X509Certificate serverCertificate = (X509Certificate) this.context.getCtxServer().getKeyStoreValue().getCertificate(this.context.getCtxServer().getServerAlias());
+            PrivateKey privateKey = (PrivateKey) this.context.getCtxServer().getKeyStoreValue().getKey(this.context.getCtxServer().getServerAlias(), this.context.getCtxServer().getKeyStorePasswordServer() == null ? null : this.context.getCtxServer().getKeyStorePasswordServer().toCharArray());
+            builder.setPrivateKey(privateKey);
+            builder.setCertificateChain(new X509Certificate[]{serverCertificate});
+            this.infoParamsX509(serverCertificate, privateKey);
+        } catch (Exception ex) {
+            log.error("[{}] Unable to load KeyStore  files server", ex.getMessage());
+        }
+//        /**
+//         * For deb => KeyStorePathFile == yml or commandline: KEY_STORE_PATH_FILE
+//         * For idea => KeyStorePathResource == common/transport/lwm2m/src/main/resources/credentials: in LwM2MTransportContextServer: credentials/serverKeyStore.jks
+//         */
+//        try {
+//            X509Certificate serverCertificate = (X509Certificate) this.context.getCtxServer().getKeyStoreValue().getCertificate(this.context.getCtxServer().getServerPrivateS());
+//            this.privateKey = (PrivateKey) this.context.getCtxServer().getKeyStoreValue().getKey(this.context.getCtxServer().getServerAlias(), this.context.getCtxServer().getKeyStorePasswordServer() == null ? null : this.context.getCtxServer().getKeyStorePasswordServer().toCharArray());
+//            if (this.privateKey != null && this.privateKey.getEncoded().length > 0) {
+//                builder.setPrivateKey(this.privateKey);
+//            }
+//            if (serverCertificate != null) {
+//                builder.setCertificateChain(new X509Certificate[]{serverCertificate});
+//                this.infoParamsX509(serverCertificate);
+//            }
+//        } catch (Exception ex) {
+//            log.error("[{}] Unable to load KeyStore  files server", ex.getMessage());
+//        }
+    }
+
+    private void infoParamsX509(X509Certificate certificate, PrivateKey privateKey) {
+        try {
+            log.info("Server uses X509 : \n X509 Certificate (Hex): [{}] \n Private Key (Hex): [{}]",
+                    Hex.encodeHexString(certificate.getEncoded()),
+                    Hex.encodeHexString(privateKey.getEncoded()));
+        } catch (CertificateEncodingException e) {
+            log.error("", e);
+        }
+    }
 }
 }

@@ -20,24 +20,32 @@ import org.eclipse.leshan.server.californium.LeshanServer;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
-import org.springframework.stereotype.Service;
+import org.springframework.stereotype.Component;
 import org.thingsboard.server.transport.lwm2m.secure.LWM2MGenerationPSkRPkECC;
 import org.thingsboard.server.transport.lwm2m.secure.LWM2MGenerationPSkRPkECC;
-import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
+
 import javax.annotation.PostConstruct;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.annotation.PreDestroy;
 
 
 @Slf4j
 @Slf4j
-@Service("LwM2MTransportServerInitializer")
+@Component("LwM2MTransportServerInitializer")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
 public class LwM2MTransportServerInitializer {
 public class LwM2MTransportServerInitializer {
 
 
-    @Autowired
-    @Qualifier("LeshanServerCert")
-    private LeshanServer lhServerCert;
 
 
     @Autowired
     @Autowired
-    @Qualifier("leshanServerNoSecPskRpk")
-    private LeshanServer lhServerNoSecPskRpk;
+    private LwM2MTransportServiceImpl service;
+
+    @Autowired(required = false)
+    @Qualifier("leshanServerX509")
+    private LeshanServer lhServerX509;
+
+    @Autowired(required = false)
+    @Qualifier("leshanServerPsk")
+    private LeshanServer lhServerPsk;
+
+    @Autowired(required = false)
+    @Qualifier("leshanServerRpk")
+    private LeshanServer lhServerRpk;
 
 
     @Autowired
     @Autowired
     private LwM2MTransportContextServer context;
     private LwM2MTransportContextServer context;
@@ -45,28 +53,47 @@ public class LwM2MTransportServerInitializer {
     @PostConstruct
     @PostConstruct
     public void init() {
     public void init() {
         if (this.context.getCtxServer().getEnableGenPskRpk()) new LWM2MGenerationPSkRPkECC();
         if (this.context.getCtxServer().getEnableGenPskRpk()) new LWM2MGenerationPSkRPkECC();
-        if (this.context.getCtxServer().isServerStartAll()) {
-            this.lhServerCert.start();
-            this.lhServerNoSecPskRpk.start();
+        if (this.context.getCtxServer().isServerStartPsk()) {
+            this.startLhServerPsk();
+        }
+        if (this.context.getCtxServer().isServerStartRpk()) {
+            this.startLhServerRpk();
         }
         }
-        else {
-            if (this.context.getCtxServer().getServerDtlsMode() == LwM2MSecurityMode.X509.code) {
-                this.lhServerCert.start();
-            }
-            else {
-                this.lhServerNoSecPskRpk.start();
-            }
+        if (this.context.getCtxServer().isServerStartX509()) {
+            this.startLhServerX509();
         }
         }
     }
     }
 
 
+    private void startLhServerPsk() {
+        this.lhServerPsk.start();
+        LwM2mServerListener lhServerPskListener = new LwM2mServerListener(this.lhServerPsk, service);
+        this.lhServerPsk.getRegistrationService().addListener(lhServerPskListener.registrationListener);
+        this.lhServerPsk.getPresenceService().addListener(lhServerPskListener.presenceListener);
+        this.lhServerPsk.getObservationService().addListener(lhServerPskListener.observationListener);
+    }
+
+    private void startLhServerRpk() {
+        this.lhServerRpk.start();
+        LwM2mServerListener lhServerRpkListener = new LwM2mServerListener(this.lhServerRpk, service);
+        this.lhServerRpk.getRegistrationService().addListener(lhServerRpkListener.registrationListener);
+        this.lhServerRpk.getPresenceService().addListener(lhServerRpkListener.presenceListener);
+        this.lhServerRpk.getObservationService().addListener(lhServerRpkListener.observationListener);
+    }
+
+    private void startLhServerX509() {
+        this.lhServerX509.start();
+        LwM2mServerListener lhServerCertListener = new LwM2mServerListener(this.lhServerX509, service);
+        this.lhServerX509.getRegistrationService().addListener(lhServerCertListener.registrationListener);
+        this.lhServerX509.getPresenceService().addListener(lhServerCertListener.presenceListener);
+        this.lhServerX509.getObservationService().addListener(lhServerCertListener.observationListener);
+    }
+
     @PreDestroy
     @PreDestroy
     public void shutdown() {
     public void shutdown() {
         log.info("Stopping LwM2M transport Server!");
         log.info("Stopping LwM2M transport Server!");
-        try {
-            lhServerCert.destroy();
-            lhServerNoSecPskRpk.destroy();
-        } finally {
-        }
+        lhServerPsk.destroy();
+        lhServerRpk.destroy();
+        lhServerX509.destroy();
         log.info("LwM2M transport Server stopped!");
         log.info("LwM2M transport Server stopped!");
     }
     }
 }
 }

@@ -15,985 +15,42 @@
  */
  */
 package org.thingsboard.server.transport.lwm2m.server;
 package org.thingsboard.server.transport.lwm2m.server;
 
 
-import com.google.gson.*;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-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.LwM2mObjectInstance;
-import org.eclipse.leshan.core.node.LwM2mSingleResource;
-import org.eclipse.leshan.core.node.LwM2mResource;
-import org.eclipse.leshan.core.node.LwM2mPath;
 import org.eclipse.leshan.core.observation.Observation;
 import org.eclipse.leshan.core.observation.Observation;
-import org.eclipse.leshan.core.request.ContentFormat;
-import org.eclipse.leshan.core.request.WriteRequest;
 import org.eclipse.leshan.core.response.ReadResponse;
 import org.eclipse.leshan.core.response.ReadResponse;
-import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.registration.Registration;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
-import org.springframework.stereotype.Service;
 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.transport.TransportService;
-import org.thingsboard.server.common.transport.TransportServiceCallback;
-import org.thingsboard.server.common.transport.adaptor.AdaptorException;
-import org.thingsboard.server.common.transport.adaptor.JsonConverter;
-import org.thingsboard.server.common.transport.service.DefaultTransportService;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.gen.transport.TransportProtos.ToTransportUpdateCredentialsProto;
-import org.thingsboard.server.gen.transport.TransportProtos.SessionEvent;
-import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
-import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.PostTelemetryMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.PostAttributeMsg;
-import org.thingsboard.server.transport.lwm2m.server.adaptors.LwM2MJsonAdaptor;
-import org.thingsboard.server.transport.lwm2m.server.client.AttrTelemetryObserveValue;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
-import org.thingsboard.server.transport.lwm2m.server.client.ModelObject;
-import org.thingsboard.server.transport.lwm2m.server.client.ResultsAnalyzerParameters;
-import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
-import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
 
 
-import javax.annotation.PostConstruct;
 import java.util.Collection;
 import java.util.Collection;
-import java.util.UUID;
-import java.util.Random;
-import java.util.Map;
-import java.util.HashMap;
-import java.util.Arrays;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.NoSuchElementException;
 import java.util.Optional;
 import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 
-import static org.eclipse.leshan.core.model.ResourceModel.Type.OPAQUE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.*;
+public interface LwM2MTransportService {
 
 
-@Slf4j
-@Service("LwM2MTransportService")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportService {
+    void onRegistered(LeshanServer lwServer, Registration registration, Collection<Observation> previousObsersations);
 
 
-    @Autowired
-    private LwM2MJsonAdaptor adaptor;
+    void updatedReg(LeshanServer lwServer, Registration registration);
 
 
-    @Autowired
-    private TransportService transportService;
+    void unReg(LeshanServer lwServer, Registration registration, Collection<Observation> observations);
 
 
-    @Autowired
-    public LwM2MTransportContextServer context;
+    void onSleepingDev(Registration registration);
 
 
-    @Autowired
-    private LwM2MTransportRequest lwM2MTransportRequest;
+    void setCancelObservations(LeshanServer lwServer, Registration registration);
 
 
-    @Autowired
-    LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
+    void setCancelObservationRecourse(LeshanServer lwServer, Registration registration, String path);
 
 
+    void onObservationResponse(Registration registration, String path, ReadResponse response);
 
 
-    @PostConstruct
-    public void init() {
-        context.getScheduler().scheduleAtFixedRate(() -> checkInactivityAndReportActivity(), new Random().nextInt((int) context.getCtxServer().getSessionReportTimeout()), context.getCtxServer().getSessionReportTimeout(), TimeUnit.MILLISECONDS);
-    }
+    void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg msg, TransportProtos.SessionInfoProto sessionInfo);
 
 
-    /**
-     * 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 lwServer             - LeshanServer
-     * @param registration         - Registration LwM2M Client
-     * @param previousObsersations - may be null
-     */
-    public void onRegistered(LeshanServer lwServer, Registration registration, Collection<Observation> previousObsersations) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getlwM2MClient(lwServer, registration);
-        if (lwM2MClient != null) {
-            lwM2MClient.setLwM2MTransportService(this);
-            lwM2MClient.setLwM2MTransportService(this);
-            lwM2MClient.setSessionUuid(UUID.randomUUID());
-            this.setLwM2MClient(lwServer, registration, lwM2MClient);
-            SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration.getId());
-            if (sessionInfo != null) {
-                lwM2MClient.setDeviceUuid(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB()));
-                lwM2MClient.setProfileUuid(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
-                lwM2MClient.setDeviceName(sessionInfo.getDeviceName());
-                lwM2MClient.setDeviceProfileName(sessionInfo.getDeviceType());
-                transportService.registerAsyncSession(sessionInfo, new LwM2MSessionMsgListener(this, sessionInfo));
-                transportService.process(sessionInfo, DefaultTransportService.getSessionEventMsg(SessionEvent.OPEN), null);
-                transportService.process(sessionInfo, TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().build(), null);
-                this.sentLogsToThingsboard(LOG_LW2M_INFO + ": Client registration", registration.getId());
-            } else {
-                log.error("Client: [{}] onRegistered [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), sessionInfo);
-            }
-        } else {
-            log.error("Client: [{}] onRegistered [{}] name  [{}] lwM2MClient ", registration.getId(), registration.getEndpoint(), lwM2MClient);
-        }
-    }
+    void onDeviceProfileUpdate(TransportProtos.SessionInfoProto sessionInfo, DeviceProfile deviceProfile);
 
 
-    /**
-     * @param lwServer     - LeshanServer
-     * @param registration - Registration LwM2M Client
-     */
-    public void updatedReg(LeshanServer lwServer, Registration registration) {
-        SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration.getId());
-        if (sessionInfo != null) {
-            log.info("Client: [{}] updatedReg [{}] name  [{}] profile ", registration.getId(), registration.getEndpoint(), sessionInfo.getDeviceType());
-        } else {
-            log.error("Client: [{}] updatedReg [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), sessionInfo);
-        }
-    }
+    void onDeviceUpdate(TransportProtos.SessionInfoProto sessionInfo, Device device, Optional<DeviceProfile> deviceProfileOpt);
 
 
-    /**
-     * @param registration - Registration LwM2M Client
-     * @param observations - All paths observations before unReg
-     *                     !!! 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) {
-        this.sentLogsToThingsboard(LOG_LW2M_INFO + ": Client unRegistration", registration.getId());
-        this.closeClientSession(registration);
-    }
+    void doTrigger(LeshanServer lwServer, Registration registration, String path);
 
 
-    private void closeClientSession(Registration registration) {
-        SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration.getId());
-        if (sessionInfo != null) {
-            transportService.deregisterSession(sessionInfo);
-            this.doCloseSession(sessionInfo);
-            lwM2mInMemorySecurityStore.delRemoveSessionAndListener(registration.getId());
-            if (lwM2mInMemorySecurityStore.getProfiles().size() > 0) {
-                this.syncSessionsAndProfiles();
-            }
-            log.info("Client: [{}] unReg [{}] name  [{}] profile ", registration.getId(), registration.getEndpoint(), sessionInfo.getDeviceType());
-        } else {
-            log.error("Client: [{}] unReg [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), sessionInfo);
-        }
-    }
+    void doDisconnect(TransportProtos.SessionInfoProto sessionInfo);
 
 
-    public void onSleepingDev(Registration registration) {
-        log.info("[{}] [{}] Received endpoint Sleeping version event", registration.getId(), registration.getEndpoint());
-        //TODO: associate endpointId with device information.
-    }
-
-    /**
-     * 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
-     */
-
-    public void onAwakeDev(Registration registration) {
-        log.info("[{}] [{}] Received endpoint Awake version event", registration.getId(), registration.getEndpoint());
-        //TODO: associate endpointId with device information.
-    }
-
-    /**
-     * This method is used to sync with sessions
-     * Removes a profile if not used in sessions
-     */
-    private void syncSessionsAndProfiles() {
-        Map<UUID, AttrTelemetryObserveValue> profilesClone = lwM2mInMemorySecurityStore.getProfiles().entrySet()
-                .stream()
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-        profilesClone.forEach((k, v) -> {
-            String registrationId = lwM2mInMemorySecurityStore.getSessions().entrySet()
-                    .stream()
-                    .filter(e -> e.getValue().getProfileUuid().equals(k))
-                    .findFirst()
-                    .map(Map.Entry::getKey) // return the key of the matching entry if found
-                    .orElse("");
-            if (registrationId.isEmpty()) {
-                lwM2mInMemorySecurityStore.getProfiles().remove(k);
-            }
-        });
-    }
-
-    /**
-     * Create new LwM2MClient for current session -> setModelClient...
-     * #1   Add all ObjectLinks (instance) to control the process of executing requests to the client
-     * to get the client model with current values
-     * #2   Get the client model with current values. Analyze the response in -> lwM2MTransportRequest.sendResponse
-     *
-     * @param lwServer     - LeshanServer
-     * @param registration - Registration LwM2M Client
-     * @param lwM2MClient  - object with All parameters off client
-     */
-    private void setLwM2MClient(LeshanServer lwServer, Registration registration, LwM2MClient lwM2MClient) {
-        // #1
-        Arrays.stream(registration.getObjectLinks()).forEach(url -> {
-            ResultIds pathIds = new ResultIds(url.getUrl());
-            if (pathIds.instanceId > -1 && pathIds.resourceId == -1) {
-                lwM2MClient.getPendingRequests().add(url.getUrl());
-            }
-        });
-        // #2
-        Arrays.stream(registration.getObjectLinks()).forEach(url -> {
-            ResultIds pathIds = new ResultIds(url.getUrl());
-            if (pathIds.instanceId > -1 && pathIds.resourceId == -1) {
-                lwM2MTransportRequest.sendAllRequest(lwServer, registration, url.getUrl(), GET_TYPE_OPER_READ,
-                        ContentFormat.TLV.getName(), lwM2MClient, null, null, this.context.getCtxServer().getTimeout());
-            }
-        });
-    }
-
-    /**
-     * @param registrationId - Id of Registration LwM2M Client
-     * @return - sessionInfo after access connect client
-     */
-    private SessionInfoProto getValidateSessionInfo(String registrationId) {
-        SessionInfoProto sessionInfo = null;
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getlwM2MClient(registrationId);
-        if (lwM2MClient != null) {
-            ValidateDeviceCredentialsResponseMsg msg = lwM2MClient.getCredentialsResponse();
-            if (msg == null || msg.getDeviceInfo() == null) {
-                log.error("[{}] [{}]", lwM2MClient.getEndPoint(), CLIENT_NOT_AUTHORIZED);
-                this.closeClientSession(lwM2MClient.getRegistration());
-            } else {
-                sessionInfo = SessionInfoProto.newBuilder()
-                        .setNodeId(this.context.getNodeId())
-                        .setSessionIdMSB(lwM2MClient.getSessionUuid().getMostSignificantBits())
-                        .setSessionIdLSB(lwM2MClient.getSessionUuid().getLeastSignificantBits())
-                        .setDeviceIdMSB(msg.getDeviceInfo().getDeviceIdMSB())
-                        .setDeviceIdLSB(msg.getDeviceInfo().getDeviceIdLSB())
-                        .setTenantIdMSB(msg.getDeviceInfo().getTenantIdMSB())
-                        .setTenantIdLSB(msg.getDeviceInfo().getTenantIdLSB())
-                        .setDeviceName(msg.getDeviceInfo().getDeviceName())
-                        .setDeviceType(msg.getDeviceInfo().getDeviceType())
-                        .setDeviceProfileIdLSB(msg.getDeviceInfo().getDeviceProfileIdLSB())
-                        .setDeviceProfileIdMSB(msg.getDeviceInfo().getDeviceProfileIdMSB())
-                        .build();
-            }
-        }
-        return sessionInfo;
-    }
-
-    /**
-     * Add attribute/telemetry information from Client and credentials/Profile to client model and start observe
-     * !!! if the resource has an observation, but no telemetry or attribute - the observation will not use
-     * #1 Client`s starting info  to  send to thingsboard
-     * #2 Sending Attribute Telemetry with value to thingsboard only once at the start of the connection
-     * #3 Start observe
-     *
-     * @param lwServer     - LeshanServer
-     * @param registration - Registration LwM2M Client
-     */
-
-    public void updatesAndSentModelParameter(LeshanServer lwServer, Registration registration) {
-        // #1
-//        this.setParametersToModelClient(registration, modelClient, deviceProfile);
-        // #2
-        this.updateAttrTelemetry(registration, true, null);
-        // #3
-        this.onSentObserveToClient(lwServer, registration);
-    }
-
-
-    /**
-     * Sent Attribute and Telemetry to Thingsboard
-     * #1 - get AttrName/TelemetryName with value:
-     * #1.1 from Client
-     * #1.2 from LwM2MClient:
-     * -- resourceId == path from AttrTelemetryObserveValue.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, boolean start, Set<String> paths) {
-        JsonObject attributes = new JsonObject();
-        JsonObject telemetrys = new JsonObject();
-        if (start) {
-            // #1.1
-            JsonObject attributeClient = this.getAttributeClient(registration);
-            if (attributeClient != null) {
-                attributeClient.entrySet().forEach(p -> {
-                    attributes.add(p.getKey(), p.getValue());
-                });
-            }
-        }
-        // #1.2
-        CountDownLatch cancelLatch = new CountDownLatch(1);
-        this.getParametersFromProfile(attributes, telemetrys, registration, paths);
-        cancelLatch.countDown();
-        try {
-            cancelLatch.await(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS);
-        } catch (InterruptedException e) {
-            log.error("[{}] updateAttrTelemetry", e.toString());
-        }
-        if (attributes.getAsJsonObject().entrySet().size() > 0)
-            this.updateParametersOnThingsboard(attributes, DEVICE_ATTRIBUTES_TOPIC, registration.getId());
-        if (telemetrys.getAsJsonObject().entrySet().size() > 0)
-            this.updateParametersOnThingsboard(telemetrys, DEVICE_TELEMETRY_TOPIC, registration.getId());
-    }
-
-    /**
-     * get AttrName/TelemetryName with value from Client
-     *
-     * @param registration -
-     * @return - JsonObject, format: {name: value}}
-     */
-    private JsonObject getAttributeClient(Registration registration) {
-        if (registration.getAdditionalRegistrationAttributes().size() > 0) {
-            JsonObject resNameValues = new JsonObject();
-            registration.getAdditionalRegistrationAttributes().entrySet().forEach(entry -> {
-                resNameValues.addProperty(entry.getKey(), entry.getValue());
-            });
-            return resNameValues;
-        }
-        return null;
-    }
-
-    /**
-     * @param attributes   - new JsonObject
-     * @param telemetry    - new JsonObject
-     * @param registration - Registration LwM2M Client
-     *                     result: add to JsonObject those resources to which the user is subscribed and they have a value
-     *                     if path==null add All resources else only one
-     *                     (attributes/telemetry): new {name(Attr/Telemetry):value}
-     */
-    private void getParametersFromProfile(JsonObject attributes, JsonObject telemetry, Registration registration, Set<String> path) {
-        AttrTelemetryObserveValue attrTelemetryObserveValue = lwM2mInMemorySecurityStore.getProfiles().get(lwM2mInMemorySecurityStore.getSessions().get(registration.getId()).getProfileUuid());
-        attrTelemetryObserveValue.getPostAttributeProfile().forEach(p -> {
-            ResultIds pathIds = new ResultIds(p.getAsString().toString());
-            if (pathIds.getResourceId() > -1) {
-                if (path == null || path.contains(p.getAsString())) {
-                    this.addParameters(pathIds, p.getAsString().toString(), attributes, registration);
-                }
-            }
-        });
-        attrTelemetryObserveValue.getPostTelemetryProfile().forEach(p -> {
-            ResultIds pathIds = new ResultIds(p.getAsString().toString());
-            if (pathIds.getResourceId() > -1) {
-                if (path == null || path.contains(p.getAsString())) {
-                    this.addParameters(pathIds, p.getAsString().toString(), telemetry, registration);
-                }
-            }
-        });
-    }
-
-    /**
-     * @param pathIds      - path resource
-     * @param parameters   - JsonObject attributes/telemetry
-     * @param registration - Registration LwM2M Client
-     */
-    private void addParameters(ResultIds pathIds, String path, JsonObject parameters, Registration registration) {
-        ModelObject modelObject = lwM2mInMemorySecurityStore.getSessions().get(registration.getId()).getModelObjects().get(pathIds.getObjectId());
-        JsonObject names = lwM2mInMemorySecurityStore.getProfiles().get(lwM2mInMemorySecurityStore.getSessions().get(registration.getId()).getProfileUuid()).getPostKeyNameProfile();
-        String resName = String.valueOf(names.get(path));
-        if (modelObject != null && resName != null && !resName.isEmpty()) {
-            String resValue = this.getResourceValue(modelObject, pathIds);
-            if (resValue != null) {
-                parameters.addProperty(resName, resValue);
-            }
-        }
-    }
-
-    /**
-     * @param modelObject - ModelObject of Client
-     * @param pathIds     - path resource
-     * @return - value of Resource or null
-     */
-    private String getResourceValue(ModelObject modelObject, ResultIds pathIds) {
-        String resValue = null;
-        if (modelObject.getInstances().get(pathIds.getInstanceId()) != null) {
-            LwM2mObjectInstance instance = modelObject.getInstances().get(pathIds.getInstanceId());
-            if (instance.getResource(pathIds.getResourceId()) != null) {
-                resValue = instance.getResource(pathIds.getResourceId()).getType() == OPAQUE ?
-                        Hex.encodeHexString((byte[]) instance.getResource(pathIds.getResourceId()).getValue()).toLowerCase() :
-                        (instance.getResource(pathIds.getResourceId()).isMultiInstances()) ?
-                                instance.getResource(pathIds.getResourceId()).getValues().toString() :
-                                instance.getResource(pathIds.getResourceId()).getValue().toString();
-            }
-        }
-        return resValue;
-    }
-
-    /**
-     * Prepare Sent to Thigsboard callback - Attribute or Telemetry
-     *
-     * @param msg            - JsonArray: [{name: value}]
-     * @param topicName      - Api Attribute or Telemetry
-     * @param registrationId - Id of Registration LwM2M Client
-     */
-    public void updateParametersOnThingsboard(JsonElement msg, String topicName, String registrationId) {
-        SessionInfoProto sessionInfo = this.getValidateSessionInfo(registrationId);
-        if (sessionInfo != null) {
-            try {
-                if (topicName.equals(LwM2MTransportHandler.DEVICE_ATTRIBUTES_TOPIC)) {
-                    PostAttributeMsg postAttributeMsg = adaptor.convertToPostAttributes(msg);
-                    TransportServiceCallback call = this.getPubAckCallbackSentAttrTelemetry(-1, postAttributeMsg);
-                    transportService.process(sessionInfo, postAttributeMsg, call);
-                } else if (topicName.equals(LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC)) {
-                    PostTelemetryMsg postTelemetryMsg = adaptor.convertToPostTelemetry(msg);
-                    TransportServiceCallback call = this.getPubAckCallbackSentAttrTelemetry(-1, postTelemetryMsg);
-                    transportService.process(sessionInfo, postTelemetryMsg, this.getPubAckCallbackSentAttrTelemetry(-1, call));
-                }
-            } catch (AdaptorException e) {
-                log.error("[{}] Failed to process publish msg [{}]", topicName, e);
-                log.info("[{}] Closing current session due to invalid publish", topicName);
-            }
-        } else {
-            log.error("Client: [{}] updateParametersOnThingsboard [{}] sessionInfo ", registrationId, sessionInfo);
-        }
-    }
-
-    /**
-     * Sent to Thingsboard Attribute || Telemetry
-     *
-     * @param msgId - always == -1
-     * @param msg   - JsonObject: [{name: value}]
-     * @return - dummy
-     */
-    private <T> TransportServiceCallback<Void> getPubAckCallbackSentAttrTelemetry(final int msgId, final T msg) {
-        return new TransportServiceCallback<Void>() {
-            @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);
-            }
-        };
-    }
-
-
-    /**
-     * Start observe
-     * #1 - Analyze:
-     * #1.1 path in observe == (attribute or telemetry)
-     * #1.2 recourseValue notNull
-     * #2 Analyze after sent request (response):
-     * #2.1 First: lwM2MTransportRequest.sendResponse -> ObservationListener.newObservation
-     * #2.2 Next: ObservationListener.onResponse     *
-     *
-     * @param lwServer     - LeshanServer
-     * @param registration - Registration LwM2M Client
-     */
-    private void onSentObserveToClient(LeshanServer lwServer, Registration registration) {
-        if (lwServer.getObservationService().getObservations(registration).size() > 0) {
-            this.setCancelObservations(lwServer, registration);
-        }
-        UUID profileUUid = lwM2mInMemorySecurityStore.getSessions().get(registration.getId()).getProfileUuid();
-        AttrTelemetryObserveValue attrTelemetryObserveValue = lwM2mInMemorySecurityStore.getProfiles().get(profileUUid);
-        attrTelemetryObserveValue.getPostObserveProfile().forEach(p -> {
-            // #1.1
-            String target = (getValidateObserve(attrTelemetryObserveValue.getPostAttributeProfile(), p.getAsString().toString())) ?
-                    p.getAsString().toString() : (getValidateObserve(attrTelemetryObserveValue.getPostTelemetryProfile(), p.getAsString().toString())) ?
-                    p.getAsString().toString() : null;
-            if (target != null) {
-                // #1.2
-                ResultIds pathIds = new ResultIds(target);
-                ModelObject modelObject = lwM2mInMemorySecurityStore.getSessions().get(registration.getId()).getModelObjects().get(pathIds.getObjectId());
-                // #2
-                if (modelObject != null) {
-                    if (getResourceValue(modelObject, pathIds) != null) {
-                        lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, GET_TYPE_OPER_OBSERVE,
-                                null, null, null, null, this.context.getCtxServer().getTimeout());
-                    }
-                }
-            }
-        });
-    }
-
-    public void setCancelObservations(LeshanServer lwServer, Registration registration) {
-        if (registration != null) {
-            Set<Observation> observations = lwServer.getObservationService().getObservations(registration);
-            observations.forEach(observation -> {
-                this.setCancelObservationRecourse(lwServer, registration, observation.getPath().toString());
-            });
-        }
-    }
-
-    /**
-     * lwM2MTransportRequest.sendAllRequest(lwServer, registration, path, POST_TYPE_OPER_OBSERVE_CANCEL, null, null, null, null, context.getTimeout());
-     * At server side this will not remove the observation from the observation store, to do it you need to use
-     * {@code ObservationService#cancelObservation()}
-     */
-    public void setCancelObservationRecourse(LeshanServer lwServer, Registration registration, String path) {
-        CountDownLatch cancelLatch = new CountDownLatch(1);
-        lwServer.getObservationService().cancelObservations(registration, path);
-        cancelLatch.countDown();
-        try {
-            cancelLatch.await(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS);
-        } catch (InterruptedException e) {
-        }
-    }
-
-    /**
-     * @param parameters - JsonArray postAttributeProfile/postTelemetryProfile
-     * @param path       - recourse from postObserveProfile
-     * @return rez - true if path observe is in attribute/telemetry
-     */
-    private boolean getValidateObserve(JsonElement parameters, String path) {
-        AtomicBoolean rez = new AtomicBoolean(false);
-        if (parameters.isJsonArray()) {
-            parameters.getAsJsonArray().forEach(p -> {
-                        if (p.getAsString().toString().equals(path)) rez.set(true);
-                    }
-            );
-        } else if (parameters.isJsonObject()) {
-            rez.set((parameters.getAsJsonObject().entrySet()).stream().map(json -> json.toString())
-                    .filter(path::equals).findAny().orElse(null) != null);
-        }
-        return rez.get();
-    }
-
-    /**
-     * Sending observe value to thingsboard from ObservationListener.onResponse: object, instance, SingleResource or MultipleResource
-     *
-     * @param registration - Registration LwM2M Client
-     * @param path         - observe
-     * @param response     - observe
-     */
-    @SneakyThrows
-    public void onObservationResponse(Registration registration, String path, ReadResponse response) {
-        if (response.getContent() != null) {
-            if (response.getContent() instanceof LwM2mObject) {
-                LwM2mObject content = (LwM2mObject) response.getContent();
-                String target = "/" + content.getId();
-            } else if (response.getContent() instanceof LwM2mObjectInstance) {
-                LwM2mObjectInstance content = (LwM2mObjectInstance) response.getContent();
-            } else if (response.getContent() instanceof LwM2mSingleResource) {
-                LwM2mSingleResource content = (LwM2mSingleResource) response.getContent();
-                this.onObservationSetResourcesValue(registration, content.getValue(), null, path);
-            } else if (response.getContent() instanceof LwM2mMultipleResource) {
-                LwM2mSingleResource content = (LwM2mSingleResource) response.getContent();
-                this.onObservationSetResourcesValue(registration, null, content.getValues(), path);
-            }
-        }
-    }
-
-    /**
-     * Sending observe value of resources to thingsboard
-     * #1 Return old Resource from ModelObject
-     * #2 Create new Resource with value from observation
-     * #3 Create new Resources from old Resources
-     * #4 Update new Resources (replace old Resource on new Resource)
-     * #5 Remove old Instance from modelClient
-     * #6 Create new Instance with new Resources values
-     * #7 Update modelClient.getModelObjects(idObject) (replace old Instance on new Instance)
-     *
-     * @param registration - Registration LwM2M Client
-     * @param value        - LwM2mSingleResource response.getContent()
-     * @param values       - LwM2mSingleResource response.getContent()
-     * @param path         - resource
-     */
-    private void onObservationSetResourcesValue(Registration registration, Object value, Map<Integer, ?> values, String path) {
-        ResultIds resultIds = new ResultIds(path);
-        // #1
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getlwM2MClient(registration.getId());
-        ModelObject modelObject = lwM2MClient.getModelObjects().get(resultIds.getObjectId());
-        Map<Integer, LwM2mObjectInstance> instancesModelObject = modelObject.getInstances();
-        LwM2mObjectInstance instanceOld = (instancesModelObject.get(resultIds.instanceId) != null) ? instancesModelObject.get(resultIds.instanceId) : null;
-        Map<Integer, LwM2mResource> resourcesOld = (instanceOld != null) ? instanceOld.getResources() : null;
-        LwM2mResource resourceOld = (resourcesOld != null && resourcesOld.get(resultIds.getResourceId()) != null) ? resourcesOld.get(resultIds.getResourceId()) : null;
-        // #2
-        LwM2mResource resourceNew;
-        if (resourceOld.isMultiInstances()) {
-            resourceNew = LwM2mMultipleResource.newResource(resultIds.getResourceId(), values, resourceOld.getType());
-        } else {
-            resourceNew = LwM2mSingleResource.newResource(resultIds.getResourceId(), value, resourceOld.getType());
-        }
-        //#3
-        Map<Integer, LwM2mResource> resourcesNew = new HashMap<>(resourcesOld);
-        // #4
-        resourcesNew.remove(resourceOld);
-        // #5
-        resourcesNew.put(resultIds.getResourceId(), resourceNew);
-        // #6
-        LwM2mObjectInstance instanceNew = new LwM2mObjectInstance(resultIds.instanceId, resourcesNew.values());
-        // #7
-        CountDownLatch respLatch = new CountDownLatch(1);
-        lwM2MClient.getModelObjects().get(resultIds.getObjectId()).removeInstance(resultIds.instanceId);
-        instancesModelObject.put(resultIds.instanceId, instanceNew);
-        respLatch.countDown();
-        try {
-            respLatch.await(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS);
-        } catch (InterruptedException ex) {
-        }
-        Set<String> paths = new HashSet<String>();
-        paths.add(path);
-        this.updateAttrTelemetry(registration, false, paths);
-    }
-
-    /**
-     * @param updateCredentials - Credentials include config only security Client (without config attr/telemetry...)
-     *                          config attr/telemetry... in profile
-     */
-    public void onToTransportUpdateCredentials(ToTransportUpdateCredentialsProto updateCredentials) {
-        log.info("[{}] idList [{}] valueList updateCredentials", updateCredentials.getCredentialsIdList(), updateCredentials.getCredentialsValueList());
-    }
-
-    /**
-     * Update - sent request in change value resources in Client (path to resources from profile by keyName)
-     * Only fo resources  W
-     * Delete - nothing
-     *
-     * @param msg         -
-     * @param sessionInfo -
-     */
-    public void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg msg, SessionInfoProto sessionInfo) {
-        if (msg.getSharedUpdatedCount() > 0) {
-            JsonElement el = JsonConverter.toJson(msg);
-            el.getAsJsonObject().entrySet().forEach(de -> {
-                String profilePath = lwM2mInMemorySecurityStore.getProfiles().get(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()))
-                        .getPostKeyNameProfile().getAsJsonObject().entrySet().stream()
-                        .filter(e -> e.getValue().getAsString().equals(de.getKey())).findFirst().map(Map.Entry::getKey)
-                        .orElse("");
-                String path = !profilePath.isEmpty() ? profilePath : this.getPathAttributeUpdate(sessionInfo, de.getKey());
-                if (path != null) {
-                    ResultIds resultIds = new ResultIds(path);
-                    LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSession(new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB())).entrySet().iterator().next().getValue();
-                    ResourceModel.Operations operations = lwM2MClient.getModelObjects().get(resultIds.getObjectId()).getObjectModel().resources.get(resultIds.getResourceId()).operations;
-                    String value = ((JsonPrimitive) de.getValue()).getAsString();
-                    if (operations.isWritable()) {
-                        lwM2MTransportRequest.sendAllRequest(lwM2MClient.getLwServer(), lwM2MClient.getRegistration(), path, POST_TYPE_OPER_WRITE_REPLACE,
-                                ContentFormat.TLV.getName(), lwM2MClient, null, value, this.context.getCtxServer().getTimeout());
-                        log.info("[{}] path onAttributeUpdate", path);
-                    }
-                    else {
-                        log.error(LOG_LW2M_ERROR + ": Resource path - [{}] value - [{}] is not Writable and cannot be updated", path, value);
-                        String logMsg = String.format(LOG_LW2M_ERROR + " attributeUpdate: Resource path - %s value - %s is not Writable and cannot be updated", path, value);
-                        this.sentLogsToThingsboard(logMsg, lwM2MClient.getRegistration().getId());
-                    }
-                }
-            });
-        } else if (msg.getSharedDeletedCount() > 0) {
-            log.info("[{}] delete [{}]  onAttributeUpdate", msg.getSharedDeletedList(), sessionInfo);
-        }
-    }
-
-    private String getPathAttributeUpdate(SessionInfoProto sessionInfo, String keyName) {
-        try {
-            LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSession(new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB())).entrySet().iterator().next().getValue();
-            Predicate<Map.Entry<Integer, ResourceModel>> predicateRes = res -> keyName.equals(splitCamelCaseString(res.getValue().name));
-            Predicate<Map.Entry<Integer, ModelObject>> predicateObj = (obj -> {
-                return obj.getValue().getObjectModel().resources.entrySet().stream().filter(predicateRes).findFirst().isPresent();
-            });
-            Stream<Map.Entry<Integer, ModelObject>> objectStream = lwM2MClient.getModelObjects().entrySet().stream().filter(predicateObj);
-            Predicate<Map.Entry<Integer, ResourceModel>> predicateResFinal = (objectStream.count() > 0) ? predicateRes : res -> keyName.equals(res.getValue().name);
-            Predicate<Map.Entry<Integer, ModelObject>> predicateObjFinal = (obj -> {
-                return obj.getValue().getObjectModel().resources.entrySet().stream().filter(predicateResFinal).findFirst().isPresent();
-            });
-            Map.Entry<Integer, ModelObject> object = lwM2MClient.getModelObjects().entrySet().stream().filter(predicateObjFinal).findFirst().get();
-            ModelObject modelObject = object.getValue();
-            LwM2mObjectInstance instance = modelObject.getInstances().entrySet().stream().findFirst().get().getValue();
-            ResourceModel resource = modelObject.getObjectModel().resources.entrySet().stream().filter(predicateResFinal).findFirst().get().getValue();
-            return new LwM2mPath(object.getKey(), instance.getId(), resource.id).toString();
-        } catch (NoSuchElementException e) {
-            log.error("[{}] keyName [{}]", keyName, e.toString());
-            return null;
-        }
-    }
-
-    public void onAttributeUpdateOk(Registration registration, String path, WriteRequest request) {
-        ResultIds resultIds = new ResultIds(path);
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getlwM2MClient(registration.getId());
-        LwM2mResource resource = lwM2MClient.getModelObjects().get(resultIds.getObjectId()).getInstances().get(resultIds.getInstanceId()).getResource(resultIds.getResourceId());
-        if (resource.isMultiInstances()) {
-            this.onObservationSetResourcesValue(registration, null, ((LwM2mSingleResource) request.getNode()).getValues(), path);
-        } else {
-            this.onObservationSetResourcesValue(registration, ((LwM2mSingleResource) request.getNode()).getValue(), null, path);
-        }
-    }
-
-    /**
-     * @param sessionInfo   -
-     * @param deviceProfile -
-     */
-    public void onDeviceProfileUpdate(TransportProtos.SessionInfoProto sessionInfo, DeviceProfile deviceProfile) {
-        String registrationId = lwM2mInMemorySecurityStore.getSessions().entrySet()
-                .stream()
-                .filter(e -> e.getValue().getDeviceUuid().equals(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB())))
-                .findFirst()
-                .map(Map.Entry::getKey)
-                .orElse("");
-        if (!registrationId.isEmpty()) {
-            this.onDeviceUpdateChangeProfile(registrationId, deviceProfile);
-        }
-    }
-
-    /**
-     * @param sessionInfo      -
-     * @param device           -
-     * @param deviceProfileOpt -
-     */
-    public void onDeviceUpdate(TransportProtos.SessionInfoProto sessionInfo, Device device, Optional<DeviceProfile> deviceProfileOpt) {
-        Optional<String> registrationIdOpt = lwM2mInMemorySecurityStore.getSessions().entrySet().stream()
-                .filter(e -> device.getUuidId().equals(e.getValue().getDeviceUuid()))
-                .map(Map.Entry::getKey)
-                .findFirst();
-        registrationIdOpt.ifPresent(registrationId -> this.onDeviceUpdateLwM2MClient(registrationId, device, deviceProfileOpt));
-    }
-
-    /**
-     * Update parameters device in LwM2MClient
-     * If new deviceProfile != old deviceProfile => update deviceProfile
-     *
-     * @param registrationId -
-     * @param device         -
-     */
-    private void onDeviceUpdateLwM2MClient(String registrationId, Device device, Optional<DeviceProfile> deviceProfileOpt) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSessions().get(registrationId);
-        lwM2MClient.setDeviceName(device.getName());
-        if (!lwM2MClient.getProfileUuid().equals(device.getDeviceProfileId().getId())) {
-            deviceProfileOpt.ifPresent(deviceProfile -> this.onDeviceUpdateChangeProfile(registrationId, deviceProfile));
-        }
-    }
-
-    /**
-     * #1 Read new, old Value (Attribute, Telemetry, Observe, KeyName)
-     * #2 Update in lwM2MClient: ...Profile
-     * #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)
-     * #4 update
-     * #4.1 add If #3 isChange, then analyze and update Value in Transport form Client and sent Value ti 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: sent Request observe to Client
-     * #5.3 Observe.del
-     * -- different between newObserve and oldObserve: sent Request cancel observe to client
-     *
-     * @param registrationId -
-     * @param deviceProfile  -
-     */
-    public void onDeviceUpdateChangeProfile(String registrationId, DeviceProfile deviceProfile) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getlwM2MClient(registrationId);
-        AttrTelemetryObserveValue attrTelemetryObserveValueOld = lwM2mInMemorySecurityStore.getProfiles().get(lwM2MClient.getProfileUuid());
-        if (lwM2mInMemorySecurityStore.addUpdateProfileParameters(deviceProfile)) {
-            LeshanServer lwServer = lwM2MClient.getLwServer();
-            Registration registration = lwM2mInMemorySecurityStore.getByRegistration(registrationId);
-            // #1
-            JsonArray attributeOld = attrTelemetryObserveValueOld.getPostAttributeProfile();
-            Set<String> attributeSetOld = new Gson().fromJson(attributeOld, Set.class);
-            JsonArray telemetryOld = attrTelemetryObserveValueOld.getPostTelemetryProfile();
-            Set<String> telemetrySetOld = new Gson().fromJson(telemetryOld, Set.class);
-            JsonArray observeOld = attrTelemetryObserveValueOld.getPostObserveProfile();
-            JsonObject keyNameOld = attrTelemetryObserveValueOld.getPostKeyNameProfile();
-
-            AttrTelemetryObserveValue attrTelemetryObserveValueNew = lwM2mInMemorySecurityStore.getProfiles().get(deviceProfile.getUuidId());
-            JsonArray attributeNew = attrTelemetryObserveValueNew.getPostAttributeProfile();
-            Set<String> attributeSetNew = new Gson().fromJson(attributeNew, Set.class);
-            JsonArray telemetryNew = attrTelemetryObserveValueNew.getPostTelemetryProfile();
-            Set<String> telemetrySetNew = new Gson().fromJson(telemetryNew, Set.class);
-            JsonArray observeNew = attrTelemetryObserveValueNew.getPostObserveProfile();
-            JsonObject keyNameNew = attrTelemetryObserveValueNew.getPostKeyNameProfile();
-            // #2
-            lwM2MClient.setDeviceProfileName(deviceProfile.getName());
-            lwM2MClient.setProfileUuid(deviceProfile.getUuidId());
-
-            // #3
-            ResultsAnalyzerParameters sentAttrToThingsboard = new ResultsAnalyzerParameters();
-            // #3.1
-            if (!attributeOld.equals(attributeNew)) {
-                ResultsAnalyzerParameters postAttributeAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(attributeOld, Set.class), attributeSetNew);
-                sentAttrToThingsboard.getPathPostParametersAdd().addAll(postAttributeAnalyzer.getPathPostParametersAdd());
-                sentAttrToThingsboard.getPathPostParametersDel().addAll(postAttributeAnalyzer.getPathPostParametersDel());
-            }
-            // #3.2
-            if (!attributeOld.equals(attributeNew)) {
-                ResultsAnalyzerParameters postTelemetryAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(telemetryOld, Set.class), telemetrySetNew);
-                sentAttrToThingsboard.getPathPostParametersAdd().addAll(postTelemetryAnalyzer.getPathPostParametersAdd());
-                sentAttrToThingsboard.getPathPostParametersDel().addAll(postTelemetryAnalyzer.getPathPostParametersDel());
-            }
-            // #3.3
-            if (!keyNameOld.equals(keyNameNew)) {
-                ResultsAnalyzerParameters keyNameChange = this.getAnalyzerKeyName(new Gson().fromJson(keyNameOld.toString(), ConcurrentHashMap.class),
-                        new Gson().fromJson(keyNameNew.toString(), ConcurrentHashMap.class));
-                sentAttrToThingsboard.getPathPostParametersAdd().addAll(keyNameChange.getPathPostParametersAdd());
-            }
-
-            // #4.1 add
-            if (sentAttrToThingsboard.getPathPostParametersAdd().size() > 0) {
-                // update value in Resources
-                this.updateResourceValueObserve(lwServer, registration, lwM2MClient, sentAttrToThingsboard.getPathPostParametersAdd(), GET_TYPE_OPER_READ);
-                // sent attr/telemetry to tingsboard for new path
-                this.updateAttrTelemetry(registration, false, sentAttrToThingsboard.getPathPostParametersAdd());
-            }
-            // #4.2 del
-            if (sentAttrToThingsboard.getPathPostParametersDel().size() > 0) {
-                ResultsAnalyzerParameters sentAttrToThingsboardDel = this.getAnalyzerParameters(sentAttrToThingsboard.getPathPostParametersAdd(), sentAttrToThingsboard.getPathPostParametersDel());
-                sentAttrToThingsboard.setPathPostParametersDel(sentAttrToThingsboardDel.getPathPostParametersDel());
-            }
-
-            // #5.1
-            if (!observeOld.equals(observeNew)) {
-                Set<String> observeSetOld = new Gson().fromJson(observeOld, Set.class);
-                Set<String> observeSetNew = new Gson().fromJson(observeNew, Set.class);
-                //#5.2 add
-                //  path Attr/Telemetry includes newObserve
-                attributeSetOld.addAll(telemetrySetOld);
-                ResultsAnalyzerParameters sentObserveToClientOld = this.getAnalyzerParametersIn(attributeSetOld, observeSetOld); // add observe
-                attributeSetNew.addAll(telemetrySetNew);
-                ResultsAnalyzerParameters sentObserveToClientNew = this.getAnalyzerParametersIn(attributeSetNew, observeSetNew); // add observe
-                // does not include oldObserve
-                ResultsAnalyzerParameters postObserveAnalyzer = this.getAnalyzerParameters(sentObserveToClientOld.getPathPostParametersAdd(), sentObserveToClientNew.getPathPostParametersAdd());
-                //  sent Request observe to Client
-                this.updateResourceValueObserve(lwServer, registration, lwM2MClient, postObserveAnalyzer.getPathPostParametersAdd(), GET_TYPE_OPER_OBSERVE);
-                // 5.3 del
-                //  sent Request cancel observe to Client
-                this.cancelObserveIsValue(lwServer, registration, 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 getAnalyzerKeyName(ConcurrentMap<String, String> keyNameOld, ConcurrentMap<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 -> map.getKey(), map -> map.getValue())).keySet();
-        analyzerParameters.setPathPostParametersAdd(paths);
-        return analyzerParameters;
-    }
-
-    private ResultsAnalyzerParameters getAnalyzerParametersIn(Set<String> parametersObserve, Set<String> parameters) {
-        ResultsAnalyzerParameters analyzerParameters = new ResultsAnalyzerParameters();
-        analyzerParameters.setPathPostParametersAdd(parametersObserve
-                .stream().filter(p -> parameters.contains(p)).collect(Collectors.toSet()));
-        return analyzerParameters;
-    }
-
-    /**
-     * Update Resource value after change RezAttrTelemetry in config Profile
-     * sent response Read to Client and add path to pathResAttrTelemetry in LwM2MClient.getAttrTelemetryObserveValue()
-     *
-     * @param lwServer     - LeshanServer
-     * @param registration - Registration LwM2M Client
-     * @param lwM2MClient  - object with All parameters off client
-     * @param targets      - path Resources == [ "/2/0/0", "/2/0/1"]
-     */
-    private void updateResourceValueObserve(LeshanServer lwServer, Registration registration, LwM2MClient lwM2MClient, Set<String> targets, String typeOper) {
-        targets.stream().forEach(target -> {
-            ResultIds pathIds = new ResultIds(target);
-            if (pathIds.resourceId >= 0 && lwM2MClient.getModelObjects().get(pathIds.getObjectId())
-                    .getInstances().get(pathIds.getInstanceId()).getResource(pathIds.getResourceId()).getValue() != null) {
-                if (GET_TYPE_OPER_READ.equals(typeOper)) {
-                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
-                            ContentFormat.TLV.getName(), null, null, null, this.context.getCtxServer().getTimeout());
-                } else if (GET_TYPE_OPER_OBSERVE.equals(typeOper)) {
-                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
-                            null, null, null, null, this.context.getCtxServer().getTimeout());
-                }
-            }
-        });
-    }
-
-    private void cancelObserveIsValue(LeshanServer lwServer, Registration registration, Set<String> paramAnallyzer) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getlwM2MClient(registration.getId());
-        paramAnallyzer.forEach(p -> {
-                    if (this.getResourceValue(lwM2MClient, p) != null) {
-                        this.setCancelObservationRecourse(lwServer, registration, p);
-                    }
-                }
-        );
-    }
-
-    private ResourceValue getResourceValue(LwM2MClient lwM2MClient, String path) {
-        ResourceValue resourceValue = null;
-        ResultIds pathIds = new ResultIds(path);
-        if (pathIds.getResourceId() > -1) {
-            LwM2mResource resource = lwM2MClient.getModelObjects().get(pathIds.getObjectId()).getInstances().get(pathIds.getInstanceId()).getResource(pathIds.getResourceId());
-            if (resource.isMultiInstances()) {
-                Map<Integer, ?> values = resource.getValues();
-                if (resource.getValues().size() > 0) {
-                    resourceValue = new ResourceValue();
-                    resourceValue.setMultiInstances(resource.isMultiInstances());
-                    resourceValue.setValues(resource.getValues());
-                }
-            } else {
-                if (resource.getValue() != null) {
-                    resourceValue = new ResourceValue();
-                    resourceValue.setMultiInstances(resource.isMultiInstances());
-                    resourceValue.setValue(resource.getValue());
-                }
-            }
-        }
-        return resourceValue;
-    }
-
-    /**
-     * Trigger Server path = "/1/0/8"
-     *
-     * Trigger bootStrap path = "/1/0/9" - have to implemented on client
-     */
-    public void doTrigger(LeshanServer lwServer, Registration registration, String path) {
-        lwM2MTransportRequest.sendAllRequest(lwServer, registration, path, POST_TYPE_OPER_EXECUTE,
-                ContentFormat.TLV.getName(), null, null, null, this.context.getCtxServer().getTimeout());
-    }
-
-    /**
-     * 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);
-    }
-
-    /**
-     * Deregister session in transport
-     * @param sessionInfo - lwm2m client
-     */
-    private void doDisconnect(SessionInfoProto sessionInfo) {
-        transportService.process(sessionInfo, DefaultTransportService.getSessionEventMsg(SessionEvent.CLOSED), null);
-        transportService.deregisterSession(sessionInfo);
-    }
-
-    private void checkInactivityAndReportActivity() {
-        lwM2mInMemorySecurityStore.getSessions().forEach((key, value) -> transportService.reportActivity(this.getValidateSessionInfo(key)));
-    }
-
-    public void sentLogsToThingsboard(String msg, String registrationId) {
-        if (msg != null) {
-            JsonObject telemetrys = new JsonObject();
-            telemetrys.addProperty(LOG_LW2M_TELEMETRY, msg);
-            this.updateParametersOnThingsboard(telemetrys, LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC, registrationId);
-        }
-    }
 
 
 }
 }

+/**
+ * Copyright © 2016-2020 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.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.leshan.core.Link;
+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.LwM2mObjectInstance;
+import org.eclipse.leshan.core.node.LwM2mPath;
+import org.eclipse.leshan.core.node.LwM2mSingleResource;
+import org.eclipse.leshan.core.observation.Observation;
+import org.eclipse.leshan.core.request.ContentFormat;
+import org.eclipse.leshan.core.request.WriteRequest;
+import org.eclipse.leshan.core.response.ReadResponse;
+import org.eclipse.leshan.core.util.NamedThreadFactory;
+import org.eclipse.leshan.server.californium.LeshanServer;
+import org.eclipse.leshan.server.registration.Registration;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.transport.TransportService;
+import org.thingsboard.server.common.transport.adaptor.AdaptorException;
+import org.thingsboard.server.common.transport.adaptor.JsonConverter;
+import org.thingsboard.server.common.transport.service.DefaultTransportService;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.gen.transport.TransportProtos.SessionEvent;
+import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
+import org.thingsboard.server.gen.transport.TransportProtos.ToTransportUpdateCredentialsProto;
+import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
+import org.thingsboard.server.transport.lwm2m.server.client.AttrTelemetryObserveValue;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
+import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
+import org.thingsboard.server.transport.lwm2m.server.client.ResultsAnalyzerParameters;
+import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
+import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
+
+import javax.annotation.PostConstruct;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+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.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.stream.Collectors;
+
+import static org.thingsboard.server.common.transport.util.JsonUtils.getJsonObject;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.CLIENT_NOT_AUTHORIZED;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.DEVICE_ATTRIBUTES_REQUEST;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.DEVICE_ATTRIBUTES_TOPIC;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_OBSERVE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_READ;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_TELEMETRY;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_EXECUTE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_WRITE_REPLACE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.SERVICE_CHANNEL;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getAckCallback;
+
+@Slf4j
+@Service("LwM2MTransportService")
+@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
+public class LwM2MTransportServiceImpl implements LwM2MTransportService {
+
+    private ExecutorService executorRegistered;
+    private ExecutorService executorUpdateRegistered;
+    private ExecutorService executorUnRegistered;
+    private LwM2mValueConverterImpl converter;
+    protected final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+    protected final Lock writeLock = readWriteLock.writeLock();
+
+
+    @Autowired
+    private TransportService transportService;
+
+    @Autowired
+    public LwM2MTransportContextServer context;
+
+    @Autowired
+    private LwM2MTransportRequest lwM2MTransportRequest;
+
+    @Autowired
+    LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
+
+    @PostConstruct
+    public void init() {
+        this.context.getScheduler().scheduleAtFixedRate(this::checkInactivityAndReportActivity, new Random().nextInt((int) context.getCtxServer().getSessionReportTimeout()), context.getCtxServer().getSessionReportTimeout(), TimeUnit.MILLISECONDS);
+        this.executorRegistered = Executors.newFixedThreadPool(this.context.getCtxServer().getRegisteredPoolSize(),
+                new NamedThreadFactory(String.format("LwM2M %s channel registered", SERVICE_CHANNEL)));
+        this.executorUpdateRegistered = Executors.newFixedThreadPool(this.context.getCtxServer().getUpdateRegisteredPoolSize(),
+                new NamedThreadFactory(String.format("LwM2M %s channel update registered", SERVICE_CHANNEL)));
+        this.executorUnRegistered = Executors.newFixedThreadPool(this.context.getCtxServer().getUnRegisteredPoolSize(),
+                new NamedThreadFactory(String.format("LwM2M %s channel un registered", SERVICE_CHANNEL)));
+        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 lwServer             - LeshanServer
+     * @param registration         - Registration LwM2M Client
+     * @param previousObsersations - may be null
+     */
+    public void onRegistered(LeshanServer lwServer, Registration registration, Collection<Observation> previousObsersations) {
+        executorRegistered.submit(() -> {
+            try {
+//                log.warn("[{}] [{{}] Client: create after Registration", registration.getEndpoint(), registration.getId());
+                LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.updateInSessionsLwM2MClient(lwServer, registration);
+                if (lwM2MClient != null) {
+                    lwM2MClient.setLwM2MTransportServiceImpl(this);
+                    lwM2MClient.setSessionUuid(UUID.randomUUID());
+                    this.sentLogsToThingsboard(LOG_LW2M_INFO + ": Client  Registered", registration);
+                    this.setLwM2mFromClientValue(lwServer, registration, lwM2MClient);
+                    SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration);
+                    if (sessionInfo != null) {
+                        lwM2MClient.setDeviceUuid(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB()));
+                        lwM2MClient.setProfileUuid(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
+                        lwM2MClient.setDeviceName(sessionInfo.getDeviceName());
+                        lwM2MClient.setDeviceProfileName(sessionInfo.getDeviceType());
+                        transportService.registerAsyncSession(sessionInfo, new LwM2MSessionMsgListener(this, sessionInfo));
+                        transportService.process(sessionInfo, DefaultTransportService.getSessionEventMsg(SessionEvent.OPEN), null);
+                        transportService.process(sessionInfo, TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().build(), null);
+                        this.sentLogsToThingsboard(LOG_LW2M_INFO + ": Client  create after Registration", registration);
+                        this.putDelayedUpdateResourcesThingsboard(lwM2MClient);
+                    } else {
+                        log.error("Client: [{}] onRegistered [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), null);
+                    }
+                } else {
+                    log.error("Client: [{}] onRegistered [{}] name  [{}] lwM2MClient ", registration.getId(), registration.getEndpoint(), null);
+                }
+            } catch (Throwable t) {
+                log.error("[{}] endpoint [{}] error Unable registration.", registration.getEndpoint(), t);
+            }
+        });
+    }
+
+    /**
+     * if sessionInfo removed from sessions, then new registerAsyncSession
+     *
+     * @param lwServer     - LeshanServer
+     * @param registration - Registration LwM2M Client
+     */
+    public void updatedReg(LeshanServer lwServer, Registration registration) {
+        executorUpdateRegistered.submit(() -> {
+            try {
+                SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration);
+                if (sessionInfo != null) {
+                    this.checkInactivity(sessionInfo);
+                    log.info("Client: [{}] updatedReg [{}] name  [{}] profile ", registration.getId(), registration.getEndpoint(), sessionInfo.getDeviceType());
+                } else {
+                    log.error("Client: [{}] updatedReg [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), null);
+                }
+            } catch (Throwable t) {
+                log.error("[{}] endpoint [{}] error Unable update registration.", registration.getEndpoint(), t);
+            }
+        });
+    }
+
+    /**
+     * @param registration - Registration LwM2M Client
+     * @param observations - All paths observations before unReg
+     *                     !!! Warn: if have not finishing unReg, then this operation will be finished on next Client`s connect
+     */
+    public void unReg(LeshanServer lwServer, Registration registration, Collection<Observation> observations) {
+        executorUnRegistered.submit(() -> {
+            try {
+                this.setCancelObservations(lwServer, registration);
+                this.sentLogsToThingsboard(LOG_LW2M_INFO + ": Client unRegistration", registration);
+                this.closeClientSession(registration);
+            } catch (Throwable t) {
+                log.error("[{}] endpoint [{}] error Unable un registration.", registration.getEndpoint(), t);
+            }
+        });
+    }
+
+    private void closeClientSession(Registration registration) {
+        SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration);
+        if (sessionInfo != null) {
+            transportService.deregisterSession(sessionInfo);
+            this.doCloseSession(sessionInfo);
+            lwM2mInMemorySecurityStore.delRemoveSessionAndListener(registration.getId());
+            if (lwM2mInMemorySecurityStore.getProfiles().size() > 0) {
+                this.syncSessionsAndProfiles();
+            }
+            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);
+        }
+    }
+
+    public void onSleepingDev(Registration registration) {
+        log.info("[{}] [{}] Received endpoint Sleeping version event", registration.getId(), registration.getEndpoint());
+        //TODO: associate endpointId with device information.
+    }
+
+    /**
+     * 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 -
+     */
+    protected void onAwakeDev(Registration registration) {
+        log.info("[{}] [{}] Received endpoint Awake version event", registration.getId(), registration.getEndpoint());
+        //TODO: associate endpointId with device information.
+    }
+
+    /**
+     * This method is used to sync with sessions
+     * Removes a profile if not used in sessions
+     */
+    private void syncSessionsAndProfiles() {
+        Map<UUID, AttrTelemetryObserveValue> profilesClone = lwM2mInMemorySecurityStore.getProfiles().entrySet()
+                .stream()
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        profilesClone.forEach((k, v) -> {
+            String registrationId = lwM2mInMemorySecurityStore.getSessions().entrySet()
+                    .stream()
+                    .filter(e -> e.getValue().getProfileUuid().equals(k))
+                    .findFirst()
+                    .map(Map.Entry::getKey) // return the key of the matching entry if found
+                    .orElse("");
+            if (registrationId.isEmpty()) {
+                lwM2mInMemorySecurityStore.getProfiles().remove(k);
+            }
+        });
+    }
+
+    /**
+     * #0 Add new ObjectModel to context
+     * Create new LwM2MClient for current session -> setModelClient...
+     * #1   Add all ObjectLinks (instance) to control the process of executing requests to the client
+     * to get the client model with current values
+     * #2   Get the client model with current values. Analyze the response in -> lwM2MTransportRequest.sendResponse
+     *
+     * @param lwServer     - LeshanServer
+     * @param registration - Registration LwM2M Client
+     * @param lwM2MClient  - object with All parameters off client
+     */
+    private void setLwM2mFromClientValue(LeshanServer lwServer, Registration registration, LwM2MClient lwM2MClient) {
+        Arrays.stream(registration.getObjectLinks()).forEach(url -> {
+            LwM2mPath pathIds = new LwM2mPath(url.getUrl());
+            if (pathIds.isObjectInstance() && !pathIds.isResource()) {
+                // #1
+                lwM2MClient.getPendingRequests().add(url.getUrl());
+                // #2
+                lwM2MTransportRequest.sendAllRequest(lwServer, registration, url.getUrl(), GET_TYPE_OPER_READ, ContentFormat.TLV.getName(),
+                        lwM2MClient, null, null, this.context.getCtxServer().getTimeout(), false);
+            }
+        });
+
+        // #1
+        for (Link url : registration.getObjectLinks()) {
+            LwM2mPath pathIds = new LwM2mPath(url.getUrl());
+            if (pathIds.isObjectInstance() && !pathIds.isResource()) {
+                lwM2MClient.getPendingRequests().add(url.getUrl());
+            }
+        }
+        // #2
+        for (Link url : registration.getObjectLinks()) {
+            LwM2mPath pathIds = new LwM2mPath(url.getUrl());
+            if (pathIds.isObjectInstance() && !pathIds.isResource()) {
+                lwM2MTransportRequest.sendAllRequest(lwServer, registration, url.getUrl(), GET_TYPE_OPER_READ, ContentFormat.TLV.getName(),
+                        lwM2MClient, null, null, this.context.getCtxServer().getTimeout(), false);
+            }
+        }
+
+        // #1
+        Arrays.stream(registration.getObjectLinks()).forEach(url -> {
+            LwM2mPath pathIds = new LwM2mPath(url.getUrl());
+            if (pathIds.isObjectInstance() && !pathIds.isResource()) {
+                lwM2MClient.getPendingRequests().add(url.getUrl());
+            }
+        });
+
+        // #2
+        Arrays.stream(registration.getObjectLinks()).forEach(url -> {
+            LwM2mPath pathIds = new LwM2mPath(url.getUrl());
+            if (pathIds.isObjectInstance() && !pathIds.isResource()) {
+                lwM2MTransportRequest.sendAllRequest(lwServer, registration, url.getUrl(), GET_TYPE_OPER_READ, ContentFormat.TLV.getName(),
+                        lwM2MClient, null, null, this.context.getCtxServer().getTimeout(), false);
+            }
+        });
+    }
+
+    /**
+     * @param registration - Registration LwM2M Client
+     * @return - sessionInfo after access connect client
+     */
+    private SessionInfoProto getValidateSessionInfo(Registration registration) {
+        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null);
+        return getNewSessionInfoProto(lwM2MClient);
+
+    }
+
+    /**
+     * @param registrationId -
+     * @return -
+     */
+    private SessionInfoProto getValidateSessionInfo(String registrationId) {
+        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(null, registrationId);
+        return getNewSessionInfoProto(lwM2MClient);
+    }
+
+    private SessionInfoProto getNewSessionInfoProto(LwM2MClient lwM2MClient) {
+        if (lwM2MClient != null) {
+            ValidateDeviceCredentialsResponseMsg msg = lwM2MClient.getCredentialsResponse();
+            if (msg == null || msg.getDeviceInfo() == null) {
+                log.error("[{}] [{}]", lwM2MClient.getEndPoint(), CLIENT_NOT_AUTHORIZED);
+                this.closeClientSession(lwM2MClient.getRegistration());
+                return null;
+            } else {
+                return SessionInfoProto.newBuilder()
+                        .setNodeId(this.context.getNodeId())
+                        .setSessionIdMSB(lwM2MClient.getSessionUuid().getMostSignificantBits())
+                        .setSessionIdLSB(lwM2MClient.getSessionUuid().getLeastSignificantBits())
+                        .setDeviceIdMSB(msg.getDeviceInfo().getDeviceIdMSB())
+                        .setDeviceIdLSB(msg.getDeviceInfo().getDeviceIdLSB())
+                        .setTenantIdMSB(msg.getDeviceInfo().getTenantIdMSB())
+                        .setTenantIdLSB(msg.getDeviceInfo().getTenantIdLSB())
+                        .setDeviceName(msg.getDeviceInfo().getDeviceName())
+                        .setDeviceType(msg.getDeviceInfo().getDeviceType())
+                        .setDeviceProfileIdLSB(msg.getDeviceInfo().getDeviceProfileIdLSB())
+                        .setDeviceProfileIdMSB(msg.getDeviceInfo().getDeviceProfileIdMSB())
+                        .build();
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Add attribute/telemetry information from Client and credentials/Profile to client model and start observe
+     * !!! if the resource has an observation, but no telemetry or attribute - the observation will not use
+     * #1 Sending Attribute Telemetry with value to thingsboard only once at the start of the connection
+     * #2 Start observe
+     *
+     * @param lwM2MClient - LwM2M Client
+     */
+
+    public void updatesAndSentModelParameter(LwM2MClient lwM2MClient) {
+        // #1
+        this.updateAttrTelemetry(lwM2MClient.getRegistration(), true, null);
+        // #2
+        this.onSentObserveToClient(lwM2MClient.getLwServer(), lwM2MClient.getRegistration());
+
+    }
+
+    /**
+     * 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 get attributes name from profile include name resources in ModelObject if resource  isWritable
+     * #2.1 #1 size > 0 => send Request getAttributes to thingsboard
+     * #2.2 #1 size == 0 => continue normal process
+     *
+     * @param lwM2MClient - LwM2M Client
+     */
+    public void putDelayedUpdateResourcesThingsboard(LwM2MClient lwM2MClient) {
+        SessionInfoProto sessionInfo = this.getValidateSessionInfo(lwM2MClient.getRegistration());
+        if (sessionInfo != null) {
+            //#1.1 + #1.2
+            List<String> attrSharedNames = this.getNamesAttrFromProfileIsWritable(lwM2MClient);
+            if (attrSharedNames.size() > 0) {
+                //#2.1
+                try {
+                    TransportProtos.GetAttributeRequestMsg getAttributeMsg = context.getAdaptor().convertToGetAttributes(null, attrSharedNames);
+                    lwM2MClient.getDelayedRequestsId().add(getAttributeMsg.getRequestId());
+                    transportService.process(sessionInfo, getAttributeMsg, getAckCallback(lwM2MClient, getAttributeMsg.getRequestId(), DEVICE_ATTRIBUTES_REQUEST));
+                } catch (AdaptorException e) {
+                    log.warn("Failed to decode get attributes request", e);
+                }
+            }
+            // #2.2
+            else {
+                lwM2MClient.onSuccessOrErrorDelayedRequests(null);
+            }
+        }
+    }
+
+    /**
+     * Update resource value on client: if there is a difference in values between the current resource values and the shared attribute values
+     * #1 Get path resource by result attributesResponse
+     * #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
+     * => sent 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 attributesResponse -
+     * @param sessionInfo        -
+     */
+    public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg attributesResponse, TransportProtos.SessionInfoProto sessionInfo) {
+        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClient(sessionInfo);
+        if (lwM2MClient.getDelayedRequestsId().contains(attributesResponse.getRequestId())) {
+            attributesResponse.getSharedAttributeListList().forEach(attr -> {
+                String path = this.getPathAttributeUpdate(sessionInfo, attr.getKv().getKey());
+                // #1.1
+                if (lwM2MClient.getDelayedRequests().containsKey(path) && attr.getTs() > lwM2MClient.getDelayedRequests().get(path).getTs()) {
+                    lwM2MClient.getDelayedRequests().put(path, attr);
+                } else {
+                    lwM2MClient.getDelayedRequests().put(path, attr);
+                }
+            });
+            // #2.1
+            lwM2MClient.getDelayedRequests().forEach((k, v) -> {
+                ArrayList<TransportProtos.KeyValueProto> listV = new ArrayList<>();
+                listV.add(v.getKv());
+                this.putDelayedUpdateResourcesClient(lwM2MClient, this.getResourceValueToString(lwM2MClient, k), getJsonObject(listV).get(v.getKv().getKey()), k);
+            });
+            lwM2MClient.getDelayedRequestsId().remove(attributesResponse.getRequestId());
+            if (lwM2MClient.getDelayedRequests().size() == 0) {
+                lwM2MClient.onSuccessOrErrorDelayedRequests(null);
+            }
+        }
+    }
+
+    private void putDelayedUpdateResourcesClient(LwM2MClient lwM2MClient, Object valueOld, Object valueNew, String path) {
+        if (valueNew != null && !valueNew.toString().equals(valueOld.toString())) {
+            lwM2MTransportRequest.sendAllRequest(lwM2MClient.getLwServer(), lwM2MClient.getRegistration(), path, POST_TYPE_OPER_WRITE_REPLACE,
+                    ContentFormat.TLV.getName(), lwM2MClient, null, valueNew, this.context.getCtxServer().getTimeout(),
+                    true);
+        }
+    }
+
+    /**
+     * Get names and keyNames from profile shared!!!! attr resources IsWritable
+     *
+     * @param lwM2MClient -
+     * @return ArrayList  keyNames from profile attr resources shared!!!! && IsWritable
+     */
+    private List<String> getNamesAttrFromProfileIsWritable(LwM2MClient lwM2MClient) {
+        AttrTelemetryObserveValue profile = lwM2mInMemorySecurityStore.getProfile(lwM2MClient.getProfileUuid());
+        Set attrSet = new Gson().fromJson(profile.getPostAttributeProfile(), Set.class);
+        ConcurrentMap<String, String> keyNamesMap = new Gson().fromJson(profile.getPostKeyNameProfile().toString(), ConcurrentHashMap.class);
+
+        ConcurrentMap<String, String> keyNamesIsWritable = keyNamesMap.entrySet()
+                .stream()
+                .filter(e -> (attrSet.contains(e.getKey()) && context.getCtxServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(e.getKey())) != null &&
+                        context.getCtxServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(e.getKey())).operations.isWritable()))
+                .collect(Collectors.toConcurrentMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        Set<String> namesIsWritable = ConcurrentHashMap.newKeySet();
+        namesIsWritable.addAll(new HashSet<>(keyNamesIsWritable.values()));
+        return new ArrayList<>(namesIsWritable);
+    }
+
+
+    /**
+     * Sent Attribute and Telemetry to Thingsboard
+     * #1 - get AttrName/TelemetryName with value:
+     * #1.1 from Client
+     * #1.2 from LwM2MClient:
+     * -- resourceId == path from AttrTelemetryObserveValue.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, boolean start, Set<String> paths) {
+        JsonObject attributes = new JsonObject();
+        JsonObject telemetries = new JsonObject();
+        if (start) {
+            // #1.1
+            JsonObject attributeClient = this.getAttributeClient(registration);
+            if (attributeClient != null) {
+                attributeClient.entrySet().forEach(p -> attributes.add(p.getKey(), p.getValue()));
+            }
+        }
+        // #1.2
+        try {
+            writeLock.lock();
+            this.getParametersFromProfile(attributes, telemetries, registration, paths);
+        } catch (Exception e) {
+            log.error("UpdateAttrTelemetry", e);
+        } finally {
+            writeLock.unlock();
+        }
+        if (attributes.getAsJsonObject().entrySet().size() > 0)
+            this.updateParametersOnThingsboard(attributes, DEVICE_ATTRIBUTES_TOPIC, registration);
+        if (telemetries.getAsJsonObject().entrySet().size() > 0)
+            this.updateParametersOnThingsboard(telemetries, DEVICE_TELEMETRY_TOPIC, registration);
+    }
+
+    /**
+     * get AttrName/TelemetryName with value from Client
+     *
+     * @param registration -
+     * @return - JsonObject, format: {name: value}}
+     */
+    private JsonObject getAttributeClient(Registration registration) {
+        if (registration.getAdditionalRegistrationAttributes().size() > 0) {
+            JsonObject resNameValues = new JsonObject();
+            registration.getAdditionalRegistrationAttributes().forEach(resNameValues::addProperty);
+            return resNameValues;
+        }
+        return null;
+    }
+
+    /**
+     * @param attributes   - new JsonObject
+     * @param telemetry    - new JsonObject
+     * @param registration - Registration LwM2M Client
+     *                     result: add to JsonObject those resources to which the user is subscribed and they have a value
+     *                     if path==null add All resources else only one
+     *                     (attributes/telemetry): new {name(Attr/Telemetry):value}
+     */
+    private void getParametersFromProfile(JsonObject attributes, JsonObject telemetry, Registration registration, Set<String> path) {
+        AttrTelemetryObserveValue attrTelemetryObserveValue = lwM2mInMemorySecurityStore.getProfiles().get(lwM2mInMemorySecurityStore.getSessions().get(registration.getId()).getProfileUuid());
+        attrTelemetryObserveValue.getPostAttributeProfile().forEach(p -> {
+            LwM2mPath pathIds = new LwM2mPath(p.getAsString().toString());
+            if (pathIds.isResource()) {
+                if (path == null || path.contains(p.getAsString())) {
+                    this.addParameters(p.getAsString().toString(), attributes, registration);
+                }
+            }
+        });
+        attrTelemetryObserveValue.getPostTelemetryProfile().forEach(p -> {
+            LwM2mPath pathIds = new LwM2mPath(p.getAsString().toString());
+            if (pathIds.isResource()) {
+                if (path == null || path.contains(p.getAsString())) {
+                    this.addParameters(p.getAsString().toString(), telemetry, registration);
+                }
+            }
+        });
+    }
+
+    /**
+     * @param parameters   - JsonObject attributes/telemetry
+     * @param registration - Registration LwM2M Client
+     */
+    private void addParameters(String path, JsonObject parameters, Registration registration) {
+        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSessions().get(registration.getId());
+        JsonObject names = lwM2mInMemorySecurityStore.getProfiles().get(lwM2MClient.getProfileUuid()).getPostKeyNameProfile();
+        String resName = String.valueOf(names.get(path));
+        if (resName != null && !resName.isEmpty()) {
+            try {
+                String resValue = this.getResourceValueToString(lwM2MClient, path);
+                if (resValue != null) {
+                    parameters.addProperty(resName, resValue);
+                }
+            } catch (Exception e) {
+                log.error(e.getStackTrace().toString());
+            }
+        }
+    }
+
+    /**
+     * Prepare Sent to Thigsboard callback - Attribute or Telemetry
+     *
+     * @param msg          - JsonArray: [{name: value}]
+     * @param topicName    - Api Attribute or Telemetry
+     * @param registration - Id of Registration LwM2M Client
+     */
+    public void updateParametersOnThingsboard(JsonElement msg, String topicName, Registration registration) {
+        SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration);
+        if (sessionInfo != null) {
+            context.sentParametersOnThingsboard(msg, topicName, sessionInfo);
+        } else {
+            log.error("Client: [{}] updateParametersOnThingsboard [{}] sessionInfo ", registration, null);
+        }
+    }
+
+    /**
+     * Start observe
+     * #1 - Analyze:
+     * #1.1 path in observe == (attribute or telemetry)
+     * #2 Analyze after sent request (response):
+     * #2.1 First: lwM2MTransportRequest.sendResponse -> ObservationListener.newObservation
+     * #2.2 Next: ObservationListener.onResponse     *
+     *
+     * @param lwServer     - LeshanServer
+     * @param registration - Registration LwM2M Client
+     */
+    private void onSentObserveToClient(LeshanServer lwServer, Registration registration) {
+        if (lwServer.getObservationService().getObservations(registration).size() > 0) {
+            this.setCancelObservations(lwServer, registration);
+        }
+        UUID profileUUid = lwM2mInMemorySecurityStore.getSessions().get(registration.getId()).getProfileUuid();
+        AttrTelemetryObserveValue attrTelemetryObserveValue = lwM2mInMemorySecurityStore.getProfiles().get(profileUUid);
+        attrTelemetryObserveValue.getPostObserveProfile().forEach(p -> {
+            // #1.1
+            String target = (getValidateObserve(attrTelemetryObserveValue.getPostAttributeProfile(), p.getAsString().toString())) ?
+                    p.getAsString().toString() : (getValidateObserve(attrTelemetryObserveValue.getPostTelemetryProfile(), p.getAsString().toString())) ?
+                    p.getAsString().toString() : null;
+            if (target != null) {
+                // #2
+                if (this.getResourceValueToString(lwM2mInMemorySecurityStore.getSessions().get(registration.getId()), target) != null) {
+                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, GET_TYPE_OPER_OBSERVE,
+                            null, null, null, null, this.context.getCtxServer().getTimeout(),
+                            false);
+                }
+            }
+        });
+    }
+
+    public void setCancelObservations(LeshanServer lwServer, Registration registration) {
+        if (registration != null) {
+            Set<Observation> observations = lwServer.getObservationService().getObservations(registration);
+            observations.forEach(observation -> this.setCancelObservationRecourse(lwServer, registration, observation.getPath().toString()));
+        }
+    }
+
+    /**
+     * lwM2MTransportRequest.sendAllRequest(lwServer, registration, path, POST_TYPE_OPER_OBSERVE_CANCEL, null, null, null, null, context.getTimeout());
+     * At server side this will not remove the observation from the observation store, to do it you need to use
+     * {@code ObservationService#cancelObservation()}
+     */
+    public void setCancelObservationRecourse(LeshanServer lwServer, Registration registration, String path) {
+        lwServer.getObservationService().cancelObservations(registration, path);
+    }
+
+    /**
+     * @param parameters - JsonArray postAttributeProfile/postTelemetryProfile
+     * @param path       - recourse from postObserveProfile
+     * @return rez - true if path observe is in attribute/telemetry
+     */
+    private boolean getValidateObserve(JsonElement parameters, String path) {
+        AtomicBoolean rez = new AtomicBoolean(false);
+        if (parameters.isJsonArray()) {
+            parameters.getAsJsonArray().forEach(p -> {
+                        if (p.getAsString().toString().equals(path)) rez.set(true);
+                    }
+            );
+        } else if (parameters.isJsonObject()) {
+            rez.set((parameters.getAsJsonObject().entrySet()).stream().map(json -> json.toString())
+                    .filter(path::equals).findAny().orElse(null) != null);
+        }
+        return rez.get();
+    }
+
+    /**
+     * Sending observe value to thingsboard from ObservationListener.onResponse: object, instance, SingleResource or MultipleResource
+     *
+     * @param registration - Registration LwM2M Client
+     * @param path         - observe
+     * @param response     - observe
+     */
+
+    public void onObservationResponse(Registration registration, String path, ReadResponse response) {
+        if (response.getContent() != null) {
+            if (response.getContent() instanceof LwM2mObject) {
+//                LwM2mObject content = (LwM2mObject) response.getContent();
+            } else if (response.getContent() instanceof LwM2mObjectInstance) {
+//                LwM2mObjectInstance content = (LwM2mObjectInstance) response.getContent();
+            } else if (response.getContent() instanceof LwM2mSingleResource) {
+                LwM2mSingleResource content = (LwM2mSingleResource) response.getContent();
+                this.onObservationSetResourcesValue(registration, content.getValue(), null, path);
+            } else if (response.getContent() instanceof LwM2mMultipleResource) {
+                LwM2mMultipleResource content = (LwM2mMultipleResource) response.getContent();
+                this.onObservationSetResourcesValue(registration, null, content.getValues(), path);
+            }
+        }
+    }
+
+    /**
+     * 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)
+     *
+     * @param registration - Registration LwM2M Client
+     * @param value        - LwM2mSingleResource response.getContent()
+     * @param values       - LwM2mSingleResource response.getContent()
+     * @param path         - resource
+     */
+    private void onObservationSetResourcesValue(Registration registration, Object value, Map<Integer, ?>  values, String path) {
+        boolean isChange = false;
+        try {
+            writeLock.lock();
+            // #1
+            LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null);
+            LwM2mPath pathIds = new LwM2mPath(path);
+//            log.warn("#0 nameDevice: [{}] resultIds: [{}] value: [{}], values: [{}] ", lwM2MClient.getDeviceName(), pathIds, value, values);
+            ResourceModel.Type resModelType = context.getCtxServer().getResourceModelType(registration, pathIds);
+            ResourceValue resValueOld = lwM2MClient.getResources().get(path);
+            // #2
+            if (resValueOld.isMultiInstances() && !values.toString().equals(resValueOld.getResourceValue().toString())) {
+                lwM2MClient.getResources().get(path).setValues(values);
+//                ResourceValue resourceValue = new ResourceValue(values, null, true);
+//                lwM2MClient.getResources().put(path, resourceValue);
+                isChange = true;
+            } else if (!LwM2MTransportHandler.equalsResourceValue(resValueOld.getValue(), value, resModelType, pathIds)) {
+                lwM2MClient.getResources().get(path).setValue(value);
+//                ResourceValue resourceValueOld = lwM2MClient.getResources().get(path);
+//                lwM2MClient.getResources().remove(resourceValueOld);
+//                ResourceValue resourceValue = new ResourceValue(null, value, false);
+//                lwM2MClient.getResources().put(path, resourceValue);
+                log.warn("upDateResize: [{}] [{}] [{}] [{}]", lwM2MClient.getEndPoint(), lwM2MClient.getResources().size(), value, path);
+                isChange = true;
+            }
+        } catch (Exception e) {
+            log.error("#1_1 Update ResourcesValue after Observation is unsuccessfully  path: [{}] value: [{}] [{}]", path, value, e.toString());
+        } finally {
+            writeLock.unlock();
+        }
+
+        if (isChange) {
+            Set<String> paths = new HashSet<>();
+            paths.add(path);
+            this.updateAttrTelemetry(registration, false, paths);
+        }
+    }
+
+    /**
+     * @param updateCredentials - Credentials include config only security Client (without config attr/telemetry...)
+     *                          config attr/telemetry... in profile
+     */
+    public void onToTransportUpdateCredentials(ToTransportUpdateCredentialsProto updateCredentials) {
+        log.info("[{}] idList [{}] valueList updateCredentials", updateCredentials.getCredentialsIdList(), updateCredentials.getCredentialsValueList());
+    }
+
+    /**
+     * Update - sent request in change value resources in Client
+     * Path to resources from profile equal keyName or from ModelObject equal name
+     * Only for resources:  isWritable && isPresent as attribute in profile -> AttrTelemetryObserveValue (format: CamelCase)
+     * Delete - nothing     *
+     *
+     * @param msg -
+     */
+    public void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg msg, TransportProtos.SessionInfoProto sessionInfo) {
+        if (msg.getSharedUpdatedCount() > 0) {
+            JsonElement el = JsonConverter.toJson(msg);
+            el.getAsJsonObject().entrySet().forEach(de -> {
+                String path = this.getPathAttributeUpdate(sessionInfo, de.getKey());
+                String value = de.getValue().getAsString();
+                LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSession(new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB())).entrySet().iterator().next().getValue();
+                AttrTelemetryObserveValue profile = lwM2mInMemorySecurityStore.getProfile(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
+                ResourceModel resourceModel = context.getCtxServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(path));
+                if (!path.isEmpty() && (this.validatePathInAttrProfile(profile, path) || this.validatePathInTelemetryProfile(profile, path))) {
+                    if (resourceModel != null && resourceModel.operations.isWritable()) {
+                        lwM2MTransportRequest.sendAllRequest(lwM2MClient.getLwServer(), lwM2MClient.getRegistration(), path, POST_TYPE_OPER_WRITE_REPLACE,
+                                ContentFormat.TLV.getName(), lwM2MClient, null, value, this.context.getCtxServer().getTimeout(),
+                                false);
+                    } else {
+                        log.error("Resource path - [{}] value - [{}] is not Writable and cannot be updated", path, value);
+                        String logMsg = String.format(LOG_LW2M_ERROR + ": attributeUpdate: Resource path - %s value - %s is not Writable and cannot be updated", path, value);
+                        this.sentLogsToThingsboard(logMsg, lwM2MClient.getRegistration());
+                    }
+                } else {
+                    log.error("Attribute name - [{}] value - [{}] is not present as attribute in profile and cannot be updated", de.getKey(), value);
+                    String logMsg = String.format(LOG_LW2M_ERROR + ": attributeUpdate: attribute name - %s value - %s is not present as attribute in profile and cannot be updated", de.getKey(), value);
+                    this.sentLogsToThingsboard(logMsg, lwM2MClient.getRegistration());
+                }
+            });
+        } else if (msg.getSharedDeletedCount() > 0) {
+            log.info("[{}] delete [{}]  onAttributeUpdate", msg.getSharedDeletedList(), sessionInfo);
+        }
+    }
+
+    /**
+     * Get path to resource from profile equal keyName or from ModelObject equal name
+     * Only for resource:  isWritable && isPresent as attribute in profile -> AttrTelemetryObserveValue (format: CamelCase)
+     *
+     * @param sessionInfo -
+     * @param name        -
+     * @return path if path isPresent in postProfile
+     */
+    private String getPathAttributeUpdate(TransportProtos.SessionInfoProto sessionInfo, String name) {
+        String profilePath = this.getPathAttributeUpdateProfile(sessionInfo, name);
+//        return !profilePath.isEmpty() ? profilePath : this.getPathAttributeUpdateModelObject(name);
+        return !profilePath.isEmpty() ? profilePath : null;
+    }
+
+    /**
+     * @param profile -
+     * @param path    -
+     * @return true if path isPresent in postAttributeProfile
+     */
+    private boolean validatePathInAttrProfile(AttrTelemetryObserveValue profile, String path) {
+        Set<String> attributesSet = new Gson().fromJson(profile.getPostAttributeProfile(), Set.class);
+        return attributesSet.stream().filter(p -> p.equals(path)).findFirst().isPresent();
+    }
+
+    /**
+     * @param profile -
+     * @param path    -
+     * @return true if path isPresent in postAttributeProfile
+     */
+    private boolean validatePathInTelemetryProfile(AttrTelemetryObserveValue profile, String path) {
+        Set<String> telemetriesSet = new Gson().fromJson(profile.getPostTelemetryProfile(), Set.class);
+        return telemetriesSet.stream().filter(p -> p.equals(path)).findFirst().isPresent();
+    }
+
+
+    /**
+     * Get path to resource from profile equal keyName
+     *
+     * @param sessionInfo -
+     * @param name        -
+     * @return -
+     */
+    private String getPathAttributeUpdateProfile(TransportProtos.SessionInfoProto sessionInfo, String name) {
+        AttrTelemetryObserveValue profile = lwM2mInMemorySecurityStore.getProfile(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
+        return profile.getPostKeyNameProfile().getAsJsonObject().entrySet().stream()
+                .filter(e -> e.getValue().getAsString().equals(name)).findFirst().map(Map.Entry::getKey)
+                .orElse("");
+    }
+
+    /**
+     * Update resource (attribute) value  on thingsboard after update value in client
+     *
+     * @param registration -
+     * @param path         -
+     * @param request      -
+     */
+    public void onAttributeUpdateOk(Registration registration, String path, WriteRequest request, boolean isDelayedUpdate) {
+        ResourceModel resource = context.getCtxServer().getResourceModel(registration, new LwM2mPath(path));
+        if (resource.multiple) {
+            this.onObservationSetResourcesValue(registration, null, ((LwM2mSingleResource) request.getNode()).getValues(), path);
+        } else {
+            this.onObservationSetResourcesValue(registration, ((LwM2mSingleResource) request.getNode()).getValue(), null, path);
+        }
+        if (isDelayedUpdate) lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null)
+                .onSuccessOrErrorDelayedRequests(request.getPath().toString());
+    }
+
+    /**
+     * @param sessionInfo   -
+     * @param deviceProfile -
+     */
+    public void onDeviceProfileUpdate(TransportProtos.SessionInfoProto sessionInfo, DeviceProfile deviceProfile) {
+        Set<String> registrationIds = lwM2mInMemorySecurityStore.getSessions().entrySet()
+                .stream()
+                .filter(e -> e.getValue().getProfileUuid().equals(deviceProfile.getUuidId()))
+                .map(Map.Entry::getKey).sorted().collect(Collectors.toCollection(LinkedHashSet::new));
+        if (registrationIds.size() > 0) {
+            this.onDeviceUpdateChangeProfile(registrationIds, deviceProfile);
+        }
+    }
+
+    /**
+     * @param sessionInfo      -
+     * @param device           -
+     * @param deviceProfileOpt -
+     */
+    public void onDeviceUpdate(TransportProtos.SessionInfoProto sessionInfo, Device device, Optional<DeviceProfile> deviceProfileOpt) {
+        Optional<String> registrationIdOpt = lwM2mInMemorySecurityStore.getSessions().entrySet().stream()
+                .filter(e -> device.getUuidId().equals(e.getValue().getDeviceUuid()))
+                .map(Map.Entry::getKey)
+                .findFirst();
+        registrationIdOpt.ifPresent(registrationId -> this.onDeviceUpdateLwM2MClient(registrationId, device, deviceProfileOpt));
+    }
+
+    /**
+     * Update parameters device in LwM2MClient
+     * If new deviceProfile != old deviceProfile => update deviceProfile
+     *
+     * @param registrationId -
+     * @param device         -
+     */
+    private void onDeviceUpdateLwM2MClient(String registrationId, Device device, Optional<DeviceProfile> deviceProfileOpt) {
+        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSessions().get(registrationId);
+        lwM2MClient.setDeviceName(device.getName());
+        if (!lwM2MClient.getProfileUuid().equals(device.getDeviceProfileId().getId())) {
+            Set<String> registrationIds = new HashSet<>();
+            registrationIds.add(registrationId);
+            deviceProfileOpt.ifPresent(deviceProfile -> this.onDeviceUpdateChangeProfile(registrationIds, deviceProfile));
+        }
+
+        lwM2MClient.setProfileUuid(device.getDeviceProfileId().getId());
+    }
+
+    /**
+     * #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)
+     * #4 update
+     * #4.1 add If #3 isChange, then analyze and update Value in Transport form Client and sent 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: sent Request observe to Client
+     * #5.3 Observe.del
+     * -- different between newObserve and oldObserve: sent Request cancel observe to client
+     *
+     * @param registrationIds -
+     * @param deviceProfile   -
+     */
+    private void onDeviceUpdateChangeProfile(Set<String> registrationIds, DeviceProfile deviceProfile) {
+
+        AttrTelemetryObserveValue attrTelemetryObserveValueOld = lwM2mInMemorySecurityStore.getProfiles().get(deviceProfile.getUuidId());
+        if (lwM2mInMemorySecurityStore.addUpdateProfileParameters(deviceProfile)) {
+
+            // #1
+            JsonArray attributeOld = attrTelemetryObserveValueOld.getPostAttributeProfile();
+            Set attributeSetOld = new Gson().fromJson(attributeOld, Set.class);
+            JsonArray telemetryOld = attrTelemetryObserveValueOld.getPostTelemetryProfile();
+            Set telemetrySetOld = new Gson().fromJson(telemetryOld, Set.class);
+            JsonArray observeOld = attrTelemetryObserveValueOld.getPostObserveProfile();
+            JsonObject keyNameOld = attrTelemetryObserveValueOld.getPostKeyNameProfile();
+
+            AttrTelemetryObserveValue attrTelemetryObserveValueNew = lwM2mInMemorySecurityStore.getProfiles().get(deviceProfile.getUuidId());
+            JsonArray attributeNew = attrTelemetryObserveValueNew.getPostAttributeProfile();
+            Set attributeSetNew = new Gson().fromJson(attributeNew, Set.class);
+            JsonArray telemetryNew = attrTelemetryObserveValueNew.getPostTelemetryProfile();
+            Set telemetrySetNew = new Gson().fromJson(telemetryNew, Set.class);
+            JsonArray observeNew = attrTelemetryObserveValueNew.getPostObserveProfile();
+            JsonObject keyNameNew = attrTelemetryObserveValueNew.getPostKeyNameProfile();
+
+            // #3
+            ResultsAnalyzerParameters sentAttrToThingsboard = new ResultsAnalyzerParameters();
+            // #3.1
+            if (!attributeOld.equals(attributeNew)) {
+                ResultsAnalyzerParameters postAttributeAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(attributeOld, Set.class), attributeSetNew);
+                sentAttrToThingsboard.getPathPostParametersAdd().addAll(postAttributeAnalyzer.getPathPostParametersAdd());
+                sentAttrToThingsboard.getPathPostParametersDel().addAll(postAttributeAnalyzer.getPathPostParametersDel());
+            }
+            // #3.2
+            if (!attributeOld.equals(attributeNew)) {
+                ResultsAnalyzerParameters postTelemetryAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(telemetryOld, Set.class), telemetrySetNew);
+                sentAttrToThingsboard.getPathPostParametersAdd().addAll(postTelemetryAnalyzer.getPathPostParametersAdd());
+                sentAttrToThingsboard.getPathPostParametersDel().addAll(postTelemetryAnalyzer.getPathPostParametersDel());
+            }
+            // #3.3
+            if (!keyNameOld.equals(keyNameNew)) {
+                ResultsAnalyzerParameters keyNameChange = this.getAnalyzerKeyName(new Gson().fromJson(keyNameOld.toString(), ConcurrentHashMap.class),
+                        new Gson().fromJson(keyNameNew.toString(), ConcurrentHashMap.class));
+                sentAttrToThingsboard.getPathPostParametersAdd().addAll(keyNameChange.getPathPostParametersAdd());
+            }
+
+            // #4.1 add
+            if (sentAttrToThingsboard.getPathPostParametersAdd().size() > 0) {
+                // update value in Resources
+                registrationIds.forEach(registrationId -> {
+                    LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(null, registrationId);
+                    LeshanServer lwServer = lwM2MClient.getLwServer();
+                    Registration registration = lwM2mInMemorySecurityStore.getByRegistration(registrationId);
+                    log.warn("[{}] # 4.1", registration.getEndpoint());
+                    this.updateResourceValueObserve(lwServer, registration, sentAttrToThingsboard.getPathPostParametersAdd(), GET_TYPE_OPER_READ);
+                    // sent attr/telemetry to tingsboard for new path
+                    this.updateAttrTelemetry(registration, false, sentAttrToThingsboard.getPathPostParametersAdd());
+                });
+            }
+            // #4.2 del
+            if (sentAttrToThingsboard.getPathPostParametersDel().size() > 0) {
+                ResultsAnalyzerParameters sentAttrToThingsboardDel = this.getAnalyzerParameters(sentAttrToThingsboard.getPathPostParametersAdd(), sentAttrToThingsboard.getPathPostParametersDel());
+                sentAttrToThingsboard.setPathPostParametersDel(sentAttrToThingsboardDel.getPathPostParametersDel());
+            }
+
+            // #5.1
+            if (!observeOld.equals(observeNew)) {
+                Set observeSetOld = new Gson().fromJson(observeOld, Set.class);
+                Set observeSetNew = new Gson().fromJson(observeNew, Set.class);
+                //#5.2 add
+                //  path Attr/Telemetry includes newObserve
+                attributeSetOld.addAll(telemetrySetOld);
+                ResultsAnalyzerParameters sentObserveToClientOld = this.getAnalyzerParametersIn(attributeSetOld, observeSetOld); // add observe
+                attributeSetNew.addAll(telemetrySetNew);
+                ResultsAnalyzerParameters sentObserveToClientNew = this.getAnalyzerParametersIn(attributeSetNew, observeSetNew); // add observe
+                // does not include oldObserve
+                ResultsAnalyzerParameters postObserveAnalyzer = this.getAnalyzerParameters(sentObserveToClientOld.getPathPostParametersAdd(), sentObserveToClientNew.getPathPostParametersAdd());
+                //  sent Request observe to Client
+                registrationIds.forEach(registrationId -> {
+                    LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClient(null, registrationId);
+                    LeshanServer lwServer = lwM2MClient.getLwServer();
+                    Registration registration = lwM2mInMemorySecurityStore.getByRegistration(registrationId);
+                    log.warn("[{}] # 5.1", registration.getEndpoint());
+                    this.updateResourceValueObserve(lwServer, registration, postObserveAnalyzer.getPathPostParametersAdd(), GET_TYPE_OPER_OBSERVE);
+                    // 5.3 del
+                    //  sent Request cancel observe to Client
+                    this.cancelObserveIsValue(lwServer, registration, 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 getAnalyzerKeyName(ConcurrentMap<String, String> keyNameOld, ConcurrentMap<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;
+    }
+
+    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
+     * sent response Read to Client and add path to pathResAttrTelemetry in LwM2MClient.getAttrTelemetryObserveValue()
+     *
+     * @param lwServer     - LeshanServer
+     * @param registration - Registration LwM2M Client
+     * @param targets      - path Resources == [ "/2/0/0", "/2/0/1"]
+     */
+    private void updateResourceValueObserve(LeshanServer lwServer, Registration registration, Set<String> targets, String typeOper) {
+        targets.forEach(target -> {
+            LwM2mPath pathIds = new LwM2mPath(target);
+            if (pathIds.isResource()) {
+                if (GET_TYPE_OPER_READ.equals(typeOper)) {
+                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
+                            ContentFormat.TLV.getName(), null, null, null, this.context.getCtxServer().getTimeout(),
+                            false);
+                } else if (GET_TYPE_OPER_OBSERVE.equals(typeOper)) {
+                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
+                            null, null, null, null, this.context.getCtxServer().getTimeout(),
+                            false);
+                }
+            }
+        });
+    }
+
+    private void cancelObserveIsValue(LeshanServer lwServer, Registration registration, Set<String> paramAnallyzer) {
+        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null);
+        paramAnallyzer.forEach(p -> {
+                    if (this.getResourceValue(lwM2MClient, new LwM2mPath(p)) != null) {
+                        this.setCancelObservationRecourse(lwServer, registration, p);
+                    }
+                }
+        );
+    }
+
+    private ResourceValue getResourceValue(LwM2MClient lwM2MClient, LwM2mPath pathIds) {
+        ResourceValue resourceValue = null;
+        if (pathIds.isResource()) {
+            resourceValue = lwM2MClient.getResources().get(pathIds.toString());
+        }
+        return resourceValue;
+    }
+
+    /**
+     * Trigger Server path = "/1/0/8"
+     *
+     * Trigger bootStrap path = "/1/0/9" - have to implemented on client
+     */
+    public void doTrigger(LeshanServer lwServer, Registration registration, String path) {
+        lwM2MTransportRequest.sendAllRequest(lwServer, registration, path, POST_TYPE_OPER_EXECUTE,
+                ContentFormat.TLV.getName(), null, null, null, this.context.getCtxServer().getTimeout(),
+                false);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * Deregister session in transport
+     *
+     * @param sessionInfo - lwm2m client
+     */
+    public void doDisconnect(SessionInfoProto sessionInfo) {
+        transportService.process(sessionInfo, DefaultTransportService.getSessionEventMsg(SessionEvent.CLOSED), null);
+        transportService.deregisterSession(sessionInfo);
+    }
+
+    private void checkInactivityAndReportActivity() {
+        lwM2mInMemorySecurityStore.getSessions().forEach((key, value) -> this.checkInactivity(this.getValidateSessionInfo(key)));
+    }
+
+    /**
+     * if sessionInfo removed from sessions, then new registerAsyncSession
+     *
+     * @param sessionInfo -
+     */
+    private void checkInactivity(SessionInfoProto sessionInfo) {
+        if (transportService.reportActivity(sessionInfo) == null) {
+            transportService.registerAsyncSession(sessionInfo, new LwM2MSessionMsgListener(this, sessionInfo));
+        }
+    }
+
+    public void sentLogsToThingsboard(String msg, Registration registration) {
+        if (msg != null) {
+            JsonObject telemetries = new JsonObject();
+            telemetries.addProperty(LOG_LW2M_TELEMETRY, msg);
+            this.updateParametersOnThingsboard(telemetries, LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC, registration);
+        }
+    }
+
+    /**
+     * @param path - path resource
+     * @return - value of Resource or null
+     */
+    private String getResourceValueToString(LwM2MClient lwM2MClient, String path) {
+        LwM2mPath pathIds = new LwM2mPath(path);
+        ResourceValue resourceValue = this.getResourceValue(lwM2MClient, pathIds);
+        return (resourceValue == null) ? null :
+                (String) this.converter.convertValue(resourceValue.getResourceValue(), this.context.getCtxServer().getResourceModelType(lwM2MClient.getRegistration(), pathIds), ResourceModel.Type.STRING, pathIds);
+    }
+}