ContactListTreeAdapter.java

/*
 * Copyright (C) 2008 Esmertec AG.
 * Copyright (C) 2008 The Android Open Source Project
 *
 * 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.android.im.app;

import android.app.Activity;
import android.content.AsyncQueryHandler;
import android.content.ContentQueryMap;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.res.Resources;
import android.database.ContentObserver;
import android.database.Cursor;
import android.database.DataSetObserver;
import android.net.Uri;
import android.os.RemoteException;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseExpandableListAdapter;
import android.widget.CursorTreeAdapter;
import android.widget.TextView;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;

import com.android.im.IImConnection;
import com.android.im.R;
import com.android.im.plugin.BrandingResourceIDs;
import com.android.im.provider.Imps;

import java.util.ArrayList;
import java.util.Observable;
import java.util.Observer;

public class ContactListTreeAdapter extends BaseExpandableListAdapter
        implements AbsListView.OnScrollListener{

    private static final String[] CONTACT_LIST_PROJECTION = {
            Imps.ContactList._ID,
            Imps.ContactList.NAME,
    };

    private static final int COLUMN_CONTACT_LIST_ID = 0;
    private static final int COLUMN_CONTACT_LIST_NAME = 1;

    Activity mActivity;
    SimpleAlertHandler mHandler;
    private LayoutInflater mInflate;
    private long mProviderId;
    long mAccountId;
    Cursor mOngoingConversations;
    Cursor mSubscriptions;
    boolean mDataValid;
    ListTreeAdapter mAdapter;
    private boolean mHideOfflineContacts;

    final MyContentObserver mContentObserver;
    final MyDataSetObserver mDataSetObserver;

    private ArrayList<Integer> mExpandedGroups;

    private static final int TOKEN_CONTACT_LISTS = -1;
    private static final int TOKEN_ONGOING_CONVERSATION = -2;
    private static final int TOKEN_SUBSCRITPTION = -3;

    private static final String NON_CHAT_AND_BLOCKED_CONTACTS = "("
        + Imps.Contacts.LAST_MESSAGE_DATE + " IS NULL) AND ("
        + Imps.Contacts.TYPE + "!=" + Imps.Contacts.TYPE_BLOCKED + ")";

    private static final String CONTACTS_SELECTION = Imps.Contacts.CONTACTLIST
            + "=? AND " + NON_CHAT_AND_BLOCKED_CONTACTS;

    private static final String ONLINE_CONTACT_SELECTION = CONTACTS_SELECTION
            + " AND "+ Imps.Contacts.PRESENCE_STATUS + " != " + Imps.Presence.OFFLINE;

    static final void log(String msg) {
        Log.d(ImApp.LOG_TAG, "<ContactListAdapter>" + msg);
    }

    static final String[] CONTACT_COUNT_PROJECTION = {
        Imps.Contacts.CONTACTLIST,
        Imps.Contacts._COUNT,
    };

    ContentQueryMap mOnlineContactsCountMap;

    // Async QueryHandler
    private final class QueryHandler extends AsyncQueryHandler {
        public QueryHandler(Context context) {
            super(context.getContentResolver());
        }

        @Override
        protected void onQueryComplete(int token, Object cookie, Cursor c) {
            if(Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
                log("onQueryComplete:token=" + token);
            }

            if (token == TOKEN_CONTACT_LISTS) {
                mDataValid = true;
                mAdapter.setGroupCursor(c);
            } else if (token == TOKEN_ONGOING_CONVERSATION) {
                setOngoingConversations(c);
                notifyDataSetChanged();
            } else if (token == TOKEN_SUBSCRITPTION) {
                setSubscriptions(c);
                notifyDataSetChanged();
            } else {
                int count = mAdapter.getGroupCount();
                for (int pos = 0; pos < count; pos++) {
                    long listId = mAdapter.getGroupId(pos);
                    if (listId == token) {
                        mAdapter.setChildrenCursor(pos, c);
                        break;
                    }
                }
            }
        }
    }
    private QueryHandler mQueryHandler;

    private int mScrollState;

    private boolean mAutoRequery;
    private boolean mRequeryPending;

    public ContactListTreeAdapter(IImConnection conn, Activity activity) {
        mActivity = activity;
        mInflate = activity.getLayoutInflater();
        mHandler = new SimpleAlertHandler(activity);

        mAdapter = new ListTreeAdapter(null);

        mContentObserver = new MyContentObserver();
        mDataSetObserver = new MyDataSetObserver();
        mExpandedGroups = new ArrayList<Integer>();
        mQueryHandler = new QueryHandler(activity);

        changeConnection(conn);
    }

    public void changeConnection(IImConnection conn) {
        mQueryHandler.cancelOperation(TOKEN_ONGOING_CONVERSATION);
        mQueryHandler.cancelOperation(TOKEN_SUBSCRITPTION);
        mQueryHandler.cancelOperation(TOKEN_CONTACT_LISTS);

        synchronized (this) {
            if (mOngoingConversations != null) {
                mOngoingConversations.close();
                mOngoingConversations = null;
            }
            if (mSubscriptions != null) {
                mSubscriptions.close();
                mSubscriptions = null;
            }
            if (mOnlineContactsCountMap != null) {
                mOnlineContactsCountMap.close();
            }
        }

        mAdapter.notifyDataSetChanged();
        if (conn != null) {
            try {
                mProviderId = conn.getProviderId();
                mAccountId = conn.getAccountId();
                startQueryOngoingConversations();
                startQueryContactLists();
                startQuerySubscriptions();
            } catch (RemoteException e) {
                // Service died!
            }
        }
    }

    public void setHideOfflineContacts(boolean hide) {
        if (mHideOfflineContacts != hide) {
            mHideOfflineContacts = hide;
            mAdapter.notifyDataSetChanged();
        }
    }

    public void startAutoRequery() {
        if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
            log("startAutoRequery()");
        }
        mAutoRequery = true;
        if (mRequeryPending) {
            mRequeryPending = false;
            startQueryOngoingConversations();
        }
    }

    private void startQueryContactLists() {
        if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
            log("startQueryContactLists()");
        }

        Uri uri = Imps.ContactList.CONTENT_URI;
        uri = ContentUris.withAppendedId(uri, mProviderId);
        uri = ContentUris.withAppendedId(uri, mAccountId);

        mQueryHandler.startQuery(TOKEN_CONTACT_LISTS, null, uri, CONTACT_LIST_PROJECTION,
                null, null, Imps.ContactList.DEFAULT_SORT_ORDER);
    }

    void startQueryOngoingConversations() {
        if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
            log("startQueryOngoingConversations()");
        }

        Uri uri = Imps.Contacts.CONTENT_URI_CHAT_CONTACTS_BY;
        uri = ContentUris.withAppendedId(uri, mProviderId);
        uri = ContentUris.withAppendedId(uri, mAccountId);

        mQueryHandler.startQuery(TOKEN_ONGOING_CONVERSATION, null, uri,
                ContactView.CONTACT_PROJECTION, null, null, Imps.Contacts.DEFAULT_SORT_ORDER);
    }

    void startQuerySubscriptions() {
        if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
            log("startQuerySubscriptions()");
        }

        Uri uri = Imps.Contacts.CONTENT_URI_CONTACTS_BY;
        uri = ContentUris.withAppendedId(uri, mProviderId);
        uri = ContentUris.withAppendedId(uri, mAccountId);

        mQueryHandler.startQuery(TOKEN_SUBSCRITPTION, null, uri,
                ContactView.CONTACT_PROJECTION,
                String.format("%s=%d AND %s=%d",
                    Imps.Contacts.SUBSCRIPTION_STATUS, Imps.Contacts.SUBSCRIPTION_STATUS_SUBSCRIBE_PENDING,
                    Imps.Contacts.SUBSCRIPTION_TYPE, Imps.Contacts.SUBSCRIPTION_TYPE_FROM),
                null,Imps.Contacts.DEFAULT_SORT_ORDER);
    }

    void startQueryContacts(long listId) {
        if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
            log("startQueryContacts - listId=" + listId);
        }

        String selection = mHideOfflineContacts ? ONLINE_CONTACT_SELECTION : CONTACTS_SELECTION;
        String[] args = { Long.toString(listId) };
        int token = (int)listId;
        mQueryHandler.startQuery(token, null, Imps.Contacts.CONTENT_URI,
                ContactView.CONTACT_PROJECTION, selection, args, Imps.Contacts.DEFAULT_SORT_ORDER);
    }

    public Object getChild(int groupPosition, int childPosition) {
        if (isPosForOngoingConversation(groupPosition)) {
            // No cursor exists for the "Empty" TextView item
            if (getOngoingConversationCount() == 0) return null;
            return moveTo(getOngoingConversations(), childPosition);
        } else if (isPosForSubscription(groupPosition)) {
            return moveTo(getSubscriptions(), childPosition);
        } else {
            return mAdapter.getChild(getChildAdapterPosition(groupPosition), childPosition);
        }
    }

    public long getChildId(int groupPosition, int childPosition) {
        if (isPosForOngoingConversation(groupPosition)) {
            // No cursor id exists for the "Empty" TextView item
            if (getOngoingConversationCount() == 0) return 0;
            return getId(getOngoingConversations(), childPosition);
        } else if (isPosForSubscription(groupPosition)) {
            return getId(getSubscriptions(), childPosition);
        } else {
            return mAdapter.getChildId(getChildAdapterPosition(groupPosition), childPosition);
        }
    }

    public View getChildView(int groupPosition, int childPosition, boolean isLastChild,
            View convertView, ViewGroup parent) {
        boolean isOngoingConversation = isPosForOngoingConversation(groupPosition);
        boolean displayEmpty = isOngoingConversation && (getOngoingConversationCount() == 0);
        if (isOngoingConversation || isPosForSubscription(groupPosition)) {
            View view = null;
            if (convertView != null) {
                // use the convert view if it matches the type required by displayEmpty
                if (displayEmpty && (convertView instanceof TextView)) {
                    view = convertView;
                    ((TextView) view).setText(mActivity.getText(R.string.empty_conversation_group));
                } else if (!displayEmpty && (convertView instanceof ContactView)) {
                     view = convertView;
                }
            }
            if (view == null) {
                if (displayEmpty) {
                    view = newEmptyView(parent);
                } else {
                    view = newChildView(parent);
                }
            }
            if (!displayEmpty) {
                Cursor cursor = isPosForOngoingConversation(groupPosition)
                        ? getOngoingConversations() : getSubscriptions();
                cursor.moveToPosition(childPosition);
                ((ContactView) view).bind(cursor, null, isScrolling());
            }
            return view;
        } else {
            return mAdapter.getChildView(getChildAdapterPosition(groupPosition), childPosition,
                    isLastChild, convertView, parent);
        }
    }

    public int getChildrenCount(int groupPosition) {
        if (!mDataValid) {
            return 0;
        }
        if (isPosForOngoingConversation(groupPosition)) {
            // if there are no ongoing conversations, we want to display "empty" textview
            int count = getOngoingConversationCount();
            if (count == 0) {
                count = 1;
            }
            return count;
        } else if (isPosForSubscription(groupPosition)) {
            return getSubscriptionCount();
        } else {
            // XXX getChildrenCount() may be called with an invalid groupPosition that is larger
            // than the total number of all groups.
            int position = getChildAdapterPosition(groupPosition);
            if (position >= mAdapter.getGroupCount()) {
                Log.w(ImApp.LOG_TAG, "getChildrenCount out of range");
                return 0;
            }
            return mAdapter.getChildrenCount(position);
        }
    }

    public Object getGroup(int groupPosition) {
        if (isPosForOngoingConversation(groupPosition)
                || isPosForSubscription(groupPosition)) {
            return null;
        } else {
            return mAdapter.getGroup(getChildAdapterPosition(groupPosition));
        }
    }

    public int getGroupCount() {
        if (!mDataValid) {
            return 0;
        }
        int count = mAdapter.getGroupCount();

        // ongoing conversations
        count++;

        if (getSubscriptionCount() > 0) {
            count++;
        }

        return count;
    }

    public long getGroupId(int groupPosition) {
        if (isPosForOngoingConversation(groupPosition) || isPosForSubscription(groupPosition)) {
            return 0;
        } else {
            return mAdapter.getGroupId(getChildAdapterPosition(groupPosition));
        }
    }

    public View getGroupView(int groupPosition, boolean isExpanded, View convertView,
            ViewGroup parent) {
        if (isPosForOngoingConversation(groupPosition) || isPosForSubscription(groupPosition)) {
            View v;
            if (convertView != null) {
                v = convertView;
            } else {
                v = newGroupView(parent);
            }

            TextView text1 = (TextView)v.findViewById(R.id.text1);
            TextView text2 = (TextView)v.findViewById(R.id.text2);

            Resources r = v.getResources();
            ImApp app = ImApp.getApplication(mActivity);
            BrandingResources brandingRes = app.getBrandingResource(mProviderId);
            String text = isPosForOngoingConversation(groupPosition) ?
                    brandingRes.getString(
                            BrandingResourceIDs.STRING_ONGOING_CONVERSATION,
                            getOngoingConversationCount()) :
                    r.getString(R.string.subscriptions);
            text1.setText(text);
            text2.setVisibility(View.GONE);
            return v;
        } else {
            return mAdapter.getGroupView(getChildAdapterPosition(groupPosition), isExpanded,
                    convertView, parent);
        }
    }

    public boolean isChildSelectable(int groupPosition, int childPosition) {
        if (isPosForOngoingConversation(groupPosition)) {
            // "Empty" TextView is not selectable
            if (getOngoingConversationCount()==0) return false;
            return true;
        }
        if (isPosForSubscription(groupPosition)) return true;
        return mAdapter.isChildSelectable(getChildAdapterPosition(groupPosition), childPosition);
    }

    public boolean stableIds() {
        return true;
    }

    @Override
    public void registerDataSetObserver(DataSetObserver observer) {
        mAdapter.registerDataSetObserver(observer);
        super.registerDataSetObserver(observer);
    }

    @Override
    public void unregisterDataSetObserver(DataSetObserver observer) {
        mAdapter.unregisterDataSetObserver(observer);
        super.unregisterDataSetObserver(observer);
    }

    public boolean hasStableIds() {
        return true;
    }

    @Override
    public void onGroupCollapsed(int groupPosition) {
        super.onGroupCollapsed(groupPosition);
        mExpandedGroups.remove(Integer.valueOf(groupPosition));
        int pos = getChildAdapterPosition(groupPosition);
        if (pos >= 0) {
            mAdapter.onGroupCollapsed(pos);
        }
    }

    @Override
    public void onGroupExpanded(int groupPosition) {
        super.onGroupExpanded(groupPosition);
        mExpandedGroups.add(groupPosition);
        int pos = getChildAdapterPosition(groupPosition);
        if (pos >= 0) {
            mAdapter.onGroupExpanded(pos);
        }
    }

    public int[] getExpandedGroups() {
        ArrayList<Integer> expandedGroups = mExpandedGroups;
        int size = expandedGroups.size();
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = expandedGroups.get(i);
        }
        return res;
    }

    View newChildView(ViewGroup parent) {
        return mInflate.inflate(R.layout.contact_view, parent, false);
    }

    View newEmptyView(ViewGroup parent) {
        return mInflate.inflate(R.layout.empty_conversation_group_view, parent, false);
    }

    View newGroupView(ViewGroup parent) {
        return mInflate.inflate(R.layout.group_view, parent, false);
    }

    private synchronized Cursor getOngoingConversations() {
        if (mOngoingConversations == null) {
            startQueryOngoingConversations();
        }
        return mOngoingConversations;
    }

    synchronized void setOngoingConversations(Cursor c) {
        if (mOngoingConversations != null) {
            mOngoingConversations.unregisterContentObserver(mContentObserver);
            mOngoingConversations.unregisterDataSetObserver(mDataSetObserver);
            mOngoingConversations.close();
        }
        c.registerContentObserver(mContentObserver);
        c.registerDataSetObserver(mDataSetObserver);
        mOngoingConversations = c;
    }

    private int getOngoingConversationCount() {
        Cursor c = getOngoingConversations();
        return c == null ? 0 : c.getCount();
    }

    private synchronized Cursor getSubscriptions() {
        if (mSubscriptions == null) {
            startQuerySubscriptions();
        }
        return mSubscriptions;
    }

    synchronized void setSubscriptions(Cursor c) {
        if (mSubscriptions != null) {
            mSubscriptions.close();
        }
        // we don't need to register observers on mSubscriptions because
        // we already have observers on mOngoingConversations and they
        // will be notified if there is any changes of subscription
        // since the two cursors come from the same table.
        mSubscriptions = c;
    }

    private int getSubscriptionCount() {
        Cursor c = getSubscriptions();
        return c == null ? 0 : c.getCount();
    }

    public boolean isPosForOngoingConversation(int groupPosition) {
        return groupPosition == 0;
    }

    public boolean isPosForSubscription(int groupPosition) {
        return groupPosition == 1 && getSubscriptionCount() > 0;
    }

    private int getChildAdapterPosition(int groupPosition) {
        if (getSubscriptionCount() > 0) {
            return groupPosition - 2;
        } else {
            return groupPosition - 1;
        }
    }

    private Cursor moveTo(Cursor cursor, int position) {
        if (cursor.moveToPosition(position)) {
            return cursor;
        }
        return null;
    }

    private long getId(Cursor cursor, int position) {
        if (cursor.moveToPosition(position)) {
            return cursor.getLong(ContactView.COLUMN_CONTACT_ID);
        }
        return 0;
    }

    class ListTreeAdapter extends CursorTreeAdapter {

        public ListTreeAdapter(Cursor cursor) {
            super(cursor, mActivity);
        }

        @Override
        protected void bindChildView(View view, Context context, Cursor cursor,
                boolean isLastChild) {
            // binding when child is text view for an empty group
            if (view instanceof TextView) {
                ((TextView) view).setText(mActivity.getText(R.string.empty_contact_group));
            } else {
                ((ContactView) view).bind(cursor, null, isScrolling());
            }
        }

        @Override
        protected void bindGroupView(View view, Context context, Cursor cursor,
                boolean isExpanded) {
            TextView text1 = (TextView)view.findViewById(R.id.text1);
            TextView text2 = (TextView)view.findViewById(R.id.text2);
            Resources r = view.getResources();

            text1.setText(cursor.getString(COLUMN_CONTACT_LIST_NAME));
            text2.setVisibility(View.VISIBLE);
            text2.setText(r.getString(R.string.online_count, getOnlineChildCount(cursor)));
        }

        View newEmptyView(ViewGroup parent) {
            return mInflate.inflate(R.layout.empty_contact_group_view, parent, false);
        }

        // if the group is empty, provide a text view. The infrastructure provides a "convertView"
        // as a possible suggestion to reuse an existing view's data. It may be null, it may be a
        // TextView, or it may be a ContactView, so we need to test the possible cases.
        @Override
        public View getChildView(int groupPosition, int childPosition, boolean isLastChild,
                View convertView, ViewGroup parent) {
            // Provide a TextView if the group is empty
            if (super.getChildrenCount(groupPosition)==0) {
                if (convertView != null) {
                    if (convertView instanceof TextView) {
                        ((TextView) convertView).setText(
                                mActivity.getText(R.string.empty_contact_group));
                        return convertView;
                    }
                }
                return newEmptyView(parent);
            }
            if ( !(convertView instanceof ContactView) ) {
                convertView = null;
            }
            return super.getChildView(groupPosition, childPosition, isLastChild, convertView,
                    parent);
        }

        @Override
        protected Cursor getChildrenCursor(Cursor groupCursor) {
            long listId = groupCursor.getLong(COLUMN_CONTACT_LIST_ID);
            startQueryContacts(listId);
            return null;
        }

        // return a TextView for empty groups
        @Override
        protected View newChildView(Context context, Cursor cursor, boolean isLastChild,
                ViewGroup parent) {
            if (cursor.getCount() == 0) {
                return newEmptyView(parent);
            } else {
                return ContactListTreeAdapter.this.newChildView(parent);
            }
        }

        @Override
        protected View newGroupView(Context context, Cursor cursor, boolean isExpanded,
                ViewGroup parent) {
            return ContactListTreeAdapter.this.newGroupView(parent);
        }

        private int getOnlineChildCount(Cursor groupCursor) {
            long listId = groupCursor.getLong(COLUMN_CONTACT_LIST_ID);
            if (mOnlineContactsCountMap == null) {
                String where = Imps.Contacts.ACCOUNT + "=" + mAccountId;
                ContentResolver cr = mActivity.getContentResolver();

                Cursor c = cr.query(Imps.Contacts.CONTENT_URI_ONLINE_COUNT,
                        CONTACT_COUNT_PROJECTION, where, null, null);
                mOnlineContactsCountMap = new ContentQueryMap(c,
                        Imps.Contacts.CONTACTLIST, true, mHandler);
                mOnlineContactsCountMap.addObserver(new Observer(){
                    public void update(Observable observable, Object data) {
                        notifyDataSetChanged();
                    }});
            }
            ContentValues value = mOnlineContactsCountMap.getValues(String.valueOf(listId));
            return  value == null ? 0 : value.getAsInteger(Imps.Contacts._COUNT);
        }

        @Override
        public int getChildrenCount(int groupPosition) {
            int children = super.getChildrenCount(groupPosition);
            if (children == 0) {
                // Count the empty group text item as a child
                return 1;
            }
            return children;
        }

        // Don't allow the empty group text item to be selected
        @Override
        public boolean isChildSelectable(int groupPosition, int childPosition) {
            return (super.getChildrenCount(groupPosition) > 0);
        }
    }

    private class MyContentObserver extends ContentObserver {

        public MyContentObserver() {
            super(mHandler);
        }

        @Override
        public void onChange(boolean selfChange) {
            if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
                log("MyContentObserver.onChange() autoRequery=" + mAutoRequery);
            }
            // Don't requery when fling. We will schedule a requery when the fling is complete.
            if (isScrolling()) {
                return;
            }
            if (mAutoRequery) {
                startQueryOngoingConversations();
            } else {
                mRequeryPending = true;
            }
        }
    }

    private class MyDataSetObserver extends DataSetObserver {
        public MyDataSetObserver() {
        }

        @Override
        public void onChanged() {
            if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
                log("MyDataSetObserver.onChanged()");
            }

            mDataValid = true;
            notifyDataSetChanged();
        }

        @Override
        public void onInvalidated() {
            if (Log.isLoggable(ImApp.LOG_TAG, Log.DEBUG)){
                log("MyDataSetObserver.onInvalidated()");
            }

            mDataValid = false;
            notifyDataSetInvalidated();
        }
    }

    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
            int totalItemCount) {
        // no op
    }

    public void onScrollStateChanged(AbsListView view, int scrollState) {
        int oldState = mScrollState;

        mScrollState = scrollState;
        //  If we just finished a fling then some items may not have an icon
        //  So force a full redraw now that the fling is complete
        if (oldState == OnScrollListener.SCROLL_STATE_FLING) {
            notifyDataSetChanged();
        }
    }

    public boolean isScrolling() {
        return mScrollState == OnScrollListener.SCROLL_STATE_FLING;
    }
}