First pass at new system UI for download manager.

This is the initial checkin for a new system UI for the download
manager.  This UI shows all entries present in the Download Manager
database, sorted by either date or size.  It allows the user to
monitor status, open files, and delete/cancel entries.

The code was initially copied from the "Downloads" page of
packages/apps/Browser, since the design is based on that UI.  Much of
the code is changed, although DateSortedExpandableListAdapter is
nearly identical.

The code is not quite finished, but this is very much a working first
pass.

Change-Id: I7fe102e9f2998e57d893cc3c0f5f6da1cf2db549

1 files changed, 347 insertions, 0 deletions

diff --git a/ui/src/com/android/providers/downloads/ui/DateSortedExpandableListAdapter.java b/ui/src/com/android/providers/downloads/ui/DateSortedExpandableListAdapter.java
new file mode 100644
index 00000000..88ffdee3
--- /dev/null
+++ b/ui/src/com/android/providers/downloads/ui/DateSortedExpandableListAdapter.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2010 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.providers.downloads.ui;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.database.DataSetObserver;
+import android.net.DownloadManager;
+import android.os.Handler;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.webkit.DateSorter;
+import android.widget.ExpandableListAdapter;
+import android.widget.ExpandableListView;
+import android.widget.TextView;
+
+import java.util.Vector;
+
+/**
+ * ExpandableListAdapter which separates data into categories based on date.  Copied from
+ * packages/apps/Browser.
+ */
+public class DateSortedExpandableListAdapter implements ExpandableListAdapter {
+    // Array for each of our bins.  Each entry represents how many items are
+    // in that bin.
+    private int mItemMap[];
+    // This is our GroupCount.  We will have at most DateSorter.DAY_COUNT
+    // bins, less if the user has no items in one or more bins.
+    private int mNumberOfBins;
+    private Vector<DataSetObserver> mObservers;
+    private Cursor mCursor;
+    private DateSorter mDateSorter;
+    private int mDateIndex;
+    private int mIdIndex;
+    private Context mContext;
+
+    private class ChangeObserver extends ContentObserver {
+        public ChangeObserver() {
+            super(new Handler());
+        }
+
+        @Override
+        public boolean deliverSelfNotifications() {
+            return true;
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            refreshData();
+        }
+    }
+
+    public DateSortedExpandableListAdapter(Context context, Cursor cursor,
+            int dateIndex) {
+        mContext = context;
+        mDateSorter = new DateSorter(context);
+        mObservers = new Vector<DataSetObserver>();
+        mCursor = cursor;
+        mIdIndex = cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_ID);
+        cursor.registerContentObserver(new ChangeObserver());
+        mDateIndex = dateIndex;
+        buildMap();
+    }
+
+    /**
+     * Set up the bins for determining which items belong to which groups.
+     */
+    private void buildMap() {
+        // The cursor is sorted by date
+        // The ItemMap will store the number of items in each bin.
+        int array[] = new int[DateSorter.DAY_COUNT];
+        // Zero out the array.
+        for (int j = 0; j < DateSorter.DAY_COUNT; j++) {
+            array[j] = 0;
+        }
+        mNumberOfBins = 0;
+        int dateIndex = -1;
+        if (mCursor.moveToFirst() && mCursor.getCount() > 0) {
+            while (!mCursor.isAfterLast()) {
+                long date = getLong(mDateIndex);
+                int index = mDateSorter.getIndex(date);
+                if (index > dateIndex) {
+                    mNumberOfBins++;
+                    if (index == DateSorter.DAY_COUNT - 1) {
+                        // We are already in the last bin, so it will
+                        // include all the remaining items
+                        array[index] = mCursor.getCount()
+                                - mCursor.getPosition();
+                        break;
+                    }
+                    dateIndex = index;
+                }
+                array[dateIndex]++;
+                mCursor.moveToNext();
+            }
+        }
+        mItemMap = array;
+    }
+
+    /**
+     * Get the byte array at cursorIndex from the Cursor.  Assumes the Cursor
+     * has already been moved to the correct position.  Along with
+     * {@link #getInt} and {@link #getString}, these are provided so the client
+     * does not need to access the Cursor directly
+     * @param cursorIndex Index to query the Cursor.
+     * @return corresponding byte array from the Cursor.
+     */
+    /* package */ byte[] getBlob(int cursorIndex) {
+        return mCursor.getBlob(cursorIndex);
+    }
+
+    /* package */ Context getContext() {
+        return mContext;
+    }
+
+    /**
+     * Get the integer at cursorIndex from the Cursor.  Assumes the Cursor has
+     * already been moved to the correct position.  Along with
+     * {@link #getBlob} and {@link #getString}, these are provided so the client
+     * does not need to access the Cursor directly
+     * @param cursorIndex Index to query the Cursor.
+     * @return corresponding integer from the Cursor.
+     */
+    /* package */ int getInt(int cursorIndex) {
+        return mCursor.getInt(cursorIndex);
+    }
+
+    /**
+     * Get the long at cursorIndex from the Cursor.  Assumes the Cursor has
+     * already been moved to the correct position.
+     */
+    /* package */ long getLong(int cursorIndex) {
+        return mCursor.getLong(cursorIndex);
+    }
+
+    /**
+     * Get the String at cursorIndex from the Cursor.  Assumes the Cursor has
+     * already been moved to the correct position.  Along with
+     * {@link #getInt} and {@link #getInt}, these are provided so the client
+     * does not need to access the Cursor directly
+     * @param cursorIndex Index to query the Cursor.
+     * @return corresponding String from the Cursor.
+     */
+    /* package */ String getString(int cursorIndex) {
+        return mCursor.getString(cursorIndex);
+    }
+
+    /**
+     * Determine which group an item belongs to.
+     * @param childId ID of the child view in question.
+     * @return int Group position of the containing group.
+    /* package */ int groupFromChildId(long childId) {
+        int group = -1;
+        for (mCursor.moveToFirst(); !mCursor.isAfterLast();
+                mCursor.moveToNext()) {
+            if (getLong(mIdIndex) == childId) {
+                int bin = mDateSorter.getIndex(getLong(mDateIndex));
+                // bin is the same as the group if the number of bins is the
+                // same as DateSorter
+                if (DateSorter.DAY_COUNT == mNumberOfBins) return bin;
+                // There are some empty bins.  Find the corresponding group.
+                group = 0;
+                for (int i = 0; i < bin; i++) {
+                    if (mItemMap[i] != 0) group++;
+                }
+                break;
+            }
+        }
+        return group;
+    }
+
+    /**
+     * Translates from a group position in the ExpandableList to a bin.  This is
+     * necessary because some groups have no history items, so we do not include
+     * those in the ExpandableList.
+     * @param groupPosition Position in the ExpandableList's set of groups
+     * @return The corresponding bin that holds that group.
+     */
+    private int groupPositionToBin(int groupPosition) {
+        if (groupPosition < 0 || groupPosition >= DateSorter.DAY_COUNT) {
+            throw new AssertionError("group position out of range");
+        }
+        if (DateSorter.DAY_COUNT == mNumberOfBins || 0 == mNumberOfBins) {
+            // In the first case, we have exactly the same number of bins
+            // as our maximum possible, so there is no need to do a
+            // conversion
+            // The second statement is in case this method gets called when
+            // the array is empty, in which case the provided groupPosition
+            // will do fine.
+            return groupPosition;
+        }
+        int arrayPosition = -1;
+        while (groupPosition > -1) {
+            arrayPosition++;
+            if (mItemMap[arrayPosition] != 0) {
+                groupPosition--;
+            }
+        }
+        return arrayPosition;
+    }
+
+    /**
+     * Move the cursor to the position indicated.
+     * @param packedPosition Position in packed position representation.
+     * @return True on success, false otherwise.
+     */
+    boolean moveCursorToPackedChildPosition(long packedPosition) {
+        if (ExpandableListView.getPackedPositionType(packedPosition) !=
+                ExpandableListView.PACKED_POSITION_TYPE_CHILD) {
+            return false;
+        }
+        int groupPosition = ExpandableListView.getPackedPositionGroup(
+                packedPosition);
+        int childPosition = ExpandableListView.getPackedPositionChild(
+                packedPosition);
+        return moveCursorToChildPosition(groupPosition, childPosition);
+    }
+
+    /**
+     * Move the cursor the the position indicated.
+     * @param groupPosition Index of the group containing the desired item.
+     * @param childPosition Index of the item within the specified group.
+     * @return boolean False if the cursor is closed, so the Cursor was not
+     *      moved.  True on success.
+     */
+    /* package */ boolean moveCursorToChildPosition(int groupPosition,
+            int childPosition) {
+        if (mCursor.isClosed()) return false;
+        groupPosition = groupPositionToBin(groupPosition);
+        int index = childPosition;
+        for (int i = 0; i < groupPosition; i++) {
+            index += mItemMap[i];
+        }
+        return mCursor.moveToPosition(index);
+    }
+
+    /* package */ void refreshData() {
+        if (mCursor.isClosed()) {
+            return;
+        }
+        mCursor.requery();
+        buildMap();
+        for (DataSetObserver o : mObservers) {
+            o.onChanged();
+        }
+    }
+
+    public View getGroupView(int groupPosition, boolean isExpanded,
+            View convertView, ViewGroup parent) {
+        TextView item;
+        if (null == convertView || !(convertView instanceof TextView)) {
+            LayoutInflater factory = LayoutInflater.from(mContext);
+            item = (TextView) factory.inflate(R.layout.list_group_header, null);
+        } else {
+            item = (TextView) convertView;
+        }
+        String label = mDateSorter.getLabel(groupPositionToBin(groupPosition));
+        item.setText(label);
+        return item;
+    }
+
+    public View getChildView(int groupPosition, int childPosition,
+            boolean isLastChild, View convertView, ViewGroup parent) {
+        return null;
+    }
+
+    public boolean areAllItemsEnabled() {
+        return true;
+    }
+
+    public boolean isChildSelectable(int groupPosition, int childPosition) {
+        return true;
+    }
+
+    public int getGroupCount() {
+        return mNumberOfBins;
+    }
+
+    public int getChildrenCount(int groupPosition) {
+        return mItemMap[groupPositionToBin(groupPosition)];
+    }
+
+    public Object getGroup(int groupPosition) {
+        return null;
+    }
+
+    public Object getChild(int groupPosition, int childPosition) {
+        return null;
+    }
+
+    public long getGroupId(int groupPosition) {
+        return groupPosition;
+    }
+
+    public long getChildId(int groupPosition, int childPosition) {
+        if (moveCursorToChildPosition(groupPosition, childPosition)) {
+            return getLong(mIdIndex);
+        }
+        return 0;
+    }
+
+    public boolean hasStableIds() {
+        return true;
+    }
+
+    public void registerDataSetObserver(DataSetObserver observer) {
+        mObservers.add(observer);
+    }
+
+    public void unregisterDataSetObserver(DataSetObserver observer) {
+        mObservers.remove(observer);
+    }
+
+    public void onGroupExpanded(int groupPosition) {
+    }
+
+    public void onGroupCollapsed(int groupPosition) {
+    }
+
+    public long getCombinedChildId(long groupId, long childId) {
+        return childId;
+    }
+
+    public long getCombinedGroupId(long groupId) {
+        return groupId;
+    }
+
+    public boolean isEmpty() {
+        return mCursor.isClosed() || mCursor.getCount() == 0;
+    }
+}