[3.2] Feature/Proto Converter (#3423)

* device post-telemetry & post-attributes & claim

* device rpc to/from server & attributes request, attributes updates

* refactoring & added implementation for gateway protos api

* added timeseries/attributes mqtt tests

* fix MqttTimseriesIntegrationTest values asserts

* mqtt attributes tests improvements

* optimized time for telemetry & attributes tests

* update proto files, refactoring converter, attribute requests tests

* added claim tests, attribute request test

* added deleted keys to gateway response on attributes request & refactored tests

* added attribute updates test & refactored attribute requests tests

* added attribute updates tests for gateways

* added tests for RPC

* fix tests & cleanup code

* fix typo & cleanup transport.proto file

* added more timeouts

* revert handleGetAttributesRequest method

* revert package-locks

* fix getJsonObjectForGateway method

* fix validateSharedResponseGateway method in AbstractMqttAttributesRequestIntegrationTest

* fix mqtt topics

* fix license headers

* refactor tests

* remove todo and lck files from pull

* improvements for claiming tests

* update device creation logic from gateway request

* refactoring

* extract TransportService process calls to private methods

* fix duplicates & removed empty lines

@@ -225,6 +225,8 @@ public class DefaultTransportApiService implements TransportApiService {
                     device.setName(requestMsg.getDeviceName());
                     device.setName(requestMsg.getDeviceName());
                     device.setType(requestMsg.getDeviceType());
                     device.setType(requestMsg.getDeviceType());
                     device.setCustomerId(gateway.getCustomerId());
                     device.setCustomerId(gateway.getCustomerId());
+                    DeviceProfile deviceProfile = deviceProfileService.findOrCreateDeviceProfile(gateway.getTenantId(), requestMsg.getDeviceType());
+                    device.setDeviceProfileId(deviceProfile.getId());
                     device = deviceService.saveDevice(device);
                     device = deviceService.saveDevice(device);
                     relationService.saveRelationAsync(TenantId.SYS_TENANT_ID, new EntityRelation(gateway.getId(), device.getId(), "Created"));
                     relationService.saveRelationAsync(TenantId.SYS_TENANT_ID, new EntityRelation(gateway.getId(), device.getId(), "Created"));
                     deviceStateService.onDeviceAdded(device);
                     deviceStateService.onDeviceAdded(device);

@@ -226,6 +226,10 @@ public abstract class AbstractWebTest {
         login(CUSTOMER_USER_EMAIL, CUSTOMER_USER_PASSWORD);
         login(CUSTOMER_USER_EMAIL, CUSTOMER_USER_PASSWORD);
     }
     }
 
 
+    protected void loginUser(String userName, String password) throws Exception {
+        login(userName, password);
+    }
+
     private Tenant savedDifferentTenant;
     private Tenant savedDifferentTenant;
 
 
     protected void loginDifferentTenant() throws Exception {
     protected void loginDifferentTenant() throws Exception {
@@ -251,15 +255,27 @@ public abstract class AbstractWebTest {
     protected User createUserAndLogin(User user, String password) throws Exception {
     protected User createUserAndLogin(User user, String password) throws Exception {
         User savedUser = doPost("/api/user", user, User.class);
         User savedUser = doPost("/api/user", user, User.class);
         logout();
         logout();
+        JsonNode activateRequest = getActivateRequest(password);
+        JsonNode tokenInfo = readResponse(doPost("/api/noauth/activate", activateRequest).andExpect(status().isOk()), JsonNode.class);
+        validateAndSetJwtToken(tokenInfo, user.getEmail());
+        return savedUser;
+    }
+
+    protected User createUser(User user, String password) throws Exception {
+        User savedUser = doPost("/api/user", user, User.class);
+        JsonNode activateRequest = getActivateRequest(password);
+        ResultActions resultActions = doPost("/api/noauth/activate", activateRequest);
+        resultActions.andExpect(status().isOk());
+        return savedUser;
+    }
+
+    private JsonNode getActivateRequest(String password) throws Exception {
         doGet("/api/noauth/activate?activateToken={activateToken}", TestMailService.currentActivateToken)
         doGet("/api/noauth/activate?activateToken={activateToken}", TestMailService.currentActivateToken)
                 .andExpect(status().isSeeOther())
                 .andExpect(status().isSeeOther())
                 .andExpect(header().string(HttpHeaders.LOCATION, "/login/createPassword?activateToken=" + TestMailService.currentActivateToken));
                 .andExpect(header().string(HttpHeaders.LOCATION, "/login/createPassword?activateToken=" + TestMailService.currentActivateToken));
-        JsonNode activateRequest = new ObjectMapper().createObjectNode()
+        return new ObjectMapper().createObjectNode()
                 .put("activateToken", TestMailService.currentActivateToken)
                 .put("activateToken", TestMailService.currentActivateToken)
                 .put("password", password);
                 .put("password", password);
-        JsonNode tokenInfo = readResponse(doPost("/api/noauth/activate", activateRequest).andExpect(status().isOk()), JsonNode.class);
-        validateAndSetJwtToken(tokenInfo, user.getEmail());
-        return savedUser;
     }
     }
 
 
     protected void login(String username, String password) throws Exception {
     protected void login(String username, String password) throws Exception {
@@ -442,6 +458,10 @@ public abstract class AbstractWebTest {
         return readResponse(doPostAsync(urlTemplate, content, timeout, params).andExpect(resultMatcher), responseClass);
         return readResponse(doPostAsync(urlTemplate, content, timeout, params).andExpect(resultMatcher), responseClass);
     }
     }
 
 
+    protected <T> T doPostClaimAsync(String urlTemplate, Object content, Class<T> responseClass, ResultMatcher resultMatcher, String... params) throws Exception {
+        return readResponse(doPostAsync(urlTemplate, content, DEFAULT_TIMEOUT, params).andExpect(resultMatcher), responseClass);
+    }
+
     protected <T> T doDelete(String urlTemplate, Class<T> responseClass, String... params) throws Exception {
     protected <T> T doDelete(String urlTemplate, Class<T> responseClass, String... params) throws Exception {
         return readResponse(doDelete(urlTemplate, params).andExpect(status().isOk()), responseClass);
         return readResponse(doDelete(urlTemplate, params).andExpect(status().isOk()), responseClass);
     }
     }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.Assert;
+import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceProfileType;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.Tenant;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.device.profile.DefaultDeviceProfileConfiguration;
+import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
+import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.security.Authority;
+import org.thingsboard.server.common.data.security.DeviceCredentials;
+import org.thingsboard.server.controller.AbstractControllerTest;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@Slf4j
+public abstract class AbstractMqttIntegrationTest extends AbstractControllerTest {
+
+    protected static final String MQTT_URL = "tcp://localhost:1883";
+
+    private static final AtomicInteger atomicInteger = new AtomicInteger(2);
+
+    protected Tenant savedTenant;
+    protected User tenantAdmin;
+
+    protected Device savedDevice;
+    protected String accessToken;
+
+    protected Device savedGateway;
+    protected String gatewayAccessToken;
+
+    protected void processBeforeTest(String deviceName, String gatewayName, TransportPayloadType payloadType, String telemetryTopic, String attributesTopic) throws Exception {
+        loginSysAdmin();
+
+        Tenant tenant = new Tenant();
+        tenant.setTitle("My tenant");
+        savedTenant = doPost("/api/tenant", tenant, Tenant.class);
+        Assert.assertNotNull(savedTenant);
+
+        tenantAdmin = new User();
+        tenantAdmin.setAuthority(Authority.TENANT_ADMIN);
+        tenantAdmin.setTenantId(savedTenant.getId());
+        tenantAdmin.setEmail("tenant" + atomicInteger.getAndIncrement() + "@thingsboard.org");
+        tenantAdmin.setFirstName("Joe");
+        tenantAdmin.setLastName("Downs");
+
+        tenantAdmin = createUserAndLogin(tenantAdmin, "testPassword1");
+
+        Device device = new Device();
+        device.setName(deviceName);
+        device.setType("default");
+
+        Device gateway = new Device();
+        gateway.setName(gatewayName);
+        gateway.setType("default");
+        ObjectNode additionalInfo = mapper.createObjectNode();
+        additionalInfo.put("gateway", true);
+        gateway.setAdditionalInfo(additionalInfo);
+
+        if (payloadType != null) {
+            DeviceProfile mqttDeviceProfile = createMqttDeviceProfile(payloadType, telemetryTopic, attributesTopic);
+            DeviceProfile savedDeviceProfile = doPost("/api/deviceProfile", mqttDeviceProfile, DeviceProfile.class);
+            device.setType(savedDeviceProfile.getName());
+            device.setDeviceProfileId(savedDeviceProfile.getId());
+            gateway.setType(savedDeviceProfile.getName());
+            gateway.setDeviceProfileId(savedDeviceProfile.getId());
+        }
+
+        savedDevice = doPost("/api/device", device, Device.class);
+
+        DeviceCredentials deviceCredentials =
+                doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
+
+        savedGateway = doPost("/api/device", gateway, Device.class);
+
+        DeviceCredentials gatewayCredentials =
+                doGet("/api/device/" + savedGateway.getId().getId().toString() + "/credentials", DeviceCredentials.class);
+
+        assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
+        accessToken = deviceCredentials.getCredentialsId();
+        assertNotNull(accessToken);
+
+        assertEquals(savedGateway.getId(), gatewayCredentials.getDeviceId());
+        gatewayAccessToken = gatewayCredentials.getCredentialsId();
+        assertNotNull(gatewayAccessToken);
+
+    }
+
+    protected void processAfterTest() throws Exception {
+        loginSysAdmin();
+        if (savedTenant != null) {
+            doDelete("/api/tenant/" + savedTenant.getId().getId().toString()).andExpect(status().isOk());
+        }
+    }
+
+    protected MqttAsyncClient getMqttAsyncClient(String accessToken) throws MqttException {
+        String clientId = MqttAsyncClient.generateClientId();
+        MqttAsyncClient client = new MqttAsyncClient(MQTT_URL, clientId);
+
+        MqttConnectOptions options = new MqttConnectOptions();
+        options.setUserName(accessToken);
+        client.connect(options).waitForCompletion();
+        return client;
+    }
+
+    protected void publishMqttMsg(MqttAsyncClient client, byte[] payload, String topic) throws MqttException {
+        MqttMessage message = new MqttMessage();
+        message.setPayload(payload);
+        client.publish(topic, message);
+    }
+
+    protected List<TransportProtos.KeyValueProto> getKvProtos(List<String> expectedKeys) {
+        List<TransportProtos.KeyValueProto> keyValueProtos = new ArrayList<>();
+        TransportProtos.KeyValueProto strKeyValueProto = getKeyValueProto(expectedKeys.get(0), "value1", TransportProtos.KeyValueType.STRING_V);
+        TransportProtos.KeyValueProto boolKeyValueProto = getKeyValueProto(expectedKeys.get(1), "true", TransportProtos.KeyValueType.BOOLEAN_V);
+        TransportProtos.KeyValueProto dblKeyValueProto = getKeyValueProto(expectedKeys.get(2), "3.0", TransportProtos.KeyValueType.DOUBLE_V);
+        TransportProtos.KeyValueProto longKeyValueProto = getKeyValueProto(expectedKeys.get(3), "4", TransportProtos.KeyValueType.LONG_V);
+        TransportProtos.KeyValueProto jsonKeyValueProto = getKeyValueProto(expectedKeys.get(4), "{\"someNumber\": 42, \"someArray\": [1,2,3], \"someNestedObject\": {\"key\": \"value\"}}", TransportProtos.KeyValueType.JSON_V);
+        keyValueProtos.add(strKeyValueProto);
+        keyValueProtos.add(boolKeyValueProto);
+        keyValueProtos.add(dblKeyValueProto);
+        keyValueProtos.add(longKeyValueProto);
+        keyValueProtos.add(jsonKeyValueProto);
+        return keyValueProtos;
+    }
+
+    protected TransportProtos.KeyValueProto getKeyValueProto(String key, String strValue, TransportProtos.KeyValueType type) {
+        TransportProtos.KeyValueProto.Builder keyValueProtoBuilder = TransportProtos.KeyValueProto.newBuilder();
+        keyValueProtoBuilder.setKey(key);
+        keyValueProtoBuilder.setType(type);
+        switch (type) {
+            case BOOLEAN_V:
+                keyValueProtoBuilder.setBoolV(Boolean.parseBoolean(strValue));
+                break;
+            case LONG_V:
+                keyValueProtoBuilder.setLongV(Long.parseLong(strValue));
+                break;
+            case DOUBLE_V:
+                keyValueProtoBuilder.setDoubleV(Double.parseDouble(strValue));
+                break;
+            case STRING_V:
+                keyValueProtoBuilder.setStringV(strValue);
+                break;
+            case JSON_V:
+                keyValueProtoBuilder.setJsonV(strValue);
+                break;
+        }
+        return keyValueProtoBuilder.build();
+    }
+
+    protected DeviceProfile createMqttDeviceProfile(TransportPayloadType transportPayloadType, String telemetryTopic, String attributesTopic) {
+        DeviceProfile deviceProfile = new DeviceProfile();
+        deviceProfile.setName(transportPayloadType.name());
+        deviceProfile.setType(DeviceProfileType.DEFAULT);
+        deviceProfile.setTransportType(DeviceTransportType.MQTT);
+        deviceProfile.setDescription(transportPayloadType.name() + " Test");
+        DeviceProfileData deviceProfileData = new DeviceProfileData();
+        DefaultDeviceProfileConfiguration configuration = new DefaultDeviceProfileConfiguration();
+        MqttDeviceProfileTransportConfiguration transportConfiguration = new MqttDeviceProfileTransportConfiguration();
+        transportConfiguration.setTransportPayloadType(transportPayloadType);
+        if (!StringUtils.isEmpty(telemetryTopic)) {
+            transportConfiguration.setDeviceTelemetryTopic(telemetryTopic);
+        }
+        if (!StringUtils.isEmpty(attributesTopic)) {
+            transportConfiguration.setDeviceAttributesTopic(attributesTopic);
+        }
+        deviceProfileData.setTransportConfiguration(transportConfiguration);
+        deviceProfileData.setConfiguration(configuration);
+        deviceProfile.setProfileData(deviceProfileData);
+        deviceProfile.setDefault(false);
+        deviceProfile.setDefaultRuleChainId(null);
+        return deviceProfile;
+    }
+
+    protected TransportProtos.PostAttributeMsg getPostAttributeMsg(List<String> expectedKeys) {
+        List<TransportProtos.KeyValueProto> kvProtos = getKvProtos(expectedKeys);
+        TransportProtos.PostAttributeMsg.Builder builder = TransportProtos.PostAttributeMsg.newBuilder();
+        builder.addAllKv(kvProtos);
+        return builder.build();
+    }
+
+}

@@ -27,7 +27,11 @@ import java.util.Arrays;
 @RunWith(ClasspathSuite.class)
 @RunWith(ClasspathSuite.class)
 @ClasspathSuite.ClassnameFilters({
 @ClasspathSuite.ClassnameFilters({
         "org.thingsboard.server.mqtt.rpc.sql.*Test",
         "org.thingsboard.server.mqtt.rpc.sql.*Test",
-        "org.thingsboard.server.mqtt.telemetry.sql.*Test"
+        "org.thingsboard.server.mqtt.telemetry.timeseries.sql.*Test",
+        "org.thingsboard.server.mqtt.telemetry.attributes.sql.*Test",
+        "org.thingsboard.server.mqtt.attributes.updates.sql.*Test",
+        "org.thingsboard.server.mqtt.attributes.request.sql.*Test",
+        "org.thingsboard.server.mqtt.claim.sql.*Test"
 })
 })
 public class MqttSqlTestSuite {
 public class MqttSqlTestSuite {
 
 

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
+import org.eclipse.paho.client.mqttv3.MqttCallback;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+@Slf4j
+public abstract class AbstractMqttAttributesIntegrationTest extends AbstractMqttIntegrationTest {
+
+    protected static final String POST_ATTRIBUTES_PAYLOAD = "{\"attribute1\":\"value1\",\"attribute2\":true,\"attribute3\":42.0,\"attribute4\":73," +
+            "\"attribute5\":{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}}";
+
+    protected void processBeforeTest(String deviceName, String gatewayName, TransportPayloadType payloadType, String telemetryTopic, String attributesTopic) throws Exception {
+        super.processBeforeTest(deviceName, gatewayName, payloadType, telemetryTopic, attributesTopic);
+    }
+
+    protected void processAfterTest() throws Exception {
+        super.processAfterTest();
+    }
+
+    protected List<TransportProtos.TsKvProto> getTsKvProtoList() {
+        TransportProtos.TsKvProto tsKvProtoAttribute1 = getTsKvProto("attribute1", "value1", TransportProtos.KeyValueType.STRING_V);
+        TransportProtos.TsKvProto tsKvProtoAttribute2 = getTsKvProto("attribute2", "true", TransportProtos.KeyValueType.BOOLEAN_V);
+        TransportProtos.TsKvProto tsKvProtoAttribute3 = getTsKvProto("attribute3", "42.0", TransportProtos.KeyValueType.DOUBLE_V);
+        TransportProtos.TsKvProto tsKvProtoAttribute4 = getTsKvProto("attribute4", "73", TransportProtos.KeyValueType.LONG_V);
+        TransportProtos.TsKvProto tsKvProtoAttribute5 = getTsKvProto("attribute5", "{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}", TransportProtos.KeyValueType.JSON_V);
+        List<TransportProtos.TsKvProto> tsKvProtoList = new ArrayList<>();
+        tsKvProtoList.add(tsKvProtoAttribute1);
+        tsKvProtoList.add(tsKvProtoAttribute2);
+        tsKvProtoList.add(tsKvProtoAttribute3);
+        tsKvProtoList.add(tsKvProtoAttribute4);
+        tsKvProtoList.add(tsKvProtoAttribute5);
+        return tsKvProtoList;
+    }
+
+
+    protected TransportProtos.TsKvProto getTsKvProto(String key, String value, TransportProtos.KeyValueType keyValueType) {
+        TransportProtos.TsKvProto.Builder tsKvProtoBuilder = TransportProtos.TsKvProto.newBuilder();
+        TransportProtos.KeyValueProto keyValueProto = getKeyValueProto(key, value, keyValueType);
+        tsKvProtoBuilder.setKv(keyValueProto);
+        return tsKvProtoBuilder.build();
+    }
+
+    protected TestMqttCallback getTestMqttCallback() {
+        CountDownLatch latch = new CountDownLatch(1);
+        return new TestMqttCallback(latch);
+    }
+
+    protected static class TestMqttCallback implements MqttCallback {
+
+        private final CountDownLatch latch;
+        private Integer qoS;
+        private byte[] payloadBytes;
+
+        TestMqttCallback(CountDownLatch latch) {
+            this.latch = latch;
+        }
+
+        public int getQoS() {
+            return qoS;
+        }
+
+        public byte[] getPayloadBytes() {
+            return payloadBytes;
+        }
+
+        public CountDownLatch getLatch() {
+            return latch;
+        }
+
+        @Override
+        public void connectionLost(Throwable throwable) {
+        }
+
+        @Override
+        public void messageArrived(String requestTopic, MqttMessage mqttMessage) throws Exception {
+            qoS = mqttMessage.getQos();
+            payloadBytes = mqttMessage.getPayload();
+            latch.countDown();
+        }
+
+        @Override
+        public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
+
+        }
+    }
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.request;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import io.netty.handler.codec.mqtt.MqttQoS;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttCallback;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.server.mqtt.attributes.AbstractMqttAttributesIntegrationTest;
+
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@Slf4j
+public abstract class AbstractMqttAttributesRequestIntegrationTest extends AbstractMqttAttributesIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Request attribute values from the server", "Gateway Test Request attribute values from the server", null, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testRequestAttributesValuesFromTheServer() throws Exception {
+        processTestRequestAttributesValuesFromTheServer();
+    }
+
+    @Test
+    public void testRequestAttributesValuesFromTheServerGateway() throws Exception {
+        processTestGatewayRequestAttributesValuesFromTheServer();
+    }
+
+    protected void processTestRequestAttributesValuesFromTheServer() throws Exception {
+
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
+
+        postAttributesAndSubscribeToTopic(savedDevice, client);
+
+        Thread.sleep(1000);
+
+        TestMqttCallback callback = getTestMqttCallback();
+        client.setCallback(callback);
+
+        validateResponse(client, callback.getLatch(), callback);
+    }
+
+    protected void processTestGatewayRequestAttributesValuesFromTheServer() throws Exception {
+
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+
+        postGatewayDeviceClientAttributes(client);
+
+        Thread.sleep(1000);
+
+        Device savedDevice = doGet("/api/tenant/devices?deviceName=" + "Gateway Device Request Attributes", Device.class);
+        assertNotNull(savedDevice);
+        doPostAsync("/api/plugins/telemetry/DEVICE/" + savedDevice.getId().getId() + "/attributes/SHARED_SCOPE", POST_ATTRIBUTES_PAYLOAD, String.class, status().isOk());
+
+        Thread.sleep(1000);
+
+        client.subscribe(MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC, MqttQoS.AT_LEAST_ONCE.value());
+
+        TestMqttCallback clientAttributesCallback = getTestMqttCallback();
+        client.setCallback(clientAttributesCallback);
+        validateClientResponseGateway(client, clientAttributesCallback);
+
+        TestMqttCallback sharedAttributesCallback = getTestMqttCallback();
+        client.setCallback(sharedAttributesCallback);
+        validateSharedResponseGateway(client, sharedAttributesCallback);
+    }
+
+    protected void postAttributesAndSubscribeToTopic(Device savedDevice, MqttAsyncClient client) throws Exception {
+        doPostAsync("/api/plugins/telemetry/DEVICE/" + savedDevice.getId().getId() + "/attributes/SHARED_SCOPE", POST_ATTRIBUTES_PAYLOAD, String.class, status().isOk());
+        client.publish(MqttTopics.DEVICE_ATTRIBUTES_TOPIC, new MqttMessage(POST_ATTRIBUTES_PAYLOAD.getBytes()));
+        client.subscribe(MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_TOPIC, MqttQoS.AT_MOST_ONCE.value());
+    }
+
+    protected void postGatewayDeviceClientAttributes(MqttAsyncClient client) throws Exception {
+        String postClientAttributes = "{\"" + "Gateway Device Request Attributes" + "\":{\"attribute1\":\"value1\",\"attribute2\":true,\"attribute3\":42.0,\"attribute4\":73,\"attribute5\":{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}}}";
+        client.publish(MqttTopics.GATEWAY_ATTRIBUTES_TOPIC, new MqttMessage(postClientAttributes.getBytes()));
+    }
+
+    protected void validateResponse(MqttAsyncClient client, CountDownLatch latch, TestMqttCallback callback) throws MqttException, InterruptedException, InvalidProtocolBufferException {
+        String keys = "attribute1,attribute2,attribute3,attribute4,attribute5";
+        String payloadStr = "{\"clientKeys\":\"" + keys + "\", \"sharedKeys\":\"" + keys + "\"}";
+        MqttMessage mqttMessage = new MqttMessage();
+        mqttMessage.setPayload(payloadStr.getBytes());
+        client.publish(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX + "1", mqttMessage);
+        latch.await(3, TimeUnit.SECONDS);
+        assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
+        String expectedRequestPayload = "{\"client\":{\"attribute1\":\"value1\",\"attribute2\":true,\"attribute3\":42.0,\"attribute4\":73,\"attribute5\":{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}},\"shared\":{\"attribute1\":\"value1\",\"attribute2\":true,\"attribute3\":42.0,\"attribute4\":73,\"attribute5\":{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}}}";
+        assertEquals(JacksonUtil.toJsonNode(expectedRequestPayload), JacksonUtil.toJsonNode(new String(callback.getPayloadBytes(), StandardCharsets.UTF_8)));
+    }
+
+    protected void validateClientResponseGateway(MqttAsyncClient client, TestMqttCallback callback) throws MqttException, InterruptedException, InvalidProtocolBufferException {
+        String payloadStr = "{\"id\": 1, \"device\": \"" + "Gateway Device Request Attributes" + "\", \"client\": true, \"keys\": [\"attribute1\", \"attribute2\", \"attribute3\", \"attribute4\", \"attribute5\"]}";
+        MqttMessage mqttMessage = new MqttMessage();
+        mqttMessage.setPayload(payloadStr.getBytes());
+        client.publish(MqttTopics.GATEWAY_ATTRIBUTES_REQUEST_TOPIC, mqttMessage);
+        callback.getLatch().await(3, TimeUnit.SECONDS);
+        assertEquals(MqttQoS.AT_LEAST_ONCE.value(), callback.getQoS());
+        String expectedRequestPayload = "{\"id\":1,\"device\":\"" + "Gateway Device Request Attributes" + "\",\"values\":{\"attribute1\":\"value1\",\"attribute2\":true,\"attribute3\":42.0,\"attribute4\":73,\"attribute5\":{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}}}";
+        assertEquals(JacksonUtil.toJsonNode(expectedRequestPayload), JacksonUtil.toJsonNode(new String(callback.getPayloadBytes(), StandardCharsets.UTF_8)));
+    }
+
+    protected void validateSharedResponseGateway(MqttAsyncClient client, TestMqttCallback callback) throws MqttException, InterruptedException, InvalidProtocolBufferException {
+        String payloadStr = "{\"id\": 1, \"device\": \"" + "Gateway Device Request Attributes" + "\", \"client\": false, \"keys\": [\"attribute1\", \"attribute2\", \"attribute3\", \"attribute4\", \"attribute5\"]}";
+        MqttMessage mqttMessage = new MqttMessage();
+        mqttMessage.setPayload(payloadStr.getBytes());
+        client.publish(MqttTopics.GATEWAY_ATTRIBUTES_REQUEST_TOPIC, mqttMessage);
+        callback.getLatch().await(3, TimeUnit.SECONDS);
+        assertEquals(MqttQoS.AT_LEAST_ONCE.value(), callback.getQoS());
+        String expectedRequestPayload = "{\"id\":1,\"device\":\"" + "Gateway Device Request Attributes" + "\",\"values\":{\"attribute1\":\"value1\",\"attribute2\":true,\"attribute3\":42.0,\"attribute4\":73,\"attribute5\":{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}}}";
+        assertEquals(JacksonUtil.toJsonNode(expectedRequestPayload), JacksonUtil.toJsonNode(new String(callback.getPayloadBytes(), StandardCharsets.UTF_8)));
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.request;
+
+import lombok.extern.slf4j.Slf4j;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+@Slf4j
+public abstract class AbstractMqttAttributesRequestJsonIntegrationTest extends AbstractMqttAttributesRequestIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Request attribute values from the server json", "Gateway Test Request attribute values from the server json", TransportPayloadType.JSON, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testRequestAttributesValuesFromTheServer() throws Exception {
+        processTestRequestAttributesValuesFromTheServer();
+    }
+
+    @Test
+    public void testRequestAttributesValuesFromTheServerGateway() throws Exception {
+        processTestGatewayRequestAttributesValuesFromTheServer();
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.request;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import io.netty.handler.codec.mqtt.MqttQoS;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@Slf4j
+public abstract class AbstractMqttAttributesRequestProtoIntegrationTest extends AbstractMqttAttributesRequestIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Request attribute values from the server proto", "Gateway Test Request attribute values from the server proto", TransportPayloadType.PROTOBUF, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testRequestAttributesValuesFromTheServer() throws Exception {
+        processTestRequestAttributesValuesFromTheServer();
+    }
+
+
+    @Test
+    public void testRequestAttributesValuesFromTheServerGateway() throws Exception {
+        processTestGatewayRequestAttributesValuesFromTheServer();
+    }
+
+    protected void postAttributesAndSubscribeToTopic(Device savedDevice, MqttAsyncClient client) throws Exception {
+        doPostAsync("/api/plugins/telemetry/DEVICE/" + savedDevice.getId().getId() + "/attributes/SHARED_SCOPE", POST_ATTRIBUTES_PAYLOAD, String.class, status().isOk());
+        String keys = "attribute1,attribute2,attribute3,attribute4,attribute5";
+        List<String> expectedKeys = Arrays.asList(keys.split(","));
+        TransportProtos.PostAttributeMsg postAttributeMsg = getPostAttributeMsg(expectedKeys);
+        byte[] payload = postAttributeMsg.toByteArray();
+        client.publish(MqttTopics.DEVICE_ATTRIBUTES_TOPIC, new MqttMessage(payload));
+        client.subscribe(MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_TOPIC, MqttQoS.AT_MOST_ONCE.value());
+    }
+
+    protected void postGatewayDeviceClientAttributes(MqttAsyncClient client) throws Exception {
+        String keys = "attribute1,attribute2,attribute3,attribute4,attribute5";
+        List<String> expectedKeys = Arrays.asList(keys.split(","));
+        TransportProtos.PostAttributeMsg postAttributeMsg = getPostAttributeMsg(expectedKeys);
+        TransportApiProtos.AttributesMsg.Builder attributesMsgBuilder = TransportApiProtos.AttributesMsg.newBuilder();
+        attributesMsgBuilder.setDeviceName("Gateway Device Request Attributes");
+        attributesMsgBuilder.setMsg(postAttributeMsg);
+        TransportApiProtos.AttributesMsg attributesMsg = attributesMsgBuilder.build();
+        TransportApiProtos.GatewayAttributesMsg.Builder gatewayAttributeMsgBuilder = TransportApiProtos.GatewayAttributesMsg.newBuilder();
+        gatewayAttributeMsgBuilder.addMsg(attributesMsg);
+        byte[] bytes = gatewayAttributeMsgBuilder.build().toByteArray();
+        client.publish(MqttTopics.GATEWAY_ATTRIBUTES_TOPIC, new MqttMessage(bytes));
+    }
+
+    protected void validateResponse(MqttAsyncClient client, CountDownLatch latch, TestMqttCallback callback) throws MqttException, InterruptedException, InvalidProtocolBufferException {
+        String keys = "attribute1,attribute2,attribute3,attribute4,attribute5";
+        TransportApiProtos.AttributesRequest.Builder attributesRequestBuilder = TransportApiProtos.AttributesRequest.newBuilder();
+        attributesRequestBuilder.setClientKeys(keys);
+        attributesRequestBuilder.setSharedKeys(keys);
+        TransportApiProtos.AttributesRequest attributesRequest = attributesRequestBuilder.build();
+        MqttMessage mqttMessage = new MqttMessage();
+        mqttMessage.setPayload(attributesRequest.toByteArray());
+        client.publish(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX + "1", mqttMessage);
+        latch.await(3, TimeUnit.SECONDS);
+        assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
+        TransportProtos.GetAttributeResponseMsg expectedAttributesResponse = getExpectedAttributeResponseMsg();
+        TransportProtos.GetAttributeResponseMsg actualAttributesResponse = TransportProtos.GetAttributeResponseMsg.parseFrom(callback.getPayloadBytes());
+        assertEquals(expectedAttributesResponse.getRequestId(), actualAttributesResponse.getRequestId());
+        List<TransportProtos.KeyValueProto> expectedClientKeyValueProtos = expectedAttributesResponse.getClientAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+        List<TransportProtos.KeyValueProto> expectedSharedKeyValueProtos = expectedAttributesResponse.getSharedAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+        List<TransportProtos.KeyValueProto> actualClientKeyValueProtos = actualAttributesResponse.getClientAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+        List<TransportProtos.KeyValueProto> actualSharedKeyValueProtos = actualAttributesResponse.getSharedAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+        assertTrue(actualClientKeyValueProtos.containsAll(expectedClientKeyValueProtos));
+        assertTrue(actualSharedKeyValueProtos.containsAll(expectedSharedKeyValueProtos));
+    }
+
+    protected void validateClientResponseGateway(MqttAsyncClient client, TestMqttCallback callback) throws MqttException, InterruptedException, InvalidProtocolBufferException {
+            String keys = "attribute1,attribute2,attribute3,attribute4,attribute5";
+            TransportApiProtos.GatewayAttributesRequestMsg gatewayAttributesRequestMsg = getGatewayAttributesRequestMsg(keys, true);
+            client.publish(MqttTopics.GATEWAY_ATTRIBUTES_REQUEST_TOPIC, new MqttMessage(gatewayAttributesRequestMsg.toByteArray()));
+            callback.getLatch().await(3, TimeUnit.SECONDS);
+            assertEquals(MqttQoS.AT_LEAST_ONCE.value(), callback.getQoS());
+            TransportApiProtos.GatewayAttributeResponseMsg expectedGatewayAttributeResponseMsg = getExpectedGatewayAttributeResponseMsg(true);
+            TransportApiProtos.GatewayAttributeResponseMsg actualGatewayAttributeResponseMsg = TransportApiProtos.GatewayAttributeResponseMsg.parseFrom(callback.getPayloadBytes());
+            assertEquals(expectedGatewayAttributeResponseMsg.getDeviceName(), actualGatewayAttributeResponseMsg.getDeviceName());
+
+            TransportProtos.GetAttributeResponseMsg expectedResponseMsg = expectedGatewayAttributeResponseMsg.getResponseMsg();
+            TransportProtos.GetAttributeResponseMsg actualResponseMsg = actualGatewayAttributeResponseMsg.getResponseMsg();
+            assertEquals(expectedResponseMsg.getRequestId(), actualResponseMsg.getRequestId());
+
+            List<TransportProtos.KeyValueProto> expectedClientKeyValueProtos = expectedResponseMsg.getClientAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+            List<TransportProtos.KeyValueProto> actualClientKeyValueProtos = actualResponseMsg.getClientAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+            assertTrue(actualClientKeyValueProtos.containsAll(expectedClientKeyValueProtos));
+    }
+
+    protected void validateSharedResponseGateway(MqttAsyncClient client, TestMqttCallback callback) throws MqttException, InterruptedException, InvalidProtocolBufferException {
+            String keys = "attribute1,attribute2,attribute3,attribute4,attribute5";
+            TransportApiProtos.GatewayAttributesRequestMsg gatewayAttributesRequestMsg = getGatewayAttributesRequestMsg(keys, false);
+            client.publish(MqttTopics.GATEWAY_ATTRIBUTES_REQUEST_TOPIC, new MqttMessage(gatewayAttributesRequestMsg.toByteArray()));
+            callback.getLatch().await(3, TimeUnit.SECONDS);
+            assertEquals(MqttQoS.AT_LEAST_ONCE.value(), callback.getQoS());
+            TransportApiProtos.GatewayAttributeResponseMsg expectedGatewayAttributeResponseMsg = getExpectedGatewayAttributeResponseMsg(false);
+            TransportApiProtos.GatewayAttributeResponseMsg actualGatewayAttributeResponseMsg = TransportApiProtos.GatewayAttributeResponseMsg.parseFrom(callback.getPayloadBytes());
+            assertEquals(expectedGatewayAttributeResponseMsg.getDeviceName(), actualGatewayAttributeResponseMsg.getDeviceName());
+
+            TransportProtos.GetAttributeResponseMsg expectedResponseMsg = expectedGatewayAttributeResponseMsg.getResponseMsg();
+            TransportProtos.GetAttributeResponseMsg actualResponseMsg = actualGatewayAttributeResponseMsg.getResponseMsg();
+            assertEquals(expectedResponseMsg.getRequestId(), actualResponseMsg.getRequestId());
+
+            List<TransportProtos.KeyValueProto> expectedSharedKeyValueProtos = expectedResponseMsg.getSharedAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+            List<TransportProtos.KeyValueProto> actualSharedKeyValueProtos = actualResponseMsg.getSharedAttributeListList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+
+            assertTrue(actualSharedKeyValueProtos.containsAll(expectedSharedKeyValueProtos));
+    }
+
+    private TransportApiProtos.GatewayAttributesRequestMsg getGatewayAttributesRequestMsg(String keys, boolean client) {
+        return TransportApiProtos.GatewayAttributesRequestMsg.newBuilder()
+                .setClient(client)
+                .addAllKeys(Arrays.asList(keys.split(",")))
+                .setDeviceName("Gateway Device Request Attributes")
+                .setId(1).build();
+    }
+
+    private TransportProtos.GetAttributeResponseMsg getExpectedAttributeResponseMsg() {
+        TransportProtos.GetAttributeResponseMsg.Builder result = TransportProtos.GetAttributeResponseMsg.newBuilder();
+        List<TransportProtos.TsKvProto> tsKvProtoList = getTsKvProtoList();
+        result.addAllClientAttributeList(tsKvProtoList);
+        result.addAllSharedAttributeList(tsKvProtoList);
+        result.setRequestId(1);
+        return result.build();
+    }
+
+    private TransportApiProtos.GatewayAttributeResponseMsg getExpectedGatewayAttributeResponseMsg(boolean client) {
+        TransportApiProtos.GatewayAttributeResponseMsg.Builder gatewayAttributeResponseMsg = TransportApiProtos.GatewayAttributeResponseMsg.newBuilder();
+        TransportProtos.GetAttributeResponseMsg.Builder getAttributeResponseMsgBuilder = TransportProtos.GetAttributeResponseMsg.newBuilder();
+        List<TransportProtos.TsKvProto> tsKvProtoList = getTsKvProtoList();
+        if (client) {
+            getAttributeResponseMsgBuilder.addAllClientAttributeList(tsKvProtoList);
+        } else {
+            getAttributeResponseMsgBuilder.addAllSharedAttributeList(tsKvProtoList);
+        }
+        getAttributeResponseMsgBuilder.setRequestId(1);
+        TransportProtos.GetAttributeResponseMsg getAttributeResponseMsg = getAttributeResponseMsgBuilder.build();
+        gatewayAttributeResponseMsg.setDeviceName("Gateway Device Request Attributes");
+        gatewayAttributeResponseMsg.setResponseMsg(getAttributeResponseMsg);
+        return gatewayAttributeResponseMsg.build();
+    }
+
+    protected List<TransportProtos.KeyValueProto> getKvProtos(List<String> expectedKeys) {
+        List<TransportProtos.KeyValueProto> keyValueProtos = new ArrayList<>();
+        TransportProtos.KeyValueProto strKeyValueProto = getKeyValueProto(expectedKeys.get(0), "value1", TransportProtos.KeyValueType.STRING_V);
+        TransportProtos.KeyValueProto boolKeyValueProto = getKeyValueProto(expectedKeys.get(1), "true", TransportProtos.KeyValueType.BOOLEAN_V);
+        TransportProtos.KeyValueProto dblKeyValueProto = getKeyValueProto(expectedKeys.get(2), "42.0", TransportProtos.KeyValueType.DOUBLE_V);
+        TransportProtos.KeyValueProto longKeyValueProto = getKeyValueProto(expectedKeys.get(3), "73", TransportProtos.KeyValueType.LONG_V);
+        TransportProtos.KeyValueProto jsonKeyValueProto = getKeyValueProto(expectedKeys.get(4), "{\"someNumber\": 42, \"someArray\": [1,2,3], \"someNestedObject\": {\"key\": \"value\"}}", TransportProtos.KeyValueType.JSON_V);
+        keyValueProtos.add(strKeyValueProto);
+        keyValueProtos.add(boolKeyValueProto);
+        keyValueProtos.add(dblKeyValueProto);
+        keyValueProtos.add(longKeyValueProto);
+        keyValueProtos.add(jsonKeyValueProto);
+        return keyValueProtos;
+    }
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.request.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.attributes.request.AbstractMqttAttributesRequestIntegrationTest;
+
+
+@DaoNoSqlTest
+public class MqttAttributesRequestNoSqlIntegrationTest extends AbstractMqttAttributesRequestIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.request.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.attributes.request.AbstractMqttAttributesRequestIntegrationTest;
+import org.thingsboard.server.mqtt.attributes.request.AbstractMqttAttributesRequestJsonIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesRequestJsonSqlIntegrationTest extends AbstractMqttAttributesRequestJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.request.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.attributes.request.AbstractMqttAttributesRequestJsonIntegrationTest;
+import org.thingsboard.server.mqtt.attributes.request.AbstractMqttAttributesRequestProtoIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesRequestProtoSqlIntegrationTest extends AbstractMqttAttributesRequestProtoIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.request.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.attributes.request.AbstractMqttAttributesRequestIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesRequestSqlIntegrationTest extends AbstractMqttAttributesRequestIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.updates;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import io.netty.handler.codec.mqtt.MqttQoS;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttCallback;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.server.mqtt.attributes.AbstractMqttAttributesIntegrationTest;
+
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@Slf4j
+public abstract class AbstractMqttAttributesUpdatesIntegrationTest extends AbstractMqttAttributesIntegrationTest {
+
+    private static final String RESPONSE_ATTRIBUTES_PAYLOAD_DELETED = "{\"deleted\":[\"attribute5\"]}";
+
+    private static String getResponseGatewayAttributesUpdatedPayload() {
+        return "{\"device\":\"" + "Gateway Device Subscribe to attribute updates" + "\"," +
+                "\"data\":{\"attribute1\":\"value1\",\"attribute2\":true,\"attribute3\":42.0,\"attribute4\":73,\"attribute5\":{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}}}";
+    }
+
+    private static String getResponseGatewayAttributesDeletedPayload() {
+        return "{\"device\":\"" + "Gateway Device Subscribe to attribute updates" + "\",\"data\":{\"deleted\":[\"attribute5\"]}}";
+    }
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Subscribe to attribute updates", "Gateway Test Subscribe to attribute updates", TransportPayloadType.JSON, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testSubscribeToAttributesUpdatesFromTheServer() throws Exception {
+        processTestSubscribeToAttributesUpdates();
+    }
+
+    @Test
+    public void testSubscribeToAttributesUpdatesFromTheServerGateway() throws Exception {
+        processGatewayTestSubscribeToAttributesUpdates();
+    }
+
+    protected void processTestSubscribeToAttributesUpdates() throws Exception {
+
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
+
+        TestMqttCallback onUpdateCallback = getTestMqttCallback();
+        client.setCallback(onUpdateCallback);
+
+        client.subscribe(MqttTopics.DEVICE_ATTRIBUTES_TOPIC, MqttQoS.AT_MOST_ONCE.value());
+
+        Thread.sleep(2000);
+
+        doPostAsync("/api/plugins/telemetry/DEVICE/" + savedDevice.getId().getId() + "/attributes/SHARED_SCOPE", POST_ATTRIBUTES_PAYLOAD, String.class, status().isOk());
+        onUpdateCallback.getLatch().await(3, TimeUnit.SECONDS);
+
+        validateUpdateAttributesResponse(onUpdateCallback);
+
+        TestMqttCallback onDeleteCallback = getTestMqttCallback();
+        client.setCallback(onDeleteCallback);
+
+        doDelete("/api/plugins/telemetry/DEVICE/" + savedDevice.getId().getId() + "/SHARED_SCOPE?keys=attribute5", String.class);
+        onDeleteCallback.getLatch().await(3, TimeUnit.SECONDS);
+
+        validateDeleteAttributesResponse(onDeleteCallback);
+    }
+
+    protected void validateUpdateAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+        String response = new String(callback.getPayloadBytes(), StandardCharsets.UTF_8);
+        assertEquals(JacksonUtil.toJsonNode(POST_ATTRIBUTES_PAYLOAD), JacksonUtil.toJsonNode(response));
+    }
+
+    protected void validateDeleteAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+        String response = new String(callback.getPayloadBytes(), StandardCharsets.UTF_8);
+        assertEquals(JacksonUtil.toJsonNode(RESPONSE_ATTRIBUTES_PAYLOAD_DELETED), JacksonUtil.toJsonNode(response));
+    }
+
+    protected void processGatewayTestSubscribeToAttributesUpdates() throws Exception {
+
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+
+        TestMqttCallback onUpdateCallback = getTestMqttCallback();
+        client.setCallback(onUpdateCallback);
+
+        Device device = new Device();
+        device.setName("Gateway Device Subscribe to attribute updates");
+        device.setType("default");
+
+        byte[] connectPayloadBytes = getConnectPayloadBytes();
+
+        publishMqttMsg(client, connectPayloadBytes, MqttTopics.GATEWAY_CONNECT_TOPIC);
+
+        Thread.sleep(1000);
+
+        Device savedDevice = doGet("/api/tenant/devices?deviceName=" + "Gateway Device Subscribe to attribute updates", Device.class);
+        assertNotNull(savedDevice);
+
+        client.subscribe(MqttTopics.GATEWAY_ATTRIBUTES_TOPIC, MqttQoS.AT_MOST_ONCE.value());
+
+        Thread.sleep(2000);
+
+        doPostAsync("/api/plugins/telemetry/DEVICE/" + savedDevice.getId().getId() + "/attributes/SHARED_SCOPE", POST_ATTRIBUTES_PAYLOAD, String.class, status().isOk());
+        onUpdateCallback.getLatch().await(3, TimeUnit.SECONDS);
+
+        validateGatewayUpdateAttributesResponse(onUpdateCallback);
+
+        TestMqttCallback onDeleteCallback = getTestMqttCallback();
+        client.setCallback(onDeleteCallback);
+
+        doDelete("/api/plugins/telemetry/DEVICE/" + savedDevice.getId().getId() + "/SHARED_SCOPE?keys=attribute5", String.class);
+        onDeleteCallback.getLatch().await(3, TimeUnit.SECONDS);
+
+        validateGatewayDeleteAttributesResponse(onDeleteCallback);
+
+    }
+
+    protected void validateGatewayUpdateAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+        String s = new String(callback.getPayloadBytes(), StandardCharsets.UTF_8);
+        assertEquals(getResponseGatewayAttributesUpdatedPayload(), s);
+    }
+
+    protected void validateGatewayDeleteAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+        String s = new String(callback.getPayloadBytes(), StandardCharsets.UTF_8);
+        assertEquals(s, getResponseGatewayAttributesDeletedPayload());
+    }
+
+    protected byte[] getConnectPayloadBytes() {
+        String connectPayload = "{\"device\": \"Gateway Device Subscribe to attribute updates\", \"type\": \"" + TransportPayloadType.JSON.name() + "\"}";
+        return connectPayload.getBytes();
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.updates;
+
+import lombok.extern.slf4j.Slf4j;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+@Slf4j
+public abstract class AbstractMqttAttributesUpdatesJsonIntegrationTest extends AbstractMqttAttributesUpdatesIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Subscribe to attribute updates", "Gateway Test Subscribe to attribute updates", TransportPayloadType.JSON, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testSubscribeToAttributesUpdatesFromTheServer() throws Exception {
+        processTestSubscribeToAttributesUpdates();
+    }
+
+    @Test
+    public void testSubscribeToAttributesUpdatesFromTheServerGateway() throws Exception {
+        processGatewayTestSubscribeToAttributesUpdates();
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.updates;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+@Slf4j
+public abstract class AbstractMqttAttributesUpdatesProtoIntegrationTest extends AbstractMqttAttributesUpdatesIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Subscribe to attribute updates", "Gateway Test Subscribe to attribute updates", TransportPayloadType.PROTOBUF, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testSubscribeToAttributesUpdatesFromTheServer() throws Exception {
+        processTestSubscribeToAttributesUpdates();
+    }
+
+    @Test
+    public void testSubscribeToAttributesUpdatesFromTheServerGateway() throws Exception {
+        processGatewayTestSubscribeToAttributesUpdates();
+    }
+
+    protected void validateUpdateAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+        TransportProtos.AttributeUpdateNotificationMsg.Builder attributeUpdateNotificationMsgBuilder = TransportProtos.AttributeUpdateNotificationMsg.newBuilder();
+        List<TransportProtos.TsKvProto> tsKvProtoList = getTsKvProtoList();
+        attributeUpdateNotificationMsgBuilder.addAllSharedUpdated(tsKvProtoList);
+
+        TransportProtos.AttributeUpdateNotificationMsg expectedAttributeUpdateNotificationMsg = attributeUpdateNotificationMsgBuilder.build();
+        TransportProtos.AttributeUpdateNotificationMsg actualAttributeUpdateNotificationMsg = TransportProtos.AttributeUpdateNotificationMsg.parseFrom(callback.getPayloadBytes());
+
+        List<TransportProtos.KeyValueProto> actualSharedUpdatedList = actualAttributeUpdateNotificationMsg.getSharedUpdatedList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+        List<TransportProtos.KeyValueProto> expectedSharedUpdatedList = expectedAttributeUpdateNotificationMsg.getSharedUpdatedList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+
+        assertEquals(expectedSharedUpdatedList.size(), actualSharedUpdatedList.size());
+        assertTrue(actualSharedUpdatedList.containsAll(expectedSharedUpdatedList));
+
+    }
+
+    protected void validateDeleteAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+        TransportProtos.AttributeUpdateNotificationMsg.Builder attributeUpdateNotificationMsgBuilder = TransportProtos.AttributeUpdateNotificationMsg.newBuilder();
+        attributeUpdateNotificationMsgBuilder.addSharedDeleted("attribute5");
+
+        TransportProtos.AttributeUpdateNotificationMsg expectedAttributeUpdateNotificationMsg = attributeUpdateNotificationMsgBuilder.build();
+        TransportProtos.AttributeUpdateNotificationMsg actualAttributeUpdateNotificationMsg = TransportProtos.AttributeUpdateNotificationMsg.parseFrom(callback.getPayloadBytes());
+
+        assertEquals(expectedAttributeUpdateNotificationMsg.getSharedDeletedList().size(), actualAttributeUpdateNotificationMsg.getSharedDeletedList().size());
+        assertEquals("attribute5", actualAttributeUpdateNotificationMsg.getSharedDeletedList().get(0));
+
+    }
+
+    protected void validateGatewayUpdateAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+
+        TransportProtos.AttributeUpdateNotificationMsg.Builder attributeUpdateNotificationMsgBuilder = TransportProtos.AttributeUpdateNotificationMsg.newBuilder();
+        List<TransportProtos.TsKvProto> tsKvProtoList = getTsKvProtoList();
+        attributeUpdateNotificationMsgBuilder.addAllSharedUpdated(tsKvProtoList);
+        TransportProtos.AttributeUpdateNotificationMsg expectedAttributeUpdateNotificationMsg = attributeUpdateNotificationMsgBuilder.build();
+
+        TransportApiProtos.GatewayAttributeUpdateNotificationMsg.Builder gatewayAttributeUpdateNotificationMsgBuilder = TransportApiProtos.GatewayAttributeUpdateNotificationMsg.newBuilder();
+        gatewayAttributeUpdateNotificationMsgBuilder.setDeviceName("Gateway Device Subscribe to attribute updates");
+        gatewayAttributeUpdateNotificationMsgBuilder.setNotificationMsg(expectedAttributeUpdateNotificationMsg);
+
+        TransportApiProtos.GatewayAttributeUpdateNotificationMsg expectedGatewayAttributeUpdateNotificationMsg = gatewayAttributeUpdateNotificationMsgBuilder.build();
+        TransportApiProtos.GatewayAttributeUpdateNotificationMsg actualGatewayAttributeUpdateNotificationMsg = TransportApiProtos.GatewayAttributeUpdateNotificationMsg.parseFrom(callback.getPayloadBytes());
+
+        assertEquals(expectedGatewayAttributeUpdateNotificationMsg.getDeviceName(), actualGatewayAttributeUpdateNotificationMsg.getDeviceName());
+
+        List<TransportProtos.KeyValueProto> actualSharedUpdatedList = actualGatewayAttributeUpdateNotificationMsg.getNotificationMsg().getSharedUpdatedList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+        List<TransportProtos.KeyValueProto> expectedSharedUpdatedList = expectedGatewayAttributeUpdateNotificationMsg.getNotificationMsg().getSharedUpdatedList().stream().map(TransportProtos.TsKvProto::getKv).collect(Collectors.toList());
+
+        assertEquals(expectedSharedUpdatedList.size(), actualSharedUpdatedList.size());
+        assertTrue(actualSharedUpdatedList.containsAll(expectedSharedUpdatedList));
+
+    }
+
+    protected void validateGatewayDeleteAttributesResponse(TestMqttCallback callback) throws InvalidProtocolBufferException {
+        assertNotNull(callback.getPayloadBytes());
+        TransportProtos.AttributeUpdateNotificationMsg.Builder attributeUpdateNotificationMsgBuilder = TransportProtos.AttributeUpdateNotificationMsg.newBuilder();
+        attributeUpdateNotificationMsgBuilder.addSharedDeleted("attribute5");
+        TransportProtos.AttributeUpdateNotificationMsg attributeUpdateNotificationMsg = attributeUpdateNotificationMsgBuilder.build();
+
+        TransportApiProtos.GatewayAttributeUpdateNotificationMsg.Builder gatewayAttributeUpdateNotificationMsgBuilder = TransportApiProtos.GatewayAttributeUpdateNotificationMsg.newBuilder();
+        gatewayAttributeUpdateNotificationMsgBuilder.setDeviceName("Gateway Device Subscribe to attribute updates");
+        gatewayAttributeUpdateNotificationMsgBuilder.setNotificationMsg(attributeUpdateNotificationMsg);
+
+        TransportApiProtos.GatewayAttributeUpdateNotificationMsg expectedGatewayAttributeUpdateNotificationMsg = gatewayAttributeUpdateNotificationMsgBuilder.build();
+        TransportApiProtos.GatewayAttributeUpdateNotificationMsg actualGatewayAttributeUpdateNotificationMsg = TransportApiProtos.GatewayAttributeUpdateNotificationMsg.parseFrom(callback.getPayloadBytes());
+
+        assertEquals(expectedGatewayAttributeUpdateNotificationMsg.getDeviceName(), actualGatewayAttributeUpdateNotificationMsg.getDeviceName());
+
+        TransportProtos.AttributeUpdateNotificationMsg expectedAttributeUpdateNotificationMsg = expectedGatewayAttributeUpdateNotificationMsg.getNotificationMsg();
+        TransportProtos.AttributeUpdateNotificationMsg actualAttributeUpdateNotificationMsg = actualGatewayAttributeUpdateNotificationMsg.getNotificationMsg();
+
+        assertEquals(expectedAttributeUpdateNotificationMsg.getSharedDeletedList().size(), actualAttributeUpdateNotificationMsg.getSharedDeletedList().size());
+        assertEquals("attribute5", actualAttributeUpdateNotificationMsg.getSharedDeletedList().get(0));
+
+    }
+
+    protected byte[] getConnectPayloadBytes() {
+        TransportApiProtos.ConnectMsg connectProto = getConnectProto();
+        return connectProto.toByteArray();
+    }
+
+    private TransportApiProtos.ConnectMsg getConnectProto() {
+        TransportApiProtos.ConnectMsg.Builder builder = TransportApiProtos.ConnectMsg.newBuilder();
+        builder.setDeviceName("Gateway Device Subscribe to attribute updates");
+        builder.setDeviceType(TransportPayloadType.PROTOBUF.name());
+        return builder.build();
+    }
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.updates.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.attributes.updates.AbstractMqttAttributesUpdatesJsonIntegrationTest;
+
+
+@DaoNoSqlTest
+public class MqttAttributesUpdatesNoSqlIntegrationTest extends AbstractMqttAttributesUpdatesJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.updates.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.attributes.updates.AbstractMqttAttributesUpdatesIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesUpdatesSqlIntegrationTest extends AbstractMqttAttributesUpdatesIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.updates.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.attributes.updates.AbstractMqttAttributesUpdatesIntegrationTest;
+import org.thingsboard.server.mqtt.attributes.updates.AbstractMqttAttributesUpdatesJsonIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesUpdatesSqlJsonIntegrationTest extends AbstractMqttAttributesUpdatesJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.attributes.updates.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.attributes.updates.AbstractMqttAttributesUpdatesJsonIntegrationTest;
+import org.thingsboard.server.mqtt.attributes.updates.AbstractMqttAttributesUpdatesProtoIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesUpdatesSqlProtoIntegrationTest extends AbstractMqttAttributesUpdatesProtoIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.claim;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.ClaimRequest;
+import org.thingsboard.server.common.data.Customer;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.data.security.Authority;
+import org.thingsboard.server.dao.device.claim.ClaimResponse;
+import org.thingsboard.server.dao.device.claim.ClaimResult;
+import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@Slf4j
+public abstract class AbstractMqttClaimDeviceTest extends AbstractMqttIntegrationTest {
+
+    protected static final String CUSTOMER_USER_PASSWORD = "customerUser123!";
+
+    protected User customerAdmin;
+    protected Customer savedCustomer;
+
+    @Before
+    public void beforeTest() throws Exception {
+        super.processBeforeTest("Test Claim device", "Test Claim gateway", null, null, null);
+        createCustomerAndUser();
+    }
+
+    protected void createCustomerAndUser() throws Exception {
+        Customer customer = new Customer();
+        customer.setTenantId(savedTenant.getId());
+        customer.setTitle("Test Claiming Customer");
+        savedCustomer = doPost("/api/customer", customer, Customer.class);
+        assertNotNull(savedCustomer);
+        assertEquals(savedTenant.getId(), savedCustomer.getTenantId());
+
+        User user = new User();
+        user.setAuthority(Authority.CUSTOMER_USER);
+        user.setTenantId(savedTenant.getId());
+        user.setCustomerId(savedCustomer.getId());
+        user.setEmail("customer@thingsboard.org");
+
+        customerAdmin = createUser(user, CUSTOMER_USER_PASSWORD);
+        assertNotNull(customerAdmin);
+        assertEquals(customerAdmin.getCustomerId(), savedCustomer.getId());
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        super.processAfterTest();
+    }
+
+    @Test
+    public void testClaimingDevice() throws Exception {
+        processTestClaimingDevice(false);
+    }
+
+    @Test
+    public void testClaimingDeviceWithoutSecretAndDuration() throws Exception {
+        processTestClaimingDevice(true);
+    }
+
+    @Test
+    public void testGatewayClaimingDevice() throws Exception {
+        processTestGatewayClaimingDevice("Test claiming gateway device", false);
+    }
+
+    @Test
+    public void testGatewayClaimingDeviceWithoutSecretAndDuration() throws Exception {
+        processTestGatewayClaimingDevice("Test claiming gateway device empty payload", true);
+    }
+
+
+    protected void processTestClaimingDevice(boolean emptyPayload) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
+        byte[] payloadBytes;
+        byte[] failurePayloadBytes;
+        if (emptyPayload) {
+            payloadBytes = "{}".getBytes();
+            failurePayloadBytes = "{\"durationMs\":1}".getBytes();
+        } else {
+            payloadBytes = "{\"secretKey\":\"value\", \"durationMs\":60000}".getBytes();
+            failurePayloadBytes = "{\"secretKey\":\"value\", \"durationMs\":1}".getBytes();
+        }
+        validateClaimResponse(emptyPayload, client, payloadBytes, failurePayloadBytes);
+    }
+
+    protected void validateClaimResponse(boolean emptyPayload, MqttAsyncClient client, byte[] payloadBytes, byte[] failurePayloadBytes) throws Exception {
+        client.publish(MqttTopics.DEVICE_CLAIM_TOPIC, new MqttMessage(failurePayloadBytes));
+
+        Thread.sleep(2000);
+
+        loginUser(customerAdmin.getName(), CUSTOMER_USER_PASSWORD);
+        ClaimRequest claimRequest;
+        if (!emptyPayload) {
+            claimRequest = new ClaimRequest("value");
+        } else {
+            claimRequest = new ClaimRequest(null);
+        }
+
+        ClaimResponse claimResponse = doPostClaimAsync("/api/customer/device/" + savedDevice.getName() + "/claim", claimRequest, ClaimResponse.class, status().isBadRequest());
+        assertEquals(claimResponse, ClaimResponse.FAILURE);
+
+        client.publish(MqttTopics.DEVICE_CLAIM_TOPIC, new MqttMessage(payloadBytes));
+
+        Thread.sleep(2000);
+
+        ClaimResult claimResult = doPostClaimAsync("/api/customer/device/" + savedDevice.getName() + "/claim", claimRequest, ClaimResult.class, status().isOk());
+        assertEquals(claimResult.getResponse(), ClaimResponse.SUCCESS);
+        Device claimedDevice = claimResult.getDevice();
+        assertNotNull(claimedDevice);
+        assertNotNull(claimedDevice.getCustomerId());
+        assertEquals(customerAdmin.getCustomerId(), claimedDevice.getCustomerId());
+
+        claimResponse = doPostClaimAsync("/api/customer/device/" + savedDevice.getName() + "/claim", claimRequest, ClaimResponse.class, status().isBadRequest());
+        assertEquals(claimResponse, ClaimResponse.CLAIMED);
+    }
+
+    protected void validateGatewayClaimResponse(String deviceName, boolean emptyPayload, MqttAsyncClient client, byte[] failurePayloadBytes, byte[] payloadBytes) throws Exception {
+        client.publish(MqttTopics.GATEWAY_CLAIM_TOPIC, new MqttMessage(failurePayloadBytes));
+
+        Thread.sleep(2000);
+
+        Device savedDevice = doGet("/api/tenant/devices?deviceName=" + deviceName, Device.class);
+        assertNotNull(savedDevice);
+
+        loginUser(customerAdmin.getName(), CUSTOMER_USER_PASSWORD);
+        ClaimRequest claimRequest;
+        if (!emptyPayload) {
+            claimRequest = new ClaimRequest("value");
+        } else {
+            claimRequest = new ClaimRequest(null);
+        }
+
+        ClaimResponse claimResponse = doPostClaimAsync("/api/customer/device/" + deviceName + "/claim", claimRequest, ClaimResponse.class, status().isBadRequest());
+        assertEquals(claimResponse, ClaimResponse.FAILURE);
+
+        client.publish(MqttTopics.GATEWAY_CLAIM_TOPIC, new MqttMessage(payloadBytes));
+
+        Thread.sleep(2000);
+
+        ClaimResult claimResult = doPostClaimAsync("/api/customer/device/" + deviceName + "/claim", claimRequest, ClaimResult.class, status().isOk());
+        assertEquals(claimResult.getResponse(), ClaimResponse.SUCCESS);
+        Device claimedDevice = claimResult.getDevice();
+        assertNotNull(claimedDevice);
+        assertNotNull(claimedDevice.getCustomerId());
+        assertEquals(customerAdmin.getCustomerId(), claimedDevice.getCustomerId());
+
+        claimResponse = doPostClaimAsync("/api/customer/device/" + deviceName + "/claim", claimRequest, ClaimResponse.class, status().isBadRequest());
+        assertEquals(claimResponse, ClaimResponse.CLAIMED);
+    }
+
+    protected void processTestGatewayClaimingDevice(String deviceName, boolean emptyPayload) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        byte[] failurePayloadBytes;
+        byte[] payloadBytes;
+        String failurePayload;
+        String payload;
+        if (emptyPayload) {
+            failurePayload = "{\"" + deviceName + "\": " + "{\"durationMs\":1}" + "}";
+            payload = "{\"" + deviceName + "\": " + "{}" + "}";
+        } else {
+            failurePayload = "{\"" + deviceName + "\": " + "{\"secretKey\":\"value\", \"durationMs\":1}" + "}";
+            payload = "{\"" + deviceName + "\": " + "{\"secretKey\":\"value\", \"durationMs\":60000}" + "}";
+        }
+        payloadBytes = payload.getBytes();
+        failurePayloadBytes = failurePayload.getBytes();
+        validateGatewayClaimResponse(deviceName, emptyPayload, client, failurePayloadBytes, payloadBytes);
+    }
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.claim;
+
+import lombok.extern.slf4j.Slf4j;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+
+@Slf4j
+public abstract class AbstractMqttClaimJsonDeviceTest extends AbstractMqttClaimDeviceTest {
+    
+    @Before
+    public void beforeTest() throws Exception {
+        super.processBeforeTest("Test Claim device", "Test Claim gateway", TransportPayloadType.JSON, null, null);
+        createCustomerAndUser();
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        super.afterTest();
+    }
+
+    @Test
+    public void testClaimingDevice() throws Exception {
+        processTestClaimingDevice(false);
+    }
+
+    @Test
+    public void testClaimingDeviceWithoutSecretAndDuration() throws Exception {
+        processTestClaimingDevice(true);
+    }
+
+    @Test
+    public void testGatewayClaimingDevice() throws Exception {
+        processTestGatewayClaimingDevice("Test claiming gateway device Json", false);
+    }
+
+    @Test
+    public void testGatewayClaimingDeviceWithoutSecretAndDuration() throws Exception {
+        processTestGatewayClaimingDevice("Test claiming gateway device empty payload Json", true);
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.claim;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+
+@Slf4j
+public abstract class AbstractMqttClaimProtoDeviceTest extends AbstractMqttClaimDeviceTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Claim device", "Test Claim gateway", TransportPayloadType.PROTOBUF, null, null);
+        createCustomerAndUser();
+    }
+
+    @After
+    public void afterTest() throws Exception { super.afterTest(); }
+
+    @Test
+    public void testClaimingDevice() throws Exception {
+        processTestClaimingDevice(false);
+    }
+
+    @Test
+    public void testClaimingDeviceWithoutSecretAndDuration() throws Exception {
+        processTestClaimingDevice(true);
+    }
+
+    @Test
+    public void testGatewayClaimingDevice() throws Exception {
+        processTestGatewayClaimingDevice("Test claiming gateway device Proto", false);
+    }
+
+    @Test
+    public void testGatewayClaimingDeviceWithoutSecretAndDuration() throws Exception {
+        processTestGatewayClaimingDevice("Test claiming gateway device empty payload Proto", true);
+    }
+
+    protected void processTestClaimingDevice(boolean emptyPayload) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
+        byte[] payloadBytes;
+        if (emptyPayload) {
+            payloadBytes = getClaimDevice(0, emptyPayload).toByteArray();
+        } else {
+            payloadBytes = getClaimDevice(60000, emptyPayload).toByteArray();
+        }
+        byte[] failurePayloadBytes = getClaimDevice(1, emptyPayload).toByteArray();
+        validateClaimResponse(emptyPayload, client, payloadBytes, failurePayloadBytes);
+    }
+
+    protected void processTestGatewayClaimingDevice(String deviceName, boolean emptyPayload) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        byte[] failurePayloadBytes;
+        byte[] payloadBytes;
+        if (emptyPayload) {
+            payloadBytes = getGatewayClaimMsg(deviceName, 0, emptyPayload).toByteArray();
+        } else {
+            payloadBytes = getGatewayClaimMsg(deviceName, 60000, emptyPayload).toByteArray();
+        }
+        failurePayloadBytes = getGatewayClaimMsg(deviceName, 1, emptyPayload).toByteArray();
+
+        validateGatewayClaimResponse(deviceName, emptyPayload, client, failurePayloadBytes, payloadBytes);
+    }
+
+    private TransportApiProtos.GatewayClaimMsg getGatewayClaimMsg(String deviceName, long duration, boolean emptyPayload) {
+        TransportApiProtos.GatewayClaimMsg.Builder gatewayClaimMsgBuilder = TransportApiProtos.GatewayClaimMsg.newBuilder();
+        TransportApiProtos.ClaimDeviceMsg.Builder claimDeviceMsgBuilder = TransportApiProtos.ClaimDeviceMsg.newBuilder();
+        TransportApiProtos.ClaimDevice.Builder claimDeviceBuilder = TransportApiProtos.ClaimDevice.newBuilder();
+        if (!emptyPayload) {
+            claimDeviceBuilder.setSecretKey("value");
+        }
+        if (duration > 0) {
+            claimDeviceBuilder.setDurationMs(duration);
+        }
+        TransportApiProtos.ClaimDevice claimDevice = claimDeviceBuilder.build();
+        claimDeviceMsgBuilder.setClaimRequest(claimDevice);
+        claimDeviceMsgBuilder.setDeviceName(deviceName);
+        TransportApiProtos.ClaimDeviceMsg claimDeviceMsg = claimDeviceMsgBuilder.build();
+        gatewayClaimMsgBuilder.addMsg(claimDeviceMsg);
+        return gatewayClaimMsgBuilder.build();
+    }
+
+    private TransportApiProtos.ClaimDevice getClaimDevice(long duration, boolean emptyPayload) {
+        TransportApiProtos.ClaimDevice.Builder claimDeviceBuilder = TransportApiProtos.ClaimDevice.newBuilder();
+        if (!emptyPayload) {
+            claimDeviceBuilder.setSecretKey("value");
+        }
+        if (duration > 0) {
+            claimDeviceBuilder.setSecretKey("value");
+            claimDeviceBuilder.setDurationMs(duration);
+        }
+        return claimDeviceBuilder.build();
+    }
+
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.claim.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.claim.AbstractMqttClaimDeviceTest;
+
+
+@DaoNoSqlTest
+public class MqttClaimDeviceNoSqlTest extends AbstractMqttClaimDeviceTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.claim.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.claim.AbstractMqttClaimDeviceTest;
+import org.thingsboard.server.mqtt.claim.AbstractMqttClaimJsonDeviceTest;
+
+@DaoSqlTest
+public class MqttClaimDeviceJsonSqlTest extends AbstractMqttClaimJsonDeviceTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.claim.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.claim.AbstractMqttClaimJsonDeviceTest;
+import org.thingsboard.server.mqtt.claim.AbstractMqttClaimProtoDeviceTest;
+
+@DaoSqlTest
+public class MqttClaimDeviceProtoSqlTest extends AbstractMqttClaimProtoDeviceTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.claim.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.claim.AbstractMqttClaimDeviceTest;
+
+@DaoSqlTest
+public class MqttClaimDeviceSqlTest extends AbstractMqttClaimDeviceTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.rpc;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.nimbusds.jose.util.StandardCharset;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
+import io.netty.handler.codec.mqtt.MqttQoS;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttCallback;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceProfileType;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.Tenant;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.device.profile.DefaultDeviceProfileConfiguration;
+import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
+import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.data.security.Authority;
+import org.thingsboard.server.common.data.security.DeviceCredentials;
+import org.thingsboard.server.controller.AbstractControllerTest;
+import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.server.service.security.AccessValidator;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+/**
+ * @author Valerii Sosliuk
+ */
+@Slf4j
+public abstract class AbstractMqttServerSideRpcDefaultIntegrationTest extends AbstractMqttServerSideRpcIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("RPC test device", "RPC test gateway", null, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        super.processAfterTest();
+    }
+
+    @Test
+    public void testServerMqttOneWayRpcDeviceOffline() throws Exception {
+        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"24\",\"value\": 1},\"timeout\": 6000}";
+        String deviceId = savedDevice.getId().getId().toString();
+
+        doPostAsync("/api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class, status().is(409),
+                asyncContextTimeoutToUseRpcPlugin);
+    }
+
+    @Test
+    public void testServerMqttOneWayRpcDeviceDoesNotExist() throws Exception {
+        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"25\",\"value\": 1}}";
+        String nonExistentDeviceId = Uuids.timeBased().toString();
+
+        String result = doPostAsync("/api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class,
+                status().isNotFound());
+        Assert.assertEquals(AccessValidator.DEVICE_WITH_REQUESTED_ID_NOT_FOUND, result);
+    }
+
+    @Test
+    public void testServerMqttTwoWayRpcDeviceOffline() throws Exception {
+        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"27\",\"value\": 1},\"timeout\": 6000}";
+        String deviceId = savedDevice.getId().getId().toString();
+
+        doPostAsync("/api/plugins/rpc/twoway/" + deviceId, setGpioRequest, String.class, status().is(409),
+                asyncContextTimeoutToUseRpcPlugin);
+    }
+
+    @Test
+    public void testServerMqttTwoWayRpcDeviceDoesNotExist() throws Exception {
+        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"28\",\"value\": 1}}";
+        String nonExistentDeviceId = Uuids.timeBased().toString();
+
+        String result = doPostAsync("/api/plugins/rpc/twoway/" + nonExistentDeviceId, setGpioRequest, String.class,
+                status().isNotFound());
+        Assert.assertEquals(AccessValidator.DEVICE_WITH_REQUESTED_ID_NOT_FOUND, result);
+    }
+
+    @Test
+    public void testServerMqttOneWayRpc() throws Exception {
+        processOneWayRpcTest();
+    }
+
+    @Test
+    public void testServerMqttTwoWayRpc() throws Exception {
+        processTwoWayRpcTest();
+    }
+
+    @Test
+    public void testGatewayServerMqttOneWayRpc() throws Exception {
+        processOneWayRpcTestGateway("Gateway Device OneWay RPC");
+    }
+
+    @Test
+    public void testGatewayServerMqttTwoWayRpc() throws Exception {
+        processTwoWayRpcTestGateway("Gateway Device TwoWay RPC");
+    }
+
+}

