refactor(Android): Remove android dependencies (#132)

Author: Rapsssito

.gitignore

@@ -33,6 +33,9 @@ local.properties
 android/gradle/
 android/gradlew
 android/gradlew.bat
+.project
+.classpath
+.settings
 
 # node.js
 #

android/src/main/java/com/asterinet/react/tcpsocket/TcpReceiverTask.java

@@ -5,33 +5,31 @@
 
 import com.facebook.react.bridge.ReadableMap;
 
+import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.security.GeneralSecurityException;
+import java.util.Arrays;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 import javax.net.SocketFactory;
 import javax.net.ssl.SSLSocket;
 import javax.net.ssl.SSLSocketFactory;
 
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
 class TcpSocketClient extends TcpSocket {
     private final ExecutorService listenExecutor;
     private final ExecutorService writeExecutor;
     private final TcpEventListener receiverListener;
-    private final TcpReceiverTask receiverTask;
+    private TcpReceiverTask receiverTask;
     private Socket socket;
 
-    TcpSocketClient(@NonNull final TcpEventListener receiverListener, @NonNull final Integer id, @Nullable final Socket socket) {
+    TcpSocketClient(TcpEventListener receiverListener, Integer id, Socket socket) {
         super(id);
         listenExecutor = Executors.newSingleThreadExecutor();
         writeExecutor = Executors.newSingleThreadExecutor();
-        receiverTask = new TcpReceiverTask(this, receiverListener);
         this.socket = socket;
         this.receiverListener = receiverListener;
     }
@@ -40,7 +38,7 @@ public Socket getSocket() {
         return socket;
     }
 
-    public void connect(@NonNull final Context context, @NonNull final String address, @NonNull final Integer port, @NonNull final ReadableMap options, @Nullable final Network network) throws IOException, GeneralSecurityException {
+    public void connect(Context context, String address, final Integer port, ReadableMap options, Network network) throws IOException, GeneralSecurityException {
         if (socket != null) throw new IOException("Already connected");
         final boolean isTls = options.hasKey("tls") && options.getBoolean("tls");
         if (isTls) {
@@ -80,6 +78,7 @@ public void connect(@NonNull final Context context, @NonNull final String addres
     }
 
     public void startListening() {
+        receiverTask = new TcpReceiverTask(this, receiverListener);
         listenExecutor.execute(receiverTask);
     }
 
@@ -147,4 +146,62 @@ public void pause() {
     public void resume() {
         receiverTask.resume();
     }
+
+    /**
+     * This is a specialized Runnable that receives data from a socket in the background, and
+     * notifies it's listener when data is received.  This is not threadsafe, the listener
+     * should handle synchronicity.
+     */
+    private static class TcpReceiverTask implements Runnable {
+
+        private final TcpSocketClient clientSocket;
+        private final TcpEventListener receiverListener;
+        private boolean paused = false;
+
+        public TcpReceiverTask(TcpSocketClient clientSocket, TcpEventListener receiverListener) {
+            this.clientSocket = clientSocket;
+            this.receiverListener = receiverListener;
+        }
+
+        /**
+         * An infinite loop to block and read data from the socket.
+         */
+        @Override
+        public void run() {
+            int socketId = clientSocket.getId();
+            Socket socket = clientSocket.getSocket();
+            byte[] buffer = new byte[16384];
+            try {
+                BufferedInputStream in = new BufferedInputStream(socket.getInputStream());
+                while (!socket.isClosed()) {
+                    int bufferCount = in.read(buffer);
+                    waitIfPaused();
+                    if (bufferCount > 0) {
+                        receiverListener.onData(socketId, Arrays.copyOfRange(buffer, 0, bufferCount));
+                    } else if (bufferCount == -1) {
+                        clientSocket.destroy();
+                    }
+                }
+            } catch (IOException | InterruptedException ioe) {
+                if (receiverListener != null && !socket.isClosed()) {
+                    receiverListener.onError(socketId, ioe.getMessage());
+                }
+            }
+        }
+
+        public synchronized void pause() {
+            paused = true;
+        }
+
+        public synchronized void resume() {
+            paused = false;
+            notify();
+        }
+
+        private synchronized void waitIfPaused() throws InterruptedException {
+            while (paused) {
+                wait();
+            }
+        }
+    }
 }

android/src/main/java/com/asterinet/react/tcpsocket/TcpSocketClient.java

@@ -1,8 +1,5 @@
 package com.asterinet.react.tcpsocket;
 
-import android.annotation.SuppressLint;
-import android.os.AsyncTask;
-
 import com.facebook.react.bridge.ReadableMap;
 
 import java.io.IOException;
@@ -14,39 +11,16 @@
 import java.util.concurrent.Executors;
 
 public final class TcpSocketServer extends TcpSocket {
-    private ServerSocket serverSocket;
     private final TcpEventListener mReceiverListener;
-    private int clientSocketIds;
-    private final ExecutorService executorService;
+    private final ExecutorService listenExecutor;
     private final ConcurrentHashMap<Integer, TcpSocket> socketClients;
-
-    @SuppressLint("StaticFieldLeak")
-    private final AsyncTask listening = new AsyncTask() {
-        @Override
-        protected Void doInBackground(Object[] objects) {
-            try {
-                while (!isCancelled() && !serverSocket.isClosed()) {
-                    Socket socket = serverSocket.accept();
-                    int clientId = getClientId();
-                    TcpSocketClient socketClient = new TcpSocketClient(mReceiverListener, clientId, socket);
-                    socketClients.put(clientId, socketClient);
-                    mReceiverListener.onConnection(getId(), clientId, socket);
-                    socketClient.startListening();
-                }
-            } catch (IOException e) {
-                if (!serverSocket.isClosed()) {
-                    mReceiverListener.onError(getId(), e.getMessage());
-                }
-            }
-            return null;
-        }
-    };
-
+    private ServerSocket serverSocket;
+    private int clientSocketIds;
 
     public TcpSocketServer(final ConcurrentHashMap<Integer, TcpSocket> socketClients, final TcpEventListener receiverListener, final Integer id,
                            final ReadableMap options) throws IOException {
         super(id);
-        this.executorService = Executors.newFixedThreadPool(1);
+        listenExecutor = Executors.newSingleThreadExecutor();
         // Get data from options
         int port = options.getInt("port");
         String address = options.getString("host");
@@ -73,6 +47,14 @@ public ServerSocket getServerSocket() {
         return serverSocket;
     }
 
+    private void addClient(Socket socket) {
+        int clientId = getClientId();
+        TcpSocketClient socketClient = new TcpSocketClient(mReceiverListener, clientId, socket);
+        socketClients.put(clientId, socketClient);
+        mReceiverListener.onConnection(getId(), clientId, socket);
+        socketClient.startListening();
+    }
+
     /**
      * Next ID for a client socket
      *
@@ -83,18 +65,12 @@ private int getClientId() {
     }
 
     private void listen() {
-        //noinspection unchecked
-        listening.executeOnExecutor(executorService);
+        TcpListenTask tcpListenTask = new TcpListenTask(this, mReceiverListener);
+        listenExecutor.execute(tcpListenTask);
     }
 
     public void close() {
         try {
-            if (!listening.isCancelled()) {
-                // stop the receiving task
-                listening.cancel(true);
-                executorService.shutdown();
-            }
-
             // close the socket
             if (serverSocket != null && !serverSocket.isClosed()) {
                 serverSocket.close();
@@ -105,4 +81,29 @@ public void close() {
             mReceiverListener.onClose(getId(), e.getMessage());
         }
     }
+
+    private static class TcpListenTask implements Runnable {
+        private final TcpEventListener receiverListener;
+        private final TcpSocketServer server;
+
+        private TcpListenTask(TcpSocketServer server, TcpEventListener receiverListener) {
+            this.server = server;
+            this.receiverListener = receiverListener;
+        }
+
+        @Override
+        public void run() {
+            ServerSocket serverSocket = server.getServerSocket();
+            try {
+                while (!serverSocket.isClosed()) {
+                    Socket socket = serverSocket.accept();
+                    server.addClient(socket);
+                }
+            } catch (IOException e) {
+                if (!serverSocket.isClosed()) {
+                    receiverListener.onError(server.getId(), e.getMessage());
+                }
+            }
+        }
+    }
 }