/*
|
* 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.*;
|
|
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 {
|
/**
|
* 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;
|
|
/** Change observer used to have ExpandableListAdapter changes pushed to us */
|
private final DataSetObserver mDataSetObserver = new MyDataSetObserver();
|
|
/**
|
* 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 = 0;
|
|
/** What is its group position in the list of all groups? */
|
int groupPos = 0;
|
|
/*
|
* 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;
|
}
|
}
|
|
@Override
|
public boolean areAllItemsEnabled() {
|
return mExpandableListAdapter.areAllItemsEnabled();
|
}
|
|
@Override
|
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;
|
}
|
|
@Override
|
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;
|
}
|
|
@Override
|
public int getViewTypeCount() {
|
if( mExpandableListAdapter instanceof HeterogeneousExpandableList ) {
|
HeterogeneousExpandableList adapter = (HeterogeneousExpandableList) mExpandableListAdapter;
|
return adapter.getGroupTypeCount() + adapter.getChildTypeCount();
|
}
|
else {
|
return 2;
|
}
|
}
|
|
@Override
|
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 );
|
}
|
|
@Override
|
public boolean isEmpty() {
|
ExpandableListAdapter adapter = getAdapter();
|
return adapter != null ? adapter.isEmpty() : true;
|
}
|
|
/**
|
* 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;
|
}
|
|
protected class MyDataSetObserver extends DataSetObserver {
|
@Override
|
public void onChanged() {
|
refreshExpGroupMetadataList( true, true );
|
|
notifyDataSetChanged();
|
}
|
|
@Override
|
public void onInvalidated() {
|
refreshExpGroupMetadataList( true, true );
|
|
notifyDataSetInvalidated();
|
}
|
}
|
|
/**
|
* 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> {
|
final static int REFRESH = - 1;
|
|
/** This group's flat list position */
|
int flPos;
|
|
/* firstChildFlPos isn't needed since it's (flPos + 1) */
|
|
/**
|
* 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 );
|
}
|
|
public static final Creator<GroupMetadata> CREATOR = new Creator<GroupMetadata>() {
|
|
public GroupMetadata createFromParcel( Parcel in ) {
|
GroupMetadata gm = GroupMetadata.obtain( in.readInt(), in.readInt(), in.readInt(), in.readLong() );
|
return gm;
|
}
|
|
public GroupMetadata[] newArray( int size ) {
|
return new GroupMetadata[size];
|
}
|
};
|
|
}
|
|
/**
|
* 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;
|
|
private void resetState() {
|
if( position != null ) {
|
position.recycle();
|
position = null;
|
}
|
groupMetadata = null;
|
groupInsertIndex = 0;
|
}
|
|
/**
|
* 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;
|
}
|
|
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;
|
}
|
}
|
}
|