@@ -16,6 +16,10 @@
 package org.thingsboard.server.mqtt.rpc;
 package org.thingsboard.server.mqtt.rpc;
 
 
 import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.datastax.oss.driver.api.core.uuid.Uuids;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.nimbusds.jose.util.StandardCharset;
 import io.netty.handler.codec.mqtt.MqttQoS;
 import io.netty.handler.codec.mqtt.MqttQoS;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -23,15 +27,28 @@ import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
 import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
 import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
 import org.eclipse.paho.client.mqttv3.MqttCallback;
 import org.eclipse.paho.client.mqttv3.MqttCallback;
 import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
 import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttException;
 import org.eclipse.paho.client.mqttv3.MqttMessage;
 import org.eclipse.paho.client.mqttv3.MqttMessage;
-import org.junit.*;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceProfileType;
+import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.Tenant;
+import org.thingsboard.server.common.data.TransportPayloadType;
 import org.thingsboard.server.common.data.User;
 import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.device.profile.DefaultDeviceProfileConfiguration;
+import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
+import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
 import org.thingsboard.server.common.data.security.Authority;
 import org.thingsboard.server.common.data.security.Authority;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.controller.AbstractControllerTest;
 import org.thingsboard.server.controller.AbstractControllerTest;
-import org.thingsboard.server.mqtt.telemetry.AbstractMqttTelemetryIntegrationTest;
+import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
 import org.thingsboard.server.service.security.AccessValidator;
 import org.thingsboard.server.service.security.AccessValidator;
 
 
 import java.util.Arrays;
 import java.util.Arrays;
