AtlasParticipantPicker.java

/*
 * Copyright (c) 2015 Layer. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.layer.atlas;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeSet;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Typeface;
import android.graphics.drawable.GradientDrawable;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.FrameLayout;
import android.widget.ListView;
import android.widget.TextView;

import com.layer.atlas.Atlas.Participant;
import com.layer.atlas.Atlas.ParticipantProvider;

/**
 * @author Oleg Orlov
 * @since 27 Apr 2015
 */
public class AtlasParticipantPicker extends FrameLayout {

    private static final String TAG = AtlasParticipantPicker.class.getSimpleName();
    private static final boolean debug = false;

    // participants picker
    private View rootView;
    private EditText textFilter;
    private ListView participantsList;
    private ViewGroup selectedParticipantsContainer;

    private ParticipantProvider participantProvider;

    private TreeSet<String> skipUserIds = new TreeSet<String>();
    private final Map<String, Participant> filteredParticipants = new HashMap<String, Participant>();
    private ArrayList<String> selectedParticipantIds = new ArrayList<String>();
    private final ArrayList<ParticipantEntry> participantsForAdapter = new ArrayList<ParticipantEntry>();

    private BaseAdapter participantsAdapter;

    // styles
    private int inputTextColor;
    private Typeface inputTextTypeface;
    private int inputTextStyle;
    private int listTextColor;
    private Typeface listTextTypeface;
    private int listTextStyle;
    private int chipBackgroundColor;
    private int chipTextColor;
    private Typeface chipTextTypeface;
    private int chipTextStyle;

    public AtlasParticipantPicker(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        parseStyle(context, attrs, defStyle);
    }

    public AtlasParticipantPicker(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public AtlasParticipantPicker(Context context) {
        super(context);
    }

    public void init(String[] userIdToSkip, ParticipantProvider participantProvider) {
        if (participantProvider == null) throw new IllegalArgumentException("ParticipantProvider cannot be null");
        
        LayoutInflater.from(getContext()).inflate(R.layout.atlas_participants_picker, this);

        this.participantProvider = participantProvider;
        if (userIdToSkip != null) skipUserIds.addAll(Arrays.asList(userIdToSkip));
        
        // START OF -------------------- Participant Picker ----------------------------------------
        this.rootView = this;
        textFilter = (EditText) rootView.findViewById(R.id.atlas_participants_picker_text);
        participantsList = (ListView) rootView.findViewById(R.id.atlas_participants_picker_list);
        selectedParticipantsContainer = (ViewGroup) rootView.findViewById(R.id.atlas_participants_picker_names);

        if (rootView.getVisibility() == View.VISIBLE) {
            textFilter.requestFocus();
        }

        // log focuses
        final View scroller = rootView.findViewById(R.id.atlas_participants_picker_scroll);
        scroller.setOnFocusChangeListener(new OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (debug) Log.w(TAG, "scroller.onFocusChange() hasFocus: " + hasFocus);
            }
        });
        selectedParticipantsContainer.setOnFocusChangeListener(new OnFocusChangeListener() {
            public void onFocusChange(View v, boolean hasFocus) {
                if (debug) Log.w(TAG, "names.onFocusChange()    hasFocus: " + hasFocus);
            }
        });

