Add Android AITT APIs to align with native AITT APIs

[Problem] Some Android AITT APIs do not cover the default parameters
          of native AITT APIs.
[Solution] Add Android AITT APIs to cover the all default parameters.

diff --git a/android/aitt-native/src/main/java/com/samsung/android/aittnative/JniInterface.java b/android/aitt-native/src/main/java/com/samsung/android/aittnative/JniInterface.java
index 58a15ee..7850c80 100644 (file)
--- a/android/aitt-native/src/main/java/com/samsung/android/aittnative/JniInterface.java
+++ b/android/aitt-native/src/main/java/com/samsung/android/aittnative/JniInterface.java
@@ -114,13 +114,13 @@ public class JniInterface {
      * JNI Interface API to publish data to specified topic
      * @param topic String to which message needs to be published
      * @param data Byte message to be published
-     * @param datalen Size/length of the message to be published
+     * @param dataLen Size/length of the message to be published
      * @param protocol Protocol to be used to publish message
      * @param qos QoS at which the message should be delivered
      * @param retain Boolean to decide whether or not the message should be retained by the broker
      */
-    public void publish(final String topic, final byte[] data, long datalen, int protocol, int qos, boolean retain) {
-        publishJNI(instance, topic, data, datalen, protocol, qos, retain);
+    public void publish(final String topic, final byte[] data, long dataLen, int protocol, int qos, boolean retain) {
+        publishJNI(instance, topic, data, dataLen, protocol, qos, retain);
     }
 
     /**
@@ -265,10 +265,10 @@ public class JniInterface {
     private native void removeDiscoveryCallbackJNI(long instance, int cbHandle);
 
     /* Native API for updating discovery message */
-    private native void updateDiscoveryMessageJNI(long instance, final String topic, final byte[] data, long datalen);
+    private native void updateDiscoveryMessageJNI(long instance, final String topic, final byte[] data, long dataLen);
 
     /* Native API for publishing to a topic */
-    private native void publishJNI(long instance, final String topic, final byte[] data, long datalen, int protocol, int qos, boolean retain);
+    private native void publishJNI(long instance, final String topic, final byte[] data, long dataLen, int protocol, int qos, boolean retain);
 
     /* Native API for subscribing to a topic */
     private native long subscribeJNI(long instance, final String topic, int protocol, int qos);

diff --git a/android/aitt/src/main/java/com/samsung/android/aitt/Aitt.java b/android/aitt/src/main/java/com/samsung/android/aitt/Aitt.java
index 4c6bdd9..6df0c09 100644 (file)
--- a/android/aitt/src/main/java/com/samsung/android/aitt/Aitt.java
+++ b/android/aitt/src/main/java/com/samsung/android/aitt/Aitt.java
@@ -241,6 +241,31 @@ public class Aitt {
      * @param topic    String to which message needs to be published
      * @param message  Byte message that needs to be published
      * @param protocol Protocol to be used to publish message
+     */
+    public void publish(String topic, byte[] message, Protocol protocol) {
+        EnumSet<Protocol> protocolSet = EnumSet.of(protocol);
+        publish(topic, message, protocolSet, QoS.AT_MOST_ONCE, false);
+    }
+
+    /**
+     * Method to publish message to a specific topic
+     *
+     * @param topic    String to which message needs to be published
+     * @param message  Byte message that needs to be published
+     * @param protocol Protocol to be used to publish message
+     * @param qos      QoS at which the message should be delivered
+     */
+    public void publish(String topic, byte[] message, Protocol protocol, QoS qos) {
+        EnumSet<Protocol> protocolSet = EnumSet.of(protocol);
+        publish(topic, message, protocolSet, qos, false);
+    }
+
+    /**
+     * Method to publish message to a specific topic
+     *
+     * @param topic    String to which message needs to be published
+     * @param message  Byte message that needs to be published
+     * @param protocol Protocol to be used to publish message
      * @param qos      QoS at which the message should be delivered
      * @param retain   Boolean to decide whether or not the message should be retained by the broker
      */
@@ -409,6 +434,18 @@ public class Aitt {
      * @param topic    String to which applications can subscribe, to receive data
      * @param callback Callback object specific to a subscribe call
      * @param protocol Protocol supported by application, invoking subscribe
+     */
+    public void subscribe(String topic, SubscribeCallback callback, Protocol protocol) {
+        EnumSet<Protocol> protocolSet = EnumSet.of(protocol);
+        subscribe(topic, callback, protocolSet, QoS.AT_MOST_ONCE);
+    }
+
+    /**
+     * Method to subscribe to a specific topic
+     *
+     * @param topic    String to which applications can subscribe, to receive data
+     * @param callback Callback object specific to a subscribe call
+     * @param protocol Protocol supported by application, invoking subscribe
      * @param qos      QoS at which the message should be delivered
      */
     public void subscribe(String topic, SubscribeCallback callback, Protocol protocol, QoS qos) {

diff --git a/android/aitt/src/test/java/com/samsung/android/aitt/AittUnitTest.java b/android/aitt/src/test/java/com/samsung/android/aitt/AittUnitTest.java
index e248a83..5fed56b 100644 (file)
--- a/android/aitt/src/test/java/com/samsung/android/aitt/AittUnitTest.java
+++ b/android/aitt/src/test/java/com/samsung/android/aitt/AittUnitTest.java
@@ -196,7 +196,7 @@ public class AittUnitTest {
             Aitt aitt = new Aitt(appContext, id);
             assertNotNull("Aitt Instance not null", aitt);
         } catch (Exception e) {
-            fail("Failed testInitialize " + e);
+            fail("Failed testAittConstructor " + e);
         }
     }
 
@@ -316,9 +316,7 @@ public class AittUnitTest {
             String _topic = "";
             byte[] payload = message.getBytes();
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.publish(_topic, payload);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -353,9 +351,7 @@ public class AittUnitTest {
             String _topic = "";
             byte[] payload = message.getBytes();
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.publish(_topic, payload, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE, false);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE, false));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -390,9 +386,7 @@ public class AittUnitTest {
             String _topic = "";
             byte[] payload = message.getBytes();
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.publish(_topic, payload, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE, false);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE, false));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -427,9 +421,7 @@ public class AittUnitTest {
             String _topic = "";
             byte[] payload = message.getBytes();
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.publish(_topic, payload, Aitt.Protocol.TCP, Aitt.QoS.AT_LEAST_ONCE, false);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, Aitt.Protocol.TCP, Aitt.QoS.AT_LEAST_ONCE, false));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -468,9 +460,7 @@ public class AittUnitTest {
             byte[] payload = message.getBytes();
             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.publish(_topic, payload, protocols, Aitt.QoS.AT_MOST_ONCE, false);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, protocols, Aitt.QoS.AT_MOST_ONCE, false));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -487,9 +477,7 @@ public class AittUnitTest {
             byte[] payload = message.getBytes();
             EnumSet<Aitt.Protocol> protocols = EnumSet.noneOf(Aitt.Protocol.class);
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.publish(topic, payload, protocols, Aitt.QoS.AT_MOST_ONCE, false);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.publish(topic, payload, protocols, Aitt.QoS.AT_MOST_ONCE, false));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -506,12 +494,7 @@ public class AittUnitTest {
             assertNotNull("Aitt Instance not null", aitt);
             aitt.connect(brokerIp, port);
 
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage message) {
-                    String _topic = message.getTopic();
-                    byte[] payload = message.getPayload();
-                }
+            aitt.subscribe(topic, message -> {
             });
 
             aitt.disconnect();
@@ -529,13 +512,8 @@ public class AittUnitTest {
 
             String _topic = "";
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(_topic, new Aitt.SubscribeCallback() {
-                    @Override
-                    public void onMessageReceived(AittMessage message) {
-                    }
-                });
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
+            }));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -551,9 +529,7 @@ public class AittUnitTest {
 
             aitt.connect(brokerIp, port);
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(topic, null);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -562,6 +538,58 @@ public class AittUnitTest {
     }
 
     @Test
+    public void testSubscribeTCP_P() {
+        try {
+            shadowJniInterface.setInitReturn(true);
+            Aitt aitt = new Aitt(appContext, aittId);
+
+            assertNotNull("Aitt Instance not null", aitt);
+            aitt.connect(brokerIp, port);
+
+            aitt.subscribe(topic, message -> {
+            }, Aitt.Protocol.TCP);
+
+            aitt.disconnect();
+        } catch (Exception e) {
+            fail("Failed testSubscribeTCP " + e);
+        }
+    }
+
+    @Test
+    public void testSubscribeTcpInvalidTopic_N() {
+        try {
+            shadowJniInterface.setInitReturn(true);
+            Aitt aitt = new Aitt(appContext, aittId);
+            aitt.connect(brokerIp, port);
+
+            String _topic = "";
+
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
+            }, Aitt.Protocol.TCP));
+
+            aitt.disconnect();
+        } catch (Exception e) {
+            fail("Failed testSubscribeTcpInvalidTopic " + e);
+        }
+    }
+
+    @Test
+    public void testSubscribeTcpInvalidCallback_N() {
+        try {
+            shadowJniInterface.setInitReturn(true);
+            Aitt aitt = new Aitt(appContext, aittId);
+
+            aitt.connect(brokerIp, port);
+
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, Aitt.Protocol.TCP));
+
+            aitt.disconnect();
+        } catch (Exception e) {
+            fail("Failed testSubscribeTcpInvalidCallback " + e);
+        }
+    }
+
+    @Test
     public void testSubscribeWebRTC_P() {
         try {
             shadowJniInterface.setInitReturn(true);
@@ -570,12 +598,7 @@ public class AittUnitTest {
             assertNotNull("Aitt Instance not null", aitt);
             aitt.connect(brokerIp, port);
 
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage message) {
-                    String _topic = message.getTopic();
-                    byte[] payload = message.getPayload();
-                }
+            aitt.subscribe(topic, message -> {
             }, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE);
 
             aitt.disconnect();
@@ -593,13 +616,8 @@ public class AittUnitTest {
 
             String _topic = "";
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(_topic, new Aitt.SubscribeCallback() {
-                    @Override
-                    public void onMessageReceived(AittMessage message) {
-                    }
-                }, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
+            }, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -615,9 +633,7 @@ public class AittUnitTest {
 
             aitt.connect(brokerIp, port);
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(topic, null, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -634,12 +650,7 @@ public class AittUnitTest {
             assertNotNull("Aitt Instance not null", aitt);
             aitt.connect(brokerIp, port);
 
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage message) {
-                    String _topic = message.getTopic();
-                    byte[] payload = message.getPayload();
-                }
+            aitt.subscribe(topic, message -> {
             }, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE);
 
             aitt.disconnect();
@@ -657,13 +668,8 @@ public class AittUnitTest {
 
             String _topic = "";
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(_topic, new Aitt.SubscribeCallback() {
-                    @Override
-                    public void onMessageReceived(AittMessage message) {
-                    }
-                }, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
+            }, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -680,12 +686,7 @@ public class AittUnitTest {
             assertNotNull("Aitt Instance not null", aitt);
             aitt.connect(brokerIp, port);
 
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage message) {
-                    String _topic = message.getTopic();
-                    byte[] payload = message.getPayload();
-                }
+            aitt.subscribe(topic, message -> {
             }, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE);
 
             aitt.disconnect();
@@ -703,13 +704,8 @@ public class AittUnitTest {
 
             String _topic = "";
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(_topic, new Aitt.SubscribeCallback() {
-                    @Override
-                    public void onMessageReceived(AittMessage message) {
-                    }
-                }, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
+            }, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -725,9 +721,7 @@ public class AittUnitTest {
 
             aitt.connect(brokerIp, port);
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(topic, null, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -744,15 +738,8 @@ public class AittUnitTest {
             aitt.connect(brokerIp, port);
             EnumSet<Aitt.Protocol> protocols = EnumSet.noneOf(Aitt.Protocol.class);
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                    @Override
-                    public void onMessageReceived(AittMessage message) {
-                        String _topic = message.getTopic();
-                        byte[] payload = message.getPayload();
-                    }
-                }, protocols, Aitt.QoS.AT_MOST_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, message -> {
+            }, protocols, Aitt.QoS.AT_MOST_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -770,12 +757,7 @@ public class AittUnitTest {
             aitt.connect(brokerIp, port);
 
             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage message) {
-                    String _topic = message.getTopic();
-                    byte[] payload = message.getPayload();
-                }
+            aitt.subscribe(topic, message -> {
             }, protocols, Aitt.QoS.EXACTLY_ONCE);
 
             aitt.disconnect();
@@ -793,13 +775,8 @@ public class AittUnitTest {
 
             String _topic = "";
             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(_topic, new Aitt.SubscribeCallback() {
-                    @Override
-                    public void onMessageReceived(AittMessage message) {
-                    }
-                }, protocols, Aitt.QoS.EXACTLY_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
+            }, protocols, Aitt.QoS.EXACTLY_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -815,9 +792,7 @@ public class AittUnitTest {
 
             aitt.connect(brokerIp, port);
             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.subscribe(topic, null, protocols, Aitt.QoS.AT_MOST_ONCE);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, protocols, Aitt.QoS.AT_MOST_ONCE));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -834,10 +809,7 @@ public class AittUnitTest {
             assertNotNull("Aitt Instance not null", aitt);
             aitt.connect(brokerIp, port);
 
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage message) {
-                }
+            aitt.subscribe(topic, message -> {
             });
 
             aitt.unsubscribe(topic);
@@ -856,9 +828,7 @@ public class AittUnitTest {
             aitt.connect(brokerIp, port);
             String _topic = "";
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.unsubscribe(_topic);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.unsubscribe(_topic));
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -900,9 +870,7 @@ public class AittUnitTest {
             shadowJniInterface.setInitReturn(true);
             Aitt aitt = new Aitt(appContext, aittId);
 
-            assertThrows(IllegalArgumentException.class, () -> {
-                aitt.setConnectionCallback(null);
-            });
+            assertThrows(IllegalArgumentException.class, () -> aitt.setConnectionCallback(null));
 
             aitt.connect(brokerIp, port);
             aitt.disconnect();
@@ -948,7 +916,7 @@ public class AittUnitTest {
             int counter = 1;
             while (counter < DISCOVERY_MESSAGES_COUNT) {
                 byte[] discoveryMessage = createDiscoveryMessage(counter);
-                messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, (Object) discoveryMessage);
+                messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, discoveryMessage);
                 counter++;
             }
 
@@ -969,11 +937,11 @@ public class AittUnitTest {
 
             int counter = 1;
             byte[] discoveryMessage = createDiscoveryMessage(counter);
-            messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, (Object) discoveryMessage);
+            messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, discoveryMessage);
 
             counter = 6;
             byte[] disconnectMessage = createDiscoveryMessage(counter);
-            messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, (Object) disconnectMessage);
+            messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, disconnectMessage);
             aitt.disconnect();
         } catch (Exception e) {
             fail("Failed testDiscoveryMessageCallback " + e);
@@ -990,7 +958,7 @@ public class AittUnitTest {
             aitt.connect(brokerIp, port);
 
             byte[] discoveryMessage = new byte[0];
-            messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, (Object) discoveryMessage);
+            messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, discoveryMessage);
 
             aitt.disconnect();
         } catch (Exception e) {
@@ -1005,12 +973,9 @@ public class AittUnitTest {
             Aitt aitt = new Aitt(appContext, aittId);
             aitt.connect(brokerIp, port);
 
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage aittMessage) {
-                    String recvTopic = aittMessage.getTopic();
-                    assertEquals("Received topic and subscribed topic are equal", recvTopic, topic);
-                }
+            aitt.subscribe(topic, aittMessage -> {
+                String receivedTopic = aittMessage.getTopic();
+                assertEquals("Received topic and subscribed topic are equal", receivedTopic, topic);
             });
 
             messageCallbackMethod.invoke(aitt, topic, message.getBytes(StandardCharsets.UTF_8));
@@ -1028,12 +993,9 @@ public class AittUnitTest {
             Aitt aitt = new Aitt(appContext, aittId);
             aitt.connect(brokerIp, port);
 
-            aitt.subscribe(topic, new Aitt.SubscribeCallback() {
-                @Override
-                public void onMessageReceived(AittMessage aittMessage) {
-                    String recvMessage = new String(aittMessage.getPayload(), StandardCharsets.UTF_8);
-                    assertEquals("Received message and sent message are equal", message, recvMessage);
-                }
+            aitt.subscribe(topic, aittMessage -> {
+                String receivedMessage = new String(aittMessage.getPayload(), StandardCharsets.UTF_8);
+                assertEquals("Received message and sent message are equal", message, receivedMessage);
             });
 
             messageCallbackMethod.invoke(aitt, topic, message.getBytes(StandardCharsets.UTF_8));