@@ -47,74 +64,88 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
  * @author Valerii Sosliuk
  * @author Valerii Sosliuk
  */
  */
 @Slf4j
 @Slf4j
-public abstract class AbstractMqttServerSideRpcIntegrationTest extends AbstractControllerTest {
+public abstract class AbstractMqttServerSideRpcIntegrationTest extends AbstractMqttIntegrationTest {
 
 
-    private static final String MQTT_URL = "tcp://localhost:1883";
-    private static final Long TIME_TO_HANDLE_REQUEST = 500L;
+    protected static final String DEVICE_RESPONSE = "{\"value1\":\"A\",\"value2\":\"B\"}";
 
 
-    private Tenant savedTenant;
-    private User tenantAdmin;
-    private Long asyncContextTimeoutToUseRpcPlugin;
+    protected Long asyncContextTimeoutToUseRpcPlugin;
 
 
-    private static final AtomicInteger atomicInteger = new AtomicInteger(2);
+    protected void processBeforeTest(String deviceName, String gatewayName, TransportPayloadType payloadType, String telemetryTopic, String attributesTopic) throws Exception {
+        super.processBeforeTest(deviceName, gatewayName, payloadType, telemetryTopic, attributesTopic);
+        asyncContextTimeoutToUseRpcPlugin = 10000L;
+    }
 
 
+    protected void processOneWayRpcTest() throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
 
 
-    @Before
-    public void beforeTest() throws Exception {
-        loginSysAdmin();
+        CountDownLatch latch = new CountDownLatch(1);
+        TestMqttCallback callback = new TestMqttCallback(client, latch);
+        client.setCallback(callback);
 
 
-        asyncContextTimeoutToUseRpcPlugin = 10000L;
+        client.subscribe(MqttTopics.DEVICE_RPC_REQUESTS_SUB_TOPIC, MqttQoS.AT_MOST_ONCE.value());
 
 
-        Tenant tenant = new Tenant();
-        tenant.setTitle("My tenant");
-        savedTenant = doPost("/api/tenant", tenant, Tenant.class);
-        Assert.assertNotNull(savedTenant);
+        Thread.sleep(2000);
 
 
-        tenantAdmin = new User();
-        tenantAdmin.setAuthority(Authority.TENANT_ADMIN);
-        tenantAdmin.setTenantId(savedTenant.getId());
-        tenantAdmin.setEmail("tenant" + atomicInteger.getAndIncrement() + "@thingsboard.org");
-        tenantAdmin.setFirstName("Joe");
-        tenantAdmin.setLastName("Downs");
+        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"23\",\"value\": 1}}";
+        String deviceId = savedDevice.getId().getId().toString();
+        String result = doPostAsync("/api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class, status().isOk());
+        Assert.assertTrue(StringUtils.isEmpty(result));
+        latch.await(3, TimeUnit.SECONDS);
+        assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
+    }
 
 
-        createUserAndLogin(tenantAdmin, "testPassword1");
+    protected void processOneWayRpcTestGateway(String deviceName) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        String payload = "{\"device\":\"" + deviceName + "\"}";
+        byte[] payloadBytes = payload.getBytes();
+        validateOneWayRpcGatewayResponse(deviceName, client, payloadBytes);
     }
     }
 
 
-    @After
-    public void afterTest() throws Exception {
-        loginSysAdmin();
-        if (savedTenant != null) {
-            doDelete("/api/tenant/" + savedTenant.getId().getId().toString()).andExpect(status().isOk());
-        }
+    protected void processTwoWayRpcTest() throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
+        client.subscribe(MqttTopics.DEVICE_RPC_REQUESTS_SUB_TOPIC, 1);
+
+        CountDownLatch latch = new CountDownLatch(1);
+        TestMqttCallback callback = new TestMqttCallback(client, latch);
+        client.setCallback(callback);
+
+        Thread.sleep(2000);
+
+        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"26\",\"value\": 1}}";
+        String deviceId = savedDevice.getId().getId().toString();
+
+        String result = doPostAsync("/api/plugins/rpc/twoway/" + deviceId, setGpioRequest, String.class, status().isOk());
+        String expected = "{\"value1\":\"A\",\"value2\":\"B\"}";
+        latch.await(3, TimeUnit.SECONDS);
+        Assert.assertEquals(expected, result);
     }
     }
 
 
-    @Test
-    public void testServerMqttOneWayRpc() throws Exception {
-        Device device = new Device();
-        device.setName("Test One-Way Server-Side RPC");
-        device.setType("default");
-        Device savedDevice = getSavedDevice(device);
-        DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
-        assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
-        String accessToken = deviceCredentials.getCredentialsId();
-        assertNotNull(accessToken);
+    protected void processTwoWayRpcTestGateway(String deviceName) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+
+        String payload = "{\"device\":\"" + deviceName + "\"}";
+        byte[] payloadBytes = payload.getBytes();
 
 
-        String clientId = MqttAsyncClient.generateClientId();
-        MqttAsyncClient client = new MqttAsyncClient(MQTT_URL, clientId);
+        validateTwoWayRpcGateway(deviceName, client, payloadBytes);
+    }
 
 
-        MqttConnectOptions options = new MqttConnectOptions();
-        options.setUserName(accessToken);
-        client.connect(options).waitForCompletion();
+    protected void validateOneWayRpcGatewayResponse(String deviceName, MqttAsyncClient client, byte[] payloadBytes) throws Exception {
+        publishMqttMsg(client, payloadBytes, MqttTopics.GATEWAY_CONNECT_TOPIC);
+
+        Thread.sleep(2000);
+
+        Device savedDevice = getDeviceByName(deviceName);
+        assertNotNull(savedDevice);
 
 
         CountDownLatch latch = new CountDownLatch(1);
         CountDownLatch latch = new CountDownLatch(1);
         TestMqttCallback callback = new TestMqttCallback(client, latch);
         TestMqttCallback callback = new TestMqttCallback(client, latch);
         client.setCallback(callback);
         client.setCallback(callback);
 
 
-        client.subscribe("v1/devices/me/rpc/request/+", MqttQoS.AT_MOST_ONCE.value());
+        client.subscribe(MqttTopics.GATEWAY_RPC_TOPIC, MqttQoS.AT_MOST_ONCE.value());
 
 
         Thread.sleep(2000);
         Thread.sleep(2000);
 
 
-        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"23\",\"value\": 1}}";
+        String setGpioRequest = "{\"method\": \"toggle_gpio\", \"params\": {\"pin\":1}}";
         String deviceId = savedDevice.getId().getId().toString();
         String deviceId = savedDevice.getId().getId().toString();
         String result = doPostAsync("/api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class, status().isOk());
         String result = doPostAsync("/api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class, status().isOk());
         Assert.assertTrue(StringUtils.isEmpty(result));
         Assert.assertTrue(StringUtils.isEmpty(result));
@@ -122,100 +153,49 @@ public abstract class AbstractMqttServerSideRpcIntegrationTest extends AbstractC
         assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
         assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
     }
     }
 
 
-    @Test
-    public void testServerMqttOneWayRpcDeviceOffline() throws Exception {
-        Device device = new Device();
-        device.setName("Test One-Way Server-Side RPC Device Offline");
-        device.setType("default");
-        Device savedDevice = getSavedDevice(device);
-        DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
-        assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
-        String accessToken = deviceCredentials.getCredentialsId();
-        assertNotNull(accessToken);
-
-        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"24\",\"value\": 1},\"timeout\": 6000}";
-        String deviceId = savedDevice.getId().getId().toString();
+    protected void validateTwoWayRpcGateway(String deviceName, MqttAsyncClient client, byte[] payloadBytes) throws Exception {
+        publishMqttMsg(client, payloadBytes, MqttTopics.GATEWAY_CONNECT_TOPIC);
 
 
-        doPostAsync("/api/plugins/rpc/oneway/" + deviceId, setGpioRequest, String.class, status().is(409),
-                asyncContextTimeoutToUseRpcPlugin);
-    }
+        Thread.sleep(2000);
 
 
-    @Test
-    public void testServerMqttOneWayRpcDeviceDoesNotExist() throws Exception {
-        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"25\",\"value\": 1}}";
-        String nonExistentDeviceId = Uuids.timeBased().toString();
+        Device savedDevice = getDeviceByName(deviceName);
+        assertNotNull(savedDevice);
 
 
-        String result = doPostAsync("/api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class,
-                status().isNotFound());
-        Assert.assertEquals(AccessValidator.DEVICE_WITH_REQUESTED_ID_NOT_FOUND, result);
-    }
+        CountDownLatch latch = new CountDownLatch(1);
+        TestMqttCallback callback = new TestMqttCallback(client, latch);
+        client.setCallback(callback);
 
 
-    @Test
-    public void testServerMqttTwoWayRpc() throws Exception {
-        Device device = new Device();
-        device.setName("Test Two-Way Server-Side RPC");
-        device.setType("default");
-        Device savedDevice = getSavedDevice(device);
-        DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
-        assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
-        String accessToken = deviceCredentials.getCredentialsId();
-        assertNotNull(accessToken);
-
-        String clientId = MqttAsyncClient.generateClientId();
-        MqttAsyncClient client = new MqttAsyncClient(MQTT_URL, clientId);
-
-        MqttConnectOptions options = new MqttConnectOptions();
-        options.setUserName(accessToken);
-        client.connect(options).waitForCompletion();
-        client.subscribe("v1/devices/me/rpc/request/+", 1);
-        client.setCallback(new TestMqttCallback(client, new CountDownLatch(1)));
+        client.subscribe(MqttTopics.GATEWAY_RPC_TOPIC, MqttQoS.AT_MOST_ONCE.value());
 
 
         Thread.sleep(2000);
         Thread.sleep(2000);
 
 
-        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"26\",\"value\": 1}}";
+        String setGpioRequest = "{\"method\": \"toggle_gpio\", \"params\": {\"pin\":1}}";
         String deviceId = savedDevice.getId().getId().toString();
         String deviceId = savedDevice.getId().getId().toString();
-
         String result = doPostAsync("/api/plugins/rpc/twoway/" + deviceId, setGpioRequest, String.class, status().isOk());
         String result = doPostAsync("/api/plugins/rpc/twoway/" + deviceId, setGpioRequest, String.class, status().isOk());
-        Assert.assertEquals("{\"value1\":\"A\",\"value2\":\"B\"}", result);
-    }
-
-    @Test
-    public void testServerMqttTwoWayRpcDeviceOffline() throws Exception {
-        Device device = new Device();
-        device.setName("Test Two-Way Server-Side RPC Device Offline");
-        device.setType("default");
-        Device savedDevice = getSavedDevice(device);
-        DeviceCredentials deviceCredentials = getDeviceCredentials(savedDevice);
-        assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
-        String accessToken = deviceCredentials.getCredentialsId();
-        assertNotNull(accessToken);
-
-        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"27\",\"value\": 1},\"timeout\": 6000}";
-        String deviceId = savedDevice.getId().getId().toString();
-
-        doPostAsync("/api/plugins/rpc/twoway/" + deviceId, setGpioRequest, String.class, status().is(409),
-                asyncContextTimeoutToUseRpcPlugin);
-    }
-
-    @Test
-    public void testServerMqttTwoWayRpcDeviceDoesNotExist() throws Exception {
-        String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"28\",\"value\": 1}}";
-        String nonExistentDeviceId = Uuids.timeBased().toString();
-
-        String result = doPostAsync("/api/plugins/rpc/twoway/" + nonExistentDeviceId, setGpioRequest, String.class,
-                status().isNotFound());
-        Assert.assertEquals(AccessValidator.DEVICE_WITH_REQUESTED_ID_NOT_FOUND, result);
+        latch.await(3, TimeUnit.SECONDS);
+        String expected = "{\"success\":true}";
+        assertEquals(expected, result);
+        assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
     }
     }
 
 
-    private Device getSavedDevice(Device device) throws Exception {
-        return doPost("/api/device", device, Device.class);
+    private Device getDeviceByName(String deviceName) throws Exception {
+        return doGet("/api/tenant/devices?deviceName=" + deviceName, Device.class);
     }
     }
 
 
-    private DeviceCredentials getDeviceCredentials(Device savedDevice) throws Exception {
-        return doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
+    protected MqttMessage processMessageArrived(String requestTopic, MqttMessage mqttMessage) throws MqttException, InvalidProtocolBufferException {
+        MqttMessage message = new MqttMessage();
+        if (requestTopic.startsWith(MqttTopics.BASE_DEVICE_API_TOPIC)) {
+            message.setPayload(DEVICE_RESPONSE.getBytes(StandardCharset.UTF_8));
+        } else {
+            JsonNode requestMsgNode = JacksonUtil.toJsonNode(new String(mqttMessage.getPayload(), StandardCharset.UTF_8));
+            String deviceName = requestMsgNode.get("device").asText();
+            int requestId = requestMsgNode.get("data").get("id").asInt();
+            message.setPayload(("{\"device\": \"" + deviceName + "\", \"id\": " + requestId + ", \"data\": {\"success\": true}}").getBytes(StandardCharset.UTF_8));
+        }
+        return message;
     }
     }
 
 
-    private static class TestMqttCallback implements MqttCallback {
+    private class TestMqttCallback implements MqttCallback {
 
 
         private final MqttAsyncClient client;
         private final MqttAsyncClient client;
         private final CountDownLatch latch;
         private final CountDownLatch latch;
@@ -237,11 +217,9 @@ public abstract class AbstractMqttServerSideRpcIntegrationTest extends AbstractC
         @Override
         @Override
         public void messageArrived(String requestTopic, MqttMessage mqttMessage) throws Exception {
         public void messageArrived(String requestTopic, MqttMessage mqttMessage) throws Exception {
             log.info("Message Arrived: " + Arrays.toString(mqttMessage.getPayload()));
             log.info("Message Arrived: " + Arrays.toString(mqttMessage.getPayload()));
-            MqttMessage message = new MqttMessage();
             String responseTopic = requestTopic.replace("request", "response");
             String responseTopic = requestTopic.replace("request", "response");
-            message.setPayload("{\"value1\":\"A\", \"value2\":\"B\"}".getBytes("UTF-8"));
             qoS = mqttMessage.getQos();
             qoS = mqttMessage.getQos();
-            client.publish(responseTopic, message);
+            client.publish(responseTopic, processMessageArrived(requestTopic, mqttMessage));
             latch.countDown();
             latch.countDown();
         }
         }
 
 

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.rpc;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+
+@Slf4j
+public abstract class AbstractMqttServerSideRpcJsonIntegrationTest extends AbstractMqttServerSideRpcIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("RPC test device", "RPC test gateway", TransportPayloadType.JSON, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        super.processAfterTest();
+    }
+
+    @Test
+    public void testServerMqttOneWayRpc() throws Exception {
+        processOneWayRpcTest();
+    }
+
+    @Test
+    public void testServerMqttTwoWayRpc() throws Exception {
+        processTwoWayRpcTest();
+    }
+
+    @Test
+    public void testGatewayServerMqttOneWayRpc() throws Exception {
+        processOneWayRpcTestGateway("Gateway Device OneWay RPC Json");
+    }
+
+    @Test
+    public void testGatewayServerMqttTwoWayRpc() throws Exception {
+        processTwoWayRpcTestGateway("Gateway Device TwoWay RPC Json");
+    }
+
+    protected void processOneWayRpcTestGateway(String deviceName) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        String payload = "{\"device\": \"" + deviceName + "\", \"type\": \"" + TransportPayloadType.JSON.name() + "\"}";
+        byte[] payloadBytes = payload.getBytes();
+        validateOneWayRpcGatewayResponse(deviceName, client, payloadBytes);
+    }
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.rpc;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@Slf4j
+public abstract class AbstractMqttServerSideRpcProtoIntegrationTest extends AbstractMqttServerSideRpcIntegrationTest {
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("RPC test device", "RPC test gateway", TransportPayloadType.PROTOBUF, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        super.processAfterTest();
+    }
+
+    @Test
+    public void testServerMqttOneWayRpc() throws Exception {
+        processOneWayRpcTest();
+    }
+
+    @Test
+    public void testServerMqttTwoWayRpc() throws Exception {
+        processTwoWayRpcTest();
+    }
+
+    @Test
+    public void testGatewayServerMqttOneWayRpc() throws Exception {
+        processOneWayRpcTestGateway("Gateway Device OneWay RPC Proto");
+    }
+
+    @Test
+    public void testGatewayServerMqttTwoWayRpc() throws Exception {
+        processTwoWayRpcTestGateway("Gateway Device TwoWay RPC Proto");
+    }
+
+    protected void processTwoWayRpcTestGateway(String deviceName) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        TransportApiProtos.ConnectMsg connectMsgProto = getConnectProto(deviceName);
+        byte[] payloadBytes = connectMsgProto.toByteArray();
+        validateTwoWayRpcGateway(deviceName, client, payloadBytes);
+    }
+
+    protected void processOneWayRpcTestGateway(String deviceName) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        TransportApiProtos.ConnectMsg connectMsgProto = getConnectProto(deviceName);
+        byte[] payloadBytes = connectMsgProto.toByteArray();
+        validateOneWayRpcGatewayResponse(deviceName, client, payloadBytes);
+    }
+
+
+    private TransportApiProtos.ConnectMsg getConnectProto(String deviceName) {
+        TransportApiProtos.ConnectMsg.Builder builder = TransportApiProtos.ConnectMsg.newBuilder();
+        builder.setDeviceName(deviceName);
+        builder.setDeviceType(TransportPayloadType.PROTOBUF.name());
+        return builder.build();
+    }
+
+    protected MqttMessage processMessageArrived(String requestTopic, MqttMessage mqttMessage) throws MqttException, InvalidProtocolBufferException {
+        MqttMessage message = new MqttMessage();
+        if (requestTopic.startsWith(MqttTopics.BASE_DEVICE_API_TOPIC)) {
+                TransportProtos.ToDeviceRpcResponseMsg toDeviceRpcResponseMsg = TransportProtos.ToDeviceRpcResponseMsg.newBuilder()
+                        .setPayload(DEVICE_RESPONSE)
+                        .setRequestId(0)
+                        .build();
+                message.setPayload(toDeviceRpcResponseMsg.toByteArray());
+        } else {
+            TransportApiProtos.GatewayDeviceRpcRequestMsg msg = TransportApiProtos.GatewayDeviceRpcRequestMsg.parseFrom(mqttMessage.getPayload());
+            String deviceName = msg.getDeviceName();
+            int requestId = msg.getRpcRequestMsg().getRequestId();
+            TransportApiProtos.GatewayRpcResponseMsg gatewayRpcResponseMsg = TransportApiProtos.GatewayRpcResponseMsg.newBuilder()
+                    .setDeviceName(deviceName)
+                    .setId(requestId)
+                    .setData("{\"success\": true}")
+                    .build();
+            message.setPayload(gatewayRpcResponseMsg.toByteArray());
+        }
+        return message;
+    }
+
+
+
+}

