operators/maintenance page: syntax corrections

Release/v1.1.30 twix

.github/workflows/cd-docs.yml

@@ -87,9 +87,14 @@ jobs:
         run: vercel pull --yes --environment=production --token=${{ secrets.VERCEL_TOKEN }}
         working-directory: dist/docs
 
-      - name: Build Project Artifacts
+      - name: Build Project Artifacts (preview)
+        if: github.ref != 'refs/heads/master'
         run: vercel build --token=${{ secrets.VERCEL_TOKEN }}
         working-directory: dist/docs
+      - name: Build Project Artifacts (production)
+        if: github.ref == 'refs/heads/master'
+        run: vercel build --prod --token=${{ secrets.VERCEL_TOKEN }}
+        working-directory: dist/docs
 
       - name: Deploy Project Artifacts to Vercel (preview)
         if: github.ref != 'refs/heads/master'

common/client-core/src/client/real_messages_control/mod.rs

@@ -224,6 +224,6 @@ impl RealMessagesController<OsRng> {
             debug!("The reply controller has finished execution!");
         });
 
-        // ack_control.start_with_shutdown(shutdown, packet_type);
+        ack_control.start_with_shutdown(shutdown, packet_type);
     }
 }

common/client-libs/gateway-client/src/packet_router.rs

@@ -102,12 +102,12 @@ impl PacketRouter {
             }
         }
 
-        // if !received_acks.is_empty() {
-        //     trace!("routing acks");
-        //     if let Err(err) = self.ack_sender.unbounded_send(received_acks) {
-        //         error!("failed to send ack: {err}");
-        //     };
-        // }
+        if !received_acks.is_empty() {
+            trace!("routing acks");
+            if let Err(err) = self.ack_sender.unbounded_send(received_acks) {
+                error!("failed to send ack: {err}");
+            };
+        }
         Ok(())
     }
 }

documentation/docs/src/nodes/mixnode.md

@@ -1,6 +1,6 @@
 # Mix Nodes
 
