/*
|
* Copyright (C) 2007 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.basic.security.widget.hlistview;
|
|
import android.database.DataSetObserver;
|
import android.os.Parcel;
|
import android.os.Parcelable;
|
import android.os.SystemClock;
|
import android.view.View;
|
import android.view.ViewGroup;
|
import android.widget.BaseAdapter;
|
import android.widget.ExpandableListAdapter;
|
import android.widget.Filter;
|
import android.widget.Filterable;
|
import android.widget.HeterogeneousExpandableList;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
/*
|
* Implementation notes:
|
*
|
* <p>
|
* Terminology:
|
* <li> flPos - Flat list position, the position used by ListView
|
* <li> gPos - Group position, the position of a group among all the groups
|
* <li> cPos - Child position, the position of a child among all the children
|
* in a group
|
*/
|
|
/**
|
* A {@link android.widget.BaseAdapter} that provides data/Views in an expandable list (offers
|
* features such as collapsing/expanding groups containing children). By
|
* itself, this adapter has no data and is a connector to a
|
* {@link android.widget.ExpandableListAdapter} which provides the data.
|
* <p/>
|
* Internally, this connector translates the flat list position that the
|
* ListAdapter expects to/from group and child positions that the ExpandableListAdapter
|
* expects.
|
*/
|
class ExpandableHListConnector extends BaseAdapter implements Filterable {
|
/**
|
* Change observer used to have ExpandableListAdapter changes pushed to us
|
*/
|
private final DataSetObserver mDataSetObserver = new MyDataSetObserver();
|
/**
|
* The ExpandableListAdapter to fetch the data/Views for this expandable list
|
*/
|
private ExpandableListAdapter mExpandableListAdapter;
|
/**
|
* List of metadata for the currently expanded groups. The metadata consists
|
* of data essential for efficiently translating between flat list positions
|
* and group/child positions. See {@link ExpandableHListConnector.GroupMetadata}.
|
*/
|
private ArrayList<GroupMetadata> mExpGroupMetadataList;
|
/**
|
* The number of children from all currently expanded groups
|
*/
|
private int mTotalExpChildrenCount;
|
/**
|
* The maximum number of allowable expanded groups. Defaults to 'no limit'
|
*/
|
private int mMaxExpGroupCount = Integer.MAX_VALUE;
|
|
/**
|
* Constructs the connector
|
*/
|
public ExpandableHListConnector(ExpandableListAdapter expandableListAdapter) {
|
mExpGroupMetadataList = new ArrayList<GroupMetadata>();
|
setExpandableListAdapter(expandableListAdapter);
|
}
|
|
/**
|
* Point to the {@link android.widget.ExpandableListAdapter} that will give us data/Views
|
*
|
* @param expandableListAdapter the adapter that supplies us with data/Views
|
*/
|
public void setExpandableListAdapter(ExpandableListAdapter expandableListAdapter) {
|
if (mExpandableListAdapter != null) {
|
mExpandableListAdapter.unregisterDataSetObserver(mDataSetObserver);
|
}
|
mExpandableListAdapter = expandableListAdapter;
|
expandableListAdapter.registerDataSetObserver(mDataSetObserver);
|
}
|
|
/**
|
* Translates a flat list position to either a) group pos if the specified
|
* flat list position corresponds to a group, or b) child pos if it
|
* corresponds to a child. Performs a binary search on the expanded
|
* groups list to find the flat list pos if it is an exp group, otherwise
|
* finds where the flat list pos fits in between the exp groups.
|
*
|
* @param flPos the flat list position to be translated
|
* @return the group position or child position of the specified flat list
|
* position encompassed in a {@link ExpandableHListConnector.PositionMetadata} object
|
* that contains additional useful info for insertion, etc.
|
*/
|
PositionMetadata getUnflattenedPos(final int flPos) {
|
/* Keep locally since frequent use */
|
final ArrayList<GroupMetadata> egml = mExpGroupMetadataList;
|
final int numExpGroups = egml.size();
|
/* Binary search variables */
|
int leftExpGroupIndex = 0;
|
int rightExpGroupIndex = numExpGroups - 1;
|
int midExpGroupIndex = 0;
|
GroupMetadata midExpGm;
|
if (numExpGroups == 0) {
|
/*
|
* There aren't any expanded groups (hence no visible children
|
* either), so flPos must be a group and its group pos will be the
|
* same as its flPos
|
*/
|
return PositionMetadata.obtain(flPos, ExpandableHListPosition.GROUP, flPos, -1, null, 0);
|
}
|
/*
|
* Binary search over the expanded groups to find either the exact
|
* expanded group (if we're looking for a group) or the group that
|
* contains the child we're looking for. If we are looking for a
|
* collapsed group, we will not have a direct match here, but we will
|
* find the expanded group just before the group we're searching for (so
|
* then we can calculate the group position of the group we're searching
|
* for). If there isn't an expanded group prior to the group being
|
* searched for, then the group being searched for's group position is
|
* the same as the flat list position (since there are no children before
|
* it, and all groups before it are collapsed).
|
*/
|
while (leftExpGroupIndex <= rightExpGroupIndex) {
|
midExpGroupIndex = (rightExpGroupIndex - leftExpGroupIndex) / 2 + leftExpGroupIndex;
|
midExpGm = egml.get(midExpGroupIndex);
|
if (flPos > midExpGm.lastChildFlPos) {
|
/*
|
* The flat list position is after the current middle group's
|
* last child's flat list position, so search right
|
*/
|
leftExpGroupIndex = midExpGroupIndex + 1;
|
} else if (flPos < midExpGm.flPos) {
|
/*
|
* The flat list position is before the current middle group's
|
* flat list position, so search left
|
*/
|
rightExpGroupIndex = midExpGroupIndex - 1;
|
} else if (flPos == midExpGm.flPos) {
|
/*
|
* The flat list position is this middle group's flat list
|
* position, so we've found an exact hit
|
*/
|
return PositionMetadata.obtain(flPos, ExpandableHListPosition.GROUP, midExpGm.gPos, -1, midExpGm, midExpGroupIndex);
|
} else if (flPos <= midExpGm.lastChildFlPos
|
/* && flPos > midGm.flPos as deduced from previous
|
* conditions */) {
|
/* The flat list position is a child of the middle group */
|
/*
|
* Subtract the first child's flat list position from the
|
* specified flat list pos to get the child's position within
|
* the group
|
*/
|
final int childPos = flPos - (midExpGm.flPos + 1);
|
return PositionMetadata.obtain(flPos, ExpandableHListPosition.CHILD, midExpGm.gPos, childPos, midExpGm, midExpGroupIndex);
|
}
|
}
|
/*
|
* If we've reached here, it means the flat list position must be a
|
* group that is not expanded, since otherwise we would have hit it
|
* in the above search.
|
*/
|
/**
|
* If we are to expand this group later, where would it go in the
|
* mExpGroupMetadataList ?
|
*/
|
int insertPosition;
|
/** What is its group position in the list of all groups? */
|
int groupPos;
|
/*
|
* To figure out exact insertion and prior group positions, we need to
|
* determine how we broke out of the binary search. We backtrack
|
* to see this.
|
*/
|
if (leftExpGroupIndex > midExpGroupIndex) {
|
/*
|
* This would occur in the first conditional, so the flat list
|
* insertion position is after the left group. Also, the
|
* leftGroupPos is one more than it should be (since that broke out
|
* of our binary search), so we decrement it.
|
*/
|
final GroupMetadata leftExpGm = egml.get(leftExpGroupIndex - 1);
|
insertPosition = leftExpGroupIndex;
|
/*
|
* Sums the number of groups between the prior exp group and this
|
* one, and then adds it to the prior group's group pos
|
*/
|
groupPos = (flPos - leftExpGm.lastChildFlPos) + leftExpGm.gPos;
|
} else if (rightExpGroupIndex < midExpGroupIndex) {
|
/*
|
* This would occur in the second conditional, so the flat list
|
* insertion position is before the right group. Also, the
|
* rightGroupPos is one less than it should be, so increment it.
|
*/
|
final GroupMetadata rightExpGm = egml.get(++rightExpGroupIndex);
|
insertPosition = rightExpGroupIndex;
|
/*
|
* Subtracts this group's flat list pos from the group after's flat
|
* list position to find out how many groups are in between the two
|
* groups. Then, subtracts that number from the group after's group
|
* pos to get this group's pos.
|
*/
|
groupPos = rightExpGm.gPos - (rightExpGm.flPos - flPos);
|
} else {
|
// TODO: clean exit
|
throw new RuntimeException("Unknown state");
|
}
|
return PositionMetadata.obtain(flPos, ExpandableHListPosition.GROUP, groupPos, -1, null, insertPosition);
|
}
|
|
/**
|
* Translates either a group pos or a child pos (+ group it belongs to) to a
|
* flat list position. If searching for a child and its group is not expanded, this will
|
* return null since the child isn't being shown in the ListView, and hence it has no
|
* position.
|
*
|
* @param pos a {@link ExpandableHListPosition} representing either a group position
|
* or child position
|
* @return the flat list position encompassed in a {@link ExpandableHListConnector.PositionMetadata}
|
* object that contains additional useful info for insertion, etc., or null.
|
*/
|
PositionMetadata getFlattenedPos(final ExpandableHListPosition pos) {
|
final ArrayList<GroupMetadata> egml = mExpGroupMetadataList;
|
final int numExpGroups = egml.size();
|
/* Binary search variables */
|
int leftExpGroupIndex = 0;
|
int rightExpGroupIndex = numExpGroups - 1;
|
int midExpGroupIndex = 0;
|
GroupMetadata midExpGm;
|
if (numExpGroups == 0) {
|
/*
|
* There aren't any expanded groups, so flPos must be a group and
|
* its flPos will be the same as its group pos. The
|
* insert position is 0 (since the list is empty).
|
*/
|
return PositionMetadata.obtain(pos.groupPos, pos.type, pos.groupPos, pos.childPos, null, 0);
|
}
|
/*
|
* Binary search over the expanded groups to find either the exact
|
* expanded group (if we're looking for a group) or the group that
|
* contains the child we're looking for.
|
*/
|
while (leftExpGroupIndex <= rightExpGroupIndex) {
|
midExpGroupIndex = (rightExpGroupIndex - leftExpGroupIndex) / 2 + leftExpGroupIndex;
|
midExpGm = egml.get(midExpGroupIndex);
|
if (pos.groupPos > midExpGm.gPos) {
|
/*
|
* It's after the current middle group, so search right
|
*/
|
leftExpGroupIndex = midExpGroupIndex + 1;
|
} else if (pos.groupPos < midExpGm.gPos) {
|
/*
|
* It's before the current middle group, so search left
|
*/
|
rightExpGroupIndex = midExpGroupIndex - 1;
|
} else if (pos.groupPos == midExpGm.gPos) {
|
/*
|
* It's this middle group, exact hit
|
*/
|
if (pos.type == ExpandableHListPosition.GROUP) {
|
/* If it's a group, give them this matched group's flPos */
|
return PositionMetadata.obtain(midExpGm.flPos, pos.type, pos.groupPos, pos.childPos, midExpGm, midExpGroupIndex);
|
} else if (pos.type == ExpandableHListPosition.CHILD) {
|
/* If it's a child, calculate the flat list pos */
|
return PositionMetadata.obtain(midExpGm.flPos + pos.childPos + 1, pos.type, pos.groupPos, pos.childPos, midExpGm, midExpGroupIndex);
|
} else {
|
return null;
|
}
|
}
|
}
|
/*
|
* If we've reached here, it means there was no match in the expanded
|
* groups, so it must be a collapsed group that they're search for
|
*/
|
if (pos.type != ExpandableHListPosition.GROUP) {
|
/* If it isn't a group, return null */
|
return null;
|
}
|
/*
|
* To figure out exact insertion and prior group positions, we need to
|
* determine how we broke out of the binary search. We backtrack to see
|
* this.
|
*/
|
if (leftExpGroupIndex > midExpGroupIndex) {
|
/*
|
* This would occur in the first conditional, so the flat list
|
* insertion position is after the left group.
|
*
|
* The leftGroupPos is one more than it should be (from the binary
|
* search loop) so we subtract 1 to get the actual left group. Since
|
* the insertion point is AFTER the left group, we keep this +1
|
* value as the insertion point
|
*/
|
final GroupMetadata leftExpGm = egml.get(leftExpGroupIndex - 1);
|
final int flPos = leftExpGm.lastChildFlPos + (pos.groupPos - leftExpGm.gPos);
|
return PositionMetadata.obtain(flPos, pos.type, pos.groupPos, pos.childPos, null, leftExpGroupIndex);
|
} else if (rightExpGroupIndex < midExpGroupIndex) {
|
/*
|
* This would occur in the second conditional, so the flat list
|
* insertion position is before the right group. Also, the
|
* rightGroupPos is one less than it should be (from binary search
|
* loop), so we increment to it.
|
*/
|
final GroupMetadata rightExpGm = egml.get(++rightExpGroupIndex);
|
final int flPos = rightExpGm.flPos - (rightExpGm.gPos - pos.groupPos);
|
return PositionMetadata.obtain(flPos, pos.type, pos.groupPos, pos.childPos, null, rightExpGroupIndex);
|
} else {
|
return null;
|
}
|
}
|
|
public boolean areAllItemsEnabled() {
|
return mExpandableListAdapter.areAllItemsEnabled();
|
}
|
|
public boolean isEnabled(int flatListPos) {
|
final PositionMetadata metadata = getUnflattenedPos(flatListPos);
|
final ExpandableHListPosition pos = metadata.position;
|
boolean retValue;
|
if (pos.type == ExpandableHListPosition.CHILD) {
|
retValue = mExpandableListAdapter.isChildSelectable(pos.groupPos, pos.childPos);
|
} else {
|
// Groups are always selectable
|
retValue = true;
|
}
|
metadata.recycle();
|
return retValue;
|
}
|
|
public int getCount() {
|
/*
|
* Total count for the list view is the number groups plus the
|
* number of children from currently expanded groups (a value we keep
|
* cached in this class)
|
*/
|
return mExpandableListAdapter.getGroupCount() + mTotalExpChildrenCount;
|
}
|
|
public Object getItem(int flatListPos) {
|
final PositionMetadata posMetadata = getUnflattenedPos(flatListPos);
|
Object retValue;
|
if (posMetadata.position.type == ExpandableHListPosition.GROUP) {
|
retValue = mExpandableListAdapter.getGroup(posMetadata.position.groupPos);
|
} else if (posMetadata.position.type == ExpandableHListPosition.CHILD) {
|
retValue = mExpandableListAdapter.getChild(posMetadata.position.groupPos, posMetadata.position.childPos);
|
} else {
|
// TODO: clean exit
|
throw new RuntimeException("Flat list position is of unknown type");
|
}
|
posMetadata.recycle();
|
return retValue;
|
}
|
|
public long getItemId(int flatListPos) {
|
final PositionMetadata posMetadata = getUnflattenedPos(flatListPos);
|
final long groupId = mExpandableListAdapter.getGroupId(posMetadata.position.groupPos);
|
long retValue;
|
if (posMetadata.position.type == ExpandableHListPosition.GROUP) {
|
retValue = mExpandableListAdapter.getCombinedGroupId(groupId);
|
} else if (posMetadata.position.type == ExpandableHListPosition.CHILD) {
|
final long childId = mExpandableListAdapter.getChildId(posMetadata.position.groupPos, posMetadata.position.childPos);
|
retValue = mExpandableListAdapter.getCombinedChildId(groupId, childId);
|
} else {
|
// TODO: clean exit
|
throw new RuntimeException("Flat list position is of unknown type");
|
}
|
posMetadata.recycle();
|
return retValue;
|
}
|
|
public View getView(int flatListPos, View convertView, ViewGroup parent) {
|
final PositionMetadata posMetadata = getUnflattenedPos(flatListPos);
|
View retValue;
|
if (posMetadata.position.type == ExpandableHListPosition.GROUP) {
|
retValue = mExpandableListAdapter.getGroupView(posMetadata.position.groupPos, posMetadata.isExpanded(), convertView, parent);
|
} else if (posMetadata.position.type == ExpandableHListPosition.CHILD) {
|
final boolean isLastChild = posMetadata.groupMetadata.lastChildFlPos == flatListPos;
|
retValue = mExpandableListAdapter.getChildView(posMetadata.position.groupPos, posMetadata.position.childPos, isLastChild, convertView, parent);
|
} else {
|
// TODO: clean exit
|
throw new RuntimeException("Flat list position is of unknown type");
|
}
|
posMetadata.recycle();
|
return retValue;
|
}
|
|
public int getItemViewType(int flatListPos) {
|
final PositionMetadata metadata = getUnflattenedPos(flatListPos);
|
final ExpandableHListPosition pos = metadata.position;
|
int retValue;
|
if (mExpandableListAdapter instanceof HeterogeneousExpandableList) {
|
HeterogeneousExpandableList adapter = (HeterogeneousExpandableList) mExpandableListAdapter;
|
if (pos.type == ExpandableHListPosition.GROUP) {
|
retValue = adapter.getGroupType(pos.groupPos);
|
} else {
|
final int childType = adapter.getChildType(pos.groupPos, pos.childPos);
|
retValue = adapter.getGroupTypeCount() + childType;
|
}
|
} else {
|
if (pos.type == ExpandableHListPosition.GROUP) {
|
retValue = 0;
|
} else {
|
retValue = 1;
|
}
|
}
|
metadata.recycle();
|
return retValue;
|
}
|
|
public int getViewTypeCount() {
|
if (mExpandableListAdapter instanceof HeterogeneousExpandableList) {
|
HeterogeneousExpandableList adapter = (HeterogeneousExpandableList) mExpandableListAdapter;
|
return adapter.getGroupTypeCount() + adapter.getChildTypeCount();
|
} else {
|
return 2;
|
}
|
}
|
|
public boolean hasStableIds() {
|
return mExpandableListAdapter.hasStableIds();
|
}
|
|
/**
|
* Traverses the expanded group metadata list and fills in the flat list
|
* positions.
|
*
|
* @param forceChildrenCountRefresh Forces refreshing of the children count
|
* for all expanded groups.
|
* @param syncGroupPositions Whether to search for the group positions
|
* based on the group IDs. This should only be needed when calling
|
* this from an onChanged callback.
|
*/
|
@SuppressWarnings("unchecked")
|
private void refreshExpGroupMetadataList(
|
boolean forceChildrenCountRefresh, boolean syncGroupPositions) {
|
final ArrayList<GroupMetadata> egml = mExpGroupMetadataList;
|
int egmlSize = egml.size();
|
int curFlPos = 0;
|
/* Update child count as we go through */
|
mTotalExpChildrenCount = 0;
|
if (syncGroupPositions) {
|
// We need to check whether any groups have moved positions
|
boolean positionsChanged = false;
|
for (int i = egmlSize - 1; i >= 0; i--) {
|
GroupMetadata curGm = egml.get(i);
|
int newGPos = findGroupPosition(curGm.gId, curGm.gPos);
|
if (newGPos != curGm.gPos) {
|
if (newGPos == android.widget.AdapterView.INVALID_POSITION) {
|
// Doh, just remove it from the list of expanded groups
|
egml.remove(i);
|
egmlSize--;
|
}
|
curGm.gPos = newGPos;
|
if (!positionsChanged) positionsChanged = true;
|
}
|
}
|
if (positionsChanged) {
|
// At least one group changed positions, so re-sort
|
Collections.sort(egml);
|
}
|
}
|
int gChildrenCount;
|
int lastGPos = 0;
|
for (int i = 0; i < egmlSize; i++) {
|
/* Store in local variable since we'll access freq */
|
GroupMetadata curGm = egml.get(i);
|
/*
|
* Get the number of children, try to refrain from calling
|
* another class's method unless we have to (so do a subtraction)
|
*/
|
if ((curGm.lastChildFlPos == GroupMetadata.REFRESH) || forceChildrenCountRefresh) {
|
gChildrenCount = mExpandableListAdapter.getChildrenCount(curGm.gPos);
|
} else {
|
/* Num children for this group is its last child's fl pos minus
|
* the group's fl pos
|
*/
|
gChildrenCount = curGm.lastChildFlPos - curGm.flPos;
|
}
|
/* Update */
|
mTotalExpChildrenCount += gChildrenCount;
|
/*
|
* This skips the collapsed groups and increments the flat list
|
* position (for subsequent exp groups) by accounting for the collapsed
|
* groups
|
*/
|
curFlPos += (curGm.gPos - lastGPos);
|
lastGPos = curGm.gPos;
|
/* Update the flat list positions, and the current flat list pos */
|
curGm.flPos = curFlPos;
|
curFlPos += gChildrenCount;
|
curGm.lastChildFlPos = curFlPos;
|
}
|
}
|
|
/**
|
* Collapse a group in the grouped list view
|
*
|
* @param groupPos position of the group to collapse
|
*/
|
boolean collapseGroup(int groupPos) {
|
ExpandableHListPosition elGroupPos = ExpandableHListPosition.obtain(ExpandableHListPosition.GROUP, groupPos, -1, -1);
|
PositionMetadata pm = getFlattenedPos(elGroupPos);
|
elGroupPos.recycle();
|
if (pm == null) return false;
|
boolean retValue = collapseGroup(pm);
|
pm.recycle();
|
return retValue;
|
}
|
|
boolean collapseGroup(PositionMetadata posMetadata) {
|
/*
|
* Collapsing requires removal from mExpGroupMetadataList
|
*/
|
/*
|
* If it is null, it must be already collapsed. This group metadata
|
* object should have been set from the search that returned the
|
* position metadata object.
|
*/
|
if (posMetadata.groupMetadata == null) return false;
|
// Remove the group from the list of expanded groups
|
mExpGroupMetadataList.remove(posMetadata.groupMetadata);
|
// Refresh the metadata
|
refreshExpGroupMetadataList(false, false);
|
// Notify of change
|
notifyDataSetChanged();
|
// Give the callback
|
mExpandableListAdapter.onGroupCollapsed(posMetadata.groupMetadata.gPos);
|
return true;
|
}
|
|
/**
|
* Expand a group in the grouped list view
|
*
|
* @param groupPos the group to be expanded
|
*/
|
boolean expandGroup(int groupPos) {
|
ExpandableHListPosition elGroupPos = ExpandableHListPosition.obtain(ExpandableHListPosition.GROUP, groupPos, -1, -1);
|
PositionMetadata pm = getFlattenedPos(elGroupPos);
|
elGroupPos.recycle();
|
boolean retValue = expandGroup(pm);
|
pm.recycle();
|
return retValue;
|
}
|
|
boolean expandGroup(PositionMetadata posMetadata) {
|
/*
|
* Expanding requires insertion into the mExpGroupMetadataList
|
*/
|
if (posMetadata.position.groupPos < 0) {
|
// TODO clean exit
|
throw new RuntimeException("Need group");
|
}
|
if (mMaxExpGroupCount == 0) return false;
|
// Check to see if it's already expanded
|
if (posMetadata.groupMetadata != null) return false;
|
/* Restrict number of expanded groups to mMaxExpGroupCount */
|
if (mExpGroupMetadataList.size() >= mMaxExpGroupCount) {
|
/* Collapse a group */
|
// TODO: Collapse something not on the screen instead of the first one?
|
// TODO: Could write overloaded function to take GroupMetadata to collapse
|
GroupMetadata collapsedGm = mExpGroupMetadataList.get(0);
|
int collapsedIndex = mExpGroupMetadataList.indexOf(collapsedGm);
|
collapseGroup(collapsedGm.gPos);
|
/* Decrement index if it is after the group we removed */
|
if (posMetadata.groupInsertIndex > collapsedIndex) {
|
posMetadata.groupInsertIndex--;
|
}
|
}
|
GroupMetadata expandedGm = GroupMetadata.obtain(GroupMetadata.REFRESH,
|
GroupMetadata.REFRESH,
|
posMetadata.position.groupPos,
|
mExpandableListAdapter.getGroupId(posMetadata.position.groupPos));
|
mExpGroupMetadataList.add(posMetadata.groupInsertIndex, expandedGm);
|
// Refresh the metadata
|
refreshExpGroupMetadataList(false, false);
|
// Notify of change
|
notifyDataSetChanged();
|
// Give the callback
|
mExpandableListAdapter.onGroupExpanded(expandedGm.gPos);
|
return true;
|
}
|
|
/**
|
* Whether the given group is currently expanded.
|
*
|
* @param groupPosition The group to check.
|
* @return Whether the group is currently expanded.
|
*/
|
public boolean isGroupExpanded(int groupPosition) {
|
GroupMetadata groupMetadata;
|
for (int i = mExpGroupMetadataList.size() - 1; i >= 0; i--) {
|
groupMetadata = mExpGroupMetadataList.get(i);
|
if (groupMetadata.gPos == groupPosition) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/**
|
* Set the maximum number of groups that can be expanded at any given time
|
*/
|
public void setMaxExpGroupCount(int maxExpGroupCount) {
|
mMaxExpGroupCount = maxExpGroupCount;
|
}
|
|
ExpandableListAdapter getAdapter() {
|
return mExpandableListAdapter;
|
}
|
|
public Filter getFilter() {
|
ExpandableListAdapter adapter = getAdapter();
|
if (adapter instanceof Filterable) {
|
return ((Filterable) adapter).getFilter();
|
} else {
|
return null;
|
}
|
}
|
|
ArrayList<GroupMetadata> getExpandedGroupMetadataList() {
|
return mExpGroupMetadataList;
|
}
|
|
void setExpandedGroupMetadataList(ArrayList<GroupMetadata> expandedGroupMetadataList) {
|
if ((expandedGroupMetadataList == null) || (mExpandableListAdapter == null)) {
|
return;
|
}
|
// Make sure our current data set is big enough for the previously
|
// expanded groups, if not, ignore this request
|
int numGroups = mExpandableListAdapter.getGroupCount();
|
for (int i = expandedGroupMetadataList.size() - 1; i >= 0; i--) {
|
if (expandedGroupMetadataList.get(i).gPos >= numGroups) {
|
// Doh, for some reason the client doesn't have some of the groups
|
return;
|
}
|
}
|
mExpGroupMetadataList = expandedGroupMetadataList;
|
refreshExpGroupMetadataList(true, false);
|
}
|
|
public boolean isEmpty() {
|
ExpandableListAdapter adapter = getAdapter();
|
return adapter == null || adapter.isEmpty();
|
}
|
|
/**
|
* Searches the expandable list adapter for a group position matching the
|
* given group ID. The search starts at the given seed position and then
|
* alternates between moving up and moving down until 1) we find the right
|
* position, or 2) we run out of time, or 3) we have looked at every
|
* position
|
*
|
* @return Position of the row that matches the given row ID, or
|
* {@link android.widget.AdapterView#INVALID_POSITION} if it can't be found
|
* @see AdapterView#findSyncPosition()
|
*/
|
int findGroupPosition(long groupIdToMatch, int seedGroupPosition) {
|
int count = mExpandableListAdapter.getGroupCount();
|
if (count == 0) {
|
return android.widget.AdapterView.INVALID_POSITION;
|
}
|
// If there isn't a selection don't hunt for it
|
if (groupIdToMatch == android.widget.AdapterView.INVALID_ROW_ID) {
|
return android.widget.AdapterView.INVALID_POSITION;
|
}
|
// Pin seed to reasonable values
|
seedGroupPosition = Math.max(0, seedGroupPosition);
|
seedGroupPosition = Math.min(count - 1, seedGroupPosition);
|
long endTime = SystemClock.uptimeMillis() + AdapterView.SYNC_MAX_DURATION_MILLIS;
|
long rowId;
|
// first position scanned so far
|
int first = seedGroupPosition;
|
// last position scanned so far
|
int last = seedGroupPosition;
|
// True if we should move down on the next iteration
|
boolean next = false;
|
// True when we have looked at the first item in the data
|
boolean hitFirst;
|
// True when we have looked at the last item in the data
|
boolean hitLast;
|
// Get the item ID locally (instead of getItemIdAtPosition), so
|
// we need the adapter
|
ExpandableListAdapter adapter = getAdapter();
|
if (adapter == null) {
|
return android.widget.AdapterView.INVALID_POSITION;
|
}
|
while (SystemClock.uptimeMillis() <= endTime) {
|
rowId = adapter.getGroupId(seedGroupPosition);
|
if (rowId == groupIdToMatch) {
|
// Found it!
|
return seedGroupPosition;
|
}
|
hitLast = last == count - 1;
|
hitFirst = first == 0;
|
if (hitLast && hitFirst) {
|
// Looked at everything
|
break;
|
}
|
if (hitFirst || (next && !hitLast)) {
|
// Either we hit the top, or we are trying to move down
|
last++;
|
seedGroupPosition = last;
|
// Try going up next time
|
next = false;
|
} else if (hitLast || (!next && !hitFirst)) {
|
// Either we hit the bottom, or we are trying to move up
|
first--;
|
seedGroupPosition = first;
|
// Try going down next time
|
next = true;
|
}
|
}
|
return android.widget.AdapterView.INVALID_POSITION;
|
}
|
|
/**
|
* Metadata about an expanded group to help convert from a flat list
|
* position to either a) group position for groups, or b) child position for
|
* children
|
*/
|
static class GroupMetadata implements Parcelable, Comparable<GroupMetadata> {
|
public static final Creator<GroupMetadata> CREATOR = new Creator<GroupMetadata>() {
|
public GroupMetadata createFromParcel(Parcel in) {
|
return GroupMetadata.obtain(in.readInt(), in.readInt(), in.readInt(), in.readLong());
|
}
|
|
public GroupMetadata[] newArray(int size) {
|
return new GroupMetadata[size];
|
}
|
};
|
final static int REFRESH = -1;
|
/* firstChildFlPos isn't needed since it's (flPos + 1) */
|
/**
|
* This group's flat list position
|
*/
|
int flPos;
|
/**
|
* This group's last child's flat list position, so basically
|
* the range of this group in the flat list
|
*/
|
int lastChildFlPos;
|
/**
|
* This group's group position
|
*/
|
int gPos;
|
/**
|
* This group's id
|
*/
|
long gId;
|
|
private GroupMetadata() {
|
}
|
|
static GroupMetadata obtain(int flPos, int lastChildFlPos, int gPos, long gId) {
|
GroupMetadata gm = new GroupMetadata();
|
gm.flPos = flPos;
|
gm.lastChildFlPos = lastChildFlPos;
|
gm.gPos = gPos;
|
gm.gId = gId;
|
return gm;
|
}
|
|
public int compareTo(GroupMetadata another) {
|
if (another == null) {
|
throw new IllegalArgumentException();
|
}
|
return gPos - another.gPos;
|
}
|
|
public int describeContents() {
|
return 0;
|
}
|
|
public void writeToParcel(Parcel dest, int flags) {
|
dest.writeInt(flPos);
|
dest.writeInt(lastChildFlPos);
|
dest.writeInt(gPos);
|
dest.writeLong(gId);
|
}
|
}
|
|
/**
|
* Data type that contains an expandable list position (can refer to either a group
|
* or child) and some extra information regarding referred item (such as
|
* where to insert into the flat list, etc.)
|
*/
|
static public class PositionMetadata {
|
private static final int MAX_POOL_SIZE = 5;
|
private static ArrayList<PositionMetadata> sPool = new ArrayList<PositionMetadata>(MAX_POOL_SIZE);
|
/**
|
* Data type to hold the position and its type (child/group)
|
*/
|
public ExpandableHListPosition position;
|
/**
|
* Link back to the expanded GroupMetadata for this group. Useful for
|
* removing the group from the list of expanded groups inside the
|
* connector when we collapse the group, and also as a check to see if
|
* the group was expanded or collapsed (this will be null if the group
|
* is collapsed since we don't keep that group's metadata)
|
*/
|
public GroupMetadata groupMetadata;
|
/**
|
* For groups that are collapsed, we use this as the index (in
|
* mExpGroupMetadataList) to insert this group when we are expanding
|
* this group.
|
*/
|
public int groupInsertIndex;
|
|
/**
|
* Use {@link #obtain(int, int, int, int, ExpandableHListConnector.GroupMetadata, int)}
|
*/
|
private PositionMetadata() {
|
}
|
|
static PositionMetadata obtain(
|
int flatListPos, int type, int groupPos, int childPos, GroupMetadata groupMetadata, int groupInsertIndex) {
|
PositionMetadata pm = getRecycledOrCreate();
|
pm.position = ExpandableHListPosition.obtain(type, groupPos, childPos, flatListPos);
|
pm.groupMetadata = groupMetadata;
|
pm.groupInsertIndex = groupInsertIndex;
|
return pm;
|
}
|
|
private static PositionMetadata getRecycledOrCreate() {
|
PositionMetadata pm;
|
synchronized (sPool) {
|
if (sPool.size() > 0) {
|
pm = sPool.remove(0);
|
} else {
|
return new PositionMetadata();
|
}
|
}
|
pm.resetState();
|
return pm;
|
}
|
|
private void resetState() {
|
if (position != null) {
|
position.recycle();
|
position = null;
|
}
|
groupMetadata = null;
|
groupInsertIndex = 0;
|
}
|
|
public void recycle() {
|
resetState();
|
synchronized (sPool) {
|
if (sPool.size() < MAX_POOL_SIZE) {
|
sPool.add(this);
|
}
|
}
|
}
|
|
/**
|
* Checks whether the group referred to in this object is expanded,
|
* or not (at the time this object was created)
|
*
|
* @return whether the group at groupPos is expanded or not
|
*/
|
public boolean isExpanded() {
|
return groupMetadata != null;
|
}
|
}
|
|
protected class MyDataSetObserver extends DataSetObserver {
|
public void onChanged() {
|
refreshExpGroupMetadataList(true, true);
|
notifyDataSetChanged();
|
}
|
|
public void onInvalidated() {
|
refreshExpGroupMetadataList(true, true);
|
notifyDataSetInvalidated();
|
}
|
}
|
}
|