@@ -16,11 +16,11 @@
 package org.thingsboard.server.mqtt.rpc.nosql;
 package org.thingsboard.server.mqtt.rpc.nosql;
 
 
 import org.thingsboard.server.dao.service.DaoNoSqlTest;
 import org.thingsboard.server.dao.service.DaoNoSqlTest;
-import org.thingsboard.server.mqtt.rpc.AbstractMqttServerSideRpcIntegrationTest;
+import org.thingsboard.server.mqtt.rpc.AbstractMqttServerSideRpcDefaultIntegrationTest;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 8/22/2017.
  * Created by Valerii Sosliuk on 8/22/2017.
  */
  */
 @DaoNoSqlTest
 @DaoNoSqlTest
-public class MqttServerSideRpcNoSqlIntegrationTest extends AbstractMqttServerSideRpcIntegrationTest {
+public class MqttServerSideRpcNoSqlIntegrationTest extends AbstractMqttServerSideRpcDefaultIntegrationTest {
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.rpc.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.rpc.AbstractMqttServerSideRpcJsonIntegrationTest;
+
+@DaoSqlTest
+public class MqttServerSideRpcJsonSqlIntegrationTest extends AbstractMqttServerSideRpcJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.rpc.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.rpc.AbstractMqttServerSideRpcProtoIntegrationTest;
+
+
+@DaoSqlTest
+public class MqttServerSideRpcProtoSqlIntegrationTest extends AbstractMqttServerSideRpcProtoIntegrationTest {
+}

@@ -16,11 +16,11 @@
 package org.thingsboard.server.mqtt.rpc.sql;
 package org.thingsboard.server.mqtt.rpc.sql;
 
 
 import org.thingsboard.server.dao.service.DaoSqlTest;
 import org.thingsboard.server.dao.service.DaoSqlTest;
-import org.thingsboard.server.mqtt.rpc.AbstractMqttServerSideRpcIntegrationTest;
+import org.thingsboard.server.mqtt.rpc.AbstractMqttServerSideRpcDefaultIntegrationTest;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 8/22/2017.
  * Created by Valerii Sosliuk on 8/22/2017.
  */
  */
 @DaoSqlTest
 @DaoSqlTest
-public class MqttServerSideRpcSqlIntegrationTest extends AbstractMqttServerSideRpcIntegrationTest {
+public class MqttServerSideRpcSqlIntegrationTest extends AbstractMqttServerSideRpcDefaultIntegrationTest {
 }
 }

-/**
- * Copyright © 2016-2020 The Thingsboard Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.thingsboard.server.mqtt.telemetry;
-
-import io.netty.handler.codec.mqtt.MqttQoS;
-import lombok.extern.slf4j.Slf4j;
-import org.eclipse.paho.client.mqttv3.*;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.springframework.web.util.UriComponentsBuilder;
-import org.thingsboard.server.common.data.Device;
-import org.thingsboard.server.common.data.security.DeviceCredentials;
-import org.thingsboard.server.controller.AbstractControllerTest;
-import org.thingsboard.server.dao.service.DaoNoSqlTest;
-
-import java.net.URI;
-import java.util.*;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
-
-/**
- * @author Valerii Sosliuk
- */
-@Slf4j
-public abstract class AbstractMqttTelemetryIntegrationTest extends AbstractControllerTest {
-
-    private static final String MQTT_URL = "tcp://localhost:1883";
-
-    private Device savedDevice;
-    private String accessToken;
-
-    @Before
-    public void beforeTest() throws Exception {
-        loginTenantAdmin();
-
-        Device device = new Device();
-        device.setName("Test device");
-        device.setType("default");
-        savedDevice = doPost("/api/device", device, Device.class);
-
-        DeviceCredentials deviceCredentials =
-                doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
-
-        assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
-        accessToken = deviceCredentials.getCredentialsId();
-        assertNotNull(accessToken);
-    }
-
-    @Test
-    public void testPushMqttRpcData() throws Exception {
-        String clientId = MqttAsyncClient.generateClientId();
-        MqttAsyncClient client = new MqttAsyncClient(MQTT_URL, clientId);
-
-        MqttConnectOptions options = new MqttConnectOptions();
-        options.setUserName(accessToken);
-        client.connect(options);
-        Thread.sleep(3000);
-        MqttMessage message = new MqttMessage();
-        message.setPayload("{\"key1\":\"value1\", \"key2\":true, \"key3\": 3.0, \"key4\": 4}".getBytes());
-        client.publish("v1/devices/me/telemetry", message);
-
-        String deviceId = savedDevice.getId().getId().toString();
-
-        Thread.sleep(2000);
-        List<String> actualKeys = doGetAsync("/api/plugins/telemetry/DEVICE/" + deviceId + "/keys/timeseries", List.class);
-        Set<String> actualKeySet = new HashSet<>(actualKeys);
-
-        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4");
-        Set<String> expectedKeySet = new HashSet<>(expectedKeys);
-
-        assertEquals(expectedKeySet, actualKeySet);
-
-        String getTelemetryValuesUrl = "/api/plugins/telemetry/DEVICE/" + deviceId + "/values/timeseries?keys=" + String.join(",", actualKeySet);
-        Map<String, List<Map<String, String>>> values = doGetAsync(getTelemetryValuesUrl, Map.class);
-
-        assertEquals("value1", values.get("key1").get(0).get("value"));
-        assertEquals("true", values.get("key2").get(0).get("value"));
-        assertEquals("3.0", values.get("key3").get(0).get("value"));
-        assertEquals("4", values.get("key4").get(0).get("value"));
-    }
-
-
-//    @Test - Unstable
-    public void testMqttQoSLevel() throws Exception {
-        String clientId = MqttAsyncClient.generateClientId();
-        MqttAsyncClient client = new MqttAsyncClient(MQTT_URL, clientId);
-
-        MqttConnectOptions options = new MqttConnectOptions();
-        options.setUserName(accessToken);
-        CountDownLatch latch = new CountDownLatch(1);
-        TestMqttCallback callback = new TestMqttCallback(client, latch);
-        client.setCallback(callback);
-        client.connect(options).waitForCompletion(5000);
-        client.subscribe("v1/devices/me/attributes", MqttQoS.AT_MOST_ONCE.value());
-        String payload = "{\"key\":\"uniqueValue\"}";
-//        TODO 3.1: we need to acknowledge subscription only after it is processed by device actor and not when the message is pushed to queue.
-//        MqttClient -> SUB REQUEST -> Transport -> Kafka -> Device Actor (subscribed)
-//        MqttClient <- SUB_ACK <- Transport
-        Thread.sleep(5000);
-        doPostAsync("/api/plugins/telemetry/" + savedDevice.getId() + "/SHARED_SCOPE", payload, String.class, status().isOk());
-        latch.await(10, TimeUnit.SECONDS);
-        assertEquals(payload, callback.getPayload());
-        assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
-    }
-
-    private static class TestMqttCallback implements MqttCallback {
-
-        private final MqttAsyncClient client;
-        private final CountDownLatch latch;
-        private volatile Integer qoS;
-        private volatile String payload;
-
-        String getPayload() {
-            return payload;
-        }
-
-        TestMqttCallback(MqttAsyncClient client, CountDownLatch latch) {
-            this.client = client;
-            this.latch = latch;
-        }
-
-        int getQoS() {
-            return qoS;
-        }
-
-        @Override
-        public void connectionLost(Throwable throwable) {
-            log.error("Client connection lost", throwable);
-        }
-
-        @Override
-        public void messageArrived(String requestTopic, MqttMessage mqttMessage) {
-            payload = new String(mqttMessage.getPayload());
-            qoS = mqttMessage.getQos();
-            latch.countDown();
-        }
-
-        @Override
-        public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
-
-        }
-    }
-
-
-}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+@Slf4j
+public abstract class AbstractMqttAttributesIntegrationTest extends AbstractMqttIntegrationTest {
+
+    protected static final String PAYLOAD_VALUES_STR = "{\"key1\":\"value1\", \"key2\":true, \"key3\": 3.0, \"key4\": 4," +
+            " \"key5\": {\"someNumber\": 42, \"someArray\": [1,2,3], \"someNestedObject\": {\"key\": \"value\"}}}";
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Post Attributes device", "Test Post Attributes gateway", null, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testPushMqttAttributes() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        processAttributesTest(MqttTopics.DEVICE_ATTRIBUTES_TOPIC, expectedKeys, PAYLOAD_VALUES_STR.getBytes());
+    }
+
+    @Test
+    public void testPushMqttAttributesGateway() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        String deviceName1 = "Device A";
+        String deviceName2 = "Device B";
+        String payload = getGatewayAttributesJsonPayload(deviceName1, deviceName2);
+        processGatewayAttributesTest(expectedKeys, payload.getBytes(), deviceName1, deviceName2);
+    }
+
+    protected void processAttributesTest(String topic, List<String> expectedKeys, byte[] payload) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
+
+        publishMqttMsg(client, payload, topic);
+
+        DeviceId deviceId = savedDevice.getId();
+
+        long start = System.currentTimeMillis();
+        long end = System.currentTimeMillis() + 2000;
+
+        List<String> actualKeys = null;
+        while (start <= end) {
+            actualKeys = doGetAsync("/api/plugins/telemetry/DEVICE/" + deviceId + "/keys/attributes/CLIENT_SCOPE", List.class);
+            if (actualKeys.size() == expectedKeys.size()) {
+                break;
+            }
+            Thread.sleep(100);
+            start += 100;
+        }
+        assertNotNull(actualKeys);
+
+        Set<String> actualKeySet = new HashSet<>(actualKeys);
+
+        Set<String> expectedKeySet = new HashSet<>(expectedKeys);
+
+        assertEquals(expectedKeySet, actualKeySet);
+
+        String getAttributesValuesUrl = getAttributesValuesUrl(deviceId, actualKeySet);
+        List<Map<String, Object>> values = doGetAsync(getAttributesValuesUrl, List.class);
+        assertAttributesValues(values, expectedKeySet);
+        String deleteAttributesUrl = "/api/plugins/telemetry/DEVICE/" + deviceId + "/CLIENT_SCOPE?keys=" + String.join(",", actualKeySet);
+        doDelete(deleteAttributesUrl);
+    }
+
+    protected void processGatewayAttributesTest(List<String> expectedKeys, byte[] payload, String firstDeviceName, String secondDeviceName) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+
+        publishMqttMsg(client, payload, MqttTopics.GATEWAY_ATTRIBUTES_TOPIC);
+
+        Thread.sleep(2000);
+
+        Device firstDevice = doGet("/api/tenant/devices?deviceName=" + firstDeviceName, Device.class);
+        assertNotNull(firstDevice);
+        Device secondDevice = doGet("/api/tenant/devices?deviceName=" + secondDeviceName, Device.class);
+        assertNotNull(secondDevice);
+
+        List<String> firstDeviceActualKeys = doGetAsync("/api/plugins/telemetry/DEVICE/" + firstDevice.getId() + "/keys/attributes/CLIENT_SCOPE", List.class);
+        Set<String> firstDeviceActualKeySet = new HashSet<>(firstDeviceActualKeys);
+
+        List<String> secondDeviceActualKeys = doGetAsync("/api/plugins/telemetry/DEVICE/" + secondDevice.getId() + "/keys/attributes/CLIENT_SCOPE", List.class);
+        Set<String> secondDeviceActualKeySet = new HashSet<>(secondDeviceActualKeys);
+
+        Set<String> expectedKeySet = new HashSet<>(expectedKeys);
+
+        assertEquals(expectedKeySet, firstDeviceActualKeySet);
+        assertEquals(expectedKeySet, secondDeviceActualKeySet);
+
+        String getAttributesValuesUrlFirstDevice = getAttributesValuesUrl(firstDevice.getId(), firstDeviceActualKeySet);
+        String getAttributesValuesUrlSecondDevice = getAttributesValuesUrl(firstDevice.getId(), secondDeviceActualKeySet);
+
+        List<Map<String, Object>> firstDeviceValues = doGetAsync(getAttributesValuesUrlFirstDevice, List.class);
+        List<Map<String, Object>> secondDeviceValues = doGetAsync(getAttributesValuesUrlSecondDevice, List.class);
+
+        assertAttributesValues(firstDeviceValues, expectedKeySet);
+        assertAttributesValues(secondDeviceValues, expectedKeySet);
+
+    }
+
+    protected void assertAttributesValues(List<Map<String, Object>> deviceValues, Set<String> expectedKeySet) {
+        for (Map<String, Object> map : deviceValues) {
+            String key = (String) map.get("key");
+            Object value = map.get("value");
+            assertTrue(expectedKeySet.contains(key));
+            switch (key) {
+                case "key1":
+                    assertEquals("value1", value);
+                    break;
+                case "key2":
+                    assertEquals(true, value);
+                    break;
+                case "key3":
+                    assertEquals(3.0, value);
+                    break;
+                case "key4":
+                    assertEquals(4, value);
+                    break;
+                case "key5":
+                    assertNotNull(value);
+                    assertEquals(3, ((LinkedHashMap) value).size());
+                    assertEquals(42, ((LinkedHashMap) value).get("someNumber"));
+                    assertEquals(Arrays.asList(1, 2, 3), ((LinkedHashMap) value).get("someArray"));
+                    LinkedHashMap<String, String> someNestedObject = (LinkedHashMap) ((LinkedHashMap) value).get("someNestedObject");
+                    assertEquals("value", someNestedObject.get("key"));
+                    break;
+            }
+        }
+    }
+
+    protected String getGatewayAttributesJsonPayload(String deviceA, String deviceB) {
+        return "{\"" + deviceA + "\": " + PAYLOAD_VALUES_STR + ",  \"" + deviceB + "\": " + PAYLOAD_VALUES_STR + "}";
+    }
+
+    private String getAttributesValuesUrl(DeviceId deviceId, Set<String> actualKeySet) {
+        return "/api/plugins/telemetry/DEVICE/" + deviceId + "/values/attributes/CLIENT_SCOPE?keys=" + String.join(",", actualKeySet);
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes;
+
+import lombok.extern.slf4j.Slf4j;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Slf4j
+public abstract class AbstractMqttAttributesJsonIntegrationTest extends AbstractMqttAttributesIntegrationTest {
+
+    private static final String POST_DATA_ATTRIBUTES_TOPIC = "data/attributes";
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Post Attributes device", "Test Post Attributes gateway", TransportPayloadType.JSON, null, POST_DATA_ATTRIBUTES_TOPIC);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testPushMqttAttributes() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        processAttributesTest(POST_DATA_ATTRIBUTES_TOPIC, expectedKeys, PAYLOAD_VALUES_STR.getBytes());
+    }
+
+    @Test
+    public void testPushMqttAttributesGateway() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        String deviceName1 = "Device A";
+        String deviceName2 = "Device B";
+        String payload = getGatewayAttributesJsonPayload(deviceName1, deviceName2);
+        processGatewayAttributesTest(expectedKeys, payload.getBytes(), deviceName1, deviceName2);
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes;
+
+import lombok.extern.slf4j.Slf4j;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+@Slf4j
+public abstract class AbstractMqttAttributesProtoIntegrationTest extends AbstractMqttAttributesIntegrationTest {
+
+    private static final String POST_DATA_ATTRIBUTES_TOPIC = "proto/attributes";
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Post Attributes device", "Test Post Attributes gateway", TransportPayloadType.PROTOBUF, null, POST_DATA_ATTRIBUTES_TOPIC);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testPushMqttAttributes() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        TransportProtos.PostAttributeMsg msg = getPostAttributeMsg(expectedKeys);
+        processAttributesTest(POST_DATA_ATTRIBUTES_TOPIC, expectedKeys, msg.toByteArray());
+    }
+
+    @Test
+    public void testPushMqttAttributesGateway() throws Exception {
+        TransportApiProtos.GatewayAttributesMsg.Builder gatewayAttributesMsgProtoBuilder = TransportApiProtos.GatewayAttributesMsg.newBuilder();
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        String deviceName1 = "Device A";
+        String deviceName2 = "Device B";
+        TransportApiProtos.AttributesMsg firstDeviceAttributesMsgProto = getDeviceAttributesMsgProto(deviceName1, expectedKeys);
+        TransportApiProtos.AttributesMsg secondDeviceAttributesMsgProto = getDeviceAttributesMsgProto(deviceName2, expectedKeys);
+        gatewayAttributesMsgProtoBuilder.addAllMsg(Arrays.asList(firstDeviceAttributesMsgProto, secondDeviceAttributesMsgProto));
+        TransportApiProtos.GatewayAttributesMsg gatewayAttributesMsg = gatewayAttributesMsgProtoBuilder.build();
+        processGatewayAttributesTest(expectedKeys, gatewayAttributesMsg.toByteArray(), deviceName1, deviceName2);
+    }
+
+    private TransportApiProtos.AttributesMsg getDeviceAttributesMsgProto(String deviceName, List<String> expectedKeys) {
+        TransportApiProtos.AttributesMsg.Builder deviceAttributesMsgBuilder = TransportApiProtos.AttributesMsg.newBuilder();
+        TransportProtos.PostAttributeMsg msg = getPostAttributeMsg(expectedKeys);
+        deviceAttributesMsgBuilder.setDeviceName(deviceName);
+        deviceAttributesMsgBuilder.setMsg(msg);
+        return deviceAttributesMsgBuilder.build();
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesIntegrationTest;
+
+@DaoNoSqlTest
+public class MqttAttributesNoSqlIntegrationTest extends AbstractMqttAttributesIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesIntegrationTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesJsonIntegrationTest;
+
+@DaoNoSqlTest
+public class MqttAttributesNoSqlJsonIntegrationTest extends AbstractMqttAttributesJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesIntegrationTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesProtoIntegrationTest;
+
+@DaoNoSqlTest
+public class MqttAttributesNoSqlProtoIntegrationTest extends AbstractMqttAttributesProtoIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesSqlIntegrationTest extends AbstractMqttAttributesIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesJsonIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesSqlJsonIntegrationTest extends AbstractMqttAttributesJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.attributes.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesJsonIntegrationTest;
+import org.thingsboard.server.mqtt.telemetry.attributes.AbstractMqttAttributesProtoIntegrationTest;
+
+@DaoSqlTest
+public class MqttAttributesSqlProtoIntegrationTest extends AbstractMqttAttributesProtoIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.timeseries;
+
+import io.netty.handler.codec.mqtt.MqttQoS;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.eclipse.paho.client.mqttv3.MqttCallback;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@Slf4j
+public abstract class AbstractMqttTimeseriesIntegrationTest extends AbstractMqttIntegrationTest {
+
+    protected static final String PAYLOAD_VALUES_STR = "{\"key1\":\"value1\", \"key2\":true, \"key3\": 3.0, \"key4\": 4," +
+            " \"key5\": {\"someNumber\": 42, \"someArray\": [1,2,3], \"someNestedObject\": {\"key\": \"value\"}}}";
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Post Telemetry device", "Test Post Telemetry gateway", null, null, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testPushMqttTelemetry() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        processTelemetryTest(MqttTopics.DEVICE_TELEMETRY_TOPIC, expectedKeys, PAYLOAD_VALUES_STR.getBytes(), false);
+    }
+
+    @Test
+    public void testPushMqttTelemetryWithTs() throws Exception {
+        String payloadStr = "{\"ts\": 10000, \"values\": " + PAYLOAD_VALUES_STR + "}";
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        processTelemetryTest(MqttTopics.DEVICE_TELEMETRY_TOPIC, expectedKeys, payloadStr.getBytes(), true);
+    }
+
+    @Test
+    public void testPushMqttTelemetryGateway() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        String deviceName1 = "Device A";
+        String deviceName2 = "Device B";
+        String payload = getGatewayTelemetryJsonPayload(deviceName1, deviceName2, "10000", "20000");
+        processGatewayTelemetryTest(MqttTopics.GATEWAY_TELEMETRY_TOPIC, expectedKeys, payload.getBytes(), deviceName1, deviceName2);
+    }
+
+    @Test
+    public void testGatewayConnect() throws Exception {
+        String payload = "{\"device\":\"Device A\"}";
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        publishMqttMsg(client, payload.getBytes(), MqttTopics.GATEWAY_CONNECT_TOPIC);
+
+        Thread.sleep(2000);
+
+        String deviceName = "Device A";
+        Device device = doGet("/api/tenant/devices?deviceName=" + deviceName, Device.class);
+        assertNotNull(device);
+    }
+
+    protected void processTelemetryTest(String topic, List<String> expectedKeys, byte[] payload, boolean withTs) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(accessToken);
+        publishMqttMsg(client, payload, topic);
+
+        String deviceId = savedDevice.getId().getId().toString();
+
+        long start = System.currentTimeMillis();
+        long end = System.currentTimeMillis() + 2000;
+
+        List<String> actualKeys = null;
+        while (start <= end) {
+            actualKeys = doGetAsync("/api/plugins/telemetry/DEVICE/" + deviceId + "/keys/timeseries", List.class);
+            if (actualKeys.size() == expectedKeys.size()) {
+                break;
+            }
+            Thread.sleep(100);
+            start += 100;
+        }
+        assertNotNull(actualKeys);
+
+        Set<String> actualKeySet = new HashSet<>(actualKeys);
+        Set<String> expectedKeySet = new HashSet<>(expectedKeys);
+
+        assertEquals(expectedKeySet, actualKeySet);
+
+        String getTelemetryValuesUrl;
+        if (withTs) {
+            getTelemetryValuesUrl = "/api/plugins/telemetry/DEVICE/" + deviceId + "/values/timeseries?startTs=0&endTs=15000&keys=" + String.join(",", actualKeySet);
+        } else {
+            getTelemetryValuesUrl = "/api/plugins/telemetry/DEVICE/" + deviceId + "/values/timeseries?keys=" + String.join(",", actualKeySet);
+        }
+        Map<String, List<Map<String, String>>> values = doGetAsync(getTelemetryValuesUrl, Map.class);
+
+        if (withTs) {
+            assertTs(values, expectedKeys, 10000, 0);
+        }
+        assertValues(values, 0);
+    }
+
+    protected void processGatewayTelemetryTest(String topic, List<String> expectedKeys, byte[] payload, String firstDeviceName, String secondDeviceName) throws Exception {
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+
+        publishMqttMsg(client, payload, topic);
+
+        Thread.sleep(2000);
+
+        Device firstDevice = doGet("/api/tenant/devices?deviceName=" + firstDeviceName, Device.class);
+        assertNotNull(firstDevice);
+        Device secondDevice = doGet("/api/tenant/devices?deviceName=" + secondDeviceName, Device.class);
+        assertNotNull(secondDevice);
+
+        List<String> firstDeviceActualKeys = doGetAsync("/api/plugins/telemetry/DEVICE/" + firstDevice.getId() + "/keys/timeseries", List.class);
+        Set<String> firstDeviceActualKeySet = new HashSet<>(firstDeviceActualKeys);
+
+        List<String> secondDeviceActualKeys = doGetAsync("/api/plugins/telemetry/DEVICE/" + secondDevice.getId() + "/keys/timeseries", List.class);
+        Set<String> secondDeviceActualKeySet = new HashSet<>(secondDeviceActualKeys);
+
+        Set<String> expectedKeySet = new HashSet<>(expectedKeys);
+
+        assertEquals(expectedKeySet, firstDeviceActualKeySet);
+        assertEquals(expectedKeySet, secondDeviceActualKeySet);
+
+        String getTelemetryValuesUrlFirstDevice = getTelemetryValuesUrl(firstDevice.getId(), firstDeviceActualKeySet);
+        String getTelemetryValuesUrlSecondDevice = getTelemetryValuesUrl(firstDevice.getId(), secondDeviceActualKeySet);
+
+        Map<String, List<Map<String, String>>> firstDeviceValues = doGetAsync(getTelemetryValuesUrlFirstDevice, Map.class);
+        Map<String, List<Map<String, String>>> secondDeviceValues = doGetAsync(getTelemetryValuesUrlSecondDevice, Map.class);
+
+        assertGatewayDeviceData(firstDeviceValues, expectedKeys);
+        assertGatewayDeviceData(secondDeviceValues, expectedKeys);
+    }
+
+    protected String getGatewayTelemetryJsonPayload(String deviceA, String deviceB, String firstTsValue, String secondTsValue) {
+        String payload = "[{\"ts\": " + firstTsValue + ", \"values\": " + PAYLOAD_VALUES_STR + "}, " +
+                "{\"ts\": " + secondTsValue + ", \"values\": " + PAYLOAD_VALUES_STR + "}]";
+        return "{\"" + deviceA + "\": " + payload + ",  \"" + deviceB + "\": " + payload + "}";
+    }
+
+    private String getTelemetryValuesUrl(DeviceId deviceId, Set<String> actualKeySet) {
+        return "/api/plugins/telemetry/DEVICE/" + deviceId + "/values/timeseries?startTs=0&endTs=25000&keys=" + String.join(",", actualKeySet);
+    }
+
+    private void assertGatewayDeviceData(Map<String, List<Map<String, String>>> deviceValues, List<String> expectedKeys) {
+
+        assertEquals(2, deviceValues.get(expectedKeys.get(0)).size());
+        assertEquals(2, deviceValues.get(expectedKeys.get(1)).size());
+        assertEquals(2, deviceValues.get(expectedKeys.get(2)).size());
+        assertEquals(2, deviceValues.get(expectedKeys.get(3)).size());
+        assertEquals(2, deviceValues.get(expectedKeys.get(4)).size());
+
+        assertTs(deviceValues, expectedKeys, 20000, 0);
+        assertTs(deviceValues, expectedKeys, 10000, 1);
+
+        assertValues(deviceValues, 0);
+        assertValues(deviceValues, 1);
+
+    }
+
+    private void assertValues(Map<String, List<Map<String, String>>> deviceValues, int arrayIndex) {
+        for (Map.Entry<String, List<Map<String, String>>> entry : deviceValues.entrySet()) {
+            String key = entry.getKey();
+            List<Map<String, String>> tsKv = entry.getValue();
+            String value = tsKv.get(arrayIndex).get("value");
+            switch (key) {
+                case "key1":
+                    assertEquals("value1", value);
+                    break;
+                case "key2":
+                    assertEquals("true", value);
+                    break;
+                case "key3":
+                    assertEquals("3.0", value);
+                    break;
+                case "key4":
+                    assertEquals("4", value);
+                    break;
+                case "key5":
+                    assertEquals("{\"someNumber\":42,\"someArray\":[1,2,3],\"someNestedObject\":{\"key\":\"value\"}}", value);
+                    break;
+            }
+        }
+    }
+
+    private void assertTs(Map<String, List<Map<String, String>>> deviceValues, List<String> expectedKeys, int ts, int arrayIndex) {
+        assertEquals(ts, deviceValues.get(expectedKeys.get(0)).get(arrayIndex).get("ts"));
+        assertEquals(ts, deviceValues.get(expectedKeys.get(1)).get(arrayIndex).get("ts"));
+        assertEquals(ts, deviceValues.get(expectedKeys.get(2)).get(arrayIndex).get("ts"));
+        assertEquals(ts, deviceValues.get(expectedKeys.get(3)).get(arrayIndex).get("ts"));
+        assertEquals(ts, deviceValues.get(expectedKeys.get(4)).get(arrayIndex).get("ts"));
+    }
+
+    //    @Test - Unstable
+    public void testMqttQoSLevel() throws Exception {
+        String clientId = MqttAsyncClient.generateClientId();
+        MqttAsyncClient client = new MqttAsyncClient(MQTT_URL, clientId);
+
+        MqttConnectOptions options = new MqttConnectOptions();
+        options.setUserName(accessToken);
+        CountDownLatch latch = new CountDownLatch(1);
+        TestMqttCallback callback = new TestMqttCallback(client, latch);
+        client.setCallback(callback);
+        client.connect(options).waitForCompletion(5000);
+        client.subscribe("v1/devices/me/attributes", MqttQoS.AT_MOST_ONCE.value());
+        String payload = "{\"key\":\"uniqueValue\"}";
+//        TODO 3.1: we need to acknowledge subscription only after it is processed by device actor and not when the message is pushed to queue.
+//        MqttClient -> SUB REQUEST -> Transport -> Kafka -> Device Actor (subscribed)
+//        MqttClient <- SUB_ACK <- Transport
+        Thread.sleep(5000);
+        doPostAsync("/api/plugins/telemetry/" + savedDevice.getId() + "/SHARED_SCOPE", payload, String.class, status().isOk());
+        latch.await(10, TimeUnit.SECONDS);
+        assertEquals(payload, callback.getPayload());
+        assertEquals(MqttQoS.AT_MOST_ONCE.value(), callback.getQoS());
+    }
+
+    private static class TestMqttCallback implements MqttCallback {
+
+        private final MqttAsyncClient client;
+        private final CountDownLatch latch;
+        private volatile Integer qoS;
+        private volatile String payload;
+
+        String getPayload() {
+            return payload;
+        }
+
+        TestMqttCallback(MqttAsyncClient client, CountDownLatch latch) {
+            this.client = client;
+            this.latch = latch;
+        }
+
+        int getQoS() {
+            return qoS;
+        }
+
+        @Override
+        public void connectionLost(Throwable throwable) {
+            log.error("Client connection lost", throwable);
+        }
+
+        @Override
+        public void messageArrived(String requestTopic, MqttMessage mqttMessage) {
+            payload = new String(mqttMessage.getPayload());
+            qoS = mqttMessage.getQos();
+            latch.countDown();
+        }
+
+        @Override
+        public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
+
+        }
+    }
+
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.timeseries;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@Slf4j
+public abstract class AbstractMqttTimeseriesJsonIntegrationTest extends AbstractMqttTimeseriesIntegrationTest {
+
+    private static final String POST_DATA_TELEMETRY_TOPIC = "data/telemetry";
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Post Telemetry device json payload", "Test Post Telemetry gateway json payload", TransportPayloadType.JSON, POST_DATA_TELEMETRY_TOPIC, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testPushMqttTelemetry() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        processTelemetryTest(POST_DATA_TELEMETRY_TOPIC, expectedKeys, PAYLOAD_VALUES_STR.getBytes(), false);
+    }
+
+    @Test
+    public void testPushMqttTelemetryWithTs() throws Exception {
+        String payloadStr = "{\"ts\": 10000, \"values\": " + PAYLOAD_VALUES_STR + "}";
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        processTelemetryTest(POST_DATA_TELEMETRY_TOPIC, expectedKeys, payloadStr.getBytes(), true);
+    }
+
+    @Test
+    public void testPushMqttTelemetryGateway() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        String deviceName1 = "Device A";
+        String deviceName2 = "Device B";
+        String payload = getGatewayTelemetryJsonPayload(deviceName1, deviceName2, "10000", "20000");
+        processGatewayTelemetryTest(MqttTopics.GATEWAY_TELEMETRY_TOPIC, expectedKeys, payload.getBytes(), deviceName1, deviceName2);
+    }
+
+    @Test
+    public void testGatewayConnect() throws Exception {
+        String payload = "{\"device\":\"Device A\", \"type\": \"" + TransportPayloadType.JSON.name() + "\"}";
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        publishMqttMsg(client, payload.getBytes(), MqttTopics.GATEWAY_CONNECT_TOPIC);
+
+        Thread.sleep(2000);
+
+        String deviceName = "Device A";
+        Device device = doGet("/api/tenant/devices?deviceName=" + deviceName, Device.class);
+        assertNotNull(device);
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.timeseries;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@Slf4j
+public abstract class AbstractMqttTimeseriesProtoIntegrationTest extends AbstractMqttTimeseriesIntegrationTest {
+
+    private static final String POST_DATA_TELEMETRY_TOPIC = "proto/telemetry";
+
+    @Before
+    public void beforeTest() throws Exception {
+        processBeforeTest("Test Post Telemetry device proto payload", "Test Post Telemetry gateway proto payload", TransportPayloadType.PROTOBUF, POST_DATA_TELEMETRY_TOPIC, null);
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        processAfterTest();
+    }
+
+    @Test
+    public void testPushMqttTelemetry() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        TransportProtos.TsKvListProto tsKvListProto = getTsKvListProto(expectedKeys, 0);
+        processTelemetryTest(POST_DATA_TELEMETRY_TOPIC, expectedKeys, tsKvListProto.toByteArray(), false);
+    }
+
+    @Test
+    public void testPushMqttTelemetryWithTs() throws Exception {
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        TransportProtos.TsKvListProto tsKvListProto = getTsKvListProto(expectedKeys, 10000);
+        processTelemetryTest(POST_DATA_TELEMETRY_TOPIC, expectedKeys, tsKvListProto.toByteArray(), true);
+    }
+
+    @Test
+    public void testPushMqttTelemetryGateway() throws Exception {
+        TransportApiProtos.GatewayTelemetryMsg.Builder gatewayTelemetryMsgProtoBuilder = TransportApiProtos.GatewayTelemetryMsg.newBuilder();
+        List<String> expectedKeys = Arrays.asList("key1", "key2", "key3", "key4", "key5");
+        String deviceName1 = "Device A";
+        String deviceName2 = "Device B";
+        TransportApiProtos.TelemetryMsg deviceATelemetryMsgProto = getDeviceTelemetryMsgProto(deviceName1, expectedKeys, 10000, 20000);
+        TransportApiProtos.TelemetryMsg deviceBTelemetryMsgProto = getDeviceTelemetryMsgProto(deviceName2, expectedKeys, 10000, 20000);
+        gatewayTelemetryMsgProtoBuilder.addAllMsg(Arrays.asList(deviceATelemetryMsgProto, deviceBTelemetryMsgProto));
+        TransportApiProtos.GatewayTelemetryMsg gatewayTelemetryMsg = gatewayTelemetryMsgProtoBuilder.build();
+        processGatewayTelemetryTest(MqttTopics.GATEWAY_TELEMETRY_TOPIC, expectedKeys, gatewayTelemetryMsg.toByteArray(), deviceName1, deviceName2);
+    }
+
+    @Test
+    public void testGatewayConnect() throws Exception {
+        String deviceName = "Device A";
+        TransportApiProtos.ConnectMsg connectMsgProto = getConnectProto(deviceName);
+        MqttAsyncClient client = getMqttAsyncClient(gatewayAccessToken);
+        publishMqttMsg(client, connectMsgProto.toByteArray(), MqttTopics.GATEWAY_CONNECT_TOPIC);
+
+        Thread.sleep(2000);
+
+        Device device = doGet("/api/tenant/devices?deviceName=" + deviceName, Device.class);
+        assertNotNull(device);
+    }
+
+    private TransportApiProtos.ConnectMsg getConnectProto(String deviceName) {
+        TransportApiProtos.ConnectMsg.Builder builder = TransportApiProtos.ConnectMsg.newBuilder();
+        builder.setDeviceName(deviceName);
+        builder.setDeviceType(TransportPayloadType.PROTOBUF.name());
+        return builder.build();
+    }
+
+    private TransportApiProtos.TelemetryMsg getDeviceTelemetryMsgProto(String deviceName, List<String> expectedKeys, long firstTs, long secondTs) {
+        TransportApiProtos.TelemetryMsg.Builder deviceTelemetryMsgBuilder = TransportApiProtos.TelemetryMsg.newBuilder();
+        TransportProtos.TsKvListProto tsKvListProto1 = getTsKvListProto(expectedKeys, firstTs);
+        TransportProtos.TsKvListProto tsKvListProto2 = getTsKvListProto(expectedKeys, secondTs);
+        TransportProtos.PostTelemetryMsg.Builder msg = TransportProtos.PostTelemetryMsg.newBuilder();
+        msg.addAllTsKvList(Arrays.asList(tsKvListProto1, tsKvListProto2));
+        deviceTelemetryMsgBuilder.setDeviceName(deviceName);
+        deviceTelemetryMsgBuilder.setMsg(msg);
+        return deviceTelemetryMsgBuilder.build();
+    }
+
+    private TransportProtos.TsKvListProto getTsKvListProto(List<String> expectedKeys, long ts) {
+        List<TransportProtos.KeyValueProto> kvProtos = getKvProtos(expectedKeys);
+        TransportProtos.TsKvListProto.Builder builder = TransportProtos.TsKvListProto.newBuilder();
+        builder.addAllKv(kvProtos);
+        builder.setTs(ts);
+        return builder.build();
+    }
+}

