Merge branch 'first_run_improvements' into 'master'

update design and UX for provider setup

See merge request leap/bitmask_android!252

11 files changed, 951 insertions, 0 deletions

diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/BaseSetupFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/BaseSetupFragment.java
new file mode 100644
index 00000000..151361ba
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/BaseSetupFragment.java
@@ -0,0 +1,96 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+import androidx.viewpager2.widget.ViewPager2;
+
+import se.leap.bitmaskclient.providersetup.activities.SetupActivityCallback;
+
+public class BaseSetupFragment extends Fragment {
+
+    public static String EXTRA_POSITION = "EXTRA_POSITION";
+    private boolean callFragmentSelected = false;
+    SetupActivityCallback setupActivityCallback;
+
+    private final ViewPager2.OnPageChangeCallback viewPagerCallback = new ViewPager2.OnPageChangeCallback() {
+        @Override
+        public void onPageSelected(int position) {
+            super.onPageSelected(position);
+            if (position == BaseSetupFragment.this.position) {
+                handleCallFragmentSelected();
+            } else {
+                callFragmentSelected = false;
+            }
+        }
+    };
+    private int position;
+
+    public static Bundle initBundle(int pos) {
+        Bundle bundle = new Bundle();
+        bundle.putInt(EXTRA_POSITION, pos);
+        return bundle;
+    }
+
+    public BaseSetupFragment() {
+    }
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        this.position = getArguments().getInt(EXTRA_POSITION);
+    }
+
+    @Override
+    public void onAttach(@NonNull Context context) {
+        super.onAttach(context);
+        if (getActivity() instanceof SetupActivityCallback) {
+            setupActivityCallback = (SetupActivityCallback) getActivity();
+        } else {
+            throw new IllegalStateException("These setup fragments are closely coupled to SetupActivityCallback interface. Activities instantiating them are required to implement the interface");
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(@NonNull Bundle outState) {
+        outState.putInt(EXTRA_POSITION, position);
+        super.onSaveInstanceState(outState);
+    }
+
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        setupActivityCallback.registerOnPageChangeCallback(viewPagerCallback);
+        if (setupActivityCallback.getCurrentPosition() == position) {
+            handleCallFragmentSelected();
+        }
+    }
+
+    private void handleCallFragmentSelected() {
+        if (!callFragmentSelected) {
+            callFragmentSelected = true;
+            onFragmentSelected();
+        }
+    }
+
+    @Override
+    public void onDestroyView() {
+        setupActivityCallback.removeOnPageChangeCallback(viewPagerCallback);
+        callFragmentSelected = false;
+        super.onDestroyView();
+    }
+
+    @Override
+    public void onDetach() {
+        setupActivityCallback = null;
+        super.onDetach();
+    }
+
+    public void onFragmentSelected() {
+
+    }
+}
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/CircumventionSetupFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/CircumventionSetupFragment.java
new file mode 100644
index 00000000..11fa582b
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/CircumventionSetupFragment.java
@@ -0,0 +1,58 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import android.graphics.Typeface;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import se.leap.bitmaskclient.base.utils.PreferenceHelper;
+import se.leap.bitmaskclient.databinding.FCircumventionSetupBinding;
+
+public class CircumventionSetupFragment extends BaseSetupFragment {
+
+    public static CircumventionSetupFragment newInstance(int position) {
+        CircumventionSetupFragment fragment = new CircumventionSetupFragment();
+        fragment.setArguments(initBundle(position));
+        return fragment;
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        FCircumventionSetupBinding binding = FCircumventionSetupBinding.inflate(inflater, container, false);
+
+        binding.circumventionRadioGroup.setOnCheckedChangeListener((group, checkedId) -> {
+            if (binding.rbCircumvention.getId() == checkedId) {
+                PreferenceHelper.useBridges(true);
+                PreferenceHelper.useSnowflake(true);
+                binding.tvCircumventionDetailDescription.setVisibility(View.VISIBLE);
+                binding.rbCircumvention.setTypeface(Typeface.DEFAULT, Typeface.BOLD);
+                binding.rbPlainVpn.setTypeface(Typeface.DEFAULT, Typeface.NORMAL);
+                return;
+            }
+
+            PreferenceHelper.useBridges(false);
+            PreferenceHelper.useSnowflake(false);
+            binding.tvCircumventionDetailDescription.setVisibility(View.GONE);
+            binding.rbPlainVpn.setTypeface(Typeface.DEFAULT, Typeface.BOLD);
+            binding.rbCircumvention.setTypeface(Typeface.DEFAULT, Typeface.NORMAL);
+        });
+
+        int id = (PreferenceHelper.hasSnowflakePrefs() && PreferenceHelper.getUseSnowflake()) ?
+                binding.rbCircumvention.getId() :
+                binding.rbPlainVpn.getId();
+        binding.circumventionRadioGroup.check(id);
+        return binding.getRoot();
+    }
+
+    @Override
+    public void onFragmentSelected() {
+        super.onFragmentSelected();
+        setupActivityCallback.setCancelButtonHidden(false);
+        setupActivityCallback.setNavigationButtonHidden(false);
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/ConfigureProviderFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/ConfigureProviderFragment.java
new file mode 100644
index 00000000..3c36065e
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/ConfigureProviderFragment.java
@@ -0,0 +1,222 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import static android.app.Activity.RESULT_CANCELED;
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+import static androidx.recyclerview.widget.RecyclerView.SCROLL_STATE_IDLE;
+import static se.leap.bitmaskclient.R.string.description_configure_provider;
+import static se.leap.bitmaskclient.R.string.description_configure_provider_circumvention;
+import static se.leap.bitmaskclient.base.models.Constants.BROADCAST_RESULT_CODE;
+import static se.leap.bitmaskclient.base.models.Constants.BROADCAST_RESULT_KEY;
+import static se.leap.bitmaskclient.base.models.Constants.PROVIDER_KEY;
+import static se.leap.bitmaskclient.base.utils.PreferenceHelper.getUseSnowflake;
+import static se.leap.bitmaskclient.base.utils.ViewHelper.animateContainerVisibility;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.CORRECTLY_DOWNLOADED_VPN_CERTIFICATE;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.DOWNLOAD_VPN_CERTIFICATE;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.ERRORS;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.INCORRECTLY_DOWNLOADED_VPN_CERTIFICATE;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.MISSING_NETWORK_CONNECTION;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.PROVIDER_NOK;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.PROVIDER_OK;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.SET_UP_PROVIDER;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.TOR_EXCEPTION;
+import static se.leap.bitmaskclient.providersetup.ProviderAPI.TOR_TIMEOUT;
+import static se.leap.bitmaskclient.tor.TorStatusObservable.getBootstrapProgress;
+import static se.leap.bitmaskclient.tor.TorStatusObservable.getLastLogs;
+import static se.leap.bitmaskclient.tor.TorStatusObservable.getLastSnowflakeLog;
+import static se.leap.bitmaskclient.tor.TorStatusObservable.getLastTorLog;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+import java.util.List;
+import java.util.Observable;
+import java.util.Observer;
+
+import se.leap.bitmaskclient.base.models.Provider;
+import se.leap.bitmaskclient.databinding.FConfigureProviderBinding;
+import se.leap.bitmaskclient.eip.EipSetupListener;
+import se.leap.bitmaskclient.eip.EipSetupObserver;
+import se.leap.bitmaskclient.providersetup.ProviderAPICommand;
+import se.leap.bitmaskclient.providersetup.TorLogAdapter;
+import se.leap.bitmaskclient.providersetup.activities.CancelCallback;
+import se.leap.bitmaskclient.tor.TorStatusObservable;
+
+public class ConfigureProviderFragment extends BaseSetupFragment implements Observer, CancelCallback, EipSetupListener {
+
+    private static final String TAG = ConfigureProviderFragment.class.getSimpleName();
+
+    FConfigureProviderBinding binding;
+    private boolean isExpanded = false;
+    private boolean ignoreProviderAPIUpdates = false;
+    private TorLogAdapter torLogAdapter;
+
+
+    public static ConfigureProviderFragment newInstance(int position) {
+        ConfigureProviderFragment fragment = new ConfigureProviderFragment();
+        fragment.setArguments(initBundle(position));
+        return fragment;
+    }
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        torLogAdapter = new TorLogAdapter(getLastLogs());
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        binding = FConfigureProviderBinding.inflate(inflater, container, false);
+        binding.detailContainer.setVisibility(getUseSnowflake() ? VISIBLE : GONE);
+        binding.tvCircumventionDescription.setText(getUseSnowflake() ? description_configure_provider_circumvention : description_configure_provider);
+        binding.detailHeaderContainer.setOnClickListener(v -> {
+            binding.ivExpand.animate().setDuration(250).rotation(isExpanded ? -90 : 0);
+            showConnectionDetails();
+            animateContainerVisibility(binding.expandableDetailContainer, isExpanded);
+            isExpanded = !isExpanded;
+        });
+
+        binding.ivExpand.animate().setDuration(0).rotation(270);
+        LinearLayoutManager layoutManager = new LinearLayoutManager(this.getContext());
+        binding.connectionDetailLogs.setLayoutManager(layoutManager);
+        binding.connectionDetailLogs.setAdapter(torLogAdapter);
+        return binding.getRoot();
+    }
+
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        setupActivityCallback.registerCancelCallback(this);
+        TorStatusObservable.getInstance().addObserver(this);
+        EipSetupObserver.addListener(this);
+    }
+
+    @Override
+    public void onDestroyView() {
+        setupActivityCallback.removeCancelCallback(this);
+        TorStatusObservable.getInstance().deleteObserver(this);
+        EipSetupObserver.removeListener(this);
+        binding = null;
+        super.onDestroyView();
+    }
+
+    @Override
+    public void onFragmentSelected() {
+        super.onFragmentSelected();
+        ignoreProviderAPIUpdates = false;
+        binding.detailContainer.setVisibility(getUseSnowflake() ? VISIBLE : GONE);
+        binding.tvCircumventionDescription.setText(getUseSnowflake() ? description_configure_provider_circumvention : description_configure_provider);
+        setupActivityCallback.setNavigationButtonHidden(true);
+        setupActivityCallback.setCancelButtonHidden(false);
+        ProviderAPICommand.execute(getContext(), SET_UP_PROVIDER, setupActivityCallback.getSelectedProvider());
+    }
+
+    protected void showConnectionDetails() {
+
+        binding.connectionDetailLogs.addOnScrollListener(new RecyclerView.OnScrollListener() {
+            @Override
+            public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
+                super.onScrollStateChanged(recyclerView, newState);
+                if (newState != SCROLL_STATE_IDLE) {
+                    torLogAdapter.postponeUpdate = true;
+                } else if (newState == SCROLL_STATE_IDLE && getFirstVisibleItemPosion() == 0) {
+                    torLogAdapter.postponeUpdate = false;
+                }
+            }
+        });
+
+        binding.snowflakeState.setText(getLastSnowflakeLog());
+        binding.torState.setText(getLastTorLog());
+    }
+
+    private int getFirstVisibleItemPosion() {
+        return ((LinearLayoutManager) binding.connectionDetailLogs.getLayoutManager()).findFirstVisibleItemPosition();
+    }
+
+    @Override
+    public void update(Observable o, Object arg) {
+        if (o instanceof TorStatusObservable) {
+            Activity activity = getActivity();
+            if (activity == null || binding == null) {
+                return;
+            }
+            activity.runOnUiThread(() -> {
+                if (binding == null) {
+                    return;
+                }
+                if (TorStatusObservable.getStatus() != TorStatusObservable.TorStatus.OFF) {
+                    if (binding.connectionDetailContainer.getVisibility() == GONE) {
+                        showConnectionDetails();
+                    } else {
+                        setLogs(getLastTorLog(), getLastSnowflakeLog(), getLastLogs());
+                    }
+                }
+                binding.tvProgressStatus.setText(TorStatusObservable.getStringForCurrentStatus(activity));
+                binding.progressSpinner.update(getBootstrapProgress());
+            });
+        }
+    }
+
+    protected void setLogs(String torLog, String snowflakeLog, List<String> lastLogs) {
+        torLogAdapter.updateData(lastLogs);
+        binding.torState.setText(torLog);
+        binding.snowflakeState.setText(snowflakeLog);
+    }
+
+    @Override
+    public void onCanceled() {
+        ignoreProviderAPIUpdates = true;
+    }
+
+    @Override
+    public void handleEipEvent(Intent intent) {}
+
+    @Override
+    public void handleProviderApiEvent(Intent intent) {
+        int resultCode = intent.getIntExtra(BROADCAST_RESULT_CODE, RESULT_CANCELED);
+        Bundle resultData = intent.getParcelableExtra(BROADCAST_RESULT_KEY);
+        if (resultData == null) {
+            resultData = Bundle.EMPTY;
+        }
+        Provider provider = resultData.getParcelable(PROVIDER_KEY);
+        if (ignoreProviderAPIUpdates ||
+                provider == null ||
+                !setupActivityCallback.getSelectedProvider().getDomain().equals(provider.getDomain())) {
+            return;
+        }
+
+        switch (resultCode) {
+            case PROVIDER_OK:
+                if (provider.allowsAnonymous()) {
+                    ProviderAPICommand.execute(this.getContext(), DOWNLOAD_VPN_CERTIFICATE, provider);
+                } else {
+                    // TODO: implement error message that this client only supports anonymous usage
+                }
+                break;
+            case CORRECTLY_DOWNLOADED_VPN_CERTIFICATE:
+                setupActivityCallback.onProviderSelected(provider);
+                setupActivityCallback.onConfigurationSuccess();
+                break;
+            case PROVIDER_NOK:
+            case INCORRECTLY_DOWNLOADED_VPN_CERTIFICATE:
+            case MISSING_NETWORK_CONNECTION:
+            case TOR_EXCEPTION:
+            case TOR_TIMEOUT:
+                String reasonToFail = resultData.getString(ERRORS);
+                setupActivityCallback.onError(reasonToFail);
+                break;
+
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/EmptyPermissionSetupFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/EmptyPermissionSetupFragment.java
new file mode 100644
index 00000000..4226d804
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/EmptyPermissionSetupFragment.java
@@ -0,0 +1,117 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Toast;
+
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import se.leap.bitmaskclient.databinding.FEmptyPermissionSetupBinding;
+
+public class EmptyPermissionSetupFragment extends BaseSetupFragment {
+
+    public static String EXTRA_VPN_INTENT = "EXTRA_VPN_INTENT";
+    public static String EXTRA_NOTIFICATION_PERMISSON_ACTION = "EXTRA_NOTIFICATION_PERMISSON_ACTION";
+
+    private String notificationPermissionAction = null;
+    private Intent vpnPermissionIntent = null;
+
+    private final ActivityResultLauncher<String> requestNotificationPermissionLauncher =
+            registerForActivityResult(new ActivityResultContracts.RequestPermission(), isGranted -> {
+                if (isGranted) {
+                    if (setupActivityCallback != null) {
+                        setupActivityCallback.onConfigurationSuccess();
+                    }
+                } else {
+                    Toast.makeText(getContext(), "Permission request failed :(", Toast.LENGTH_LONG).show();
+                    setupActivityCallback.setNavigationButtonHidden(false);
+                    // TODO: implement sth. useful
+                }
+            });
+
+    private final ActivityResultLauncher<Intent> requestVpnPermissionLauncher =
+            registerForActivityResult(
+                    new ActivityResultContracts.StartActivityForResult(),
+                    result -> {
+                        if (result.getResultCode() == Activity.RESULT_OK) {
+                            if (setupActivityCallback != null) {
+                                setupActivityCallback.onConfigurationSuccess();
+                            }
+                        } else {
+                            Toast.makeText(getContext(), "Permission request failed :(", Toast.LENGTH_LONG).show();
+                            setupActivityCallback.setNavigationButtonHidden(false);
+                            // TODO: implement sth. useful
+                        }
+                    }
+            );
+
+
+    public static EmptyPermissionSetupFragment newInstance(int position, Intent vpnPermissionIntent) {
+        Bundle bundle = initBundle(position);
+        bundle.putParcelable(EXTRA_VPN_INTENT, vpnPermissionIntent);
+        EmptyPermissionSetupFragment fragment = new EmptyPermissionSetupFragment();
+        fragment.setArguments(bundle);
+        return fragment;
+    }
+
+    public static EmptyPermissionSetupFragment newInstance(int position, String notificationPermissionAction) {
+        Bundle bundle = initBundle(position);
+        bundle.putString(EXTRA_NOTIFICATION_PERMISSON_ACTION, notificationPermissionAction);
+        EmptyPermissionSetupFragment fragment = new EmptyPermissionSetupFragment();
+        fragment.setArguments(bundle);
+        return fragment;
+    }
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        this.vpnPermissionIntent = getArguments().getParcelable(EXTRA_VPN_INTENT);
+        this.notificationPermissionAction = getArguments().getString(EXTRA_NOTIFICATION_PERMISSON_ACTION);
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        FEmptyPermissionSetupBinding binding = FEmptyPermissionSetupBinding.inflate(inflater, container, false);
+        return binding.getRoot();
+    }
+
+    @Override
+    public void onSaveInstanceState(@NonNull Bundle outState) {
+        if (vpnPermissionIntent != null) {
+            outState.putParcelable(EXTRA_VPN_INTENT, vpnPermissionIntent);
+        }
+        if (notificationPermissionAction != null) {
+            outState.putString(EXTRA_NOTIFICATION_PERMISSON_ACTION, notificationPermissionAction);
+        }
+        super.onSaveInstanceState(outState);
+    }
+
+    @Override
+    public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
+        super.onViewStateRestored(savedInstanceState);
+    }
+
+    @Override
+    public void onFragmentSelected() {
+        super.onFragmentSelected();
+        if (notificationPermissionAction != null) {
+            requestNotificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS);
+        } else if (vpnPermissionIntent != null) {
+            requestVpnPermissionLauncher.launch(vpnPermissionIntent);
+        }
+
+        setupActivityCallback.setNavigationButtonHidden(true);
+        setupActivityCallback.setCancelButtonHidden(true);
+    }
+
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/NotificationSetupFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/NotificationSetupFragment.java
new file mode 100644
index 00000000..a9589336
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/NotificationSetupFragment.java
@@ -0,0 +1,35 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import se.leap.bitmaskclient.databinding.FNotificationSetupBinding;
+
+public class NotificationSetupFragment extends BaseSetupFragment {
+
+    public static NotificationSetupFragment newInstance(int position) {
+        NotificationSetupFragment fragment = new NotificationSetupFragment();
+        fragment.setArguments(initBundle(position));
+        return fragment;
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        FNotificationSetupBinding binding = FNotificationSetupBinding.inflate(inflater, container, false);
+        return binding.getRoot();
+    }
+
+    @Override
+    public void onFragmentSelected() {
+        super.onFragmentSelected();
+        setupActivityCallback.setNavigationButtonHidden(false);
+        setupActivityCallback.setCancelButtonHidden(true);
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/ProviderSelectionFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/ProviderSelectionFragment.java
new file mode 100644
index 00000000..e8f37e43
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/ProviderSelectionFragment.java
@@ -0,0 +1,153 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import static se.leap.bitmaskclient.providersetup.fragments.viewmodel.ProviderSelectionViewModel.ADD_PROVIDER;
+
+import android.content.Context;
+import android.graphics.Typeface;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.RadioButton;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.ViewModelProvider;
+
+import java.util.ArrayList;
+
+import se.leap.bitmaskclient.R;
+import se.leap.bitmaskclient.base.models.Provider;
+import se.leap.bitmaskclient.base.models.ProviderObservable;
+import se.leap.bitmaskclient.base.utils.ViewHelper;
+import se.leap.bitmaskclient.databinding.FProviderSelectionBinding;
+import se.leap.bitmaskclient.providersetup.activities.CancelCallback;
+import se.leap.bitmaskclient.providersetup.fragments.viewmodel.ProviderSelectionViewModel;
+import se.leap.bitmaskclient.providersetup.fragments.viewmodel.ProviderSelectionViewModelFactory;
+
+public class ProviderSelectionFragment extends BaseSetupFragment implements CancelCallback {
+
+    private ProviderSelectionViewModel viewModel;
+    private ArrayList<RadioButton> radioButtons;
+
+    private FProviderSelectionBinding binding;
+
+    public static ProviderSelectionFragment newInstance(int position) {
+        ProviderSelectionFragment fragment = new ProviderSelectionFragment();
+        fragment.setArguments(initBundle(position));
+        return fragment;
+    }
+
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        viewModel = new ViewModelProvider(this,
+                new ProviderSelectionViewModelFactory(
+                        getContext().getApplicationContext().getAssets(),
+                        getContext().getExternalFilesDir(null))).
+                get(ProviderSelectionViewModel.class);
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        binding = FProviderSelectionBinding.inflate(inflater, container, false);
+
+        radioButtons = new ArrayList<>();
+        for (int i = 0; i < viewModel.size(); i++) {
+            RadioButton radioButton = new RadioButton(binding.getRoot().getContext());
+            radioButton.setText(viewModel.getProviderName(i));
+            radioButton.setId(i);
+            binding.providerRadioGroup.addView(radioButton);
+            radioButtons.add(radioButton);
+        }
+        RadioButton radioButton = new RadioButton(binding.getRoot().getContext());
+        radioButton.setText(getText(R.string.add_provider));
+        radioButton.setId(ADD_PROVIDER);
+        binding.providerRadioGroup.addView(radioButton);
+        radioButtons.add(radioButton);
+
+        binding.editCustomProvider.setVisibility(viewModel.getEditProviderVisibility());
+        return binding.getRoot();
+    }
+
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        setupActivityCallback.registerCancelCallback(this);
+    }
+
+    @Override
+    public void onFragmentSelected() {
+        super.onFragmentSelected();
+        setupActivityCallback.setCancelButtonHidden(true);
+        setupActivityCallback.setNavigationButtonHidden(false);
+        binding.providerRadioGroup.setOnCheckedChangeListener((group, checkedId) -> {
+            viewModel.setSelected(checkedId);
+            for (RadioButton rb : radioButtons) {
+                rb.setTypeface(Typeface.DEFAULT, rb.getId() == checkedId ? Typeface.BOLD : Typeface.NORMAL);
+            }
+            binding.providerDescription.setText(viewModel.getProviderDescription(getContext()));
+            binding.editCustomProvider.setVisibility(viewModel.getEditProviderVisibility());
+            setupActivityCallback.onSetupStepValidationChanged(viewModel.isValidConfig());
+            if (checkedId != ADD_PROVIDER) {
+                setupActivityCallback.onProviderSelected(viewModel.getProvider(checkedId));
+            } else if (viewModel.isValidConfig()) {
+                setupActivityCallback.onProviderSelected(new Provider(binding.editCustomProvider.getText().toString()));
+            }
+        });
+
+        binding.editCustomProvider.addTextChangedListener(new TextWatcher() {
+            @Override
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+            @Override
+            public void onTextChanged(CharSequence s, int start, int before, int count) {
+                viewModel.setCustomUrl(s.toString());
+                if (viewModel.isCustomProviderSelected()) {
+                    setupActivityCallback.onSetupStepValidationChanged(viewModel.isValidConfig());
+                    if (viewModel.isValidConfig()) {
+                        setupActivityCallback.onProviderSelected(new Provider(s.toString()));
+                    }
+                }
+            }
+
+            @Override
+            public void afterTextChanged(Editable s) {}
+        });
+
+        binding.editCustomProvider.setOnFocusChangeListener((v, hasFocus) -> {
+            if (!hasFocus) {
+                ViewHelper.hideKeyboardFrom(getContext(), v);
+            }
+        });
+        binding.providerRadioGroup.check(viewModel.getSelected());
+    }
+
+    @Override
+    public void onDestroyView() {
+        setupActivityCallback.removeCancelCallback(this);
+        binding = null;
+        radioButtons = null;
+        super.onDestroyView();
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        setupActivityCallback.onSetupStepValidationChanged(viewModel.isValidConfig());
+    }
+
+    @Override
+    public void onCanceled() {
+        binding.providerRadioGroup.check(0);
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/SetupFragmentFactory.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/SetupFragmentFactory.java
new file mode 100644
index 00000000..eaf3fbfa
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/SetupFragmentFactory.java
@@ -0,0 +1,65 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import android.Manifest;
+import android.content.Intent;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+
+import java.util.ArrayList;
+
+public class SetupFragmentFactory {
+    public static final int PROVIDER_SELECTION_FRAGMENT = 0;
+    public static final int CIRCUMVENTION_SETUP_FRAGMENT = 1;
+    public static final int CONFIGURE_PROVIDER_FRAGMENT = 2;
+    public static final int VPN_PERMISSON_EDUCATIONAL_FRAGMENT = 3;
+    public static final int VPN_PERMISSON_FRAGMENT = 4;
+    public static final int NOTIFICATION_PERMISSON_EDUCATIONAL_FRAGMENT = 5;
+    public static final int NOTIFICATION_PERMISSON_FRAGMENT = 6;
+
+    public static final int SUCCESS_FRAGMENT = 7;
+
+    private final Intent vpnPermissionRequest;
+
+    private final ArrayList<Integer> fragmentTypes;
+
+    public SetupFragmentFactory(@NonNull ArrayList<Integer> fragmentTypes, Intent vpnPermissionRequest) {
+        this.fragmentTypes = fragmentTypes;
+        this.vpnPermissionRequest = vpnPermissionRequest;
+    }
+
+    public Fragment createFragment(int position) {
+        if (position < 0 || position >= fragmentTypes.size()) {
+            throw new IllegalStateException("Illegal fragment position");
+        }
+        int type = fragmentTypes.get(position);
+        switch (type) {
+            case PROVIDER_SELECTION_FRAGMENT:
+                return ProviderSelectionFragment.newInstance(position);
+            case CIRCUMVENTION_SETUP_FRAGMENT:
+                return CircumventionSetupFragment.newInstance(position);
+            case CONFIGURE_PROVIDER_FRAGMENT:
+                return ConfigureProviderFragment.newInstance(position);
+            case NOTIFICATION_PERMISSON_EDUCATIONAL_FRAGMENT:
+                return NotificationSetupFragment.newInstance(position);
+            case NOTIFICATION_PERMISSON_FRAGMENT:
+                return EmptyPermissionSetupFragment.newInstance(position, Manifest.permission.POST_NOTIFICATIONS);
+            case VPN_PERMISSON_EDUCATIONAL_FRAGMENT:
+                return VpnPermissionSetupFragment.newInstance(position);
+            case VPN_PERMISSON_FRAGMENT:
+                return EmptyPermissionSetupFragment.newInstance(position, vpnPermissionRequest);
+            case SUCCESS_FRAGMENT:
+                return SetupSuccessFragment.newInstance(position);
+            default:
+                throw new IllegalArgumentException("Unexpected fragment type: " + type);
+        }
+    }
+
+    public int getItemCount() {
+        return fragmentTypes.size();
+    }
+
+    public int getPos(int fragmentType) {
+        return fragmentTypes.indexOf(fragmentType);
+    }
+}
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/SetupSuccessFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/SetupSuccessFragment.java
new file mode 100644
index 00000000..daf4ed6c
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/SetupSuccessFragment.java
@@ -0,0 +1,44 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import se.leap.bitmaskclient.R;
+import se.leap.bitmaskclient.databinding.FSetupSuccessBinding;
+
+public class SetupSuccessFragment extends BaseSetupFragment {
+
+    public static SetupSuccessFragment newInstance(int position) {
+        SetupSuccessFragment fragment = new SetupSuccessFragment();
+        fragment.setArguments(initBundle(position));
+        return fragment;
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        FSetupSuccessBinding binding = FSetupSuccessBinding.inflate(inflater, container, false);
+
+        binding.mainButton.setOnClickListener(v -> {
+            setupActivityCallback.onSetupFinished();
+            binding.mainButton.setEnabled(false);
+            binding.mainButton.setCustomDrawable(R.drawable.button_setup_circle_progress);
+        });
+        binding.mainButton.setCustomDrawable(R.drawable.button_setup_circle_start);
+
+        return binding.getRoot();
+    }
+
+    @Override
+    public void onFragmentSelected() {
+        super.onFragmentSelected();
+        setupActivityCallback.setNavigationButtonHidden(true);
+        setupActivityCallback.setCancelButtonHidden(true);
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/VpnPermissionSetupFragment.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/VpnPermissionSetupFragment.java
new file mode 100644
index 00000000..188ba9ac
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/VpnPermissionSetupFragment.java
@@ -0,0 +1,36 @@
+package se.leap.bitmaskclient.providersetup.fragments;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import se.leap.bitmaskclient.databinding.FVpnPermissionSetupBinding;
+
+public class VpnPermissionSetupFragment extends BaseSetupFragment {
+
+    public static VpnPermissionSetupFragment newInstance(int position) {
+        VpnPermissionSetupFragment fragment = new VpnPermissionSetupFragment();
+        fragment.setArguments(initBundle(position));
+        return fragment;
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        FVpnPermissionSetupBinding binding = FVpnPermissionSetupBinding.inflate(inflater, container, false);
+        return binding.getRoot();
+    }
+
+    @Override
+    public void onFragmentSelected() {
+        super.onFragmentSelected();
+        setupActivityCallback.setNavigationButtonHidden(false);
+        setupActivityCallback.setCancelButtonHidden(true);
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/viewmodel/ProviderSelectionViewModel.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/viewmodel/ProviderSelectionViewModel.java
new file mode 100644
index 00000000..aa2fe7cb
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/viewmodel/ProviderSelectionViewModel.java
@@ -0,0 +1,97 @@
+package se.leap.bitmaskclient.providersetup.fragments.viewmodel;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.util.Patterns;
+import android.view.View;
+import android.webkit.URLUtil;
+
+import androidx.lifecycle.ViewModel;
+
+import java.io.File;
+import java.util.List;
+
+import se.leap.bitmaskclient.R;
+import se.leap.bitmaskclient.base.models.Provider;
+import se.leap.bitmaskclient.providersetup.ProviderManager;
+
+public class ProviderSelectionViewModel extends ViewModel {
+    private final ProviderManager providerManager;
+    public static int ADD_PROVIDER = 100100100;
+
+    private int selected = 0;
+    private String customUrl;
+
+    public ProviderSelectionViewModel(AssetManager assetManager, File externalFilesDir) {
+        providerManager = ProviderManager.getInstance(assetManager, externalFilesDir);
+        providerManager.setAddDummyEntry(false);
+    }
+
+    public int size() {
+        return providerManager.size();
+    }
+
+    public List<Provider> providers() {
+        return providerManager.providers();
+    }
+
+   public Provider getProvider(int pos) {
+        return providerManager.get(pos);
+   }
+
+    public void setSelected(int checkedId) {
+        selected = checkedId;
+    }
+
+    public int getSelected() {
+        return selected;
+    }
+
+    public boolean isValidConfig() {
+        if (selected == ADD_PROVIDER) {
+            return URLUtil.isValidUrl(customUrl) && Patterns.WEB_URL.matcher(customUrl).matches();
+        }
+        return true;
+    }
+
+    public boolean isCustomProviderSelected() {
+        return selected == ADD_PROVIDER;
+    }
+
+    public CharSequence getProviderDescription(Context context) {
+        if (selected == ADD_PROVIDER) {
+            return context.getText(R.string.add_provider_description);
+        }
+        Provider provider = getProvider(selected);
+        if ("riseup.net".equals(provider.getDomain())) {
+            return context.getText(R.string.provider_description_riseup);
+        }
+        if ("calyx.net".equals(provider.getDomain())) {
+            return context.getText(R.string.provider_description_calyx);
+        }
+        return provider.getDescription();
+    }
+
+    public int getEditProviderVisibility() {
+        if (selected == ADD_PROVIDER) {
+            return View.VISIBLE;
+        }
+        return View.GONE;
+    }
+
+    public void setCustomUrl(String url) {
+        customUrl = url;
+    }
+
+
+    public String getProviderName(int pos) {
+        String domain = getProvider(pos).getDomain();
+        if ("riseup.net".equals(domain)) {
+            return "Riseup";
+        }
+        if ("calyx.net".equals(domain)) {
+            return "The Calyx Institute";
+        }
+        return domain;
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/viewmodel/ProviderSelectionViewModelFactory.java b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/viewmodel/ProviderSelectionViewModelFactory.java
new file mode 100644
index 00000000..a21e4924
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/providersetup/fragments/viewmodel/ProviderSelectionViewModelFactory.java
@@ -0,0 +1,28 @@
+package se.leap.bitmaskclient.providersetup.fragments.viewmodel;
+
+import android.content.res.AssetManager;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.ViewModel;
+import androidx.lifecycle.ViewModelProvider;
+
+import java.io.File;
+
+public class ProviderSelectionViewModelFactory implements ViewModelProvider.Factory {
+    private final AssetManager assetManager;
+    private final File externalFilesDir;
+
+    public ProviderSelectionViewModelFactory(AssetManager assetManager, File externalFilesDir) {
+        this.assetManager = assetManager;
+        this.externalFilesDir = externalFilesDir;
+    }
+
+    @NonNull
+    @Override
+    public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
+        if (modelClass.isAssignableFrom(ProviderSelectionViewModel.class)) {
+            return (T) new ProviderSelectionViewModel(assetManager, externalFilesDir);
+        }
+        throw new IllegalArgumentException("Unknown ViewModel class");
+    }
+}
\ No newline at end of file