Sharing multiple connections

WordPress/build.gradle

@@ -2,7 +2,6 @@ buildscript {
     repositories {
         jcenter()
         maven { url 'https://maven.fabric.io/public' }
-
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:2.1.2'

WordPress/src/main/java/org/wordpress/android/models/PublicizeConnection.java

@@ -3,6 +3,8 @@
 import android.support.annotation.NonNull;
 import android.text.TextUtils;
 
+import org.json.JSONArray;
+import org.json.JSONException;
 import org.json.JSONObject;
 import org.wordpress.android.util.JSONUtils;
 import org.wordpress.android.util.StringUtils;
@@ -39,6 +41,7 @@ public String toString() {
     private String mExternalName;
     private String mExternalDisplayName;
     private String mExternalProfilePictureUrl;
+    private int[] mSites;
 
     // `status` can be `ok` or `broken` -- `broken` means the connection needs to be re-established via the `refresh_URL`
     private String mStatus;
@@ -136,6 +139,24 @@ public boolean isSameAs(PublicizeConnection other) {
                 && other.getService().equals(this.getService());
     }
 
+    public void setSites(int[] sites) {
+        mSites = sites;
+    }
+
+    public int[] getSites() {
+        return mSites;
+    }
+
+    public boolean isInSite(int siteId) {
+        for (int i = 0; i < mSites.length; i++) {
+            if (siteId == mSites[i]) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /*
      * passed JSON is a single connection from the response to sites/%d/publicize-connections
        {"ID":12783250,
@@ -185,6 +206,23 @@ public static PublicizeConnection fromJson(JSONObject json) {
         connection.mStatus = json.optString("status");
         connection.mRefreshUrl = json.optString("refresh_URL");
 
+        try {
+            JSONArray jsonSitesArray = json.getJSONArray("sites");
+            connection.mSites = getSitesArrayFromJson(jsonSitesArray);
+        } catch (JSONException e) {
+            connection.mSites = new int[0];
+            e.printStackTrace();
+        }
+
         return connection;
     }
+
+    private static int[] getSitesArrayFromJson(JSONArray jsonArray) throws JSONException {
+        int[] sitesArray = new int[jsonArray.length()];
+        for (int i = 0; i < jsonArray.length(); i++) {
+            sitesArray[i] = jsonArray.getInt(i);
+        }
+
+        return sitesArray;
+    }
 }

WordPress/src/main/java/org/wordpress/android/ui/publicize/ConnectButton.java

@@ -74,6 +74,12 @@ private void updateView() {
                 textColorResId = R.color.white;
                 captionResId = R.string.share_btn_reconnect;
                 break;
+            case CONNECT_ANOTHER_ACCOUNT:
+                normalColorResId = R.color.blue_medium;
+                pressedColorResId = R.color.blue_light;
+                textColorResId = R.color.white;
+                captionResId = R.string.share_btn_connect_another_account;
+                break;
             default:
                 return;
         }

WordPress/src/main/java/org/wordpress/android/ui/publicize/PublicizeAccountChooserDialogFragment.java

@@ -0,0 +1,163 @@
+package org.wordpress.android.ui.publicize;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.LinearLayout;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.wordpress.android.R;
+import org.wordpress.android.models.PublicizeConnection;
+import org.wordpress.android.util.ToastUtils;
+
+import java.util.ArrayList;
+
+import de.greenrobot.event.EventBus;
+
+public class PublicizeAccountChooserDialogFragment extends DialogFragment implements PublicizeAccountChooserListAdapter.OnPublicizeAccountChooserListener {
+    public static String TAG = "publicize-account-chooser-dialog-fragment";
+    private RecyclerView mNotConnectedRecyclerView;
+    private ArrayList<PublicizeConnection> mNotConnectedAccounts;
+    private ArrayList<PublicizeConnection> mConnectedAccounts;
+    private String mConnectionName = "";
+    private String mServiceId = "";
+    private int mSelectedIndex = 0;
+    private int mSiteId = 0;
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        retrieveCurrentSiteFromArgs();
+        configureConnectionName();
+
+        LayoutInflater inflater = getActivity().getLayoutInflater();
+        View view = inflater.inflate(R.layout.publicize_account_chooser_dialog, null);
+
+        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        configureAlertDialog(view, builder);
+        configureRecyclerViews(view);
+
+        return builder.create();
+    }
+
+    @Override
+    public void onDismiss(DialogInterface dialog) {
+        super.onDismiss(dialog);
+        Activity activity = getActivity();
+        if (activity != null && activity instanceof DialogInterface.OnDismissListener) {
+            ((DialogInterface.OnDismissListener) activity).onDismiss(dialog);
+        }
+    }
+
+    private void configureRecyclerViews(View view) {
+        PublicizeAccountChooserListAdapter notConnectedAdapter = new PublicizeAccountChooserListAdapter(mNotConnectedAccounts, this, false);
+        notConnectedAdapter.setHasStableIds(true);
+        mNotConnectedRecyclerView = (RecyclerView) view.findViewById(R.id.not_connected_recyclerview);
+        mNotConnectedRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
+        mNotConnectedRecyclerView.setAdapter(notConnectedAdapter);
+
+        if (mConnectedAccounts.isEmpty()) {
+            hideConnectedView(view);
+        } else {
+            populateConnectedListView(view);
+        }
+    }
+
+    private void hideConnectedView(View view) {
+        LinearLayout connectedHeader = (LinearLayout) view.findViewById(R.id.connected_header);
+        connectedHeader.setVisibility(View.GONE);
+    }
+
+    private void populateConnectedListView(View view) {
+        RecyclerView listViewConnected = (RecyclerView) view.findViewById(R.id.connected_recyclerview);
+        PublicizeAccountChooserListAdapter connectedAdapter = new PublicizeAccountChooserListAdapter(mConnectedAccounts, null, true);
+
+        listViewConnected.setLayoutManager(new LinearLayoutManager(getActivity()));
+        listViewConnected.setAdapter(connectedAdapter);
+    }
+
+    private void configureAlertDialog(View view, AlertDialog.Builder builder) {
+        builder.setView(view);
+        builder.setTitle(getString(R.string.connecting_social_network, mConnectionName));
+        builder.setMessage(getString(R.string.connection_chooser_message));
+        builder.setPositiveButton(R.string.share_btn_connect, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialogInterface, int i) {
+                dialogInterface.dismiss();
+                int keychainId = mNotConnectedAccounts.get(mSelectedIndex).connectionId;
+                EventBus.getDefault().post(new PublicizeEvents.ActionAccountChosen(mSiteId, keychainId));
+            }
+        });
+        builder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialogInterface, int i) {
+                dialogInterface.cancel();
+                ToastUtils.showToast(getActivity(), getActivity().getString(R.string.cannot_connect_account_error, mConnectionName));
+            }
+        });
+    }
+
+    private boolean containsSiteId(int[] array) {
+        for (int a : array) {
+            if (a == mSiteId) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private void retrieveCurrentSiteFromArgs() {
+        Bundle args = getArguments();
+        if (args != null) {
+            mSiteId = args.getInt(PublicizeConstants.ARG_SITE_ID);
+            mServiceId = args.getString(PublicizeConstants.ARG_SERVICE_ID);
+            String jsonString = args.getString(PublicizeConstants.ARG_CONNECTION_ARRAY_JSON);
+            addConnectionsToLists(jsonString);
+        }
+    }
+
+    private void addConnectionsToLists(String jsonString) {
+        mNotConnectedAccounts = new ArrayList<>();
+        mConnectedAccounts = new ArrayList<>();
+        try {
+            JSONObject jsonObject = new JSONObject(jsonString);
+            JSONArray jsonArray = jsonObject.getJSONArray("connections");
+            for (int i = 0; i < jsonArray.length(); i++) {
+                PublicizeConnection connection = PublicizeConnection.fromJson(jsonArray.getJSONObject(i));
+                if (connection.getService().equals(mServiceId)) {
+                    if (connection.isInSite(mSiteId)) {
+                        mConnectedAccounts.add(connection);
+                    } else {
+                        mNotConnectedAccounts.add(connection);
+                    }
+                }
+            }
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void configureConnectionName() {
+        PublicizeConnection connection = mNotConnectedAccounts.get(0);
+        if (connection != null) {
+            mConnectionName = connection.getLabel();
+        }
+    }
+
+    @Override
+    public void onAccountSelected(int selectedIndex) {
+        mSelectedIndex = selectedIndex;
+        mNotConnectedRecyclerView.getAdapter().notifyDataSetChanged();
+    }
+}

WordPress/src/main/java/org/wordpress/android/ui/publicize/PublicizeAccountChooserListAdapter.java

@@ -0,0 +1,81 @@
+package org.wordpress.android.ui.publicize;
+
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.RadioButton;
+import android.widget.TextView;
+
+import org.wordpress.android.R;
+import org.wordpress.android.models.PublicizeConnection;
+import org.wordpress.android.widgets.WPNetworkImageView;
+
+import java.util.List;
+
+public class PublicizeAccountChooserListAdapter extends RecyclerView.Adapter<PublicizeAccountChooserListAdapter.ViewHolder> {
+    private List<PublicizeConnection> mConnectionItems;
+    private OnPublicizeAccountChooserListener mListener;
+    private boolean mAreAccountsConnected;
+    private int mSelectedPosition;
+
+    public PublicizeAccountChooserListAdapter(List<PublicizeConnection> connectionItems, OnPublicizeAccountChooserListener listener, boolean isConnected) {
+        mConnectionItems = connectionItems;
+        mListener = listener;
+        mAreAccountsConnected = isConnected;
+        mSelectedPosition = 0;
+    }
+
+    @Override
+    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.publicize_connection_list_item, parent, false);
+
+        return new ViewHolder(view);
+    }
+
+    @Override
+    public void onBindViewHolder(final ViewHolder holder, int position) {
+        final PublicizeConnection connection = mConnectionItems.get(position);
+        holder.mProfileImageView.setImageUrl(connection.getExternalProfilePictureUrl(), WPNetworkImageView.ImageType.PHOTO);
+        holder.mNameTextView.setText(connection.getExternalDisplayName());
+        holder.mRadioButton.setChecked(position == mSelectedPosition);
+
+        if (!mAreAccountsConnected) {
+            holder.mView.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View view) {
+                    if (mListener != null) {
+                        mSelectedPosition = holder.getAdapterPosition();
+                        mListener.onAccountSelected(mSelectedPosition);
+                    }
+                }
+            });
+        } else {
+            holder.mRadioButton.setVisibility(View.INVISIBLE);
+        }
+    }
+
+    @Override
+    public int getItemCount() {
+        return mConnectionItems.size();
+    }
+
+    public class ViewHolder extends RecyclerView.ViewHolder {
+        public final View mView;
+        public final RadioButton mRadioButton;
+        public final WPNetworkImageView mProfileImageView;
+        public final TextView mNameTextView;
+
+        public ViewHolder(View view) {
+            super(view);
+            mView = view;
+            mRadioButton = (RadioButton) view.findViewById(R.id.radio_button);
+            mProfileImageView = (WPNetworkImageView) view.findViewById(R.id.profile_pic);
+            mNameTextView = (TextView) view.findViewById(R.id.name);
+        }
+    }
+
+    public interface OnPublicizeAccountChooserListener {
+        void onAccountSelected(int selectedIndex);
+    }
+}

WordPress/src/main/java/org/wordpress/android/ui/publicize/PublicizeActions.java

@@ -7,6 +7,7 @@
 import com.wordpress.rest.RestRequest;
 
 import org.json.JSONArray;
+import org.json.JSONException;
 import org.json.JSONObject;
 import org.wordpress.android.WordPress;
 import org.wordpress.android.datasets.PublicizeTable;
@@ -83,8 +84,13 @@ private static void connectStepOne(final int siteId, final String serviceId) {
         RestRequest.Listener listener = new RestRequest.Listener() {
             @Override
             public void onResponse(JSONObject jsonObject) {
-                int keyringConnectionId = parseServiceKeyringId(serviceId, jsonObject);
-                connectStepTwo(siteId, keyringConnectionId);
+                if (shouldShowChooserDialog(siteId, serviceId, jsonObject)) {
+                    // show dialog showing multiple options
+                    EventBus.getDefault().post(new PublicizeEvents.ActionRequestChooseAccount(siteId, serviceId, jsonObject));
+                } else {
+                    int keyringConnectionId = parseServiceKeyringId(serviceId, jsonObject);
+                    connectStepTwo(siteId, keyringConnectionId);
+                }
             }
         };
         RestRequest.ErrorListener errorListener = new RestRequest.ErrorListener() {
@@ -103,7 +109,7 @@ public void onErrorResponse(VolleyError volleyError) {
      * step two in creating a publicize connection: now that we have the keyring connection id,
      * create the actual connection
      */
-    private static void connectStepTwo(int siteId, int keyringConnectionId) {
+    public static void connectStepTwo(int siteId, int keyringConnectionId) {
         RestRequest.Listener listener = new RestRequest.Listener() {
             @Override
             public void onResponse(JSONObject jsonObject) {
@@ -127,6 +133,28 @@ public void onErrorResponse(VolleyError volleyError) {
         WordPress.getRestClientUtilsV1_1().post(path, params, null, listener, errorListener);
     }
 
+    private static boolean shouldShowChooserDialog(int siteId, String serviceId, JSONObject jsonObject) {
+        JSONArray jsonConnectionList = jsonObject.optJSONArray("connections");
+        if (jsonConnectionList == null || jsonConnectionList.length() <= 1) {
+            return false;
+        }
+
+        int totalAccounts = 0;
+        try {
+            for (int i = 0; i < jsonConnectionList.length(); i++) {
+                JSONObject connectionObject = jsonConnectionList.getJSONObject(i);
+                PublicizeConnection publicizeConnection = PublicizeConnection.fromJson(connectionObject);
+                if (publicizeConnection.getService().equals(serviceId) && !publicizeConnection.isInSite(siteId)) {
+                    totalAccounts++;
+                }
+            }
+
+            return totalAccounts > 0;
+        } catch (JSONException e) {
+            return false;
+        }
+    }
+
     /*
      * extract the keyring connection for the passed service from the response
      * to /me/keyring-connections