@@ -13,14 +13,14 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.thingsboard.server.mqtt.telemetry.nosql;
+package org.thingsboard.server.mqtt.telemetry.timeseries.nosql;
 
 
 import org.thingsboard.server.dao.service.DaoNoSqlTest;
 import org.thingsboard.server.dao.service.DaoNoSqlTest;
-import org.thingsboard.server.mqtt.telemetry.AbstractMqttTelemetryIntegrationTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesIntegrationTest;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 8/22/2017.
  * Created by Valerii Sosliuk on 8/22/2017.
  */
  */
 @DaoNoSqlTest
 @DaoNoSqlTest
-public class MqttTelemetryNoSqlIntegrationTest extends AbstractMqttTelemetryIntegrationTest {
+public class MqttTimeseriesNoSqlIntegrationTest extends AbstractMqttTimeseriesIntegrationTest {
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.timeseries.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesJsonIntegrationTest;
+
+@DaoNoSqlTest
+public class MqttTimeseriesNoSqlJsonIntegrationTest extends AbstractMqttTimeseriesJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.timeseries.nosql;
+
+import org.thingsboard.server.dao.service.DaoNoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesProtoIntegrationTest;
+
+@DaoNoSqlTest
+public class MqttTimeseriesNoSqlProtoIntegrationTest extends AbstractMqttTimeseriesProtoIntegrationTest {
+}

@@ -13,15 +13,14 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.thingsboard.server.mqtt.telemetry.sql;
+package org.thingsboard.server.mqtt.telemetry.timeseries.sql;
 
 
-import org.thingsboard.server.dao.service.DaoNoSqlTest;
 import org.thingsboard.server.dao.service.DaoSqlTest;
 import org.thingsboard.server.dao.service.DaoSqlTest;
-import org.thingsboard.server.mqtt.telemetry.AbstractMqttTelemetryIntegrationTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesIntegrationTest;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 8/22/2017.
  * Created by Valerii Sosliuk on 8/22/2017.
  */
  */
 @DaoSqlTest
 @DaoSqlTest
-public class MqttTelemetrySqlIntegrationTest extends AbstractMqttTelemetryIntegrationTest {
+public class MqttTimeseriesSqlIntegrationTest extends AbstractMqttTimeseriesIntegrationTest {
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.timeseries.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesIntegrationTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesJsonIntegrationTest;
+
+/**
+ * Created by Valerii Sosliuk on 8/22/2017.
+ */
+@DaoSqlTest
+public class MqttTimeseriesSqlJsonIntegrationTest extends AbstractMqttTimeseriesJsonIntegrationTest {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.mqtt.telemetry.timeseries.sql;
+
+import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesJsonIntegrationTest;
+import org.thingsboard.server.mqtt.telemetry.timeseries.AbstractMqttTimeseriesProtoIntegrationTest;
+
+/**
+ * Created by Valerii Sosliuk on 8/22/2017.
+ */
+@DaoSqlTest
+public class MqttTimeseriesSqlProtoIntegrationTest extends AbstractMqttTimeseriesProtoIntegrationTest {
+}

@@ -16,7 +16,6 @@
 package org.thingsboard.server.rules.flow.sql;
 package org.thingsboard.server.rules.flow.sql;
 
 
 import org.thingsboard.server.dao.service.DaoSqlTest;
 import org.thingsboard.server.dao.service.DaoSqlTest;
-import org.thingsboard.server.mqtt.rpc.AbstractMqttServerSideRpcIntegrationTest;
 import org.thingsboard.server.rules.flow.AbstractRuleEngineFlowIntegrationTest;
 import org.thingsboard.server.rules.flow.AbstractRuleEngineFlowIntegrationTest;
 
 
 /**
 /**

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

@@ -16,11 +16,14 @@
 package org.thingsboard.server.common.data.device.profile;
 package org.thingsboard.server.common.data.device.profile;
 
 
 import lombok.Data;
 import lombok.Data;
+import org.thingsboard.server.common.data.TransportPayloadType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 
 
 @Data
 @Data
 public class MqttDeviceProfileTransportConfiguration implements DeviceProfileTransportConfiguration {
 public class MqttDeviceProfileTransportConfiguration implements DeviceProfileTransportConfiguration {
 
 
+    private TransportPayloadType transportPayloadType = TransportPayloadType.JSON;
+
     private String deviceTelemetryTopic = MqttTopics.DEVICE_TELEMETRY_TOPIC;
     private String deviceTelemetryTopic = MqttTopics.DEVICE_TELEMETRY_TOPIC;
     private String deviceAttributesTopic = MqttTopics.DEVICE_ATTRIBUTES_TOPIC;
     private String deviceAttributesTopic = MqttTopics.DEVICE_ATTRIBUTES_TOPIC;
 
 

@@ -20,28 +20,48 @@ package org.thingsboard.server.common.data.device.profile;
  */
  */
 public class MqttTopics {
 public class MqttTopics {
 
 
+    private static final String RPC = "/rpc";
+    private static final String CONNECT = "/connect";
+    private static final String DISCONNECT = "/disconnect";
+    private static final String TELEMETRY = "/telemetry";
+    private static final String ATTRIBUTES = "/attributes";
+    private static final String CLAIM = "/claim";
+    private static final String SUB_TOPIC = "+";
+    private static final String ATTRIBUTES_RESPONSE = "/attributes/response";
+    private static final String ATTRIBUTES_REQUEST = "/attributes/request";
+
+    private static final String DEVICE_RPC_RESPONSE = "/rpc/response/";
+    private static final String DEVICE_RPC_REQUEST = "/rpc/request/";
+
+    private static final String DEVICE_ATTRIBUTES_RESPONSE = ATTRIBUTES_RESPONSE + "/";
+    private static final String DEVICE_ATTRIBUTES_REQUEST = ATTRIBUTES_REQUEST + "/";
+
+    // V1_JSON topics
+
     public static final String BASE_DEVICE_API_TOPIC = "v1/devices/me";
     public static final String BASE_DEVICE_API_TOPIC = "v1/devices/me";
-    public static final String DEVICE_RPC_RESPONSE_TOPIC = BASE_DEVICE_API_TOPIC + "/rpc/response/";
-    public static final String DEVICE_RPC_RESPONSE_SUB_TOPIC = DEVICE_RPC_RESPONSE_TOPIC + "+";
-    public static final String DEVICE_RPC_REQUESTS_TOPIC = BASE_DEVICE_API_TOPIC + "/rpc/request/";
-    public static final String DEVICE_RPC_REQUESTS_SUB_TOPIC = DEVICE_RPC_REQUESTS_TOPIC + "+";
-    public static final String DEVICE_ATTRIBUTES_RESPONSE_TOPIC_PREFIX = BASE_DEVICE_API_TOPIC + "/attributes/response/";
-    public static final String DEVICE_ATTRIBUTES_RESPONSES_TOPIC = DEVICE_ATTRIBUTES_RESPONSE_TOPIC_PREFIX + "+";
-    public static final String DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX = BASE_DEVICE_API_TOPIC + "/attributes/request/";
-    public static final String DEVICE_TELEMETRY_TOPIC = BASE_DEVICE_API_TOPIC + "/telemetry";
-    public static final String DEVICE_CLAIM_TOPIC = BASE_DEVICE_API_TOPIC + "/claim";
-    public static final String DEVICE_ATTRIBUTES_TOPIC = BASE_DEVICE_API_TOPIC + "/attributes";
 
 
-    public static final String BASE_GATEWAY_API_TOPIC = "v1/gateway";
-    public static final String GATEWAY_CONNECT_TOPIC = BASE_GATEWAY_API_TOPIC + "/connect";
-    public static final String GATEWAY_DISCONNECT_TOPIC = BASE_GATEWAY_API_TOPIC + "/disconnect";
-    public static final String GATEWAY_ATTRIBUTES_TOPIC = BASE_GATEWAY_API_TOPIC + "/attributes";
-    public static final String GATEWAY_TELEMETRY_TOPIC = BASE_GATEWAY_API_TOPIC + "/telemetry";
-    public static final String GATEWAY_CLAIM_TOPIC = BASE_GATEWAY_API_TOPIC + "/claim";
-    public static final String GATEWAY_RPC_TOPIC = BASE_GATEWAY_API_TOPIC + "/rpc";
-    public static final String GATEWAY_ATTRIBUTES_REQUEST_TOPIC = BASE_GATEWAY_API_TOPIC + "/attributes/request";
-    public static final String GATEWAY_ATTRIBUTES_RESPONSE_TOPIC = BASE_GATEWAY_API_TOPIC + "/attributes/response";
+    public static final String DEVICE_RPC_RESPONSE_TOPIC = BASE_DEVICE_API_TOPIC + DEVICE_RPC_RESPONSE;
+    public static final String DEVICE_RPC_RESPONSE_SUB_TOPIC = DEVICE_RPC_RESPONSE_TOPIC + SUB_TOPIC;
+    public static final String DEVICE_RPC_REQUESTS_TOPIC = BASE_DEVICE_API_TOPIC + DEVICE_RPC_REQUEST;
+    public static final String DEVICE_RPC_REQUESTS_SUB_TOPIC = DEVICE_RPC_REQUESTS_TOPIC + SUB_TOPIC;
+    public static final String DEVICE_ATTRIBUTES_RESPONSE_TOPIC_PREFIX = BASE_DEVICE_API_TOPIC + DEVICE_ATTRIBUTES_RESPONSE;
+    public static final String DEVICE_ATTRIBUTES_RESPONSES_TOPIC = DEVICE_ATTRIBUTES_RESPONSE_TOPIC_PREFIX + SUB_TOPIC;
+    public static final String DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX = BASE_DEVICE_API_TOPIC + DEVICE_ATTRIBUTES_REQUEST;
+    public static final String DEVICE_TELEMETRY_TOPIC = BASE_DEVICE_API_TOPIC + TELEMETRY;
+    public static final String DEVICE_CLAIM_TOPIC = BASE_DEVICE_API_TOPIC + CLAIM;
+    public static final String DEVICE_ATTRIBUTES_TOPIC = BASE_DEVICE_API_TOPIC + ATTRIBUTES;
+
+    // V1_JSON gateway topics
 
 
+    public static final String BASE_GATEWAY_API_TOPIC = "v1/gateway";
+    public static final String GATEWAY_CONNECT_TOPIC = BASE_GATEWAY_API_TOPIC + CONNECT;
+    public static final String GATEWAY_DISCONNECT_TOPIC = BASE_GATEWAY_API_TOPIC + DISCONNECT;
+    public static final String GATEWAY_ATTRIBUTES_TOPIC = BASE_GATEWAY_API_TOPIC + ATTRIBUTES;
+    public static final String GATEWAY_TELEMETRY_TOPIC = BASE_GATEWAY_API_TOPIC + TELEMETRY;
+    public static final String GATEWAY_CLAIM_TOPIC = BASE_GATEWAY_API_TOPIC + CLAIM;
+    public static final String GATEWAY_RPC_TOPIC = BASE_GATEWAY_API_TOPIC + RPC;
+    public static final String GATEWAY_ATTRIBUTES_REQUEST_TOPIC = BASE_GATEWAY_API_TOPIC + ATTRIBUTES_REQUEST;
+    public static final String GATEWAY_ATTRIBUTES_RESPONSE_TOPIC = BASE_GATEWAY_API_TOPIC + ATTRIBUTES_RESPONSE;
 
 
     private MqttTopics() {
     private MqttTopics() {
     }
     }

@@ -24,7 +24,8 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.transport.TransportContext;
 import org.thingsboard.server.common.transport.TransportContext;
-import org.thingsboard.server.transport.mqtt.adaptors.MqttTransportAdaptor;
+import org.thingsboard.server.transport.mqtt.adaptors.JsonMqttAdaptor;
+import org.thingsboard.server.transport.mqtt.adaptors.ProtoMqttAdaptor;
 
 
 /**
 /**
  * Created by ashvayka on 04.10.18.
  * Created by ashvayka on 04.10.18.
@@ -40,7 +41,11 @@ public class MqttTransportContext extends TransportContext {
 
 
     @Getter
     @Getter
     @Autowired
     @Autowired
-    private MqttTransportAdaptor adaptor;
+    private JsonMqttAdaptor jsonMqttAdaptor;
+
+    @Getter
+    @Autowired
+    private ProtoMqttAdaptor protoMqttAdaptor;
 
 
     @Getter
     @Getter
     @Value("${transport.mqtt.netty.max_payload_size}")
     @Value("${transport.mqtt.netty.max_payload_size}")

@@ -38,7 +38,6 @@ import io.netty.util.ReferenceCountUtil;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.GenericFutureListener;
 import io.netty.util.concurrent.GenericFutureListener;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.StringUtils;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.device.profile.MqttTopics;
 import org.thingsboard.server.common.data.device.profile.MqttTopics;
@@ -53,8 +52,6 @@ import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsRes
 import org.thingsboard.server.common.transport.service.DefaultTransportService;
 import org.thingsboard.server.common.transport.service.DefaultTransportService;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionEvent;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionEvent;
-import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
-import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceTokenRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceX509CertRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceX509CertRequestMsg;
 import org.thingsboard.server.transport.mqtt.adaptors.MqttTransportAdaptor;
 import org.thingsboard.server.transport.mqtt.adaptors.MqttTransportAdaptor;
 import org.thingsboard.server.transport.mqtt.session.DeviceSessionCtx;
 import org.thingsboard.server.transport.mqtt.session.DeviceSessionCtx;
@@ -66,7 +63,6 @@ import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.security.cert.X509Certificate;
 import javax.security.cert.X509Certificate;
 import java.io.IOException;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
@@ -74,7 +70,6 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentMap;
 
 
 import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_ACCEPTED;
 import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_ACCEPTED;
-import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_REFUSED_BAD_USER_NAME_OR_PASSWORD;
 import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED;
 import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED;
 import static io.netty.handler.codec.mqtt.MqttMessageType.CONNACK;
 import static io.netty.handler.codec.mqtt.MqttMessageType.CONNACK;
 import static io.netty.handler.codec.mqtt.MqttMessageType.PINGRESP;
 import static io.netty.handler.codec.mqtt.MqttMessageType.PINGRESP;
@@ -95,7 +90,6 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
 
 
     private final UUID sessionId;
     private final UUID sessionId;
     private final MqttTransportContext context;
     private final MqttTransportContext context;
-    private final MqttTransportAdaptor adaptor;
     private final TransportService transportService;
     private final TransportService transportService;
     private final SslHandler sslHandler;
     private final SslHandler sslHandler;
     private final ConcurrentMap<MqttTopicMatcher, Integer> mqttQoSMap;
     private final ConcurrentMap<MqttTopicMatcher, Integer> mqttQoSMap;
@@ -108,10 +102,9 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
         this.sessionId = UUID.randomUUID();
         this.sessionId = UUID.randomUUID();
         this.context = context;
         this.context = context;
         this.transportService = context.getTransportService();
         this.transportService = context.getTransportService();
-        this.adaptor = context.getAdaptor();
         this.sslHandler = sslHandler;
         this.sslHandler = sslHandler;
         this.mqttQoSMap = new ConcurrentHashMap<>();
         this.mqttQoSMap = new ConcurrentHashMap<>();
-        this.deviceSessionCtx = new DeviceSessionCtx(sessionId, mqttQoSMap);
+        this.deviceSessionCtx = new DeviceSessionCtx(sessionId, mqttQoSMap, context);
     }
     }
 
 
     @Override
     @Override
@@ -215,23 +208,24 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
 
 
     private void processDevicePublish(ChannelHandlerContext ctx, MqttPublishMessage mqttMsg, String topicName, int msgId) {
     private void processDevicePublish(ChannelHandlerContext ctx, MqttPublishMessage mqttMsg, String topicName, int msgId) {
         try {
         try {
+            MqttTransportAdaptor payloadAdaptor = deviceSessionCtx.getPayloadAdaptor();
             if (deviceSessionCtx.isDeviceTelemetryTopic(topicName)) {
             if (deviceSessionCtx.isDeviceTelemetryTopic(topicName)) {
-                TransportProtos.PostTelemetryMsg postTelemetryMsg = adaptor.convertToPostTelemetry(deviceSessionCtx, mqttMsg);
+                TransportProtos.PostTelemetryMsg postTelemetryMsg = payloadAdaptor.convertToPostTelemetry(deviceSessionCtx, mqttMsg);
                 transportService.process(deviceSessionCtx.getSessionInfo(), postTelemetryMsg, getPubAckCallback(ctx, msgId, postTelemetryMsg));
                 transportService.process(deviceSessionCtx.getSessionInfo(), postTelemetryMsg, getPubAckCallback(ctx, msgId, postTelemetryMsg));
             } else if (deviceSessionCtx.isDeviceAttributesTopic(topicName)) {
             } else if (deviceSessionCtx.isDeviceAttributesTopic(topicName)) {
-                TransportProtos.PostAttributeMsg postAttributeMsg = adaptor.convertToPostAttributes(deviceSessionCtx, mqttMsg);
+                TransportProtos.PostAttributeMsg postAttributeMsg = payloadAdaptor.convertToPostAttributes(deviceSessionCtx, mqttMsg);
                 transportService.process(deviceSessionCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(ctx, msgId, postAttributeMsg));
                 transportService.process(deviceSessionCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(ctx, msgId, postAttributeMsg));
             } else if (topicName.startsWith(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX)) {
             } else if (topicName.startsWith(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX)) {
-                TransportProtos.GetAttributeRequestMsg getAttributeMsg = adaptor.convertToGetAttributes(deviceSessionCtx, mqttMsg);
+                TransportProtos.GetAttributeRequestMsg getAttributeMsg = payloadAdaptor.convertToGetAttributes(deviceSessionCtx, mqttMsg);
                 transportService.process(deviceSessionCtx.getSessionInfo(), getAttributeMsg, getPubAckCallback(ctx, msgId, getAttributeMsg));
                 transportService.process(deviceSessionCtx.getSessionInfo(), getAttributeMsg, getPubAckCallback(ctx, msgId, getAttributeMsg));
             } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_RESPONSE_TOPIC)) {
             } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_RESPONSE_TOPIC)) {
-                TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = adaptor.convertToDeviceRpcResponse(deviceSessionCtx, mqttMsg);
+                TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = payloadAdaptor.convertToDeviceRpcResponse(deviceSessionCtx, mqttMsg);
                 transportService.process(deviceSessionCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(ctx, msgId, rpcResponseMsg));
                 transportService.process(deviceSessionCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(ctx, msgId, rpcResponseMsg));
             } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_REQUESTS_TOPIC)) {
             } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_REQUESTS_TOPIC)) {
-                TransportProtos.ToServerRpcRequestMsg rpcRequestMsg = adaptor.convertToServerRpcRequest(deviceSessionCtx, mqttMsg);
+                TransportProtos.ToServerRpcRequestMsg rpcRequestMsg = payloadAdaptor.convertToServerRpcRequest(deviceSessionCtx, mqttMsg);
                 transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequestMsg, getPubAckCallback(ctx, msgId, rpcRequestMsg));
                 transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequestMsg, getPubAckCallback(ctx, msgId, rpcRequestMsg));
             } else if (topicName.equals(MqttTopics.DEVICE_CLAIM_TOPIC)) {
             } else if (topicName.equals(MqttTopics.DEVICE_CLAIM_TOPIC)) {
-                TransportProtos.ClaimDeviceMsg claimDeviceMsg = adaptor.convertToClaimDevice(deviceSessionCtx, mqttMsg);
+                TransportProtos.ClaimDeviceMsg claimDeviceMsg = payloadAdaptor.convertToClaimDevice(deviceSessionCtx, mqttMsg);
                 transportService.process(deviceSessionCtx.getSessionInfo(), claimDeviceMsg, getPubAckCallback(ctx, msgId, claimDeviceMsg));
                 transportService.process(deviceSessionCtx.getSessionInfo(), claimDeviceMsg, getPubAckCallback(ctx, msgId, claimDeviceMsg));
             } else {
             } else {
                 transportService.reportActivity(deviceSessionCtx.getSessionInfo());
                 transportService.reportActivity(deviceSessionCtx.getSessionInfo());
@@ -244,7 +238,6 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
     }
     }
 
 
 
 
-
     private <T> TransportServiceCallback<Void> getPubAckCallback(final ChannelHandlerContext ctx, final int msgId, final T msg) {
     private <T> TransportServiceCallback<Void> getPubAckCallback(final ChannelHandlerContext ctx, final int msgId, final T msg) {
         return new TransportServiceCallback<Void>() {
         return new TransportServiceCallback<Void>() {
             @Override
             @Override
@@ -288,10 +281,10 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
                         break;
                         break;
                     }
                     }
                     case MqttTopics.DEVICE_RPC_RESPONSE_SUB_TOPIC:
                     case MqttTopics.DEVICE_RPC_RESPONSE_SUB_TOPIC:
+                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_TOPIC:
                     case MqttTopics.GATEWAY_ATTRIBUTES_TOPIC:
                     case MqttTopics.GATEWAY_ATTRIBUTES_TOPIC:
                     case MqttTopics.GATEWAY_RPC_TOPIC:
                     case MqttTopics.GATEWAY_RPC_TOPIC:
                     case MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC:
                     case MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC:
-                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_TOPIC:
                         registerSubQoS(topic, grantedQoSList, reqQoS);
                         registerSubQoS(topic, grantedQoSList, reqQoS);
                         break;
                         break;
                     default:
                     default:
@@ -490,7 +483,7 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
             if (infoNode != null) {
             if (infoNode != null) {
                 JsonNode gatewayNode = infoNode.get("gateway");
                 JsonNode gatewayNode = infoNode.get("gateway");
                 if (gatewayNode != null && gatewayNode.asBoolean()) {
                 if (gatewayNode != null && gatewayNode.asBoolean()) {
-                    gatewaySessionHandler = new GatewaySessionHandler(context, deviceSessionCtx, sessionId);
+                    gatewaySessionHandler = new GatewaySessionHandler(deviceSessionCtx, sessionId);
                 }
                 }
             }
             }
         } catch (IOException e) {
         } catch (IOException e) {
@@ -544,7 +537,7 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
     @Override
     @Override
     public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg response) {
     public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg response) {
         try {
         try {
-            adaptor.convertToPublish(deviceSessionCtx, response).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+            deviceSessionCtx.getPayloadAdaptor().convertToPublish(deviceSessionCtx, response).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
         } catch (Exception e) {
         } catch (Exception e) {
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
         }
         }
@@ -553,7 +546,7 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
     @Override
     @Override
     public void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg notification) {
     public void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg notification) {
         try {
         try {
-            adaptor.convertToPublish(deviceSessionCtx, notification).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+            deviceSessionCtx.getPayloadAdaptor().convertToPublish(deviceSessionCtx, notification).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
         } catch (Exception e) {
         } catch (Exception e) {
             log.trace("[{}] Failed to convert device attributes update to MQTT msg", sessionId, e);
             log.trace("[{}] Failed to convert device attributes update to MQTT msg", sessionId, e);
         }
         }
@@ -569,17 +562,17 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
     public void onToDeviceRpcRequest(TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
     public void onToDeviceRpcRequest(TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
         log.trace("[{}] Received RPC command to device", sessionId);
         log.trace("[{}] Received RPC command to device", sessionId);
         try {
         try {
-            adaptor.convertToPublish(deviceSessionCtx, rpcRequest).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+            deviceSessionCtx.getPayloadAdaptor().convertToPublish(deviceSessionCtx, rpcRequest).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
         } catch (Exception e) {
         } catch (Exception e) {
-            log.trace("[{}] Failed to convert device RPC commandto MQTT msg", sessionId, e);
+            log.trace("[{}] Failed to convert device RPC command to MQTT msg", sessionId, e);
         }
         }
     }
     }
 
 
     @Override
     @Override
     public void onToServerRpcResponse(TransportProtos.ToServerRpcResponseMsg rpcResponse) {
     public void onToServerRpcResponse(TransportProtos.ToServerRpcResponseMsg rpcResponse) {
-        log.trace("[{}] Received RPC command to device", sessionId);
+        log.trace("[{}] Received RPC command to server", sessionId);
         try {
         try {
-            adaptor.convertToPublish(deviceSessionCtx, rpcResponse).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+            deviceSessionCtx.getPayloadAdaptor().convertToPublish(deviceSessionCtx, rpcResponse).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
         } catch (Exception e) {
         } catch (Exception e) {
             log.trace("[{}] Failed to convert device RPC command to MQTT msg", sessionId, e);
             log.trace("[{}] Failed to convert device RPC command to MQTT msg", sessionId, e);
         }
         }

@@ -38,6 +38,7 @@ import org.thingsboard.server.common.data.device.profile.MqttTopics;
 import org.thingsboard.server.transport.mqtt.session.MqttDeviceAwareSessionContext;
 import org.thingsboard.server.transport.mqtt.session.MqttDeviceAwareSessionContext;
 
 
 import java.nio.charset.Charset;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.HashSet;
 import java.util.Optional;
 import java.util.Optional;
@@ -47,12 +48,13 @@ import java.util.UUID;
 /**
 /**
  * @author Andrew Shvayka
  * @author Andrew Shvayka
  */
  */
-@Component("JsonMqttAdaptor")
+@Component
 @Slf4j
 @Slf4j
 public class JsonMqttAdaptor implements MqttTransportAdaptor {
 public class JsonMqttAdaptor implements MqttTransportAdaptor {
 
 
+    protected static final Charset UTF8 = StandardCharsets.UTF_8;
+
     private static final Gson GSON = new Gson();
     private static final Gson GSON = new Gson();
-    private static final Charset UTF8 = Charset.forName("UTF-8");
     private static final ByteBufAllocator ALLOCATOR = new UnpooledByteBufAllocator(false);
     private static final ByteBufAllocator ALLOCATOR = new UnpooledByteBufAllocator(false);
 
 
     @Override
     @Override
@@ -76,11 +78,81 @@ public class JsonMqttAdaptor implements MqttTransportAdaptor {
     }
     }
 
 
     @Override
     @Override
+    public TransportProtos.ClaimDeviceMsg convertToClaimDevice(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        String payload = validatePayload(ctx.getSessionId(), inbound.payload(), true);
+        try {
+            return JsonConverter.convertToClaimDeviceProto(ctx.getDeviceId(), payload);
+        } catch (IllegalStateException | JsonSyntaxException ex) {
+            throw new AdaptorException(ex);
+        }
+    }
+
+    @Override
     public TransportProtos.GetAttributeRequestMsg convertToGetAttributes(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
     public TransportProtos.GetAttributeRequestMsg convertToGetAttributes(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        return processGetAttributeRequestMsg(inbound, MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX);
+    }
+
+    @Override
+    public TransportProtos.ToDeviceRpcResponseMsg convertToDeviceRpcResponse(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        return processToDeviceRpcResponseMsg(inbound, MqttTopics.DEVICE_RPC_RESPONSE_TOPIC);
+    }
+
+    @Override
+    public TransportProtos.ToServerRpcRequestMsg convertToServerRpcRequest(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        return processToServerRpcRequestMsg(ctx, inbound, MqttTopics.DEVICE_RPC_REQUESTS_TOPIC);
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+        return processConvertFromAttributeResponseMsg(ctx, responseMsg, MqttTopics.DEVICE_ATTRIBUTES_RESPONSE_TOPIC_PREFIX);
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+        return processConvertFromGatewayAttributeResponseMsg(ctx, deviceName, responseMsg, MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC);
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.AttributeUpdateNotificationMsg notificationMsg) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_ATTRIBUTES_TOPIC, JsonConverter.toJson(notificationMsg)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.AttributeUpdateNotificationMsg notificationMsg) {
+        JsonObject result = JsonConverter.getJsonObjectForGateway(deviceName, notificationMsg);
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_ATTRIBUTES_TOPIC, result));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_RPC_REQUESTS_TOPIC + rpcRequest.getRequestId(), JsonConverter.toJson(rpcRequest, false)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_RPC_TOPIC, JsonConverter.toGatewayJson(deviceName, rpcRequest)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.ToServerRpcResponseMsg rpcResponse) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_RPC_RESPONSE_TOPIC + rpcResponse.getRequestId(), JsonConverter.toJson(rpcResponse)));
+    }
+
+    public static JsonElement validateJsonPayload(UUID sessionId, ByteBuf payloadData) throws AdaptorException {
+        String payload = validatePayload(sessionId, payloadData, false);
+        try {
+            return new JsonParser().parse(payload);
+        } catch (JsonSyntaxException ex) {
+            log.warn("Payload is in incorrect format: {}", payload);
+            throw new AdaptorException(ex);
+        }
+    }
+
+    protected TransportProtos.GetAttributeRequestMsg processGetAttributeRequestMsg(MqttPublishMessage inbound, String topic) throws AdaptorException {
         String topicName = inbound.variableHeader().topicName();
         String topicName = inbound.variableHeader().topicName();
         try {
         try {
             TransportProtos.GetAttributeRequestMsg.Builder result = TransportProtos.GetAttributeRequestMsg.newBuilder();
             TransportProtos.GetAttributeRequestMsg.Builder result = TransportProtos.GetAttributeRequestMsg.newBuilder();
-            result.setRequestId(Integer.valueOf(topicName.substring(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX.length())));
+            result.setRequestId(getRequestId(topicName, topic));
             String payload = inbound.payload().toString(UTF8);
             String payload = inbound.payload().toString(UTF8);
             JsonElement requestBody = new JsonParser().parse(payload);
             JsonElement requestBody = new JsonParser().parse(payload);
             Set<String> clientKeys = toStringSet(requestBody, "clientKeys");
             Set<String> clientKeys = toStringSet(requestBody, "clientKeys");
@@ -98,93 +170,53 @@ public class JsonMqttAdaptor implements MqttTransportAdaptor {
         }
         }
     }
     }
 
 
-    @Override
-    public TransportProtos.ToDeviceRpcResponseMsg convertToDeviceRpcResponse(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+    protected TransportProtos.ToDeviceRpcResponseMsg processToDeviceRpcResponseMsg(MqttPublishMessage inbound, String topic) throws AdaptorException {
         String topicName = inbound.variableHeader().topicName();
         String topicName = inbound.variableHeader().topicName();
         try {
         try {
-            Integer requestId = Integer.valueOf(topicName.substring(MqttTopics.DEVICE_RPC_RESPONSE_TOPIC.length()));
+            int requestId = getRequestId(topicName, topic);
             String payload = inbound.payload().toString(UTF8);
             String payload = inbound.payload().toString(UTF8);
             return TransportProtos.ToDeviceRpcResponseMsg.newBuilder().setRequestId(requestId).setPayload(payload).build();
             return TransportProtos.ToDeviceRpcResponseMsg.newBuilder().setRequestId(requestId).setPayload(payload).build();
         } catch (RuntimeException e) {
         } catch (RuntimeException e) {
-            log.warn("Failed to decode get attributes request", e);
+            log.warn("Failed to decode Rpc response", e);
             throw new AdaptorException(e);
             throw new AdaptorException(e);
         }
         }
     }
     }
 
 
-    @Override
-    public TransportProtos.ToServerRpcRequestMsg convertToServerRpcRequest(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+    protected TransportProtos.ToServerRpcRequestMsg processToServerRpcRequestMsg(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound, String topic) throws AdaptorException {
         String topicName = inbound.variableHeader().topicName();
         String topicName = inbound.variableHeader().topicName();
         String payload = validatePayload(ctx.getSessionId(), inbound.payload(), false);
         String payload = validatePayload(ctx.getSessionId(), inbound.payload(), false);
         try {
         try {
-            Integer requestId = Integer.valueOf(topicName.substring(MqttTopics.DEVICE_RPC_REQUESTS_TOPIC.length()));
+            int requestId = getRequestId(topicName, topic);
             return JsonConverter.convertToServerRpcRequest(new JsonParser().parse(payload), requestId);
             return JsonConverter.convertToServerRpcRequest(new JsonParser().parse(payload), requestId);
         } catch (IllegalStateException | JsonSyntaxException ex) {
         } catch (IllegalStateException | JsonSyntaxException ex) {
             throw new AdaptorException(ex);
             throw new AdaptorException(ex);
         }
         }
     }
     }
 
 
-    @Override
-    public TransportProtos.ClaimDeviceMsg convertToClaimDevice(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
-        String payload = validatePayload(ctx.getSessionId(), inbound.payload(), true);
-        try {
-            return JsonConverter.convertToClaimDeviceProto(ctx.getDeviceId(), payload);
-        } catch (IllegalStateException | JsonSyntaxException ex) {
-            throw new AdaptorException(ex);
-        }
-    }
-
-    @Override
-    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+    protected Optional<MqttMessage> processConvertFromAttributeResponseMsg(MqttDeviceAwareSessionContext ctx, TransportProtos.GetAttributeResponseMsg responseMsg, String topic) throws AdaptorException {
         if (!StringUtils.isEmpty(responseMsg.getError())) {
         if (!StringUtils.isEmpty(responseMsg.getError())) {
             throw new AdaptorException(responseMsg.getError());
             throw new AdaptorException(responseMsg.getError());
         } else {
         } else {
-            Integer requestId = responseMsg.getRequestId();
+            int requestId = responseMsg.getRequestId();
             if (requestId >= 0) {
             if (requestId >= 0) {
                 return Optional.of(createMqttPublishMsg(ctx,
                 return Optional.of(createMqttPublishMsg(ctx,
-                        MqttTopics.DEVICE_ATTRIBUTES_RESPONSE_TOPIC_PREFIX + requestId,
+                        topic + requestId,
                         JsonConverter.toJson(responseMsg)));
                         JsonConverter.toJson(responseMsg)));
             }
             }
             return Optional.empty();
             return Optional.empty();
         }
         }
     }
     }
 
 
-    @Override
-    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+    protected Optional<MqttMessage> processConvertFromGatewayAttributeResponseMsg(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.GetAttributeResponseMsg responseMsg, String topic) throws AdaptorException {
         if (!StringUtils.isEmpty(responseMsg.getError())) {
         if (!StringUtils.isEmpty(responseMsg.getError())) {
             throw new AdaptorException(responseMsg.getError());
             throw new AdaptorException(responseMsg.getError());
         } else {
         } else {
             JsonObject result = JsonConverter.getJsonObjectForGateway(deviceName, responseMsg);
             JsonObject result = JsonConverter.getJsonObjectForGateway(deviceName, responseMsg);
-            return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC, result));
+            return Optional.of(createMqttPublishMsg(ctx, topic, result));
         }
         }
     }
     }
 
 
