Write the first test case

This includes dummy classes and other small changes in the uprotocol API

Author: velitasali

.gitignore

@@ -0,0 +1,7 @@
+/target
+/.idea
+/projectFilesBackup
+*.iml
+local.properties
+*.jar
+settings.xml

src/main/java/org/monora/uprotocol/core/CommunicationBridge.java

@@ -40,6 +40,9 @@
 import java.net.SocketException;
 import java.util.List;
 
+import static org.monora.uprotocol.core.spec.alpha.Config.PORT_UPROTOCOL;
+import static org.monora.uprotocol.core.spec.alpha.Config.TIMEOUT_SOCKET_DEFAULT;
+
 /**
  * created by: Veli
  * date: 11.02.2018 15:07
@@ -49,12 +52,6 @@ public class CommunicationBridge implements Closeable
 {
     public static final String TAG = CommunicationBridge.class.getSimpleName();
 
-    public static final int TIMEOUT_SOCKET_DEFAULT = 5000;
-
-    public static final int PORT_UPROTOCOL = 1128;
-
-    public static final int LENGTH_DEVICE_NAME = 32;
-
 
     private final PersistenceProvider persistenceProvider;
 
@@ -103,15 +100,15 @@ public static CommunicationBridge connect(ConnectionProvider connectionProvider,
             throws IOException, JSONException, CommunicationException
     {
         ActiveConnection activeConnection = connectionProvider.openConnection(deviceAddress.inetAddress);
-        String remoteDeviceId = activeConnection.receive().getAsString();
+        String remoteDeviceUid = activeConnection.receive().getAsString();
 
-        if (device != null && device.uid != null && !device.uid.equals(remoteDeviceId)) {
+        if (device != null && device.uid != null && !device.uid.equals(remoteDeviceUid)) {
             activeConnection.closeSafely();
-            throw new DifferentClientException(device, remoteDeviceId);
+            throw new DifferentClientException(device, remoteDeviceUid);
         }
 
         if (device == null)
-            device = persistenceProvider.createDeviceFor(remoteDeviceId);
+            device = persistenceProvider.createDeviceFor(remoteDeviceUid);
 
         try {
             persistenceProvider.sync(device);
@@ -160,12 +157,15 @@ public static ActiveConnection openConnection(InetAddress inetAddress) throws IO
      * request in that timespan, this will invoke {@link TransportSeat#handleAcquaintanceRequest(Device, DeviceAddress)}
      * method on the remote and it will choose you.
      *
-     * @throws JSONException If something goes wrong when creating the JSON object.
-     * @throws IOException   If an IO error occurs.
+     * @return True if successful.
+     * @throws JSONException          If something goes wrong when creating JSON object.
+     * @throws IOException            If an IO error occurs.
+     * @throws CommunicationException When there is a communication error due to misconfiguration.
      */
-    public void requestAcquaintance() throws JSONException, IOException
+    public boolean requestAcquaintance() throws JSONException, IOException, CommunicationException
     {
         getActiveConnection().reply(new JSONObject().put(Keyword.REQUEST, Keyword.REQUEST_ACQUAINTANCE));
+        return receiveResult();
     }
 
     /**
@@ -178,48 +178,77 @@ public void requestAcquaintance() throws JSONException, IOException
      *
      * @param transferId That ties a group of {@link TransferItem} as in {@link TransferItem#transferId}.
      * @param files      That has been generated using {@link PersistenceProvider#toJson(List)}.
-     * @throws JSONException If something goes wrong when creating the JSON object.
-     * @throws IOException   If an IO error occurs.
+     * @return True if successful.
+     * @throws JSONException          If something goes wrong when creating JSON object.
+     * @throws IOException            If an IO error occurs.
+     * @throws CommunicationException When there is a communication error due to misconfiguration.
      */