        // If filter.requestFocus is called from .onClickListener - filter receives focus, but
        // NamesLayout receives it immediately after that. So filter lose it.
        // XXX: scroller also receives focus 
        selectedParticipantsContainer.setOnTouchListener(new OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                if (debug) Log.w(TAG, "names.onTouch() event: " + event);
                if (event.getAction() == MotionEvent.ACTION_DOWN) // ACTION_UP never comes if  
                    textFilter.requestFocus(); //   there is no .onClickListener
                return false;
            }
        });

        textFilter.setOnFocusChangeListener(new OnFocusChangeListener() {
            public void onFocusChange(View v, boolean hasFocus) {
                View focused = selectedParticipantsContainer.hasFocus() ? selectedParticipantsContainer : selectedParticipantsContainer.findFocus();
                if (debug) Log.w(TAG, "filter.onFocusChange()   hasFocus: " + hasFocus + ", focused: " + focused);
                if (hasFocus) {
                    participantsList.setVisibility(View.VISIBLE);
                }
                v.post(new Runnable() { // check focus runnable
                    @Override
                    public void run() {
                        if (debug) Log.w(TAG, "filter.onFocusChange.run()   filter.focus: " + textFilter.hasFocus());
                        if (debug) Log.w(TAG, "filter.onFocusChange.run()    names.focus: " + selectedParticipantsContainer.hasFocus());
                        if (debug) Log.w(TAG, "filter.onFocusChange.run() scroller.focus: " + scroller.hasFocus());

                        // check focus is on any descendants and hide list otherwise  
                        View focused = selectedParticipantsContainer.hasFocus() ? selectedParticipantsContainer : selectedParticipantsContainer.findFocus();
                        if (focused == null) {
                            participantsList.setVisibility(View.GONE);
                            textFilter.setText("");
                        }
                    }
                });
            }
        });

        participantsList.setAdapter(participantsAdapter = new BaseAdapter() {
            public View getView(int position, View convertView, ViewGroup parent) {
                if (convertView == null) {
                    convertView = LayoutInflater.from(parent.getContext()).inflate(R.layout.atlas_view_participants_picker_convert, parent, false);
                }

                TextView name = (TextView) convertView.findViewById(R.id.atlas_view_participants_picker_convert_name);
                TextView avatarText = (TextView) convertView.findViewById(R.id.atlas_view_participants_picker_convert_ava);
                ParticipantEntry entry = participantsForAdapter.get(position);

                if (entry != null) {
                    name.setText(Atlas.getFullName(entry.participant));
                    avatarText.setText(Atlas.getInitials(entry.participant));
                } else {
                    name.setText(null);
                    avatarText.setText(null);
                }
                
                // apply styles
                name.setTextColor(listTextColor);
                name.setTypeface(listTextTypeface, listTextStyle);
                avatarText.setTextColor(listTextColor);
                avatarText.setTypeface(listTextTypeface, listTextStyle);
                return convertView;
            }

            public long getItemId(int position) {
                return participantsForAdapter.get(position).id.hashCode();
            }

            public Object getItem(int position) {
                return participantsForAdapter.get(position);
            }

            public int getCount() {
                return participantsForAdapter.size();
            }
        });

        participantsList.setOnItemClickListener(new OnItemClickListener() {
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                ParticipantEntry entry = participantsForAdapter.get(position);
                selectedParticipantIds.add(entry.id);
                refreshParticipants(selectedParticipantIds);
                textFilter.setText("");
                textFilter.requestFocus();
                filterParticipants("");                 // refresh participantList
            }

        });

        // track text and filter participant list
        textFilter.addTextChangedListener(new TextWatcher() {
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                if (debug) Log.w(TAG, "beforeTextChanged() s: " + s + " start: " + start + " count: " + count + " after: " + after);
            }

            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (debug) Log.w(TAG, "onTextChanged()     s: " + s + " start: " + start + " before: " + before + " count: " + count);

                final String filter = s.toString().toLowerCase();
                filterParticipants(filter);
            }

            public void afterTextChanged(Editable s) {
                if (debug) Log.w(TAG, "afterTextChanged()  s: " + s);
            }
        });

        // select last added participant when press "Backspace/Del"
        textFilter.setOnKeyListener(new OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                if (debug) Log.w(TAG, "onKey() keyCode: " + keyCode + ", event: " + event);
                if (keyCode == KeyEvent.KEYCODE_DEL && event.getAction() == KeyEvent.ACTION_DOWN && textFilter.getText().length() == 0 && selectedParticipantIds.size() > 0) {

                    selectedParticipantIds.remove(selectedParticipantIds.size() - 1);
                    refreshParticipants(selectedParticipantIds);
                    filterParticipants("");
                    textFilter.requestFocus();
                }
                return false;
            }
        });
        // END OF ---------------------- Participant Picker ---------------------------------------- 
        
        filterParticipants("");

        applyStyle();
    }

    private void refreshParticipants(final ArrayList<String> selectedParticipantIds) {

        // remove name_converts first. Better to keep editText in place rather than add/remove that force keyboard to blink
        for (int i = selectedParticipantsContainer.getChildCount() - 1; i >= 0; i--) {
            View child = selectedParticipantsContainer.getChildAt(i);
            if (child != textFilter) {
                selectedParticipantsContainer.removeView(child);
            }
        }
        if (debug) Log.w(TAG, "refreshParticipants() childs left: " + selectedParticipantsContainer.getChildCount());
        for (String id : selectedParticipantIds) {
            Participant entry = participantProvider.getParticipant(id);
            View participantView = LayoutInflater.from(selectedParticipantsContainer.getContext()).inflate(R.layout.atlas_view_participants_picker_name_convert, selectedParticipantsContainer, false);

            TextView avaText = (TextView) participantView.findViewById(R.id.atlas_view_participants_picker_name_convert_ava);
            avaText.setText(Atlas.getInitials(entry));
            TextView nameText = (TextView) participantView.findViewById(R.id.atlas_view_participants_picker_name_convert_name);
            nameText.setText(Atlas.getFullName(entry));
            participantView.setTag(entry);

            selectedParticipantsContainer.addView(participantView, selectedParticipantsContainer.getChildCount() - 1);
            if (debug) Log.w(TAG, "refreshParticipants() child added: " + participantView + ", for: " + entry);
            
            // apply styles
            avaText.setTextColor(chipTextColor);
            avaText.setTypeface(chipTextTypeface, chipTextStyle);
            nameText.setTextColor(chipTextColor);
            nameText.setTypeface(chipTextTypeface, chipTextStyle);
            View container = participantView.findViewById(R.id.atlas_view_participants_picker_name_convert);
            GradientDrawable drawable = (GradientDrawable) container.getBackground();
            drawable.setColor(chipBackgroundColor);
            
        }
        if (selectedParticipantIds.size() == 0) {
            LayoutParams params = new LayoutParams(textFilter.getLayoutParams());
            params.width = LayoutParams.MATCH_PARENT;
        }
        selectedParticipantsContainer.requestLayout();
    }
    
    private void filterParticipants(final String filter) {
        filteredParticipants.clear();
        participantProvider.getParticipants(filter, filteredParticipants);
        participantsForAdapter.clear();
        for (Map.Entry<String, Participant> entry : filteredParticipants.entrySet()) {
            if (selectedParticipantIds.contains(entry.getKey())) continue;
            if (skipUserIds.contains(entry.getKey())) continue;
            participantsForAdapter.add(new ParticipantEntry(entry.getValue(), entry.getKey()));
        }
        Collections.sort(participantsForAdapter, new ParticipantEntryFilteringComparator(filter));
        participantsAdapter.notifyDataSetChanged();
    }

    private void parseStyle(Context context, AttributeSet attrs, int defStyle) {
        TypedArray ta = context.getTheme().obtainStyledAttributes(attrs, R.styleable.AtlasParticipantPicker, R.attr.AtlasParticipantPicker, defStyle);
        this.inputTextColor = ta.getColor(R.styleable.AtlasParticipantPicker_inputTextColor, context.getResources().getColor(R.color.atlas_text_black));
        this.inputTextStyle = ta.getInt(R.styleable.AtlasParticipantPicker_inputTextStyle, Typeface.NORMAL);
        String inputTextTypefaceName = ta.getString(R.styleable.AtlasParticipantPicker_inputTextTypeface); 
        this.inputTextTypeface  = inputTextTypefaceName != null ? Typeface.create(inputTextTypefaceName, inputTextStyle) : null;
        
        this.listTextColor = ta.getColor(R.styleable.AtlasParticipantPicker_listTextColor, context.getResources().getColor(R.color.atlas_text_black));
        this.listTextStyle = ta.getInt(R.styleable.AtlasParticipantPicker_listTextStyle, Typeface.NORMAL);
        String listTextTypefaceName = ta.getString(R.styleable.AtlasParticipantPicker_listTextTypeface); 
        this.listTextTypeface  = listTextTypefaceName != null ? Typeface.create(listTextTypefaceName, inputTextStyle) : null;
        
        this.chipBackgroundColor = ta.getColor(R.styleable.AtlasParticipantPicker_chipBackgroundColor, context.getResources().getColor(R.color.atlas_background_gray)); 
        this.chipTextColor = ta.getColor(R.styleable.AtlasParticipantPicker_chipTextColor, context.getResources().getColor(R.color.atlas_text_black)); 
        this.chipTextStyle = ta.getInt(R.styleable.AtlasParticipantPicker_chipTextStyle, Typeface.NORMAL);
        String chipTextTypefaceName = ta.getString(R.styleable.AtlasParticipantPicker_chipTextTypeface); 
        this.chipTextTypeface  = chipTextTypefaceName != null ? Typeface.create(chipTextTypefaceName, inputTextStyle) : null;
        ta.recycle();
    }
    
    private void applyStyle() {
        refreshParticipants(selectedParticipantIds);
        participantsAdapter.notifyDataSetChanged();
        textFilter.setTextColor(inputTextColor);
        textFilter.setTypeface(inputTextTypeface, inputTextStyle);
    }

    public String[] getSelectedUserIds() {
        String[] userIds = new String[selectedParticipantIds.size()];
        int i = 0;
        for (String id : selectedParticipantIds) {
            userIds[i++] = id;
        }
        return userIds;
    }

    public void setVisibility(int visibility) {
        super.setVisibility(visibility);
        if (visibility == View.VISIBLE) {
            textFilter.requestFocus();
        }
    }

    private static final class FilteringComparator implements Comparator<Participant> {
        private final String filter;

        /**
         * @param filter - the less indexOf(filter) the less order of participant
         */
        public FilteringComparator(String filter) {
            this.filter = filter;
        }

        @Override
        public int compare(Participant lhs, Participant rhs) {
            int result = subCompareCaseInsensitive(lhs.getFirstName(), rhs.getFirstName());
            if (result != 0) return result;
            return subCompareCaseInsensitive(lhs.getLastName(), rhs.getLastName());
        }

        private int subCompareCaseInsensitive(String lhs, String rhs) {
            int left = lhs != null ? lhs.toLowerCase().indexOf(filter) : -1;
            int right = rhs != null ? rhs.toLowerCase().indexOf(filter) : -1;

            if (left == -1 && right == -1) return 0;
            if (left != -1 && right == -1) return -1;
            if (left == -1 && right != -1) return 1;
            if (left - right != 0) return left - right;
            return String.CASE_INSENSITIVE_ORDER.compare(lhs, rhs);
        }
    }

    private static final class ParticipantEntryFilteringComparator implements Comparator<ParticipantEntry> {
        FilteringComparator comparator;

        public ParticipantEntryFilteringComparator(String filter) {
            this.comparator = new FilteringComparator(filter);
        }

        @Override
        public int compare(ParticipantEntry lhs, ParticipantEntry rhs) {
            return comparator.compare(lhs.participant, rhs.participant);
        }
    }
    
    private static class ParticipantEntry {
        final Participant participant;
        final String id;

        public ParticipantEntry(Participant participant, String id) {
            if (participant == null) throw new IllegalArgumentException("Participant cannot be null");
            if (id == null) throw new IllegalArgumentException("ID cannot be null");
            this.participant = participant;
            this.id = id;
        }
    }

}