-    @Override
-    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.AttributeUpdateNotificationMsg notificationMsg) throws AdaptorException {
-        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_ATTRIBUTES_TOPIC, JsonConverter.toJson(notificationMsg)));
-    }
-
-    @Override
-    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.AttributeUpdateNotificationMsg notificationMsg) throws AdaptorException {
-        JsonObject result = JsonConverter.getJsonObjectForGateway(deviceName, notificationMsg);
-        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_ATTRIBUTES_TOPIC, result));
-    }
-
-    @Override
-    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) throws AdaptorException {
-        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_RPC_REQUESTS_TOPIC + rpcRequest.getRequestId(), JsonConverter.toJson(rpcRequest, false)));
-    }
-
-    @Override
-    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) throws AdaptorException {
-        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_RPC_TOPIC, JsonConverter.toGatewayJson(deviceName, rpcRequest)));
-    }
-
-    @Override
-    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.ToServerRpcResponseMsg rpcResponse) {
-        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_RPC_RESPONSE_TOPIC + rpcResponse.getRequestId(), JsonConverter.toJson(rpcResponse)));
-    }
-
-    private MqttPublishMessage createMqttPublishMsg(MqttDeviceAwareSessionContext ctx, String topic, JsonElement json) {
+    protected MqttPublishMessage createMqttPublishMsg(MqttDeviceAwareSessionContext ctx, String topic, JsonElement json) {
         MqttFixedHeader mqttFixedHeader =
         MqttFixedHeader mqttFixedHeader =
                 new MqttFixedHeader(MqttMessageType.PUBLISH, false, ctx.getQoSForTopic(topic), false, 0);
                 new MqttFixedHeader(MqttMessageType.PUBLISH, false, ctx.getQoSForTopic(topic), false, 0);
         MqttPublishVariableHeader header = new MqttPublishVariableHeader(topic, ctx.nextMsgId());
         MqttPublishVariableHeader header = new MqttPublishVariableHeader(topic, ctx.nextMsgId());
@@ -202,16 +234,6 @@ public class JsonMqttAdaptor implements MqttTransportAdaptor {
         }
         }
     }
     }
 
 
-    public static JsonElement validateJsonPayload(UUID sessionId, ByteBuf payloadData) throws AdaptorException {
-        String payload = validatePayload(sessionId, payloadData, false);
-        try {
-            return new JsonParser().parse(payload);
-        } catch (JsonSyntaxException ex) {
-            log.warn("Payload is in incorrect format: {}", payload);
-            throw new AdaptorException(ex);
-        }
-    }
-
     private static String validatePayload(UUID sessionId, ByteBuf payloadData, boolean isEmptyPayloadAllowed) throws AdaptorException {
     private static String validatePayload(UUID sessionId, ByteBuf payloadData, boolean isEmptyPayloadAllowed) throws AdaptorException {
         String payload = payloadData.toString(UTF8);
         String payload = payloadData.toString(UTF8);
         if (payload == null) {
         if (payload == null) {
@@ -223,4 +245,8 @@ public class JsonMqttAdaptor implements MqttTransportAdaptor {
         return payload;
         return payload;
     }
     }
 
 
+    private int getRequestId(String topicName, String topic) {
+        return Integer.parseInt(topicName.substring(topic.length()));
+    }
+
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.mqtt.adaptors;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.mqtt.MqttFixedHeader;
+import io.netty.handler.codec.mqtt.MqttMessage;
+import io.netty.handler.codec.mqtt.MqttMessageType;
+import io.netty.handler.codec.mqtt.MqttPublishMessage;
+import io.netty.handler.codec.mqtt.MqttPublishVariableHeader;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.transport.adaptor.AdaptorException;
+import org.thingsboard.server.common.transport.adaptor.ProtoConverter;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.transport.mqtt.session.MqttDeviceAwareSessionContext;
+
+import java.util.Optional;
+
+@Component
+@Slf4j
+public class ProtoMqttAdaptor implements MqttTransportAdaptor {
+
+    private static final ByteBufAllocator ALLOCATOR = new UnpooledByteBufAllocator(false);
+
+    @Override
+    public TransportProtos.PostTelemetryMsg convertToPostTelemetry(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        byte[] bytes = toBytes(inbound.payload());
+        try {
+            return ProtoConverter.convertToTelemetryProto(bytes);
+        } catch (InvalidProtocolBufferException | IllegalArgumentException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    @Override
+    public TransportProtos.PostAttributeMsg convertToPostAttributes(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        byte[] bytes = toBytes(inbound.payload());
+        try {
+            return ProtoConverter.validatePostAttributeMsg(bytes);
+        } catch (InvalidProtocolBufferException | IllegalArgumentException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    @Override
+    public TransportProtos.ClaimDeviceMsg convertToClaimDevice(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        byte[] bytes = toBytes(inbound.payload());
+        try {
+            return ProtoConverter.convertToClaimDeviceProto(ctx.getDeviceId(), bytes);
+        } catch (InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    @Override
+    public TransportProtos.GetAttributeRequestMsg convertToGetAttributes(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
+        byte[] bytes = toBytes(inbound.payload());
+        String topicName = inbound.variableHeader().topicName();
+        int requestId = getRequestId(topicName, MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX);
+        try {
+            return ProtoConverter.convertToGetAttributeRequestMessage(bytes, requestId);
+        } catch (InvalidProtocolBufferException e) {
+            log.warn("Failed to decode get attributes request", e);
+            throw new AdaptorException(e);
+        }
+    }
+
+    @Override
+    public TransportProtos.ToDeviceRpcResponseMsg convertToDeviceRpcResponse(MqttDeviceAwareSessionContext ctx, MqttPublishMessage mqttMsg) throws AdaptorException {
+        byte[] bytes = toBytes(mqttMsg.payload());
+        try {
+            return TransportProtos.ToDeviceRpcResponseMsg.parseFrom(bytes);
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            log.warn("Failed to decode Rpc response", e);
+            throw new AdaptorException(e);
+        }
+    }
+
+    @Override
+    public TransportProtos.ToServerRpcRequestMsg convertToServerRpcRequest(MqttDeviceAwareSessionContext ctx, MqttPublishMessage mqttMsg) throws AdaptorException {
+        byte[] bytes = toBytes(mqttMsg.payload());
+        String topicName = mqttMsg.variableHeader().topicName();
+        try {
+            int requestId = getRequestId(topicName, MqttTopics.DEVICE_RPC_REQUESTS_TOPIC);
+            return ProtoConverter.convertToServerRpcRequest(bytes, requestId);
+        } catch (InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+        if (!StringUtils.isEmpty(responseMsg.getError())) {
+            throw new AdaptorException(responseMsg.getError());
+        } else {
+            int requestId = responseMsg.getRequestId();
+            if (requestId >= 0) {
+                return Optional.of(createMqttPublishMsg(ctx,
+                        MqttTopics.DEVICE_ATTRIBUTES_RESPONSE_TOPIC_PREFIX + requestId,
+                        responseMsg.toByteArray()));
+            }
+            return Optional.empty();
+        }
+    }
+
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_RPC_REQUESTS_TOPIC + rpcRequest.getRequestId(), rpcRequest.toByteArray()));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.ToServerRpcResponseMsg rpcResponse) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_RPC_RESPONSE_TOPIC + rpcResponse.getRequestId(), rpcResponse.toByteArray()));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.AttributeUpdateNotificationMsg notificationMsg) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_ATTRIBUTES_TOPIC, notificationMsg.toByteArray()));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+        if (!StringUtils.isEmpty(responseMsg.getError())) {
+            throw new AdaptorException(responseMsg.getError());
+        } else {
+            TransportApiProtos.GatewayAttributeResponseMsg.Builder responseMsgBuilder = TransportApiProtos.GatewayAttributeResponseMsg.newBuilder();
+            responseMsgBuilder.setDeviceName(deviceName);
+            responseMsgBuilder.setResponseMsg(responseMsg);
+            byte[] payloadBytes = responseMsgBuilder.build().toByteArray();
+            return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC, payloadBytes));
+        }
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.AttributeUpdateNotificationMsg notificationMsg) {
+        TransportApiProtos.GatewayAttributeUpdateNotificationMsg.Builder builder = TransportApiProtos.GatewayAttributeUpdateNotificationMsg.newBuilder();
+        builder.setDeviceName(deviceName);
+        builder.setNotificationMsg(notificationMsg);
+        byte[] payloadBytes = builder.build().toByteArray();
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_ATTRIBUTES_TOPIC, payloadBytes));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
+        TransportApiProtos.GatewayDeviceRpcRequestMsg.Builder builder = TransportApiProtos.GatewayDeviceRpcRequestMsg.newBuilder();
+        builder.setDeviceName(deviceName);
+        builder.setRpcRequestMsg(rpcRequest);
+        byte[] payloadBytes = builder.build().toByteArray();
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_RPC_TOPIC, payloadBytes));
+    }
+
+    public static byte[] toBytes(ByteBuf inbound) {
+        byte[] bytes = new byte[inbound.readableBytes()];
+        int readerIndex = inbound.readerIndex();
+        inbound.getBytes(readerIndex, bytes);
+        return bytes;
+    }
+
+    private MqttPublishMessage createMqttPublishMsg(MqttDeviceAwareSessionContext ctx, String topic, byte[] payloadBytes) {
+        MqttFixedHeader mqttFixedHeader =
+                new MqttFixedHeader(MqttMessageType.PUBLISH, false, ctx.getQoSForTopic(topic), false, 0);
+        MqttPublishVariableHeader header = new MqttPublishVariableHeader(topic, ctx.nextMsgId());
+        ByteBuf payload = ALLOCATOR.buffer();
+        payload.writeBytes(payloadBytes);
+        return new MqttPublishMessage(mqttFixedHeader, header, payload);
+    }
+
+    private int getRequestId(String topicName, String topic) {
+        return Integer.parseInt(topicName.substring(topic.length()));
+    }
+
+}

@@ -20,9 +20,11 @@ import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.TransportPayloadType;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration;
-import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.transport.mqtt.MqttTransportContext;
+import org.thingsboard.server.transport.mqtt.adaptors.MqttTransportAdaptor;
 import org.thingsboard.server.transport.mqtt.util.MqttTopicFilter;
 import org.thingsboard.server.transport.mqtt.util.MqttTopicFilter;
 import org.thingsboard.server.transport.mqtt.util.MqttTopicFilterFactory;
 import org.thingsboard.server.transport.mqtt.util.MqttTopicFilterFactory;
 
 
