Merge pull request 'connection_functionality' (#7) from connection_functionality into dev

Reviewed-on: https://git.bubblev.org/bubblev/bubble-droid/pulls/7

ui/src/main/java/com/wireguard/android/activity/MainActivity.java

@@ -1,14 +1,32 @@
 package com.wireguard.android.activity;
 
+import androidx.annotation.Nullable;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.lifecycle.ViewModelProvider;
 import android.content.Intent;
 import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.wireguard.android.Application;
 import com.wireguard.android.R;
+import com.wireguard.android.backend.GoBackend;
+import com.wireguard.android.backend.Tunnel;
+import com.wireguard.android.model.ObservableTunnel;
 import com.wireguard.android.viewmodel.MainViewModel;
 
 public class MainActivity extends AppCompatActivity {
     private MainViewModel mainViewModel;
+    private TextView bubbleStatus;
+    private TextView deviceStatus;
+    private Button connectButton;
+    public ObservableTunnel pendingTunnel;
+    private Boolean pendingTunnelUp;
+
+    private static final int REQUEST_CODE_VPN_PERMISSION = 23491;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -21,5 +39,68 @@ public class MainActivity extends AppCompatActivity {
             startActivity(intent);
             finish();
         }
+        initUI();
+        pendingTunnel = mainViewModel.getTunnel(this);
+    }
+
+    private void initUI() {
+        initViews();
+        initListeners();
+    }
+
+    private void initViews() {
+        bubbleStatus = findViewById(R.id.bubbleStatus);
+        deviceStatus = findViewById(R.id.deviceStatus);
+        connectButton = findViewById(R.id.connectButton);
+    }
+
+    private void initListeners() {
+        connectButton.setOnClickListener(new OnClickListener() {
+            @Override public void onClick(final View v) {
+                connect();
+            }
+        });
+    }
+
+    private void connect() {
+            setTunnelState(true);
+    }
+
+    private void setTunnelState(final Boolean checked) {
+        if(pendingTunnel!=null) {
+            final ObservableTunnel tunnel = pendingTunnel;
+            Application.getBackendAsync().thenAccept(backend -> {
+                if (backend instanceof GoBackend) {
+                    final Intent intent = GoBackend.VpnService.prepare(this);
+                    if (intent != null) {
+                        pendingTunnelUp = checked;
+                        startActivityForResult(intent, REQUEST_CODE_VPN_PERMISSION);
+                        return;
+                    }
+                }
+                setTunnelStateWithPermissionsResult(tunnel, checked);
+            });
+        }
+
+}
+
+    private void setTunnelStateWithPermissionsResult(final ObservableTunnel tunnel, final boolean checked) {
+        tunnel.setStateAsync(Tunnel.State.of(checked)).whenComplete((observableTunnel, throwable) ->{
+           if(throwable==null){
+               Toast.makeText(this,"Connected",Toast.LENGTH_SHORT).show();
+           }
+           else {
+               Toast.makeText(this,"Failed",Toast.LENGTH_SHORT).show();
+           }
+        });
+    }
+
+    @Override protected void onActivityResult(final int requestCode, final int resultCode, @Nullable final Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (requestCode == REQUEST_CODE_VPN_PERMISSION) {
+            if (pendingTunnel != null && pendingTunnelUp != null) setTunnelStateWithPermissionsResult(pendingTunnel, pendingTunnelUp);
+            pendingTunnel = null;
+            pendingTunnelUp = null;
+        }
     }
 }

ui/src/main/java/com/wireguard/android/repository/DataRepository.java

@@ -10,10 +10,16 @@ import com.wireguard.android.api.ApiConstants;
 import com.wireguard.android.api.network.ClientApi;
 import com.wireguard.android.api.network.ClientService;
 import com.wireguard.android.api.network.NetworkBoundStatusResource;
+import com.wireguard.android.backend.Tunnel.State;
+import com.wireguard.android.configStore.FileConfigStore;
 import com.wireguard.android.model.Device;
+import com.wireguard.android.model.ObservableTunnel;
+import com.wireguard.android.model.TunnelManager;
 import com.wireguard.android.model.User;
 import com.wireguard.android.resource.StatusResource;
