Refactoring of the LwM2MTransport

@@ -14,7 +14,7 @@
     <logger name="org.springframework.boot.test" level="WARN"/>
     <logger name="org.apache.cassandra" level="WARN"/>
     <logger name="org.cassandraunit" level="INFO"/>
-    <logger name="org.eclipse.leshan" level="TRACE"/>
+    <logger name="org.eclipse.leshan" level="INFO"/>
 
 
     <root level="WARN">

@@ -42,14 +42,12 @@ public class OtaPackageTransportResource extends AbstractCoapTransportResource {
     private static final int ACCESS_TOKEN_POSITION = 2;
 
     private final OtaPackageType otaPackageType;
-    private final ExecutorService sendOtaDataOutUriLarge;
 
     public OtaPackageTransportResource(CoapTransportContext ctx, OtaPackageType otaPackageType) {
         super(ctx, otaPackageType.getKeyPrefix());
         this.otaPackageType = otaPackageType;
 
         this.setObservable(true);
-        this.sendOtaDataOutUriLarge = ThingsBoardExecutors.newWorkStealingPool(10, "LwM2M sendOtaDataOutUriLarge");
     }
 
     @Override
@@ -140,46 +138,12 @@ public class OtaPackageTransportResource extends AbstractCoapTransportResource {
         Response response = new Response(CoAP.ResponseCode.CONTENT);
         if (data != null && data.length > 0) {
             response.setPayload(data);
-//            response.getOptions().setAccept(MediaTypeRegistry.APPLICATION_OCTET_STREAM);
             if (exchange.getRequestOptions().getBlock2() != null) {
                 int chunkSize = exchange.getRequestOptions().getBlock2().getSzx();
                 boolean lastFlag = data.length <= chunkSize;
-                this.sendOtaDataOutUriLarge.submit(() -> {
-                    response.getOptions().setBlock2(chunkSize, lastFlag, 0);
-                });            }
-            exchange.respond(response);
-        }
-    }
-
-    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) {
-
+                response.getOptions().setBlock2(chunkSize, lastFlag, 0);
+            }
+            transportContext.getExecutor().submit(() -> exchange.respond(response));
         }
     }
 