@@ -38,14 +40,19 @@ public class DeviceSessionCtx extends MqttDeviceAwareSessionContext {
 
 
     @Getter
     @Getter
     private ChannelHandlerContext channel;
     private ChannelHandlerContext channel;
+
+    @Getter
+    private MqttTransportContext context;
+
     private final AtomicInteger msgIdSeq = new AtomicInteger(0);
     private final AtomicInteger msgIdSeq = new AtomicInteger(0);
 
 
     private volatile MqttTopicFilter telemetryTopicFilter = MqttTopicFilterFactory.getDefaultTelemetryFilter();
     private volatile MqttTopicFilter telemetryTopicFilter = MqttTopicFilterFactory.getDefaultTelemetryFilter();
     private volatile MqttTopicFilter attributesTopicFilter = MqttTopicFilterFactory.getDefaultAttributesFilter();
     private volatile MqttTopicFilter attributesTopicFilter = MqttTopicFilterFactory.getDefaultAttributesFilter();
+    private volatile TransportPayloadType payloadType = TransportPayloadType.JSON;
 
 
-
-    public DeviceSessionCtx(UUID sessionId, ConcurrentMap<MqttTopicMatcher, Integer> mqttQoSMap) {
+    public DeviceSessionCtx(UUID sessionId, ConcurrentMap<MqttTopicMatcher, Integer> mqttQoSMap, MqttTransportContext context) {
         super(sessionId, mqttQoSMap);
         super(sessionId, mqttQoSMap);
+        this.context = context;
     }
     }
 
 
     public void setChannel(ChannelHandlerContext channel) {
     public void setChannel(ChannelHandlerContext channel) {
@@ -56,14 +63,20 @@ public class DeviceSessionCtx extends MqttDeviceAwareSessionContext {
         return msgIdSeq.incrementAndGet();
         return msgIdSeq.incrementAndGet();
     }
     }
 
 
-    public boolean isDeviceTelemetryTopic(String topicName) {
-        return telemetryTopicFilter.filter(topicName);
-    }
+    public boolean isDeviceTelemetryTopic(String topicName) { return telemetryTopicFilter.filter(topicName); }
 
 
     public boolean isDeviceAttributesTopic(String topicName) {
     public boolean isDeviceAttributesTopic(String topicName) {
         return attributesTopicFilter.filter(topicName);
         return attributesTopicFilter.filter(topicName);
     }
     }
 
 
+    public MqttTransportAdaptor getPayloadAdaptor() {
+        return payloadType.equals(TransportPayloadType.JSON) ? context.getJsonMqttAdaptor() : context.getProtoMqttAdaptor();
+    }
+
+    public boolean isJsonPayloadType() {
+        return payloadType.equals(TransportPayloadType.JSON);
+    }
+
     @Override
     @Override
     public void setDeviceProfile(DeviceProfile deviceProfile) {
     public void setDeviceProfile(DeviceProfile deviceProfile) {
         super.setDeviceProfile(deviceProfile);
         super.setDeviceProfile(deviceProfile);
@@ -76,11 +89,13 @@ public class DeviceSessionCtx extends MqttDeviceAwareSessionContext {
         updateTopicFilters(deviceProfile);
         updateTopicFilters(deviceProfile);
     }
     }
 
 
+
     private void updateTopicFilters(DeviceProfile deviceProfile) {
     private void updateTopicFilters(DeviceProfile deviceProfile) {
         DeviceProfileTransportConfiguration transportConfiguration = deviceProfile.getProfileData().getTransportConfiguration();
         DeviceProfileTransportConfiguration transportConfiguration = deviceProfile.getProfileData().getTransportConfiguration();
         if (transportConfiguration.getType().equals(DeviceTransportType.MQTT) &&
         if (transportConfiguration.getType().equals(DeviceTransportType.MQTT) &&
                 transportConfiguration instanceof MqttDeviceProfileTransportConfiguration) {
                 transportConfiguration instanceof MqttDeviceProfileTransportConfiguration) {
             MqttDeviceProfileTransportConfiguration mqttConfig = (MqttDeviceProfileTransportConfiguration) transportConfiguration;
             MqttDeviceProfileTransportConfiguration mqttConfig = (MqttDeviceProfileTransportConfiguration) transportConfiguration;
+            payloadType = mqttConfig.getTransportPayloadType();
             telemetryTopicFilter = MqttTopicFilterFactory.toFilter(mqttConfig.getDeviceTelemetryTopic());
             telemetryTopicFilter = MqttTopicFilterFactory.toFilter(mqttConfig.getDeviceTelemetryTopic());
             attributesTopicFilter = MqttTopicFilterFactory.toFilter(mqttConfig.getDeviceAttributesTopic());
             attributesTopicFilter = MqttTopicFilterFactory.toFilter(mqttConfig.getDeviceAttributesTopic());
         } else {
         } else {
@@ -88,4 +103,5 @@ public class DeviceSessionCtx extends MqttDeviceAwareSessionContext {
             attributesTopicFilter = MqttTopicFilterFactory.getDefaultAttributesFilter();
             attributesTopicFilter = MqttTopicFilterFactory.getDefaultAttributesFilter();
         }
         }
     }
     }
+
 }
 }

@@ -20,7 +20,6 @@ import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.transport.SessionMsgListener;
 import org.thingsboard.server.common.transport.SessionMsgListener;
 import org.thingsboard.server.common.transport.auth.TransportDeviceInfo;
 import org.thingsboard.server.common.transport.auth.TransportDeviceInfo;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 
 
 import java.util.UUID;
 import java.util.UUID;
@@ -70,7 +69,7 @@ public class GatewayDeviceSessionCtx extends MqttDeviceAwareSessionContext imple
     @Override
     @Override
     public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg response) {
     public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg response) {
         try {
         try {
-            parent.getAdaptor().convertToGatewayPublish(this, getDeviceInfo().getDeviceName(), response).ifPresent(parent::writeAndFlush);
+            parent.getPayloadAdaptor().convertToGatewayPublish(this, getDeviceInfo().getDeviceName(), response).ifPresent(parent::writeAndFlush);
         } catch (Exception e) {
         } catch (Exception e) {
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
         }
         }
@@ -79,27 +78,27 @@ public class GatewayDeviceSessionCtx extends MqttDeviceAwareSessionContext imple
     @Override
     @Override
     public void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg notification) {
     public void onAttributeUpdate(TransportProtos.AttributeUpdateNotificationMsg notification) {
         try {
         try {
-            parent.getAdaptor().convertToGatewayPublish(this, getDeviceInfo().getDeviceName(), notification).ifPresent(parent::writeAndFlush);
+            parent.getPayloadAdaptor().convertToGatewayPublish(this, getDeviceInfo().getDeviceName(), notification).ifPresent(parent::writeAndFlush);
         } catch (Exception e) {
         } catch (Exception e) {
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public void onRemoteSessionCloseCommand(TransportProtos.SessionCloseNotificationProto sessionCloseNotification) {
-        parent.deregisterSession(getDeviceInfo().getDeviceName());
-    }
-
-    @Override
     public void onToDeviceRpcRequest(TransportProtos.ToDeviceRpcRequestMsg request) {
     public void onToDeviceRpcRequest(TransportProtos.ToDeviceRpcRequestMsg request) {
         try {
         try {
-            parent.getAdaptor().convertToGatewayPublish(this, getDeviceInfo().getDeviceName(), request).ifPresent(parent::writeAndFlush);
+            parent.getPayloadAdaptor().convertToGatewayPublish(this, getDeviceInfo().getDeviceName(), request).ifPresent(parent::writeAndFlush);
         } catch (Exception e) {
         } catch (Exception e) {
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
             log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
         }
         }
     }
     }
 
 
     @Override
     @Override
+    public void onRemoteSessionCloseCommand(TransportProtos.SessionCloseNotificationProto sessionCloseNotification) {
+        parent.deregisterSession(getDeviceInfo().getDeviceName());
+    }
+
+    @Override
     public void onToServerRpcResponse(TransportProtos.ToServerRpcResponseMsg toServerResponse) {
     public void onToServerRpcResponse(TransportProtos.ToServerRpcResponseMsg toServerResponse) {
         // This feature is not supported in the TB IoT Gateway yet.
         // This feature is not supported in the TB IoT Gateway yet.
     }
     }

@@ -25,32 +25,38 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonNull;
 import com.google.gson.JsonNull;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonSyntaxException;
 import com.google.gson.JsonSyntaxException;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.ProtocolStringList;
+import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.mqtt.MqttMessage;
 import io.netty.handler.codec.mqtt.MqttMessage;
 import io.netty.handler.codec.mqtt.MqttPublishMessage;
 import io.netty.handler.codec.mqtt.MqttPublishMessage;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.util.CollectionUtils;
 import org.springframework.util.StringUtils;
 import org.springframework.util.StringUtils;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.transport.TransportService;
 import org.thingsboard.server.common.transport.TransportService;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.common.transport.adaptor.AdaptorException;
 import org.thingsboard.server.common.transport.adaptor.AdaptorException;
 import org.thingsboard.server.common.transport.adaptor.JsonConverter;
 import org.thingsboard.server.common.transport.adaptor.JsonConverter;
+import org.thingsboard.server.common.transport.adaptor.ProtoConverter;
 import org.thingsboard.server.common.transport.auth.GetOrCreateDeviceFromGatewayResponse;
 import org.thingsboard.server.common.transport.auth.GetOrCreateDeviceFromGatewayResponse;
 import org.thingsboard.server.common.transport.auth.TransportDeviceInfo;
 import org.thingsboard.server.common.transport.auth.TransportDeviceInfo;
 import org.thingsboard.server.common.transport.service.DefaultTransportService;
 import org.thingsboard.server.common.transport.service.DefaultTransportService;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayRequestMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
 import org.thingsboard.server.transport.mqtt.MqttTransportContext;
 import org.thingsboard.server.transport.mqtt.MqttTransportContext;
 import org.thingsboard.server.transport.mqtt.MqttTransportHandler;
 import org.thingsboard.server.transport.mqtt.MqttTransportHandler;
 import org.thingsboard.server.transport.mqtt.adaptors.JsonMqttAdaptor;
 import org.thingsboard.server.transport.mqtt.adaptors.JsonMqttAdaptor;
 import org.thingsboard.server.transport.mqtt.adaptors.MqttTransportAdaptor;
 import org.thingsboard.server.transport.mqtt.adaptors.MqttTransportAdaptor;
+import org.thingsboard.server.transport.mqtt.adaptors.ProtoMqttAdaptor;
 
 
 import javax.annotation.Nullable;
 import javax.annotation.Nullable;
 import java.util.Collections;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Map;
 import java.util.Set;
 import java.util.Set;
 import java.util.UUID;
 import java.util.UUID;
@@ -80,8 +86,8 @@ public class GatewaySessionHandler {
     private final ChannelHandlerContext channel;
     private final ChannelHandlerContext channel;
     private final DeviceSessionCtx deviceSessionCtx;
     private final DeviceSessionCtx deviceSessionCtx;
 
 
-    public GatewaySessionHandler(MqttTransportContext context, DeviceSessionCtx deviceSessionCtx, UUID sessionId) {
-        this.context = context;
+    public GatewaySessionHandler(DeviceSessionCtx deviceSessionCtx, UUID sessionId) {
+        this.context = deviceSessionCtx.getContext();
         this.transportService = context.getTransportService();
         this.transportService = context.getTransportService();
         this.deviceSessionCtx = deviceSessionCtx;
         this.deviceSessionCtx = deviceSessionCtx;
         this.gateway = deviceSessionCtx.getDeviceInfo();
         this.gateway = deviceSessionCtx.getDeviceInfo();
@@ -93,10 +99,108 @@ public class GatewaySessionHandler {
         this.channel = deviceSessionCtx.getChannel();
         this.channel = deviceSessionCtx.getChannel();
     }
     }
 
 
-    public void onDeviceConnect(MqttPublishMessage msg) throws AdaptorException {
-        JsonElement json = getJson(msg);
-        String deviceName = checkDeviceName(getDeviceName(json));
-        String deviceType = getDeviceType(json);
+    public void onDeviceConnect(MqttPublishMessage mqttMsg) throws AdaptorException {
+        if (isJsonPayloadType()) {
+            onDeviceConnectJson(mqttMsg);
+        } else {
+            onDeviceConnectProto(mqttMsg);
+        }
+    }
+
+    public void onDeviceDisconnect(MqttPublishMessage mqttMsg) throws AdaptorException {
+        if (isJsonPayloadType()) {
+            onDeviceDisconnectJson(mqttMsg);
+        } else {
+            onDeviceDisconnectProto(mqttMsg);
+        }
+    }
+
+    public void onDeviceTelemetry(MqttPublishMessage mqttMsg) throws AdaptorException {
+        int msgId = getMsgId(mqttMsg);
+        ByteBuf payload = mqttMsg.payload();
+        if (isJsonPayloadType()) {
+            onDeviceTelemetryJson(msgId, payload);
+        } else {
+            onDeviceTelemetryProto(msgId, payload);
+        }
+    }
+
+    public void onDeviceClaim(MqttPublishMessage mqttMsg) throws AdaptorException {
+        int msgId = getMsgId(mqttMsg);
+        ByteBuf payload = mqttMsg.payload();
+        if (isJsonPayloadType()) {
+            onDeviceClaimJson(msgId, payload);
+        } else {
+            onDeviceClaimProto(msgId, payload);
+        }
+    }
+
+    public void onDeviceAttributes(MqttPublishMessage mqttMsg) throws AdaptorException {
+        int msgId = getMsgId(mqttMsg);
+        ByteBuf payload = mqttMsg.payload();
+        if (isJsonPayloadType()) {
+            onDeviceAttributesJson(msgId, payload);
+        } else {
+            onDeviceAttributesProto(msgId, payload);
+        }
+    }
+
+    public void onDeviceAttributesRequest(MqttPublishMessage mqttMsg) throws AdaptorException {
+        if (isJsonPayloadType()) {
+            onDeviceAttributesRequestJson(mqttMsg);
+        } else {
+            onDeviceAttributesRequestProto(mqttMsg);
+        }
+    }
+
+    public void onDeviceRpcResponse(MqttPublishMessage mqttMsg) throws AdaptorException {
+        int msgId = getMsgId(mqttMsg);
+        ByteBuf payload = mqttMsg.payload();
+        if (isJsonPayloadType()) {
+            onDeviceRpcResponseJson(msgId, payload);
+        } else {
+            onDeviceRpcResponseProto(msgId, payload);
+        }
+    }
+
+    public void onGatewayDisconnect() {
+        devices.forEach(this::deregisterSession);
+    }
+
+    public String getNodeId() {
+        return context.getNodeId();
+    }
+
+    public UUID getSessionId() {
+        return sessionId;
+    }
+
+    public MqttTransportAdaptor getPayloadAdaptor() {
+        return deviceSessionCtx.getPayloadAdaptor();
+    }
+
+    void deregisterSession(String deviceName) {
+        GatewayDeviceSessionCtx deviceSessionCtx = devices.remove(deviceName);
+        if (deviceSessionCtx != null) {
+            deregisterSession(deviceName, deviceSessionCtx);
+        } else {
+            log.debug("[{}] Device [{}] was already removed from the gateway session", sessionId, deviceName);
+        }
+    }
+
+    void writeAndFlush(MqttMessage mqttMessage) {
+        channel.writeAndFlush(mqttMessage);
+    }
+
+    int nextMsgId() {
+        return deviceSessionCtx.nextMsgId();
+    }
+
+    private boolean isJsonPayloadType() {
+        return deviceSessionCtx.isJsonPayloadType();
+    }
+
+    private void processOnConnect(MqttPublishMessage msg, String deviceName, String deviceType) {
         log.trace("[{}] onDeviceConnect: {}", sessionId, deviceName);
         log.trace("[{}] onDeviceConnect: {}", sessionId, deviceName);
         Futures.addCallback(onDeviceConnect(deviceName, deviceType), new FutureCallback<GatewayDeviceSessionCtx>() {
         Futures.addCallback(onDeviceConnect(deviceName, deviceType), new FutureCallback<GatewayDeviceSessionCtx>() {
             @Override
             @Override
@@ -183,28 +287,50 @@ public class GatewaySessionHandler {
         return future;
         return future;
     }
     }
 
 
-    public void onDeviceDisconnect(MqttPublishMessage msg) throws AdaptorException {
+    private int getMsgId(MqttPublishMessage mqttMsg) {
+        return mqttMsg.variableHeader().packetId();
+    }
+
+    private void onDeviceConnectJson(MqttPublishMessage mqttMsg) throws AdaptorException {
+        JsonElement json = getJson(mqttMsg);
+        String deviceName = checkDeviceName(getDeviceName(json));
+        String deviceType = getDeviceType(json);
+        processOnConnect(mqttMsg, deviceName, deviceType);
+    }
+
+    private void onDeviceConnectProto(MqttPublishMessage mqttMsg) throws AdaptorException {
+        try {
+            TransportApiProtos.ConnectMsg connectProto = TransportApiProtos.ConnectMsg.parseFrom(getBytes(mqttMsg.payload()));
+            String deviceName = checkDeviceName(connectProto.getDeviceName());
+            String deviceType = StringUtils.isEmpty(connectProto.getDeviceType()) ? DEFAULT_DEVICE_TYPE : connectProto.getDeviceType();
+            processOnConnect(mqttMsg, deviceName, deviceType);
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    private void onDeviceDisconnectJson(MqttPublishMessage msg) throws AdaptorException {
         String deviceName = checkDeviceName(getDeviceName(getJson(msg)));
         String deviceName = checkDeviceName(getDeviceName(getJson(msg)));
-        deregisterSession(deviceName);
-        ack(msg);
+        processOnDisconnect(msg, deviceName);
     }
     }
 
 
-    void deregisterSession(String deviceName) {
-        GatewayDeviceSessionCtx deviceSessionCtx = devices.remove(deviceName);
-        if (deviceSessionCtx != null) {
-            deregisterSession(deviceName, deviceSessionCtx);
-        } else {
-            log.debug("[{}] Device [{}] was already removed from the gateway session", sessionId, deviceName);
+    private void onDeviceDisconnectProto(MqttPublishMessage mqttMsg) throws AdaptorException {
+        try {
+            TransportApiProtos.DisconnectMsg connectProto = TransportApiProtos.DisconnectMsg.parseFrom(getBytes(mqttMsg.payload()));
+            String deviceName = checkDeviceName(connectProto.getDeviceName());
+            processOnDisconnect(mqttMsg, deviceName);
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
         }
         }
     }
     }
 
 
-    public void onGatewayDisconnect() {
-        devices.forEach(this::deregisterSession);
+    private void processOnDisconnect(MqttPublishMessage msg, String deviceName) {
+        deregisterSession(deviceName);
+        ack(msg);
     }
     }
 
 
-    public void onDeviceTelemetry(MqttPublishMessage mqttMsg) throws AdaptorException {
-        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, mqttMsg.payload());
-        int msgId = mqttMsg.variableHeader().packetId();
+    private void onDeviceTelemetryJson(int msgId, ByteBuf payload) throws AdaptorException {
+        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, payload);
         if (json.isJsonObject()) {
         if (json.isJsonObject()) {
             JsonObject jsonObj = json.getAsJsonObject();
             JsonObject jsonObj = json.getAsJsonObject();
             for (Map.Entry<String, JsonElement> deviceEntry : jsonObj.entrySet()) {
             for (Map.Entry<String, JsonElement> deviceEntry : jsonObj.entrySet()) {
@@ -218,7 +344,7 @@ public class GatewaySessionHandler {
                                 }
                                 }
                                 try {
                                 try {
                                     TransportProtos.PostTelemetryMsg postTelemetryMsg = JsonConverter.convertToTelemetryProto(deviceEntry.getValue().getAsJsonArray());
                                     TransportProtos.PostTelemetryMsg postTelemetryMsg = JsonConverter.convertToTelemetryProto(deviceEntry.getValue().getAsJsonArray());
-                                    transportService.process(deviceCtx.getSessionInfo(), postTelemetryMsg, getPubAckCallback(channel, deviceName, msgId, postTelemetryMsg));
+                                    processPostTelemetryMsg(deviceCtx, postTelemetryMsg, deviceName, msgId);
                                 } catch (Throwable e) {
                                 } catch (Throwable e) {
                                     log.warn("[{}][{}] Failed to convert telemetry: {}", gateway.getDeviceId(), deviceName, deviceEntry.getValue(), e);
                                     log.warn("[{}][{}] Failed to convert telemetry: {}", gateway.getDeviceId(), deviceName, deviceEntry.getValue(), e);
                                 }
                                 }
@@ -235,9 +361,47 @@ public class GatewaySessionHandler {
         }
         }
     }
     }
 
 
-    public void onDeviceClaim(MqttPublishMessage mqttMsg) throws AdaptorException {
-        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, mqttMsg.payload());
-        int msgId = mqttMsg.variableHeader().packetId();
+    private void onDeviceTelemetryProto(int msgId, ByteBuf payload) throws AdaptorException {
+        try {
+            TransportApiProtos.GatewayTelemetryMsg telemetryMsgProto = TransportApiProtos.GatewayTelemetryMsg.parseFrom(getBytes(payload));
+            List<TransportApiProtos.TelemetryMsg> deviceMsgList = telemetryMsgProto.getMsgList();
+            if (!CollectionUtils.isEmpty(deviceMsgList)) {
+                deviceMsgList.forEach(telemetryMsg -> {
+                    String deviceName = checkDeviceName(telemetryMsg.getDeviceName());
+                    Futures.addCallback(checkDeviceConnected(deviceName),
+                            new FutureCallback<GatewayDeviceSessionCtx>() {
+                                @Override
+                                public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
+                                    TransportProtos.PostTelemetryMsg msg = telemetryMsg.getMsg();
+                                    try {
+                                        TransportProtos.PostTelemetryMsg postTelemetryMsg = ProtoConverter.validatePostTelemetryMsg(msg.toByteArray());
+                                        processPostTelemetryMsg(deviceCtx, postTelemetryMsg, deviceName, msgId);
+                                    } catch (Throwable e) {
+                                        log.warn("[{}][{}] Failed to convert telemetry: {}", gateway.getDeviceId(), deviceName, msg, e);
+                                    }
+                                }
+
+                                @Override
+                                public void onFailure(Throwable t) {
+                                    log.debug("[{}] Failed to process device telemetry command: {}", sessionId, deviceName, t);
+                                }
+                            }, context.getExecutor());
+                });
+            } else {
+                log.debug("[{}] Devices telemetry messages is empty for: [{}]", sessionId, gateway.getDeviceId());
+                throw new IllegalArgumentException("[" + sessionId + "] Devices telemetry messages is empty for [" + gateway.getDeviceId() + "]");
+            }
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    private void processPostTelemetryMsg(GatewayDeviceSessionCtx deviceCtx, TransportProtos.PostTelemetryMsg postTelemetryMsg, String deviceName, int msgId) {
+        transportService.process(deviceCtx.getSessionInfo(), postTelemetryMsg, getPubAckCallback(channel, deviceName, msgId, postTelemetryMsg));
+    }
+
+    private void onDeviceClaimJson(int msgId, ByteBuf payload) throws AdaptorException {
+        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, payload);
         if (json.isJsonObject()) {
         if (json.isJsonObject()) {
             JsonObject jsonObj = json.getAsJsonObject();
             JsonObject jsonObj = json.getAsJsonObject();
             for (Map.Entry<String, JsonElement> deviceEntry : jsonObj.entrySet()) {
             for (Map.Entry<String, JsonElement> deviceEntry : jsonObj.entrySet()) {
@@ -252,7 +416,7 @@ public class GatewaySessionHandler {
                                 try {
                                 try {
                                     DeviceId deviceId = deviceCtx.getDeviceId();
                                     DeviceId deviceId = deviceCtx.getDeviceId();
                                     TransportProtos.ClaimDeviceMsg claimDeviceMsg = JsonConverter.convertToClaimDeviceProto(deviceId, deviceEntry.getValue());
                                     TransportProtos.ClaimDeviceMsg claimDeviceMsg = JsonConverter.convertToClaimDeviceProto(deviceId, deviceEntry.getValue());
-                                    transportService.process(deviceCtx.getSessionInfo(), claimDeviceMsg, getPubAckCallback(channel, deviceName, msgId, claimDeviceMsg));
+                                    processClaimDeviceMsg(deviceCtx, claimDeviceMsg, deviceName, msgId);
                                 } catch (Throwable e) {
                                 } catch (Throwable e) {
                                     log.warn("[{}][{}] Failed to convert claim message: {}", gateway.getDeviceId(), deviceName, deviceEntry.getValue(), e);
                                     log.warn("[{}][{}] Failed to convert claim message: {}", gateway.getDeviceId(), deviceName, deviceEntry.getValue(), e);
                                 }
                                 }
@@ -269,9 +433,51 @@ public class GatewaySessionHandler {
         }
         }
     }
     }
 
 
-    public void onDeviceAttributes(MqttPublishMessage mqttMsg) throws AdaptorException {
-        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, mqttMsg.payload());
-        int msgId = mqttMsg.variableHeader().packetId();
+    private void onDeviceClaimProto(int msgId, ByteBuf payload) throws AdaptorException {
+        try {
+            TransportApiProtos.GatewayClaimMsg claimMsgProto = TransportApiProtos.GatewayClaimMsg.parseFrom(getBytes(payload));
+            List<TransportApiProtos.ClaimDeviceMsg> claimMsgList = claimMsgProto.getMsgList();
+            if (!CollectionUtils.isEmpty(claimMsgList)) {
+                claimMsgList.forEach(claimDeviceMsg -> {
+                    String deviceName = checkDeviceName(claimDeviceMsg.getDeviceName());
+                    Futures.addCallback(checkDeviceConnected(deviceName),
+                            new FutureCallback<GatewayDeviceSessionCtx>() {
+                                @Override
+                                public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
+                                    TransportApiProtos.ClaimDevice claimRequest = claimDeviceMsg.getClaimRequest();
+                                    if (claimRequest == null) {
+                                        throw new IllegalArgumentException("Claim request for device: " + deviceName + " is null!");
+                                    }
+                                    try {
+                                        DeviceId deviceId = deviceCtx.getDeviceId();
+                                        TransportProtos.ClaimDeviceMsg claimDeviceMsg = ProtoConverter.convertToClaimDeviceProto(deviceId, claimRequest.toByteArray());
+                                        processClaimDeviceMsg(deviceCtx, claimDeviceMsg, deviceName, msgId);
+                                    } catch (Throwable e) {
+                                        log.warn("[{}][{}] Failed to convert claim message: {}", gateway.getDeviceId(), deviceName, claimRequest, e);
+                                    }
+                                }
+
+                                @Override
+                                public void onFailure(Throwable t) {
+                                    log.debug("[{}] Failed to process device claiming command: {}", sessionId, deviceName, t);
+                                }
+                            }, context.getExecutor());
+                });
+            } else {
+                log.debug("[{}] Devices claim messages is empty for: [{}]", sessionId, gateway.getDeviceId());
+                throw new IllegalArgumentException("[" + sessionId + "] Devices claim messages is empty for [" + gateway.getDeviceId() + "]");
+            }
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    private void processClaimDeviceMsg(GatewayDeviceSessionCtx deviceCtx, TransportProtos.ClaimDeviceMsg claimDeviceMsg, String deviceName, int msgId) {
+        transportService.process(deviceCtx.getSessionInfo(), claimDeviceMsg, getPubAckCallback(channel, deviceName, msgId, claimDeviceMsg));
+    }
+
+    private void onDeviceAttributesJson(int msgId, ByteBuf payload) throws AdaptorException {
+        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, payload);
         if (json.isJsonObject()) {
         if (json.isJsonObject()) {
             JsonObject jsonObj = json.getAsJsonObject();
             JsonObject jsonObj = json.getAsJsonObject();
             for (Map.Entry<String, JsonElement> deviceEntry : jsonObj.entrySet()) {
             for (Map.Entry<String, JsonElement> deviceEntry : jsonObj.entrySet()) {
@@ -284,7 +490,7 @@ public class GatewaySessionHandler {
                                     throw new JsonSyntaxException(CAN_T_PARSE_VALUE + json);
                                     throw new JsonSyntaxException(CAN_T_PARSE_VALUE + json);
                                 }
                                 }
                                 TransportProtos.PostAttributeMsg postAttributeMsg = JsonConverter.convertToAttributesProto(deviceEntry.getValue().getAsJsonObject());
                                 TransportProtos.PostAttributeMsg postAttributeMsg = JsonConverter.convertToAttributesProto(deviceEntry.getValue().getAsJsonObject());
-                                transportService.process(deviceCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(channel, deviceName, msgId, postAttributeMsg));
+                                processPostAttributesMsg(deviceCtx, postAttributeMsg, deviceName, msgId);
                             }
                             }
 
 
                             @Override
                             @Override
@@ -298,34 +504,49 @@ public class GatewaySessionHandler {
         }
         }
     }
     }
 
 
-    public void onDeviceRpcResponse(MqttPublishMessage mqttMsg) throws AdaptorException {
-        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, mqttMsg.payload());
-        int msgId = mqttMsg.variableHeader().packetId();
-        if (json.isJsonObject()) {
-            JsonObject jsonObj = json.getAsJsonObject();
-            String deviceName = jsonObj.get(DEVICE_PROPERTY).getAsString();
-            Futures.addCallback(checkDeviceConnected(deviceName),
-                    new FutureCallback<GatewayDeviceSessionCtx>() {
-                        @Override
-                        public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
-                            Integer requestId = jsonObj.get("id").getAsInt();
-                            String data = jsonObj.get("data").toString();
-                            TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = TransportProtos.ToDeviceRpcResponseMsg.newBuilder()
-                                    .setRequestId(requestId).setPayload(data).build();
-                            transportService.process(deviceCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(channel, deviceName, msgId, rpcResponseMsg));
-                        }
+    private void onDeviceAttributesProto(int msgId, ByteBuf payload) throws AdaptorException {
+        try {
+            TransportApiProtos.GatewayAttributesMsg attributesMsgProto = TransportApiProtos.GatewayAttributesMsg.parseFrom(getBytes(payload));
+            List<TransportApiProtos.AttributesMsg> attributesMsgList = attributesMsgProto.getMsgList();
+            if (!CollectionUtils.isEmpty(attributesMsgList)) {
+                attributesMsgList.forEach(attributesMsg -> {
+                    String deviceName = checkDeviceName(attributesMsg.getDeviceName());
+                    Futures.addCallback(checkDeviceConnected(deviceName),
+                            new FutureCallback<GatewayDeviceSessionCtx>() {
+                                @Override
+                                public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
+                                    TransportProtos.PostAttributeMsg kvListProto = attributesMsg.getMsg();
+                                    if (kvListProto == null) {
+                                        throw new IllegalArgumentException("Attributes List for device: " + deviceName + " is empty!");
+                                    }
+                                    try {
+                                        TransportProtos.PostAttributeMsg postAttributeMsg = ProtoConverter.validatePostAttributeMsg(kvListProto.toByteArray());
+                                        processPostAttributesMsg(deviceCtx, postAttributeMsg, deviceName, msgId);
+                                    } catch (Throwable e) {
+                                        log.warn("[{}][{}] Failed to process device attributes command: {}", gateway.getDeviceId(), deviceName, kvListProto, e);
+                                    }
+                                }
 
 
-                        @Override
-                        public void onFailure(Throwable t) {
-                            log.debug("[{}] Failed to process device teleemtry command: {}", sessionId, deviceName, t);
-                        }
-                    }, context.getExecutor());
-        } else {
-            throw new JsonSyntaxException(CAN_T_PARSE_VALUE + json);
+                                @Override
+                                public void onFailure(Throwable t) {
+                                    log.debug("[{}] Failed to process device attributes command: {}", sessionId, deviceName, t);
+                                }
+                            }, context.getExecutor());
+                });
+            } else {
+                log.debug("[{}] Devices attributes keys list is empty for: [{}]", sessionId, gateway.getDeviceId());
+                throw new IllegalArgumentException("[" + sessionId + "] Devices attributes keys list is empty for [" + gateway.getDeviceId() + "]");
+            }
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
         }
         }
     }
     }
 
 
-    public void onDeviceAttributesRequest(MqttPublishMessage msg) throws AdaptorException {
+    private void processPostAttributesMsg(GatewayDeviceSessionCtx deviceCtx, TransportProtos.PostAttributeMsg postAttributeMsg, String deviceName, int msgId) {
+        transportService.process(deviceCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(channel, deviceName, msgId, postAttributeMsg));
+    }
+
+    private void onDeviceAttributesRequestJson(MqttPublishMessage msg) throws AdaptorException {
         JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, msg.payload());
         JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, msg.payload());
         if (json.isJsonObject()) {
         if (json.isJsonObject()) {
             JsonObject jsonObj = json.getAsJsonObject();
             JsonObject jsonObj = json.getAsJsonObject();
@@ -342,27 +563,47 @@ public class GatewaySessionHandler {
                     keys.add(keyObj.getAsString());
                     keys.add(keyObj.getAsString());
                 }
                 }
             }
             }
-            TransportProtos.GetAttributeRequestMsg.Builder result = TransportProtos.GetAttributeRequestMsg.newBuilder();
-            result.setRequestId(requestId);
+            TransportProtos.GetAttributeRequestMsg requestMsg = toGetAttributeRequestMsg(requestId, clientScope, keys);
+            processGetAttributeRequestMessage(msg, deviceName, requestMsg);
+        } else {
+            throw new JsonSyntaxException(CAN_T_PARSE_VALUE + json);
+        }
+    }
 
 
-            if (clientScope) {
-                result.addAllClientAttributeNames(keys);
-            } else {
-                result.addAllSharedAttributeNames(keys);
-            }
-            TransportProtos.GetAttributeRequestMsg requestMsg = result.build();
-            int msgId = msg.variableHeader().packetId();
+    private void onDeviceAttributesRequestProto(MqttPublishMessage mqttMsg) throws AdaptorException {
+        try {
+            TransportApiProtos.GatewayAttributesRequestMsg gatewayAttributesRequestMsg = TransportApiProtos.GatewayAttributesRequestMsg.parseFrom(getBytes(mqttMsg.payload()));
+            String deviceName = checkDeviceName(gatewayAttributesRequestMsg.getDeviceName());
+            int requestId = gatewayAttributesRequestMsg.getId();
+            boolean clientScope = gatewayAttributesRequestMsg.getClient();
+            ProtocolStringList keysList = gatewayAttributesRequestMsg.getKeysList();
+            Set<String> keys = new HashSet<>(keysList);
+            TransportProtos.GetAttributeRequestMsg requestMsg = toGetAttributeRequestMsg(requestId, clientScope, keys);
+            processGetAttributeRequestMessage(mqttMsg, deviceName, requestMsg);
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    private void onDeviceRpcResponseJson(int msgId, ByteBuf payload) throws AdaptorException {
+        JsonElement json = JsonMqttAdaptor.validateJsonPayload(sessionId, payload);
+        if (json.isJsonObject()) {
+            JsonObject jsonObj = json.getAsJsonObject();
+            String deviceName = jsonObj.get(DEVICE_PROPERTY).getAsString();
             Futures.addCallback(checkDeviceConnected(deviceName),
             Futures.addCallback(checkDeviceConnected(deviceName),
                     new FutureCallback<GatewayDeviceSessionCtx>() {
                     new FutureCallback<GatewayDeviceSessionCtx>() {
                         @Override
                         @Override
                         public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
                         public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
-                            transportService.process(deviceCtx.getSessionInfo(), requestMsg, getPubAckCallback(channel, deviceName, msgId, requestMsg));
+                            Integer requestId = jsonObj.get("id").getAsInt();
+                            String data = jsonObj.get("data").toString();
+                            TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = TransportProtos.ToDeviceRpcResponseMsg.newBuilder()
+                                    .setRequestId(requestId).setPayload(data).build();
+                            processRpcResponseMsg(deviceCtx, rpcResponseMsg, deviceName, msgId);
                         }
                         }
 
 
                         @Override
                         @Override
                         public void onFailure(Throwable t) {
                         public void onFailure(Throwable t) {
-                            ack(msg);
-                            log.debug("[{}] Failed to process device attributes request command: {}", sessionId, deviceName, t);
+                            log.debug("[{}] Failed to process device Rpc response command: {}", sessionId, deviceName, t);
                         }
                         }
                     }, context.getExecutor());
                     }, context.getExecutor());
         } else {
         } else {
@@ -370,6 +611,64 @@ public class GatewaySessionHandler {
         }
         }
     }
     }
 
 
+    private void onDeviceRpcResponseProto(int msgId, ByteBuf payload) throws AdaptorException {
+        try {
+            TransportApiProtos.GatewayRpcResponseMsg gatewayRpcResponseMsg = TransportApiProtos.GatewayRpcResponseMsg.parseFrom(getBytes(payload));
+            String deviceName = checkDeviceName(gatewayRpcResponseMsg.getDeviceName());
+            Futures.addCallback(checkDeviceConnected(deviceName),
+                    new FutureCallback<GatewayDeviceSessionCtx>() {
+                        @Override
+                        public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
+                            Integer requestId = gatewayRpcResponseMsg.getId();
+                            String data = gatewayRpcResponseMsg.getData();
+                            TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = TransportProtos.ToDeviceRpcResponseMsg.newBuilder()
+                                    .setRequestId(requestId).setPayload(data).build();
+                            processRpcResponseMsg(deviceCtx, rpcResponseMsg, deviceName, msgId);
+                        }
+
+                        @Override
+                        public void onFailure(Throwable t) {
+                            log.debug("[{}] Failed to process device Rpc response command: {}", sessionId, deviceName, t);
+                        }
+                    }, context.getExecutor());
+        } catch (RuntimeException | InvalidProtocolBufferException e) {
+            throw new AdaptorException(e);
+        }
+    }
+
+    private void processRpcResponseMsg(GatewayDeviceSessionCtx deviceCtx, TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg, String deviceName, int msgId) {
+        transportService.process(deviceCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(channel, deviceName, msgId, rpcResponseMsg));
+    }
+
+    private void processGetAttributeRequestMessage(MqttPublishMessage mqttMsg, String deviceName, TransportProtos.GetAttributeRequestMsg requestMsg) {
+        int msgId = getMsgId(mqttMsg);
+        Futures.addCallback(checkDeviceConnected(deviceName),
+                new FutureCallback<GatewayDeviceSessionCtx>() {
+                    @Override
+                    public void onSuccess(@Nullable GatewayDeviceSessionCtx deviceCtx) {
+                        transportService.process(deviceCtx.getSessionInfo(), requestMsg, getPubAckCallback(channel, deviceName, msgId, requestMsg));
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        ack(mqttMsg);
+                        log.debug("[{}] Failed to process device attributes request command: {}", sessionId, deviceName, t);
+                    }
+                }, context.getExecutor());
+    }
+
+    private TransportProtos.GetAttributeRequestMsg toGetAttributeRequestMsg(int requestId, boolean clientScope, Set<String> keys) {
+        TransportProtos.GetAttributeRequestMsg.Builder result = TransportProtos.GetAttributeRequestMsg.newBuilder();
+        result.setRequestId(requestId);
+
+        if (clientScope) {
+            result.addAllClientAttributeNames(keys);
+        } else {
+            result.addAllSharedAttributeNames(keys);
+        }
+        return result.build();
+    }
+
     private ListenableFuture<GatewayDeviceSessionCtx> checkDeviceConnected(String deviceName) {
     private ListenableFuture<GatewayDeviceSessionCtx> checkDeviceConnected(String deviceName) {
         GatewayDeviceSessionCtx ctx = devices.get(deviceName);
         GatewayDeviceSessionCtx ctx = devices.get(deviceName);
         if (ctx == null) {
         if (ctx == null) {
@@ -388,11 +687,11 @@ public class GatewaySessionHandler {
         }
         }
     }
     }
 
 
-    private String getDeviceName(JsonElement json) throws AdaptorException {
+    private String getDeviceName(JsonElement json) {
         return json.getAsJsonObject().get(DEVICE_PROPERTY).getAsString();
         return json.getAsJsonObject().get(DEVICE_PROPERTY).getAsString();
     }
     }
 
 
-    private String getDeviceType(JsonElement json) throws AdaptorException {
+    private String getDeviceType(JsonElement json) {
         JsonElement type = json.getAsJsonObject().get("type");
         JsonElement type = json.getAsJsonObject().get("type");
         return type == null || type instanceof JsonNull ? DEFAULT_DEVICE_TYPE : type.getAsString();
         return type == null || type instanceof JsonNull ? DEFAULT_DEVICE_TYPE : type.getAsString();
     }
     }
@@ -401,18 +700,15 @@ public class GatewaySessionHandler {
         return JsonMqttAdaptor.validateJsonPayload(sessionId, mqttMsg.payload());
         return JsonMqttAdaptor.validateJsonPayload(sessionId, mqttMsg.payload());
     }
     }
 
 
-    private void ack(MqttPublishMessage msg) {
-        if (msg.variableHeader().packetId() > 0) {
-            writeAndFlush(MqttTransportHandler.createMqttPubAckMsg(msg.variableHeader().packetId()));
-        }
-    }
-
-    void writeAndFlush(MqttMessage mqttMessage) {
-        channel.writeAndFlush(mqttMessage);
+    private byte[] getBytes(ByteBuf payload) {
+        return ProtoMqttAdaptor.toBytes(payload);
     }
     }
 
 
-    public String getNodeId() {
-        return context.getNodeId();
+    private void ack(MqttPublishMessage msg) {
+        int msgId = getMsgId(msg);
+        if (msgId > 0) {
+            writeAndFlush(MqttTransportHandler.createMqttPubAckMsg(msgId));
+        }
     }
     }
 
 
     private void deregisterSession(String deviceName, GatewayDeviceSessionCtx deviceSessionCtx) {
     private void deregisterSession(String deviceName, GatewayDeviceSessionCtx deviceSessionCtx) {
@@ -433,25 +729,9 @@ public class GatewaySessionHandler {
 
 
             @Override
             @Override
             public void onError(Throwable e) {
             public void onError(Throwable e) {
-                log.trace("[{}] Failed to publish msg: {}", sessionId, deviceName, msg, e);
+                log.trace("[{}] Failed to publish msg: {} for device: {}", sessionId, msg, deviceName, e);
                 ctx.close();
                 ctx.close();
             }
             }
         };
         };
     }
     }
-
-    public MqttTransportContext getContext() {
-        return context;
-    }
-
-    MqttTransportAdaptor getAdaptor() {
-        return context.getAdaptor();
-    }
-
-    int nextMsgId() {
-        return deviceSessionCtx.nextMsgId();
-    }
-
-    public UUID getSessionId() {
-        return sessionId;
-    }
 }
 }

@@ -16,7 +16,14 @@
 package org.thingsboard.server.transport.mqtt.session;
 package org.thingsboard.server.transport.mqtt.session;
 
 
 import io.netty.handler.codec.mqtt.MqttQoS;
 import io.netty.handler.codec.mqtt.MqttQoS;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.TransportPayloadType;
+import org.thingsboard.server.common.data.device.profile.DeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.transport.session.DeviceAwareSessionContext;
 import org.thingsboard.server.common.transport.session.DeviceAwareSessionContext;
+import org.thingsboard.server.transport.mqtt.util.MqttTopicFilter;
+import org.thingsboard.server.transport.mqtt.util.MqttTopicFilterFactory;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.Map;
 import java.util.Map;
@@ -52,5 +59,4 @@ public abstract class MqttDeviceAwareSessionContext extends DeviceAwareSessionCo
             return MqttQoS.AT_LEAST_ONCE;
             return MqttQoS.AT_LEAST_ONCE;
         }
         }
     }
     }
-
 }
 }