-> The mix node setup and maintenance guide has migrated to the [Operator Guides book](https://nymtech.net/developers/nodes/mix-node-setup.html).
+> The mix node setup and maintenance guide has migrated to the [Operator Guides book](https://nymtech.net/operators/nodes/mix-node-setup.html).
 
 Mix nodes are the backbone of the mixnet. These are the nodes that perform 'mix mining', otherwise known simply as 'mixing'. 
 
@@ -14,4 +14,4 @@ Mix nodes are rewarded according to their quality of service, and the probabilit
 * [Nym Whitepaper](https://nymtech.net/nym-whitepaper.pdf) section 4 
 * [Nym Blog: Mix node deepdive](https://blog.nymtech.net/nym-mixnodes-deep-dive-d2b91917f097)
 * [Mixnet Traffic Flow overview](../architecture/traffic-flow.md)
-* [Reward Sharing for Mixnets](https://nymtech.net/nym-cryptoecon-paper.pdf)
+* [Reward Sharing for Mixnets](https://nymtech.net/nym-cryptoecon-paper.pdf)

documentation/docs/src/nodes/network-requester.md

@@ -1,6 +1,6 @@
 # Network Requester
 
-> The network requester setup and maintenance guide has moved to the [Operator Guides book](https://nymtech.net/developers/nodes/network-requester-setup.html).
+> The network requester setup and maintenance guide has moved to the [Operator Guides book](https://nymtech.net/operators/nodes/network-requester-setup.html).
 
 Network requesters are the first instance of the catch-all term 'service', or 'service providers'. In essence, think of services as being the part of the mixnet infrastructure that let you _do_ something, such as access emails, messaging service backends, or blockchains via the mixnet. 
 
@@ -19,4 +19,4 @@ This default whitelist is useful for knowing that the majority of Network reques
 
 ## Further reading
 * [Nym Blog: Network Requester deepdive](https://blog.nymtech.net/tech-deepdive-network-requesters-e5359a6cc31c)
-* [Nym Blog: Choose Your Character](https://blog.nymtech.net/choose-your-character-an-overview-of-nym-network-actors-19e6a9808540)
+* [Nym Blog: Choose Your Character](https://blog.nymtech.net/choose-your-character-an-overview-of-nym-network-actors-19e6a9808540)

documentation/operators/src/nodes/maintenance.md

@@ -10,7 +10,7 @@ A `build-info` command prints the build information like commit hash, rust versi
 
 For example `./target/debug/nym-network-requester --no-banner build-info --output json` will return:
 
-```
+```sh
 {"binary_name":"nym-network-requester","build_timestamp":"2023-07-24T15:38:37.00657Z","build_version":"1.1.23","commit_sha":"c70149400206dce24cf20babb1e64f22202672dd","commit_timestamp":"2023-07-24T14:45:45Z","commit_branch":"feature/simplify-cli-parsing","rustc_version":"1.71.0","rustc_channel":"stable","cargo_profile":"debug"}
 ```
 
@@ -57,25 +57,25 @@ If you are running an existing network requester registered with nym-connect, up
 
 Initiate the new network requester:
 
-```
+```sh
 nym-network-requester init --id <YOUR_ID>
 ```
 
 Copy the old keys from your client to the network-requester configuration that was created above:
 
-```
+```sh
 cp -vr ~/.nym/clients/myoldclient/data/* ~/.nym/service-providers/network-requester/<YOUR_ID>/data
 ```
 
 Edit the configuration to match what you used on your client. Specifically, edit the configuration file at:
 
-```
+```sh
 ~/.nym/service-providers/network-requester/<YOUR_ID>/config/config.toml
 ```
 
 Ensure that the fields `gateway_id`, `gateway_owner`, `gateway_listener` in the new config match those in the old client config at:
 
-```
+```sh
 ~/.nym/clients/myoldclient/config/config.toml
 ```
 
@@ -115,7 +115,8 @@ Assuming both machines are remote VPS.
 
 * Make sure your `~/.ssh/<YOUR_KEY>.pub` is in both of the machines `~/.ssh/authorized_keys` file
 * Create a `mixnodes` folder in the target VPS. Ssh in from your terminal and run:
-```
+
+```sh
 # in case none of the nym configs was created previously
 mkdir ~/.nym
 
@@ -123,7 +124,7 @@ mkdir ~/.nym
 mkdir ~/.nym/mixnodes
 ```
 * Move the node data (keys) and config file to the new machine by opening a local terminal (as that one's ssh key is authorized in both of the machines) and running:
-```
+```sh
 scp -r -3 <SOURCE_USER_NAME>@<SOURCE_HOST_ADDRESS>:~/.nym/mixnodes/<YOUR_ID> <TARGET_USER_NAME>@<TARGET_HOST_ADDRESS>:~/.nym/mixnodes/
 ```
 * Re-run init (remember that init doesn't overwrite existing keys) to generate a config with the new listening address etc.
@@ -134,7 +135,7 @@ scp -r -3 <SOURCE_USER_NAME>@<SOURCE_HOST_ADDRESS>:~/.nym/mixnodes/<YOUR_ID> <TA
 ### Configure your firewall
 Although your `<NODE>` is now ready to receive traffic, your server may not be. The following commands will allow you to set up a firewall using `ufw`.
 
-```
+```sh
 # check if you have ufw installed
 ufw version
 
@@ -150,7 +151,7 @@ sudo ufw status
 
 Finally open your `<NODE>` p2p port, as well as ports for ssh and ports for verloc and measurement pings:
 
-```
+```sh
 # for mix node
 sudo ufw allow 1789,1790,8000,22/tcp
 
@@ -165,7 +166,7 @@ sudo ufw allow 1317,26656,26660,22,80,443/tcp
 ```
 
 Check the status of the firewall:
-```
+```sh
 sudo ufw status
 ```
 
@@ -179,7 +180,7 @@ Although it’s not totally necessary, it's useful to have the mix node automati
 
 `nohup` is a command with which your terminal is told to ignore the `HUP` or 'hangup' signal. This will stop the node process ending if you kill your session.
 
-```
+```sh
 nohup ./<NODE> run --id <YOUR_ID> # where `<YOUR_ID>` is the id you set during the `init` command and <NODE> depends on which node you starting
 ```
 
@@ -207,17 +208,17 @@ No when you installed tmux on your VPS, let's run a mix node on tmux, which allo
 
 * Pause your `<NODE>`
 * Start tmux with the command 
-```
+```sh
 tmux
 ```
 * The tmux terminal should open in the same working directory, just the layout changed into tmux default layout.
 * Start the `<NODE>` again with a command:
-```
+```sh
 ./<NODE> run --id <YOUR_ID>
 ```
 * Now, without closing the tmux window, you can close the whole terminal and the `<NODE>` (and any other process running in tmux) will stay active.
 * Next time just start your teminal, ssh into the VPS and run the following command to attach back to your previous session:
-```
+```sh
 tmux attach-session
 ```
 * To see keybinding options of tmux press `ctrl`+`b` and after 1 second `?`
@@ -293,7 +294,7 @@ WantedBy=multi-user.target
 
 Now enable and start your requester:
 
-```
+```sh
 systemctl enable nym-network-requester.service
 systemctl start nym-network-requester.service
 
@@ -313,10 +314,10 @@ StartLimitInterval=350
 StartLimitBurst=10
 
 [Service]
-User=nyx                                                          # change to your user
+User=<USER>                                                       # change to your user
 Type=simple
-Environment="LD_LIBRARY_PATH=/home/youruser/path/to/nyx/binaries" # change to correct path
-ExecStart=/home/youruser/path/to/nyx/binaries/nymd start          # change to correct path
+Environment="LD_LIBRARY_PATH=/home/<USER>/<PATH_TO_NYX_BINARIES>" # change to correct path
+ExecStart=/home/<USER>/<PATH_TO_NYX_BINARIES>/nymd start          # change to correct path
 Restart=on-failure
 RestartSec=30
 LimitNOFILE=infinity
@@ -327,11 +328,11 @@ WantedBy=multi-user.target
 
 Proceed to start it with:
 
-```
+```sh
 systemctl daemon-reload # to pickup the new unit file
 systemctl enable nymd   # to enable the service
 systemctl start nymd    # to actually start the service
-journalctl -f           # to monitor system logs showing the service start
+journalctl -f -u nymd # to monitor system logs showing the service start
 ```
 
 ##### Following steps for Nym Mixnet nodes
@@ -344,9 +345,13 @@ If you have built nym in the `$HOME` directory on your server, and your username
 
 Then run:
 
+```sh
+systemctl daemon-reload # to pickup the new unit file
 ```
+
+```sh
 # for mix node
-systemctl enable nym-mix node.service
+systemctl enable nym-mixnode.service
 
 # for gateway
 systemctl enable nym-gateway.service
@@ -354,7 +359,7 @@ systemctl enable nym-gateway.service
 
 Start your node:
 
-```
+```sh
 # for mix node
 service nym-mixnode start
 
@@ -365,6 +370,16 @@ service nym-gateway start
 
 This will cause your node to start at system boot time. If you restart your machine, the node will come back up automatically.
 
+You can monitor system logs of your node by running:
+```sh
+journalctl -f -u <NODE>.service
+```
+
+Or check a status by running:
+```sh
+systemctl status <NODE>.service
+```
+
 You can also do `service <NODE> stop` or `service <NODE> restart`.
 
 Note: if you make any changes to your systemd script after you've enabled it, you will need to run:
@@ -383,7 +398,7 @@ Linux machines limit how many open files a user is allowed to have. This is call
 
 If you see errors such as:
 
-```
+```sh
 Failed to accept incoming connection - Os { code: 24, kind: Other, message: "Too many open files" }
 ```
 
@@ -397,8 +412,8 @@ The ulimit setup is relevant for maintenance of nym mix node only.
 
 Query the `ulimit` of your `<NODE>` with:
 
-```
-# for nym-, nym-gateway and nym-network requester:
+```sh
+# for nym-mixnode, nym-gateway and nym-network requester:
 grep -i "open files" /proc/$(ps -A -o pid,cmd|grep <NODE> | grep -v grep |head -n 1 | awk '{print $1}')/limits
 
 # for nyx validator:
@@ -409,7 +424,7 @@ grep -i "open files" /proc/$(ps -A -o pid,cmd|grep nymd | grep -v grep |head -n
 
 You'll get back the hard and soft limits, which looks something like this:
 
-```
+```sh
 Max open files            65536                65536                files
 ```
 
@@ -417,26 +432,26 @@ If your output is **the same as above**, your node will not encounter any `ulimi
 
 However if either value is `1024`, you must raise the limit via the systemd service file. Add the line:
 
-```
+```sh
 LimitNOFILE=65536
 ```
 
 Reload the daemon:
 
-```
+```sh
 systemctl daemon-reload
 ```
 
 or execute this as root for system-wide setting of `ulimit`:
 
-```
+```sh
 echo "DefaultLimitNOFILE=65535" >> /etc/systemd/system.conf
 ```
 
 Reboot your machine and restart your node. When it comes back, use:
-```
+```sh
 # for nym-mixnode, nym-gateway and nym-network requester:
-cat /proc/$(pidof <NODE>)/limits | grep "Max open files"` to make sure the limit has changed to 65535.
+cat /proc/$(pidof <NODE>)/limits | grep "Max open files"
 
 # for validator
 cat /proc/$(pidof nym-validator)/limits | grep "Max open files"
@@ -447,7 +462,7 @@ Make sure the limit has changed to 65535.
 
 In case you chose tmux option for mix node automatization, see your `ulimit` list by running:
 
-```
+```sh
 ulimit -a
 
 # watch for the output line -n
@@ -456,13 +471,13 @@ ulimit -a
 
 You can change it either by running a command:
 
-```
+```sh
 ulimit -u -n 4096
 ```
 
 or editing `etc/security/conf` and add the following lines:
 
-```
+```sh
 # Example hard limit for max opened files
 username        hard nofile 4096
 
@@ -479,7 +494,7 @@ On some services (AWS, Google, etc) the machine's available bind address is not
 
 For example, on a Google machine, you may see the following output from the `ifconfig` command:
 
-```
+```sh
 ens4: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1460
         inet 10.126.5.7  netmask 255.255.255.255  broadcast 0.0.0.0
         ...
@@ -492,7 +507,7 @@ The `ens4` interface has the IP `10.126.5.7`. But this isn't the public IP of th
 Trying `nym-mixnode init --host 36.68.243.18`, you'll get back a startup error saying `AddrNotAvailable`. This is because the mix node doesn't know how to bind to a host that's not in the output of `ifconfig`.
 
 The right thing to do in this situation is to init with a command:
-```
+```sh
 ./nym-mixnode init --host 10.126.5.7 --announce-host 36.68.243.18
 ```
 
@@ -513,13 +528,13 @@ The endpoint is a particularly common for mix node operators as it can provide a
 
 Using this API endpoint returns information about the Reward Estimation:
 
-```
+```sh
 /status/mixnode/<MIX_ID>/reward-estimation
 ```
 
 Query Response:
 
-```
+```sh
     "estimation": {
         "total_node_reward": "942035.916721770541325331",
         "operator": "161666.263307386408152071",
@@ -546,19 +561,19 @@ Query Response:
 
 Install `nginx` and allow the 'Nginx Full' rule in your firewall:
 
-```
+```sh
 sudo ufw allow 'Nginx Full'
 ```
 
 Check nginx is running via systemctl:
 
-```
+```sh
 systemctl status nginx
 ```
 
 Which should return:
 
-```
+```sh
 ● nginx.service - A high performance web server and a reverse proxy server
    Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
    Active: active (running) since Fri 2018-04-20 16:08:19 UTC; 3 days ago
@@ -574,7 +589,7 @@ Which should return:
 
 Proxying your validator's port `26657` to nginx port `80` can then be done by creating a file with the following at `/etc/nginx/conf.d/validator.conf`:
 
-```
+```sh
 server {
   listen 80;
   listen [::]:80;
@@ -591,7 +606,7 @@ server {
 
 Followed by:
 
-```
+```sh
 sudo apt install certbot nginx python3
 certbot --nginx -d nym-validator.yourdomain.com -m you@yourdomain.com --agree-tos --noninteractive --redirect
 ```
@@ -606,7 +621,7 @@ These commands will get you an https encrypted nginx proxy in front of the API.
 
 Configure Prometheus with the following commands (adapted from NodesGuru's [Agoric setup guide](https://nodes.guru/agoric/setup-guide/en)):
 
-```
+```sh
 echo 'export OTEL_EXPORTER_PROMETHEUS_PORT=9464' >> $HOME/.bashrc
 source ~/.bashrc
 sed -i '/\[telemetry\]/{:a;n;/enabled/s/false/true/;Ta}' $HOME/.nymd/config/app.toml

explorer-api/explorer-client/src/lib.rs

@@ -1,4 +1,3 @@
-#[cfg(not(target_arch = "wasm32"))]
 use std::time::Duration;
 
 use reqwest::StatusCode;

gateway/Cargo.toml

@@ -37,7 +37,7 @@ serde_json = { workspace = true }
 sqlx = { version = "0.5", features = [ "runtime-tokio-rustls", "sqlite", "macros", "migrate", ] }
 subtle-encoding = { version = "0.5", features = ["bech32-preview"] }
 thiserror = "1"
-tokio = { workspace = true, features = [ "rt-multi-thread", "net", "signal", "fs", "time" ] }
+tokio = { version = "1.24.1", features = [ "rt-multi-thread", "net", "signal", "fs", ] }
 tokio-stream = { version = "0.1.11", features = ["fs"] }
 tokio-tungstenite = "0.14"
 tokio-util = { version = "0.7.4", features = ["codec"] }

gateway/src/node/client_handling/active_clients.rs

@@ -1,23 +1,13 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::node::client_handling::websocket::message_receiver::MixMessageSender;
 use dashmap::DashMap;
 use nym_sphinx::DestinationAddressBytes;
 use std::sync::Arc;
 
-use super::websocket::message_receiver::{IsActiveRequestSender, MixMessageSender};
-
 #[derive(Clone)]
-pub(crate) struct ActiveClientsStore(Arc<DashMap<DestinationAddressBytes, ClientIncomingChannels>>);
-
-#[derive(Clone)]
-pub(crate) struct ClientIncomingChannels {
-    // Mix messages coming from the mixnet to the handler of a client.
-    pub mix_message_sender: MixMessageSender,
-
-    // Requests sent from the handler of one client to the handler of other clients.
-    pub is_active_request_sender: IsActiveRequestSender,
-}
+pub(crate) struct ActiveClientsStore(Arc<DashMap<DestinationAddressBytes, MixMessageSender>>);
 
 impl ActiveClientsStore {
     /// Creates new instance of `ActiveClientsStore` to store in-memory handles to all currently connected clients.
@@ -31,13 +21,13 @@ impl ActiveClientsStore {
     /// # Arguments
     ///
     /// * `client`: address of the client for which to obtain the handle.
-    pub(crate) fn get(&self, client: DestinationAddressBytes) -> Option<ClientIncomingChannels> {
+    pub(crate) fn get(&self, client: DestinationAddressBytes) -> Option<MixMessageSender> {
         let entry = self.0.get(&client)?;
         let handle = entry.value();
 
         // if the entry is stale, remove it from the map
         // if handle.is_valid() {
-        if !handle.mix_message_sender.is_closed() {
+        if !handle.is_closed() {
             Some(handle.clone())
         } else {
             // drop the reference to the map to prevent deadlocks
@@ -62,19 +52,8 @@ impl ActiveClientsStore {
     ///
     /// * `client`: address of the client for which to insert the handle.
     /// * `handle`: the sender channel for all mix packets to be pushed back onto the websocket
-    pub(crate) fn insert(
-        &self,
-        client: DestinationAddressBytes,
-        handle: MixMessageSender,
-        is_active_request_sender: IsActiveRequestSender,
-    ) {
-        self.0.insert(
-            client,
-            ClientIncomingChannels {
-                mix_message_sender: handle,
-                is_active_request_sender,
-            },
-        );
+    pub(crate) fn insert(&self, client: DestinationAddressBytes, handle: MixMessageSender) {
+        self.0.insert(client, handle);
     }
 
     /// Get number of active clients in store

gateway/src/node/client_handling/websocket/connection_handler/authenticated.rs

@@ -1,39 +1,28 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use futures::{
-    future::{FusedFuture, OptionFuture},
-    FutureExt, StreamExt,
-};
+use crate::node::client_handling::websocket::connection_handler::{ClientDetails, FreshHandler};
+use crate::node::client_handling::websocket::message_receiver::MixMessageReceiver;
+use crate::node::storage::error::StorageError;
+use crate::node::storage::Storage;
+use futures::StreamExt;
 use log::*;
-use nym_gateway_requests::{
-    iv::{IVConversionError, IV},
-    types::{BinaryRequest, ServerResponse},
-    ClientControlRequest, GatewayRequestsError,
-};
+use nym_gateway_requests::iv::IVConversionError;
+use nym_gateway_requests::types::{BinaryRequest, ServerResponse};
+use nym_gateway_requests::{ClientControlRequest, GatewayRequestsError};
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_task::TaskClient;
-use nym_validator_client::coconut::CoconutApiError;
 use rand::{CryptoRng, Rng};
+use std::convert::TryFrom;
+use std::process;
 use thiserror::Error;
 use tokio::io::{AsyncRead, AsyncWrite};
-use tokio_tungstenite::tungstenite::{protocol::Message, Error as WsError};
+use tokio_tungstenite::tungstenite::protocol::Message;
 
-use std::{convert::TryFrom, process, time::Duration};
-
-use crate::node::{
-    client_handling::{
-        bandwidth::Bandwidth,
-        websocket::{
-            connection_handler::{ClientDetails, FreshHandler},
-            message_receiver::{
-                IsActive, IsActiveRequestReceiver, IsActiveResultSender, MixMessageReceiver,
-            },
-        },
-        FREE_TESTNET_BANDWIDTH_VALUE,
-    },
-    storage::{error::StorageError, Storage},
-};
+use crate::node::client_handling::bandwidth::Bandwidth;
+use crate::node::client_handling::FREE_TESTNET_BANDWIDTH_VALUE;
+use nym_gateway_requests::iv::IV;
+use nym_task::TaskClient;
+use nym_validator_client::coconut::CoconutApiError;
 
 #[derive(Debug, Error)]
 pub(crate) enum RequestHandlingError {
@@ -108,11 +97,6 @@ pub(crate) struct AuthenticatedHandler<R, S, St> {
     inner: FreshHandler<R, S, St>,
     client: ClientDetails,
     mix_receiver: MixMessageReceiver,
-    // Occasionally the handler is requested to ping the connected client for confirm that it's
-    // active, such as when a duplicate connection is detected. This hashmap stores the oneshot
-    // senders that are used to return the result of the ping to the handler requesting the ping.
-    is_active_request_receiver: IsActiveRequestReceiver,
-    is_active_ping_pending_reply: Option<(u64, IsActiveResultSender)>,
 }
 
 // explicitly remove handle from the global store upon being dropped
@@ -143,14 +127,11 @@ where
         fresh: FreshHandler<R, S, St>,
         client: ClientDetails,
         mix_receiver: MixMessageReceiver,
-        is_active_request_receiver: IsActiveRequestReceiver,
     ) -> Self {
         AuthenticatedHandler {
             inner: fresh,
             client,
             mix_receiver,
-            is_active_request_receiver,
-            is_active_ping_pending_reply: None,
         }
     }
 
@@ -370,29 +351,6 @@ where
         }
     }
 
-    /// Handles pong message received from the client.
-    /// If the client is still active, the handler that requested the ping will receive a reply.
-    async fn handle_pong(&mut self, msg: Vec<u8>) {
-        if let Ok(msg) = msg.try_into() {
-            let msg = u64::from_be_bytes(msg);
-            trace!("Received pong from client: {}", msg);
-            if let Some((tag, _)) = &self.is_active_ping_pending_reply {
-                if tag == &msg {
-                    debug!("Reporting back to the handler that the client is still active");
-                    let tx = self.is_active_ping_pending_reply.take().unwrap().1;
-                    if let Err(err) = tx.send(IsActive::Active) {
-                        warn!("Failed to send pong reply back to the requesting handler: {err:?}");
-                    }
-                } else {
-                    warn!(
-                        "Received pong reply from the client with unexpected tag: {}",
-                        msg
-                    );
-                }
-            }
-        }
-    }
-
     /// Attempts to handle websocket message received from the connected client.
     ///
     /// # Arguments
@@ -405,64 +363,10 @@ where
         match raw_request {
             Message::Binary(bin_msg) => Some(self.handle_binary(bin_msg).await),
             Message::Text(text_msg) => Some(self.handle_text(text_msg).await),
-            Message::Pong(msg) => {
-                self.handle_pong(msg).await;
-                None
-            }
             _ => None,
         }
     }
 
-    /// Send a ping to the connected client and return a tag identifying the ping.
-    async fn send_ping(&mut self) -> Result<u64, WsError>
-    where
-        S: AsyncRead + AsyncWrite + Unpin,
-    {
-        let tag: u64 = rand::thread_rng().gen();
-        debug!("Got request to ping our connection: {}", tag);
-        self.inner
-            .send_websocket_message(Message::Ping(tag.to_be_bytes().to_vec()))
-            .await?;
-        Ok(tag)
-    }
-
-    /// Handles the ping timeout by responding back to the handler that requested the ping.
-    async fn handle_ping_timeout(&mut self) {
-        debug!("Ping timeout expired!");
-        if let Some((_tag, reply_tx)) = self.is_active_ping_pending_reply.take() {
-            if let Err(err) = reply_tx.send(IsActive::NotActive) {
-                warn!("Failed to respond back to the handler requesting the ping: {err:?}");
-            }
-        }
-    }
-
-    async fn handle_is_active_request(
-        &mut self,
-        reply_tx: IsActiveResultSender,
-    ) -> Result<(), WsError>
-    where
-        S: AsyncRead + AsyncWrite + Unpin,
-    {
-        if self.is_active_ping_pending_reply.is_some() {
-            warn!("Received request to ping the client, but a ping is already in progress!");
-            if let Err(err) = reply_tx.send(IsActive::BusyPinging) {
-                warn!("Failed to respond back to the handler requesting the ping: {err:?}");
-            }
-            return Ok(());
-        }
-
-        match self.send_ping().await {
-            Ok(tag) => {
-                self.is_active_ping_pending_reply = Some((tag, reply_tx));
-                Ok(())
-            }
-            Err(err) => {
-                warn!("Failed to send ping to client: {err}. Assuming the connection is dead.");
-                Err(err)
-            }
-        }
-    }
-
     /// Simultaneously listens for incoming client requests, which realistically should only be
     /// binary requests to forward sphinx packets or increase bandwidth
     /// and for sphinx packets received from the mix network that should be sent back to the client.
@@ -473,32 +377,11 @@ where
     {
         trace!("Started listening for ALL incoming requests...");
 
-        // Ping timeout future used to check if the client responded to our ping request
-        let mut ping_timeout: OptionFuture<_> = None.into();
-
         while !shutdown.is_shutdown() {
             tokio::select! {
                 _ = shutdown.recv() => {
                     log::trace!("client_handling::AuthenticatedHandler: received shutdown");
-                },
-                // Received a request to ping the client to check if it's still active
-                tx = self.is_active_request_receiver.next() => {
-                    match tx {
-                        None => break,
-                        Some(reply_tx) => {
-                            if self.handle_is_active_request(reply_tx).await.is_err() {
-                                break;
-                            }
-                            // NOTE: fuse here due to .is_terminated() check below
-                            ping_timeout = Some(Box::pin(tokio::time::sleep(Duration::from_millis(1000)).fuse())).into();
-                        }
-                    };
-                },
-                // The ping timeout expired, meaning the client didn't respond to our ping request
-                _ = &mut ping_timeout, if !ping_timeout.is_terminated() => {
-                   ping_timeout = None.into();
-                   self.handle_ping_timeout().await;
-                },
+                }
                 socket_msg = self.inner.read_websocket_message() => {
                     let socket_msg = match socket_msg {
                         None => break,
@@ -523,13 +406,7 @@ where
                     }
                 },
                 mix_messages = self.mix_receiver.next() => {
-                    let mix_messages = match mix_messages {
-                        None => {
-                            warn!("mix receiver was closed! Assuming the connection is dead.");
-                            break;
-                        }
-                        Some(mix_messages) => mix_messages,
-                    };
+                    let mix_messages = mix_messages.expect("sender was unexpectedly closed! this shouldn't have ever happened!");
                     if let Err(err) = self.inner.push_packets_to_client(&self.client.shared_keys, mix_messages).await {
                         warn!("failed to send the unwrapped sphinx packets back to the client - {err}, assuming the connection is dead");
                         break;

gateway/src/node/client_handling/websocket/connection_handler/fresh.rs

@@ -1,43 +1,33 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use futures::{
-    channel::{mpsc, oneshot},
-    SinkExt, StreamExt,
+use crate::node::client_handling::active_clients::ActiveClientsStore;
+use crate::node::client_handling::websocket::connection_handler::coconut::CoconutVerifier;
+use crate::node::client_handling::websocket::connection_handler::{
+    AuthenticatedHandler, ClientDetails, InitialAuthResult, SocketStream,
 };
+use crate::node::storage::error::StorageError;
+use crate::node::storage::Storage;
+use futures::{channel::mpsc, SinkExt, StreamExt};
 use log::*;
 use nym_crypto::asymmetric::identity;
 use nym_gateway_requests::authentication::encrypted_address::{
     EncryptedAddressBytes, EncryptedAddressConversionError,
 };
-use nym_gateway_requests::{
-    iv::{IVConversionError, IV},
-    registration::handshake::{error::HandshakeError, gateway_handshake, SharedKeys},
-    types::{ClientControlRequest, ServerResponse},
-    BinaryResponse, PROTOCOL_VERSION,
-};
+use nym_gateway_requests::iv::{IVConversionError, IV};
+use nym_gateway_requests::registration::handshake::error::HandshakeError;
+use nym_gateway_requests::registration::handshake::{gateway_handshake, SharedKeys};
+use nym_gateway_requests::types::{ClientControlRequest, ServerResponse};
+use nym_gateway_requests::{BinaryResponse, PROTOCOL_VERSION};
 use nym_mixnet_client::forwarder::MixForwardingSender;
 use nym_sphinx::DestinationAddressBytes;
 use rand::{CryptoRng, Rng};
-use std::{convert::TryFrom, sync::Arc, time::Duration};
+use std::convert::TryFrom;
+use std::sync::Arc;
 use thiserror::Error;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_tungstenite::tungstenite::{protocol::Message, Error as WsError};
 
-use crate::node::{
-    client_handling::{
-        active_clients::ActiveClientsStore,
-        websocket::{
-            connection_handler::{
-                coconut::CoconutVerifier, AuthenticatedHandler, ClientDetails, InitialAuthResult,
-                SocketStream,
-            },
-            message_receiver::{IsActive, IsActiveRequestSender},
-        },
-    },
-    storage::{error::StorageError, Storage},
-};
-
 #[derive(Debug, Error)]
 pub(crate) enum InitialAuthenticationError {
     #[error("Internal gateway storage error")]
@@ -404,59 +394,6 @@ where
         }
     }
 
-    async fn handle_duplicate_client(
-        &mut self,
-        address: DestinationAddressBytes,
-        mut is_active_request_tx: IsActiveRequestSender,
-    ) -> Result<(), InitialAuthenticationError> {
-        // Ask the other connection to ping if they are still active.
-        // Use a oneshot channel to return the result to us
-        let (ping_result_sender, ping_result_receiver) = oneshot::channel();
-        log::debug!("Asking other connection handler to ping the connected client to see if it is still active");
-        if let Err(err) = is_active_request_tx.send(ping_result_sender).await {
-            warn!("Failed to send ping request to other handler: {err}");
-        }
-
-        // Wait for the reply
-        match tokio::time::timeout(Duration::from_millis(2000), ping_result_receiver).await {
-            Ok(Ok(res)) => {
-                match res {
-                    IsActive::NotActive => {
-                        // The other handler reported that the client is not active, so we can
-                        // disconnect the other client and continue with this connection.
-                        log::debug!("Other handler reports it is not active");
-                        self.active_clients_store.disconnect(address);
-                    }
-                    IsActive::Active => {
-                        // The other handled reported a positive reply, so we have to assume it's
-                        // still active and disconnect this connection.
-                        log::info!("Other handler reports it is active");
-                        return Err(InitialAuthenticationError::DuplicateConnection);
-                    }
-                    IsActive::BusyPinging => {
-                        // The other handler is already busy pinging the client, so we have to
-                        // assume it's still active and disconnect this connection.
-                        log::debug!("Other handler reports it is already busy pinging the client");
-                        return Err(InitialAuthenticationError::DuplicateConnection);
-                    }
-                }
-            }
-            Ok(Err(_)) => {
-                // Other channel failed to reply (the channel sender probably dropped)
-                log::info!("Other connection failed to reply, disconnecting it in favour of this new connection");
-                self.active_clients_store.disconnect(address);
-            }
-            Err(_) => {
-                // Timeout waiting for reply
-                log::warn!(
-                    "Other connection timed out, disconnecting it in favour of this new connection"
-                );
-                self.active_clients_store.disconnect(address);
-            }
-        }
-        Ok(())
-    }
-
     /// Tries to handle the received authentication request by checking correctness of the received data.
     ///
     /// # Arguments
@@ -481,11 +418,8 @@ where
         let encrypted_address = EncryptedAddressBytes::try_from_base58_string(enc_address)?;
         let iv = IV::try_from_base58_string(iv)?;
 
-        // Check for duplicate clients
-        if let Some(client_tx) = self.active_clients_store.get(address) {
-            log::warn!("Detected duplicate connection for client: {}", address);
-            self.handle_duplicate_client(address, client_tx.is_active_request_sender)
-                .await?;
+        if self.active_clients_store.get(address).is_some() {
+            return Err(InitialAuthenticationError::DuplicateConnection);
         }
 
         let shared_keys = self
@@ -672,19 +606,12 @@ where
                             }
 
                             return if let Some(client_details) = auth_result.client_details {
-                                // Channel for handlers to ask other handlers if they are still active.
-                                let (is_active_request_sender, is_active_request_receiver) =
-                                    mpsc::unbounded();
-                                self.active_clients_store.insert(
-                                    client_details.address,
-                                    mix_sender,
-                                    is_active_request_sender,
-                                );
+                                self.active_clients_store
+                                    .insert(client_details.address, mix_sender);
                                 Some(AuthenticatedHandler::upgrade(
                                     self,
                                     client_details,
                                     mix_receiver,
-                                    is_active_request_receiver,
                                 ))
                             } else {
                                 None

gateway/src/node/client_handling/websocket/connection_handler/mod.rs

@@ -100,7 +100,7 @@ pub(crate) async fn handle_connection<R, S, St>(
         .await
     {
         None => {
-            trace!("received shutdown signal while performing initial authentication");
+            trace!("received shutdown signal while performing initial authetnication");
             return;
         }
         Some(None) => {

gateway/src/node/client_handling/websocket/message_receiver.rs

@@ -1,20 +1,7 @@
 // Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use futures::channel::{mpsc, oneshot};
+use futures::channel::mpsc;
 
 pub(crate) type MixMessageSender = mpsc::UnboundedSender<Vec<Vec<u8>>>;
 pub(crate) type MixMessageReceiver = mpsc::UnboundedReceiver<Vec<Vec<u8>>>;
-
-// Channels used for one handler to requester another handler to check that the client is still
-// active. The result is then passed back to the requesting handler in the oneshot channel.
-pub(crate) type IsActiveRequestSender = mpsc::UnboundedSender<IsActiveResultSender>;
-pub(crate) type IsActiveRequestReceiver = mpsc::UnboundedReceiver<IsActiveResultSender>;
-
-#[derive(Debug)]
-pub(crate) enum IsActive {
-    Active,
-    NotActive,
-    BusyPinging,
-}
-pub(crate) type IsActiveResultSender = oneshot::Sender<IsActive>;

gateway/src/node/mixnet_handling/receiver/connection_handler.rs

@@ -70,9 +70,9 @@ impl<St: Storage> ConnectionHandler<St> {
     }
 
     fn update_clients_store_cache_entry(&mut self, client_address: DestinationAddressBytes) {
-        if let Some(client_senders) = self.active_clients_store.get(client_address) {
+        if let Some(client_sender) = self.active_clients_store.get(client_address) {
             self.clients_store_cache
-                .insert(client_address, client_senders.mix_message_sender);
+                .insert(client_address, client_sender);
         }
     }
 

nym-connect/desktop/Cargo.lock

@@ -3992,7 +3992,7 @@ dependencies = [
 
 [[package]]
 name = "nym-connect"
-version = "1.1.20"
+version = "1.1.19"
 dependencies = [
  "anyhow",
  "bip39",

nym-vpn/android/.gitignore

@@ -1,71 +0,0 @@
-# Built application files
-*.apk
-*.aar
-*.ap_
-*.aab
-# Files for the ART/Dalvik VM
-*.dex
-# Java class files
-*.class
-# Generated files
-bin/
-gen/
-out/
-release/
-build/
-# Gradle files
-.gradle/
-# Local configuration file (sdk path, etc)
-local.properties
-# Proguard folder generated by Eclipse
-proguard/
-# Log Files
-*.log
-# Android Studio Navigation editor temp files
-.navigation/
-# Android Studio captures folder
-captures/
-# IntelliJ
-*.iml
-.idea/
-# .idea/workspace.xml
-# .idea/tasks.xml
-# .idea/gradle.xml
-# .idea/assetWizardSettings.xml
-# .idea/dictionaries
-.idea/libraries
-# Android Studio 3 in .gitignore file.
-.idea/caches
-.idea/modules.xml
-# Comment next line if keeping position of elements in Navigation Editor is relevant for you
-.idea/navEditor.xml
-# Keystore files
-# Uncomment the following lines if you do not want to check your keystore files in.
-*.jks
-*.keystore
-# External native build folder generated in Android Studio 2.2 and later
-.externalNativeBuild
-.cxx/
-# Freeline
-freeline.py
-freeline/
-freeline_project_description.json
-# fastlane
-fastlane/report.xml
-fastlane/Preview.html
-fastlane/screenshots
-fastlane/test_output
-fastlane/readme.md
-# Version control
-vcs.xml
-# lint
-lint/intermediates/
-lint/generated/
-lint/outputs/
-lint/tmp/
-# lint/reports/
-# MacOS
-.DS_Store
-# App Specific cases
-app/release/output.json
-.idea/codeStyles/

nym-vpn/android/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 NymConnect
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

nym-vpn/android/README.md

@@ -1,42 +0,0 @@
-## NymConnect for Android
-
-### Prerequisites
-
-_TODO_
-
-### Getting started
-
-[Install](https://developer.android.com/studio/install) Android Studio and open
-the project.\
-Setup an android emulator using AVD.\
-[Run](https://developer.android.com/studio/run/emulator) the project.
-
-**⚠ NOTE**: be sure
-to [set](https://developer.android.com/studio/run#changing-variant)
-the build variant to `x86_64Debug` when running on emulator
-
-### Features
-
-* Add tunnels via .conf file
-* Auto connect to VPN based on Wi-Fi SSID
-* Split tunneling by application with search
-* Always-on VPN for Android support
-* Quick tile support for vpn toggling
-* Dynamic shortcuts support for automation integration
-* Configurable Trusted Network list 
-* Optional auto connect on mobile data
-* Automatic service restart after reboot
-* Service will stay running in background after app has been closed
-
-### Building
-
-_TODO_
-
-### Credits
-
-This project is based on the "WG Tunnel" project made by Zane Schepke
-https://github.com/zaneschepke/wgtunnel
-
-### License
-
-MIT

nym-vpn/android/app/.gitignore

@@ -1,2 +0,0 @@
-/build
-/release

nym-vpn/android/app/build.gradle.kts

@@ -1,159 +0,0 @@
-val rExtra = rootProject.extra
-
-plugins {
-    id("com.android.application")
-    id("org.jetbrains.kotlin.android")
-    kotlin("kapt")
-    id("com.google.dagger.hilt.android")
-    id("org.jetbrains.kotlin.plugin.serialization")
-    id("io.objectbox")
-}
-
-android {
-    namespace = "net.nymtech.nymconnect"
-    compileSdk = 34
-
-    val versionMajor = 1
-    val versionMinor = 0
-    val versionPatch = 0
-    val versionBuild = 0
-
-    defaultConfig {
-        applicationId = "net.nymtech.nymconnect"
-        minSdk = 28
-        targetSdk = 34
-        versionCode = versionMajor * 10000 + versionMinor * 1000 + versionPatch * 100 + versionBuild
-        versionName = "${versionMajor}.${versionMinor}.${versionPatch}"
-
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        vectorDrawables {
-            useSupportLibrary = true
-        }
-    }
-
-    buildTypes {
-        release {
-            isDebuggable = false
-            isMinifyEnabled = false
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-    kotlinOptions {
-        jvmTarget = "17"
-    }
-    buildFeatures {
-        compose = true
-    }
-    composeOptions {
-        kotlinCompilerExtensionVersion = "1.4.8"
-    }
-    packaging {
-        resources {
-            excludes += "/META-INF/{AL2.0,LGPL2.1}"
-        }
-    }
-
-    /* flavorDimensions += "abi"
-    productFlavors {
-        create("universal") {
-            dimension = "abi"
-            ndk {
-                abiFilters += listOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
-            }
-        }
-        create("arch64") {
-            dimension = "abi"
-            ndk {
-                abiFilters += listOf("arm64-v8a", "x86_64")
-            }
-        }
-        create("arm64") {
-            dimension = "abi"
-            ndk {
-                abiFilters += "arm64-v8a"
-            }
-        }
-        create("arm") {
-            dimension = "abi"
-            ndk {
-                abiFilters += "armeabi-v7a"
-            }
-        }
-        create("x86_64") {
-            dimension = "abi"
-            ndk {
-                abiFilters += "x86_64"
-            }
-        }
-        create("x86") {
-            dimension = "abi"
-            ndk {
-                abiFilters += "x86"
-            }
-        }
-    } */
-}
-
-dependencies {
-    implementation("androidx.core:core-ktx:1.10.1")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.1")
-    implementation("androidx.activity:activity-compose:1.7.2")
-    implementation(platform("androidx.compose:compose-bom:2023.03.00"))
-    implementation("androidx.compose.ui:ui")
-    implementation("androidx.compose.ui:ui-graphics")
-    implementation("androidx.compose.ui:ui-tooling-preview")
-    implementation("androidx.compose.material3:material3:1.1.1")
-    implementation("androidx.appcompat:appcompat:1.6.1")
-
-    testImplementation("junit:junit:4.13.2")
-    androidTestImplementation("androidx.test.ext:junit:1.1.5")
-    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
-    androidTestImplementation(platform("androidx.compose:compose-bom:2023.03.00"))
-    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
-    debugImplementation("androidx.compose.ui:ui-tooling")
-    debugImplementation("androidx.compose.ui:ui-test-manifest")
-
-    //wireguard tunnel
-    implementation("com.wireguard.android:tunnel:1.0.20230706")
-
-    //logging
-    implementation("com.jakewharton.timber:timber:5.0.1")
-
-    // compose navigation
-    implementation("androidx.navigation:navigation-compose:2.7.1")
-    implementation("androidx.hilt:hilt-navigation-compose:1.0.0")
-
-    // hilt
-    implementation("com.google.dagger:hilt-android:${rExtra.get("hiltVersion")}")
-    kapt("com.google.dagger:hilt-android-compiler:${rExtra.get("hiltVersion")}")
-
-    //accompanist
-    implementation("com.google.accompanist:accompanist-systemuicontroller:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-permissions:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-flowlayout:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-navigation-animation:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-drawablepainter:${rExtra.get("accompanistVersion")}")
-
-    //db
-    implementation("io.objectbox:objectbox-kotlin:${rExtra.get("objectBoxVersion")}")
-
-    //lifecycle
-    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.6.1")
-
-    //icons
-    implementation("androidx.compose.material:material-icons-extended:1.5.0")
-
-
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1")
-}
-
-kapt {
-    correctErrorTypes = true
-}

nym-vpn/android/app/objectbox-models/default.json

@@ -1,99 +0,0 @@
-{
-  "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
-  "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
-  "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
-  "entities": [
-    {
-      "id": "1:2692736974585027589",
-      "lastPropertyId": "15:5057486545428188436",
-      "name": "TunnelConfig",
-      "properties": [
-        {
-          "id": "1:1985347930017457084",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "12:2409068226744965585",
-          "name": "name",
-          "indexId": "1:4811206443952699137",
-          "type": 9,
-          "flags": 34848
-        },
-        {
-          "id": "13:8987443291286312275",
-          "name": "wgQuick",
-          "type": 9
-        }
-      ],
-      "relations": []
-    },
-    {
-      "id": "2:8887605597748372702",
-      "lastPropertyId": "9:4468844863383145378",
-      "name": "Settings",
-      "properties": [
-        {
-          "id": "1:7485739868216068651",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "2:5814013113141456749",
-          "name": "isAutoTunnelEnabled",
-          "type": 1
-        },
-        {
-          "id": "4:5645665441196906014",
-          "name": "trustedNetworkSSIDs",
-          "type": 30
-        },
-        {
-          "id": "5:4989886999117763881",
-          "name": "isTunnelOnMobileDataEnabled",
-          "type": 1
-        },
-        {
-          "id": "6:3370284381040192129",
-          "name": "defaultTunnel",
-          "type": 9
-        },
-        {
-          "id": "9:4468844863383145378",
-          "name": "isAlwaysOnVpnEnabled",
-          "type": 1
-        }
-      ],
-      "relations": []
-    }
-  ],
-  "lastEntityId": "2:8887605597748372702",
-  "lastIndexId": "1:4811206443952699137",
-  "lastRelationId": "0:0",
-  "lastSequenceId": "0:0",
-  "modelVersion": 5,
-  "modelVersionParserMinimum": 5,
-  "retiredEntityUids": [],
-  "retiredIndexUids": [],
-  "retiredPropertyUids": [
-    1763475292291320186,
-    6483820955437198310,
-    8323071516033820771,
-    5904440563612311217,
-    1408037976996390989,
-    7737847485212546994,
-    8215616901775229364,
-    8021610768066328637,
-    6174306582797008721,
-    2175939938544485767,
-    7555225587864607050,
-    969146862000617878,
-    5057486545428188436,
-    2814640993034665120,
-    4981008812459251156
-  ],
-  "retiredRelationUids": [],
-  "version": 1
-}

nym-vpn/android/app/objectbox-models/default.json.bak

@@ -1,94 +0,0 @@
-{
-  "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
-  "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
-  "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
-  "entities": [
-    {
-      "id": "1:2692736974585027589",
-      "lastPropertyId": "15:5057486545428188436",
-      "name": "TunnelConfig",
-      "properties": [
-        {
-          "id": "1:1985347930017457084",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "12:2409068226744965585",
-          "name": "name",
-          "indexId": "1:4811206443952699137",
-          "type": 9,
-          "flags": 34848
-        },
-        {
-          "id": "13:8987443291286312275",
-          "name": "wgQuick",
-          "type": 9
-        }
-      ],
-      "relations": []
-    },
-    {
-      "id": "2:8887605597748372702",
-      "lastPropertyId": "8:4981008812459251156",
-      "name": "Settings",
-      "properties": [
-        {
-          "id": "1:7485739868216068651",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "2:5814013113141456749",
-          "name": "isAutoTunnelEnabled",
-          "type": 1
-        },
-        {
-          "id": "4:5645665441196906014",
-          "name": "trustedNetworkSSIDs",
-          "type": 30
-        },
-        {
-          "id": "5:4989886999117763881",
-          "name": "isTunnelOnMobileDataEnabled",
-          "type": 1
-        },
-        {
-          "id": "6:3370284381040192129",
-          "name": "defaultTunnel",
-          "type": 9
-        }
-      ],
-      "relations": []
-    }
-  ],
-  "lastEntityId": "2:8887605597748372702",
-  "lastIndexId": "1:4811206443952699137",
-  "lastRelationId": "0:0",
-  "lastSequenceId": "0:0",
-  "modelVersion": 5,
-  "modelVersionParserMinimum": 5,
-  "retiredEntityUids": [],
-  "retiredIndexUids": [],
-  "retiredPropertyUids": [
-    1763475292291320186,
-    6483820955437198310,
-    8323071516033820771,
-    5904440563612311217,
-    1408037976996390989,
-    7737847485212546994,
-    8215616901775229364,
-    8021610768066328637,
-    6174306582797008721,
-    2175939938544485767,
-    7555225587864607050,
-    969146862000617878,
-    5057486545428188436,
-    2814640993034665120,
-    4981008812459251156
-  ],
-  "retiredRelationUids": [],
-  "version": 1
-}

nym-vpn/android/app/proguard-rules.pro

@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

nym-vpn/android/app/src/androidTest/java/com/zaneschepke/wireguardautotunnel/ExampleInstrumentedTest.kt

@@ -1,24 +0,0 @@
-package net.nymtech.nymconnect
-
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.ext.junit.runners.AndroidJUnit4
-
-import org.junit.Test
-import org.junit.runner.RunWith
-
-import org.junit.Assert.*
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-    @Test
-    fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("net.nymtech.nymconnect", appContext.packageName)
-    }
-}

nym-vpn/android/app/src/main/AndroidManifest.xml

@@ -1,115 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
-        android:maxSdkVersion="32" />
-    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"
-        android:maxSdkVersion="30"
-        tools:ignore="LeanbackUsesWifi" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
-    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
-    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING"/>
-    <!--foreground service permissions-->
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.WAKE_LOCK" />
-    <!--start service on boot permission-->
-    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
-    <!--android tv support-->
-    <uses-feature android:name="android.software.leanback"
-        android:required="false" />
-    <uses-feature android:name="android.hardware.touchscreen"
-        android:required="false" />
-    <uses-feature
-        android:name="android.hardware.location.gps"
-        android:required="false" />
-    <uses-feature
-    android:name="android.hardware.screen.portrait"
-    android:required="false" />
-    <queries>
-        <intent>
-            <action android:name="android.intent.action.MAIN" />
-        </intent>
-    </queries>
-    <application
-        android:allowBackup="true"
-        android:name=".WireGuardAutoTunnel"
-        android:dataExtractionRules="@xml/data_extraction_rules"
-        android:fullBackupContent="@xml/backup_rules"
-        android:icon="@mipmap/ic_launcher"
-        android:banner="@mipmap/ic_banner"
-        android:label="@string/app_name"
-        android:roundIcon="@mipmap/ic_launcher_round"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.WireguardAutoTunnel"
-        tools:targetApi="31">
-        <activity
-            android:name=".ui.MainActivity"
-            android:exported="true"
-            android:theme="@style/Theme.WireguardAutoTunnel">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
-            </intent-filter>
-        </activity>
-        <activity
-            android:finishOnTaskLaunch="true"
-            android:theme="@android:style/Theme.NoDisplay"
-            android:name=".service.shortcut.ShortcutsActivity"/>
-        <service
-            android:name=".service.foreground.ForegroundService"
-            android:enabled="true"
-            android:foregroundServiceType="remoteMessaging"
-            android:exported="false">
-        </service>
-        <service
-            android:exported="true"
-            android:name=".service.tile.TunnelControlTile"
-            android:icon="@drawable/shield"
-            android:label="NymConnect"
-            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
-            <meta-data android:name="android.service.quicksettings.ACTIVE_TILE"
-                android:value="true" />
-            <meta-data android:name="android.service.quicksettings.TOGGLEABLE_TILE"
-                android:value="true" />
-            <intent-filter>
-                <action android:name="android.service.quicksettings.action.QS_TILE" />
-            </intent-filter>
-        </service>
-        <service
-            android:name=".service.foreground.WireGuardTunnelService"
-            android:permission="android.permission.BIND_VPN_SERVICE"
-            android:enabled="true"
-            android:persistent="true"
-            android:foregroundServiceType="remoteMessaging"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="android.net.VpnService"/>
-            </intent-filter>
-            <meta-data android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
-                android:value="true"/>
-        </service>
-        <service
-            android:name=".service.foreground.WireGuardConnectivityWatcherService"
-            android:enabled="true"
-            android:stopWithTask="false"
-            android:persistent="true"
-            android:foregroundServiceType="location"
-            android:permission=""
-            android:exported="false">
-        </service>
-        <receiver android:enabled="true" android:name=".receiver.BootReceiver"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED"/>
-            </intent-filter>
-        </receiver>
-        <receiver android:exported="false" android:name=".receiver.NotificationActionReceiver"/>
-    </application>
-</manifest>

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/Constants.kt

@@ -1,6 +0,0 @@
-package net.nymtech.nymconnect
-
-object Constants {
-    const val VPN_CONNECTIVITY_CHECK_INTERVAL = 3000L;
-    const val VPN_STATISTIC_CHECK_INTERVAL = 10000L;
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/WireGuardAutoTunnel.kt

@@ -1,27 +0,0 @@
-package net.nymtech.nymconnect
-
-import android.app.Application
-import android.content.Context
-import android.content.pm.PackageManager
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import dagger.hilt.android.HiltAndroidApp
-import javax.inject.Inject
-
-@HiltAndroidApp
-class WireGuardAutoTunnel : Application() {
-
-    @Inject
-    lateinit var settingsRepo : Repository<Settings>
-
-    override fun onCreate() {
-        super.onCreate()
-        settingsRepo.init()
-    }
-
-    companion object {
-        fun isRunningOnAndroidTv(context : Context) : Boolean {
-            return context.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/module/BoxModule.kt

@@ -1,40 +0,0 @@
-package net.nymtech.nymconnect.module
-
-import android.content.Context
-import net.nymtech.nymconnect.service.tunnel.model.MyObjectBox
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-class BoxModule {
-
-    @Provides
-    @Singleton
-    fun provideBoxStore(@ApplicationContext context : Context) : BoxStore {
-        return MyObjectBox.builder()
-            .androidContext(context.applicationContext)
-            .build()
-    }
-
-    @Provides
-    @Singleton
-    fun provideBoxForSettings(store : BoxStore) : Box<Settings> {
-        return store.boxFor(Settings::class.java)
-    }
-
-    @Provides
-    @Singleton
-    fun provideBoxForTunnels(store : BoxStore) : Box<TunnelConfig> {
-        return store.boxFor(TunnelConfig::class.java)
-    }
-
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/module/RepositoryModule.kt

@@ -1,25 +0,0 @@
-package net.nymtech.nymconnect.module
-
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.repository.SettingsBox
-import net.nymtech.nymconnect.repository.TunnelBox
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-abstract class RepositoryModule {
-
-    @Binds
-    @Singleton
-    abstract fun provideSettingsRepository(settingsBox: SettingsBox) : Repository<Settings>
-
-    @Binds
-    @Singleton
-    abstract fun provideTunnelRepository(tunnelBox: TunnelBox) : Repository<TunnelConfig>
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/module/ServiceModule.kt

@@ -1,29 +0,0 @@
-package net.nymtech.nymconnect.module
-
-import net.nymtech.nymconnect.service.network.MobileDataService
-import net.nymtech.nymconnect.service.network.NetworkService
-import net.nymtech.nymconnect.service.network.WifiService
-import net.nymtech.nymconnect.service.notification.NotificationService
-import net.nymtech.nymconnect.service.notification.WireGuardNotification
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.android.components.ServiceComponent
-import dagger.hilt.android.scopes.ServiceScoped
-
-@Module
-@InstallIn(ServiceComponent::class)
-abstract class ServiceModule {
-
-    @Binds
-    @ServiceScoped
-    abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification) : NotificationService
-
-    @Binds
-    @ServiceScoped
-    abstract fun provideWifiService(wifiService: WifiService) : NetworkService<WifiService>
-
-    @Binds
-    @ServiceScoped
-    abstract fun provideMobileDataService(mobileDataService : MobileDataService) : NetworkService<MobileDataService>
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/module/TunnelModule.kt

@@ -1,31 +0,0 @@
-package net.nymtech.nymconnect.module
-
-import android.content.Context
-import com.wireguard.android.backend.Backend
-import com.wireguard.android.backend.GoBackend
-import net.nymtech.nymconnect.service.tunnel.VpnService
-import net.nymtech.nymconnect.service.tunnel.WireGuardTunnel
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-class TunnelModule {
-
-    @Provides
-    @Singleton
-    fun provideBackend(@ApplicationContext context : Context) : Backend {
-        return GoBackend(context)
-    }
-
-    @Provides
-    @Singleton
-    fun provideVpnService(backend: Backend) : VpnService {
-        return WireGuardTunnel(backend)
-    }
-
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/receiver/BootReceiver.kt

@@ -1,39 +0,0 @@
-package net.nymtech.nymconnect.receiver
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.foreground.ServiceManager
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class BootReceiver : BroadcastReceiver() {
-
-    @Inject
-    lateinit var settingsRepo : Repository<Settings>
-
-    override fun onReceive(context: Context, intent: Intent) {
-        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
-            CoroutineScope(Dispatchers.IO).launch {
-                try {
-                    val settings = settingsRepo.getAll()
-                    if (!settings.isNullOrEmpty()) {
-                        val setting = settings.first()
-                        if (setting.isAutoTunnelEnabled && setting.defaultTunnel != null) {
-                            ServiceManager.startWatcherService(context, setting.defaultTunnel!!)
-                        }
-                    }
-                } finally {
-                    cancel()
-                }
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/receiver/NotificationActionReceiver.kt

@@ -1,39 +0,0 @@
-package net.nymtech.nymconnect.receiver
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.foreground.ServiceManager
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class NotificationActionReceiver : BroadcastReceiver() {
-
-    @Inject
-    lateinit var settingsRepo : Repository<Settings>
-    override fun onReceive(context: Context, intent: Intent?) {
-        CoroutineScope(Dispatchers.IO).launch {
-            try {
-                val settings = settingsRepo.getAll()
-                if (!settings.isNullOrEmpty()) {
-                    val setting = settings.first()
-                    if (setting.defaultTunnel != null) {
-                        ServiceManager.stopVpnService(context)
-                        delay(1000)
-                        ServiceManager.startVpnService(context, setting.defaultTunnel.toString())
-                    }
-                }
-            } finally {
-                cancel()
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/repository/Repository.kt

@@ -1,16 +0,0 @@
-package net.nymtech.nymconnect.repository
-
-import kotlinx.coroutines.flow.Flow
-
-interface Repository<T> {
-    suspend fun save(t : T)
-    suspend fun saveAll(t : List<T>)
-    suspend fun getById(id : Long) : T?
-    suspend fun getAll() : List<T>?
-    suspend fun delete(t : T) : Boolean?
-    suspend fun count() : Long?
-
-    val itemFlow : Flow<MutableList<T>>
-
-    fun init()
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/repository/SettingsBox.kt

@@ -1,63 +0,0 @@
-package net.nymtech.nymconnect.repository
-
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import io.objectbox.kotlin.awaitCallInTx
-import io.objectbox.kotlin.toFlow
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-
-class SettingsBox @Inject constructor(private val box : Box<Settings>, private val boxStore : BoxStore) : Repository<Settings> {
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    override val itemFlow = box.query().build().subscribe().toFlow()
-
-    override fun init() {
-        CoroutineScope(Dispatchers.IO).launch {
-            if(getAll().isNullOrEmpty()) {
-                save(Settings())
-            }
-        }
-    }
-
-    override suspend fun save(t : Settings) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun saveAll(t : List<Settings>) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun getById(id: Long): Settings? {
-        return boxStore.awaitCallInTx {
-            box[id]
-        }
-    }
-
-    override suspend fun getAll(): List<Settings>? {
-        return boxStore.awaitCallInTx {
-            box.all
-        }
-    }
-
-    override suspend fun delete(t : Settings): Boolean? {
-        return boxStore.awaitCallInTx {
-            box.remove(t)
-        }
-    }
-
-    override suspend fun count() : Long? {
-        return boxStore.awaitCallInTx {
-            box.count()
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/repository/TunnelBox.kt

@@ -1,57 +0,0 @@
-package net.nymtech.nymconnect.repository
-
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import io.objectbox.kotlin.awaitCallInTx
-import io.objectbox.kotlin.toFlow
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import timber.log.Timber
-import javax.inject.Inject
-
-class TunnelBox @Inject constructor(private val box : Box<TunnelConfig>,private val boxStore : BoxStore) : Repository<TunnelConfig> {
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    override val itemFlow = box.query().build().subscribe().toFlow()
-    override fun init() {
-
-    }
-
-    override suspend fun save(t : TunnelConfig) {
-        Timber.d("Saving tunnel config")
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-
-    }
-
-    override suspend fun saveAll(t : List<TunnelConfig>) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun getById(id: Long): TunnelConfig? {
-       return boxStore.awaitCallInTx {
-            box[id]
-        }
-    }
-
-    override suspend fun getAll(): List<TunnelConfig>? {
-        return boxStore.awaitCallInTx {
-            box.all
-        }
-    }
-
-    override suspend fun delete(t : TunnelConfig): Boolean? {
-        return boxStore.awaitCallInTx {
-            box.remove(t)
-        }
-    }
-
-    override suspend fun count() : Long? {
-        return boxStore.awaitCallInTx {
-            box.count()
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/Action.kt

@@ -1,6 +0,0 @@
-package net.nymtech.nymconnect.service.foreground
-
-enum class Action {
-    START,
-    STOP
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/ForegroundService.kt

@@ -1,64 +0,0 @@
-package net.nymtech.nymconnect.service.foreground
-
-import android.app.Service
-import android.content.Intent
-import android.os.Bundle
-import android.os.IBinder
-import timber.log.Timber
-
-
-open class ForegroundService : Service() {
-
-    private var isServiceStarted = false
-
-    override fun onBind(intent: Intent): IBinder? {
-        // We don't provide binding, so return null
-        return null
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        Timber.d("onStartCommand executed with startId: $startId")
-        if (intent != null) {
-            val action = intent.action
-            Timber.d("using an intent with action $action")
-            when (action) {
-                Action.START.name -> startService(intent.extras)
-                Action.STOP.name -> stopService(intent.extras)
-                "android.net.VpnService" -> {
-                    Timber.d("Always-on VPN starting service")
-                    startService(intent.extras)
-                }
-                else -> Timber.d("This should never happen. No action in the received intent")
-            }
-        } else {
-            Timber.d(
-                "with a null intent. It has been probably restarted by the system."
-            )
-        }
-        // by returning this we make sure the service is restarted if the system kills the service
-        return START_STICKY
-    }
-
-
-    override fun onDestroy() {
-        super.onDestroy()
-        Timber.d("The service has been destroyed")
-    }
-
-    protected open fun startService(extras : Bundle?) {
-        if (isServiceStarted) return
-        Timber.d("Starting ${this.javaClass.simpleName}")
-        isServiceStarted = true
-    }
-
-    protected open fun stopService(extras : Bundle?) {
-        Timber.d("Stopping ${this.javaClass.simpleName}")
-        try {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-            stopSelf()
-        } catch (e: Exception) {
-            Timber.d("Service stopped without being started: ${e.message}")
-        }
-        isServiceStarted = false
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/ServiceManager.kt

@@ -1,90 +0,0 @@
-package net.nymtech.nymconnect.service.foreground
-
-import android.app.ActivityManager
-import android.app.Application
-import android.app.Service
-import android.content.Context
-import android.content.Context.ACTIVITY_SERVICE
-import android.content.Intent
-import net.nymtech.nymconnect.R
-import timber.log.Timber
-
-object ServiceManager {
-    @Suppress("DEPRECATION")
-    private // Deprecated for third party Services.
-    fun <T> Context.isServiceRunning(service: Class<T>) =
-        (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
-            .getRunningServices(Integer.MAX_VALUE)
-            .any { it.service.className == service.name }
-
-    fun <T : Service> getServiceState(context: Context, cls : Class<T>): ServiceState {
-        val isServiceRunning = context.isServiceRunning(cls)
-        return if(isServiceRunning) ServiceState.STARTED else ServiceState.STOPPED
-    }
-
-    private fun <T : Service> actionOnService(action: Action, context: Context, cls : Class<T>, extras : Map<String,String>? = null) {
-        if (getServiceState(context, cls) == ServiceState.STOPPED && action == Action.STOP) return
-        if (getServiceState(context, cls) == ServiceState.STARTED && action == Action.START) return
-        val intent = Intent(context, cls).also {
-            it.action = action.name
-            extras?.forEach {(k, v) ->
-                it.putExtra(k, v)
-            }
-        }
-        intent.component?.javaClass
-        try {
-            when(action) {
-                Action.START -> {
-                    try {
-                        context.startForegroundService(intent)
-                    } catch (e : Exception) {
-                        Timber.e("Unable to start service foreground ${e.message}")
-                        context.startService(intent)
-                    }
-                }
-                Action.STOP -> context.startService(intent)
-            }
-        } catch (e : Exception) {
-            Timber.tag("ServiceManager").e(e)
-        }
-    }
-
-    fun startVpnService(context : Context, tunnelConfig : String) {
-        actionOnService(
-            Action.START,
-            context,
-            WireGuardTunnelService::class.java,
-            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig))
-    }
-    fun stopVpnService(context : Context) {
-        actionOnService(
-            Action.STOP,
-            context,
-            WireGuardTunnelService::class.java
-        )
-    }
-
-    fun startWatcherService(context : Context, tunnelConfig : String) {
-        actionOnService(
-            Action.START, context,
-            WireGuardConnectivityWatcherService::class.java, mapOf(context.
-            getString(R.string.tunnel_extras_key) to
-                    tunnelConfig))
-    }
-
-    fun stopWatcherService(context : Context) {
-        actionOnService(
-            Action.STOP, context,
-            WireGuardConnectivityWatcherService::class.java)
-    }
-
-    fun toggleWatcherService(context: Context, tunnelConfig : String) {
-        when(getServiceState(
-            context,
-            WireGuardConnectivityWatcherService::class.java,
-        )) {
-            ServiceState.STARTED -> stopWatcherService(context)
-            ServiceState.STOPPED -> startWatcherService(context, tunnelConfig)
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/ServiceState.kt

@@ -1,6 +0,0 @@
-package net.nymtech.nymconnect.service.foreground
-
-enum class ServiceState {
-    STARTED,
-    STOPPED,
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardConnectivityWatcherService.kt

@@ -1,210 +0,0 @@
-package net.nymtech.nymconnect.service.foreground
-
-import android.app.AlarmManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.os.Bundle
-import android.os.PowerManager
-import android.os.SystemClock
-import com.wireguard.android.backend.Tunnel
-import net.nymtech.nymconnect.Constants
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.network.MobileDataService
-import net.nymtech.nymconnect.service.network.NetworkService
-import net.nymtech.nymconnect.service.network.NetworkStatus
-import net.nymtech.nymconnect.service.network.WifiService
-import net.nymtech.nymconnect.service.notification.NotificationService
-import net.nymtech.nymconnect.service.tunnel.VpnService
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class WireGuardConnectivityWatcherService : ForegroundService() {
-
-    private val foregroundId = 122;
-
-    @Inject
-    lateinit var wifiService : NetworkService<WifiService>
-
-    @Inject
-    lateinit var mobileDataService : NetworkService<MobileDataService>
-
-    @Inject
-    lateinit var settingsRepo: Repository<Settings>
-
-    @Inject
-    lateinit var notificationService : NotificationService
-
-    @Inject
-    lateinit var vpnService : VpnService
-
-    private var isWifiConnected = false;
-    private var isMobileDataConnected = false;
-    private var currentNetworkSSID = "";
-
-    private lateinit var watcherJob : Job;
-    private lateinit var setting : Settings
-    private lateinit var tunnelConfig: String
-
-    private var wakeLock: PowerManager.WakeLock? = null
-    private val tag = this.javaClass.name;
-
-
-    override fun startService(extras: Bundle?) {
-        super.startService(extras)
-        val tunnelId = extras?.getString(getString(R.string.tunnel_extras_key))
-        if (tunnelId != null) {
-            this.tunnelConfig = tunnelId
-        }
-        // we need this lock so our service gets not affected by Doze Mode
-        initWakeLock()
-        cancelWatcherJob()
-        launchWatcherNotification()
-        if(this::tunnelConfig.isInitialized) {
-            startWatcherJob()
-        } else {
-            stopService(extras)
-        }
-    }
-
-    override fun stopService(extras: Bundle?) {
-        super.stopService(extras)
-        wakeLock?.let {
-            if (it.isHeld) {
-                it.release()
-            }
-        }
-        cancelWatcherJob()
-        stopSelf()
-    }
-
-    private fun launchWatcherNotification() {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.watcher_channel_id),
-            channelName = getString(R.string.watcher_channel_name),
-            description = getString(R.string.watcher_notification_text))
-        super.startForeground(foregroundId, notification)
-    }
-
-    //try to start task again if killed
-    override fun onTaskRemoved(rootIntent: Intent) {
-        Timber.d("Task Removed called")
-        val restartServiceIntent = Intent(rootIntent)
-        val restartServicePendingIntent: PendingIntent = PendingIntent.getService(this, 1, restartServiceIntent,
-            PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE);
-        applicationContext.getSystemService(Context.ALARM_SERVICE);
-        val alarmService: AlarmManager = applicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager;
-        alarmService.set(AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime() + 1000, restartServicePendingIntent);
-    }
-
-    private fun initWakeLock() {
-        wakeLock =
-            (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
-                newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
-                    acquire()
-                }
-            }
-    }
-
-    private fun cancelWatcherJob() {
-        if(this::watcherJob.isInitialized) {
-            watcherJob.cancel()
-        }
-    }
-
-    private fun startWatcherJob() {
-        watcherJob = CoroutineScope(Dispatchers.IO).launch {
-            val settings = settingsRepo.getAll();
-            if(!settings.isNullOrEmpty()) {
-                setting = settings[0]
-            }
-            launch {
-                watchForWifiConnectivityChanges()
-            }
-            if(setting.isTunnelOnMobileDataEnabled) {
-                launch {
-                    watchForMobileDataConnectivityChanges()
-                }
-            }
-            launch {
-                manageVpn()
-            }
-        }
-    }
-
-    private suspend fun watchForMobileDataConnectivityChanges() {
-        mobileDataService.networkStatus.collect {
-            when(it) {
-                is NetworkStatus.Available -> {
-                    Timber.d("Gained Mobile data connection")
-                    isMobileDataConnected = true
-                }
-                is NetworkStatus.CapabilitiesChanged -> {
-                    isMobileDataConnected = true
-                    Timber.d("Mobile data capabilities changed")
-                }
-                is NetworkStatus.Unavailable -> {
-                    isMobileDataConnected = false
-                    Timber.d("Lost mobile data connection")
-                }
-
-                else -> {}
-            }
-        }
-    }
-
-    private suspend fun watchForWifiConnectivityChanges() {
-        wifiService.networkStatus.collect {
-                when (it) {
-                    is NetworkStatus.Available -> {
-                        Timber.d("Gained Wi-Fi connection")
-                        isWifiConnected = true
-                    }
-                    is NetworkStatus.CapabilitiesChanged -> {
-                        Timber.d("Wifi capabilities changed")
-                        isWifiConnected = true
-                        currentNetworkSSID = wifiService.getNetworkName(it.networkCapabilities) ?: "";
-                    }
-                    is NetworkStatus.Unavailable -> {
-                        isWifiConnected = false
-                        Timber.d("Lost Wi-Fi connection")
-                    }
-
-                    else -> {}
-                }
-            }
-        }
-
-    private suspend fun manageVpn() {
-        while(watcherJob.isActive) {
-            if(setting.isTunnelOnMobileDataEnabled &&
-                !isWifiConnected &&
-                isMobileDataConnected
-                && vpnService.getState() == Tunnel.State.DOWN) {
-                ServiceManager.startVpnService(this, tunnelConfig)
-            } else if(!setting.isTunnelOnMobileDataEnabled &&
-                !isWifiConnected &&
-                vpnService.getState() == Tunnel.State.UP) {
-                ServiceManager.stopVpnService(this)
-            } else if(isWifiConnected &&
-                !setting.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
-                (vpnService.getState() != Tunnel.State.UP)) {
-                ServiceManager.startVpnService(this, tunnelConfig)
-            } else if((isWifiConnected &&
-                        setting.trustedNetworkSSIDs.contains(currentNetworkSSID)) &&
-                (vpnService.getState() == Tunnel.State.UP)) {
-                ServiceManager.stopVpnService(this)
-            }
-            delay(Constants.VPN_CONNECTIVITY_CHECK_INTERVAL)
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardTunnelService.kt

@@ -1,154 +0,0 @@
-package net.nymtech.nymconnect.service.foreground
-
-import android.app.PendingIntent
-import android.content.Intent
-import android.os.Bundle
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.receiver.NotificationActionReceiver
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.notification.NotificationService
-import net.nymtech.nymconnect.service.tunnel.HandshakeStatus
-import net.nymtech.nymconnect.service.tunnel.VpnService
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class WireGuardTunnelService : ForegroundService() {
-
-    private val foregroundId = 123;
-
-    @Inject
-    lateinit var vpnService : VpnService
-
-    @Inject
-    lateinit var settingsRepo: Repository<Settings>
-
-    @Inject
-    lateinit var notificationService : NotificationService
-
-    private lateinit var job : Job
-
-    private var tunnelName : String = ""
-
-    override fun startService(extras : Bundle?) {
-        super.startService(extras)
-        val tunnelConfigString = extras?.getString(getString(R.string.tunnel_extras_key))
-        cancelJob()
-        job = CoroutineScope(Dispatchers.IO).launch {
-            if(tunnelConfigString != null) {
-                try {
-                    val tunnelConfig = TunnelConfig.from(tunnelConfigString)
-                    tunnelName = tunnelConfig.name
-                    vpnService.startTunnel(tunnelConfig)
-                    launchVpnStartingNotification()
-                } catch (e : Exception) {
-                    Timber.e("Problem starting tunnel: ${e.message}")
-                    stopService(extras)
-                }
-            } else {
-                Timber.d("Tunnel config null, starting default tunnel")
-                val settings = settingsRepo.getAll();
-                if(!settings.isNullOrEmpty()) {
-                    val setting = settings[0]
-                    if(setting.defaultTunnel != null && setting.isAlwaysOnVpnEnabled) {
-                        val tunnelConfig = TunnelConfig.from(setting.defaultTunnel!!)
-                        tunnelName = tunnelConfig.name
-                        vpnService.startTunnel(tunnelConfig)
-                        launchVpnStartingNotification()
-                    }
-                }
-            }
-        }
-        CoroutineScope(job).launch {
-            var didShowConnected = false
-            var didShowFailedHandshakeNotification = false
-            vpnService.handshakeStatus.collect {
-                when(it) {
-                    HandshakeStatus.NOT_STARTED -> {
-                    }
-                    HandshakeStatus.NEVER_CONNECTED -> {
-                        if(!didShowFailedHandshakeNotification) {
-                            launchVpnConnectionFailedNotification(getString(R.string.initial_connection_failure_message))
-                            didShowFailedHandshakeNotification = true
-                            didShowConnected = false
-                        }
-                    }
-                    HandshakeStatus.HEALTHY -> {
-                        if(!didShowConnected) {
-                            launchVpnConnectedNotification()
-                            didShowConnected = true
-                        }
-                    }
-                    HandshakeStatus.UNHEALTHY -> {
-                        if(!didShowFailedHandshakeNotification) {
-                            launchVpnConnectionFailedNotification(getString(R.string.lost_connection_failure_message))
-                            didShowFailedHandshakeNotification = true
-                            didShowConnected = false
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    override fun stopService(extras : Bundle?) {
-        super.stopService(extras)
-        CoroutineScope(Dispatchers.IO).launch() {
-            vpnService.stopTunnel()
-        }
-        cancelJob()
-        stopSelf()
-    }
-
-    private fun launchVpnConnectedNotification() {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.vpn_channel_id),
-            channelName = getString(R.string.vpn_channel_name),
-            title = getString(R.string.tunnel_start_title),
-            onGoing = false,
-            showTimestamp = true,
-            description = "${getString(R.string.tunnel_start_text)} $tunnelName"
-        )
-        super.startForeground(foregroundId, notification)
-    }
-
-    private fun launchVpnStartingNotification() {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.vpn_channel_id),
-            channelName = getString(R.string.vpn_channel_name),
-            title = getString(R.string.vpn_starting),
-            onGoing = false,
-            showTimestamp = true,
-            description = getString(R.string.attempt_connection)
-        )
-        super.startForeground(foregroundId, notification)
-    }
-
-    private fun launchVpnConnectionFailedNotification(message : String) {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.vpn_channel_id),
-            channelName = getString(R.string.vpn_channel_name),
-            action = PendingIntent.getBroadcast(this,0,Intent(this, NotificationActionReceiver::class.java),PendingIntent.FLAG_IMMUTABLE),
-            actionText = getString(R.string.restart),
-            title = getString(R.string.vpn_connection_failed),
-            onGoing = false,
-            showTimestamp = true,
-            description = message
-        )
-        super.startForeground(foregroundId, notification)
-    }
-
-
-    private fun cancelJob() {
-        if(this::job.isInitialized) {
-            job.cancel()
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/BaseNetworkService.kt

@@ -1,117 +0,0 @@
-package net.nymtech.nymconnect.service.network
-
-import android.content.Context
-import android.net.ConnectivityManager
-import android.net.Network
-import android.net.NetworkCapabilities
-import android.net.NetworkRequest
-import android.net.wifi.SupplicantState
-import android.net.wifi.WifiInfo
-import android.net.wifi.WifiManager
-import android.os.Build
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.flow.map
-
-
-abstract class BaseNetworkService<T : BaseNetworkService<T>>(val context: Context, networkCapability : Int) : NetworkService<T> {
-    private val connectivityManager =
-        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-
-    private val wifiManager =
-        context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
-
-    override val networkStatus = callbackFlow {
-        val networkStatusCallback = when (Build.VERSION.SDK_INT) {
-            in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
-                object : ConnectivityManager.NetworkCallback(
-                    FLAG_INCLUDE_LOCATION_INFO
-                ) {
-                    override fun onAvailable(network: Network) {
-                        trySend(NetworkStatus.Available(network))
-                    }
-
-                    override fun onLost(network: Network) {
-                        trySend(NetworkStatus.Unavailable(network))
-                    }
-
-                    override fun onCapabilitiesChanged(
-                        network: Network,
-                        networkCapabilities: NetworkCapabilities
-                    ) {
-                        trySend(NetworkStatus.CapabilitiesChanged(network, networkCapabilities))
-                    }
-                }
-            }
-
-            else -> {
-                object : ConnectivityManager.NetworkCallback() {
-
-                    override fun onAvailable(network: Network) {
-                        trySend(NetworkStatus.Available(network))
-                    }
-
-                    override fun onLost(network: Network) {
-                        trySend(NetworkStatus.Unavailable(network))
-                    }
-
-                    override fun onCapabilitiesChanged(
-                        network: Network,
-                        networkCapabilities: NetworkCapabilities
-                    ) {
-                        trySend(NetworkStatus.CapabilitiesChanged(network, networkCapabilities))
-                    }
-                }
-            }
-        }
-        val request = NetworkRequest.Builder()
-            .addTransportType(networkCapability)
-            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-            .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-            .build()
-        connectivityManager.registerNetworkCallback(request, networkStatusCallback)
-
-        awaitClose {
-            connectivityManager.unregisterNetworkCallback(networkStatusCallback)
-        }
-    }
-
-
-    override fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
-        var ssid: String? = getWifiNameFromCapabilities(networkCapabilities)
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
-            val info = wifiManager.connectionInfo
-            if (info.supplicantState === SupplicantState.COMPLETED) {
-                ssid = info.ssid
-            }
-        }
-        return ssid?.trim('"')
-    }
-
-
-    companion object {
-        private fun getWifiNameFromCapabilities(networkCapabilities: NetworkCapabilities): String? {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                val info: WifiInfo
-                if (networkCapabilities.transportInfo is WifiInfo) {
-                    info = networkCapabilities.transportInfo as WifiInfo
-                    return info.ssid
-                }
-            }
-            return null
-        }
-    }
-}
-
-inline fun <Result> Flow<NetworkStatus>.map(
-    crossinline onUnavailable: suspend (network : Network) -> Result,
-    crossinline onAvailable: suspend (network : Network) -> Result,
-    crossinline onCapabilitiesChanged: suspend (network : Network, networkCapabilities : NetworkCapabilities) -> Result,
-): Flow<Result> = map { status ->
-    when (status) {
-        is NetworkStatus.Unavailable -> onUnavailable(status.network)
-        is NetworkStatus.Available -> onAvailable(status.network)
-        is NetworkStatus.CapabilitiesChanged -> onCapabilitiesChanged(status.network, status.networkCapabilities)
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/MobileDataService.kt

@@ -1,10 +0,0 @@
-package net.nymtech.nymconnect.service.network
-
-import android.content.Context
-import android.net.NetworkCapabilities
-import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
-
-class MobileDataService @Inject constructor(@ApplicationContext context: Context) :
-    BaseNetworkService<MobileDataService>(context, NetworkCapabilities.TRANSPORT_CELLULAR) {
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/NetworkService.kt

@@ -1,10 +0,0 @@
-package net.nymtech.nymconnect.service.network
-
-import android.net.NetworkCapabilities
-import kotlinx.coroutines.flow.Flow
-
-interface NetworkService<T> {
-    fun getNetworkName(networkCapabilities: NetworkCapabilities) : String?
-    val networkStatus : Flow<NetworkStatus>
-
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/NetworkStatus.kt

@@ -1,10 +0,0 @@
-package net.nymtech.nymconnect.service.network
-
-import android.net.Network
-import android.net.NetworkCapabilities
-
-sealed class NetworkStatus {
-    class Available(val network : Network) : NetworkStatus()
-    class Unavailable(val network : Network) : NetworkStatus()
-    class CapabilitiesChanged(val network : Network, val networkCapabilities : NetworkCapabilities) : NetworkStatus()
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/WifiService.kt

@@ -1,10 +0,0 @@
-package net.nymtech.nymconnect.service.network
-
-import android.content.Context
-import android.net.NetworkCapabilities
-import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
-
-class WifiService @Inject constructor(@ApplicationContext context: Context) :
-    BaseNetworkService<WifiService>(context, NetworkCapabilities.TRANSPORT_WIFI) {
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/notification/NotificationService.kt

@@ -1,21 +0,0 @@
-package net.nymtech.nymconnect.service.notification
-
-import android.app.Notification
-import android.app.NotificationManager
-import android.app.PendingIntent
-
-interface NotificationService {
-    fun createNotification(
-        channelId: String,
-        channelName: String,
-        title: String = "",
-        action: PendingIntent? = null,
-        actionText: String? = null,
-        description: String,
-        showTimestamp : Boolean = false,
-        importance: Int = NotificationManager.IMPORTANCE_HIGH,
-        vibration: Boolean = true,
-        onGoing: Boolean = true,
-        lights: Boolean = true
-    ): Notification
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/notification/WireGuardNotification.kt

@@ -1,77 +0,0 @@
-package net.nymtech.nymconnect.service.notification
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.graphics.Color
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.ui.MainActivity
-import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
-
-class WireGuardNotification @Inject constructor(@ApplicationContext private val context: Context) : NotificationService {
-
-    private val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager;
-
-    override fun createNotification(
-        channelId: String,
-        channelName: String,
-        title: String,
-        action: PendingIntent?,
-        actionText: String?,
-        description: String,
-        showTimestamp: Boolean,
-        importance: Int,
-        vibration: Boolean,
-        onGoing: Boolean,
-        lights: Boolean
-    ): Notification {
-        val channel = NotificationChannel(
-            channelId,
-            channelName,
-            importance
-        ).let {
-            it.description = title
-            it.enableLights(lights)
-            it.lightColor = Color.RED
-            it.enableVibration(vibration)
-            it.vibrationPattern = longArrayOf(100, 200, 300, 400, 500, 400, 300, 200, 400)
-            it
-        }
-        notificationManager.createNotificationChannel(channel)
-        val pendingIntent: PendingIntent =
-            Intent(context, MainActivity::class.java).let { notificationIntent ->
-                PendingIntent.getActivity(
-                    context,
-                    0,
-                    notificationIntent,
-                    PendingIntent.FLAG_IMMUTABLE
-                )
-            }
-
-        val builder: Notification.Builder =
-            Notification.Builder(
-                context,
-                channelId
-            )
-        return builder.let {
-            if(action != null && actionText != null) {
-                //TODO find a not deprecated way to do this
-                it.addAction(
-                    Notification.Action.Builder(0, actionText, action)
-                        .build())
-                    it.setAutoCancel(true)
-            }
-                it.setContentTitle(title)
-                .setContentText(description)
-                .setContentIntent(pendingIntent)
-                .setOngoing(onGoing)
-                .setShowWhen(showTimestamp)
-                .setSmallIcon(R.mipmap.ic_launcher_foreground)
-                .build()
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/shortcut/ShortcutsActivity.kt

@@ -1,28 +0,0 @@
-package net.nymtech.nymconnect.service.shortcut
-
-import android.os.Bundle
-import androidx.appcompat.app.AppCompatActivity
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.service.foreground.Action
-import net.nymtech.nymconnect.service.foreground.ServiceManager
-import net.nymtech.nymconnect.service.foreground.WireGuardTunnelService
-import dagger.hilt.android.AndroidEntryPoint
-
-@AndroidEntryPoint
-class ShortcutsActivity : AppCompatActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        if(intent.getStringExtra(ShortcutsManager.CLASS_NAME_EXTRA_KEY)
-            .equals(WireGuardTunnelService::class.java.name)) {
-            intent.getStringExtra(getString(R.string.tunnel_extras_key))?.let {
-                ServiceManager.toggleWatcherService(this, it)
-            }
-            when(intent.action){
-                Action.STOP.name -> ServiceManager.stopVpnService(this)
-                Action.START.name -> intent.getStringExtra(getString(R.string.tunnel_extras_key))
-                    ?.let { ServiceManager.startVpnService(this, it) }
-            }
-        }
-        finish()
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/shortcut/ShortcutsManager.kt

@@ -1,73 +0,0 @@
-package net.nymtech.nymconnect.service.shortcut
-
-import android.content.Context
-import android.content.Intent
-import androidx.core.content.pm.ShortcutInfoCompat
-import androidx.core.content.pm.ShortcutManagerCompat
-import androidx.core.graphics.drawable.IconCompat
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.service.foreground.Action
-import net.nymtech.nymconnect.service.foreground.WireGuardTunnelService
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-
-object ShortcutsManager {
-
-    private const val SHORT_LABEL_MAX_SIZE = 10;
-    private const val LONG_LABEL_MAX_SIZE = 25;
-    private const val APPEND_ON = " On";
-    private const val APPEND_OFF = " Off"
-    const val CLASS_NAME_EXTRA_KEY = "className"
-
-    private fun createAndPushShortcut(context : Context, intent : Intent, id : String, shortLabel : String,
-                               longLabel : String, drawable : Int ) {
-        val shortcut = ShortcutInfoCompat.Builder(context, id)
-            .setShortLabel(shortLabel)
-            .setLongLabel(longLabel)
-            .setIcon(IconCompat.createWithResource(context, drawable))
-            .setIntent(intent)
-            .build()
-        ShortcutManagerCompat.pushDynamicShortcut(context, shortcut)
-    }
-
-    fun createTunnelShortcuts(context : Context, tunnelConfig : TunnelConfig) {
-        createAndPushShortcut(context,
-            createTunnelOnIntent(context, mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig.toString())),
-            tunnelConfig.id.toString() + APPEND_ON,
-            tunnelConfig.name.take((SHORT_LABEL_MAX_SIZE - APPEND_ON.length)) + APPEND_ON,
-            tunnelConfig.name.take((LONG_LABEL_MAX_SIZE - APPEND_ON.length)) + APPEND_ON,
-            R.drawable.vpn_on
-            )
-        createAndPushShortcut(context,
-            createTunnelOffIntent(context, mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig.toString())),
-            tunnelConfig.id.toString() + APPEND_OFF,
-            tunnelConfig.name.take((SHORT_LABEL_MAX_SIZE - APPEND_OFF.length)) + APPEND_OFF,
-            tunnelConfig.name.take((LONG_LABEL_MAX_SIZE - APPEND_OFF.length)) + APPEND_OFF,
-            R.drawable.vpn_off
-        )
-    }
-
-    fun removeTunnelShortcuts(context : Context, tunnelConfig : TunnelConfig) {
-        ShortcutManagerCompat.removeDynamicShortcuts(context, listOf(tunnelConfig.id.toString() + APPEND_ON,
-            tunnelConfig.id.toString() + APPEND_OFF ))
-    }
-
-    private fun createTunnelOnIntent(context: Context, extras : Map<String,String>) : Intent {
-        return Intent(context, ShortcutsActivity::class.java).also {
-            it.action = Action.START.name
-            it.putExtra(CLASS_NAME_EXTRA_KEY, WireGuardTunnelService::class.java.name)
-            extras.forEach {(k, v) ->
-                it.putExtra(k, v)
-            }
-        }
-    }
-
-    private fun createTunnelOffIntent(context : Context, extras : Map<String,String>) : Intent {
-        return Intent(context, ShortcutsActivity::class.java).also {
-            it.action = Action.STOP.name
-            it.putExtra(CLASS_NAME_EXTRA_KEY, WireGuardTunnelService::class.java.name)
-            extras.forEach {(k, v) ->
-                it.putExtra(k, v)
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tile/TunnelControlTile.kt

@@ -1,142 +0,0 @@
-package net.nymtech.nymconnect.service.tile
-
-import android.os.Build
-import android.service.quicksettings.Tile
-import android.service.quicksettings.TileService
-import com.wireguard.android.backend.Tunnel
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.foreground.ServiceManager
-import net.nymtech.nymconnect.service.tunnel.VpnService
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class TunnelControlTile : TileService() {
-
-    @Inject
-    lateinit var settingsRepo : Repository<Settings>
-
-    @Inject
-    lateinit var configRepo : Repository<TunnelConfig>
-
-    @Inject
-    lateinit var vpnService : VpnService
-
-    private val scope = CoroutineScope(Dispatchers.Main);
-
-    private lateinit var job : Job
-
-    override fun onStartListening() {
-        job = scope.launch {
-            updateTileState()
-        }
-        super.onStartListening()
-    }
-
-    override fun onTileAdded() {
-        super.onTileAdded()
-        qsTile.contentDescription = this.resources.getString(R.string.toggle_vpn)
-        scope.launch {
-            updateTileState();
-        }
-    }
-
-    override fun onTileRemoved() {
-        super.onTileRemoved()
-        cancelJob()
-    }
-
-    override fun onClick() {
-        super.onClick()
-        unlockAndRun {
-            scope.launch {
-                try {
-                    val tunnel = determineTileTunnel();
-                    if(tunnel != null) {
-                        attemptWatcherServiceToggle(tunnel.toString())
-                        if(vpnService.getState() == Tunnel.State.UP) {
-                            ServiceManager.stopVpnService(this@TunnelControlTile)
-                        } else {
-                            ServiceManager.startVpnService(this@TunnelControlTile, tunnel.toString())
-                        }
-                    }
-                } catch (e : Exception) {
-                    Timber.e(e.message)
-                } finally {
-                    cancel()
-                }
-            }
-        }
-    }
-
-    private suspend fun determineTileTunnel() : TunnelConfig? {
-        var tunnelConfig : TunnelConfig? = null;
-        val settings = settingsRepo.getAll()
-        if (!settings.isNullOrEmpty()) {
-            val setting = settings.first()
-            tunnelConfig = if (setting.defaultTunnel != null) {
-                TunnelConfig.from(setting.defaultTunnel!!);
-            } else {
-                val config = configRepo.getAll()?.first();
-                config;
-            }
-        }
-        return tunnelConfig;
-    }
-
-
-    private fun attemptWatcherServiceToggle(tunnelConfig : String) {
-        scope.launch {
-            val settings = settingsRepo.getAll()
-            if (!settings.isNullOrEmpty()) {
-                val setting = settings.first()
-                if(setting.isAutoTunnelEnabled) {
-                    ServiceManager.toggleWatcherService(this@TunnelControlTile, tunnelConfig)
-                }
-            }
-        }
-    }
-
-    private suspend fun updateTileState() {
-        vpnService.state.collect {
-            when(it) {
-                Tunnel.State.UP -> {
-                    qsTile.state = Tile.STATE_ACTIVE
-                }
-                Tunnel.State.DOWN -> {
-                    qsTile.state = Tile.STATE_INACTIVE;
-                }
-                else -> {
-                    qsTile.state = Tile.STATE_UNAVAILABLE
-                }
-            }
-            val config = determineTileTunnel();
-            setTileDescription(config?.name ?: this.resources.getString(R.string.no_tunnel_available))
-            qsTile.updateTile()
-        }
-    }
-
-    private fun setTileDescription(description : String) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            qsTile.subtitle = description
-        }
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            qsTile.stateDescription = description;
-        }
-    }
-
-    private fun cancelJob() {
-        if(this::job.isInitialized) {
-            job.cancel();
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/HandshakeStatus.kt

@@ -1,14 +0,0 @@
-package net.nymtech.nymconnect.service.tunnel
-
-enum class HandshakeStatus {
-    HEALTHY,
-    UNHEALTHY,
-    NEVER_CONNECTED,
-    NOT_STARTED;
-
-    companion object {
-        private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 120
-        const val UNHEALTHY_TIME_LIMIT_SEC = WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + 60
-        const val NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC = 30
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/VpnService.kt

@@ -1,18 +0,0 @@
-package net.nymtech.nymconnect.service.tunnel
-
-import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Tunnel
-import com.wireguard.crypto.Key
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import kotlinx.coroutines.flow.SharedFlow
-
-interface VpnService : Tunnel {
-    suspend fun startTunnel(tunnelConfig : TunnelConfig) : Tunnel.State
-    suspend fun stopTunnel()
-    val state : SharedFlow<Tunnel.State>
-    val tunnelName : SharedFlow<String>
-    val statistics : SharedFlow<Statistics>
-    val lastHandshake : SharedFlow<Map<Key,Long>>
-    val handshakeStatus : SharedFlow<HandshakeStatus>
-    fun getState() : Tunnel.State
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/WireGuardTunnel.kt

@@ -1,131 +0,0 @@
-package net.nymtech.nymconnect.service.tunnel
-
-import com.wireguard.android.backend.Backend
-import com.wireguard.android.backend.BackendException
-import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Tunnel
-import com.wireguard.crypto.Key
-import net.nymtech.nymconnect.Constants
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import net.nymtech.nymconnect.util.NumberUtils
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.channels.BufferOverflow
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-
-class WireGuardTunnel @Inject constructor(private val backend : Backend,
-) : VpnService {
-
-    private val _tunnelName = MutableStateFlow("")
-    override val tunnelName get() = _tunnelName.asStateFlow()
-
-    private val _state = MutableSharedFlow<Tunnel.State>(
-        onBufferOverflow = BufferOverflow.DROP_OLDEST,
-        replay = 1)
-
-    private val _handshakeStatus = MutableSharedFlow<HandshakeStatus>(replay = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST)
-    override val state get() = _state.asSharedFlow()
-
-    private val _statistics = MutableSharedFlow<Statistics>(replay = 1)
-    override val statistics get() = _statistics.asSharedFlow()
-
-    private val _lastHandshake = MutableSharedFlow<Map<Key, Long>>(replay = 1)
-    override val lastHandshake get() = _lastHandshake.asSharedFlow()
-
-    override val handshakeStatus: SharedFlow<HandshakeStatus>
-        get() = _handshakeStatus.asSharedFlow()
-
-    private lateinit var statsJob : Job
-
-
-    override suspend fun startTunnel(tunnelConfig: TunnelConfig) : Tunnel.State{
-        return try {
-            if(getState() == Tunnel.State.UP && _tunnelName.value != tunnelConfig.name) {
-                stopTunnel()
-            }
-            _tunnelName.emit(tunnelConfig.name)
-            val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val state = backend.setState(
-                this, Tunnel.State.UP, config)
-            _state.emit(state)
-            state;
-        } catch (e : Exception) {
-            Timber.e("Failed to start tunnel with error: ${e.message}")
-            Tunnel.State.DOWN
-        }
-    }
-
-    override fun getName(): String {
-        return _tunnelName.value
-    }
-
-    override suspend  fun stopTunnel() {
-        try {
-            if(getState() == Tunnel.State.UP) {
-                val state = backend.setState(this, Tunnel.State.DOWN, null)
-                _state.emit(state)
-            }
-        } catch (e : BackendException) {
-            Timber.e("Failed to stop tunnel with error: ${e.message}")
-        }
-    }
-
-    override fun getState(): Tunnel.State {
-        return backend.getState(this)
-    }
-
-    override fun onStateChange(state : Tunnel.State) {
-        val tunnel = this;
-        _state.tryEmit(state)
-        if(state == Tunnel.State.UP) {
-            statsJob = CoroutineScope(Dispatchers.IO).launch {
-                val handshakeMap = HashMap<Key, Long>()
-                var neverHadHandshakeCounter = 0
-                while (true) {
-                    val statistics = backend.getStatistics(tunnel)
-                    _statistics.emit(statistics)
-                    statistics.peers().forEach {
-                        val handshakeEpoch = statistics.peer(it)?.latestHandshakeEpochMillis ?: 0L
-                        handshakeMap[it] = handshakeEpoch
-                        if(handshakeEpoch == 0L) {
-                            if(neverHadHandshakeCounter >= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
-                                _handshakeStatus.emit(HandshakeStatus.NEVER_CONNECTED)
-                            } else {
-                                _handshakeStatus.emit(HandshakeStatus.NOT_STARTED)
-                            }
-                            if(neverHadHandshakeCounter <= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
-                                neverHadHandshakeCounter += 10
-                            }
-                            return@forEach
-                        }
-                        if(NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch) >= HandshakeStatus.UNHEALTHY_TIME_LIMIT_SEC) {
-                            _handshakeStatus.emit(HandshakeStatus.UNHEALTHY)
-                        } else {
-                            _handshakeStatus.emit(HandshakeStatus.HEALTHY)
-                        }
-                    }
-                    _lastHandshake.emit(handshakeMap)
-                    delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
-                }
-            }
-        }
-        if(state == Tunnel.State.DOWN) {
-            if(this::statsJob.isInitialized) {
-                statsJob.cancel()
-            }
-            _handshakeStatus.tryEmit(HandshakeStatus.NOT_STARTED)
-            _lastHandshake.tryEmit(emptyMap())
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/model/Settings.kt

@@ -1,15 +0,0 @@
-package net.nymtech.nymconnect.service.tunnel.model
-
-import io.objectbox.annotation.Entity
-import io.objectbox.annotation.Id
-
-@Entity
-data class Settings(
-    @Id
-    var id : Long = 0,
-    var isAutoTunnelEnabled : Boolean = false,
-    var isTunnelOnMobileDataEnabled : Boolean = false,
-    var trustedNetworkSSIDs : MutableList<String> = mutableListOf(),
-    var defaultTunnel : String? = null,
-    var isAlwaysOnVpnEnabled : Boolean = false,
-)

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/model/TunnelConfig.kt

@@ -1,89 +0,0 @@
-package net.nymtech.nymconnect.service.tunnel.model
-
-import com.wireguard.config.Config
-import io.objectbox.annotation.ConflictStrategy
-import io.objectbox.annotation.Entity
-import io.objectbox.annotation.Id
-import io.objectbox.annotation.Unique
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
-import java.io.InputStream
-
-
-@Entity
-@Serializable
-data class TunnelConfig(
-    @Id
-    var id : Long = 0,
-    @Unique(onConflict = ConflictStrategy.REPLACE)
-    var name : String,
-    var wgQuick : String
-) {
-
-
-    override fun toString(): String {
-        return Json.encodeToString(serializer(), this)
-    }
-
-    companion object {
-        private const val INCLUDED_APPLICATIONS = "IncludedApplications = "
-        private const val EXCLUDED_APPLICATIONS = "ExcludedApplications = "
-        private const val INTERFACE = "[Interface]"
-        private const val NEWLINE_CHAR = "\n"
-        private const val APP_CONFIG_SEPARATOR = ", "
-
-        private fun addApplicationsToConfig(appConfig : String, wgQuick : String) : String {
-            val configList = wgQuick.split(NEWLINE_CHAR).toMutableList()
-            val interfaceIndex = configList.indexOf(INTERFACE)
-            configList.add(interfaceIndex + 1, appConfig)
-            return configList.joinToString(NEWLINE_CHAR)
-        }
-
-        fun clearAllApplicationsFromConfig(wgQuick : String) : String {
-            val configList = wgQuick.split(NEWLINE_CHAR).toMutableList()
-            val itr = configList.iterator()
-            while (itr.hasNext()) {
-                val next = itr.next()
-                if(next.contains(INCLUDED_APPLICATIONS) || next.contains(EXCLUDED_APPLICATIONS)) {
-                    itr.remove()
-                }
-            }
-            return configList.joinToString(NEWLINE_CHAR)
-        }
-
-
-        fun setExcludedApplicationsOnQuick(packages : List<String>, wgQuick: String) : String {
-            if(packages.isEmpty()) {
-                return wgQuick
-            }
-            val clearedWgQuick = clearAllApplicationsFromConfig(wgQuick)
-            val excludeConfig = buildExcludedApplicationsString(packages)
-            return addApplicationsToConfig(excludeConfig, clearedWgQuick)
-        }
-
-        fun setIncludedApplicationsOnQuick(packages : List<String>, wgQuick: String) : String {
-            if(packages.isEmpty()) {
-                return wgQuick
-            }
-            val clearedWgQuick = clearAllApplicationsFromConfig(wgQuick)
-            val includeConfig = buildIncludedApplicationsString(packages)
-            return addApplicationsToConfig(includeConfig, clearedWgQuick)
-        }
-
-        private fun buildExcludedApplicationsString(packages : List<String>) : String {
-            return EXCLUDED_APPLICATIONS + packages.joinToString(APP_CONFIG_SEPARATOR)
-        }
-
-        private fun buildIncludedApplicationsString(packages : List<String>) : String {
-            return INCLUDED_APPLICATIONS + packages.joinToString(APP_CONFIG_SEPARATOR)
-        }
-        fun from(string : String) : TunnelConfig {
-            return Json.decodeFromString<TunnelConfig>(string)
-        }
-        fun configFromQuick(wgQuick: String): Config {
-            val inputStream: InputStream = wgQuick.byteInputStream()
-            val reader = inputStream.bufferedReader(Charsets.UTF_8)
-            return Config.parse(reader)
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/MainActivity.kt

@@ -1,201 +0,0 @@
-package net.nymtech.nymconnect.ui
-
-import android.Manifest
-import android.content.Intent
-import android.net.Uri
-import android.os.Build
-import android.os.Bundle
-import android.provider.Settings
-import android.view.KeyEvent
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.compose.setContent
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.animation.ExperimentalAnimationApi
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.slideInHorizontally
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.input.key.onKeyEvent
-import com.google.accompanist.navigation.animation.AnimatedNavHost
-import com.google.accompanist.navigation.animation.composable
-import com.google.accompanist.navigation.animation.rememberAnimatedNavController
-import com.google.accompanist.permissions.ExperimentalPermissionsApi
-import com.google.accompanist.permissions.isGranted
-import com.google.accompanist.permissions.rememberPermissionState
-import com.wireguard.android.backend.GoBackend
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.ui.common.PermissionRequestFailedScreen
-import net.nymtech.nymconnect.ui.common.navigation.BottomNavBar
-import net.nymtech.nymconnect.ui.screens.config.ConfigScreen
-import net.nymtech.nymconnect.ui.screens.detail.DetailScreen
-import net.nymtech.nymconnect.ui.screens.main.MainScreen
-import net.nymtech.nymconnect.ui.screens.settings.SettingsScreen
-import net.nymtech.nymconnect.ui.screens.support.SupportScreen
-import net.nymtech.nymconnect.ui.theme.TransparentSystemBars
-import net.nymtech.nymconnect.ui.theme.WireguardAutoTunnelTheme
-import dagger.hilt.android.AndroidEntryPoint
-import timber.log.Timber
-import java.lang.IllegalStateException
-
-@AndroidEntryPoint
-class MainActivity : AppCompatActivity() {
-
-    @OptIn(ExperimentalAnimationApi::class,
-        ExperimentalPermissionsApi::class
-    )
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContent {
-            val navController = rememberAnimatedNavController()
-            val focusRequester = remember { FocusRequester() }
-
-            WireguardAutoTunnelTheme {
-                TransparentSystemBars()
-
-                val snackbarHostState = remember { SnackbarHostState() }
-
-                val notificationPermissionState =
-                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS)
-
-                fun requestNotificationPermission() {
-                    if (!notificationPermissionState.status.isGranted && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                        notificationPermissionState.launchPermissionRequest()
-                    }
-                }
-
-                var vpnIntent by remember { mutableStateOf(GoBackend.VpnService.prepare(this)) }
-                val vpnActivityResultState = rememberLauncherForActivityResult(
-                    ActivityResultContracts.StartActivityForResult(),
-                    onResult = {
-                        val accepted = (it.resultCode == RESULT_OK)
-                        if (accepted) {
-                            vpnIntent = null
-                        }
-                    })
-                LaunchedEffect(vpnIntent) {
-                    if (vpnIntent != null) {
-                        vpnActivityResultState.launch(vpnIntent)
-                    } else requestNotificationPermission()
-                }
-
-                Scaffold(snackbarHost = { SnackbarHost(snackbarHostState)},
-                    modifier = Modifier.onKeyEvent {
-                        if (it.nativeKeyEvent.action == KeyEvent.ACTION_UP) {
-                            when (it.nativeKeyEvent.keyCode) {
-                                KeyEvent.KEYCODE_DPAD_UP -> {
-                                    try {
-                                        focusRequester.requestFocus()
-                                    } catch(e : IllegalStateException) {
-                                        Timber.e("No D-Pad focus request modifier added to element on screen")
-                                    }
-                                    false
-                                } else -> {
-                                   false;
-                                }
-                            }
-                        } else {
-                            false
-                        }
-                    },
-                    bottomBar = if (vpnIntent == null && notificationPermissionState.status.isGranted) {
-                        { BottomNavBar(navController, Routes.navItems) }
-                    } else {
-                        {}
-                    },
-                )
-                { padding ->
-                    if (vpnIntent != null) {
-                        PermissionRequestFailedScreen(
-                            padding = padding,
-                            onRequestAgain = { vpnActivityResultState.launch(vpnIntent) },
-                            message = getString(R.string.vpn_permission_required),
-                            getString(R.string.retry)
-                        )
-                        return@Scaffold
-                    }
-                    if (!notificationPermissionState.status.isGranted) {
-                        PermissionRequestFailedScreen(
-                            padding = padding,
-                            onRequestAgain = {
-                                val intentSettings =
-                                    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
-                                intentSettings.data =
-                                    Uri.fromParts("package", this.packageName, null)
-                                startActivity(intentSettings);
-                            },
-                            message = getString(R.string.notification_permission_required),
-                            getString(R.string.open_settings)
-                        )
-                        return@Scaffold
-                    }
-                    AnimatedNavHost(navController, startDestination = Routes.Main.name) {
-                        composable(Routes.Main.name, enterTransition = {
-                            when (initialState.destination.route) {
-                                Routes.Settings.name, Routes.Support.name ->
-                                    slideInHorizontally(
-                                        initialOffsetX = { -1000 },
-                                        animationSpec = tween(500)
-                                    )
-
-                                else -> {
-                                    fadeIn(animationSpec = tween(1000))
-                                }
-                            }
-                        }) {
-                            MainScreen(padding = padding, snackbarHostState = snackbarHostState, navController = navController)
-                        }
-                        composable(Routes.Settings.name, enterTransition = {
-                            when (initialState.destination.route) {
-                                Routes.Main.name ->
-                                    slideInHorizontally(
-                                        initialOffsetX = { 1000 },
-                                        animationSpec = tween(500)
-                                    )
-
-                                Routes.Support.name -> {
-                                    slideInHorizontally(
-                                        initialOffsetX = { -1000 },
-                                        animationSpec = tween(500)
-                                    )
-                                }
-
-                                else -> {
-                                    fadeIn(animationSpec = tween(1000))
-                                }
-                            }
-                        }) { SettingsScreen(padding = padding, snackbarHostState = snackbarHostState, navController = navController, focusRequester = focusRequester) }
-                        composable(Routes.Support.name, enterTransition = {
-                            when (initialState.destination.route) {
-                                Routes.Settings.name, Routes.Main.name ->
-                                    slideInHorizontally(
-                                        initialOffsetX = { 1000 },
-                                        animationSpec = tween(500)
-                                    )
-
-                                else -> {
-                                    fadeIn(animationSpec = tween(1000))
-                                }
-                            }
-                        }) { SupportScreen(padding = padding, focusRequester) }
-                        composable("${Routes.Config.name}/{id}", enterTransition = {
-                            fadeIn(animationSpec = tween(1000))
-                        }) { ConfigScreen(padding = padding, navController = navController, id = it.arguments?.getString("id"), focusRequester = focusRequester)}
-                        composable("${Routes.Detail.name}/{id}", enterTransition = {
-                            fadeIn(animationSpec = tween(1000))
-                        }) { DetailScreen(padding = padding, id = it.arguments?.getString("id")) }
-                    }
-                }
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/Routes.kt

@@ -1,36 +0,0 @@
-package net.nymtech.nymconnect.ui
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Home
-import androidx.compose.material.icons.rounded.QuestionMark
-import androidx.compose.material.icons.rounded.Settings
-import net.nymtech.nymconnect.ui.common.navigation.BottomNavItem
-
-enum class Routes {
-    Main,
-    Settings,
-    Support,
-    Config,
-    Detail;
-
-
-    companion object {
-        val navItems = listOf(
-            BottomNavItem(
-                name = "Tunnels",
-                route = Main.name,
-                icon = Icons.Rounded.Home,
-            ),
-            BottomNavItem(
-                name = "Settings",
-                route = Settings.name,
-                icon = Icons.Rounded.Settings,
-            ),
-            BottomNavItem(
-                name = "Support",
-                route = Support.name,
-                icon = Icons.Rounded.QuestionMark,
-            )
-        )
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/ViewState.kt

@@ -1,9 +0,0 @@
-package net.nymtech.nymconnect.ui
-
-data class ViewState(
-    val showSnackbarMessage : Boolean = false,
-    val snackbarMessage : String = "",
-    val snackbarActionText : String = "",
-    val onSnackbarActionClick : () -> Unit = {},
-    val isLoading : Boolean = false
-)

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/ClickableIconButton.kt

@@ -1,31 +0,0 @@
-package net.nymtech.nymconnect.ui.common
-
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.size
-import androidx.compose.material3.Button
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.vector.ImageVector
-
-@Composable
-fun ClickableIconButton(onIconClick : () -> Unit, text : String, icon : ImageVector, enabled : Boolean) {
-    Button(onClick = {},
-        enabled = enabled
-    ) {
-        Text(text)
-        Spacer(modifier = Modifier.size(ButtonDefaults.IconSpacing))
-        Icon(
-            imageVector = icon,
-            contentDescription = "Delete",
-            modifier = Modifier.size(ButtonDefaults.IconSize).clickable {
-                if(enabled) {
-                    onIconClick()
-                }
-            }
-        )
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/PermissionRequestFailedScreen.kt

@@ -1,35 +0,0 @@
-package net.nymtech.nymconnect.ui.common
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import kotlinx.coroutines.launch
-
-@Composable
-fun PermissionRequestFailedScreen(padding : PaddingValues, onRequestAgain : () -> Unit, message : String, buttonText : String ) {
-    val scope = rememberCoroutineScope()
-    Column(horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center,
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(padding)) {
-        Text(message, textAlign = TextAlign.Center, modifier = Modifier.padding(15.dp))
-        Button(onClick = {
-            scope.launch {
-                onRequestAgain()
-            }
-        }) {
-            Text(buttonText)
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/RowListItem.kt

@@ -1,55 +0,0 @@
-package net.nymtech.nymconnect.ui.common
-
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.unit.dp
-
-@OptIn(ExperimentalFoundationApi::class)
-@Composable
-fun RowListItem(leadingIcon : ImageVector? = null, leadingIconColor : Color = Color.Gray, text : String, onHold : () -> Unit, onClick: () -> Unit, rowButton : @Composable() () -> Unit ) {
-    Box(
-        modifier = Modifier
-            .combinedClickable(
-                onClick = {
-                    onClick()
-                },
-                onLongClick = {
-                    onHold()
-                }
-            )
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(14.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Row(verticalAlignment = Alignment.CenterVertically,) {
-                if(leadingIcon != null) {
-                    Icon(
-                        leadingIcon, "status",
-                        tint = leadingIconColor,
-                        modifier =  Modifier.padding(end = 10.dp).size(15.dp)
-                    )
-                }
-                Text(text)
-            }
-
-            rowButton()
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/SearchBar.kt

@@ -1,80 +0,0 @@
-package net.nymtech.nymconnect.ui.common
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Clear
-import androidx.compose.material.icons.rounded.Search
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
-import androidx.compose.material3.TextFieldDefaults
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.RectangleShape
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.input.KeyboardType
-import net.nymtech.nymconnect.R
-
-@Composable
-fun SearchBar(
-    onQuery : (queryString : String) -> Unit
-) {
-    // Immediately update and keep track of query from text field changes.
-    var query: String by rememberSaveable { mutableStateOf("") }
-    var showClearIcon by rememberSaveable { mutableStateOf(false) }
-
-    if (query.isEmpty()) {
-        showClearIcon = false
-    } else if (query.isNotEmpty()) {
-        showClearIcon = true
-    }
-
-    TextField(
-        value = query,
-        onValueChange = { onQueryChanged ->
-            // If user makes changes to text, immediately updated it.
-            query = onQueryChanged
-            onQuery(onQueryChanged)
-        },
-        leadingIcon = {
-            Icon(
-                imageVector = Icons.Rounded.Search,
-                tint = MaterialTheme.colorScheme.onBackground,
-                contentDescription = stringResource(id = R.string.search_icon)
-            )
-        },
-        trailingIcon = {
-            if (showClearIcon) {
-                IconButton(onClick = { query = "" }) {
-                    Icon(
-                        imageVector = Icons.Rounded.Clear,
-                        tint = MaterialTheme.colorScheme.onBackground,
-                        contentDescription = stringResource(id = R.string.clear_icon)
-                    )
-                }
-            }
-        },
-        maxLines = 1,
-        colors = TextFieldDefaults.colors(
-            focusedContainerColor = Color.Transparent,
-            unfocusedContainerColor = Color.Transparent,
-            disabledContainerColor = Color.Transparent,
-        ),
-        placeholder = { Text(text = stringResource(R.string.hint_search_packages)) },
-        textStyle = MaterialTheme.typography.bodySmall,
-        singleLine = true,
-        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Text),
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape)
-    )
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/navigation/BottomNavBar.kt

@@ -1,42 +0,0 @@
-package net.nymtech.nymconnect.ui.common.navigation
-
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.NavigationBar
-import androidx.compose.material3.NavigationBarItem
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.text.font.FontWeight
-import androidx.navigation.NavController
-import androidx.navigation.compose.currentBackStackEntryAsState
-
-@Composable
-fun BottomNavBar(navController : NavController, bottomNavItems : List<BottomNavItem>) {
-
-    val backStackEntry = navController.currentBackStackEntryAsState()
-
-    NavigationBar(
-        containerColor = MaterialTheme.colorScheme.background,
-    ) {
-        bottomNavItems.forEach { item ->
-            val selected = item.route == backStackEntry.value?.destination?.route
-
-            NavigationBarItem(
-                selected = selected,
-                onClick = { navController.navigate(item.route) },
-                label = {
-                    Text(
-                        text = item.name,
-                        fontWeight = FontWeight.SemiBold,
-                    )
-                },
-                icon = {
-                    Icon(
-                        imageVector = item.icon,
-                        contentDescription = "${item.name} Icon",
-                    )
-                }
-            )
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/navigation/BottomNavItem.kt

@@ -1,9 +0,0 @@
-package net.nymtech.nymconnect.ui.common.navigation
-
-import androidx.compose.ui.graphics.vector.ImageVector
-
-data class BottomNavItem(
-    val name: String,
-    val route: String,
-    val icon: ImageVector,
-)

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/config/ConfigScreen.kt

@@ -1,241 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.config
-
-import android.widget.Toast
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Android
-import androidx.compose.material3.Button
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.Icon
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.ExperimentalComposeUiApi
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.navigation.NavController
-import com.google.accompanist.drawablepainter.DrawablePainter
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.ui.Routes
-import net.nymtech.nymconnect.ui.common.SearchBar
-import kotlinx.coroutines.launch
-
-@OptIn(ExperimentalComposeUiApi::class)
-@Composable
-fun ConfigScreen(
-    viewModel: ConfigViewModel = hiltViewModel(),
-    padding: PaddingValues,
-    focusRequester: FocusRequester,
-    navController: NavController,
-    id : String?
-) {
-
-    val context = LocalContext.current
-    val focusManager = LocalFocusManager.current
-
-    val keyboardController = LocalSoftwareKeyboardController.current
-    val scope = rememberCoroutineScope()
-    val tunnel by viewModel.tunnel.collectAsStateWithLifecycle(null)
-    val tunnelName = viewModel.tunnelName.collectAsStateWithLifecycle()
-    val packages by viewModel.packages.collectAsStateWithLifecycle()
-    val checkedPackages by viewModel.checkedPackages.collectAsStateWithLifecycle()
-    val include by viewModel.include.collectAsStateWithLifecycle()
-    val allApplications by viewModel.allApplications.collectAsStateWithLifecycle()
-
-    LaunchedEffect(Unit) {
-        viewModel.getTunnelById(id)
-        viewModel.emitQueriedPackages("")
-        viewModel.emitCurrentPackageConfigurations(id)
-    }
-
-    if(tunnel != null) {
-        LazyColumn(
-            horizontalAlignment = Alignment.Start,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-            item {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 20.dp, vertical = 7.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceBetween
-                ) {
-                    OutlinedTextField(
-                        modifier = Modifier.focusRequester(focusRequester),
-                        value = tunnelName.value,
-                        onValueChange = {
-                            viewModel.onTunnelNameChange(it)
-                        },
-                        label = { Text(stringResource(id = R.string.tunnel_name)) },
-                        maxLines = 1,
-                        keyboardOptions = KeyboardOptions(
-                            capitalization = KeyboardCapitalization.None,
-                            imeAction = ImeAction.Done
-                        ),
-                        keyboardActions = KeyboardActions(
-                            onDone = {
-                                focusManager.clearFocus()
-                                keyboardController?.hide()
-                                viewModel.onTunnelNameChange(tunnelName.value)
-                            }
-                        ),
-                    )
-                }
-            }
-            item {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 20.dp, vertical = 7.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceBetween
-                ) {
-                    Text(stringResource(id = R.string.tunnel_all))
-                    Switch(
-                        checked = allApplications,
-                        onCheckedChange = {
-                            viewModel.onAllApplicationsChange(!allApplications)
-                        }
-                    )
-                }
-            }
-                if (!allApplications) {
-                    item {
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(horizontal = 20.dp, vertical = 7.dp),
-                            verticalAlignment = Alignment.CenterVertically,
-                            horizontalArrangement = Arrangement.SpaceBetween
-                        ) {
-                            Row(
-                                verticalAlignment = Alignment.CenterVertically,
-                                horizontalArrangement = Arrangement.SpaceBetween
-                            ) {
-                                Text(stringResource(id = R.string.include))
-                                Checkbox(
-                                    checked = include,
-                                    onCheckedChange = {
-                                        viewModel.onIncludeChange(!include)
-                                    }
-                                )
-                            }
-                            Row(
-                                verticalAlignment = Alignment.CenterVertically,
-                                horizontalArrangement = Arrangement.SpaceBetween
-                            ) {
-                                Text(stringResource(id = R.string.exclude))
-                                Checkbox(
-                                    checked = !include,
-                                    onCheckedChange = {
-                                        viewModel.onIncludeChange(!include)
-                                    }
-                                )
-                            }
-                        }
-                    }
-                    item {
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(horizontal = 20.dp, vertical = 7.dp),
-                            verticalAlignment = Alignment.CenterVertically,
-                            horizontalArrangement = Arrangement.SpaceBetween) {
-                            SearchBar(viewModel::emitQueriedPackages);
-                        }
-                    }
-                    items(packages) { pack ->
-                        Row(
-                            verticalAlignment = Alignment.CenterVertically,
-                            horizontalArrangement = Arrangement.SpaceBetween
-                        ) {
-                            Row(
-                                horizontalArrangement = Arrangement.Center,
-                                verticalAlignment = Alignment.CenterVertically,
-                                modifier = Modifier.padding(5.dp)
-                            ) {
-                                val drawable =
-                                    pack.applicationInfo?.loadIcon(context.packageManager)
-                                if (drawable != null) {
-                                    Image(
-                                        painter = DrawablePainter(drawable),
-                                        stringResource(id = R.string.icon),
-                                        modifier = Modifier.size(50.dp, 50.dp)
-                                    )
-                                } else {
-                                    Icon(
-                                        Icons.Rounded.Android,
-                                        stringResource(id = R.string.edit),
-                                        modifier = Modifier.size(50.dp, 50.dp)
-                                    )
-                                }
-                                Text(
-                                    pack.applicationInfo.loadLabel(context.packageManager)
-                                        .toString(), modifier = Modifier.padding(5.dp)
-                                )
-                            }
-                            Checkbox(
-                                checked = (checkedPackages.contains(pack.packageName)),
-                                onCheckedChange = {
-                                    if (it) viewModel.onAddCheckedPackage(pack.packageName) else viewModel.onRemoveCheckedPackage(
-                                        pack.packageName
-                                    )
-                                }
-                            )
-                        }
-                    }
-                }
-            item {
-                Row(
-                    horizontalArrangement = Arrangement.Center,
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    Button(onClick = {
-                        scope.launch {
-                            viewModel.onSaveAllChanges()
-                            Toast.makeText(
-                                context,
-                                context.resources.getString(R.string.config_changes_saved),
-                                Toast.LENGTH_LONG
-                            ).show()
-                            navController.navigate(Routes.Main.name)
-                        }
-                    }, Modifier.padding(25.dp)) {
-                        Text(stringResource(id = R.string.save_changes))
-                    }
-                }
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/config/ConfigViewModel.kt

@@ -1,152 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.config
-
-import android.Manifest
-import android.app.Application
-import android.content.pm.PackageInfo
-import android.content.pm.PackageManager
-import android.os.Build
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.toMutableStateList
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-@HiltViewModel
-class ConfigViewModel @Inject constructor(private val application : Application,
-                                          private val tunnelRepo : Repository<TunnelConfig>,
-                                          private val settingsRepo : Repository<Settings>) : ViewModel() {
-
-    private val _tunnel = MutableStateFlow<TunnelConfig?>(null)
-    private val _tunnelName = MutableStateFlow("")
-    val tunnelName get() = _tunnelName.asStateFlow()
-    val tunnel get() = _tunnel.asStateFlow()
-    private val _packages = MutableStateFlow(emptyList<PackageInfo>())
-    val packages get() = _packages.asStateFlow()
-    private val packageManager = application.packageManager
-
-    private val _checkedPackages = MutableStateFlow(mutableStateListOf<String>())
-    val checkedPackages get() = _checkedPackages.asStateFlow()
-    private val _include = MutableStateFlow(true)
-    val include get() = _include.asStateFlow()
-
-    private val _allApplications = MutableStateFlow(true)
-    val allApplications get() = _allApplications.asStateFlow()
-
-    suspend fun getTunnelById(id : String?) : TunnelConfig? {
-        return try {
-            if(id != null) {
-                val config = tunnelRepo.getById(id.toLong())
-                if (config != null) {
-                    _tunnel.emit(config)
-                    _tunnelName.emit(config.name)
-
-                }
-                return config
-            }
-            return null
-        } catch (e : Exception) {
-            Timber.e(e.message)
-            null
-        }
-    }
-
-    fun onTunnelNameChange(name : String) {
-        _tunnelName.value = name
-    }
-
-    fun onIncludeChange(include : Boolean) {
-        _include.value = include
-    }
-    fun onAddCheckedPackage(packageName : String) {
-        _checkedPackages.value.add(packageName)
-    }
-
-    fun onAllApplicationsChange(allApplications : Boolean) {
-        _allApplications.value = allApplications
-    }
-
-    fun onRemoveCheckedPackage(packageName : String) {
-        _checkedPackages.value.remove(packageName)
-    }
-
-    suspend fun emitCurrentPackageConfigurations(id : String?) {
-        val tunnelConfig = getTunnelById(id)
-        if(tunnelConfig != null) {
-            val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val excludedApps = config.`interface`.excludedApplications
-            val includedApps = config.`interface`.includedApplications
-            if(excludedApps.isNullOrEmpty() && includedApps.isNullOrEmpty()) {
-                _allApplications.emit(true)
-                return
-            }
-            if(excludedApps.isEmpty()) {
-                _include.emit(true)
-                _checkedPackages.emit(includedApps.toMutableStateList())
-            } else {
-                _include.emit(false)
-                _checkedPackages.emit(excludedApps.toMutableStateList())
-            }
-            _allApplications.emit(false)
-        }
-    }
-
-    fun emitQueriedPackages(query : String) {
-        viewModelScope.launch {
-            _packages.emit(getAllInternetCapablePackages().filter {
-                it.packageName.contains(query)
-            })
-        }
-    }
-
-    private fun getAllInternetCapablePackages() : List<PackageInfo> {
-        return getPackagesHoldingPermissions(arrayOf(Manifest.permission.INTERNET))
-    }
-
-    private fun getPackagesHoldingPermissions(permissions: Array<String>): List<PackageInfo> {
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            packageManager.getPackagesHoldingPermissions(permissions, PackageManager.PackageInfoFlags.of(0L))
-        } else {
-            @Suppress("DEPRECATION")
-            packageManager.getPackagesHoldingPermissions(permissions, 0)
-        }
-    }
-
-    suspend fun onSaveAllChanges() {
-        var wgQuick = _tunnel.value?.wgQuick
-        if(wgQuick != null) {
-            wgQuick = if(_include.value) {
-                TunnelConfig.setIncludedApplicationsOnQuick(_checkedPackages.value, wgQuick)
-            } else {
-                TunnelConfig.setExcludedApplicationsOnQuick(_checkedPackages.value, wgQuick)
-            }
-            if(_allApplications.value) {
-                wgQuick = TunnelConfig.clearAllApplicationsFromConfig(wgQuick)
-            }
-            _tunnel.value?.copy(
-                name = _tunnelName.value,
-                wgQuick = wgQuick
-            )?.let {
-                tunnelRepo.save(it)
-                val settings = settingsRepo.getAll()
-                if(settings != null) {
-                    val setting = settings[0]
-                    if(setting.defaultTunnel != null) {
-                        if(it.id == TunnelConfig.from(setting.defaultTunnel!!).id) {
-                            settingsRepo.save(setting.copy(
-                                defaultTunnel = it.toString()
-                            ))
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/detail/DetailScreen.kt

@@ -1,139 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.detail
-
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.ClipboardManager
-import androidx.compose.ui.platform.LocalClipboardManager
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.util.NumberUtils
-import java.time.Duration
-import java.time.Instant
-
-@Composable
-fun DetailScreen(
-    viewModel: DetailViewModel = hiltViewModel(),
-    padding: PaddingValues,
-    id : String?
-) {
-
-    val clipboardManager: ClipboardManager = LocalClipboardManager.current
-    val tunnelStats by viewModel.tunnelStats.collectAsStateWithLifecycle(null)
-    val tunnel by viewModel.tunnel.collectAsStateWithLifecycle(null)
-    val tunnelName by viewModel.tunnelName.collectAsStateWithLifecycle()
-    val lastHandshake by viewModel.lastHandshake.collectAsStateWithLifecycle(emptyMap())
-
-
-    LaunchedEffect(Unit) {
-        viewModel.getTunnelById(id)
-    }
-
-    if(tunnel != null) {
-        val interfaceKey = tunnel?.`interface`?.keyPair?.publicKey?.toBase64().toString()
-        val addresses = tunnel?.`interface`?.addresses!!.joinToString()
-        val dnsServers = tunnel?.`interface`?.dnsServers!!.joinToString()
-        val optionalMtu = tunnel?.`interface`?.mtu
-        val mtu = if(optionalMtu?.isPresent == true) optionalMtu.get().toString() else "None"
-        Column(
-            horizontalAlignment = Alignment.Start,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .verticalScroll(rememberScrollState())
-                .padding(padding)
-        ) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 20.dp, vertical = 7.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween
-            ) {
-                Column {
-                    Text(stringResource(R.string.config_interface), fontWeight = FontWeight.Bold, fontSize = 20.sp)
-                    Text(stringResource(R.string.name), fontStyle = FontStyle.Italic)
-                    Text(text = tunnelName,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(tunnelName))
-                    })
-                    Text(stringResource(R.string.public_key), fontStyle = FontStyle.Italic)
-                    Text(text = interfaceKey,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(interfaceKey))
-                    })
-                    Text(stringResource(R.string.addresses), fontStyle = FontStyle.Italic)
-                    Text(text = addresses,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(addresses))
-                    })
-                    Text(stringResource(R.string.dns_servers), fontStyle = FontStyle.Italic)
-                    Text(text = dnsServers,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(dnsServers))
-                    })
-                    Text(stringResource(R.string.mtu), fontStyle = FontStyle.Italic)
-                    Text(text = mtu,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(mtu))
-                    })
-                    Box(modifier = Modifier.padding(10.dp))
-                    tunnel?.peers?.forEach{
-                        val peerKey = it.publicKey.toBase64().toString()
-                        val allowedIps = it.allowedIps.joinToString()
-                        val endpoint = if(it.endpoint.isPresent) it.endpoint.get().toString() else "None"
-                        Text(stringResource(R.string.peer), fontWeight = FontWeight.Bold, fontSize = 20.sp)
-                        Text(stringResource(R.string.public_key), fontStyle = FontStyle.Italic)
-                        Text(text = peerKey,  modifier = Modifier.clickable {
-                            clipboardManager.setText(AnnotatedString(peerKey))
-                        })
-                        Text(stringResource(id = R.string.allowed_ips), fontStyle = FontStyle.Italic)
-                        Text(text = allowedIps,  modifier = Modifier.clickable {
-                            clipboardManager.setText(AnnotatedString(allowedIps))
-                        })
-                        Text(stringResource(R.string.endpoint), fontStyle = FontStyle.Italic)
-                        Text(text = endpoint,  modifier = Modifier.clickable {
-                            clipboardManager.setText(AnnotatedString(endpoint))
-                        })
-                        if (tunnelStats != null) {
-                            val totalRx = tunnelStats?.totalRx() ?: 0
-                            val totalTx = tunnelStats?.totalTx() ?: 0
-                            if((totalRx + totalTx != 0L))  {
-                                val rxKB = NumberUtils.bytesToKB(tunnelStats!!.totalRx())
-                                val txKB = NumberUtils.bytesToKB(tunnelStats!!.totalTx())
-                                Text(stringResource(R.string.transfer), fontStyle = FontStyle.Italic)
-                                Text("rx: ${NumberUtils.formatDecimalTwoPlaces(rxKB)} KB tx: ${NumberUtils.formatDecimalTwoPlaces(txKB)} KB")
-                                Text(stringResource(R.string.last_handshake), fontStyle = FontStyle.Italic)
-                                val handshakeEpoch = lastHandshake[it.publicKey]
-                                if(handshakeEpoch != null) {
-                                    if(handshakeEpoch == 0L) {
-                                        Text("Never")
-                                    } else {
-                                        val time = Instant.ofEpochMilli(handshakeEpoch)
-                                        Text("${Duration.between(time, Instant.now()).seconds} seconds ago")
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/detail/DetailViewModel.kt

@@ -1,45 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.detail
-
-import androidx.lifecycle.ViewModel
-import com.wireguard.config.Config
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.tunnel.VpnService
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import timber.log.Timber
-import javax.inject.Inject
-
-@HiltViewModel
-class DetailViewModel @Inject constructor(private val tunnelRepo : Repository<TunnelConfig>, private val vpnService : VpnService
-
-) : ViewModel() {
-
-    private val _tunnel = MutableStateFlow<Config?>(null)
-    val tunnel get() = _tunnel.asStateFlow()
-
-    private val _tunnelName = MutableStateFlow<String>("")
-    val tunnelName = _tunnelName.asStateFlow()
-    val tunnelStats get() = vpnService.statistics
-    val lastHandshake get() = vpnService.lastHandshake
-
-    private var config : TunnelConfig? = null
-
-    suspend fun getTunnelById(id : String?) : TunnelConfig? {
-        return try {
-            if(id != null) {
-               config = tunnelRepo.getById(id.toLong())
-                if (config != null) {
-                    _tunnel.emit(TunnelConfig.configFromQuick(config!!.wgQuick))
-                    _tunnelName.emit(config!!.name)
-                }
-                return config
-            }
-            return null
-        } catch (e : Exception) {
-            Timber.e(e.message)
-            null
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/MainScreen.kt

@@ -1,336 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.main
-
-import android.annotation.SuppressLint
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.focusable
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.lazy.itemsIndexed
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.FileOpen
-import androidx.compose.material.icons.rounded.Add
-import androidx.compose.material.icons.rounded.Circle
-import androidx.compose.material.icons.rounded.Delete
-import androidx.compose.material.icons.rounded.Edit
-import androidx.compose.material.icons.rounded.Info
-import androidx.compose.material3.Divider
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.FabPosition
-import androidx.compose.material3.FloatingActionButton
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.ModalBottomSheet
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.SnackbarDuration
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.SnackbarResult
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Text
-import androidx.compose.material3.rememberModalBottomSheetState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
-import androidx.compose.ui.input.nestedscroll.NestedScrollSource
-import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.navigation.NavController
-import com.wireguard.android.backend.Tunnel
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.WireGuardAutoTunnel
-import net.nymtech.nymconnect.service.tunnel.HandshakeStatus
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import net.nymtech.nymconnect.ui.Routes
-import net.nymtech.nymconnect.ui.common.RowListItem
-import net.nymtech.nymconnect.ui.theme.brickRed
-import net.nymtech.nymconnect.ui.theme.mint
-import kotlinx.coroutines.launch
-
-@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun MainScreen(
-    viewModel: MainViewModel = hiltViewModel(), padding: PaddingValues,
-    snackbarHostState: SnackbarHostState, navController: NavController
-) {
-
-    val haptic = LocalHapticFeedback.current
-    val context = LocalContext.current
-    val isVisible = rememberSaveable { mutableStateOf(true) }
-    val scope = rememberCoroutineScope()
-
-    val sheetState = rememberModalBottomSheetState()
-    var showBottomSheet by remember { mutableStateOf(false) }
-    val tunnels by viewModel.tunnels.collectAsStateWithLifecycle(mutableListOf())
-    val handshakeStatus by viewModel.handshakeStatus.collectAsStateWithLifecycle(HandshakeStatus.NOT_STARTED)
-    val viewState = viewModel.viewState.collectAsStateWithLifecycle()
-    var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
-    val state by viewModel.state.collectAsStateWithLifecycle(Tunnel.State.DOWN)
-    val tunnelName by viewModel.tunnelName.collectAsStateWithLifecycle("")
-
-    // Nested scroll for control FAB
-    val nestedScrollConnection = remember {
-        object : NestedScrollConnection {
-            override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
-                // Hide FAB
-                if (available.y < -1) {
-                    isVisible.value = false
-                }
-                // Show FAB
-                if (available.y > 1) {
-                    isVisible.value = true
-                }
-                return Offset.Zero
-            }
-        }
-    }
-
-    LaunchedEffect(viewState.value) {
-        if (viewState.value.showSnackbarMessage) {
-            val result = snackbarHostState.showSnackbar(
-                message = viewState.value.snackbarMessage,
-                actionLabel = viewState.value.snackbarActionText,
-                duration = SnackbarDuration.Long,
-            )
-            when (result) {
-                SnackbarResult.ActionPerformed -> viewState.value.onSnackbarActionClick
-                SnackbarResult.Dismissed -> viewState.value.onSnackbarActionClick
-            }
-        }
-    }
-
-    val pickFileLauncher = rememberLauncherForActivityResult(
-        ActivityResultContracts.GetContent()
-    ) { file ->
-        if (file != null) {
-            viewModel.onTunnelFileSelected(file)
-        }
-    }
-
-    Scaffold(
-        modifier = Modifier.pointerInput(Unit) {
-            detectTapGestures(onTap = {
-                selectedTunnel = null
-            })
-        },
-        floatingActionButtonPosition = FabPosition.End,
-        floatingActionButton = {
-            AnimatedVisibility(
-                visible = isVisible.value,
-                enter = slideInVertically(initialOffsetY = { it * 2 }),
-                exit = slideOutVertically(targetOffsetY = { it * 2 }),
-            ) {
-                FloatingActionButton(
-                    modifier = Modifier.padding(bottom = 90.dp),
-                    onClick = {
-                        showBottomSheet = true
-                    },
-                    containerColor = MaterialTheme.colorScheme.secondary,
-                    shape = RoundedCornerShape(16.dp),
-                ) {
-                    Icon(
-                        imageVector = Icons.Rounded.Add,
-                        contentDescription = stringResource(id = R.string.add_tunnel),
-                        tint = Color.DarkGray,
-                    )
-                }
-            }
-        }
-    ) {
-        if (tunnels.isEmpty()) {
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center,
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(padding)
-            ) {
-                Text(text = stringResource(R.string.no_tunnels), fontStyle = FontStyle.Italic)
-            }
-        }
-        if (showBottomSheet) {
-            ModalBottomSheet(
-                onDismissRequest = {
-                    showBottomSheet = false
-                },
-                sheetState = sheetState
-            ) {
-                // Sheet content
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .clickable {
-                            showBottomSheet = false
-                            pickFileLauncher.launch("*/*")
-                        }
-                        .padding(10.dp)
-                ) {
-                    Icon(
-                        Icons.Filled.FileOpen,
-                        contentDescription = stringResource(id = R.string.open_file),
-                        modifier = Modifier.padding(10.dp)
-                    )
-                    Text(
-                        stringResource(id = R.string.add_from_file),
-                        modifier = Modifier.padding(10.dp)
-                    )
-                }
-                Divider()
-            }
-        }
-        Column(
-            horizontalAlignment = Alignment.Start,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-
-            LazyColumn(
-                modifier = Modifier.fillMaxSize()
-                    .nestedScroll(nestedScrollConnection),
-            ) {
-                itemsIndexed(tunnels.toList()) { index, tunnel ->
-                    val focusRequester = FocusRequester();
-                    RowListItem(leadingIcon = Icons.Rounded.Circle,
-                        leadingIconColor = if (tunnelName == tunnel.name) when (handshakeStatus) {
-                            HandshakeStatus.HEALTHY -> mint
-                            HandshakeStatus.UNHEALTHY -> brickRed
-                            HandshakeStatus.NOT_STARTED -> Color.Gray
-                            HandshakeStatus.NEVER_CONNECTED -> brickRed
-                        } else Color.Gray,
-                        text = tunnel.name,
-                        onHold = {
-                            if (state == Tunnel.State.UP && tunnel.name == tunnelName) {
-                                scope.launch {
-                                    viewModel.showSnackBarMessage(context.resources.getString(R.string.turn_off_tunnel))
-                                }
-                                return@RowListItem
-                            }
-                            haptic.performHapticFeedback(HapticFeedbackType.LongPress)
-                            selectedTunnel = tunnel;
-                        },
-                        onClick = {
-                            if (!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                                navController.navigate("${Routes.Detail.name}/${tunnel.id}")
-                            } else {
-                                focusRequester.requestFocus()
-                            }
-                        },
-                        rowButton = {
-                            if (tunnel.id == selectedTunnel?.id) {
-                                Row {
-                                    IconButton(onClick = {
-                                        navController.navigate("${Routes.Config.name}/${selectedTunnel?.id}")
-                                    }) {
-                                        Icon(Icons.Rounded.Edit, stringResource(id = R.string.edit))
-                                    }
-                                    IconButton(
-                                        modifier = Modifier.focusable(),
-                                        onClick = { viewModel.onDelete(tunnel) }) {
-                                        Icon(
-                                            Icons.Rounded.Delete,
-                                            stringResource(id = R.string.delete)
-                                        )
-                                    }
-                                }
-                            } else {
-                                if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                                    Row {
-                                        IconButton(
-                                            modifier = Modifier.focusRequester(focusRequester),
-                                            onClick = {
-                                                navController.navigate("${Routes.Detail.name}/${tunnel.id}")
-                                            }) {
-                                            Icon(Icons.Rounded.Info, "Info")
-                                        }
-                                        IconButton(onClick = {
-                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName)
-                                                scope.launch {
-                                                    viewModel.showSnackBarMessage(
-                                                        context.resources.getString(
-                                                            R.string.turn_off_tunnel
-                                                        )
-                                                    )
-                                                } else {
-                                                navController.navigate("${Routes.Config.name}/${tunnel.id}")
-                                            }
-                                        }) {
-                                            Icon(
-                                                Icons.Rounded.Edit,
-                                                stringResource(id = R.string.edit)
-                                            )
-                                        }
-                                        IconButton(onClick = {
-                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName)
-                                                scope.launch {
-                                                    viewModel.showSnackBarMessage(
-                                                        context.resources.getString(
-                                                            R.string.turn_off_tunnel
-                                                        )
-                                                    )
-                                                } else {
-                                                viewModel.onDelete(tunnel)
-                                            }
-                                        }) {
-                                            Icon(
-                                                Icons.Rounded.Delete,
-                                                stringResource(id = R.string.delete)
-                                            )
-                                        }
-                                        Switch(
-                                            checked = (state == Tunnel.State.UP && tunnel.name == tunnelName),
-                                            onCheckedChange = { checked ->
-                                                if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
-                                            }
-                                        )
-                                    }
-                                } else {
-                                    Switch(
-                                        checked = (state == Tunnel.State.UP && tunnel.name == tunnelName),
-                                        onCheckedChange = { checked ->
-                                            if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
-                                        }
-                                    )
-                                }
-                            }
-                        })
-                }
-            }
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/MainViewModel.kt

@@ -1,179 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.main
-
-import android.annotation.SuppressLint
-import android.app.Application
-import android.content.Context
-import android.net.Uri
-import android.provider.OpenableColumns
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.wireguard.config.BadConfigException
-import com.wireguard.config.Config
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.foreground.ServiceState
-import net.nymtech.nymconnect.service.foreground.ServiceManager
-import net.nymtech.nymconnect.service.foreground.WireGuardConnectivityWatcherService
-import net.nymtech.nymconnect.service.shortcut.ShortcutsManager
-import net.nymtech.nymconnect.service.tunnel.VpnService
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import net.nymtech.nymconnect.ui.ViewState
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-
-@HiltViewModel
-class MainViewModel @Inject constructor(private val application : Application,
-                                        private val tunnelRepo : Repository<TunnelConfig>,
-                                        private val settingsRepo : Repository<Settings>,
-                                        private val vpnService: VpnService,
-) : ViewModel() {
-
-    private val _viewState = MutableStateFlow(ViewState())
-    val viewState get() = _viewState.asStateFlow()
-    val tunnels get() = tunnelRepo.itemFlow
-    val state get() = vpnService.state
-
-    val handshakeStatus get() = vpnService.handshakeStatus
-    val tunnelName get() = vpnService.tunnelName
-    private val _settings = MutableStateFlow(Settings())
-    val settings get() = _settings.asStateFlow()
-
-    private val defaultConfigName = {
-        "tunnel${(Math.random() * 100000).toInt()}"
-    }
-
-
-    init {
-        viewModelScope.launch {
-            settingsRepo.itemFlow.collect {
-                val settings = it.first()
-                validateWatcherServiceState(settings)
-                _settings.emit(settings)
-            }
-        }
-    }
-
-    private fun validateWatcherServiceState(settings: Settings) {
-        val watcherState = ServiceManager.getServiceState(application.applicationContext, WireGuardConnectivityWatcherService::class.java)
-        if(settings.isAutoTunnelEnabled && watcherState == ServiceState.STOPPED && settings.defaultTunnel != null) {
-            ServiceManager.startWatcherService(application.applicationContext, settings.defaultTunnel!!)
-        }
-    }
-
-
-    fun onDelete(tunnel : TunnelConfig) {
-        viewModelScope.launch {
-            if(tunnelRepo.count() == 1L) {
-                ServiceManager.stopWatcherService(application.applicationContext)
-                val settings = settingsRepo.getAll()
-                if(!settings.isNullOrEmpty()) {
-                    val setting = settings[0]
-                    setting.defaultTunnel = null
-                    setting.isAutoTunnelEnabled = false
-                    setting.isAlwaysOnVpnEnabled = false
-                    settingsRepo.save(setting)
-                }
-            }
-            tunnelRepo.delete(tunnel)
-            ShortcutsManager.removeTunnelShortcuts(application.applicationContext, tunnel)
-        }
-    }
-
-    fun onTunnelStart(tunnelConfig : TunnelConfig) = viewModelScope.launch {
-        ServiceManager.startVpnService(application.applicationContext, tunnelConfig.toString())
-    }
-
-    fun onTunnelStop() {
-        ServiceManager.stopVpnService(application.applicationContext)
-    }
-
-    fun onTunnelFileSelected(uri : Uri) {
-        try {
-            val fileName = getFileName(application.applicationContext, uri)
-            val extension = getFileExtensionFromFileName(fileName)
-            if(extension != ".conf") {
-                viewModelScope.launch {
-                    showSnackBarMessage(application.resources.getString(R.string.file_extension_message))
-                }
-                return
-            }
-            val stream = application.applicationContext.contentResolver.openInputStream(uri)
-            stream ?: return
-            val bufferReader = stream.bufferedReader(charset = Charsets.UTF_8)
-                val config = Config.parse(bufferReader)
-                val tunnelName = getNameFromFileName(fileName)
-                saveTunnel(TunnelConfig(name = tunnelName, wgQuick = config.toWgQuickString()))
-            stream.close()
-        } catch(_: BadConfigException) {
-            viewModelScope.launch {
-                showSnackBarMessage(application.applicationContext.getString(R.string.bad_config))
-            }
-        }
-    }
-
-    private fun saveTunnel(tunnelConfig : TunnelConfig) {
-        viewModelScope.launch {
-            tunnelRepo.save(tunnelConfig)
-            ShortcutsManager.createTunnelShortcuts(application.applicationContext, tunnelConfig)
-        }
-    }
-
-    @SuppressLint("Range")
-    private fun getFileName(context: Context, uri: Uri): String {
-        if (uri.scheme == "content") {
-            val cursor = try {
-                context.contentResolver.query(uri, null, null, null, null)
-            } catch (e : Exception) {
-                Timber.d("Exception getting config name")
-                null
-            }
-            cursor ?: return defaultConfigName()
-            cursor.use {
-                if(cursor.moveToFirst()) {
-                    return cursor.getString(cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME))
-                }
-            }
-        }
-        return defaultConfigName()
-    }
-
-    suspend fun showSnackBarMessage(message : String) {
-        _viewState.emit(_viewState.value.copy(
-            showSnackbarMessage = true,
-            snackbarMessage = message,
-            snackbarActionText = "Okay",
-            onSnackbarActionClick = {
-                viewModelScope.launch {
-                    dismissSnackBar()
-                }
-            }
-        ))
-        delay(3000)
-        dismissSnackBar()
-    }
-
-    private suspend fun dismissSnackBar() {
-        _viewState.emit(_viewState.value.copy(
-            showSnackbarMessage = false
-        ))
-    }
-
-    private fun getNameFromFileName(fileName : String) : String {
-        return fileName.substring(0 , fileName.lastIndexOf('.') )
-    }
-
-    private fun getFileExtensionFromFileName(fileName : String) : String {
-        return try {
-            fileName.substring(fileName.lastIndexOf('.'))
-        } catch (e : Exception) {
-            ""
-        }
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/SettingsScreen.kt

@@ -1,415 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.settings
-
-import android.Manifest
-import android.content.Intent
-import android.net.Uri
-import android.os.Build
-import android.provider.Settings
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.FlowRow
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Close
-import androidx.compose.material.icons.outlined.Add
-import androidx.compose.material.icons.rounded.LocationOff
-import androidx.compose.material3.Button
-import androidx.compose.material3.DropdownMenuItem
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ExposedDropdownMenuBox
-import androidx.compose.material3.ExposedDropdownMenuDefaults
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.SnackbarDuration
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.SnackbarResult
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.navigation.NavController
-import com.google.accompanist.permissions.ExperimentalPermissionsApi
-import com.google.accompanist.permissions.isGranted
-import com.google.accompanist.permissions.rememberPermissionState
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.WireGuardAutoTunnel
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import net.nymtech.nymconnect.ui.Routes
-import net.nymtech.nymconnect.ui.common.ClickableIconButton
-import kotlinx.coroutines.launch
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalPermissionsApi::class,
-    ExperimentalLayoutApi::class
-)
-@Composable
-fun SettingsScreen(
-    viewModel: SettingsViewModel = hiltViewModel(),
-    padding: PaddingValues,
-    navController: NavController,
-    focusRequester: FocusRequester,
-    snackbarHostState: SnackbarHostState = remember { SnackbarHostState() }
-) {
-
-    val scope = rememberCoroutineScope()
-    val context = LocalContext.current
-    val focusManager = LocalFocusManager.current
-    val interactionSource = remember { MutableInteractionSource() }
-
-    var expanded by remember { mutableStateOf(false) }
-    val viewState by viewModel.viewState.collectAsStateWithLifecycle()
-    val settings by viewModel.settings.collectAsStateWithLifecycle()
-    val trustedSSIDs by viewModel.trustedSSIDs.collectAsStateWithLifecycle()
-    val tunnels by viewModel.tunnels.collectAsStateWithLifecycle(mutableListOf())
-    val backgroundLocationState =
-        rememberPermissionState(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
-    val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
-    var currentText by remember { mutableStateOf("") }
-    val scrollState = rememberScrollState()
-    var isLocationServicesEnabled by remember { mutableStateOf(viewModel.checkLocationServicesEnabled())}
-
-    LaunchedEffect(viewState) {
-        if (viewState.showSnackbarMessage) {
-            val result = snackbarHostState.showSnackbar(
-                message = viewState.snackbarMessage,
-                actionLabel = viewState.snackbarActionText,
-                duration = SnackbarDuration.Long,
-            )
-            when (result) {
-                SnackbarResult.ActionPerformed -> viewState.onSnackbarActionClick
-                SnackbarResult.Dismissed -> viewState.onSnackbarActionClick
-            }
-        }
-    }
-
-    fun saveTrustedSSID() {
-        if (currentText.isNotEmpty()) {
-            scope.launch {
-                viewModel.onSaveTrustedSSID(currentText)
-                currentText = ""
-            }
-        }
-    }
-
-    fun openSettings() {
-        scope.launch {
-            val intentSettings =
-                Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
-            intentSettings.data =
-                Uri.fromParts("package", context.packageName, null)
-            context.startActivity(intentSettings)
-        }
-    }
-
-    if(!backgroundLocationState.status.isGranted && Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
-        Column(horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .verticalScroll(scrollState)
-                .padding(padding)) {
-            Icon(Icons.Rounded.LocationOff, contentDescription = stringResource(id = R.string.map), modifier = Modifier
-                .padding(30.dp)
-                .size(128.dp))
-            Text(stringResource(R.string.prominent_background_location_title), textAlign = TextAlign.Center, modifier = Modifier.padding(30.dp), fontSize = 20.sp)
-            Text(stringResource(R.string.prominent_background_location_message), textAlign = TextAlign.Center, modifier = Modifier.padding(30.dp), fontSize = 15.sp)
-            Row(
-                modifier = if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) Modifier
-                    .fillMaxWidth()
-                    .padding(10.dp) else Modifier
-                    .fillMaxWidth()
-                    .padding(30.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceEvenly
-            ) {
-                Button(onClick = {
-                    navController.navigate(Routes.Main.name)
-                }) {
-                    Text(stringResource(id = R.string.no_thanks))
-                }
-                Button(modifier = Modifier.focusRequester(focusRequester), onClick = {
-                    openSettings()
-                }) {
-                    Text(stringResource(id = R.string.turn_on))
-                }
-            }
-        }
-        return
-    }
-
-    if(!fineLocationState.status.isGranted) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-            Text(
-                stringResource(id = R.string.precise_location_message),
-                textAlign = TextAlign.Center,
-                modifier = Modifier.padding(15.dp),
-                fontStyle = FontStyle.Italic
-            )
-            Button(modifier = Modifier.focusRequester(focusRequester),onClick = {
-                fineLocationState.launchPermissionRequest()
-            }) {
-                Text(stringResource(id = R.string.request))
-            }
-
-        }
-        return
-    }
-
-    if (tunnels.isEmpty()) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-            Text(
-                stringResource(R.string.one_tunnel_required),
-                textAlign = TextAlign.Center,
-                modifier = Modifier.padding(15.dp),
-                fontStyle = FontStyle.Italic
-            )
-        }
-        return
-    }
-    if(!isLocationServicesEnabled && Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-            Text(
-                stringResource(id = R.string.location_services_not_detected),
-                textAlign = TextAlign.Center,
-                modifier = Modifier.padding(15.dp),
-                fontStyle = FontStyle.Italic
-            )
-            Button(modifier = Modifier.focusRequester(focusRequester), onClick = {
-                val locationServicesEnabled = viewModel.checkLocationServicesEnabled()
-                isLocationServicesEnabled = locationServicesEnabled
-                if(!locationServicesEnabled) {
-                    scope.launch {
-                        viewModel.showSnackBarMessage(context.getString(R.string.detecting_location_services_disabled))
-                    }
-                }
-            }) {
-                Text(stringResource(id = R.string.check_again))
-            }
-        }
-        return
-    }
-    val screenPadding = if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) 5.dp else 15.dp
-    Column(
-        horizontalAlignment = Alignment.Start,
-        verticalArrangement = Arrangement.Top,
-        modifier = if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) Modifier
-            .fillMaxHeight(.85f)
-            .fillMaxWidth()
-            .verticalScroll(scrollState)
-            .clickable(indication = null, interactionSource = interactionSource) {
-                focusManager.clearFocus()
-            }
-            .padding(padding) else Modifier
-            .fillMaxSize()
-            .verticalScroll(scrollState)
-            .clickable(indication = null, interactionSource = interactionSource) {
-                focusManager.clearFocus()
-            }
-            .padding(padding)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(screenPadding),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Text(stringResource(R.string.enable_auto_tunnel))
-            Switch(
-                modifier = Modifier.focusRequester(focusRequester),
-                enabled = !settings.isAlwaysOnVpnEnabled,
-                checked = settings.isAutoTunnelEnabled,
-                onCheckedChange = {
-                    scope.launch {
-                        viewModel.toggleAutoTunnel()
-                    }
-                }
-            )
-        }
-        Text(
-            stringResource(id = R.string.select_tunnel),
-            textAlign = TextAlign.Center,
-            modifier = Modifier.padding(screenPadding, bottom = 5.dp, top = 5.dp)
-        )
-        ExposedDropdownMenuBox(
-            expanded = expanded,
-            onExpandedChange = {
-                if(!(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled)) {
-                expanded = !expanded }},
-            modifier = Modifier.padding(start = 15.dp, top = 5.dp, bottom = 10.dp).clickable {
-                  expanded = !expanded
-            },
-        ) {
-            TextField(
-                enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
-                value = settings.defaultTunnel?.let {
-                    TunnelConfig.from(it).name }
-                    ?: "",
-                readOnly = true,
-                modifier = Modifier.menuAnchor(),
-                label = { Text(stringResource(R.string.tunnels)) },
-                onValueChange = { },
-                trailingIcon = {
-                    ExposedDropdownMenuDefaults.TrailingIcon(
-                        expanded = expanded
-                    )
-                }
-            )
-            ExposedDropdownMenu(
-                expanded = expanded,
-                onDismissRequest = {
-                    expanded = false
-                }
-            ) {
-                tunnels.forEach() { tunnel ->
-                    DropdownMenuItem(
-                        onClick = {
-                            scope.launch {
-                                viewModel.onDefaultTunnelSelected(tunnel)
-                            }
-                            expanded = false
-                        },
-                        text = { Text(text = tunnel.name) }
-                    )
-                }
-            }
-        }
-        Text(
-            stringResource(R.string.trusted_ssid),
-            textAlign = TextAlign.Center,
-            modifier = Modifier.padding(screenPadding, bottom = 5.dp, top = 5.dp)
-        )
-        FlowRow(
-            modifier = Modifier.padding(screenPadding),
-            horizontalArrangement = Arrangement.spacedBy(8.dp),
-            verticalArrangement = Arrangement.SpaceEvenly
-        ) {
-            trustedSSIDs.forEach { ssid ->
-                ClickableIconButton(onIconClick = {
-                    scope.launch {
-                        viewModel.onDeleteTrustedSSID(ssid)
-                    }
-                }, text = ssid, icon = Icons.Filled.Close, enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled))
-            }
-        }
-        OutlinedTextField(
-            enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
-            value = currentText,
-            onValueChange = { currentText = it },
-            label = { Text(stringResource(R.string.add_trusted_ssid)) },
-            modifier = Modifier.padding(start = screenPadding, top = 5.dp),
-            maxLines = 1,
-            keyboardOptions = KeyboardOptions(
-                capitalization = KeyboardCapitalization.None,
-                imeAction = ImeAction.Done
-            ),
-            keyboardActions = KeyboardActions(
-                onDone = {
-                    saveTrustedSSID()
-                }
-            ),
-            trailingIcon = {
-                IconButton(onClick = { saveTrustedSSID() }) {
-                    Icon(
-                        imageVector = Icons.Outlined.Add,
-                        contentDescription = if (currentText == "") stringResource(id = R.string.trusted_ssid_empty_description) else stringResource(
-                            id = R.string.trusted_ssid_value_description
-                        ),
-                        tint = if(currentText == "") Color.Transparent else Color.Green
-                    )
-                }
-            },
-        )
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(screenPadding),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Text(stringResource(R.string.tunnel_mobile_data))
-            Switch(
-                enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
-                checked = settings.isTunnelOnMobileDataEnabled,
-                onCheckedChange = {
-                    scope.launch {
-                        viewModel.onToggleTunnelOnMobileData()
-                    }
-                }
-            )
-        }
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(screenPadding),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Text(stringResource(R.string.always_on_vpn_support))
-            Switch(
-                enabled = !settings.isAutoTunnelEnabled,
-                checked = settings.isAlwaysOnVpnEnabled,
-                onCheckedChange = {
-                    scope.launch {
-                        viewModel.onToggleAlwaysOnVPN()
-                    }
-                }
-            )
-        }
-    }
-}
-
-

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/SettingsViewModel.kt

@@ -1,124 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.settings
-
-import android.app.Application
-import android.content.Context
-import android.location.LocationManager
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import net.nymtech.nymconnect.R
-import net.nymtech.nymconnect.repository.Repository
-import net.nymtech.nymconnect.service.foreground.ServiceManager
-import net.nymtech.nymconnect.service.tunnel.model.Settings
-import net.nymtech.nymconnect.service.tunnel.model.TunnelConfig
-import net.nymtech.nymconnect.ui.ViewState
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-
-@HiltViewModel
-class SettingsViewModel @Inject constructor(private val application : Application,
-    private val tunnelRepo : Repository<TunnelConfig>, private val settingsRepo : Repository<Settings>
-) : ViewModel() {
-
-    private val _trustedSSIDs = MutableStateFlow(emptyList<String>())
-    val trustedSSIDs = _trustedSSIDs.asStateFlow()
-    private val _settings = MutableStateFlow(Settings())
-    val settings get() = _settings.asStateFlow()
-    val tunnels get() = tunnelRepo.itemFlow
-    private val _viewState = MutableStateFlow(ViewState())
-    val viewState get() = _viewState.asStateFlow()
-
-    init {
-        checkLocationServicesEnabled()
-        viewModelScope.launch {
-            settingsRepo.itemFlow.collect {
-                val settings = it.first()
-                _settings.emit(settings)
-                _trustedSSIDs.emit(settings.trustedNetworkSSIDs.toList())
-            }
-        }
-    }
-
-    suspend fun onSaveTrustedSSID(ssid: String) {
-        val trimmed = ssid.trim()
-        if (!_settings.value.trustedNetworkSSIDs.contains(trimmed)) {
-            _settings.value.trustedNetworkSSIDs.add(trimmed)
-            settingsRepo.save(_settings.value)
-        } else {
-            showSnackBarMessage("SSID already exists.")
-        }
-    }
-
-    suspend fun onDefaultTunnelSelected(tunnelConfig: TunnelConfig) {
-        settingsRepo.save(_settings.value.copy(
-            defaultTunnel = tunnelConfig.toString()
-        ))
-    }
-
-    suspend fun onToggleTunnelOnMobileData() {
-        settingsRepo.save(_settings.value.copy(
-            isTunnelOnMobileDataEnabled = !_settings.value.isTunnelOnMobileDataEnabled
-        ))
-    }
-
-    suspend fun onDeleteTrustedSSID(ssid: String) {
-        _settings.value.trustedNetworkSSIDs.remove(ssid)
-        settingsRepo.save(_settings.value)
-    }
-
-    suspend fun toggleAutoTunnel() {
-        if(_settings.value.defaultTunnel.isNullOrEmpty() && !_settings.value.isAutoTunnelEnabled) {
-            showSnackBarMessage(application.getString(R.string.select_tunnel_message))
-            return
-        }
-        if(_settings.value.isAutoTunnelEnabled) {
-            ServiceManager.stopWatcherService(application)
-        } else {
-            if(_settings.value.defaultTunnel != null) {
-                val defaultTunnel = _settings.value.defaultTunnel
-                ServiceManager.startWatcherService(application, defaultTunnel!!)
-            }
-        }
-        settingsRepo.save(_settings.value.copy(
-            isAutoTunnelEnabled = !_settings.value.isAutoTunnelEnabled
-        ))
-    }
-
-    suspend fun showSnackBarMessage(message : String) {
-        _viewState.emit(_viewState.value.copy(
-            showSnackbarMessage = true,
-            snackbarMessage = message,
-            snackbarActionText = "Okay",
-            onSnackbarActionClick = {
-                viewModelScope.launch {
-                    dismissSnackBar()
-                }
-            }
-        ))
-    }
-
-    private suspend fun dismissSnackBar() {
-        _viewState.emit(_viewState.value.copy(
-            showSnackbarMessage = false
-        ))
-    }
-
-    suspend fun onToggleAlwaysOnVPN() {
-        if(_settings.value.defaultTunnel != null) {
-            _settings.emit(
-                _settings.value.copy(isAlwaysOnVpnEnabled = !_settings.value.isAlwaysOnVpnEnabled)
-            )
-            settingsRepo.save(_settings.value)
-        } else {
-            showSnackBarMessage(application.getString(R.string.select_tunnel_message))
-        }
-    }
-    fun checkLocationServicesEnabled() : Boolean {
-        val locationManager =
-            application.getSystemService(Context.LOCATION_SERVICE) as LocationManager
-        return locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/SupportScreen.kt

@@ -1,83 +0,0 @@
-package net.nymtech.nymconnect.ui.screens.support
-
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.net.Uri
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.focusable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.res.vectorResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.style.TextDecoration
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import net.nymtech.nymconnect.R
-
-@Composable
-fun SupportScreen(padding : PaddingValues, focusRequester: FocusRequester) {
-
-    val context = LocalContext.current
-
-    fun openWebPage(url: String) {
-        val webpage: Uri = Uri.parse(url)
-        val intent = Intent(Intent.ACTION_VIEW, webpage)
-        context.startActivity(intent)
-    }
-
-        Column(horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .verticalScroll(rememberScrollState())
-                .focusable()
-                .padding(padding)) {
-            Text(stringResource(R.string.support_text), textAlign = TextAlign.Center, modifier = Modifier.padding(30.dp), fontSize = 15.sp)
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(14.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceEvenly
-            ) {
-                IconButton(onClick = {
-                    openWebPage(context.resources.getString(R.string.discord_url))
-                }) {
-                    Icon(imageVector = ImageVector.vectorResource(R.drawable.discord), "Discord")
-                }
-                IconButton(modifier = Modifier.focusRequester(focusRequester),onClick = {
-                    openWebPage(context.resources.getString(R.string.github_url))
-                }) {
-                    Icon(imageVector = ImageVector.vectorResource(R.drawable.github), "Github")
-                }
-            }
-            Spacer(modifier = Modifier.weight(1f))
-            Text(stringResource(id = R.string.privacy_policy), style = TextStyle(textDecoration = TextDecoration.Underline),
-                modifier = Modifier.clickable {
-                openWebPage(context.resources.getString(R.string.privacy_policy_url))
-            })
-            Text("App version: ${net.nymtech.nymconnect.BuildConfig.VERSION_NAME}", Modifier.padding(25.dp))
-        }
-    }

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/Color.kt

@@ -1,17 +0,0 @@
-package net.nymtech.nymconnect.ui.theme
-
-import androidx.compose.ui.graphics.Color
-
-val Purple80 = Color(0xFFD0BCFF)
-val PurpleGrey80 = Color(0xFFCCC2DC)
-val Pink80 = Color(0xFF492532)
-val virdigris = Color(0xFF5BC0BE)
-
-val Purple40 = Color(0xFF6650a4)
-val PurpleGrey40 = Color(0xFF625b71)
-val Pink40 = Color(0xFFFFFFFF)
-
-//status colors
-val brickRed = Color(0xFFCE4257)
-val pinkRed = Color(0xFFEF476F)
-val mint = Color(0xFF52B788)

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/Theme.kt

@@ -1,80 +0,0 @@
-package net.nymtech.nymconnect.ui.theme
-
-import android.app.Activity
-import android.os.Build
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.darkColorScheme
-import androidx.compose.material3.dynamicDarkColorScheme
-import androidx.compose.material3.dynamicLightColorScheme
-import androidx.compose.material3.lightColorScheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.SideEffect
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalView
-import androidx.core.view.WindowCompat
-
-private val DarkColorScheme = darkColorScheme(
-    //primary = Purple80,
-    primary = virdigris,
-    secondary = virdigris,
-   // secondary = PurpleGrey80,
-    tertiary = virdigris
-    //tertiary = Pink80
-)
-
-private val LightColorScheme = lightColorScheme(
-    primary = Purple40,
-    secondary = PurpleGrey40,
-    tertiary = Pink40
-
-    /* Other default colors to override
-    background = Color(0xFFFFFBFE),
-    surface = Color(0xFFFFFBFE),
-    onPrimary = Color.White,
-    onSecondary = Color.White,
-    onTertiary = Color.White,
-    onBackground = Color(0xFF1C1B1F),
-    onSurface = Color(0xFF1C1B1F),
-    */
-)
-
-@Composable
-fun WireguardAutoTunnelTheme(
-    //force dark theme
-    darkTheme : Boolean = true,
-    //darkTheme: Boolean = isSystemInDarkTheme(),
-    // Dynamic color is available on Android 12+
-    //turning off dynamic color for now
-    dynamicColor: Boolean = false,
-    content: @Composable () -> Unit
-) {
-
-    val colorScheme = when {
-        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
-            val context = LocalContext.current
-            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
-        }
-
-        darkTheme -> DarkColorScheme
-        else -> LightColorScheme
-    }
-    val view = LocalView.current
-    if (!view.isInEditMode) {
-        SideEffect {
-            val window = (view.context as Activity).window
-            WindowCompat.setDecorFitsSystemWindows(window, false)
-            window.statusBarColor = Color.Transparent.toArgb()
-            window.navigationBarColor = Color.Transparent.toArgb()
-            WindowCompat.getInsetsController(window, window.decorView).isAppearanceLightStatusBars = !darkTheme
-            WindowCompat.getInsetsController(window, window.decorView).isAppearanceLightNavigationBars = !darkTheme
-        }
-    }
-
-    MaterialTheme(
-        colorScheme = colorScheme,
-        typography = Typography,
-        content = content
-    )
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/TransparentSystemBars.kt

@@ -1,22 +0,0 @@
-package net.nymtech.nymconnect.ui.theme
-
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.ui.graphics.Color
-import com.google.accompanist.systemuicontroller.rememberSystemUiController
-
-@Composable
-fun TransparentSystemBars() {
-    val systemUiController = rememberSystemUiController()
-    val useDarkIcons = !isSystemInDarkTheme()
-
-    DisposableEffect(systemUiController, useDarkIcons) {
-        systemUiController.setSystemBarsColor(
-            color = Color.Transparent,
-            darkIcons = useDarkIcons
-        )
-
-        onDispose {}
-    }
-}

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/Type.kt

@@ -1,34 +0,0 @@
-package net.nymtech.nymconnect.ui.theme
-
-import androidx.compose.material3.Typography
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.sp
-
-// Set of Material typography styles to start with
-val Typography = Typography(
-    bodyLarge = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Normal,
-        fontSize = 16.sp,
-        lineHeight = 24.sp,
-        letterSpacing = 0.5.sp
-    )
-    /* Other default text styles to override
-    titleLarge = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Normal,
-        fontSize = 22.sp,
-        lineHeight = 28.sp,
-        letterSpacing = 0.sp
-    ),
-    labelSmall = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Medium,
-        fontSize = 11.sp,
-        lineHeight = 16.sp,
-        letterSpacing = 0.5.sp
-    )
-    */
-)

nym-vpn/android/app/src/main/java/com/zaneschepke/wireguardautotunnel/util/NumberUtils.kt

@@ -1,25 +0,0 @@
-package net.nymtech.nymconnect.util
-
-import java.math.BigDecimal
-import java.text.DecimalFormat
-import java.time.Duration
-import java.time.Instant
-
-object NumberUtils {
-
-    private const val BYTES_IN_KB = 1024L
-
-    fun bytesToKB(bytes : Long) : BigDecimal {
-        return bytes.toBigDecimal().divide(BYTES_IN_KB.toBigDecimal())
-    }
-
-    fun formatDecimalTwoPlaces(bigDecimal: BigDecimal) : String {
-        val df = DecimalFormat("#.##")
-        return df.format(bigDecimal)
-    }
-
-    fun getSecondsBetweenTimestampAndNow(epoch : Long) : Long {
-        val time = Instant.ofEpochMilli(epoch)
-        return Duration.between(time, Instant.now()).seconds
-    }
-}

nym-vpn/android/app/src/main/res/drawable/discord.xml

@@ -1,10 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="800dp"
-    android:height="800dp"
-    android:viewportWidth="256"
-    android:viewportHeight="256">
-  <path
-      android:pathData="M216.86,45.1C200.29,37.34 182.57,31.71 164.04,28.5C161.77,32.61 159.11,38.15 157.28,42.55C137.58,39.58 118.07,39.58 98.74,42.55C96.91,38.15 94.19,32.61 91.9,28.5C73.35,31.71 55.61,37.36 39.04,45.14C5.62,95.65 -3.44,144.9 1.09,193.46C23.26,210.01 44.74,220.07 65.86,226.65C71.08,219.47 75.73,211.84 79.74,203.8C72.1,200.9 64.79,197.32 57.89,193.17C59.72,191.81 61.51,190.39 63.24,188.93C105.37,208.63 151.13,208.63 192.75,188.93C194.51,190.39 196.3,191.81 198.11,193.17C191.18,197.34 183.85,200.92 176.22,203.82C180.23,211.84 184.86,219.49 190.1,226.67C211.24,220.09 232.74,210.03 254.91,193.46C260.23,137.17 245.83,88.37 216.86,45.1ZM85.47,163.59C72.83,163.59 62.46,151.79 62.46,137.41C62.46,123.04 72.61,111.21 85.47,111.21C98.34,111.21 108.71,123.02 108.49,137.41C108.51,151.79 98.34,163.59 85.47,163.59ZM170.53,163.59C157.88,163.59 147.51,151.79 147.51,137.41C147.51,123.04 157.66,111.21 170.53,111.21C183.39,111.21 193.76,123.02 193.54,137.41C193.54,151.79 183.39,163.59 170.53,163.59Z"
-      android:fillColor="#5865F2"
-      android:fillType="nonZero"/>
-</vector>

nym-vpn/android/app/src/main/res/drawable/github.xml

@@ -1,12 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="800dp"
-    android:height="800dp"
-    android:viewportWidth="20"
-    android:viewportHeight="20">
-  <path
-      android:pathData="M10,0C15.523,0 20,4.59 20,10.253C20,14.782 17.138,18.624 13.167,19.981C12.66,20.082 12.48,19.762 12.48,19.489C12.48,19.151 12.492,18.047 12.492,16.675C12.492,15.719 12.172,15.095 11.813,14.777C14.04,14.523 16.38,13.656 16.38,9.718C16.38,8.598 15.992,7.684 15.35,6.966C15.454,6.707 15.797,5.664 15.252,4.252C15.252,4.252 14.414,3.977 12.505,5.303C11.706,5.076 10.85,4.962 10,4.958C9.15,4.962 8.295,5.076 7.497,5.303C5.586,3.977 4.746,4.252 4.746,4.252C4.203,5.664 4.546,6.707 4.649,6.966C4.01,7.684 3.619,8.598 3.619,9.718C3.619,13.646 5.954,14.526 8.175,14.785C7.889,15.041 7.63,15.493 7.54,16.156C6.97,16.418 5.522,16.871 4.63,15.304C4.63,15.304 4.101,14.319 3.097,14.247C3.097,14.247 2.122,14.234 3.029,14.87C3.029,14.87 3.684,15.185 4.139,16.37C4.139,16.37 4.726,18.2 7.508,17.58C7.513,18.437 7.522,19.245 7.522,19.489C7.522,19.76 7.338,20.077 6.839,19.982C2.865,18.627 0,14.783 0,10.253C0,4.59 4.478,0 10,0"
-      android:strokeWidth="1"
-      android:fillColor="#000000"
-      android:fillType="evenOdd"
-      android:strokeColor="#00000000"/>
-</vector>

nym-vpn/android/app/src/main/res/drawable/ic_launcher_background.xml

@@ -1,170 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#3DDC84"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M9,0L9,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,0L19,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,0L29,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,0L39,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,0L49,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,0L59,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,0L69,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,0L79,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M89,0L89,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M99,0L99,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,9L108,9"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,19L108,19"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,29L108,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,39L108,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,49L108,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,59L108,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,69L108,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,79L108,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,89L108,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,99L108,99"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,29L89,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,39L89,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,49L89,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,59L89,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,69L89,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,79L89,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,19L29,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,19L39,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,19L49,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,19L59,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,19L69,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,19L79,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-</vector>

nym-vpn/android/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -1,30 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:aapt="http://schemas.android.com/aapt"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
-        <aapt:attr name="android:fillColor">
-            <gradient
-                android:endX="85.84757"
-                android:endY="92.4963"
-                android:startX="42.9492"
-                android:startY="49.59793"
-                android:type="linear">
-                <item
-                    android:color="#44000000"
-                    android:offset="0.0" />
-                <item
-                    android:color="#00000000"
-                    android:offset="1.0" />
-            </gradient>
-        </aapt:attr>
-    </path>
-    <path
-        android:fillColor="#FFFFFF"
-        android:fillType="nonZero"
-        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
-        android:strokeWidth="1"
-        android:strokeColor="#00000000" />
-</vector>

nym-vpn/android/app/src/main/res/drawable/shield.xml

@@ -1,5 +0,0 @@
-<vector android:height="24dp" android:tint="#000000"
-    android:viewportHeight="24" android:viewportWidth="24"
-    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
-    <path android:fillColor="@android:color/white" android:pathData="M12,1L3,5v6c0,5.55 3.84,10.74 9,12 5.16,-1.26 9,-6.45 9,-12V5l-9,-4z"/>
-</vector>

nym-vpn/android/app/src/main/res/drawable/vpn_off.xml

@@ -1,5 +0,0 @@
-<vector android:height="24dp" android:tint="#000000"
-    android:viewportHeight="24" android:viewportWidth="24"
-    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
-    <path android:fillColor="@android:color/white" android:pathData="M20.83,18H21v-4h2v-4H12.83L20.83,18zM19.78,22.61l1.41,-1.41L2.81,2.81L1.39,4.22l2.59,2.59C2.2,7.85 1,9.79 1,12c0,3.31 2.69,6 6,6c2.21,0 4.15,-1.2 5.18,-2.99L19.78,22.61zM8.99,11.82C9,11.88 9,11.94 9,12c0,1.1 -0.9,2 -2,2s-2,-0.9 -2,-2s0.9,-2 2,-2c0.06,0 0.12,0 0.18,0.01L8.99,11.82z"/>
-</vector>

nym-vpn/android/app/src/main/res/drawable/vpn_on.xml

@@ -1,5 +0,0 @@
-<vector android:height="24dp" android:tint="#000000"
-    android:viewportHeight="24" android:viewportWidth="24"
-    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
-    <path android:fillColor="@android:color/white" android:pathData="M12.65,10C11.83,7.67 9.61,6 7,6c-3.31,0 -6,2.69 -6,6s2.69,6 6,6c2.61,0 4.83,-1.67 5.65,-4H17v4h4v-4h2v-4H12.65zM7,14c-1.1,0 -2,-0.9 -2,-2s0.9,-2 2,-2 2,0.9 2,2 -0.9,2 -2,2z"/>
-</vector>

nym-vpn/android/app/src/main/res/mipmap-anydpi-v26/ic_banner.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_banner_background"/>
-    <foreground android:drawable="@mipmap/ic_banner_foreground"/>
-</adaptive-icon>

nym-vpn/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
-</adaptive-icon>

nym-vpn/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
-</adaptive-icon>