Creating a user session fragment.

I've separated the user session management to it, and encapsulated
ProviderAPICommand into its own class.

Putting the fragment statically in dashboard.xml isn't working, Android
complains about it being duplicated, so I'm going to add it dynamically.

4 files changed, 524 insertions, 0 deletions

diff --git a/app/src/main/java/se/leap/bitmaskclient/userstatus/SessionDialog.java b/app/src/main/java/se/leap/bitmaskclient/userstatus/SessionDialog.java
new file mode 100644
index 00000000..f51a6779
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/userstatus/SessionDialog.java
@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2013 LEAP Encryption Access Project and contributers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package se.leap.bitmaskclient.userstatus;
+
+import android.app.*;
+import android.content.*;
+import android.os.*;
+import android.view.*;
+import android.widget.*;
+
+import butterknife.*;
+import se.leap.bitmaskclient.EipFragment;
+import se.leap.bitmaskclient.Provider;
+import se.leap.bitmaskclient.R;
+
+/**
+ * Implements the log in dialog, currently without progress dialog.
+ * <p/>
+ * It returns to the previous fragment when finished, and sends username and password to the authenticate method.
+ * <p/>
+ * It also notifies the user if the password is not valid.
+ *
+ * @author parmegv
+ */
+public class SessionDialog extends DialogFragment {
+
+
+    final public static String TAG = SessionDialog.class.getSimpleName();
+
+    final public static String USERNAME = "username";
+    final public static String PASSWORD = "password";
+
+    public static enum ERRORS {
+        USERNAME_MISSING,
+        PASSWORD_INVALID_LENGTH,
+        RISEUP_WARNING
+    }
+
+    @InjectView(R.id.user_message)
+    TextView user_message;
+    @InjectView(R.id.username_entered)
+    EditText username_field;
+    @InjectView(R.id.password_entered)
+    EditText password_field;
+
+    private static boolean is_eip_pending = false;
+
+    public static SessionDialog getInstance(Provider provider, Bundle arguments) {
+        SessionDialog dialog = new SessionDialog();
+        if (provider.getName().equalsIgnoreCase("riseup")) {
+            arguments =
+                    arguments == Bundle.EMPTY ?
+                            new Bundle() : arguments;
+            arguments.putBoolean(SessionDialog.ERRORS.RISEUP_WARNING.toString(), true);
+        }
+        if (arguments != null && !arguments.isEmpty()) {
+            dialog.setArguments(arguments);
+        }
+        return dialog;
+    }
+
+    public AlertDialog onCreateDialog(Bundle savedInstanceState) {
+
+        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        LayoutInflater inflater = getActivity().getLayoutInflater();
+        View view = inflater.inflate(R.layout.session_dialog, null);
+        ButterKnife.inject(this, view);
+
+        Bundle arguments = getArguments();
+        if (arguments != Bundle.EMPTY) {
+            setUp(arguments);
+        }
+
+        builder.setView(view)
+                .setPositiveButton(R.string.login_button, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int id) {
+                        String username = getEnteredUsername();
+                        String password = getEnteredPassword();
+                        dialog.dismiss();
+                        interface_with_Dashboard.logIn(username, password);
+                    }
+                })
+                .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int id) {
+                        dialog.cancel();
+                        interface_with_Dashboard.cancelLoginOrSignup();
+                    }
+                })
+                .setNeutralButton(R.string.signup_button, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int id) {
+                        String username = getEnteredUsername();
+                        String password = getEnteredPassword();
+                        dialog.dismiss();
+                        interface_with_Dashboard.signUp(username, password);
+                    }
+                });
+
+        return builder.create();
+    }
+
+    private void setUp(Bundle arguments) {
+        is_eip_pending = arguments.getBoolean(EipFragment.IS_PENDING, false);
+        if (arguments.containsKey(ERRORS.PASSWORD_INVALID_LENGTH.toString()))
+            password_field.setError(getString(R.string.error_not_valid_password_user_message));
+        else if (arguments.containsKey(ERRORS.RISEUP_WARNING.toString())) {
+            user_message.setVisibility(TextView.VISIBLE);
+            user_message.setText(R.string.login_riseup_warning);
+        }
+        if (arguments.containsKey(USERNAME)) {
+            String username = arguments.getString(USERNAME);
+            username_field.setText(username);
+        }
+        if (arguments.containsKey(ERRORS.USERNAME_MISSING.toString())) {
+            username_field.setError(getString(R.string.username_ask));
+        }
+        if (arguments.containsKey(getString(R.string.user_message))) {
+            user_message.setText(arguments.getString(getString(R.string.user_message)));
+            user_message.setVisibility(View.VISIBLE);
+        } else if (user_message.getVisibility() != TextView.VISIBLE)
+            user_message.setVisibility(View.GONE);
+
+        if (!username_field.getText().toString().isEmpty() && password_field.isFocusable())
+            password_field.requestFocus();
+
+    }
+
+    private String getEnteredUsername() {
+        return username_field.getText().toString();
+    }
+
+    private String getEnteredPassword() {
+        return password_field.getText().toString();
+    }
+
+
+    /**
+     * Interface used to communicate SessionDialog with Dashboard.
+     *
+     * @author parmegv
+     */
+    public interface SessionDialogInterface {
+        public void logIn(String username, String password);
+
+        public void signUp(String username, String password);
+
+        public void cancelLoginOrSignup();
+    }
+
+    SessionDialogInterface interface_with_Dashboard;
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+        try {
+            interface_with_Dashboard = (SessionDialogInterface) activity;
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement LogInDialogListener");
+        }
+    }
+
+    @Override
+    public void onCancel(DialogInterface dialog) {
+        super.onCancel(dialog);
+        if (is_eip_pending)
+            interface_with_Dashboard.cancelLoginOrSignup();
+    }
+}
diff --git a/app/src/main/java/se/leap/bitmaskclient/userstatus/User.java b/app/src/main/java/se/leap/bitmaskclient/userstatus/User.java
new file mode 100644
index 00000000..716e2ed6
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/userstatus/User.java
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2013 LEAP Encryption Access Project and contributers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package se.leap.bitmaskclient.userstatus;
+
+import se.leap.bitmaskclient.LeapSRPSession;
+
+public class User {
+    private static String user_name = "";
+    private static User user;
+
+    public static User init() {
+        if (user == null) {
+            user = new User();
+        }
+        return user;
+    }
+
+    public static void setUserName(String user_name) {
+        User.user_name = user_name;
+    }
+
+    private User() {  }
+
+    public static String userName() {
+        return user_name;
+    }
+
+    public static boolean loggedIn() {
+        return LeapSRPSession.loggedIn();
+    }
+}
diff --git a/app/src/main/java/se/leap/bitmaskclient/userstatus/UserSessionFragment.java b/app/src/main/java/se/leap/bitmaskclient/userstatus/UserSessionFragment.java
new file mode 100644
index 00000000..02b9fbeb
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/userstatus/UserSessionFragment.java
@@ -0,0 +1,178 @@
+package se.leap.bitmaskclient.userstatus;
+
+import android.app.*;
+import android.os.*;
+import android.view.*;
+import android.widget.*;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+import butterknife.*;
+import se.leap.bitmaskclient.*;
+import se.leap.bitmaskclient.eip.EipStatus;
+
+public class UserSessionFragment extends Fragment implements Observer, SessionDialog.SessionDialogInterface {
+
+    private static View view;
+
+    public static String TAG = UserSessionFragment.class.getSimpleName();
+    private static Dashboard dashboard;
+    private ProviderAPIResultReceiver providerAPI_result_receiver;
+
+    @InjectView(R.id.user_session_status)
+    TextView user_session_status_text_view;
+    @InjectView(R.id.user_session_status_progress)
+    ProgressBar user_session_status_progress_bar;
+    @InjectView(R.id.user_session_button)
+    Button main_button;
+
+    private UserSessionStatus user_session_status;
+    private boolean allows_registration = false;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        user_session_status = UserSessionStatus.getInstance(getResources());
+        user_session_status.addObserver(this);
+
+        handleNewUserSessionStatus(user_session_status);
+    }
+
+    @Override
+    public void onSaveInstanceState(@NotNull Bundle outState) {
+        if (user_session_status_text_view != null && user_session_status_text_view.getVisibility() == TextView.VISIBLE)
+            outState.putSerializable(UserSessionStatus.TAG, user_session_status.sessionStatus());
+
+        super.onSaveInstanceState(outState);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                             Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_user_session, container, false);
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        Fragment fragment = (getFragmentManager().findFragmentById(R.id.user_session_fragment));
+        FragmentTransaction ft = getActivity().getFragmentManager().beginTransaction();
+        ft.remove(fragment);
+        ft.commit();
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+        dashboard = (Dashboard) activity;
+
+        providerAPI_result_receiver = new ProviderAPIResultReceiver(new Handler());
+        providerAPI_result_receiver.setReceiver(dashboard);
+    }
+
+    public void restoreSessionStatus(Bundle savedInstanceState) {
+        if (savedInstanceState != null)
+            if (savedInstanceState.containsKey(UserSessionStatus.TAG)) {
+                UserSessionStatus.SessionStatus status = (UserSessionStatus.SessionStatus) savedInstanceState.getSerializable(UserSessionStatus.TAG);
+                user_session_status.updateStatus(status, getResources());
+            }
+    }
+
+    @OnClick(R.id.user_session_button)
+    public void handleMainButton() {
+        if(user_session_status.isLoggedIn())
+            logOut();
+        else if(user_session_status.isLoggedOut())
+            dashboard.sessionDialog(Bundle.EMPTY);
+        else if(user_session_status.inProgress())
+            cancelLoginOrSignup();
+    }
+
+    @Override
+    public void update(Observable observable, Object data) {
+        if (observable instanceof UserSessionStatus) {
+            UserSessionStatus status = (UserSessionStatus) observable;
+            handleNewUserSessionStatus(status);
+        }
+    }
+
+    private void handleNewUserSessionStatus(UserSessionStatus status) {
+        user_session_status = status;
+        if (allows_registration) {
+            if (user_session_status.inProgress())
+                showUserSessionProgressBar();
+            else
+                hideUserSessionProgressBar();
+            changeSessionStatusMessage();
+            updateButton();
+        }
+    }
+
+    private void showUserSessionProgressBar() {
+        dashboard.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                user_session_status_progress_bar.setVisibility(ProgressBar.VISIBLE);
+            }
+        });
+    }
+
+    private void hideUserSessionProgressBar() {
+        dashboard.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                user_session_status_progress_bar.setVisibility(ProgressBar.GONE);
+            }
+        });
+    }
+
+    private void changeSessionStatusMessage() {
+        final String message = user_session_status.toString();
+        dashboard.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                user_session_status_text_view.setText(message);
+            }
+        });
+    }
+
+    private void updateButton() {
+        if(User.loggedIn())
+            main_button.setText(getString(R.string.logout_button));
+        else if(allows_registration)
+            main_button.setText(getString(R.string.login_button));
+    }
+
+
+    @Override
+    public void signUp(String username, String password) {
+        User.setUserName(username);
+        Bundle parameters = bundlePassword(password);
+        ProviderAPICommand.execute(parameters, ProviderAPI.SIGN_UP, providerAPI_result_receiver);
+    }
+
+    @Override
+    public void logIn(String username, String password) {
+        User.setUserName(username);
+        Bundle parameters = bundlePassword(password);
+        ProviderAPICommand.execute(parameters, ProviderAPI.LOG_IN, providerAPI_result_receiver);
+    }
+
+    public void logOut() {
+        ProviderAPICommand.execute(Bundle.EMPTY, ProviderAPI.LOG_OUT, providerAPI_result_receiver);
+    }
+
+    public void cancelLoginOrSignup() {
+        EipStatus.getInstance().setConnectedOrDisconnected();
+    }
+
+    private Bundle bundlePassword(String password) {
+        Bundle parameters = new Bundle();
+        if (!password.isEmpty())
+            parameters.putString(SessionDialog.PASSWORD, password);
+        return parameters;
+    }
+}
diff --git a/app/src/main/java/se/leap/bitmaskclient/userstatus/UserSessionStatus.java b/app/src/main/java/se/leap/bitmaskclient/userstatus/UserSessionStatus.java
new file mode 100644
index 00000000..dec0e719
--- /dev/null
+++ b/app/src/main/java/se/leap/bitmaskclient/userstatus/UserSessionStatus.java
@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) 2013 LEAP Encryption Access Project and contributers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package se.leap.bitmaskclient.userstatus;
+
+import android.content.res.*;
+
+import java.util.*;
+
+import se.leap.bitmaskclient.R;
+
+public class UserSessionStatus extends Observable {
+    public static String TAG = UserSessionStatus.class.getSimpleName();
+    private static UserSessionStatus current_status;
+    private static Resources resources;
+
+    public enum SessionStatus {
+        LOGGED_IN,
+        LOGGED_OUT,
+        NOT_LOGGED_IN,
+        DIDNT_LOG_OUT,
+        LOGGING_IN,
+        LOGGING_OUT,
+        SIGNING_UP;
+
+        @Override
+        public String toString() {
+            int id = 0;
+            if(this == SessionStatus.LOGGED_IN)
+                id = R.string.logged_in_user_status;
+            else if(this == SessionStatus.LOGGED_OUT)
+                id = R.string.logged_out_user_status;
+            else if(this == SessionStatus.NOT_LOGGED_IN)
+                id = R.string.not_logged_in_user_status;
+            else if(this == SessionStatus.DIDNT_LOG_OUT)
+                id = R.string.didnt_log_out_user_status;
+            else if(this == SessionStatus.LOGGING_IN)
+                id = R.string.logging_in_user_status;
+            else if(this == SessionStatus.LOGGING_OUT)
+                id = R.string.logging_out_user_status;
+            else if(this == SessionStatus.SIGNING_UP)
+                id = R.string.signingup_message;
+
+            return resources.getString(id);
+        }
+    }
+
+    private static SessionStatus session_status = SessionStatus.NOT_LOGGED_IN;
+
+    public static UserSessionStatus getInstance(Resources resources) {
+        if (current_status == null) {
+            current_status = new UserSessionStatus(resources);
+        }
+        return current_status;
+    }
+
+    private UserSessionStatus(Resources resources) {
+        UserSessionStatus.resources = resources;
+    }
+
+    private void sessionStatus(SessionStatus session_status) {
+        this.session_status = session_status;
+    }
+
+    public SessionStatus sessionStatus() {
+        return session_status;
+    }
+
+    public boolean inProgress() {
+        return session_status == SessionStatus.LOGGING_IN
+                || session_status == SessionStatus.LOGGING_OUT;
+    }
+
+    public boolean isLoggedIn() {
+        return session_status == SessionStatus.LOGGING_IN;
+    }
+
+    public boolean isLoggedOut() {
+        return session_status == SessionStatus.LOGGED_OUT;
+    }
+
+    public static void updateStatus(SessionStatus session_status, Resources resources) {
+        current_status = getInstance(resources);
+        current_status.sessionStatus(session_status);
+        current_status.setChanged();
+        current_status.notifyObservers();
+    }
+
+    @Override
+    public String toString() {
+        String user_session_status = User.userName();
+
+        String default_username = resources.getString(R.string.default_user, "");
+        if(user_session_status.isEmpty() && !default_username.equalsIgnoreCase("null")) user_session_status = default_username;
+        user_session_status += " " + session_status.toString();
+
+        user_session_status = user_session_status.trim();
+        if(User.userName().isEmpty())
+            user_session_status = capitalize(user_session_status);
+        return user_session_status;
+    }
+
+    private String capitalize(String to_be_capitalized) {
+        return to_be_capitalized.substring(0,1).toUpperCase() + to_be_capitalized.substring(1);
+    }
+}