@@ -20,7 +20,6 @@ import org.thingsboard.server.common.data.device.profile.MqttTopics;
 
 
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentMap;
-import java.util.regex.Pattern;
 
 
 @Slf4j
 @Slf4j
 public class MqttTopicFilterFactory {
 public class MqttTopicFilterFactory {

@@ -107,6 +107,19 @@
             <groupId>org.apache.commons</groupId>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
             <artifactId>commons-lang3</artifactId>
         </dependency>
         </dependency>
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+        </dependency>
     </dependencies>
     </dependencies>
 
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.xolstice.maven.plugins</groupId>
+                <artifactId>protobuf-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
 </project>
 </project>

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.transport.adaptor;
+
+import com.google.gson.JsonParser;
+import com.google.protobuf.InvalidProtocolBufferException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.DataConstants;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.gen.transport.TransportApiProtos;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Slf4j
+public class ProtoConverter {
+
+    public static final JsonParser JSON_PARSER = new JsonParser();
+
+    public static TransportProtos.PostTelemetryMsg convertToTelemetryProto(byte[] payload) throws InvalidProtocolBufferException, IllegalArgumentException {
+        TransportProtos.TsKvListProto protoPayload = TransportProtos.TsKvListProto.parseFrom(payload);
+        TransportProtos.PostTelemetryMsg.Builder postTelemetryMsgBuilder = TransportProtos.PostTelemetryMsg.newBuilder();
+        TransportProtos.TsKvListProto tsKvListProto = validateTsKvListProto(protoPayload);
+        postTelemetryMsgBuilder.addTsKvList(tsKvListProto);
+        return postTelemetryMsgBuilder.build();
+    }
+
+    public static TransportProtos.PostTelemetryMsg validatePostTelemetryMsg(byte[] payload) throws InvalidProtocolBufferException, IllegalArgumentException {
+        TransportProtos.PostTelemetryMsg msg = TransportProtos.PostTelemetryMsg.parseFrom(payload);
+        TransportProtos.PostTelemetryMsg.Builder postTelemetryMsgBuilder = TransportProtos.PostTelemetryMsg.newBuilder();
+        List<TransportProtos.TsKvListProto> tsKvListProtoList = msg.getTsKvListList();
+        if (!CollectionUtils.isEmpty(tsKvListProtoList)) {
+            List<TransportProtos.TsKvListProto> tsKvListProtos = new ArrayList<>();
+            tsKvListProtoList.forEach(tsKvListProto -> {
+                TransportProtos.TsKvListProto transportTsKvListProto = validateTsKvListProto(tsKvListProto);
+                tsKvListProtos.add(transportTsKvListProto);
+            });
+            postTelemetryMsgBuilder.addAllTsKvList(tsKvListProtos);
+            return postTelemetryMsgBuilder.build();
+        } else {
+            throw new IllegalArgumentException("TsKv list is empty!");
+        }
+    }
+
+    public static TransportProtos.PostAttributeMsg validatePostAttributeMsg(byte[] bytes) throws IllegalArgumentException, InvalidProtocolBufferException {
+        TransportProtos.PostAttributeMsg proto = TransportProtos.PostAttributeMsg.parseFrom(bytes);
+        List<TransportProtos.KeyValueProto> kvList = proto.getKvList();
+        if (!CollectionUtils.isEmpty(kvList)) {
+            List<TransportProtos.KeyValueProto> keyValueProtos = validateKeyValueProtos(kvList);
+            TransportProtos.PostAttributeMsg.Builder result = TransportProtos.PostAttributeMsg.newBuilder();
+            result.addAllKv(keyValueProtos);
+            return result.build();
+        } else {
+            throw new IllegalArgumentException("KeyValue list is empty!");
+        }
+    }
+
+    public static TransportProtos.ClaimDeviceMsg convertToClaimDeviceProto(DeviceId deviceId, byte[] bytes) throws InvalidProtocolBufferException {
+        TransportApiProtos.ClaimDevice proto = TransportApiProtos.ClaimDevice.parseFrom(bytes);
+        String secretKey = proto.getSecretKey() != null ? proto.getSecretKey() : DataConstants.DEFAULT_SECRET_KEY;
+        long durationMs = proto.getDurationMs();
+        return buildClaimDeviceMsg(deviceId, secretKey, durationMs);
+    }
+
+    public static TransportProtos.GetAttributeRequestMsg convertToGetAttributeRequestMessage(byte[] bytes, int requestId) throws InvalidProtocolBufferException, RuntimeException {
+        TransportApiProtos.AttributesRequest proto = TransportApiProtos.AttributesRequest.parseFrom(bytes);
+        TransportProtos.GetAttributeRequestMsg.Builder result = TransportProtos.GetAttributeRequestMsg.newBuilder();
+        result.setRequestId(requestId);
+        String clientKeys = proto.getClientKeys();
+        String sharedKeys = proto.getSharedKeys();
+        if (!StringUtils.isEmpty(clientKeys)) {
+            List<String> clientKeysList = Arrays.asList(clientKeys.split(","));
+            result.addAllClientAttributeNames(clientKeysList);
+        }
+        if (!StringUtils.isEmpty(sharedKeys)) {
+            List<String> sharedKeysList = Arrays.asList(sharedKeys.split(","));
+            result.addAllSharedAttributeNames(sharedKeysList);
+        }
+        return result.build();
+    }
+
+    public static TransportProtos.ToServerRpcRequestMsg convertToServerRpcRequest(byte[] bytes, int requestId) throws InvalidProtocolBufferException {
+        TransportApiProtos.RpcRequest proto = TransportApiProtos.RpcRequest.parseFrom(bytes);
+        String method = proto.getMethod();
+        String params = proto.getParams();
+        return TransportProtos.ToServerRpcRequestMsg.newBuilder().setRequestId(requestId).setMethodName(method).setParams(params).build();
+    }
+
+    private static TransportProtos.ClaimDeviceMsg buildClaimDeviceMsg(DeviceId deviceId, String secretKey, long durationMs) {
+        TransportProtos.ClaimDeviceMsg.Builder result = TransportProtos.ClaimDeviceMsg.newBuilder();
+        return result
+                .setDeviceIdMSB(deviceId.getId().getMostSignificantBits())
+                .setDeviceIdLSB(deviceId.getId().getLeastSignificantBits())
+                .setSecretKey(secretKey)
+                .setDurationMs(durationMs)
+                .build();
+    }
+
+    private static TransportProtos.TsKvListProto validateTsKvListProto(TransportProtos.TsKvListProto tsKvListProto) {
+        TransportProtos.TsKvListProto.Builder tsKvListBuilder = TransportProtos.TsKvListProto.newBuilder();
+        long ts = tsKvListProto.getTs();
+        if (ts == 0) {
+            ts = System.currentTimeMillis();
+        }
+        tsKvListBuilder.setTs(ts);
+        List<TransportProtos.KeyValueProto> kvList = tsKvListProto.getKvList();
+        if (!CollectionUtils.isEmpty(kvList)) {
+            List<TransportProtos.KeyValueProto> keyValueListProtos = validateKeyValueProtos(kvList);
+            tsKvListBuilder.addAllKv(keyValueListProtos);
+            return tsKvListBuilder.build();
+        } else {
+            throw new IllegalArgumentException("KeyValue list is empty!");
+        }
+    }
+
+
+    private static List<TransportProtos.KeyValueProto> validateKeyValueProtos(List<TransportProtos.KeyValueProto> kvList) {
+        kvList.forEach(keyValueProto -> {
+            String key = keyValueProto.getKey();
+            if (StringUtils.isEmpty(key)) {
+                throw new IllegalArgumentException("Invalid key value: " + key + "!");
+            }
+            TransportProtos.KeyValueType type = keyValueProto.getType();
+            switch (type) {
+                case BOOLEAN_V:
+                case LONG_V:
+                case DOUBLE_V:
+                    break;
+                case STRING_V:
+                    if (StringUtils.isEmpty(keyValueProto.getStringV())) {
+                        throw new IllegalArgumentException("Value is empty for key: " + key + "!");
+                    }
+                    break;
+                case JSON_V:
+                    try {
+                        JSON_PARSER.parse(keyValueProto.getJsonV());
+                    } catch (Exception e) {
+                        throw new IllegalArgumentException("Can't parse value: " + keyValueProto.getJsonV() + " for key: " + key + "!");
+                    }
+                    break;
+                case UNRECOGNIZED:
+                    throw new IllegalArgumentException("Unsupported keyValueType: " + type + "!");
+            }
+        });
+        return kvList;
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+syntax = "proto3";
+package transportapi;
+
+option java_package = "org.thingsboard.server.gen.transport";
+option java_outer_classname = "TransportApiProtos";
+
+import "queue.proto";
+
+message ClaimDevice {
+  string secretKey = 1;
+  int64 durationMs = 2;
+}
+
+message AttributesRequest {
+  string clientKeys = 1;
+  string sharedKeys = 2;
+}
+
+message RpcRequest {
+  string method = 1;
+  string params = 2;
+}
+
+message DisconnectMsg {
+  string deviceName = 1;
+}
+
+message ConnectMsg {
+  string deviceName = 1;
+  string deviceType = 2;
+}
+
+message TelemetryMsg {
+  string deviceName = 1;
+  transport.PostTelemetryMsg msg = 3;
+}
+
+message AttributesMsg {
+  string deviceName = 1;
+  transport.PostAttributeMsg msg = 2;
+}
+
+message ClaimDeviceMsg {
+  string deviceName = 1;
+  ClaimDevice claimRequest = 2;
+}
+
+message GatewayTelemetryMsg {
+  repeated TelemetryMsg msg = 1;
+}
+
+message GatewayClaimMsg {
+  repeated ClaimDeviceMsg msg = 1;
+}
+
+message GatewayAttributesMsg {
+  repeated AttributesMsg msg = 1;
+}
+
+message GatewayRpcResponseMsg {
+  string deviceName = 1;
+  int32  id = 2;
+  string data = 3;
+}
+
+message GatewayAttributeResponseMsg {
+  string deviceName = 1;
+  transport.GetAttributeResponseMsg responseMsg = 2;
+}
+
+message GatewayAttributeUpdateNotificationMsg {
+  string deviceName = 1;
+  transport.AttributeUpdateNotificationMsg notificationMsg = 2;
+}
+
+message GatewayDeviceRpcRequestMsg {
+  string deviceName = 1;
+  transport.ToDeviceRpcRequestMsg rpcRequestMsg = 2;
+}
+
+message GatewayAttributesRequestMsg {
+  int32  id = 1;
+  string deviceName = 2;
+  bool client = 3;
+  repeated string keys = 4;
+}

@@ -177,6 +177,9 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
         String sharedAttributeValue = RandomStringUtils.randomAlphanumeric(8);
         String sharedAttributeValue = RandomStringUtils.randomAlphanumeric(8);
         sharedAttributes.addProperty("sharedAttr", sharedAttributeValue);
         sharedAttributes.addProperty("sharedAttr", sharedAttributeValue);
 
 
+        // Subscribe for attribute update event
+        mqttClient.on("v1/gateway/attributes", listener, MqttQoS.AT_LEAST_ONCE).get();
+
         ResponseEntity sharedAttributesResponse = restClient.getRestTemplate()
         ResponseEntity sharedAttributesResponse = restClient.getRestTemplate()
                 .postForEntity(HTTPS_URL + "/api/plugins/telemetry/DEVICE/{deviceId}/SHARED_SCOPE",
                 .postForEntity(HTTPS_URL + "/api/plugins/telemetry/DEVICE/{deviceId}/SHARED_SCOPE",
                         mapper.readTree(sharedAttributes.toString()), ResponseEntity.class,
                         mapper.readTree(sharedAttributes.toString()), ResponseEntity.class,

@@ -45,7 +45,6 @@ transport:
   mqtt:
   mqtt:
     bind_address: "${MQTT_BIND_ADDRESS:0.0.0.0}"
     bind_address: "${MQTT_BIND_ADDRESS:0.0.0.0}"
     bind_port: "${MQTT_BIND_PORT:1883}"
     bind_port: "${MQTT_BIND_PORT:1883}"
-    adaptor: "${MQTT_ADAPTOR_NAME:JsonMqttAdaptor}"
     timeout: "${MQTT_TIMEOUT:10000}"
     timeout: "${MQTT_TIMEOUT:10000}"
     netty:
     netty:
       leak_detector_level: "${NETTY_LEAK_DETECTOR_LVL:DISABLED}"
       leak_detector_level: "${NETTY_LEAK_DETECTOR_LVL:DISABLED}"

@@ -20,6 +20,17 @@
     <fieldset class="fields-group">
     <fieldset class="fields-group">
       <legend class="group-title" translate>device-profile.mqtt-device-topic-filters</legend>
       <legend class="group-title" translate>device-profile.mqtt-device-topic-filters</legend>
       <div fxLayoutGap="8px" fxLayout="column">
       <div fxLayoutGap="8px" fxLayout="column">
+        <mat-form-field class="mat-block">
+          <mat-label translate>device-profile.mqtt-device-payload-type</mat-label>
+          <mat-select formControlName="transportPayloadType" required>
+            <mat-option *ngFor="let type of mqttTransportPayloadTypes" [value]="type">
+              {{mqttTransportPayloadTypeTranslations.get(type) | translate}}
+            </mat-option>
+          </mat-select>
+          <mat-error *ngIf="mqttDeviceProfileTransportConfigurationFormGroup.get('configuration.transportPayloadType').hasError('required')">
+            {{ 'device-profile.mqtt-payload-type-required' | translate }}
+          </mat-error>
+        </mat-form-field>
         <div fxLayout="row" fxLayoutGap="8px" fxLayout.xs="column">
         <div fxLayout="row" fxLayoutGap="8px" fxLayout.xs="column">
           <mat-form-field fxFlex>
           <mat-form-field fxFlex>
             <mat-label translate>device-profile.telemetry-topic-filter</mat-label>
             <mat-label translate>device-profile.telemetry-topic-filter</mat-label>

@@ -28,9 +28,10 @@ import { Store } from '@ngrx/store';
 import { AppState } from '@app/core/core.state';
 import { AppState } from '@app/core/core.state';
 import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import {
 import {
+  MqttTransportPayloadType,
   DeviceProfileTransportConfiguration,
   DeviceProfileTransportConfiguration,
   DeviceTransportType,
   DeviceTransportType,
-  MqttDeviceProfileTransportConfiguration
+  MqttDeviceProfileTransportConfiguration, mqttTransportPayloadTypeTranslationMap
 } from '@shared/models/device.models';
 } from '@shared/models/device.models';
 import { isDefinedAndNotNull } from '@core/utils';
 import { isDefinedAndNotNull } from '@core/utils';
 
 
@@ -46,6 +47,11 @@ import { isDefinedAndNotNull } from '@core/utils';
 })
 })
 export class MqttDeviceProfileTransportConfigurationComponent implements ControlValueAccessor, OnInit {
 export class MqttDeviceProfileTransportConfigurationComponent implements ControlValueAccessor, OnInit {
 
 
+  mqttTransportPayloadTypes = Object.keys(MqttTransportPayloadType);
+
+  mqttTransportPayloadTypeTranslations = mqttTransportPayloadTypeTranslationMap;
+
+
   mqttDeviceProfileTransportConfigurationFormGroup: FormGroup;
   mqttDeviceProfileTransportConfigurationFormGroup: FormGroup;
 
 
   private requiredValue: boolean;
   private requiredValue: boolean;
@@ -79,7 +85,8 @@ export class MqttDeviceProfileTransportConfigurationComponent implements Control
     this.mqttDeviceProfileTransportConfigurationFormGroup = this.fb.group({
     this.mqttDeviceProfileTransportConfigurationFormGroup = this.fb.group({
       configuration: this.fb.group({
       configuration: this.fb.group({
         deviceAttributesTopic: [null, [Validators.required, this.validationMQTTTopic()]],
         deviceAttributesTopic: [null, [Validators.required, this.validationMQTTTopic()]],
-        deviceTelemetryTopic: [null, [Validators.required, this.validationMQTTTopic()]]
+        deviceTelemetryTopic: [null, [Validators.required, this.validationMQTTTopic()]],
+        transportPayloadType: [MqttTransportPayloadType.JSON, Validators.required]
       })
       })
     });
     });
     this.mqttDeviceProfileTransportConfigurationFormGroup.valueChanges.subscribe(() => {
     this.mqttDeviceProfileTransportConfigurationFormGroup.valueChanges.subscribe(() => {

@@ -36,6 +36,11 @@ export enum DeviceTransportType {
   LWM2M = 'LWM2M'
   LWM2M = 'LWM2M'
 }
 }
 
 
+export enum MqttTransportPayloadType {
+  JSON = 'JSON',
+  PROTOBUF = 'PROTOBUF'
+}
+
 export interface DeviceConfigurationFormInfo {
 export interface DeviceConfigurationFormInfo {
   hasProfileConfiguration: boolean;
   hasProfileConfiguration: boolean;
   hasDeviceConfiguration: boolean;
   hasDeviceConfiguration: boolean;
@@ -67,6 +72,14 @@ export const deviceTransportTypeTranslationMap = new Map<DeviceTransportType, st
   ]
   ]
 );
 );
 
 
+export const mqttTransportPayloadTypeTranslationMap = new Map<MqttTransportPayloadType, string>(
+  [
+    [MqttTransportPayloadType.JSON, 'device-profile.mqtt-device-payload-type-json'],
+    [MqttTransportPayloadType.PROTOBUF, 'device-profile.mqtt-device-payload-type-proto']
+  ]
+);
+
+
 export const deviceTransportTypeConfigurationInfoMap = new Map<DeviceTransportType, DeviceConfigurationFormInfo>(
 export const deviceTransportTypeConfigurationInfoMap = new Map<DeviceTransportType, DeviceConfigurationFormInfo>(
   [
   [
     [
     [
@@ -162,7 +175,8 @@ export function createDeviceProfileTransportConfiguration(type: DeviceTransportT
       case DeviceTransportType.MQTT:
       case DeviceTransportType.MQTT:
         const mqttTransportConfiguration: MqttDeviceProfileTransportConfiguration = {
         const mqttTransportConfiguration: MqttDeviceProfileTransportConfiguration = {
           deviceTelemetryTopic: 'v1/devices/me/telemetry',
           deviceTelemetryTopic: 'v1/devices/me/telemetry',
-          deviceAttributesTopic: 'v1/devices/me/attributes'
+          deviceAttributesTopic: 'v1/devices/me/attributes',
+          transportPayloadType: MqttTransportPayloadType.JSON
         };
         };
         transportConfiguration = {...mqttTransportConfiguration, type: DeviceTransportType.MQTT};
         transportConfiguration = {...mqttTransportConfiguration, type: DeviceTransportType.MQTT};
         break;
         break;

@@ -798,6 +798,10 @@
         "no-device-profiles-found": "No device profiles found.",
         "no-device-profiles-found": "No device profiles found.",
         "create-new-device-profile": "Create a new one!",
         "create-new-device-profile": "Create a new one!",
         "mqtt-device-topic-filters": "MQTT device topic filters",
         "mqtt-device-topic-filters": "MQTT device topic filters",
+        "mqtt-device-payload-type": "MQTT device payload",
+        "mqtt-device-payload-type-json": "JSON",
+        "mqtt-device-payload-type-proto": "Protobuf",
+        "mqtt-payload-type-required": "Payload type is required.",
         "support-level-wildcards": "Single <code>[+]</code> and multi-level <code>[#]</code> wildcards supported.",
         "support-level-wildcards": "Single <code>[+]</code> and multi-level <code>[#]</code> wildcards supported.",
         "telemetry-topic-filter": "Telemetry topic filter",
         "telemetry-topic-filter": "Telemetry topic filter",
         "telemetry-topic-filter-required": "Telemetry topic filter is required.",
         "telemetry-topic-filter-required": "Telemetry topic filter is required.",