-    public void requestFileTransfer(long transferId, JSONArray files) throws JSONException, IOException
+    public boolean requestFileTransfer(long transferId, JSONArray files) throws JSONException, IOException,
+            CommunicationException
     {
         getActiveConnection().reply(new JSONObject()
                 .put(Keyword.REQUEST, Keyword.REQUEST_TRANSFER)
                 .put(Keyword.TRANSFER_ID, transferId)
                 .put(Keyword.INDEX, files));
+        return receiveResult();
     }
 
     /**
-     * Ask the remote to start the transfer job.
+     * Ask remote to start a transfer job.
      * <p>
-     * The transfer request has already been sent {@link #requestFileTransfer(long, JSONArray)}.
+     * The transfer request, in this case, has already been sent {@link #requestFileTransfer(long, JSONArray)}.
      *
      * @param transferId That ties a group of {@link TransferItem} as in {@link TransferItem#transferId}.
      * @param type       Of the transfer as in {@link TransferItem#type}.
-     * @throws JSONException If something goes wrong when creating the JSON object.
-     * @throws IOException   If an IO error occurs.
+     * @return True if successful.
+     * @throws JSONException          If something goes wrong when creating JSON object.
+     * @throws IOException            If an IO error occurs.
+     * @throws CommunicationException When there is a communication error due to misconfiguration.
      */
-    public void requestFileTransferStart(long transferId, TransferItem.Type type) throws JSONException, IOException
+    public boolean requestFileTransferStart(long transferId, TransferItem.Type type) throws JSONException, IOException,
+            CommunicationException
     {
         getActiveConnection().reply(new JSONObject()
                 .put(Keyword.REQUEST, Keyword.REQUEST_TRANSFER_JOB)
                 .put(Keyword.TRANSFER_ID, transferId)
                 .put(Keyword.TRANSFER_TYPE, type));
+        return receiveResult();
     }
 
-    public void requestNotifyTransferState(long transferId, boolean accepted) throws JSONException, IOException
+    /**
+     * Inform remote about the state of a transfer request it sent previously.
+     *
+     * @param transferId The transfer id that you are informing about.
+     * @param accepted   True if the transfer request was accepted.
+     * @return True if the request was processed successfully.
+     * @throws JSONException          If something goes wrong when creating JSON object.
+     * @throws IOException            If an IO error occurs.
+     * @throws CommunicationException When there is a communication error due to misconfiguration.
+     */
+    public boolean requestNotifyTransferState(long transferId, boolean accepted) throws JSONException, IOException,
+            CommunicationException
     {
         getActiveConnection().reply(new JSONObject()
                 .put(Keyword.REQUEST, Keyword.REQUEST_NOTIFY_TRANSFER_STATE)
                 .put(Keyword.TRANSFER_ID, transferId)
                 .put(Keyword.TRANSFER_IS_ACCEPTED, accepted));
+        return receiveResult();
     }
 
-    public void requestTextTransfer(String text) throws JSONException, IOException
+    /**
+     * Request a text transfer.
+     *
+     * @param text To send.
+     * @throws JSONException          If something goes wrong when creating JSON object.
+     * @throws IOException            If an IO error occurs.
+     * @throws CommunicationException When there is a communication error due to misconfiguration.
+     */
+    public boolean requestTextTransfer(String text) throws JSONException, IOException, CommunicationException
     {
         getActiveConnection().reply(new JSONObject()
                 .put(Keyword.REQUEST, Keyword.REQUEST_TRANSFER_TEXT)
                 .put(Keyword.TRANSFER_TEXT, text));
+        return receiveResult();
     }
 
     public static JSONObject receiveSecure(ActiveConnection activeConnection, Device device) throws IOException,

src/main/java/org/monora/uprotocol/core/DeviceLoader.java

@@ -6,15 +6,14 @@
 import org.monora.uprotocol.core.network.DeviceAddress;
 import org.monora.uprotocol.core.persistence.PersistenceException;
 import org.monora.uprotocol.core.persistence.PersistenceProvider;
