Merge with FW/SW improvements

application/src/main/java/org/thingsboard/server/actors/device/DeviceActorMessageProcessor.java

@@ -192,6 +192,7 @@ class DeviceActorMessageProcessor extends AbstractContextAwareMsgProcessor {
                     syncSessionSet.add(key);
                 }
             });
+            log.trace("46) Rpc syncSessionSet [{}] subscription after sent [{}]",syncSessionSet, rpcSubscriptions);
             syncSessionSet.forEach(rpcSubscriptions::remove);
         }
 
@@ -454,7 +455,7 @@ class DeviceActorMessageProcessor extends AbstractContextAwareMsgProcessor {
         } else {
             SessionInfoMetaData sessionMD = sessions.get(sessionId);
             if (sessionMD == null) {
-                sessionMD = new SessionInfoMetaData(new SessionInfo(SessionType.SYNC, sessionInfo.getNodeId()));
+                sessionMD = new SessionInfoMetaData(new SessionInfo(subscribeCmd.getSessionType(), sessionInfo.getNodeId()));
             }
             sessionMD.setSubscribedToAttributes(true);
             log.debug("[{}] Registering attributes subscription for session [{}]", deviceId, sessionId);
@@ -475,7 +476,7 @@ class DeviceActorMessageProcessor extends AbstractContextAwareMsgProcessor {
         } else {
             SessionInfoMetaData sessionMD = sessions.get(sessionId);
             if (sessionMD == null) {
-                sessionMD = new SessionInfoMetaData(new SessionInfo(SessionType.SYNC, sessionInfo.getNodeId()));
+                sessionMD = new SessionInfoMetaData(new SessionInfo(subscribeCmd.getSessionType(), sessionInfo.getNodeId()));
             }
             sessionMD.setSubscribedToRPC(true);
             log.debug("[{}] Registering rpc subscription for session [{}]", deviceId, sessionId);

application/src/main/resources/thingsboard.yml

@@ -656,7 +656,7 @@ transport:
       bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
       bind_port: "${LWM2M_BIND_PORT_BS:5687}"
       security:
-        bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
+        bind_address: "${LWM2M_BIND_ADDRESS_SECURITY_BS:0.0.0.0}"
         bind_port: "${LWM2M_BIND_PORT_SECURITY_BS:5688}"
         #  Only for RPK: Public & Private Key. If the keystore file is missing or not working
         public_x: "${LWM2M_SERVER_PUBLIC_X_BS:5017c87a1c1768264656b3b355434b0def6edb8b9bf166a4762d9930cd730f91}"

common/queue/src/main/proto/queue.proto

@@ -310,10 +310,12 @@ message SessionCloseNotificationProto {
 
 message SubscribeToAttributeUpdatesMsg {
   bool unsubscribe = 1;
+  SessionType sessionType = 2;
 }
 
 message SubscribeToRPCMsg {
   bool unsubscribe = 1;
+  SessionType sessionType = 2;
 }
 
 message ToDeviceRpcRequestMsg {

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/bootstrap/LwM2MTransportBootstrapService.java

@@ -102,7 +102,7 @@ public class LwM2MTransportBootstrapService {
         builder.setLocalSecureAddress(bootstrapConfig.getSecureHost(), bootstrapConfig.getSecurePort());
 
         /** Create CoAP Config */
-        builder.setCoapConfig(getCoapConfig(bootstrapConfig.getPort(), bootstrapConfig.getSecurePort()));
+        builder.setCoapConfig(getCoapConfig(bootstrapConfig.getPort(), bootstrapConfig.getSecurePort(), serverConfig));
 
         /** Define model provider (Create Models )*/
 

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/AbstractLwM2mTransportResource.java

@@ -0,0 +1,92 @@
+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.californium.core.coap.CoAP;
+import org.eclipse.californium.core.coap.Response;
+import org.eclipse.californium.core.server.resources.CoapExchange;
+import org.eclipse.leshan.core.californium.LwM2mCoapResource;
+import org.thingsboard.server.common.transport.TransportServiceCallback;
+
+@Slf4j
+public abstract class AbstractLwM2mTransportResource extends LwM2mCoapResource {
+
+    public AbstractLwM2mTransportResource(String name) {
+        super(name);
+    }
+
+    @Override
+    public void handleGET(CoapExchange exchange) {
+        processHandleGet(exchange);
+    }
+
+    @Override
+    public void handlePOST(CoapExchange exchange) {
+        processHandlePost(exchange);
+    }
+
+    protected abstract void processHandleGet(CoapExchange exchange);
+
+    protected abstract void processHandlePost(CoapExchange exchange);
+
+    public static class CoapOkCallback implements TransportServiceCallback<Void> {
+        private final CoapExchange exchange;
+        private final CoAP.ResponseCode onSuccessResponse;
+        private final CoAP.ResponseCode onFailureResponse;
+
+        public CoapOkCallback(CoapExchange exchange, CoAP.ResponseCode onSuccessResponse, CoAP.ResponseCode onFailureResponse) {
+            this.exchange = exchange;
+            this.onSuccessResponse = onSuccessResponse;
+            this.onFailureResponse = onFailureResponse;
+        }
+
+        @Override
+        public void onSuccess(Void msg) {
+            Response response = new Response(onSuccessResponse);
+            response.setAcknowledged(isConRequest());
+            exchange.respond(response);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            exchange.respond(onFailureResponse);
+        }
+
+        private boolean isConRequest() {
+            return exchange.advanced().getRequest().isConfirmable();
+        }
+    }
+
+    public static class CoapNoOpCallback implements TransportServiceCallback<Void> {
+        private final CoapExchange exchange;
+
+        CoapNoOpCallback(CoapExchange exchange) {
+            this.exchange = exchange;
+        }
+
+        @Override
+        public void onSuccess(Void msg) {
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            exchange.respond(CoAP.ResponseCode.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+
+}

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/DefaultLwM2MTransportMsgHandler.java

@@ -5,7 +5,7 @@
  * 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
+ *     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,
@@ -62,7 +62,8 @@ import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClientStateExce
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientProfile;
-import org.thingsboard.server.transport.lwm2m.server.client.Lwm2mClientRpcRequest;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientRpcRequest;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mFwSwUpdate;
 import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
 import org.thingsboard.server.transport.lwm2m.server.client.ResultsAddKeyValueProto;
 import org.thingsboard.server.transport.lwm2m.server.client.ResultsAnalyzerParameters;
@@ -89,20 +90,21 @@ import java.util.stream.Collectors;
 import static org.eclipse.californium.core.coap.CoAP.ResponseCode.BAD_REQUEST;
 import static org.eclipse.leshan.core.attributes.Attribute.OBJECT_VERSION;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.DOWNLOADED;
+import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.FAILED;
+import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.INITIATED;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.UPDATING;
 import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_PATH;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportServerHelper.getValueFromKvProto;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.DEVICE_ATTRIBUTES_REQUEST;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_ID;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_5_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_RESULT_ID;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_STATE_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_ERROR;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_INFO;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_TELEMETRY;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_VALUE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_WARN;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LWM2M_STRATEGY_2;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.DISCOVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.EXECUTE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE_CANCEL;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE_CANCEL_ALL;
@@ -110,8 +112,8 @@ import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.L
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_ATTRIBUTES;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_REPLACE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SW_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SW_RESULT_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertJsonArrayToSet;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertOtaUpdateValueToString;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromIdVerToObjectId;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromObjectIdToIdVer;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.getAckCallback;
@@ -140,6 +142,7 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
     public final LwM2mClientContext clientContext;
     public final LwM2mTransportRequest lwM2mTransportRequest;
     private final Map<UUID, Long> rpcSubscriptions;
+    public final Map<String, Integer> firmwareUpdateState;
 
     public DefaultLwM2MTransportMsgHandler(TransportService transportService, LwM2MTransportServerConfig config, LwM2mTransportServerHelper helper,
                                            LwM2mClientContext clientContext,
@@ -155,6 +158,7 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
         this.context = context;
         this.adaptor = adaptor;
         this.rpcSubscriptions = new ConcurrentHashMap<>();
+        this.firmwareUpdateState = new ConcurrentHashMap<>();
         this.sessionStore = sessionStore;
     }
 
@@ -191,11 +195,12 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
                     this.sendLogsToThingsboard(lwM2MClient, LOG_LW2M_INFO + ": Client registered with registration id: " + registration.getId());
                     SessionInfoProto sessionInfo = lwM2MClient.getSession();
                     transportService.registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(this, sessionInfo));
+                    log.warn("40) sessionId [{}] Registering rpc subscription after Registration client", new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB()));
                     TransportProtos.TransportToDeviceActorMsg msg = TransportProtos.TransportToDeviceActorMsg.newBuilder()
                             .setSessionInfo(sessionInfo)
                             .setSessionEvent(DefaultTransportService.getSessionEventMsg(SessionEvent.OPEN))
-                            .setSubscribeToAttributes(TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().build())
+                            .setSubscribeToAttributes(TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().setSessionType(TransportProtos.SessionType.ASYNC).build())
-                            .setSubscribeToRPC(TransportProtos.SubscribeToRPCMsg.newBuilder().build())
+                            .setSubscribeToRPC(TransportProtos.SubscribeToRPCMsg.newBuilder().setSessionType(TransportProtos.SessionType.ASYNC).build())
                             .build();
                     transportService.process(msg, null);
                     this.getInfoFirmwareUpdate(lwM2MClient, null);
@@ -238,10 +243,10 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
                     }
                 }
             } catch (LwM2MClientStateException stateException) {
-                if (LwM2MClientState.UNREGISTERED.equals(stateException.getState())) {
+                if (LwM2MClientState.REGISTERED.equals(stateException.getState())) {
-                    log.info("[{}] update registration failed because client was already unregistered: [{}].", registration.getEndpoint(), stateException.getState());
+                    log.info("[{}] update registration failed because client has different registration id: [{}] {}.", registration.getEndpoint(), stateException.getState(), stateException.getMessage());
                 } else {
-                    log.info("[{}] update registration: [{}] {}.", registration.getEndpoint(), stateException.getState(), stateException.getMessage());
+                    onRegistered(registration, Collections.emptyList());
                 }
             } catch (Throwable t) {
                 log.error("[{}] endpoint [{}] error Unable update registration.", registration.getEndpoint(), t);
@@ -263,8 +268,8 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
                 SessionInfoProto sessionInfo = client.getSession();
                 if (sessionInfo != null) {
                     transportService.deregisterSession(sessionInfo);
-                    sessionStore.remove(registration.getEndpoint());
                     this.doCloseSession(sessionInfo);
+                    sessionStore.remove(registration.getEndpoint());
                     log.info("Client close session: [{}] unReg [{}] name  [{}] profile ", registration.getId(), registration.getEndpoint(), sessionInfo.getDeviceType());
                 } else {
                     log.error("Client close session: [{}] unReg [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), null);
@@ -307,7 +312,7 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
      * @param response     - observe
      */
     @Override
-    public void onUpdateValueAfterReadResponse(Registration registration, String path, ReadResponse response, Lwm2mClientRpcRequest rpcRequest) {
+    public void onUpdateValueAfterReadResponse(Registration registration, String path, ReadResponse response, LwM2mClientRpcRequest rpcRequest) {
         if (response.getContent() != null) {
             LwM2mClient lwM2MClient = clientContext.getClientByEndpoint(registration.getEndpoint());
             ObjectModel objectModelVersion = lwM2MClient.getObjectModel(path, this.config.getModelProvider());
@@ -330,7 +335,7 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
     }
 
     private void sendRpcRequestAfterReadResponse(Registration registration, LwM2mClient lwM2MClient, String pathIdVer, ReadResponse response,
-                                                 Lwm2mClientRpcRequest rpcRequest) {
+                                                 LwM2mClientRpcRequest rpcRequest) {
         Object value = null;
         if (response.getContent() instanceof LwM2mObject) {
             value = lwM2MClient.objectToString((LwM2mObject) response.getContent(), this.converter, pathIdVer);
@@ -447,7 +452,7 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
 
     /**
      * #1 del from rpcSubscriptions by timeout
-     * #2 if not present in rpcSubscriptions by requestId: create new Lwm2mClientRpcRequest, after success - add requestId, timeout
+     * #2 if not present in rpcSubscriptions by requestId: create new LwM2mClientRpcRequest, after success - add requestId, timeout
      */
     @Override
     public void onToDeviceRpcRequest(TransportProtos.ToDeviceRpcRequestMsg toDeviceRpcRequestMsg, SessionInfoProto sessionInfo) {
@@ -459,39 +464,53 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
         UUID requestUUID = new UUID(toDeviceRpcRequestMsg.getRequestIdMSB(), toDeviceRpcRequestMsg.getRequestIdLSB());
         if (!this.rpcSubscriptions.containsKey(requestUUID)) {
             this.rpcSubscriptions.put(requestUUID, toDeviceRpcRequestMsg.getExpirationTime());
-            Lwm2mClientRpcRequest lwm2mClientRpcRequest = null;
+            LwM2mClientRpcRequest lwm2mClientRpcRequest = null;
             try {
                 LwM2mClient client = clientContext.getClientBySessionInfo(sessionInfo);
                 Registration registration = client.getRegistration();
-                lwm2mClientRpcRequest = new Lwm2mClientRpcRequest(lwM2mTypeOper, bodyParams, toDeviceRpcRequestMsg.getRequestId(), sessionInfo, registration, this);
+                if(registration != null) {
-                if (lwm2mClientRpcRequest.getErrorMsg() != null) {
+                    lwm2mClientRpcRequest = new LwM2mClientRpcRequest(lwM2mTypeOper, bodyParams, toDeviceRpcRequestMsg.getRequestId(), sessionInfo, registration, this);
-                    lwm2mClientRpcRequest.setResponseCode(BAD_REQUEST.name());
+                    if (lwm2mClientRpcRequest.getErrorMsg() != null) {
-                    this.onToDeviceRpcResponse(lwm2mClientRpcRequest.getDeviceRpcResponseResultMsg(), sessionInfo);
+                        lwm2mClientRpcRequest.setResponseCode(BAD_REQUEST.name());
+                        this.onToDeviceRpcResponse(lwm2mClientRpcRequest.getDeviceRpcResponseResultMsg(), sessionInfo);
+                    } else {
+                        lwM2mTransportRequest.sendAllRequest(client, lwm2mClientRpcRequest.getTargetIdVer(), lwm2mClientRpcRequest.getTypeOper(),
+                                null,
+                                lwm2mClientRpcRequest.getValue() == null ? lwm2mClientRpcRequest.getParams() : lwm2mClientRpcRequest.getValue(),
+                                this.config.getTimeout(), lwm2mClientRpcRequest);
+                    }
                 } else {
-                    lwM2mTransportRequest.sendAllRequest(client, lwm2mClientRpcRequest.getTargetIdVer(), lwm2mClientRpcRequest.getTypeOper(),
+                    this.sendErrorRpcResponse(lwm2mClientRpcRequest, "registration == null", sessionInfo);
-                            null,
-                            lwm2mClientRpcRequest.getValue() == null ? lwm2mClientRpcRequest.getParams() : lwm2mClientRpcRequest.getValue(),
-                            this.config.getTimeout(), lwm2mClientRpcRequest);
                 }
             } catch (Exception e) {
-                if (lwm2mClientRpcRequest == null) {
+                this.sendErrorRpcResponse(lwm2mClientRpcRequest, e.getMessage(), sessionInfo);
-                    lwm2mClientRpcRequest = new Lwm2mClientRpcRequest();
-                }
-                lwm2mClientRpcRequest.setResponseCode(BAD_REQUEST.name());
-                if (lwm2mClientRpcRequest.getErrorMsg() == null) {
-                    lwm2mClientRpcRequest.setErrorMsg(e.getMessage());
-                }
-                this.onToDeviceRpcResponse(lwm2mClientRpcRequest.getDeviceRpcResponseResultMsg(), sessionInfo);
             }
         }
     }
 
+    private void sendErrorRpcResponse(LwM2mClientRpcRequest lwm2mClientRpcRequest, String msgError, SessionInfoProto sessionInfo) {
+        if (lwm2mClientRpcRequest == null) {
+            lwm2mClientRpcRequest = new LwM2mClientRpcRequest();
+        }
+        lwm2mClientRpcRequest.setResponseCode(BAD_REQUEST.name());
+        if (lwm2mClientRpcRequest.getErrorMsg() == null) {
+            lwm2mClientRpcRequest.setErrorMsg(msgError);
+        }
+        this.onToDeviceRpcResponse(lwm2mClientRpcRequest.getDeviceRpcResponseResultMsg(), sessionInfo);
+    }
+
     private void checkRpcRequestTimeout() {
-        Set<UUID> rpcSubscriptionsToRemove = rpcSubscriptions.entrySet().stream().filter(kv -> System.currentTimeMillis() > kv.getValue()).map(Map.Entry::getKey).collect(Collectors.toSet());
+        log.warn("4.1) before rpcSubscriptions.size(): [{}]", rpcSubscriptions.size());
-        rpcSubscriptionsToRemove.forEach(rpcSubscriptions::remove);
+        if (rpcSubscriptions.size() > 0) {
+            Set<UUID> rpcSubscriptionsToRemove = rpcSubscriptions.entrySet().stream().filter(kv -> System.currentTimeMillis() > kv.getValue()).map(Map.Entry::getKey).collect(Collectors.toSet());
+            log.warn("4.2) System.currentTimeMillis(): [{}]", System.currentTimeMillis());
+            log.warn("4.3) rpcSubscriptionsToRemove: [{}]", rpcSubscriptionsToRemove);
+            rpcSubscriptionsToRemove.forEach(rpcSubscriptions::remove);
+        }
+        log.warn("4.4) after rpcSubscriptions.size(): [{}]", rpcSubscriptions.size());
     }
 
-    public void sentRpcResponse(Lwm2mClientRpcRequest rpcRequest, String requestCode, String msg, String typeMsg) {
+    public void sentRpcResponse(LwM2mClientRpcRequest rpcRequest, String requestCode, String msg, String typeMsg) {
         rpcRequest.setResponseCode(requestCode);
         if (LOG_LW2M_ERROR.equals(typeMsg)) {
             rpcRequest.setInfoMsg(null);
@@ -593,7 +612,7 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
         LwM2mClientProfile lwM2MClientProfile = clientContext.getProfile(lwM2MClient.getProfileId());
         Set<String> clientObjects = clientContext.getSupportedIdVerInClient(lwM2MClient);
         if (clientObjects != null && clientObjects.size() > 0) {
-            if (LWM2M_STRATEGY_2 == LwM2mTransportUtil.getClientOnlyObserveAfterConnect(lwM2MClientProfile)) {
+            if (LwM2mTransportUtil.LwM2MClientStrategy.CLIENT_STRATEGY_2.code == lwM2MClientProfile.getClientStrategy()) {
                 // #2
                 lwM2MClient.getPendingReadRequests().addAll(clientObjects);
                 clientObjects.forEach(path -> lwM2mTransportRequest.sendAllRequest(lwM2MClient, path, READ,
@@ -650,60 +669,18 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
             /** version != null
              * set setClient_fw_info... = value
              **/
-            if (lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
+            if (lwM2MClient.getFwUpdate() != null && lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
                 lwM2MClient.getFwUpdate().initReadValue(this, this.lwM2mTransportRequest, path);
             }
-            if (lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
+            if (lwM2MClient.getSwUpdate() != null && lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
                 lwM2MClient.getSwUpdate().initReadValue(this, this.lwM2mTransportRequest, path);
             }
 
-            /**
+            if ((convertPathFromObjectIdToIdVer(FW_RESULT_ID, registration).equals(path)) ||
-             * Before operation Execute (FwUpdate) inspection Update Result :
+                    (convertPathFromObjectIdToIdVer(FW_STATE_ID, registration).equals(path))) {
-             *  - after finished operation Write result: success (FwUpdate): fw_state = DOWNLOADED
+                LwM2mFwSwUpdate fwUpdate = lwM2MClient.getFwUpdate(clientContext);
-             *  - before start operation Execute (FwUpdate) Update Result = 0 - Initial value
+                log.warn("93) path: [{}] value: [{}]", path, lwM2mResource.getValue());
-             *  - start Execute (FwUpdate)
+                fwUpdate.updateStateOta(this, lwM2mTransportRequest, registration, path, ((Long) lwM2mResource.getValue()).intValue());
-             *  After finished operation Execute (FwUpdate) inspection Update Result :
-             *  - after start operation Execute (FwUpdate):  fw_state = UPDATING
-             *  - after success finished operation Execute (FwUpdate) Update Result == 1 ("Firmware updated successfully")
-             *  - finished operation Execute (FwUpdate)
-             */
-            if (lwM2MClient.getFwUpdate() != null
-                    && (convertPathFromObjectIdToIdVer(FW_RESULT_ID, registration).equals(path))) {
-                if (DOWNLOADED.name().equals(lwM2MClient.getFwUpdate().getStateUpdate())
-                        && lwM2MClient.getFwUpdate().conditionalFwExecuteStart()) {
-                    lwM2MClient.getFwUpdate().executeFwSwWare(this, this.lwM2mTransportRequest);
-                } else if (UPDATING.name().equals(lwM2MClient.getFwUpdate().getStateUpdate())
-                        && lwM2MClient.getFwUpdate().conditionalFwExecuteAfterSuccess()) {
-                    lwM2MClient.getFwUpdate().finishFwSwUpdate(this, true);
-                } else if (UPDATING.name().equals(lwM2MClient.getFwUpdate().getStateUpdate())
-                        && lwM2MClient.getFwUpdate().conditionalFwExecuteAfterError()) {
-                    lwM2MClient.getFwUpdate().finishFwSwUpdate(this, false);
-                }
-            }
-
-            /**
-             * Before operation Execute (SwUpdate) inspection Update Result :
-             *  - after finished operation Write result: success (SwUpdate): fw_state = DOWNLOADED
-             *  - before operation Execute (SwUpdate) Update Result = 3 - Successfully Downloaded and package integrity verified
-             *  - start Execute (SwUpdate)
-             *  After finished operation Execute (SwUpdate) inspection Update Result :
-             *  - after start operation Execute (SwUpdate):  fw_state = UPDATING
-             *  - after success finished operation Execute (SwUpdate) Update Result == 2 "Software successfully installed.""
-             *  - after success finished operation Execute (SwUpdate) Update Result == 2 "Software successfully installed.""
-             *  - finished operation Execute (SwUpdate)
-             */
-            if (lwM2MClient.getSwUpdate() != null
-                    && (convertPathFromObjectIdToIdVer(SW_RESULT_ID, registration).equals(path))) {
-                if (DOWNLOADED.name().equals(lwM2MClient.getSwUpdate().getStateUpdate())
-                        && lwM2MClient.getSwUpdate().conditionalSwUpdateExecute()) {
-                    lwM2MClient.getSwUpdate().executeFwSwWare(this, this.lwM2mTransportRequest);
-                } else if (UPDATING.name().equals(lwM2MClient.getSwUpdate().getStateUpdate())
-                        && lwM2MClient.getSwUpdate().conditionalSwExecuteAfterSuccess()) {
-                    lwM2MClient.getSwUpdate().finishFwSwUpdate(this, true);
-                } else if (UPDATING.name().equals(lwM2MClient.getSwUpdate().getStateUpdate())
-                        && lwM2MClient.getSwUpdate().conditionalSwExecuteAfterError()) {
-                    lwM2MClient.getSwUpdate().finishFwSwUpdate(this, false);
-                }
             }
             Set<String> paths = new HashSet<>();
             paths.add(path);
@@ -865,8 +842,9 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
                             valueKvProto = new JsonObject();
                             Object finalvalueKvProto = valueKvProto;
                             Gson gson = new GsonBuilder().create();
+                            ResourceModel.Type finalCurrentType = currentType;
                             resourceValue.getInstances().forEach((k, v) -> {
-                                Object val = this.converter.convertValue(v, currentType, expectedType,
+                                Object val = this.converter.convertValue(v, finalCurrentType, expectedType,
                                         new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer)));
                                 JsonElement element = gson.toJsonTree(val, val.getClass());
                                 ((JsonObject) finalvalueKvProto).add(String.valueOf(k), element);
@@ -876,6 +854,9 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
                             valueKvProto = this.converter.convertValue(resourceValue.getValue(), currentType, expectedType,
                                     new LwM2mPath(convertPathFromIdVerToObjectId(pathIdVer)));
                         }
+                        LwM2mOtaConvert lwM2mOtaConvert = convertOtaUpdateValueToString(pathIdVer, valueKvProto, currentType);
+                        valueKvProto = lwM2mOtaConvert.getValue();
+                        currentType = lwM2mOtaConvert.getCurrentType();
                         return valueKvProto != null ? this.helper.getKvAttrTelemetryToThingsboard(currentType, resourceName, valueKvProto, resourceValue.isMultiInstances()) : null;
                     }
                 } catch (Exception e) {
@@ -1340,8 +1321,8 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
         }
     }
 
-    public void getInfoFirmwareUpdate(LwM2mClient lwM2MClient, Lwm2mClientRpcRequest rpcRequest) {
+    public void getInfoFirmwareUpdate(LwM2mClient lwM2MClient, LwM2mClientRpcRequest rpcRequest) {
-        if (lwM2MClient.getRegistration().getSupportedVersion(FW_ID) != null) {
+        if (lwM2MClient.getRegistration().getSupportedVersion(FW_5_ID) != null) {
             SessionInfoProto sessionInfo = this.getSessionInfo(lwM2MClient);
             if (sessionInfo != null) {
                 DefaultLwM2MTransportMsgHandler handler = this;
@@ -1351,18 +1332,33 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
                             public void onSuccess(TransportProtos.GetOtaPackageResponseMsg response) {
                                 if (TransportProtos.ResponseStatus.SUCCESS.equals(response.getResponseStatus())
                                         && response.getType().equals(OtaPackageType.FIRMWARE.name())) {
-                                    log.warn("7) firmware start with ver: [{}]", response.getVersion());
+                                    LwM2mFwSwUpdate fwUpdate = lwM2MClient.getFwUpdate(clientContext);
-                                    lwM2MClient.getFwUpdate().setRpcRequest(rpcRequest);
+                                    if (rpcRequest != null) {
-                                    lwM2MClient.getFwUpdate().setCurrentVersion(response.getVersion());
+                                        fwUpdate.setStateUpdate(INITIATED.name());
-                                    lwM2MClient.getFwUpdate().setCurrentTitle(response.getTitle());
+                                    }
-                                    lwM2MClient.getFwUpdate().setCurrentId(new OtaPackageId(new UUID(response.getOtaPackageIdMSB(), response.getOtaPackageIdLSB())).getId());
+                                    if (!FAILED.name().equals(fwUpdate.getStateUpdate())) {
-                                    if (rpcRequest == null) {
+                                        log.warn("7) firmware start with ver: [{}]", response.getVersion());
-                                        lwM2MClient.getFwUpdate().sendReadObserveInfo(lwM2mTransportRequest);
+                                        fwUpdate.setRpcRequest(rpcRequest);
+                                        fwUpdate.setCurrentVersion(response.getVersion());
+                                        fwUpdate.setCurrentTitle(response.getTitle());
+                                        fwUpdate.setCurrentId(new UUID(response.getOtaPackageIdMSB(), response.getOtaPackageIdLSB()));
+                                        if (rpcRequest == null) {
+                                            fwUpdate.sendReadObserveInfo(lwM2mTransportRequest);
+                                        } else {
+                                            fwUpdate.writeFwSwWare(handler, lwM2mTransportRequest);
+                                        }
                                     } else {
-                                        lwM2MClient.getFwUpdate().writeFwSwWare(handler, lwM2mTransportRequest);
+                                        String msgError = String.format("OtaPackage device: %s, version: %s, stateUpdate: %s",
+                                                lwM2MClient.getDeviceName(), response.getVersion(), fwUpdate.getStateUpdate());
+                                        log.warn("7_1 [{}]", msgError);
                                     }
                                 } else {
-                                    log.trace("OtaPackage [{}] [{}]", lwM2MClient.getDeviceName(), response.getResponseStatus().toString());
+                                    String msgError = String.format("OtaPackage device: %s, responseStatus: %s",
+                                            lwM2MClient.getDeviceName(), response.getResponseStatus().toString());
+                                    log.trace(msgError);
+                                    if (rpcRequest != null) {
+                                        sendErrorRpcResponse(rpcRequest, msgError, sessionInfo);
+                                    }
                                 }
                             }
 
@@ -1375,7 +1371,7 @@ public class DefaultLwM2MTransportMsgHandler implements LwM2mTransportMsgHandler
         }
     }
 
-    public void getInfoSoftwareUpdate(LwM2mClient lwM2MClient, Lwm2mClientRpcRequest rpcRequest) {
+    public void getInfoSoftwareUpdate(LwM2mClient lwM2MClient, LwM2mClientRpcRequest rpcRequest) {
         if (lwM2MClient.getRegistration().getSupportedVersion(SW_ID) != null) {
             SessionInfoProto sessionInfo = this.getSessionInfo(lwM2MClient);
             if (sessionInfo != null) {

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/DefaultLwM2mTransportService.java

@@ -28,7 +28,6 @@ import org.eclipse.leshan.server.californium.registration.CaliforniumRegistratio
 import org.eclipse.leshan.server.model.LwM2mModelProvider;
 import org.eclipse.leshan.server.security.EditableSecurityStore;
 import org.springframework.stereotype.Component;
-import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.server.common.data.StringUtils;
 import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
@@ -60,14 +59,13 @@ import java.security.spec.InvalidParameterSpecException;
 import java.security.spec.KeySpec;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.util.Arrays;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
 
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256;
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CBC_SHA256;
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CCM_8;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mNetworkConfig.getCoapConfig;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FIRMWARE_UPDATE_COAP_RECOURSE;
 
 @Slf4j
 @Component
@@ -83,7 +81,7 @@ public class DefaultLwM2mTransportService implements LwM2MTransportService {
     private final LwM2mTransportContext context;
     private final LwM2MTransportServerConfig config;
     private final LwM2mTransportServerHelper helper;
-    private final LwM2mTransportMsgHandler handler;
+    private final DefaultLwM2MTransportMsgHandler handler;
     private final CaliforniumRegistrationStore registrationStore;
     private final TbSecurityStore securityStore;
     private final LwM2mClientContext lwM2mClientContext;
@@ -98,6 +96,17 @@ public class DefaultLwM2mTransportService implements LwM2MTransportService {
             new LWM2MGenerationPSkRPkECC();
         }
         this.server = getLhServer();
+        /**
+         * Add a resource to the server.
+         * CoapResource ->
+         * path = FW_PACKAGE or SW_PACKAGE
+         * nameFile = "BC68JAR01A09_TO_BC68JAR01A10.bin"
+         * "coap://host:port/{path}/{token}/{nameFile}"
+         */
+
+
+        LwM2mTransportCoapResource otaCoapResource = new LwM2mTransportCoapResource(handler, FIRMWARE_UPDATE_COAP_RECOURSE);
+        this.server.coap().getServer().add(otaCoapResource);
         this.startLhServer();
         this.context.setServer(server);
     }
@@ -128,7 +137,7 @@ public class DefaultLwM2mTransportService implements LwM2MTransportService {
         builder.setEncoder(new DefaultLwM2mNodeEncoder(LwM2mValueConverterImpl.getInstance()));
 
         /* Create CoAP Config */
-        builder.setCoapConfig(getCoapConfig(config.getPort(), config.getSecurePort()));
+        builder.setCoapConfig(getCoapConfig(config.getPort(), config.getSecurePort(), config));
 
         /* Define model provider (Create Models )*/
         LwM2mModelProvider modelProvider = new LwM2mVersionedModelProvider(this.lwM2mClientContext, this.helper, this.context);

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/LwM2mNetworkConfig.java

@@ -16,10 +16,14 @@
 package org.thingsboard.server.transport.lwm2m.server;
 
 import org.eclipse.californium.core.network.config.NetworkConfig;
+import org.eclipse.californium.core.network.config.NetworkConfigDefaults;
+import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
+
+import static org.eclipse.californium.core.network.config.NetworkConfigDefaults.DEFAULT_BLOCKWISE_STATUS_LIFETIME;
 
 public class LwM2mNetworkConfig {
 
-    public static NetworkConfig getCoapConfig(Integer serverPortNoSec, Integer serverSecurePort) {
+    public static NetworkConfig getCoapConfig(Integer serverPortNoSec, Integer serverSecurePort, LwM2MTransportServerConfig config) {
         NetworkConfig coapConfig = new NetworkConfig();
         coapConfig.setInt(NetworkConfig.Keys.COAP_PORT,serverPortNoSec);
         coapConfig.setInt(NetworkConfig.Keys.COAP_SECURE_PORT,serverSecurePort);
@@ -49,8 +53,15 @@ public class LwM2mNetworkConfig {
          - value of true indicate that the server will response with block2 option event if no further blocks are required.
          */
         coapConfig.setBoolean(NetworkConfig.Keys.BLOCKWISE_ENTITY_TOO_LARGE_AUTO_FAILOVER, true);
-
+        /**
-        coapConfig.setInt(NetworkConfig.Keys.BLOCKWISE_STATUS_LIFETIME, 300000);
+         * The maximum amount of time (in milliseconds) allowed between
+         * transfers of individual blocks in a blockwise transfer before the
+         * blockwise transfer state is discarded.
+         * <p>
+         * The default value of this property is
+         * {@link NetworkConfigDefaults#DEFAULT_BLOCKWISE_STATUS_LIFETIME} = 5 * 60 * 1000; // 5 mins [ms].
+         */
+        coapConfig.setLong(NetworkConfig.Keys.BLOCKWISE_STATUS_LIFETIME, DEFAULT_BLOCKWISE_STATUS_LIFETIME);
         /**
          !!! REQUEST_ENTITY_TOO_LARGE CODE=4.13
          The maximum size of a resource body (in bytes) that will be accepted

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/LwM2mOtaConvert.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+import lombok.Data;
+import org.eclipse.leshan.core.model.ResourceModel;
+
+@Data
+public class LwM2mOtaConvert {
+    private ResourceModel.Type currentType;
+    private Object value;
+}

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/LwM2mTransportCoapResource.java

@@ -0,0 +1,156 @@
+/**
+ * Copyright © 2016-2021 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.lwm2m.server;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.californium.core.coap.CoAP;
+import org.eclipse.californium.core.coap.Request;
+import org.eclipse.californium.core.coap.Response;
+import org.eclipse.californium.core.network.Exchange;
+import org.eclipse.californium.core.observe.ObserveRelation;
+import org.eclipse.californium.core.server.resources.CoapExchange;
+import org.eclipse.californium.core.server.resources.Resource;
+import org.eclipse.californium.core.server.resources.ResourceObserver;
+
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FIRMWARE_UPDATE_COAP_RECOURSE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SOFTWARE_UPDATE_COAP_RECOURSE;
+
+@Slf4j
+public class LwM2mTransportCoapResource extends AbstractLwM2mTransportResource {
+    private final ConcurrentMap<String, ObserveRelation> tokenToObserveRelationMap = new ConcurrentHashMap<>();
+    private final ConcurrentMap<String, AtomicInteger> tokenToObserveNotificationSeqMap = new ConcurrentHashMap<>();
+    private final LwM2mTransportMsgHandler handler;
+
+    public LwM2mTransportCoapResource(LwM2mTransportMsgHandler handler, String name) {
+        super(name);
+        this.handler = handler;
+        this.setObservable(true); // enable observing
+        this.addObserver(new CoapResourceObserver());
+    }
+
+
+    @Override
+    public void checkObserveRelation(Exchange exchange, Response response) {
+        String token = getTokenFromRequest(exchange.getRequest());
+        final ObserveRelation relation = exchange.getRelation();
+        if (relation == null || relation.isCanceled()) {
+            return; // because request did not try to establish a relation
+        }
+        if (CoAP.ResponseCode.isSuccess(response.getCode())) {
+
+            if (!relation.isEstablished()) {
+                relation.setEstablished();
+                addObserveRelation(relation);
+            }
+            AtomicInteger notificationCounter = tokenToObserveNotificationSeqMap.computeIfAbsent(token, s -> new AtomicInteger(0));
+            response.getOptions().setObserve(notificationCounter.getAndIncrement());
+        } // ObserveLayer takes care of the else case
+    }
+
+
+    @Override
+    protected void processHandleGet(CoapExchange exchange) {
+        log.warn("90) processHandleGet [{}]", exchange);
+        if (exchange.getRequestOptions().getUriPath().size() == 2 &&
+                (FIRMWARE_UPDATE_COAP_RECOURSE.equals(exchange.getRequestOptions().getUriPath().get(0)) ||
+                 SOFTWARE_UPDATE_COAP_RECOURSE.equals(exchange.getRequestOptions().getUriPath().get(0)))) {
+            this.sentOtaData(exchange);
+        }
+    }
+
+    @Override
+    protected void processHandlePost(CoapExchange exchange) {
+        log.warn("2) processHandleGet [{}]", exchange);
+    }
+
+    /**
+     * Override the default behavior so that requests to sub resources (typically /{name}/{token}) are handled by
+     * /name resource.
+     */
+    @Override
+    public Resource getChild(String name) {
+        return this;
+    }
+
+
+    private String getTokenFromRequest(Request request) {
+        return (request.getSourceContext() != null ? request.getSourceContext().getPeerAddress().getAddress().getHostAddress() : "null")
+                + ":" + (request.getSourceContext() != null ? request.getSourceContext().getPeerAddress().getPort() : -1) + ":" + request.getTokenString();
+    }
+
+    public class CoapResourceObserver implements ResourceObserver {
+
+        @Override
+        public void changedName(String old) {
+
+        }
+
+        @Override
+        public void changedPath(String old) {
+
+        }
+
+        @Override
+        public void addedChild(Resource child) {
+
+        }
+
+        @Override
+        public void removedChild(Resource child) {
+
+        }
+
+        @Override
+        public void addedObserveRelation(ObserveRelation relation) {
+
+        }
+
+        @Override
+        public void removedObserveRelation(ObserveRelation relation) {
+
+        }
+    }
+
+    private void sentOtaData(CoapExchange exchange) {
+        String idStr = exchange.getRequestOptions().getUriPath().get(1);
+        UUID currentId = UUID.fromString(idStr);
+        if (exchange.getRequestOptions().getBlock2() != null) {
+            int chunkSize = exchange.getRequestOptions().getBlock2().getSzx();
+            int chunk = 0;
+            Response response = new Response(CoAP.ResponseCode.CONTENT);
+            byte[] fwData = this.getOtaData(currentId);
+            log.warn("91) read softWare data (length): [{}]", fwData.length);
+            if (fwData != null && fwData.length > 0) {
+                response.setPayload(fwData);
+                boolean moreFlag = fwData.length > chunkSize;
+                response.getOptions().setBlock2(chunkSize, moreFlag, chunk);
+                log.warn("92) Send currentId: [{}], length: [{}], chunkSize [{}], moreFlag [{}]", currentId.toString(), fwData.length, chunkSize, moreFlag);
+                exchange.respond(response);
+            }
+
+        }
+    }
+
+    private byte[] getOtaData(UUID currentId) {
+        return ((DefaultLwM2MTransportMsgHandler) handler).otaPackageDataCache.get(currentId.toString());
+    }
+
+}

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/LwM2mTransportMsgHandler.java

@@ -23,7 +23,7 @@ import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
-import org.thingsboard.server.transport.lwm2m.server.client.Lwm2mClientRpcRequest;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientRpcRequest;
 
 import java.util.Collection;
 import java.util.Optional;
@@ -40,7 +40,7 @@ public interface LwM2mTransportMsgHandler {
 
     void setCancelObservationsAll(Registration registration);
 
-    void onUpdateValueAfterReadResponse(Registration registration, String path, ReadResponse response, Lwm2mClientRpcRequest rpcRequest);
+    void onUpdateValueAfterReadResponse(Registration registration, String path, ReadResponse response, LwM2mClientRpcRequest rpcRequest);
 
     void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg msg, TransportProtos.SessionInfoProto sessionInfo);
 

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/LwM2mTransportRequest.java

@@ -55,7 +55,7 @@ import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.transport.lwm2m.config.LwM2MTransportServerConfig;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
-import org.thingsboard.server.transport.lwm2m.server.client.Lwm2mClientRpcRequest;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientRpcRequest;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 
 import javax.annotation.PostConstruct;
@@ -75,7 +75,7 @@ import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.DOWN
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.FAILED;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportServerHelper.getContentFormatByResourceModelType;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.DEFAULT_TIMEOUT;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_PACKAGE_ID;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_PACKAGE_5_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_UPDATE_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_ERROR;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_INFO;
@@ -116,13 +116,13 @@ public class LwM2mTransportRequest {
                 new NamedThreadFactory(String.format("LwM2M %s channel response after request", RESPONSE_REQUEST_CHANNEL)));
     }
 
-    public void sendAllRequest(LwM2mClient lwM2MClient, String targetIdVer, LwM2mTypeOper typeOper, Object params, long timeoutInMs, Lwm2mClientRpcRequest lwm2mClientRpcRequest) {
+    public void sendAllRequest(LwM2mClient lwM2MClient, String targetIdVer, LwM2mTypeOper typeOper, Object params, long timeoutInMs, LwM2mClientRpcRequest lwm2mClientRpcRequest) {
         sendAllRequest(lwM2MClient, targetIdVer, typeOper, lwM2MClient.getDefaultContentFormat(), params, timeoutInMs, lwm2mClientRpcRequest);
     }
 
 
     public void sendAllRequest(LwM2mClient lwM2MClient, String targetIdVer, LwM2mTypeOper typeOper,
-                               ContentFormat contentFormat, Object params, long timeoutInMs, Lwm2mClientRpcRequest lwm2mClientRpcRequest) {
+                               ContentFormat contentFormat, Object params, long timeoutInMs, LwM2mClientRpcRequest lwm2mClientRpcRequest) {
         Registration registration = lwM2MClient.getRegistration();
         try {
             String target = convertPathFromIdVerToObjectId(targetIdVer);
@@ -141,7 +141,7 @@ public class LwM2mTransportRequest {
                         } catch (ClientSleepingException e) {
                             SimpleDownlinkRequest finalRequest = request;
                             long finalTimeoutInMs = timeoutInMs;
-                            Lwm2mClientRpcRequest finalRpcRequest = lwm2mClientRpcRequest;
+                            LwM2mClientRpcRequest finalRpcRequest = lwm2mClientRpcRequest;
                             lwM2MClient.getQueuedRequests().add(() -> sendRequest(registration, lwM2MClient, finalRequest, finalTimeoutInMs, finalRpcRequest));
                         } catch (Exception e) {
                             log.error("[{}] [{}] [{}] Failed to send downlink.", registration.getEndpoint(), targetIdVer, typeOper.name(), e);
@@ -161,12 +161,12 @@ public class LwM2mTransportRequest {
                         if (lwm2mClientRpcRequest != null) {
                             ResourceModel resourceModel = lwM2MClient.getResourceModel(targetIdVer, this.config.getModelProvider());
                             String errorMsg = resourceModel == null ? String.format("Path %s not found in object version", targetIdVer) : "SendRequest - null";
-                            this.handler.sentRpcResponse(lwm2mClientRpcRequest, NOT_FOUND.getName(), errorMsg, LOG_LW2M_ERROR);
+                            handler.sentRpcResponse(lwm2mClientRpcRequest, NOT_FOUND.getName(), errorMsg, LOG_LW2M_ERROR);
                         }
                     }
                 } else if (lwm2mClientRpcRequest != null) {
                     String errorMsg = String.format("Path %s not found in object version", targetIdVer);
-                    this.handler.sentRpcResponse(lwm2mClientRpcRequest, NOT_FOUND.getName(), errorMsg, LOG_LW2M_ERROR);
+                    handler.sentRpcResponse(lwm2mClientRpcRequest, NOT_FOUND.getName(), errorMsg, LOG_LW2M_ERROR);
                 }
             } else {
                 switch (typeOper) {
@@ -186,7 +186,7 @@ public class LwM2mTransportRequest {
                         this.handler.sendLogsToThingsboard(lwM2MClient, msg);
                         if (lwm2mClientRpcRequest != null) {
                             String valueMsg = String.format("Paths - %s", paths);
-                            this.handler.sentRpcResponse(lwm2mClientRpcRequest, CONTENT.name(), valueMsg, LOG_LW2M_VALUE);
+                            handler.sentRpcResponse(lwm2mClientRpcRequest, CONTENT.name(), valueMsg, LOG_LW2M_VALUE);
                         }
                         break;
                     case OBSERVE_CANCEL:
@@ -206,7 +206,7 @@ public class LwM2mTransportRequest {
                         break;
                     // lwm2mClientRpcRequest != null
                     case FW_UPDATE:
-                        this.handler.getInfoFirmwareUpdate(lwM2MClient, lwm2mClientRpcRequest);
+                        handler.getInfoFirmwareUpdate(lwM2MClient, lwm2mClientRpcRequest);
                         break;
                 }
             }
@@ -223,7 +223,7 @@ public class LwM2mTransportRequest {
 
     private SimpleDownlinkRequest createRequest(Registration registration, LwM2mClient lwM2MClient, LwM2mTypeOper typeOper,
                                           ContentFormat contentFormat, String target, String targetIdVer,
-                                          LwM2mPath resultIds, Object params, Lwm2mClientRpcRequest rpcRequest) {
+                                          LwM2mPath resultIds, Object params, LwM2mClientRpcRequest rpcRequest) {
         SimpleDownlinkRequest request = null;
         switch (typeOper) {
             case READ:
@@ -328,7 +328,7 @@ public class LwM2mTransportRequest {
 
     @SuppressWarnings({"error sendRequest"})
     private void sendRequest(Registration registration, LwM2mClient lwM2MClient, SimpleDownlinkRequest request,
-                             long timeoutInMs, Lwm2mClientRpcRequest rpcRequest) {
+                             long timeoutInMs, LwM2mClientRpcRequest rpcRequest) {
         context.getServer().send(registration, request, timeoutInMs, (ResponseCallback<?>) response -> {
 
             if (!lwM2MClient.isInit()) {
@@ -352,13 +352,13 @@ public class LwM2mTransportRequest {
                 /** Not Found
                  set setClient_fw_info... = empty
                  **/
-                if (lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
+                if (lwM2MClient.getFwUpdate() != null && lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
                     lwM2MClient.getFwUpdate().initReadValue(handler, this, request.getPath().toString());
                 }
-                if (lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
+                if (lwM2MClient.getSwUpdate() != null && lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
                     lwM2MClient.getSwUpdate().initReadValue(handler, this, request.getPath().toString());
                 }
-                if (request.getPath().toString().equals(FW_PACKAGE_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
+                if (request.getPath().toString().equals(FW_PACKAGE_5_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
                     this.afterWriteFwSWUpdateError(registration, request, response.getErrorMessage());
                 }
                 if (request.getPath().toString().equals(FW_UPDATE_ID) || request.getPath().toString().equals(SW_INSTALL_ID)) {
@@ -369,13 +369,13 @@ public class LwM2mTransportRequest {
             /** version == null
              set setClient_fw_info... = empty
              **/
-            if (lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
+            if (lwM2MClient.getFwUpdate() != null && lwM2MClient.getFwUpdate().isInfoFwSwUpdate()) {
                 lwM2MClient.getFwUpdate().initReadValue(handler, this, request.getPath().toString());
             }
-            if (lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
+            if (lwM2MClient.getSwUpdate() != null && lwM2MClient.getSwUpdate().isInfoFwSwUpdate()) {
                 lwM2MClient.getSwUpdate().initReadValue(handler, this, request.getPath().toString());
             }
-            if (request.getPath().toString().equals(FW_PACKAGE_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
+            if (request.getPath().toString().equals(FW_PACKAGE_5_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
                 this.afterWriteFwSWUpdateError(registration, request, e.getMessage());
             }
             if (request.getPath().toString().equals(FW_UPDATE_ID) || request.getPath().toString().equals(SW_INSTALL_ID)) {
@@ -396,7 +396,7 @@ public class LwM2mTransportRequest {
 
     private WriteRequest getWriteRequestSingleResource(ContentFormat contentFormat, Integer objectId, Integer instanceId,
                                                        Integer resourceId, Object value, ResourceModel.Type type,
-                                                       LwM2mClient client, Lwm2mClientRpcRequest rpcRequest) {
+                                                       LwM2mClient client, LwM2mClientRpcRequest rpcRequest) {
         try {
             if (type != null) {
                 switch (type) {
@@ -442,7 +442,7 @@ public class LwM2mTransportRequest {
     }
 
     private void handleResponse(LwM2mClient lwM2mClient, final String path, LwM2mResponse response,
-                                SimpleDownlinkRequest request, Lwm2mClientRpcRequest rpcRequest) {
+                                SimpleDownlinkRequest request, LwM2mClientRpcRequest rpcRequest) {
         responseRequestExecutor.submit(() -> {
             try {
                 this.sendResponse(lwM2mClient, path, response, request, rpcRequest);
@@ -455,12 +455,11 @@ public class LwM2mTransportRequest {
     /**
      * processing a response from a client
      *
-     * @param registration -
      * @param path         -
      * @param response     -
      */
     private void sendResponse(LwM2mClient lwM2mClient, String path, LwM2mResponse response,
-                              SimpleDownlinkRequest request, Lwm2mClientRpcRequest rpcRequest) {
+                              SimpleDownlinkRequest request, LwM2mClientRpcRequest rpcRequest) {
         Registration registration = lwM2mClient.getRegistration();
         String pathIdVer = convertPathFromObjectIdToIdVer(path, registration);
         String msgLog = "";
@@ -508,7 +507,7 @@ public class LwM2mTransportRequest {
         }
     }
 
-    private void infoWriteResponse(LwM2mClient lwM2mClient, LwM2mResponse response, SimpleDownlinkRequest request, Lwm2mClientRpcRequest rpcRequest) {
+    private void infoWriteResponse(LwM2mClient lwM2mClient, LwM2mResponse response, SimpleDownlinkRequest request, LwM2mClientRpcRequest rpcRequest) {
         try {
             Registration registration = lwM2mClient.getRegistration();
             LwM2mNode node = ((WriteRequest) request).getNode();
@@ -546,7 +545,7 @@ public class LwM2mTransportRequest {
             }
             if (msg != null) {
                 handler.sendLogsToThingsboard(lwM2mClient, msg);
-                if (request.getPath().toString().equals(FW_PACKAGE_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
+                if (request.getPath().toString().equals(FW_PACKAGE_5_ID) || request.getPath().toString().equals(SW_PACKAGE_ID)) {
                     this.afterWriteSuccessFwSwUpdate(registration, request);
                     if (rpcRequest != null) {
                         rpcRequest.setInfoMsg(msg);
@@ -568,7 +567,7 @@ public class LwM2mTransportRequest {
      */
     private void afterWriteSuccessFwSwUpdate(Registration registration, SimpleDownlinkRequest request) {
         LwM2mClient lwM2MClient = this.lwM2mClientContext.getClientByRegistrationId(registration.getId());
-        if (request.getPath().toString().equals(FW_PACKAGE_ID) && lwM2MClient.getFwUpdate() != null) {
+        if (request.getPath().toString().equals(FW_PACKAGE_5_ID) && lwM2MClient.getFwUpdate() != null) {
             lwM2MClient.getFwUpdate().setStateUpdate(DOWNLOADED.name());
             lwM2MClient.getFwUpdate().sendLogs(this.handler, WRITE_REPLACE.name(), LOG_LW2M_INFO, null);
         }
@@ -583,7 +582,7 @@ public class LwM2mTransportRequest {
      */
     private void afterWriteFwSWUpdateError(Registration registration, SimpleDownlinkRequest request, String msgError) {
         LwM2mClient lwM2MClient = this.lwM2mClientContext.getClientByRegistrationId(registration.getId());
-        if (request.getPath().toString().equals(FW_PACKAGE_ID) && lwM2MClient.getFwUpdate() != null) {
+        if (request.getPath().toString().equals(FW_PACKAGE_5_ID) && lwM2MClient.getFwUpdate() != null) {
             lwM2MClient.getFwUpdate().setStateUpdate(FAILED.name());
             lwM2MClient.getFwUpdate().sendLogs(this.handler, WRITE_REPLACE.name(), LOG_LW2M_ERROR, msgError);
         }
@@ -603,7 +602,7 @@ public class LwM2mTransportRequest {
         }
     }
 
-    private void afterObserveCancel(LwM2mClient lwM2mClient, int observeCancelCnt, String observeCancelMsg, Lwm2mClientRpcRequest rpcRequest) {
+    private void afterObserveCancel(LwM2mClient lwM2mClient, int observeCancelCnt, String observeCancelMsg, LwM2mClientRpcRequest rpcRequest) {
         handler.sendLogsToThingsboard(lwM2mClient, observeCancelMsg);
         log.warn("[{}]", observeCancelMsg);
         if (rpcRequest != null) {

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/LwM2mTransportServerHelper.java

@@ -65,13 +65,11 @@ import static org.thingsboard.server.gen.transport.TransportProtos.KeyValueType.
 public class LwM2mTransportServerHelper {
 
     private final LwM2mTransportContext context;
-    private final LwM2MJsonAdaptor adaptor;
     private final AtomicInteger atomicTs = new AtomicInteger(0);
 
 
     public long getTS() {
-        int addTs =  atomicTs.getAndIncrement() >= 1000 ? atomicTs.getAndSet(0) : atomicTs.get();
+        return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()) * 1000L + (atomicTs.getAndIncrement() % 1000);
-        return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()) * 1000L +  addTs;
     }
 
     /**

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/LwM2mTransportUtil.java

@@ -43,11 +43,11 @@ import org.eclipse.leshan.server.registration.Registration;
 import org.nustaq.serialization.FSTConfiguration;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.ota.OtaPackageKey;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus;
 import org.thingsboard.server.common.data.ota.OtaPackageUtil;
-import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientProfile;
@@ -77,18 +77,23 @@ import static org.eclipse.leshan.core.model.ResourceModel.Type.OBJLNK;
 import static org.eclipse.leshan.core.model.ResourceModel.Type.OPAQUE;
 import static org.eclipse.leshan.core.model.ResourceModel.Type.STRING;
 import static org.eclipse.leshan.core.model.ResourceModel.Type.TIME;
+import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_KEY;
+import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_PATH;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.DOWNLOADED;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.DOWNLOADING;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.FAILED;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.UPDATED;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.UPDATING;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.VERIFIED;
-import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_KEY;
-import static org.thingsboard.server.common.data.lwm2m.LwM2mConstants.LWM2M_SEPARATOR_PATH;
 
 @Slf4j
 public class LwM2mTransportUtil {
 
+    public static final String EVENT_AWAKE = "AWAKE";
+    public static final String RESPONSE_REQUEST_CHANNEL = "RESP_REQ";
+    public static final String RESPONSE_CHANNEL = "RESP";
+    public static final String OBSERVE_CHANNEL = "OBSERVE";
+
     public static final String TRANSPORT_DEFAULT_LWM2M_VERSION = "1.0";
     public static final String CLIENT_LWM2M_SETTINGS = "clientLwM2mSettings";
     public static final String BOOTSTRAP = "bootstrap";
@@ -116,9 +121,6 @@ public class LwM2mTransportUtil {
     public static final String LOG_LW2M_WARN = "warn";
     public static final String LOG_LW2M_VALUE = "value";
 
-    public static final int LWM2M_STRATEGY_1 = 1;
-    public static final int LWM2M_STRATEGY_2 = 2;
-
     public static final String CLIENT_NOT_AUTHORIZED = "Client not authorized";
     public static final String LWM2M_VERSION_DEFAULT = "1.0";
 
@@ -132,18 +134,23 @@ public class LwM2mTransportUtil {
     public static final String FINISH_VALUE_KEY = ",";
     public static final String START_JSON_KEY = "{";
     public static final String FINISH_JSON_KEY = "}";
-    //    public static final String contentFormatNameKey = "contentFormatName";
     public static final String INFO_KEY = "info";
-    //    public static final String TIME_OUT_IN_MS = "timeOutInMs";
     public static final String RESULT_KEY = "result";
     public static final String ERROR_KEY = "error";
     public static final String METHOD_KEY = "methodName";
 
+
     // Firmware
+    public static final String FIRMWARE_UPDATE_COAP_RECOURSE = "firmwareUpdateCoapRecourse";
     public static final String FW_UPDATE = "Firmware update";
-    public static final Integer FW_ID = 5;
+    public static final Integer FW_5_ID = 5;
+    public static final Integer FW_19_ID = 19;
+
     // Package W
-    public static final String FW_PACKAGE_ID = "/5/0/0";
+    public static final String FW_PACKAGE_5_ID = "/5/0/0";
+    public static final String FW_PACKAGE_19_ID = "/19/0/0";
+    // Package URI
+    public static final String FW_PACKAGE_URI_ID = "/5/0/1";
     // State R
     public static final String FW_STATE_ID = "/5/0/3";
     // Update Result R
@@ -151,15 +158,28 @@ public class LwM2mTransportUtil {
     // PkgName R
     public static final String FW_NAME_ID = "/5/0/6";
     // PkgVersion R
-    public static final String FW_VER_ID = "/5/0/7";
+    public static final String FW_5_VER_ID = "/5/0/7";
+    /**
+     * Quectel@Hi15RM1-HLB_V1.0@BC68JAR01A10,V150R100C20B300SP7,V150R100C20B300SP7@8
+     * BC68JAR01A10
+     * # Request prodct type number
+     * ATI
+     * Quectel
+     * BC68
+     * Revision:BC68JAR01A10
+     */
+    public static final String FW_3_VER_ID = "/3/0/3";
     // Update E
     public static final String FW_UPDATE_ID = "/5/0/2";
 
     // Software
+    public static final String SOFTWARE_UPDATE_COAP_RECOURSE = "softwareUpdateCoapRecourse";
     public static final String SW_UPDATE = "Software update";
     public static final Integer SW_ID = 9;
     // Package W
     public static final String SW_PACKAGE_ID = "/9/0/2";
+    // Package URI
+    public static final String SW_PACKAGE_URI_ID = "/9/0/3";
     // Update State R
     public static final String SW_UPDATE_STATE_ID = "/9/0/7";
     // Update Result R
@@ -232,7 +252,7 @@ public class LwM2mTransportUtil {
         DELETE(11, "Delete"),
 
         // only for RPC
-        FW_UPDATE(12,"FirmwareUpdate");
+        FW_UPDATE(12, "FirmwareUpdate");
 //        FW_READ_INFO(12, "FirmwareReadInfo"),
 
 //        SW_READ_INFO(15, "SoftwareReadInfo"),
@@ -355,20 +375,11 @@ public class LwM2mTransportUtil {
      * FirmwareUpdateStatus {
      * DOWNLOADING, DOWNLOADED, VERIFIED, UPDATING, UPDATED, FAILED
      */
-    public static OtaPackageUpdateStatus EqualsFwSateToFirmwareUpdateStatus(StateFw stateFw, UpdateResultFw updateResultFw) {
+    public static OtaPackageUpdateStatus equalsFwSateFwResultToFirmwareUpdateStatus(StateFw stateFw, UpdateResultFw updateResultFw) {
         switch (updateResultFw) {
             case INITIAL:
-                switch (stateFw) {
+                return equalsFwSateToFirmwareUpdateStatus(stateFw);
-                    case IDLE:
+             case UPDATE_SUCCESSFULLY:
-                        return VERIFIED;
-                    case DOWNLOADING:
-                        return DOWNLOADING;
-                    case DOWNLOADED:
-                        return DOWNLOADED;
-                    case UPDATING:
-                        return UPDATING;
-                }
-            case UPDATE_SUCCESSFULLY:
                 return UPDATED;
             case NOT_ENOUGH:
             case OUT_OFF_MEMORY:
@@ -384,6 +395,41 @@ public class LwM2mTransportUtil {
         }
     }
 
+    public static OtaPackageUpdateStatus equalsFwResultToFirmwareUpdateStatus(UpdateResultFw updateResultFw) {
+        switch (updateResultFw) {
+            case INITIAL:
+                return VERIFIED;
+             case UPDATE_SUCCESSFULLY:
+                return UPDATED;
+            case NOT_ENOUGH:
+            case OUT_OFF_MEMORY:
+            case CONNECTION_LOST:
+            case INTEGRITY_CHECK_FAILURE:
+            case UNSUPPORTED_TYPE:
+            case INVALID_URI:
+            case UPDATE_FAILED:
+            case UNSUPPORTED_PROTOCOL:
+                return FAILED;
+            default:
+                throw new CodecException("Invalid value stateFw %s for FirmwareUpdateStatus.", updateResultFw.name());
+        }
+    }
+
+    public static OtaPackageUpdateStatus equalsFwSateToFirmwareUpdateStatus(StateFw stateFw) {
+        switch (stateFw) {
+            case IDLE:
+                return VERIFIED;
+            case DOWNLOADING:
+                return DOWNLOADING;
+            case DOWNLOADED:
+                return DOWNLOADED;
+            case UPDATING:
+                return UPDATING;
+            default:
+                throw new CodecException("Invalid value stateFw %d for FirmwareUpdateStatus.", stateFw);
+        }
+    }
+
     /**
      * SW Update State R
      * 0: INITIAL Before downloading. (see 5.1.2.1)
@@ -497,6 +543,101 @@ public class LwM2mTransportUtil {
         }
     }
 
+    public enum LwM2MClientStrategy {
+        CLIENT_STRATEGY_1(1, "Read only resources marked as observation"),
+        CLIENT_STRATEGY_2(2, "Read all client resources");
+
+        public int code;
+        public String type;
+
+        LwM2MClientStrategy(int code, String type) {
+            this.code = code;
+            this.type = type;
+        }
+
+        public static LwM2MClientStrategy fromStrategyClientByType(String type) {
+            for (LwM2MClientStrategy to : LwM2MClientStrategy.values()) {
+                if (to.type.equals(type)) {
+                    return to;
+                }
+            }
+            throw new IllegalArgumentException(String.format("Unsupported Client Strategy type  : %s", type));
+        }
+
+        public static LwM2MClientStrategy fromStrategyClientByCode(int code) {
+            for (LwM2MClientStrategy to : LwM2MClientStrategy.values()) {
+                if (to.code == code) {
+                    return to;
+                }
+            }
+            throw new IllegalArgumentException(String.format("Unsupported Client Strategy code : %s", code));
+        }
+    }
+
+    public enum LwM2MFirmwareUpdateStrategy {
+        OBJ_5_BINARY(1, "ObjectId 5, Binary"),
+        OBJ_5_TEMP_URL(2, "ObjectId 5, URI"),
+        OBJ_19_BINARY(3, "ObjectId 19, Binary");
+
+        public int code;
+        public String type;
+
+        LwM2MFirmwareUpdateStrategy(int code, String type) {
+            this.code = code;
+            this.type = type;
+        }
+
+        public static LwM2MFirmwareUpdateStrategy fromStrategyFwByType(String type) {
+            for (LwM2MFirmwareUpdateStrategy to : LwM2MFirmwareUpdateStrategy.values()) {
+                if (to.type.equals(type)) {
+                    return to;
+                }
+            }
+            throw new IllegalArgumentException(String.format("Unsupported FW State type  : %s", type));
+        }
+
+        public static LwM2MFirmwareUpdateStrategy fromStrategyFwByCode(int code) {
+            for (LwM2MFirmwareUpdateStrategy to : LwM2MFirmwareUpdateStrategy.values()) {
+                if (to.code == code) {
+                    return to;
+                }
+            }
+            throw new IllegalArgumentException(String.format("Unsupported FW Strategy code : %s", code));
+        }
+    }
+
+    public enum LwM2MSoftwareUpdateStrategy {
+        BINARY(1, "ObjectId 9, Binary"),
+        TEMP_URL(2, "ObjectId 9, URI");
+
+        public int code;
+        public String type;
+
+        LwM2MSoftwareUpdateStrategy(int code, String type) {
+            this.code = code;
+            this.type = type;
+        }
+
+        public static LwM2MSoftwareUpdateStrategy fromStrategySwByType(String type) {
+            for (LwM2MSoftwareUpdateStrategy to : LwM2MSoftwareUpdateStrategy.values()) {
+                if (to.type.equals(type)) {
+                    return to;
+                }
+            }
+            throw new IllegalArgumentException(String.format("Unsupported SW Strategy type  : %s", type));
+        }
+
+        public static LwM2MSoftwareUpdateStrategy fromStrategySwByCode(int code) {
+            for (LwM2MSoftwareUpdateStrategy to : LwM2MSoftwareUpdateStrategy.values()) {
+                if (to.code == code) {
+                    return to;
+                }
+            }
+            throw new IllegalArgumentException(String.format("Unsupported SW Strategy code : %s", code));
+        }
+
+    }
+
     /**
      * FirmwareUpdateStatus {
      * DOWNLOADING, DOWNLOADED, VERIFIED, UPDATING, UPDATED, FAILED
@@ -534,10 +675,6 @@ public class LwM2mTransportUtil {
         }
     }
 
-    public static final String EVENT_AWAKE = "AWAKE";
-    public static final String RESPONSE_REQUEST_CHANNEL = "RESP_REQ";
-    public static final String RESPONSE_CHANNEL = "RESP";
-    public static final String OBSERVE_CHANNEL = "OBSERVE";
 
     public static boolean equalsResourceValue(Object valueOld, Object valueNew, ResourceModel.Type type, LwM2mPath
             resourcePath) throws CodecException {
@@ -558,6 +695,36 @@ public class LwM2mTransportUtil {
         }
     }
 
+    public static LwM2mOtaConvert convertOtaUpdateValueToString (String pathIdVer, Object value, ResourceModel.Type currentType) {
+        String path = convertPathFromIdVerToObjectId(pathIdVer);
+        LwM2mOtaConvert lwM2mOtaConvert = new LwM2mOtaConvert();
+        if (path != null) {
+            if (FW_STATE_ID.equals(path)) {
+                lwM2mOtaConvert.setCurrentType(STRING);
+                lwM2mOtaConvert.setValue(StateFw.fromStateFwByCode(((Long) value).intValue()).type);
+                return lwM2mOtaConvert;
+            }
+            else if (FW_RESULT_ID.equals(path)) {
+                lwM2mOtaConvert.setCurrentType(STRING);
+                lwM2mOtaConvert.setValue(UpdateResultFw.fromUpdateResultFwByCode(((Long) value).intValue()).type);
+                return lwM2mOtaConvert;
+            }
+            else if (SW_UPDATE_STATE_ID.equals(path)) {
+                lwM2mOtaConvert.setCurrentType(STRING);
+                lwM2mOtaConvert.setValue(UpdateStateSw.fromUpdateStateSwByCode(((Long) value).intValue()).type);
+                return lwM2mOtaConvert;
+            }
+            else if (SW_RESULT_ID.equals(path)) {
+                lwM2mOtaConvert.setCurrentType(STRING);
+                lwM2mOtaConvert.setValue(UpdateResultSw.fromUpdateResultSwByCode(((Long) value).intValue()).type);
+                return lwM2mOtaConvert;
+            }
+        }
+        lwM2mOtaConvert.setCurrentType(currentType);
+        lwM2mOtaConvert.setValue(value);
+        return lwM2mOtaConvert;
+    }
+
     public static LwM2mNode getLvM2mNodeToObject(LwM2mNode content) {
         if (content instanceof LwM2mObject) {
             return (LwM2mObject) content;
@@ -633,11 +800,6 @@ public class LwM2mTransportUtil {
         return null;
     }
 
-    public static int getClientOnlyObserveAfterConnect(LwM2mClientProfile profile) {
-        return profile.getPostClientLwM2mSettings().getAsJsonObject().has("clientOnlyObserveAfterConnect") ?
-                profile.getPostClientLwM2mSettings().getAsJsonObject().get("clientOnlyObserveAfterConnect").getAsInt() : 1;
-    }
-
     private static boolean getValidateCredentialsBodyFromThingsboard(JsonObject objectMsg) {
         return (objectMsg != null &&
                 !objectMsg.isJsonNull() &&
@@ -914,7 +1076,7 @@ public class LwM2mTransportUtil {
             case GREATER_THAN:
             case LESSER_THAN:
             case STEP:
-                if (value.getClass().getSimpleName().equals("String") ) {
+                if (value.getClass().getSimpleName().equals("String")) {
                     value = Double.valueOf((String) value);
                 }
                 return serviceImpl.converter.convertValue(value, equalsResourceTypeGetSimpleName(value), FLOAT, new LwM2mPath(target));
@@ -928,11 +1090,11 @@ public class LwM2mTransportUtil {
             return new Attribute(key, attrValue);
         } catch (Exception e) {
             log.error("CreateAttribute, not valid parameter key: [{}], attrValue: [{}], error: [{}]", key, attrValue, e.getMessage());
-            return  null;
+            return null;
         }
     }
 
-    public static boolean isFwSwWords (String pathName) {
+    public static boolean isFwSwWords(String pathName) {
         return OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.VERSION).equals(pathName)
                 || OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.TITLE).equals(pathName)
                 || OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.CHECKSUM).equals(pathName)

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/LwM2mClient.java

@@ -94,8 +94,6 @@ public class LwM2mClient implements Cloneable {
     @Getter
     private UUID deviceId;
     @Getter
-    private UUID sessionId;
-    @Getter
     private SessionInfoProto session;
     @Getter
     private UUID profileId;
@@ -135,8 +133,6 @@ public class LwM2mClient implements Cloneable {
         this.credentials = credentials;
         this.profileId = profileId;
         this.init = false;
-        this.fwUpdate = new LwM2mFwSwUpdate(this, OtaPackageType.FIRMWARE);
-        this.swUpdate = new LwM2mFwSwUpdate(this, OtaPackageType.SOFTWARE);
         if (this.credentials != null && this.credentials.hasDeviceInfo()) {
             this.session = createSession(nodeId, sessionId, credentials);
             this.deviceId = new UUID(session.getDeviceIdMSB(), session.getDeviceIdLSB());
@@ -396,5 +392,22 @@ public class LwM2mClient implements Cloneable {
             return ContentFormat.TEXT;
         }
     }
+
+    public LwM2mFwSwUpdate  getFwUpdate (LwM2mClientContext clientContext) {
+        if (this.fwUpdate == null) {
+            LwM2mClientProfile lwM2mClientProfile = clientContext.getProfile(this.getProfileId());
+            this.fwUpdate = new LwM2mFwSwUpdate(this, OtaPackageType.FIRMWARE, lwM2mClientProfile.getFwUpdateStrategy());
+        }
+        return this.fwUpdate;
+    }
+
+    public LwM2mFwSwUpdate  getSwUpdate (LwM2mClientContext clientContext) {
+        if (this.swUpdate == null) {
+            LwM2mClientProfile lwM2mClientProfile = clientContext.getProfile(this.getProfileId());
+            this.swUpdate = new LwM2mFwSwUpdate(this, OtaPackageType.SOFTWARE, lwM2mClientProfile.getSwUpdateStrategy());
+        }
+        return this.fwUpdate;
+    }
+
 }
 

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/LwM2mClientContext.java

@@ -16,7 +16,6 @@
 package org.thingsboard.server.transport.lwm2m.server.client;
 
 import org.eclipse.leshan.server.registration.Registration;
-import org.eclipse.leshan.server.security.SecurityInfo;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
 import org.thingsboard.server.gen.transport.TransportProtos;

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/LwM2mClientContextImpl.java

@@ -96,12 +96,7 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
             if (!LwM2MClientState.REGISTERED.equals(lwM2MClient.getState())) {
                 throw new LwM2MClientStateException(lwM2MClient.getState(), "Client is in invalid state.");
             }
-            Registration currentRegistration = lwM2MClient.getRegistration();
+            lwM2MClient.setRegistration(registration);
-            if (currentRegistration.getId().equals(registration.getId())) {
-                lwM2MClient.setRegistration(registration);
-            } else {
-                throw new LwM2MClientStateException(lwM2MClient.getState(), "Client has different registration.");
-            }
         } finally {
             lwM2MClient.unlock();
         }
@@ -120,7 +115,6 @@ public class LwM2mClientContextImpl implements LwM2mClientContext {
                 lwM2MClient.setState(LwM2MClientState.UNREGISTERED);
                 lwM2mClientsByEndpoint.remove(lwM2MClient.getEndpoint());
                 this.securityStore.remove(lwM2MClient.getEndpoint());
-                this.lwM2mClientsByRegistrationId.remove(registration.getId());
                 UUID profileId = lwM2MClient.getProfileId();
                 if (profileId != null) {
                     Optional<LwM2mClient> otherClients = lwM2mClientsByRegistrationId.values().stream().filter(e -> e.getProfileId().equals(profileId)).findFirst();

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/LwM2mClientProfile.java

@@ -20,15 +20,23 @@ import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import lombok.Data;
 import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MClientStrategy;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MSoftwareUpdateStrategy;
 
 @Data
 public class LwM2mClientProfile {
+    private final String clientStrategyStr = "clientStrategy";
+    private final String fwUpdateStrategyStr = "fwUpdateStrategy";
+    private final String swUpdateStrategyStr = "swUpdateStrategy";
 
     private TenantId tenantId;
     /**
-     * {"clientLwM2mSettings": {
+     *   "clientLwM2mSettings": {
-     *      clientUpdateValueAfterConnect: false;
+     *     "fwUpdateStrategy": "1",
-     *       }
+     *     "swUpdateStrategy": "1",
+     *     "clientStrategy": "1"
+     *   }
      **/
     private JsonObject postClientLwM2mSettings;
 
@@ -85,5 +93,21 @@ public class LwM2mClientProfile {
         }
     }
 
+    public int getClientStrategy() {
+        return this.postClientLwM2mSettings.getAsJsonObject().has(this.clientStrategyStr) ?
+                Integer.parseInt(this.postClientLwM2mSettings.getAsJsonObject().get(this.clientStrategyStr).getAsString()) :
+                LwM2MClientStrategy.CLIENT_STRATEGY_1.code;
+    }
 
+    public int getFwUpdateStrategy() {
+        return this.postClientLwM2mSettings.getAsJsonObject().has(this.fwUpdateStrategyStr) ?
+                Integer.parseInt(this.postClientLwM2mSettings.getAsJsonObject().get(this.fwUpdateStrategyStr).getAsString()) :
+                LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY.code;
+    }
+
+    public int getSwUpdateStrategy() {
+        return this.postClientLwM2mSettings.getAsJsonObject().has(this.swUpdateStrategyStr) ?
+                Integer.parseInt(this.postClientLwM2mSettings.getAsJsonObject().get(this.swUpdateStrategyStr).getAsString()) :
+                LwM2MSoftwareUpdateStrategy.BINARY.code;
+    }
 }

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/Lwm2mClientRpcRequest.java → common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/LwM2mClientRpcRequest.java

@@ -57,7 +57,7 @@ import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.v
 
 @Slf4j
 @Data
-public class Lwm2mClientRpcRequest {
+public class LwM2mClientRpcRequest {
 
     private Registration registration;
     private TransportProtos.SessionInfoProto sessionInfo;
@@ -75,10 +75,10 @@ public class Lwm2mClientRpcRequest {
     private String infoMsg;
     private String responseCode;
 
-    public Lwm2mClientRpcRequest() {
+    public LwM2mClientRpcRequest() {
     }
 
-    public Lwm2mClientRpcRequest(LwM2mTypeOper lwM2mTypeOper, String bodyParams, int requestId,
+    public LwM2mClientRpcRequest(LwM2mTypeOper lwM2mTypeOper, String bodyParams, int requestId,
                                  TransportProtos.SessionInfoProto sessionInfo, Registration registration, DefaultLwM2MTransportMsgHandler handler) {
         this.registration = registration;
         this.sessionInfo = sessionInfo;

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/LwM2mFwSwUpdate.java

@@ -20,6 +20,7 @@ import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.eclipse.leshan.core.request.ContentFormat;
+import org.eclipse.leshan.server.registration.Registration;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus;
 import org.thingsboard.server.gen.transport.TransportProtos;
@@ -32,21 +33,32 @@ import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+import static org.eclipse.californium.core.coap.CoAP.ResponseCode.CONTENT;
 import static org.thingsboard.server.common.data.ota.OtaPackageKey.STATE;
 import static org.thingsboard.server.common.data.ota.OtaPackageType.FIRMWARE;
 import static org.thingsboard.server.common.data.ota.OtaPackageType.SOFTWARE;
+import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.DOWNLOADED;
+import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.FAILED;
+import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.INITIATED;
+import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.UPDATED;
 import static org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus.UPDATING;
 import static org.thingsboard.server.common.data.ota.OtaPackageUtil.getAttributeKey;
-import static org.eclipse.californium.core.coap.CoAP.ResponseCode.CONTENT;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FIRMWARE_UPDATE_COAP_RECOURSE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_3_VER_ID;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_5_VER_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_NAME_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_PACKAGE_ID;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_PACKAGE_19_ID;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_PACKAGE_5_ID;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_PACKAGE_URI_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_RESULT_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_STATE_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_UPDATE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_UPDATE_ID;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.FW_VER_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_ERROR;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LOG_LW2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_19_BINARY;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_5_TEMP_URL;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.EXECUTE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.OBSERVE;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.LwM2mTypeOper.WRITE_REPLACE;
@@ -59,6 +71,7 @@ import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.S
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SW_UPDATE_STATE_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.SW_VER_ID;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.convertPathFromObjectIdToIdVer;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.equalsFwSateToFirmwareUpdateStatus;
 import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportUtil.splitCamelCaseString;
 
 @Slf4j
@@ -106,23 +119,29 @@ public class LwM2mFwSwUpdate {
     private final List<String> pendingInfoRequestsStart;
     @Getter
     @Setter
-    private volatile Lwm2mClientRpcRequest rpcRequest;
+    private volatile LwM2mClientRpcRequest rpcRequest;
+    @Getter
+    @Setter
+    private volatile int updateStrategy;
 
-    public LwM2mFwSwUpdate(LwM2mClient lwM2MClient, OtaPackageType type) {
+    public LwM2mFwSwUpdate(LwM2mClient lwM2MClient, OtaPackageType type, int updateStrategy) {
         this.lwM2MClient = lwM2MClient;
         this.pendingInfoRequestsStart = new CopyOnWriteArrayList<>();
         this.type = type;
         this.stateUpdate = null;
+        this.updateStrategy = updateStrategy;
         this.initPathId();
     }
 
     private void initPathId() {
         if (FIRMWARE.equals(this.type)) {
-            this.pathPackageId = FW_PACKAGE_ID;
+            this.pathPackageId = LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY.code == this.updateStrategy ?
+                    FW_PACKAGE_5_ID : LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_5_TEMP_URL.code == this.updateStrategy ?
+                    FW_PACKAGE_URI_ID : FW_PACKAGE_19_ID;
             this.pathStateId = FW_STATE_ID;
             this.pathResultId = FW_RESULT_ID;
             this.pathNameId = FW_NAME_ID;
-            this.pathVerId = FW_VER_ID;
+            this.pathVerId = FW_5_VER_ID;
             this.pathInstallId = FW_UPDATE_ID;
             this.wUpdate = FW_UPDATE;
         } else if (SOFTWARE.equals(this.type)) {
@@ -143,13 +162,13 @@ public class LwM2mFwSwUpdate {
         }
         if (this.pendingInfoRequestsStart.size() == 0) {
             this.infoFwSwUpdate = false;
-            if (!OtaPackageUpdateStatus.DOWNLOADING.name().equals(this.stateUpdate)) {
+//            if (!FAILED.name().equals(this.stateUpdate)) {
-                boolean conditionalStart = this.type.equals(FIRMWARE) ? this.conditionalFwUpdateStart() :
+            boolean conditionalStart = this.type.equals(FIRMWARE) ? this.conditionalFwUpdateStart(handler) :
-                        this.conditionalSwUpdateStart();
+                    this.conditionalSwUpdateStart(handler);
-                if (conditionalStart) {
+            if (conditionalStart) {
-                    this.writeFwSwWare(handler, request);
+                this.writeFwSwWare(handler, request);
-                }
             }
+//            }
         }
     }
 
@@ -159,32 +178,44 @@ public class LwM2mFwSwUpdate {
      */
     public void writeFwSwWare(DefaultLwM2MTransportMsgHandler handler, LwM2mTransportRequest request) {
         if (this.currentId != null) {
-            this.stateUpdate = OtaPackageUpdateStatus.DOWNLOADING.name();
+            this.stateUpdate = OtaPackageUpdateStatus.INITIATED.name();
             this.sendLogs(handler, WRITE_REPLACE.name(), LOG_LW2M_INFO, null);
-            int chunkSize = 0;
-            int chunk = 0;
-            byte[] firmwareChunk = handler.otaPackageDataCache.get(this.currentId.toString(), chunkSize, chunk);
             String targetIdVer = convertPathFromObjectIdToIdVer(this.pathPackageId, this.lwM2MClient.getRegistration());
             String fwMsg = String.format("%s: Start type operation %s paths:  %s", LOG_LW2M_INFO,
-                    LwM2mTransportUtil.LwM2mTypeOper.FW_UPDATE.name(),  FW_PACKAGE_ID);
+                    LwM2mTransportUtil.LwM2mTypeOper.FW_UPDATE.name(), this.pathPackageId);
-            handler.sendLogsToThingsboard(lwM2MClient, fwMsg);
+            handler.sendLogsToThingsboard(fwMsg, lwM2MClient.getRegistration().getId());
             log.warn("8) Start firmware Update. Send save to: [{}] ver: [{}] path: [{}]", this.lwM2MClient.getDeviceName(), this.currentVersion, targetIdVer);
-            request.sendAllRequest(this.lwM2MClient, targetIdVer, WRITE_REPLACE, ContentFormat.OPAQUE,
+            if (LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY.code == this.updateStrategy) {
-                    firmwareChunk, handler.config.getTimeout(), this.rpcRequest);
+                int chunkSize = 0;
-        }
+                int chunk = 0;
-        else {
+                byte[] firmwareChunk = handler.otaPackageDataCache.get(this.currentId.toString(), chunkSize, chunk);
+                request.sendAllRequest(this.lwM2MClient, targetIdVer, WRITE_REPLACE, ContentFormat.OPAQUE,
+                        firmwareChunk, handler.config.getTimeout(), this.rpcRequest);
+            } else if (LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_5_TEMP_URL.code == this.updateStrategy) {
+                Registration registration = this.getLwM2MClient().getRegistration();
+//                String api = handler.config.getHostRequests();
+                String api = "0.0.0.0";
+                int port = registration.getIdentity().isSecure() ? handler.config.getSecurePort() : handler.config.getPort();
+                String uri = "coap://" + api + ":" + Integer.valueOf(port) + "/" + FIRMWARE_UPDATE_COAP_RECOURSE + "/" + this.currentId.toString();
+                log.warn("89) coapUri: [{}]", uri);
+                request.sendAllRequest(this.lwM2MClient, targetIdVer, WRITE_REPLACE, null,
+                        uri, handler.config.getTimeout(), this.rpcRequest);
+            } else if (LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_19_BINARY.code == this.updateStrategy) {
+
+            }
+        } else {
             String msgError = "FirmWareId is null.";
             log.warn("6) [{}]", msgError);
             if (this.rpcRequest != null) {
                 handler.sentRpcResponse(this.rpcRequest, CONTENT.name(), msgError, LOG_LW2M_ERROR);
             }
-            log.error (msgError);
+            log.error(msgError);
             this.sendLogs(handler, WRITE_REPLACE.name(), LOG_LW2M_ERROR, msgError);
         }
     }
 
     public void sendLogs(DefaultLwM2MTransportMsgHandler handler, String typeOper, String typeInfo, String msgError) {
-        this.sendSateOnThingsBoard(handler);
+//        this.sendSateOnThingsBoard(handler);
         String msg = String.format("%s: %s, %s, pkgVer: %s: pkgName - %s state - %s.",
                 typeInfo, this.wUpdate, typeOper, this.currentVersion, this.currentTitle, this.stateUpdate);
         if (LOG_LW2M_ERROR.equals(typeInfo)) {
@@ -200,31 +231,49 @@ public class LwM2mFwSwUpdate {
      * send execute
      */
     public void executeFwSwWare(DefaultLwM2MTransportMsgHandler handler, LwM2mTransportRequest request) {
-        this.setStateUpdate(UPDATING.name());
         this.sendLogs(handler, EXECUTE.name(), LOG_LW2M_INFO, null);
         request.sendAllRequest(this.lwM2MClient, this.pathInstallId, EXECUTE, null, 0, this.rpcRequest);
     }
 
     /**
-     * Firmware start:
+     * Firmware start: Check if the version has changed and launch a new update.
+     * -ObjectId 5, Binary or ObjectId 5, URI
      * -- If the result of the update - errors (more than 1) - This means that the previous. the update failed.
      * - We launch the update regardless of the state of the firmware and its version.
-     * -- If the result of the update is not errors (equal to 1 or 0) and ver is not empty - This means that before the update has passed.
+     * -- If the result of the update - errors (more than 1) - This means that the previous. the update failed.
-     * -- If the result of the update is not errors and is empty - This means that there has not been an update yet.
+     * * ObjectId 5, Binary
-     * - Check if the version has changed and launch a new update.
+     * -- If the result of the update is not errors (equal to 1 or 0) and ver in Object 5 is not empty - it means that the previous update has passed.
+     * Compare current versions  by equals.
+     * * ObjectId 5, URI
+     * -- If the result of the update is not errors (equal to 1 or 0) and ver in Object 5 is not empty - it means that the previous update has passed.
+     * Compare current versions  by contains.
      */
-    private boolean conditionalFwUpdateStart() {
+    private boolean conditionalFwUpdateStart(DefaultLwM2MTransportMsgHandler handler) {
         Long updateResultFw = (Long) this.lwM2MClient.getResourceValue(null, this.pathResultId);
+        String ver5 = (String) this.lwM2MClient.getResourceValue(null, this.pathVerId);
+        String pathName = (String) this.lwM2MClient.getResourceValue(null, this.pathNameId);
+        String ver3 = (String) this.lwM2MClient.getResourceValue(null, FW_3_VER_ID);
         // #1/#2
-        return updateResultFw > LwM2mTransportUtil.UpdateResultFw.UPDATE_SUCCESSFULLY.code ||
+        String fwMsg = null;
-                (
+        if ((this.currentVersion != null &&  (
-                        (updateResultFw <= LwM2mTransportUtil.UpdateResultFw.UPDATE_SUCCESSFULLY.code
+                ver5 != null && ver5.equals(this.currentVersion) ||
-                        ) &&
+                ver3 != null && ver3.contains(this.currentVersion)
-                                (
+            )) ||
-                                        (this.currentVersion != null && !this.currentVersion.equals(this.lwM2MClient.getResourceValue(null, this.pathVerId))) ||
+            (this.currentTitle != null && pathName != null && this.currentTitle.equals(pathName))) {
-                                                (this.currentTitle != null && !this.currentTitle.equals(this.lwM2MClient.getResourceValue(null, this.pathNameId)))
+            fwMsg = String.format("%s: The update was interrupted. The device has the same version: %s.", LOG_LW2M_ERROR,
-                                )
+                    this.currentVersion);
-                );
+        }
+        else if (updateResultFw != null && updateResultFw > LwM2mTransportUtil.UpdateResultFw.UPDATE_SUCCESSFULLY.code) {
+            fwMsg = String.format("%s: The update was interrupted. The device has the status UpdateResult: error (%d).", LOG_LW2M_ERROR,
+                    updateResultFw);
+        }
+        if (fwMsg != null) {
+            handler.sendLogsToThingsboard(fwMsg, lwM2MClient.getRegistration().getId());
+            return false;
+        }
+        else {
+            return true;
+        }
     }
 
 
@@ -248,7 +297,7 @@ public class LwM2mFwSwUpdate {
 
     /**
      * After operation Execute success  inspection Update Result :
-     *  > 1 error: "Firmware updated successfully"
+     * > 1 error: "Firmware updated successfully"
      */
     public boolean conditionalFwExecuteAfterError() {
         Long updateResult = (Long) this.lwM2MClient.getResourceValue(null, this.pathResultId);
@@ -264,7 +313,7 @@ public class LwM2mFwSwUpdate {
      * - If Update Result is not errors and ver is not empty - This means that before unInstall update
      * * - Check if the version has changed and launch a new update.
      */
-    private boolean conditionalSwUpdateStart() {
+    private boolean conditionalSwUpdateStart(DefaultLwM2MTransportMsgHandler handler) {
         Long updateResultSw = (Long) this.lwM2MClient.getResourceValue(null, this.pathResultId);
         // #1/#2
         return updateResultSw >= LwM2mTransportUtil.UpdateResultSw.NOT_ENOUGH_STORAGE.code ||
@@ -292,7 +341,7 @@ public class LwM2mFwSwUpdate {
      * -- inspection Update Result:
      * ---- FW если Update Result == 1 ("Firmware updated successfully") или  SW если Update Result == 2 ("Software successfully installed.")
      * -- fw_state/sw_state = UPDATED
-     *
+     * <p>
      * After finish operation Execute (error):
      * -- inspection updateResult and send to thingsboard info about error
      * --- send to telemetry ( key - this is name Update Result in model) (
@@ -325,7 +374,7 @@ public class LwM2mFwSwUpdate {
 
     /**
      * After operation Execute success  inspection Update Result :
-     *  >= 50 - error "NOT_ENOUGH_STORAGE"
+     * >= 50 - error "NOT_ENOUGH_STORAGE"
      */
     public boolean conditionalSwExecuteAfterError() {
         Long updateResult = (Long) this.lwM2MClient.getResourceValue(null, this.pathResultId);
@@ -354,17 +403,75 @@ public class LwM2mFwSwUpdate {
 
     public void sendReadObserveInfo(LwM2mTransportRequest request) {
         this.infoFwSwUpdate = true;
-        this.pendingInfoRequestsStart.add(convertPathFromObjectIdToIdVer(
-                this.pathVerId, this.lwM2MClient.getRegistration()));
-        this.pendingInfoRequestsStart.add(convertPathFromObjectIdToIdVer(
-                this.pathNameId, this.lwM2MClient.getRegistration()));
         this.pendingInfoRequestsStart.add(convertPathFromObjectIdToIdVer(
                 this.pathStateId, this.lwM2MClient.getRegistration()));
         this.pendingInfoRequestsStart.add(convertPathFromObjectIdToIdVer(
                 this.pathResultId, this.lwM2MClient.getRegistration()));
+        this.pendingInfoRequestsStart.add(convertPathFromObjectIdToIdVer(
+                FW_3_VER_ID, this.lwM2MClient.getRegistration()));
+        if (LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY.code == this.updateStrategy ||
+                LwM2mTransportUtil.LwM2MFirmwareUpdateStrategy.OBJ_19_BINARY.code == this.updateStrategy ||
+                SOFTWARE.equals(this.type)) {
+            this.pendingInfoRequestsStart.add(convertPathFromObjectIdToIdVer(
+                    this.pathVerId, this.lwM2MClient.getRegistration()));
+            this.pendingInfoRequestsStart.add(convertPathFromObjectIdToIdVer(
+                    this.pathNameId, this.lwM2MClient.getRegistration()));
+        }
         this.pendingInfoRequestsStart.forEach(pathIdVer -> {
             request.sendAllRequest(this.lwM2MClient, pathIdVer, OBSERVE, null, 0, this.rpcRequest);
         });
 
     }
+
+    /**
+     * Before operation Execute (FwUpdate) inspection Update Result :
+     * - after finished operation Write result: success (FwUpdate): fw_state = DOWNLOADED
+     * - before start operation Execute (FwUpdate) Update Result = 0 - Initial value
+     * - start Execute (FwUpdate)
+     * After finished operation Execute (FwUpdate) inspection Update Result :
+     * - after start operation Execute (FwUpdate):  fw_state = UPDATING
+     * - after success finished operation Execute (FwUpdate) Update Result == 1 ("Firmware updated successfully")
+     * - finished operation Execute (FwUpdate)
+     */
+    public void updateStateOta(DefaultLwM2MTransportMsgHandler handler, LwM2mTransportRequest request,
+                               Registration registration, String path, int value) {
+        if (OBJ_5_BINARY.code == this.getUpdateStrategy()) {
+            if ((convertPathFromObjectIdToIdVer(FW_RESULT_ID, registration).equals(path))) {
+                if (DOWNLOADED.name().equals(this.getStateUpdate())
+                        && this.conditionalFwExecuteStart()) {
+                    this.executeFwSwWare(handler, request);
+                } else if (UPDATING.name().equals(this.getStateUpdate())
+                        && this.conditionalFwExecuteAfterSuccess()) {
+                    this.finishFwSwUpdate(handler, true);
+                } else if (UPDATING.name().equals(this.getStateUpdate())
+                        && this.conditionalFwExecuteAfterError()) {
+                    this.finishFwSwUpdate(handler, false);
+                }
+            }
+        } else if (OBJ_5_TEMP_URL.code == this.getUpdateStrategy()) {
+            if (this.currentId != null && (convertPathFromObjectIdToIdVer(FW_STATE_ID, registration).equals(path))) {
+                String state = equalsFwSateToFirmwareUpdateStatus(LwM2mTransportUtil.StateFw.fromStateFwByCode(value)).name();
+                if (StringUtils.isNotEmpty(state) && !FAILED.name().equals(this.stateUpdate) &&  !state.equals(this.stateUpdate)) {
+                    this.stateUpdate = state;
+                    this.sendSateOnThingsBoard(handler);
+                }
+                if (value == LwM2mTransportUtil.StateFw.DOWNLOADED.code) {
+                    this.executeFwSwWare(handler, request);
+                }
+                handler.firmwareUpdateState.put(lwM2MClient.getEndpoint(), value);
+            }
+            if ((convertPathFromObjectIdToIdVer(FW_RESULT_ID, registration).equals(path))) {
+                if (this.currentId != null && value == LwM2mTransportUtil.UpdateResultFw.INITIAL.code) {
+                    this.setStateUpdate(INITIATED.name());
+                } else if (this.currentId != null && value == LwM2mTransportUtil.UpdateResultFw.UPDATE_SUCCESSFULLY.code) {
+                    this.setStateUpdate(UPDATED.name());
+                } else if (value > LwM2mTransportUtil.UpdateResultFw.UPDATE_SUCCESSFULLY.code) {
+                    this.setStateUpdate(FAILED.name());
+                }
+                this.sendSateOnThingsBoard(handler);
+            }
+        } else if (OBJ_19_BINARY.code == this.getUpdateStrategy()) {
+
+        }
+    }
 }

common/transport/mqtt/src/main/java/org/thingsboard/server/transport/mqtt/session/GatewaySessionHandler.java

@@ -259,8 +259,10 @@ public class GatewaySessionHandler {
                                     transportService.process(TransportProtos.TransportToDeviceActorMsg.newBuilder()
                                             .setSessionInfo(deviceSessionInfo)
                                             .setSessionEvent(DefaultTransportService.getSessionEventMsg(TransportProtos.SessionEvent.OPEN))
-                                            .setSubscribeToAttributes(TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().build())
+                                            .setSubscribeToAttributes(TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder()
-                                            .setSubscribeToRPC(TransportProtos.SubscribeToRPCMsg.newBuilder().build())
+                                                    .setSessionType(TransportProtos.SessionType.ASYNC).build())
+                                            .setSubscribeToRPC(TransportProtos.SubscribeToRPCMsg.newBuilder()
+                                                    .setSessionType(TransportProtos.SessionType.ASYNC).build())
                                             .build(), null);
                                 }
                                 futureToSet.set(devices.get(deviceName));

transport/lwm2m/src/main/resources/tb-lwm2m-transport.yml

@@ -114,13 +114,14 @@ transport:
         private_encoded: "${LWM2M_SERVER_PRIVATE_ENCODED:308193020100301306072a8648ce3d020106082a8648ce3d030107047930770201010420dc774b309e547ceb48fee547e104ce201a9c48c449dc5414cd04e7f5cf05f67ba00a06082a8648ce3d030107a1440342000405064b9e6762dd8d8b8a52355d7b4d8b9a3d64e6d2ee277d76c248861353f3585eeb1838e4f9e37b31fa347aef5ce3431eb54e0a2506910c5e0298817445721b}"
         # Only Certificate_x509:
         alias: "${LWM2M_KEYSTORE_ALIAS_SERVER:server}"
+        skip_validity_check_for_client_cert: "${TB_LWM2M_SERVER_SECURITY_SKIP_VALIDITY_CHECK_FOR_CLIENT_CERT:false}"
     bootstrap:
       enable: "${LWM2M_ENABLED_BS:true}"
       id: "${LWM2M_SERVER_ID_BS:111}"
       bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
       bind_port: "${LWM2M_BIND_PORT_BS:5687}"
       security:
-        bind_address: "${LWM2M_BIND_ADDRESS_BS:0.0.0.0}"
+        bind_address: "${LWM2M_BIND_ADDRESS_SECURITY_BS:0.0.0.0}"
         bind_port: "${LWM2M_BIND_PORT_SECURITY_BS:5688}"
         #  Only for RPK: Public & Private Key. If the keystore file is missing or not working
         public_x: "${LWM2M_SERVER_PUBLIC_X_BS:5017c87a1c1768264656b3b355434b0def6edb8b9bf166a4762d9930cd730f91}"

ui-ngx/src/app/modules/home/components/profile/device/lwm2m/lwm2m-device-profile-transport-configuration.component.html

@@ -15,112 +15,123 @@
     limitations under the License.
 
 -->
-<section style="padding-bottom: 16px; margin: 0">
+<section style="padding-bottom: 16px; margin: 0" mat-dialog-content>
   <mat-tab-group dynamicHeight>
     <mat-tab label="{{ 'device-profile.lwm2m.model-tab' | translate }}">
       <ng-template matTabContent>
         <section [formGroup]="lwm2mDeviceProfileFormGroup">
-          <div *ngIf="false" class="mat-padding" style="padding-bottom: 0">
+          <div class="mat-padding" style="padding-top: 0">
-            <mat-form-field class="mat-block">
+            <tb-profile-lwm2m-object-list
-              <mat-label>{{ 'device-profile.lwm2m.client-only-observe-after-connect-label' | translate }}</mat-label>
+              (addList)="addObjectsList($event)"
-              <mat-select formControlName="clientOnlyObserveAfterConnect"
+              (removeList)="removeObjectsList($event)"
-                          matTooltip="{{ 'device-profile.lwm2m.client-only-observe-after-connect-tip' | translate:
+              [required]="required"
-                          { count: +lwm2mDeviceProfileFormGroup.get('clientOnlyObserveAfterConnect').value } }}"
+              formControlName="objectIds">
-                          matTooltipPosition="above">
+            </tb-profile-lwm2m-object-list>
-                <mat-option value=1>{{ 'device-profile.lwm2m.client-only-observe-after-connect' | translate:
+          </div>
-                  {count: 1} }}</mat-option>
+          <div class="mat-padding">
-                <mat-option value=2>{{ 'device-profile.lwm2m.client-only-observe-after-connect' | translate:
+            <tb-profile-lwm2m-observe-attr-telemetry
-                  {count: 2} }}</mat-option>
+              [required]="required"
-              </mat-select>
+              formControlName="observeAttrTelemetry">
-            </mat-form-field>
+            </tb-profile-lwm2m-observe-attr-telemetry>
           </div>
-          <tb-profile-lwm2m-object-list
-            (addList)="addObjectsList($event)"
-            (removeList)="removeObjectsList($event)"
-            [required]="required"
-            formControlName="objectIds">
-          </tb-profile-lwm2m-object-list>
-          <tb-profile-lwm2m-observe-attr-telemetry
-            [required]="required"
-            formControlName="observeAttrTelemetry">
-          </tb-profile-lwm2m-observe-attr-telemetry>
         </section>
       </ng-template>
     </mat-tab>
-    <mat-tab label="{{ 'device-profile.lwm2m.servers' | translate }}">
+    <mat-tab label="{{ 'device-profile.lwm2m.bootstrap-tab' | translate }}">
       <ng-template matTabContent>
         <section [formGroup]="lwm2mDeviceProfileFormGroup">
           <div class="mat-padding">
             <mat-accordion multi="true" class="mat-body-1">
               <mat-expansion-panel>
                 <mat-expansion-panel-header>
-                  <mat-panel-title>{{ 'device-profile.lwm2m.servers' | translate }}</mat-panel-title>
+                  <mat-panel-title>
+                    <div class="tb-panel-title">{{ 'device-profile.lwm2m.servers' | translate | uppercase }}</div>
+                  </mat-panel-title>
                 </mat-expansion-panel-header>
                 <ng-template matExpansionPanelContent>
-                  <div fxLayout="row" fxLayout.xs="column" fxLayoutGap="8px" fxLayoutGap.xs="0px">
+                  <div fxLayout="column">
-                    <mat-form-field fxFlex>
+                    <div fxLayout="row" fxLayoutGap="8px">
-                      <mat-label>{{ 'device-profile.lwm2m.short-id' | translate }}</mat-label>
+                      <mat-form-field fxFlex>
-                      <input matInput type="number" formControlName="shortId" required>
+                        <mat-label>{{ 'device-profile.lwm2m.short-id' | translate }}</mat-label>
-                      <mat-error *ngIf="lwm2mDeviceProfileFormGroup.get('shortId').hasError('required')">
+                        <input matInput type="number" formControlName="shortId" required>
-                        {{ 'device-profile.lwm2m.short-id' | translate }}
+                        <mat-error *ngIf="lwm2mDeviceProfileFormGroup.get('shortId').hasError('required')">
-                        <strong>{{ 'device-profile.lwm2m.required' | translate }}</strong>
+                          {{ 'device-profile.lwm2m.short-id' | translate }}
-                      </mat-error>
+                          <strong>{{ 'device-profile.lwm2m.required' | translate }}</strong>
-                    </mat-form-field>
+                        </mat-error>
-                    <mat-form-field fxFlex>
+                      </mat-form-field>
-                      <mat-label>{{ 'device-profile.lwm2m.lifetime' | translate }}</mat-label>
+                      <mat-form-field fxFlex>
-                      <input matInput type="number" formControlName="lifetime" required>
+                        <mat-label>{{ 'device-profile.lwm2m.lifetime' | translate }}</mat-label>
-                      <mat-error
+                        <input matInput type="number" formControlName="lifetime" required>
-                        *ngIf="lwm2mDeviceProfileFormGroup.get('lifetime').hasError('required')">
+                        <mat-error
-                        {{ 'device-profile.lwm2m.lifetime' | translate }}
+                          *ngIf="lwm2mDeviceProfileFormGroup.get('lifetime').hasError('required')">
-                        <strong>{{ 'device-profile.lwm2m.required' | translate }}</strong>
+                          {{ 'device-profile.lwm2m.lifetime' | translate }}
-                      </mat-error>
+                          <strong>{{ 'device-profile.lwm2m.required' | translate }}</strong>
-                    </mat-form-field>
+                        </mat-error>
-                    <mat-form-field fxFlex>
+                      </mat-form-field>
-                      <mat-label>{{ 'device-profile.lwm2m.default-min-period' | translate }}</mat-label>
+                      <mat-form-field fxFlex>
-                      <input matInput type="number" formControlName="defaultMinPeriod" required>
+                        <mat-label>{{ 'device-profile.lwm2m.default-min-period' | translate }}</mat-label>
-                      <mat-error
+                        <input matInput type="number" formControlName="defaultMinPeriod" required>
-                        *ngIf="lwm2mDeviceProfileFormGroup.get('defaultMinPeriod').hasError('required')">
+                        <mat-error
-                        {{ 'device-profile.lwm2m.default-min-period' | translate }}
+                          *ngIf="lwm2mDeviceProfileFormGroup.get('defaultMinPeriod').hasError('required')">
-                        <strong>{{ 'device-profile.lwm2m.required' | translate }}</strong>
+                          {{ 'device-profile.lwm2m.default-min-period' | translate }}
-                      </mat-error>
+                          <strong>{{ 'device-profile.lwm2m.required' | translate }}</strong>
-                    </mat-form-field>
+                        </mat-error>
+                      </mat-form-field>
+                    </div>
+                    <div fxLayout="row" fxLayoutGap="8px">
+                      <mat-form-field class="mat-block" fxFlex="100">
+                        <mat-label>{{ 'device-profile.lwm2m.binding' | translate }}</mat-label>
+                        <mat-select formControlName="binding">
+                          <mat-option *ngFor="let bindingMode of  bindingModeTypes"
+                                      [value]="bindingMode">
+                            {{ bindingModeTypeNamesMap.get(bindingModeType[bindingMode]) }}
+                          </mat-option>
+                        </mat-select>
+                      </mat-form-field>
+                    </div>
+                    <div>
+                      <mat-checkbox formControlName="notifIfDisabled" color="primary">
+                        {{ 'device-profile.lwm2m.notif-if-disabled' | translate }}
+                      </mat-checkbox>
+                    </div>
                   </div>
-                  <mat-form-field class="mat-block">
-                    <mat-label>{{ 'device-profile.lwm2m.binding' | translate }}</mat-label>
-                    <mat-select formControlName="binding">
-                      <mat-option *ngFor="let bindingMode of  bindingModeTypes"
-                                  [value]="bindingMode">
-                        {{ bindingModeTypeNamesMap.get(bindingModeType[bindingMode]) }}
-                      </mat-option>
-                    </mat-select>
-                  </mat-form-field>
-                  <mat-checkbox formControlName="notifIfDisabled" color="primary">
-                    {{ 'device-profile.lwm2m.notif-if-disabled' | translate }}
-                  </mat-checkbox>
                 </ng-template>
               </mat-expansion-panel>
+            </mat-accordion>
+            <mat-accordion multi="true" class="mat-body-1">
               <mat-expansion-panel>
                 <mat-expansion-panel-header>
-                  <mat-panel-title>{{ 'device-profile.lwm2m.bootstrap-server' | translate }}</mat-panel-title>
+                  <mat-panel-title>
+                    <div
+                      class="tb-panel-title">{{ 'device-profile.lwm2m.bootstrap-server' | translate | uppercase }}</div>
+                  </mat-panel-title>
                 </mat-expansion-panel-header>
                 <ng-template matExpansionPanelContent>
-                  <tb-profile-lwm2m-device-config-server
+                  <div class="mat-padding">
-                    [required]="required"
+                    <tb-profile-lwm2m-device-config-server
-                    formControlName="bootstrapServer"
+                      [required]="required"
-                    [bootstrapServerIs]=true>
+                      formControlName="bootstrapServer"
-                  </tb-profile-lwm2m-device-config-server>
+                      [bootstrapServerIs]=true>
+                    </tb-profile-lwm2m-device-config-server>
+                  </div>
                 </ng-template>
               </mat-expansion-panel>
+            </mat-accordion>
+            <mat-accordion multi="true" class="mat-body-1">
               <mat-expansion-panel>
                 <mat-expansion-panel-header>
-                  <mat-panel-title>{{ 'device-profile.lwm2m.lwm2m-server' | translate }}</mat-panel-title>
+                  <mat-panel-title>
+                    <div class="tb-panel-title">{{ 'device-profile.lwm2m.lwm2m-server' | translate | uppercase }}</div>
+                  </mat-panel-title>
                 </mat-expansion-panel-header>
                 <ng-template matExpansionPanelContent>
-                  <tb-profile-lwm2m-device-config-server
+                  <div class="mat-padding">
-                    [required]="required"
+                    <tb-profile-lwm2m-device-config-server
-                    formControlName="lwm2mServer"
+                      [required]="required"
-                    [bootstrapServerIs]=false>
+                      formControlName="lwm2mServer"
-                  </tb-profile-lwm2m-device-config-server>
+                      [bootstrapServerIs]=false>
+                    </tb-profile-lwm2m-device-config-server>
+                  </div>
                 </ng-template>
               </mat-expansion-panel>
             </mat-accordion>
@@ -128,6 +139,48 @@
         </section>
       </ng-template>
     </mat-tab>
+    <mat-tab label="{{ 'device-profile.lwm2m.others-tab' | translate }}">
+      <ng-template matTabContent>
+        <section [formGroup]="lwm2mDeviceProfileFormGroup">
+          <div *ngIf="false" class="mat-padding" style="padding-bottom: 0px">
+            <mat-form-field class="mat-block">
+              <mat-label>{{ 'device-profile.lwm2m.client-strategy-label' | translate }}</mat-label>
+              <mat-select formControlName="clientStrategy"
+                          matTooltip="{{ 'device-profile.lwm2m.client-strategy-tip' | translate:
+                          { count: +lwm2mDeviceProfileFormGroup.get('clientStrategy').value } }}"
+                          matTooltipPosition="above">
+                <mat-option value=1>{{ 'device-profile.lwm2m.client-strategy' | translate:
+                  {count: 1} }}</mat-option>
+                <mat-option value=2>{{ 'device-profile.lwm2m.client-strategy' | translate:
+                  {count: 2} }}</mat-option>
+              </mat-select>
+            </mat-form-field>
+          </div>
+          <div class="mat-padding" style="padding-bottom: 0px">
+            <mat-form-field class="mat-block">
+              <mat-label>{{ 'device-profile.lwm2m.fw-update-strategy-label' | translate }}</mat-label>
+              <mat-select formControlName="fwUpdateStrategy">
+                <mat-option value=1>{{ 'device-profile.lwm2m.fw-update-strategy' | translate:
+                  {count: 1} }}</mat-option>
+                <mat-option value=2>{{ 'device-profile.lwm2m.fw-update-strategy' | translate:
+                  {count: 2} }}</mat-option>
+                <mat-option value=2>{{ 'device-profile.lwm2m.fw-update-strategy' | translate:
+                  {count: 3} }}</mat-option>
+              </mat-select>
+            </mat-form-field>
+            <mat-form-field class="mat-block">
+              <mat-label>{{ 'device-profile.lwm2m.sw-update-strategy-label' | translate }}</mat-label>
+              <mat-select formControlName="swUpdateStrategy">
+                <mat-option value=1>{{ 'device-profile.lwm2m.sw-update-strategy' | translate:
+                  {count: 1} }}</mat-option>
+                <mat-option value=2>{{ 'device-profile.lwm2m.sw-update-strategy' | translate:
+                  {count: 2} }}</mat-option>
+              </mat-select>
+            </mat-form-field>
+          </div>
+        </section>
+      </ng-template>
+    </mat-tab>
     <mat-tab label="{{ 'device-profile.lwm2m.config-json-tab' | translate }}">
       <ng-template matTabContent>
         <section [formGroup]="lwm2mDeviceConfigFormGroup" class="mat-padding">

ui-ngx/src/app/modules/home/components/profile/device/lwm2m/lwm2m-device-profile-transport-configuration.component.ts

@@ -83,7 +83,6 @@ export class Lwm2mDeviceProfileTransportConfigurationComponent implements Contro
   constructor(private fb: FormBuilder,
               private deviceProfileService: DeviceProfileService) {
     this.lwm2mDeviceProfileFormGroup = this.fb.group({
-      clientOnlyObserveAfterConnect: [1, []],
       objectIds: [null, Validators.required],
       observeAttrTelemetry: [null, Validators.required],
       shortId: [null, Validators.required],
@@ -93,6 +92,9 @@ export class Lwm2mDeviceProfileTransportConfigurationComponent implements Contro
       binding: [],
       bootstrapServer: [null, Validators.required],
       lwm2mServer: [null, Validators.required],
+      clientStrategy: [1, []],
+      fwUpdateStrategy: [1, []],
+      swUpdateStrategy: [1, []],
     });
     this.lwm2mDeviceConfigFormGroup = this.fb.group({
       configurationJson: [null, Validators.required]
@@ -168,7 +170,6 @@ export class Lwm2mDeviceProfileTransportConfigurationComponent implements Contro
 
   private updateWriteValue = (value: ModelValue): void => {
     this.lwm2mDeviceProfileFormGroup.patchValue({
-        clientOnlyObserveAfterConnect: this.configurationValue.clientLwM2mSettings.clientOnlyObserveAfterConnect,
         objectIds: value,
         observeAttrTelemetry: this.getObserveAttrTelemetryObjects(value.objectsList),
         shortId: this.configurationValue.bootstrap.servers.shortId,
@@ -177,7 +178,10 @@ export class Lwm2mDeviceProfileTransportConfigurationComponent implements Contro
         notifIfDisabled: this.configurationValue.bootstrap.servers.notifIfDisabled,
         binding: this.configurationValue.bootstrap.servers.binding,
         bootstrapServer: this.configurationValue.bootstrap.bootstrapServer,
-        lwm2mServer: this.configurationValue.bootstrap.lwm2mServer
+        lwm2mServer: this.configurationValue.bootstrap.lwm2mServer,
+        clientStrategy: this.configurationValue.clientLwM2mSettings.clientStrategy,
+        fwUpdateStrategy: this.configurationValue.clientLwM2mSettings.fwUpdateStrategy,
+        swUpdateStrategy: this.configurationValue.clientLwM2mSettings.swUpdateStrategy
       },
       {emitEvent: false});
   }
@@ -199,8 +203,6 @@ export class Lwm2mDeviceProfileTransportConfigurationComponent implements Contro
 
   private updateDeviceProfileValue(config): void {
     if (this.lwm2mDeviceProfileFormGroup.valid) {
-      this.configurationValue.clientLwM2mSettings.clientOnlyObserveAfterConnect =
-        config.clientOnlyObserveAfterConnect;
       this.updateObserveAttrTelemetryFromGroupToJson(config.observeAttrTelemetry.clientLwM2M);
       this.configurationValue.bootstrap.bootstrapServer = config.bootstrapServer;
       this.configurationValue.bootstrap.lwm2mServer = config.lwm2mServer;
@@ -210,6 +212,9 @@ export class Lwm2mDeviceProfileTransportConfigurationComponent implements Contro
       bootstrapServers.defaultMinPeriod = config.defaultMinPeriod;
       bootstrapServers.notifIfDisabled = config.notifIfDisabled;
       bootstrapServers.binding = config.binding;
+      this.configurationValue.clientLwM2mSettings.clientStrategy = config.clientStrategy;
+      this.configurationValue.clientLwM2mSettings.fwUpdateStrategy = config.fwUpdateStrategy;
+      this.configurationValue.clientLwM2mSettings.swUpdateStrategy = config.swUpdateStrategy;
       this.upDateJsonAllConfig();
       this.updateModel();
     }

ui-ngx/src/app/modules/home/components/profile/device/lwm2m/lwm2m-profile-config.models.ts

@@ -165,7 +165,9 @@ export interface Lwm2mProfileConfigModels {
 }
 
 export interface ClientLwM2mSettings {
-  clientOnlyObserveAfterConnect: number;
+  clientStrategy: string;
+  fwUpdateStrategy: string;
+  swUpdateStrategy: string;
 }
 
 export interface ObservableAttributes {
@@ -235,7 +237,9 @@ export function getDefaultProfileConfig(hostname?: any): Lwm2mProfileConfigModel
 
 function getDefaultProfileClientLwM2mSettingsConfig(): ClientLwM2mSettings {
   return {
-    clientOnlyObserveAfterConnect: 1
+    clientStrategy: "1",
+    fwUpdateStrategy: "1",
+    swUpdateStrategy: "1"
   };
 }
 

ui-ngx/src/assets/locale/locale.constant-en_US.json

@@ -1192,9 +1192,6 @@
         "device-profile-file": "Device profile file",
         "invalid-device-profile-file-error": "Unable to import device profile: Invalid device profile data structure.",
         "lwm2m": {
-            "client-only-observe-after-connect-label": "Strategy",
-            "client-only-observe-after-connect": "{ count, plural, 1 {1: Only Observe Request to the client after the initial connection} other {2: Read All Resources & Observe Request to the client after registration} }",
-            "client-only-observe-after-connect-tip": "{ count, plural, 1 {Strategy 1: After the initial connection of the LWM2M Client, the server sends Observe resources Request to the client, those resources that are marked as observation in the Device profile and which exist on the LWM2M client.} other {Strategy  2: After the registration, request the client to read all the resource values for all objects that the LWM2M client has,\n then execute:  the server sends Observe resources Request to the client, those resources that are marked as observation in the Device profile and which exist on the LWM2M client.} }",
             "object-list": "Object list",
             "object-list-empty": "No objects selected.",
             "no-objects-matching": "No objects matching '{{object}}' were found.",
@@ -1242,6 +1239,7 @@
             "default-min-period": "Minimum Period between two notifications (sec)",
             "notif-if-disabled": "Notification Storing When Disabled or Offline",
             "binding": "Binding",
+            "bootstrap-tab": "Bootstrap",
             "bootstrap-server": "Bootstrap Server",
             "lwm2m-server": "LwM2M Server",
             "server-host": "Host",
@@ -1254,6 +1252,20 @@
             "client-hold-off-time-tip": "Client Hold Off Time for use with a Bootstrap-Server only",
             "bootstrap-server-account-timeout": "Account after the timeout",
             "bootstrap-server-account-timeout-tip": "Bootstrap-Server Account after the timeout value given by this resource.",
+            "others-tab": "Other settings...",
+            "client-strategy-label": "Strategy",
+            "client-strategy-connect": "{ count, plural, 1 {1: Only Observe Request to the client after the initial connection} other {2: Read All Resources & Observe Request to the client after registration} }",
+            "client-strategy-tip": "{ count, plural, 1 {Strategy 1: After the initial connection of the LWM2M Client, the server sends Observe resources Request to the client, those resources that are marked as observation in the Device profile and which exist on the LWM2M client.} other {Strategy  2: After the registration, request the client to read all the resource values for all objects that the LWM2M client has,\n then execute:  the server sends Observe resources Request to the client, those resources that are marked as observation in the Device profile and which exist on the LWM2M client.} }",
+            "ota-update-strategy": "Ota update strategy",
+            "fw-update-strategy-label": "Firmware update strategy",
+            "fw-update-strategy": "{ count, plural, 1 {Push firmware update as binary file using Object 5 and Resource 0 (Package).} 2 {Auto-generate unique CoAP URL to download the package and push firmware update as Object 5 and Resource 1 (Package URI).} other {Push firmware update as binary file using Object 19 and Resource 0 (Data).} }",
+            "sw-update-strategy-label": "Software update strategy",
+            "sw-update-strategy": "{ count, plural, 1 {Push binary file using Object 9 and Resource 2 (Package).} other {Auto-generate unique CoAP URL to download the package and push software update using Object 9 and Resource 3 (Package URI).} }",
+            "blockwise-settings": "Blockwise settings",
+            "blockwise-enabled": "Enable blockwise",
+            "blockwise-status-lifetime": "Blockwise Status Lifetime",
+            "fw-update-recourse": "Firmware update Coap recourse",
+            "sw-update-recourse": "Software update Coap recourse",
             "config-json-tab": "Json Config Profile Device"
         }
     },