@@ -142,7 +142,7 @@ public class LwM2MTransportServerConfig implements LwM2MSecureServerConfig {
         URI uri = null;
         try {
             uri = Resources.getResource(keyStorePathFile).toURI();
-            log.error("URI: {}", uri);
+            log.info("URI: {}", uri);
             File keyStoreFile = new File(uri);
             InputStream inKeyStore = new FileInputStream(keyStoreFile);
             keyStoreValue = KeyStore.getInstance(keyStoreType);

@@ -59,12 +59,12 @@ public class LwM2mCredentialsSecurityInfoValidator {
     public TbLwM2MSecurityInfo getEndpointSecurityInfoByCredentialsId(String credentialsId, LwM2mTypeServer keyValue) {
         CountDownLatch latch = new CountDownLatch(1);
         final TbLwM2MSecurityInfo[] resultSecurityStore = new TbLwM2MSecurityInfo[1];
-        log.warn("001) [{}]", credentialsId);
+        log.trace("Validating credentials [{}]", credentialsId);
         context.getTransportService().process(ValidateDeviceLwM2MCredentialsRequestMsg.newBuilder().setCredentialsId(credentialsId).build(),
                 new TransportServiceCallback<>() {
                     @Override
                     public void onSuccess(ValidateDeviceCredentialsResponse msg) {
-                        log.warn("002) [{}] [{}]", credentialsId, msg);
+                        log.trace("Validated credentials: [{}] [{}]", credentialsId, msg);
                         String credentialsBody = msg.getCredentials();
                         resultSecurityStore[0] = createSecurityInfo(credentialsId, credentialsBody, keyValue);
                         resultSecurityStore[0].setMsg(msg);
@@ -74,7 +74,6 @@ public class LwM2mCredentialsSecurityInfoValidator {
 
                     @Override
                     public void onError(Throwable e) {
-                        log.warn("003) [{}] [{}] Failed to process credentials ", credentialsId, e);
                         log.trace("[{}] [{}] Failed to process credentials ", credentialsId, e);
                         resultSecurityStore[0] = createSecurityInfo(credentialsId, null, null);
                         latch.countDown();

@@ -46,10 +46,10 @@ import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTrans
 import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
 import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
-import org.thingsboard.server.transport.lwm2m.server.ota.firmware.UpdateResultFw;
-import org.thingsboard.server.transport.lwm2m.server.ota.firmware.UpdateStateFw;
-import org.thingsboard.server.transport.lwm2m.server.ota.software.UpdateResultSw;
-import org.thingsboard.server.transport.lwm2m.server.ota.software.UpdateStateSw;
+import org.thingsboard.server.transport.lwm2m.server.ota.firmware.FirmwareUpdateResult;
+import org.thingsboard.server.transport.lwm2m.server.ota.firmware.FirmwareUpdateState;
+import org.thingsboard.server.transport.lwm2m.server.ota.software.SoftwareUpdateResult;
+import org.thingsboard.server.transport.lwm2m.server.ota.software.SoftwareUpdateState;
 import org.thingsboard.server.transport.lwm2m.server.uplink.DefaultLwM2MUplinkMsgHandler;
 
 import java.util.ArrayList;
@@ -148,19 +148,19 @@ public class LwM2mTransportUtil {
         if (path != null) {
             if (FW_STATE_ID.equals(path)) {
                 lwM2mOtaConvert.setCurrentType(STRING);
-                lwM2mOtaConvert.setValue(UpdateStateFw.fromStateFwByCode(((Long) value).intValue()).type);
+                lwM2mOtaConvert.setValue(FirmwareUpdateState.fromStateFwByCode(((Long) value).intValue()).type);
                 return lwM2mOtaConvert;
             } else if (FW_RESULT_ID.equals(path)) {
                 lwM2mOtaConvert.setCurrentType(STRING);
-                lwM2mOtaConvert.setValue(UpdateResultFw.fromUpdateResultFwByCode(((Long) value).intValue()).getType());
+                lwM2mOtaConvert.setValue(FirmwareUpdateResult.fromUpdateResultFwByCode(((Long) value).intValue()).getType());
                 return lwM2mOtaConvert;
             } else if (SW_UPDATE_STATE_ID.equals(path)) {
                 lwM2mOtaConvert.setCurrentType(STRING);
-                lwM2mOtaConvert.setValue(UpdateStateSw.fromUpdateStateSwByCode(((Long) value).intValue()).type);
+                lwM2mOtaConvert.setValue(SoftwareUpdateState.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);
+                lwM2mOtaConvert.setValue(SoftwareUpdateResult.fromUpdateResultSwByCode(((Long) value).intValue()).type);
                 return lwM2mOtaConvert;
             }
         }
@@ -435,19 +435,6 @@ public class LwM2mTransportUtil {
         }
     }
 
-//    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)
-//                || OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.CHECKSUM_ALGORITHM).equals(pathName)
-//                || OtaPackageUtil.getAttributeKey(OtaPackageType.FIRMWARE, OtaPackageKey.SIZE).equals(pathName)
-//                || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.VERSION).equals(pathName)
-//                || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.TITLE).equals(pathName)
-//                || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.CHECKSUM).equals(pathName)
-//                || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.CHECKSUM_ALGORITHM).equals(pathName)
-//                || OtaPackageUtil.getAttributeKey(OtaPackageType.SOFTWARE, OtaPackageKey.SIZE).equals(pathName);
-//    }
-
     /**
      * @param lwM2MClient -
      * @param path        -

@@ -25,6 +25,7 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.DonAsynchron;
 import org.thingsboard.server.cache.ota.OtaPackageDataCache;
 import org.thingsboard.server.common.data.StringUtils;
+import org.thingsboard.server.common.data.device.data.lwm2m.OtherConfiguration;
 import org.thingsboard.server.common.data.ota.OtaPackageKey;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.data.ota.OtaPackageUpdateStatus;
@@ -45,12 +46,12 @@ import org.thingsboard.server.transport.lwm2m.server.downlink.TbLwM2MWriteReplac
 import org.thingsboard.server.transport.lwm2m.server.downlink.TbLwM2MWriteResponseCallback;
 import org.thingsboard.server.transport.lwm2m.server.log.LwM2MTelemetryLogService;
 import org.thingsboard.server.transport.lwm2m.server.ota.firmware.LwM2MFirmwareUpdateStrategy;
-import org.thingsboard.server.transport.lwm2m.server.ota.firmware.UpdateDeliveryFw;
-import org.thingsboard.server.transport.lwm2m.server.ota.firmware.UpdateResultFw;
-import org.thingsboard.server.transport.lwm2m.server.ota.firmware.UpdateStateFw;
+import org.thingsboard.server.transport.lwm2m.server.ota.firmware.FirmwareDeliveryMethod;
+import org.thingsboard.server.transport.lwm2m.server.ota.firmware.FirmwareUpdateResult;
+import org.thingsboard.server.transport.lwm2m.server.ota.firmware.FirmwareUpdateState;
 import org.thingsboard.server.transport.lwm2m.server.ota.software.LwM2MSoftwareUpdateStrategy;
-import org.thingsboard.server.transport.lwm2m.server.ota.software.UpdateResultSw;
-import org.thingsboard.server.transport.lwm2m.server.ota.software.UpdateStateSw;
+import org.thingsboard.server.transport.lwm2m.server.ota.software.SoftwareUpdateResult;
+import org.thingsboard.server.transport.lwm2m.server.ota.software.SoftwareUpdateState;
 import org.thingsboard.server.transport.lwm2m.server.uplink.LwM2mUplinkMsgHandler;
 
 import javax.annotation.PostConstruct;
@@ -201,20 +202,20 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
     }
 
     @Override
-    public void onCurrentFirmwareStrategyUpdate(LwM2mClient client, Integer newStrategy, String newBaseUrl) {
-        log.debug("[{}] Current fw strategy: {}", client.getEndpoint(), newStrategy);
+    public void onCurrentFirmwareStrategyUpdate(LwM2mClient client, OtherConfiguration configuration) {
+        log.debug("[{}] Current fw strategy: {}", client.getEndpoint(), configuration.getFwUpdateStrategy());
         LwM2MClientOtaInfo fwInfo = getOrInitFwInfo(client);
-        fwInfo.setFwStrategy(LwM2MFirmwareUpdateStrategy.fromStrategyFwByCode(newStrategy));
-        fwInfo.setBaseUrl(newBaseUrl);
+        fwInfo.setFwStrategy(LwM2MFirmwareUpdateStrategy.fromStrategyFwByCode(configuration.getFwUpdateStrategy()));
+        fwInfo.setBaseUrl(configuration.getFwUpdateRecourse());
         startFirmwareUpdateIfNeeded(client, fwInfo);
     }
 
     @Override
-    public void onCurrentSoftwareStrategyUpdate(LwM2mClient client, Integer newStrategy, String newBaseUrl) {
-        log.debug("[{}] Current sw strategy: {}", client.getEndpoint(), newStrategy);
+    public void onCurrentSoftwareStrategyUpdate(LwM2mClient client, OtherConfiguration configuration) {
+        log.debug("[{}] Current sw strategy: {}", client.getEndpoint(), configuration.getSwUpdateStrategy());
         LwM2MClientOtaInfo swInfo = getOrInitSwInfo(client);
-        swInfo.setSwStrategy(LwM2MSoftwareUpdateStrategy.fromStrategySwByCode(newStrategy));
-        swInfo.setBaseUrl(newBaseUrl);
+        swInfo.setSwStrategy(LwM2MSoftwareUpdateStrategy.fromStrategySwByCode(configuration.getSwUpdateStrategy()));
+        swInfo.setBaseUrl(configuration.getSwUpdateRecourse());
         startSoftwareUpdateIfNeeded(client, swInfo);
     }
 
@@ -236,8 +237,8 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
     public void onCurrentFirmwareStateUpdate(LwM2mClient client, Long stateCode) {
         log.debug("[{}] Current fw state: {}", client.getEndpoint(), stateCode);
         LwM2MClientOtaInfo fwInfo = getOrInitFwInfo(client);
-        UpdateStateFw state = UpdateStateFw.fromStateFwByCode(stateCode.intValue());
-        if (UpdateStateFw.DOWNLOADED.equals(state)) {
+        FirmwareUpdateState state = FirmwareUpdateState.fromStateFwByCode(stateCode.intValue());
+        if (FirmwareUpdateState.DOWNLOADED.equals(state)) {
             executeFwUpdate(client);
         }
         fwInfo.setUpdateState(state);
@@ -250,7 +251,7 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
     public void onCurrentFirmwareResultUpdate(LwM2mClient client, Long code) {
         log.debug("[{}] Current fw result: {}", client.getEndpoint(), code);
         LwM2MClientOtaInfo fwInfo = getOrInitFwInfo(client);
-        UpdateResultFw result = UpdateResultFw.fromUpdateResultFwByCode(code.intValue());
+        FirmwareUpdateResult result = FirmwareUpdateResult.fromUpdateResultFwByCode(code.intValue());
         Optional<OtaPackageUpdateStatus> status = this.toOtaPackageUpdateStatus(result);
         status.ifPresent(otaStatus -> sendStateUpdateToTelemetry(client, fwInfo,
                 otaStatus, "Firmware Update Result: " + result.name()));
@@ -324,10 +325,10 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
         if (TransportProtos.ResponseStatus.SUCCESS.equals(response.getResponseStatus())) {
             UUID otaPackageId = new UUID(response.getOtaPackageIdMSB(), response.getOtaPackageIdLSB());
             LwM2MFirmwareUpdateStrategy strategy;
-            if (fwInfo.getDeliveryMethod() == null || fwInfo.getDeliveryMethod() == UpdateDeliveryFw.BOTH.code) {
+            if (fwInfo.getDeliveryMethod() == null || fwInfo.getDeliveryMethod() == FirmwareDeliveryMethod.BOTH.code) {
                 strategy = fwInfo.getFwStrategy();
             } else {
-                strategy = fwInfo.getDeliveryMethod() == UpdateDeliveryFw.PULL.code ? LwM2MFirmwareUpdateStrategy.OBJ_5_TEMP_URL : LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY;
+                strategy = fwInfo.getDeliveryMethod() == FirmwareDeliveryMethod.PULL.code ? LwM2MFirmwareUpdateStrategy.OBJ_5_TEMP_URL : LwM2MFirmwareUpdateStrategy.OBJ_5_BINARY;
             }
             switch (strategy) {
                 case OBJ_5_BINARY:
@@ -405,8 +406,8 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
         helper.sendParametersOnThingsboardTelemetry(result, client.getSession());
     }
 
-    private static Optional<OtaPackageUpdateStatus> toOtaPackageUpdateStatus(UpdateResultFw updateResultFw) {
-        switch (updateResultFw) {
+    private static Optional<OtaPackageUpdateStatus> toOtaPackageUpdateStatus(FirmwareUpdateResult fwUpdateResult) {
+        switch (fwUpdateResult) {
             case INITIAL:
                 return Optional.empty();
             case UPDATE_SUCCESSFULLY:
@@ -421,12 +422,12 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
             case UNSUPPORTED_PROTOCOL:
                 return Optional.of(FAILED);
             default:
-                throw new CodecException("Invalid value stateFw %s for FirmwareUpdateStatus.", updateResultFw.name());
+                throw new CodecException("Invalid value stateFw %s for FirmwareUpdateStatus.", fwUpdateResult.name());
         }
     }
 
-    private static Optional<OtaPackageUpdateStatus> toOtaPackageUpdateStatus(UpdateStateFw updateStateFw) {
-        switch (updateStateFw) {
+    private static Optional<OtaPackageUpdateStatus> toOtaPackageUpdateStatus(FirmwareUpdateState firmwareUpdateState) {
+        switch (firmwareUpdateState) {
             case IDLE:
                 return Optional.empty();
             case DOWNLOADING:
@@ -436,7 +437,7 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
             case UPDATING:
                 return Optional.of(UPDATING);
             default:
-                throw new CodecException("Invalid value stateFw %d for FirmwareUpdateStatus.", updateStateFw);
+                throw new CodecException("Invalid value stateFw %d for FirmwareUpdateStatus.", firmwareUpdateState);
         }
     }
 
@@ -444,10 +445,10 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
      * FirmwareUpdateStatus {
      * DOWNLOADING, DOWNLOADED, VERIFIED, UPDATING, UPDATED, FAILED
      */
-    public static Optional<OtaPackageUpdateStatus> toSwSateResultUpdateStatus(UpdateStateSw updateStateSw, UpdateResultSw updateResultSw) {
-        switch (updateResultSw) {
+    public static Optional<OtaPackageUpdateStatus> toSwSateResultUpdateStatus(SoftwareUpdateState softwareUpdateState, SoftwareUpdateResult softwareUpdateResult) {
+        switch (softwareUpdateResult) {
             case INITIAL:
-                switch (updateStateSw) {
+                switch (softwareUpdateState) {
                     case INITIAL:
                     case DOWNLOAD_STARTED:
                         return Optional.of(DOWNLOADING);
@@ -473,10 +474,8 @@ public class DefaultLwM2MOtaUpdateService extends LwM2MExecutorAwareService impl
             case UN_INSTALL_FAILURE:
                 return Optional.of(FAILED);
             default:
-                throw new CodecException("Invalid value stateFw %s   %s for FirmwareUpdateStatus.", updateStateSw.name(), updateResultSw.name());
+                throw new CodecException("Invalid value stateFw %s   %s for FirmwareUpdateStatus.", softwareUpdateState.name(), softwareUpdateResult.name());
         }
     }
 
-
-
 }

@@ -19,8 +19,8 @@ import lombok.Data;
 import org.thingsboard.server.common.data.StringUtils;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.transport.lwm2m.server.ota.firmware.LwM2MFirmwareUpdateStrategy;
-import org.thingsboard.server.transport.lwm2m.server.ota.firmware.UpdateResultFw;
-import org.thingsboard.server.transport.lwm2m.server.ota.firmware.UpdateStateFw;
+import org.thingsboard.server.transport.lwm2m.server.ota.firmware.FirmwareUpdateResult;
+import org.thingsboard.server.transport.lwm2m.server.ota.firmware.FirmwareUpdateState;
 import org.thingsboard.server.transport.lwm2m.server.ota.software.LwM2MSoftwareUpdateStrategy;
 
 import java.util.Optional;
@@ -47,8 +47,8 @@ public class LwM2MClientOtaInfo {
     //TODO: use value from device if applicable;
     private LwM2MFirmwareUpdateStrategy fwStrategy;
     private LwM2MSoftwareUpdateStrategy swStrategy;
-    private UpdateStateFw updateState;
-    private UpdateResultFw updateResult;
+    private FirmwareUpdateState updateState;
+    private FirmwareUpdateResult updateResult;
 
     private String failedPackageId;
     private int retryAttempts;
@@ -90,7 +90,7 @@ public class LwM2MClientOtaInfo {
         return StringUtils.isNotEmpty(currentName) || StringUtils.isNotEmpty(currentVersion5) || StringUtils.isNotEmpty(currentVersion3);
     }
 
-    public void setUpdateResult(UpdateResultFw updateResult) {
+    public void setUpdateResult(FirmwareUpdateResult updateResult) {
         this.updateResult = updateResult;
         switch (updateResult) {
             case INITIAL:

@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.transport.lwm2m.server.ota;
 
+import org.thingsboard.server.common.data.device.data.lwm2m.OtherConfiguration;
 import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
 
 import java.util.Optional;
@@ -31,9 +32,9 @@ public interface LwM2MOtaUpdateService {
 
     void onCurrentFirmwareNameUpdate(LwM2mClient client, String name);
 
-    void onCurrentFirmwareStrategyUpdate(LwM2mClient client, Integer newStrategy, String newBaseUrl);
+    void onCurrentFirmwareStrategyUpdate(LwM2mClient client, OtherConfiguration configuration);
 
-    void onCurrentSoftwareStrategyUpdate(LwM2mClient client, Integer newStrategy, String newBaseUrl);
+    void onCurrentSoftwareStrategyUpdate(LwM2mClient client, OtherConfiguration configuration);
 
     void onCurrentFirmwareVersion3Update(LwM2mClient client, String version);
 

@@ -15,14 +15,7 @@
  */
 package org.thingsboard.server.transport.lwm2m.server.ota.firmware;
 
-/**
- * /** Delivery Method R
- * 0: Pull only
- * 1: Push only
- * 2: Both:
- * - In this case the LwM2M Server MAY choose the preferred mechanism for conveying the firmware image to the LwM2M Client.
- */
-public enum UpdateDeliveryFw {
+public enum FirmwareDeliveryMethod {
     PULL(0, "Pull only"),
     PUSH(1, "Push only"),
     BOTH(2, "Push or Push");
@@ -30,13 +23,13 @@ public enum UpdateDeliveryFw {
     public int code;
     public String type;
 
-    UpdateDeliveryFw(int code, String type) {
+    FirmwareDeliveryMethod(int code, String type) {
         this.code = code;
         this.type = type;
     }
 
-    public static UpdateDeliveryFw fromStateFwByType(String type) {
-        for (UpdateDeliveryFw to : UpdateDeliveryFw.values()) {
+    public static FirmwareDeliveryMethod fromStateFwByType(String type) {
+        for (FirmwareDeliveryMethod to : FirmwareDeliveryMethod.values()) {
             if (to.type.equals(type)) {
                 return to;
             }
@@ -44,8 +37,8 @@ public enum UpdateDeliveryFw {
         throw new IllegalArgumentException(String.format("Unsupported FW delivery type  : %s", type));
     }
 
-    public static UpdateDeliveryFw fromStateFwByCode(int code) {
-        for (UpdateDeliveryFw to : UpdateDeliveryFw.values()) {
+    public static FirmwareDeliveryMethod fromStateFwByCode(int code) {
+        for (FirmwareDeliveryMethod to : FirmwareDeliveryMethod.values()) {
             if (to.code == code) {
                 return to;
             }

@@ -30,7 +30,7 @@ import lombok.Getter;
  * 8: Firmware update failed.
  * 9: Unsupported protocol.
  */
-public enum UpdateResultFw {
+public enum FirmwareUpdateResult {
     INITIAL(0, "Initial value", false),
     UPDATE_SUCCESSFULLY(1, "Firmware updated successfully", false),
     NOT_ENOUGH(2, "Not enough flash memory for the new firmware package", false),
@@ -49,14 +49,14 @@ public enum UpdateResultFw {
     @Getter
     private boolean again;
 
-    UpdateResultFw(int code, String type, boolean isAgain) {
+    FirmwareUpdateResult(int code, String type, boolean isAgain) {
         this.code = code;
         this.type = type;
         this.again = isAgain;
     }
 
-    public static UpdateResultFw fromUpdateResultFwByType(String type) {
-        for (UpdateResultFw to : UpdateResultFw.values()) {
+    public static FirmwareUpdateResult fromUpdateResultFwByType(String type) {
+        for (FirmwareUpdateResult to : FirmwareUpdateResult.values()) {
             if (to.type.equals(type)) {
                 return to;
             }
@@ -64,8 +64,8 @@ public enum UpdateResultFw {
         throw new IllegalArgumentException(String.format("Unsupported FW Update Result type  : %s", type));
     }
 
-    public static UpdateResultFw fromUpdateResultFwByCode(int code) {
-        for (UpdateResultFw to : UpdateResultFw.values()) {
+    public static FirmwareUpdateResult fromUpdateResultFwByCode(int code) {
+        for (FirmwareUpdateResult to : FirmwareUpdateResult.values()) {
             if (to.code == code) {
                 return to;
             }

@@ -22,7 +22,7 @@ package org.thingsboard.server.transport.lwm2m.server.ota.firmware;
  * 2: Downloaded
  * 3: Updating
  */
-public enum UpdateStateFw {
+public enum FirmwareUpdateState {
     IDLE(0, "Idle"),
     DOWNLOADING(1, "Downloading"),
     DOWNLOADED(2, "Downloaded"),
@@ -31,13 +31,13 @@ public enum UpdateStateFw {
     public int code;
     public String type;
 
-    UpdateStateFw(int code, String type) {
+    FirmwareUpdateState(int code, String type) {
         this.code = code;
         this.type = type;
     }
 
-    public static UpdateStateFw fromStateFwByType(String type) {
-        for (UpdateStateFw to : UpdateStateFw.values()) {
+    public static FirmwareUpdateState fromStateFwByType(String type) {
+        for (FirmwareUpdateState to : FirmwareUpdateState.values()) {
             if (to.type.equals(type)) {
                 return to;
             }
@@ -45,8 +45,8 @@ public enum UpdateStateFw {
         throw new IllegalArgumentException(String.format("Unsupported FW State type  : %s", type));
     }
 
-    public static UpdateStateFw fromStateFwByCode(int code) {
-        for (UpdateStateFw to : UpdateStateFw.values()) {
+    public static FirmwareUpdateState fromStateFwByCode(int code) {
+        for (FirmwareUpdateState to : FirmwareUpdateState.values()) {
             if (to.code == code) {
                 return to;
             }

@@ -39,7 +39,7 @@ package org.thingsboard.server.transport.lwm2m.server.ota.software;
  * 60-200 : (for expansion, selection to be in blocks depending on new introduction of features)
  * This Resource MAY be reported by sending Observe operation.
  */
-public enum UpdateResultSw {
+public enum SoftwareUpdateResult {
     INITIAL(0, "Initial value", false),
     DOWNLOADING(1, "Downloading", false),
     SUCCESSFULLY_INSTALLED(2, "Software successfully installed", false),
@@ -58,14 +58,14 @@ public enum UpdateResultSw {
     public String type;
     public boolean isAgain;
 
-    UpdateResultSw(int code, String type, boolean isAgain) {
+    SoftwareUpdateResult(int code, String type, boolean isAgain) {
         this.code = code;
         this.type = type;
         this.isAgain = isAgain;
     }
 
-    public static UpdateResultSw fromUpdateResultSwByType(String type) {
-        for (UpdateResultSw to : UpdateResultSw.values()) {
+    public static SoftwareUpdateResult fromUpdateResultSwByType(String type) {
+        for (SoftwareUpdateResult to : SoftwareUpdateResult.values()) {
             if (to.type.equals(type)) {
                 return to;
             }
@@ -73,8 +73,8 @@ public enum UpdateResultSw {
         throw new IllegalArgumentException(String.format("Unsupported SW Update Result type  : %s", type));
     }
 
-    public static UpdateResultSw fromUpdateResultSwByCode(int code) {
-        for (UpdateResultSw to : UpdateResultSw.values()) {
+    public static SoftwareUpdateResult fromUpdateResultSwByCode(int code) {
+        for (SoftwareUpdateResult to : SoftwareUpdateResult.values()) {
             if (to.code == code) {
                 return to;
             }

@@ -26,7 +26,7 @@ package org.thingsboard.server.transport.lwm2m.server.ota.software;
  * After executing the UnInstall Resource, the state changes to INITIAL.
  * 4: INSTALLED
  */
-public enum UpdateStateSw {
+public enum SoftwareUpdateState {
     INITIAL(0, "Initial"),
     DOWNLOAD_STARTED(1, "DownloadStarted"),
     DOWNLOADED(2, "Downloaded"),
@@ -36,13 +36,13 @@ public enum UpdateStateSw {
     public int code;
     public String type;
 
-    UpdateStateSw(int code, String type) {
+    SoftwareUpdateState(int code, String type) {
         this.code = code;
         this.type = type;
     }
 
-    public static UpdateStateSw fromUpdateStateSwByType(String type) {
-        for (UpdateStateSw to : UpdateStateSw.values()) {
+    public static SoftwareUpdateState fromUpdateStateSwByType(String type) {
+        for (SoftwareUpdateState to : SoftwareUpdateState.values()) {
             if (to.type.equals(type)) {
                 return to;
             }
@@ -50,8 +50,8 @@ public enum UpdateStateSw {
         throw new IllegalArgumentException(String.format("Unsupported SW State type  : %s", type));
     }
 
-    public static UpdateStateSw fromUpdateStateSwByCode(int code) {
-        for (UpdateStateSw to : UpdateStateSw.values()) {
+    public static SoftwareUpdateState fromUpdateStateSwByCode(int code) {
+        for (SoftwareUpdateState to : SoftwareUpdateState.values()) {
             if (to.code == code) {
                 return to;
             }

@@ -40,7 +40,9 @@ import org.thingsboard.common.util.DonAsynchron;
 import org.thingsboard.server.cache.ota.OtaPackageDataCache;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.StringUtils;
 import org.thingsboard.server.common.data.device.data.lwm2m.ObjectAttributes;
+import org.thingsboard.server.common.data.device.data.lwm2m.OtherConfiguration;
 import org.thingsboard.server.common.data.device.data.lwm2m.TelemetryMappingConfiguration;
 import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.ota.OtaPackageUtil;
@@ -130,16 +132,13 @@ public class DefaultLwM2MUplinkMsgHandler extends LwM2MExecutorAwareService impl
     private final LwM2mTransportContext context;
     private final LwM2MAttributesService attributesService;
     private final LwM2MOtaUpdateService otaService;
-    public final LwM2MTransportServerConfig config;
+    private final LwM2MTransportServerConfig config;
     private final LwM2MTelemetryLogService logService;
-    public final OtaPackageDataCache otaPackageDataCache;
-    public final LwM2mTransportServerHelper helper;
+    private final LwM2mTransportServerHelper helper;
     private final TbLwM2MDtlsSessionStore sessionStore;
-    public final LwM2mClientContext clientContext;
+    private final LwM2mClientContext clientContext;
     private final LwM2MRpcRequestHandler rpcHandler;
-    public final LwM2mDownlinkMsgHandler defaultLwM2MDownlinkMsgHandler;
-
-    public final Map<String, Integer> firmwareUpdateState;
+    private final LwM2mDownlinkMsgHandler defaultLwM2MDownlinkMsgHandler;
 
     public DefaultLwM2MUplinkMsgHandler(TransportService transportService,
                                         LwM2MTransportServerConfig config,
@@ -150,7 +149,6 @@ public class DefaultLwM2MUplinkMsgHandler extends LwM2MExecutorAwareService impl
                                         @Lazy LwM2MAttributesService attributesService,
                                         @Lazy LwM2MRpcRequestHandler rpcHandler,
                                         @Lazy LwM2mDownlinkMsgHandler defaultLwM2MDownlinkMsgHandler,
-                                        OtaPackageDataCache otaPackageDataCache,
                                         LwM2mTransportContext context, TbLwM2MDtlsSessionStore sessionStore) {
         this.transportService = transportService;
         this.attributesService = attributesService;
@@ -161,9 +159,7 @@ public class DefaultLwM2MUplinkMsgHandler extends LwM2MExecutorAwareService impl
         this.logService = logService;
         this.rpcHandler = rpcHandler;
         this.defaultLwM2MDownlinkMsgHandler = defaultLwM2MDownlinkMsgHandler;
-        this.otaPackageDataCache = otaPackageDataCache;
         this.context = context;
-        this.firmwareUpdateState = new ConcurrentHashMap<>();
         this.sessionStore = sessionStore;
     }
 
@@ -781,27 +777,19 @@ public class DefaultLwM2MUplinkMsgHandler extends LwM2MExecutorAwareService impl
                 }
             }
 
-            // # 7.1
             // update value in fwInfo
-            if (!newProfile.getClientLwM2mSettings().getFwUpdateStrategy().equals(oldProfile.getClientLwM2mSettings().getFwUpdateStrategy())
-                    || (LwM2MFirmwareUpdateStrategy.OBJ_5_TEMP_URL.code == newProfile.getClientLwM2mSettings().getFwUpdateStrategy() &&
-                        !newProfile.getClientLwM2mSettings().getFwUpdateRecourse().equals(oldProfile.getClientLwM2mSettings().getFwUpdateRecourse()))) {
-                clients.forEach(lwM2MClient -> {
-                    otaService.onCurrentFirmwareStrategyUpdate(lwM2MClient,
-                            newProfile.getClientLwM2mSettings().getFwUpdateStrategy(),
-                            newProfile.getClientLwM2mSettings().getFwUpdateRecourse());
-                });
+            OtherConfiguration newLwM2mSettings = newProfile.getClientLwM2mSettings();
+            OtherConfiguration oldLwM2mSettings = oldProfile.getClientLwM2mSettings();
+            if (!newLwM2mSettings.getFwUpdateStrategy().equals(oldLwM2mSettings.getFwUpdateStrategy())
+                    || (StringUtils.isNotEmpty(newLwM2mSettings.getFwUpdateRecourse()) &&
+                    !newLwM2mSettings.getFwUpdateRecourse().equals(oldLwM2mSettings.getFwUpdateRecourse()))) {
+                clients.forEach(lwM2MClient -> otaService.onCurrentFirmwareStrategyUpdate(lwM2MClient, newLwM2mSettings));
             }
 
-            //# 7.2 // update value in swInfo
-            if (!newProfile.getClientLwM2mSettings().getSwUpdateStrategy().equals(oldProfile.getClientLwM2mSettings().getSwUpdateStrategy())
-                    || (LwM2MSoftwareUpdateStrategy.TEMP_URL.code == newProfile.getClientLwM2mSettings().getSwUpdateStrategy() &&
-                    !newProfile.getClientLwM2mSettings().getSwUpdateRecourse().equals(oldProfile.getClientLwM2mSettings().getSwUpdateRecourse()))) {
-                clients.forEach(lwM2MClient -> {
-                    otaService.onCurrentSoftwareStrategyUpdate(lwM2MClient,
-                            newProfile.getClientLwM2mSettings().getFwUpdateStrategy(),
-                            newProfile.getClientLwM2mSettings().getFwUpdateRecourse());
-                });
+            if (!newLwM2mSettings.getSwUpdateStrategy().equals(oldLwM2mSettings.getSwUpdateStrategy())
+                    || (StringUtils.isNotEmpty(newLwM2mSettings.getSwUpdateRecourse()) &&
+                    !newLwM2mSettings.getSwUpdateRecourse().equals(oldLwM2mSettings.getSwUpdateRecourse()))) {
+                clients.forEach(lwM2MClient -> otaService.onCurrentSoftwareStrategyUpdate(lwM2MClient, newLwM2mSettings));
             }
         }
     }