-import org.monora.uprotocol.core.protocol.ConnectionProvider;
-import org.monora.uprotocol.core.protocol.DeviceBlockedException;
-import org.monora.uprotocol.core.protocol.DeviceInsecureException;
-import org.monora.uprotocol.core.protocol.DeviceVerificationException;
+import org.monora.uprotocol.core.protocol.*;
 import org.monora.uprotocol.core.spec.alpha.Keyword;
 
 import java.net.InetAddress;
 import java.util.Base64;
 
+import static org.monora.uprotocol.core.spec.alpha.Config.LENGTH_DEVICE_USERNAME;
+
 public class DeviceLoader
 {
     public static void loadAsClient(PersistenceProvider persistenceProvider, JSONObject object, Device device)
@@ -64,14 +63,15 @@ private static void loadFrom(PersistenceProvider persistenceProvider, JSONObject
         device.brand = object.getString(Keyword.DEVICE_BRAND);
         device.model = object.getString(Keyword.DEVICE_MODEL);
         device.username = object.getString(Keyword.DEVICE_USERNAME);
+        device.clientType = object.getEnum(ClientType.class, Keyword.DEVICE_CLIENT_TYPE);
         device.lastUsageTime = System.currentTimeMillis();
         device.versionCode = object.getInt(Keyword.DEVICE_VERSION_CODE);
         device.versionName = object.getString(Keyword.DEVICE_VERSION_NAME);
         device.protocolVersion = object.getInt(Keyword.DEVICE_PROTOCOL_VERSION);
         device.protocolVersionMin = object.getInt(Keyword.DEVICE_PROTOCOL_VERSION_MIN);
 
-        if (device.username.length() > CommunicationBridge.LENGTH_DEVICE_NAME)
-            device.username = device.username.substring(0, CommunicationBridge.LENGTH_DEVICE_NAME);
+        if (device.username.length() > LENGTH_DEVICE_USERNAME)
+            device.username = device.username.substring(0, LENGTH_DEVICE_USERNAME);
 
         persistenceProvider.save(device);
 

src/main/java/org/monora/uprotocol/core/TransportSession.java

@@ -24,9 +24,9 @@ public class TransportSession extends CoolSocket
 
     public TransportSession(PersistenceProvider persistenceProvider, TransportSeat transportSeat)
     {
-        super(Config.SERVER_PORT_COMMUNICATION);
+        super(Config.PORT_UPROTOCOL);
 
-        getConfigFactory().setReadTimeout(CommunicationBridge.TIMEOUT_SOCKET_DEFAULT);
+        getConfigFactory().setReadTimeout(Config.TIMEOUT_SOCKET_DEFAULT);
         this.persistenceProvider = persistenceProvider;
         this.transportSeat = transportSeat;
     }

src/main/java/org/monora/uprotocol/core/network/Device.java

@@ -1,5 +1,7 @@
 package org.monora.uprotocol.core.network;
 
+import org.monora.uprotocol.core.protocol.ClientType;
+
 /**
  * A device is a representation of a client using the latest information it has provided in a previous communication.
  */
@@ -20,11 +22,6 @@ public abstract class Device
      */
     public String versionName;
 
-    /**
-     * The OS that the client is running on.
-     */
-    public String clientOs;
-
     /**
      * The brand/manufacturer of the device.
      */
@@ -35,6 +32,11 @@ public abstract class Device
      */
     public String model;
 
+    /**
+     * The client type.
+     */
+    public ClientType clientType;
+
     /**
      * The key that we will send to the remote when we are the one who is initiating the communication.
      *
@@ -78,7 +80,7 @@ public abstract class Device
     public boolean isTrusted;
 
     /**
-     * This represents whether this devices is blocked on this client. When devices are blocked they
+     * This represents whether this device is blocked on this client. When devices are blocked they
      * cannot access unless the user for this client unblocks it.
      *
      * @see #isTrusted
@@ -89,4 +91,35 @@ public abstract class Device
      * Determine whether this device instance belongs to this client (us).
      */
     public boolean isLocal;
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (obj instanceof Device) {
+            return uid != null && uid.equals(((Device) obj).uid);
+        }
+        return super.equals(obj);
+    }
+
+    public void from(Device device)
+    {
+        from(device.username, device.senderKey, device.receiverKey, device.brand, device.model, device.clientType,
+                device.versionName, device.versionCode, device.protocolVersion, device.protocolVersionMin);
+    }
+
+    protected void from(String username, int senderKey, int receiverKey, String brand, String model,
+                        ClientType clientType, String versionName, int versionCode, int protocolVersion,
+                        int protocolVersionMin)
+    {
+        this.username = username;
+        this.senderKey = senderKey;
+        this.receiverKey = receiverKey;
+        this.brand = brand;
+        this.model = model;
+        this.clientType = clientType;
+        this.versionName = versionName;
+        this.versionCode = versionCode;
+        this.protocolVersion = protocolVersion;
+        this.protocolVersionMin = protocolVersionMin;
+    }
 }

