allow selecting routes

.gitmodules

@@ -1,3 +1,4 @@
 [submodule "netbird"]
 	path = netbird
-	url = https://github.com/netbirdio/netbird.git
+	url = https://github.com/doromaraujo/netbird.git
+	branch = feature/android-allow-selecting-routes

app/src/main/java/io/netbird/client/MyApplication.java

@@ -7,6 +7,7 @@
 import androidx.appcompat.app.AppCompatDelegate;
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
 
+import io.netbird.client.repository.VPNServiceRepository;
 import io.netbird.client.tool.NetworkChangeNotifier;
 
 public class MyApplication extends Application {
@@ -28,4 +29,8 @@ public void registerNetworkReceiver() {
                 new IntentFilter(NetworkChangeNotifier.action)
         );
     }
+
+    public VPNServiceRepository getVPNServiceRepository() {
+        return new VPNServiceRepository(this);
+    }
 }

app/src/main/java/io/netbird/client/repository/VPNServiceBindListener.java

@@ -0,0 +1,5 @@
+package io.netbird.client.repository;
+
+public interface VPNServiceBindListener {
+    void onServiceBind();
+}

app/src/main/java/io/netbird/client/repository/VPNServiceRepository.java

@@ -0,0 +1,173 @@
+package io.netbird.client.repository;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.netbird.client.tool.RouteChangeListener;
+import io.netbird.client.tool.VPNService;
+import io.netbird.client.ui.home.NetworkDomain;
+import io.netbird.client.ui.home.Resource;
+import io.netbird.client.ui.home.RoutingPeer;
+import io.netbird.client.ui.home.Status;
+import io.netbird.gomobile.android.NetworkDomains;
+import io.netbird.gomobile.android.PeerRoutes;
+
+public class VPNServiceRepository {
+    private VPNService.MyLocalBinder binder;
+    private final Context context;
+    private VPNServiceBindListener serviceBindListener;
+
+    private final ServiceConnection serviceConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            binder = (VPNService.MyLocalBinder) service;
+            if (serviceBindListener != null) {
+                serviceBindListener.onServiceBind();
+            }
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            if (binder != null) {
+                binder = null;
+            }
+
+            serviceBindListener = null;
+        }
+    };
+
+    public VPNServiceRepository(Context context) {
+        this.context = context;
+    }
+
+    private List<String> createPeerRoutesList(PeerRoutes peerRoutes) {
+        List<String> routes = new ArrayList<>();
+
+        try {
+            for (int i = 0; i < peerRoutes.size(); i++) {
+                routes.add(peerRoutes.get(i));
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        return routes;
+    }
+
+    private List<NetworkDomain> createNetworkDomainsList(NetworkDomains networkDomains) {
+        List<NetworkDomain> domains = new ArrayList<>();
+
+        io.netbird.gomobile.android.NetworkDomain goNetworkDomain;
+        NetworkDomain networkDomain;
+        String ipAddress;
+
+        try {
+            for (int i = 0; i < networkDomains.size(); i++) {
+                goNetworkDomain = networkDomains.get(i);
+                networkDomain = new NetworkDomain(goNetworkDomain.getAddress());
+
+                var resolvedIPs = goNetworkDomain.getResolvedIPs();
+
+                for (int j = 0; j < resolvedIPs.size(); j++) {
+                    ipAddress = resolvedIPs.get(j);
+                    networkDomain.addResolvedIP(ipAddress);
+                }
+
+                domains.add(networkDomain);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        return domains;
+    }
+
+    public void setServiceBindListener(VPNServiceBindListener listener) {
+        this.serviceBindListener = listener;
+    }
+
+    public void bindService() {
+        var intent = new Intent(context, VPNService.class);
+        context.bindService(intent, serviceConnection, Context.BIND_ABOVE_CLIENT);
+    }
+
+    public void unbindService() {
+        if (binder != null) {
+            context.unbindService(serviceConnection);
+            binder = null;
+        }
+    }
+
+    public List<Resource> getNetworks() {
+        if (binder == null) {
+            return new ArrayList<>();
+        }
+
+        var resources = new ArrayList<Resource>();
+        var networks = binder.networks();
+
+        for (int i = 0; i < networks.size(); i++) {
+            var network = networks.get(i);
+            var networkDomains = network.getNetworkDomains();
+
+            resources.add(new Resource(Status.fromString(network.getStatus()),
+                    network.getName(),
+                    network.getNetwork(),
+                    network.getPeer(),
+                    network.getIsSelected(),
+                    createNetworkDomainsList(networkDomains)));
+        }
+
+        return resources;
+    }
+
+    public List<RoutingPeer> getRoutingPeers() {
+        if (binder == null) {
+            return new ArrayList<>();
+        }
+
+        var peers = new ArrayList<RoutingPeer>();
+        var peersFromEngine = binder.peersInfo();
+
+        for (int i = 0; i < peersFromEngine.size(); i++) {
+            var peerInfo = peersFromEngine.get(i);
+            var peerRoutes = peerInfo.getPeerRoutes();
+
+            peers.add(new RoutingPeer(
+                    Status.fromString(peerInfo.getConnStatus()),
+                    createPeerRoutesList(peerRoutes)));
+        }
+
+        return peers;
+    }
+
+    public void addRouteChangeListener(RouteChangeListener listener) {
+        if (binder != null) {
+            binder.addRouteChangeListener(listener);
+        }
+    }
+
+    public void removeRouteChangeListener(RouteChangeListener listener) {
+        if (binder != null) {
+            binder.removeRouteChangeListener(listener);
+        }
+    }
+
+    public void selectRoute(String route) throws Exception {
+        if (binder != null) {
+            binder.selectRoute(route);
+        }
+    }
+
+    public void deselectRoute(String route) throws Exception {
+        if (binder != null) {
+            binder.deselectRoute(route);
+        }
+    }
+}

app/src/main/java/io/netbird/client/ui/home/NetworkDomain.java

@@ -0,0 +1,26 @@
+package io.netbird.client.ui.home;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NetworkDomain {
+    private final String address;
+    private final List<String> resolvedIPs;
+
+    public NetworkDomain(String address) {
+        this.address = address;
+        this.resolvedIPs = new ArrayList<>();
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void addResolvedIP(String ipAddress) {
+        this.resolvedIPs.add(ipAddress);
+    }
+
+    public List<String> getResolvedIPs() {
+        return this.resolvedIPs;
+    }
+}

app/src/main/java/io/netbird/client/ui/home/NetworksAdapter.java

@@ -1,45 +1,50 @@
 package io.netbird.client.ui.home;
 
-import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.ViewGroup;
 
+import androidx.annotation.DrawableRes;
 import androidx.annotation.NonNull;
 import androidx.recyclerview.widget.RecyclerView;
 
-
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import io.netbird.client.R;
 import io.netbird.client.databinding.ListItemResourceBinding;
 
 public class NetworksAdapter extends RecyclerView.Adapter<NetworksAdapter.ResourceViewHolder> {
-
+    public interface RouteSwitchToggleHandler {
+        void handleSwitchToggle(String route, boolean isChecked) throws Exception;
+    }
 
     private final List<Resource> resourcesList;
+    private final List<RoutingPeer> peers;
     private final List<Resource> filteredResourcesList;
-
-
+    private final RouteSwitchToggleHandler switchToggleHandler;
     private String filterQueryString = "";
 
-    public NetworksAdapter(List<Resource> resourcesList) {
+    public NetworksAdapter(List<Resource> resourcesList, List<RoutingPeer> peers, RouteSwitchToggleHandler switchToggleHandler) {
         this.resourcesList = resourcesList;
+        this.peers = peers;
         filteredResourcesList = new ArrayList<>(resourcesList);
+        this.switchToggleHandler = switchToggleHandler;
         sort();
     }
 
     @NonNull
     @Override
     public ResourceViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
         // Use ViewBinding to inflate the layout
-        ListItemResourceBinding binding = ListItemResourceBinding.inflate(LayoutInflater.from(parent.getContext()), parent, false);
-        return new ResourceViewHolder(binding);
+        ListItemResourceBinding binding = ListItemResourceBinding.inflate(
+                LayoutInflater.from(parent.getContext()), parent, false);
+        return new ResourceViewHolder(binding, switchToggleHandler);
     }
 
     @Override
     public void onBindViewHolder(@NonNull ResourceViewHolder holder, int position) {
-        holder.bind(filteredResourcesList.get(position));
+        holder.bind(filteredResourcesList.get(position), peers);
     }
 
     @Override
@@ -67,7 +72,7 @@ private void doFilterBySearchQuery() {
 
         ArrayList<Resource> temporaryList = new ArrayList<>(resourcesList);
         for (Resource res : temporaryList) {
-            if (res.getName().toLowerCase().contains(filterQueryString.toLowerCase())){
+            if (res.getName().toLowerCase().contains(filterQueryString.toLowerCase())) {
                 filteredResourcesList.add(res);
             }
         }
@@ -81,24 +86,86 @@ private void sort() {
 
     public static class ResourceViewHolder extends RecyclerView.ViewHolder {
         ListItemResourceBinding binding;
+        RouteSwitchToggleHandler switchToggleHandler;
 
-        public ResourceViewHolder(ListItemResourceBinding binding) {
+        public ResourceViewHolder(ListItemResourceBinding binding, RouteSwitchToggleHandler switchToggleHandler) {
             super(binding.getRoot());
             this.binding = binding;
+            this.switchToggleHandler = switchToggleHandler;
+        }
+
+        /**
+         * <p>
+         * Returns a drawable indicating whether a given resource is CONNECTED, SELECTED or DESELECTED.
+         * A resource is considered CONNECTED when, given a list of routing peers, at least one of them
+         * also has a CONNECTED status and contains a route that maps to that given resource's address
+         * </p>
+         * <p>
+         * OR
+         * </p>
+         * <p>
+         * if the resource is mapped to a domain whose any of its resolved IP addresses is contained
+         * in any of the CONNECTED routing peer's routes.
+         * <p>
+         * Barring those conditions, it simply checks if the resource is selected or not.
+         * </p>
+         */
+        @DrawableRes
+        private int getConnectionStatusIndicatorDrawable(Resource resource, List<RoutingPeer> peers) {
+            var connectedPeers = peers.stream()
+                    .filter(peer -> peer.getStatus().equals(Status.CONNECTED))
+                    .collect(Collectors.toList());
+
+            var totalPeersWithRouteMatchingResourceAddress = connectedPeers.stream()
+                    .filter(peer -> peer.getRoutes().contains(resource.getAddress()))
+                    .count();
+
+            if (totalPeersWithRouteMatchingResourceAddress > 0) {
+                return R.drawable.peer_status_connected;
+            }
+
+            var allResolvedIPAddresses = resource.getDomains().stream()
+                    .flatMap(domain -> domain.getResolvedIPs().stream());
+
+            var allConnectedRoutingPeerRoutes = connectedPeers.stream()
+                    .flatMap(peer -> peer.getRoutes().stream())
+                    .collect(Collectors.toList());
+
+            if (allResolvedIPAddresses.anyMatch(allConnectedRoutingPeerRoutes::contains)) {
+                return R.drawable.peer_status_connected;
+            }
+
+            if (resource.isSelected()) return R.drawable.peer_status_selected;
+            return R.drawable.peer_status_disconnected;
         }
 
-        public void bind(Resource resource) {
+        public void bind(Resource resource, List<RoutingPeer> peers) {
             binding.address.setText(resource.getAddress());
             binding.name.setText(resource.getName());
             binding.peer.setText(resource.getPeer());
 
-            if (resource.getStatus() == Status.CONNECTED) {
-                binding.verticalLine.setBackgroundResource(R.drawable.peer_status_connected); // Green for connected
-            } else {
-                binding.verticalLine.setBackgroundResource(R.drawable.peer_status_disconnected); // Red for disconnected
-            }
-
-            if(resource.isExitNode()) {
+            // Necessary when rebinding because onCheckedChangeListener is already set.
+            binding.switchControl.setTag(true);
+
+            binding.switchControl.setChecked(resource.isSelected());
+            binding.switchControl.setTag(false);
+            binding.switchControl.setOnCheckedChangeListener((buttonView, isChecked) -> {
+                try {
+                    boolean tag = (boolean)binding.switchControl.getTag();
+                    if (!tag) {
+                        this.switchToggleHandler.handleSwitchToggle(resource.getName(), isChecked);
+                    }
+                } catch (Exception ignored) {
+                    // This is done so that reversing the toggle action won't retrigger the toggle handler.
+                    binding.switchControl.setTag(true);
+                    binding.switchControl.setChecked(!isChecked);
+                    binding.switchControl.setTag(false);
+                }
+            });
+
+            binding.verticalLine.setBackgroundResource(getConnectionStatusIndicatorDrawable(resource, peers));
+
+            if (resource.isExitNode()) {
                 binding.exitNode.setVisibility(android.view.View.VISIBLE);
             } else {
                 binding.exitNode.setVisibility(android.view.View.GONE);