+import com.wireguard.android.util.TunnelStore;
 import com.wireguard.android.util.UserStore;
+import com.wireguard.config.BadConfigException;
 import com.wireguard.config.Config;
 
 import java.io.ByteArrayInputStream;
@@ -135,8 +141,7 @@ public class DataRepository {
                                 final String[] myDeviceName = deviceName.split(SEPARATOR);
                                 if (deviceNameItem.length > 1) {
                                     if (deviceNameItem[ANDROID_ID].equals(myDeviceName[ANDROID_ID])) {
-                                        UserStore.getInstance(context).setDeviceName(device.getName());
-                                        UserStore.getInstance(context).setDeviceID(device.getUuid());
+                                        UserStore.getInstance(context).setDevice(device.getName(), device.getUuid());
                                         hasDevice = true;
                                         getConfig(context);
                                         break;
@@ -161,8 +166,7 @@ public class DataRepository {
                                             .subscribeOn(Schedulers.newThread())
                                             .observeOn(AndroidSchedulers.mainThread())
                                             .subscribe(device -> {
-                                                UserStore.getInstance(context).setDeviceName(device.getName());
-                                                UserStore.getInstance(context).setDeviceID(device.getUuid());
+                                                UserStore.getInstance(context).setDevice(device.getName(), device.getUuid());
                                                 getConfig(context);
                                             }, throwable -> {
                                                 setMutableLiveData(StatusResource.error(throwable.getMessage()));
@@ -200,8 +204,7 @@ public class DataRepository {
                                                 .subscribeOn(Schedulers.newThread())
                                                 .observeOn(AndroidSchedulers.mainThread())
                                                 .subscribe(device -> {
-                                                    UserStore.getInstance(context).setDeviceName(device.getName());
-                                                    UserStore.getInstance(context).setDeviceID(device.getUuid());
+                                                    UserStore.getInstance(context).setDevice(device.getName(), device.getUuid());
                                                     getConfig(context);
                                                 }, throwable -> {
                                                     setMutableLiveData(StatusResource.error(throwable.getMessage()));
@@ -232,30 +235,27 @@ public class DataRepository {
                         final InputStream inputStream = response.body().byteStream();
                         final Scanner scanner = new Scanner(inputStream).useDelimiter(DELIMITER);
                         final String data = scanner.hasNext() ? scanner.next() : "";
-                        parseConfig(data);
+                        createTunnel(data, tunnelName);
                     }
                 });
             }
 
-            private void parseConfig(String data) {
+            private void createTunnel(String rawConfig, String tunnelName) {
                 try {
-                    final byte[] configText = data.getBytes();
-                    final Config config = Config.parse(new ByteArrayInputStream(configText));
-                    createTunnel(config, tunnelName);
+                    final byte[] configBytes = rawConfig.getBytes();
+                    final Config config = Config.parse(new ByteArrayInputStream(configBytes));
+                    Application.getTunnelManager().create(tunnelName, config).whenComplete((observableTunnel, throwable) -> {
+                        if (observableTunnel != null) {
+                            TunnelStore.getInstance(context).setTunnel(tunnelName, rawConfig);
+                            setMutableLiveData(StatusResource.success());
+                        } else {
+                            setMutableLiveData(StatusResource.error(throwable.getMessage()));
+                        }
+                    });
                 } catch (Exception e) {
                     postMutableLiveData(StatusResource.error(e.getMessage()));
                 }
             }
-
-            private void createTunnel(Config config, String tunnelName) {
-                Application.getTunnelManager().create(tunnelName, config).whenComplete((observableTunnel, throwable) -> {
-                    if (observableTunnel != null) {
-                        setMutableLiveData(StatusResource.success());
-                    } else {
-                        setMutableLiveData(StatusResource.error(throwable.getMessage()));
-                    }
-                });
-            }
         }.getMutableLiveData();
     }
 
@@ -298,4 +298,25 @@ public class DataRepository {
     public void clearDisposable() {
         compositeDisposable.clear();
     }
+
+
+    public ObservableTunnel getTunnel(Context context) {
+        //TODO implement config is null case
+        Config config = null;
+        try {
+            config = parseConfig(TunnelStore.getInstance(context).getConfig());
+        } catch (final IOException | BadConfigException e) {
+            return null;
+        }
+        final String name = TunnelStore.getInstance(context).getTunnelName();
+        final TunnelManager tunnelManager = new TunnelManager(new FileConfigStore(context));
+        final ObservableTunnel tunnel = new ObservableTunnel(tunnelManager, name, config, State.DOWN);
+        return tunnel;
+    }
+
+    private Config parseConfig(String data) throws IOException, BadConfigException {
+        final byte[] configText = data.getBytes();
+        final Config config = Config.parse(new ByteArrayInputStream(configText));
+        return config;
+    }
 }

ui/src/main/java/com/wireguard/android/util/TunnelStore.java

@@ -0,0 +1,44 @@
+package com.wireguard.android.util;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+public class TunnelStore {
+    private static TunnelStore instance;
+    private SharedPreferences sharedPreferences;
+
+    private static final String TUNNEL_SHARED_PREF = "com.wireguard.android.util.bubbleTunnelSharedPref";
+    private static final String TUNNEL_DATA_KEY = "com.wireguard.android.util.bubbleResponse";
+    private static final String CONFIG_DATA_KEY = "com.wireguard.android.util.bubbleConfigResponse";
+    public static final String TUNNEL_DEFAULT_VALUE = "";
+    public static final String CONFIG_DEFAULT_VALUE = "";
+
+    public static TunnelStore getInstance(Context context) {
+        if (instance == null) {
+            synchronized (UserStore.class) {
+                if (instance == null) {
+                    instance = new TunnelStore(context);
+                }
+            }
+        }
+
+        return instance;
+    }
+
+    private TunnelStore(Context context) {
+        sharedPreferences = context.getSharedPreferences(TUNNEL_SHARED_PREF, Context.MODE_PRIVATE);
+    }
+
+    public void setTunnel(String tunnelName , String config){
+        sharedPreferences.edit().putString(TUNNEL_DATA_KEY,tunnelName).apply();
+        sharedPreferences.edit().putString(CONFIG_DATA_KEY,config).apply();
+    }
+
+    public String getTunnelName(){
+        return sharedPreferences.getString(TUNNEL_DATA_KEY, TUNNEL_DEFAULT_VALUE);
+    }
+
+    public String getConfig(){
+        return sharedPreferences.getString(CONFIG_DATA_KEY,CONFIG_DEFAULT_VALUE);
+    }
+}

ui/src/main/java/com/wireguard/android/util/UserStore.java

@@ -39,18 +39,15 @@ public class UserStore {
         return sharedPreferences.getString(USER_DATA_KEY, USER_TOKEN_DEFAULT_VALUE);
     }
 
-    public void setDeviceName(String device){
-        sharedPreferences.edit().putString(DEVICE_DATA_KEY, device).apply();
+    public void setDevice(String deviceName, String deviceID){
+        sharedPreferences.edit().putString(DEVICE_DATA_KEY, deviceName).apply();
+        sharedPreferences.edit().putString(DEVICE_ID_KEY,deviceID).apply();
     }
 
     public String getDeviceName(){
         return sharedPreferences.getString(DEVICE_DATA_KEY, DEVICE_DEFAULT_VALUE);
     }
 
-    public void setDeviceID(String id){
-        sharedPreferences.edit().putString(DEVICE_ID_KEY,id).apply();
-    }
-
     public String getDeviceID(){
         return sharedPreferences.getString(DEVICE_ID_KEY,DEVICE_ID_DEFAULT_VALUE);
     }

ui/src/main/java/com/wireguard/android/viewmodel/MainViewModel.java

@@ -1,6 +1,8 @@
 package com.wireguard.android.viewmodel;
 
 import android.content.Context;
+
+import com.wireguard.android.model.ObservableTunnel;
 import com.wireguard.android.repository.DataRepository;
 import androidx.lifecycle.ViewModel;
 
@@ -8,4 +10,8 @@ public class MainViewModel extends ViewModel {
     public boolean isUserLoggedIn(Context context){
         return DataRepository.getRepositoryInstance().isUserLoggedIn(context);
     }
+
+    public ObservableTunnel getTunnel(Context context) {
+        return DataRepository.getRepositoryInstance().getTunnel(context);
+    }
 }