src/main/java/org/monora/uprotocol/core/network/DeviceAddress.java

@@ -18,12 +18,21 @@ public abstract class DeviceAddress
     /**
      * The {@link Device#uid} that specifies who owns this address.
      */
-    public String deviceId;
+    public String deviceUid;
 
     /**
      * The last time that a communication was started with this address.
      *
      * @see System#currentTimeMillis()
      */
-    public long lastCheckedDate;
+    public long lastUsageTime;
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (obj instanceof DeviceAddress) {
+            return inetAddress != null && inetAddress.equals(((DeviceAddress) obj).inetAddress);
+        }
+        return super.equals(obj);
+    }
 }

src/main/java/org/monora/uprotocol/core/network/TransferItem.java

@@ -78,4 +78,15 @@ public enum Type
          */
         OUTGOING
     }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (obj instanceof TransferItem) {
+            TransferItem other = (TransferItem) obj;
+            return type != null && type.equals(other.type) && transferId == other.transferId && id == other.id;
+        }
+
+        return super.equals(obj);
+    }
 }

src/main/java/org/monora/uprotocol/core/persistence/PersistenceProvider.java

@@ -222,6 +222,7 @@ default JSONObject toJson(int senderKey, int pin) throws JSONException
                 .put(Keyword.DEVICE_BRAND, device.brand)
                 .put(Keyword.DEVICE_MODEL, device.model)
                 .put(Keyword.DEVICE_USERNAME, device.username)
+                .put(Keyword.DEVICE_CLIENT_TYPE, device.clientType)
                 .put(Keyword.DEVICE_VERSION_CODE, device.versionCode)
                 .put(Keyword.DEVICE_VERSION_NAME, device.versionName)
                 .put(Keyword.DEVICE_PROTOCOL_VERSION, device.protocolVersion)

src/main/java/org/monora/uprotocol/core/protocol/ClientType.java

@@ -0,0 +1,15 @@
+package org.monora.uprotocol.core.protocol;
+
+// TODO: 9/11/20 Mention this devices on other platforms too.
+
+/**
+ * This enum determines the type of the client.
+ */
+public enum ClientType
+{
+    Any,
+    Mobile,
+    Web,
+    Desktop,
+    IoT
+}

src/main/java/org/monora/uprotocol/core/protocol/ConnectionProvider.java

@@ -6,8 +6,8 @@
 import java.net.InetAddress;
 
 /**
- * This factory class is for opening connections in order to bypass the NAT/firewall. What this does is communicate with
- * the appropriate system resources before opening a connection.
+ * This factory class is responsible for opening connections in order to bypass the NAT/firewall. What this does is
+ * communicate with the appropriate system resources before opening a connection.
  */
 public interface ConnectionProvider
 {