/*
 * Copyright (C) 2006 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.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.Gravity;
import android.view.SoundEffectConstants;
import android.view.View;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityNodeInfo;
import android.widget.ExpandableListAdapter;
import android.widget.ListAdapter;

import com.basic.security.utils.RUtils;

import java.util.ArrayList;

/**
 * A view that shows items in a vertically scrolling two-level list. This
 * differs from the {@link HListView} by allowing two levels: groups which can
 * individually be expanded to show its children. The items come from the
 * {@link android.widget.ExpandableListAdapter} associated with this view.
 * <p/>
 * Expandable lists are able to show an indicator beside each item to display
 * the item's current state (the states are usually one of expanded group,
 * collapsed group, child, or last child). Use
 * {@link #setChildIndicator(Drawable)} or {@link #setGroupIndicator(Drawable)}
 * (or the corresponding XML attributes) to set these indicators (see the docs
 * for each method to see additional state that each Drawable can have). The
 * default style for an {@link ExpandableHListView} provides indicators which
 * will be shown next to Views given to the {@link ExpandableHListView}. The
 * layouts android.com.basic.security.utils.ResolutionAdaptation.simple_expandable_list_item_1 and
 * android.com.basic.security.utils.ResolutionAdaptation.simple_expandable_list_item_2 (which should be used with
 * {@link android.widget.SimpleCursorTreeAdapter}) contain the preferred position information
 * for indicators.
 * <p/>
 * The context menu information set by an {@link ExpandableHListView} will be a
 * {@link ExpandableListContextMenuInfo} object with
 * {@link ExpandableListContextMenuInfo#packedPosition} being a packed position
 * that can be used with {@link #getPackedPositionType(long)} and the other
 * similar methods.
 * <p/>
 * <em><b>Note:</b></em> You cannot use the value <code>wrap_content</code>
 * for the <code>android:layout_height</code> attribute of a
 * ExpandableListView in XML if the parent's size is also not strictly specified
 * (for example, if the parent were ScrollView you could not specify
 * wrap_content since it also can be any length. However, you can use
 * wrap_content if the ExpandableListView parent has a specific size, such as
 * 100 pixels.
 *
 * @attr ref android.R.styleable#ExpandableListView_groupIndicator
 * @attr ref android.R.styleable#ExpandableListView_indicatorLeft
 * @attr ref android.R.styleable#ExpandableListView_indicatorRight
 * @attr ref android.R.styleable#ExpandableListView_childIndicator
 * @attr ref android.R.styleable#ExpandableListView_childIndicatorLeft
 * @attr ref android.R.styleable#ExpandableListView_childIndicatorRight
 * @attr ref android.R.styleable#ExpandableListView_childDivider
 * @attr ref android.R.styleable#ExpandableListView_indicatorStart
 * @attr ref android.R.styleable#ExpandableListView_indicatorEnd
 * @attr ref android.R.styleable#ExpandableListView_childIndicatorStart
 * @attr ref android.R.styleable#ExpandableListView_childIndicatorEnd
 */
public class ExpandableHListView extends HListView {
    /**
     * The packed position represents a group.
     */
    public static final int PACKED_POSITION_TYPE_GROUP = 0;
    /**
     * The packed position represents a child.
     */
    public static final int PACKED_POSITION_TYPE_CHILD = 1;
    /**
     * The packed position represents a neither/null/no preference.
     */
    public static final int PACKED_POSITION_TYPE_NULL = 2;
    /**
     * The value for a packed position that represents neither/null/no
     * preference. This value is not otherwise possible since a group type
     * (first bit 0) should not have a child position filled.
     */
    public static final long PACKED_POSITION_VALUE_NULL = 0x00000000FFFFFFFFL;
    /**
     * Denotes when a child indicator should inherit this bound from the generic
     * indicator bounds
     */
    public static final int CHILD_INDICATOR_INHERIT = -1;
    /**
     * The mask (in packed position representation) for the child
     */
    private static final long PACKED_POSITION_MASK_CHILD = 0x00000000FFFFFFFFL;
    /**
     * The mask (in packed position representation) for the group
     */
    private static final long PACKED_POSITION_MASK_GROUP = 0x7FFFFFFF00000000L;
    /**
     * The mask (in packed position representation) for the type
     */
    private static final long PACKED_POSITION_MASK_TYPE = 0x8000000000000000L;
    /**
     * The shift amount (in packed position representation) for the group
     */
    private static final long PACKED_POSITION_SHIFT_GROUP = 32;
    /**
     * The shift amount (in packed position representation) for the type
     */
    private static final long PACKED_POSITION_SHIFT_TYPE = 63;
    /**
     * The mask (in integer child position representation) for the child
     */
    private static final long PACKED_POSITION_INT_MASK_CHILD = 0xFFFFFFFF;
    /**
     * The mask (in integer group position representation) for the group
     */
    private static final long PACKED_POSITION_INT_MASK_GROUP = 0x7FFFFFFF;
    /**
     * Denotes an undefined value for an indicator
     */
    private static final int INDICATOR_UNDEFINED = -2;
    private static final int[] EMPTY_STATE_SET = {};
    /**
     * State indicating the group is expanded.
     */
    private static final int[] GROUP_EXPANDED_STATE_SET = {android.R.attr.state_expanded};
    /**
     * State indicating the group is empty (has no children).
     */
    private static final int[] GROUP_EMPTY_STATE_SET = {android.R.attr.state_empty};
    /**
     * State indicating the group is expanded and empty (has no children).
     */
    private static final int[] GROUP_EXPANDED_EMPTY_STATE_SET = {android.R.attr.state_expanded, android.R.attr.state_empty};
    /**
     * States for the group where the 0th bit is expanded and 1st bit is empty.
     */
    private static final int[][] GROUP_STATE_SETS = {EMPTY_STATE_SET, // 00
            GROUP_EXPANDED_STATE_SET, // 01
            GROUP_EMPTY_STATE_SET, // 10
            GROUP_EXPANDED_EMPTY_STATE_SET // 11
    };
    /**
     * State indicating the child is the last within its group.
     */
    private static final int[] CHILD_LAST_STATE_SET = {android.R.attr.state_last};
    // Bounds of the indicator to be drawn
    private final Rect mIndicatorRect = new Rect();
    private final Rect mTempRect = new Rect();
    /**
     * Serves as the glue/translator between a ListView and an ExpandableListView
     */
    private ExpandableHListConnector mConnector;
    /**
     * Gives us Views through group+child positions
     */
    private ExpandableListAdapter mAdapter;
    /**
     * Left bound for drawing the indicator.
     */
    private int mIndicatorTop;
    /**
     * Right bound for drawing the indicator.
     */
    private int mIndicatorLeft;
    /**
     * Group indicator gravity
     */
    private int mIndicatorGravity;
    /**
     * Child indicator gravity
     */
    private int mChildIndicatorGravity;
    private int mChildIndicatorTop;
    private int mChildIndicatorLeft;
    /**
     * The indicator drawn next to a group.
     */
    private Drawable mGroupIndicator;
    /**
     * The indicator drawn next to a child.
     */
    private Drawable mChildIndicator;
    /**
     * Drawable to be used as a divider when it is adjacent to any children
     */
    private Drawable mChildDivider;
    private int mGroupIndicatorWidth;
    private int mGroupIndicatorHeight;
    private int mChildIndicatorWidth;
    private int mChildIndicatorHeight;
    private OnGroupCollapseListener mOnGroupCollapseListener;
    private OnGroupExpandListener mOnGroupExpandListener;
    private OnGroupClickListener mOnGroupClickListener;
    private OnChildClickListener mOnChildClickListener;

    public ExpandableHListView(Context context) {
        this(context, null);
    }

    public ExpandableHListView(Context context, AttributeSet attrs) {
        this(context, attrs, RUtils.R_attr_hlv_expandableListViewStyle);
    }

    public ExpandableHListView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        TypedArray a = context.obtainStyledAttributes(attrs, com.basic.security.utils.RUtils.R_styleable_ExpandableHListView, defStyle, 0);
        setGroupIndicator(a.getDrawable(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_groupIndicator));
        setChildIndicator(a.getDrawable(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_childIndicator));
        mIndicatorLeft = a.getDimensionPixelSize(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_indicatorPaddingLeft, 0);
        mIndicatorTop = a.getDimensionPixelSize(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_indicatorPaddingTop, 0);
        mIndicatorGravity = a.getInt(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_indicatorGravity, Gravity.NO_GRAVITY);
        mChildIndicatorGravity = a.getInt(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_childIndicatorGravity, Gravity.NO_GRAVITY);
        mChildIndicatorLeft = a.getDimensionPixelSize(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_childIndicatorPaddingLeft, 0);
        mChildIndicatorTop = a.getDimensionPixelSize(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_childIndicatorPaddingTop, 0);
        mChildDivider = a.getDrawable(com.basic.security.utils.RUtils.R_styleable_ExpandableHListView_hlv_childDivider);
        a.recycle();
    }

    /**
     * Gets the type of a packed position. See
     * {@link #getPackedPositionForChild(int, int)}.
     *
     * @param packedPosition The packed position for which to return the type.
     * @return The type of the position contained within the packed position,
     * either {@link #PACKED_POSITION_TYPE_CHILD}, {@link #PACKED_POSITION_TYPE_GROUP}, or
     * {@link #PACKED_POSITION_TYPE_NULL}.
     */
    public static int getPackedPositionType(long packedPosition) {
        if (packedPosition == PACKED_POSITION_VALUE_NULL) {
            return PACKED_POSITION_TYPE_NULL;
        }
        return (packedPosition & PACKED_POSITION_MASK_TYPE) == PACKED_POSITION_MASK_TYPE ? PACKED_POSITION_TYPE_CHILD : PACKED_POSITION_TYPE_GROUP;
    }

    /**
     * Gets the group position from a packed position. See
     * {@link #getPackedPositionForChild(int, int)}.
     *
     * @param packedPosition The packed position from which the group position
     *                       will be returned.
     * @return The group position portion of the packed position. If this does
     * not contain a group, returns -1.
     */
    public static int getPackedPositionGroup(long packedPosition) {
        // Null
        if (packedPosition == PACKED_POSITION_VALUE_NULL) return -1;
        return (int) ((packedPosition & PACKED_POSITION_MASK_GROUP) >> PACKED_POSITION_SHIFT_GROUP);
    }

    /**
     * Gets the child position from a packed position that is of
     * {@link #PACKED_POSITION_TYPE_CHILD} type (use {@link #getPackedPositionType(long)}).
     * To get the group that this child belongs to, use
     * {@link #getPackedPositionGroup(long)}. See
     * {@link #getPackedPositionForChild(int, int)}.
     *
     * @param packedPosition The packed position from which the child position
     *                       will be returned.
     * @return The child position portion of the packed position. If this does
     * not contain a child, returns -1.
     */
    public static int getPackedPositionChild(long packedPosition) {
        // Null
        if (packedPosition == PACKED_POSITION_VALUE_NULL) return -1;
        // Group since a group type clears this bit
        if ((packedPosition & PACKED_POSITION_MASK_TYPE) != PACKED_POSITION_MASK_TYPE) return -1;
        return (int) (packedPosition & PACKED_POSITION_MASK_CHILD);
    }

    /**
     * Returns the packed position representation of a child's position.
     * <p/>
     * In general, a packed position should be used in
     * situations where the position given to/returned from an
     * {@link ExpandableListAdapter} or {@link ExpandableHListView} method can
     * either be a child or group. The two positions are packed into a single
     * long which can be unpacked using
     * {@link #getPackedPositionChild(long)},
     * {@link #getPackedPositionGroup(long)}, and
     * {@link #getPackedPositionType(long)}.
     *
     * @param groupPosition The child's parent group's position.
     * @param childPosition The child position within the group.
     * @return The packed position representation of the child (and parent group).
     */
    public static long getPackedPositionForChild(int groupPosition, int childPosition) {
        return (((long) PACKED_POSITION_TYPE_CHILD) << PACKED_POSITION_SHIFT_TYPE) |
                ((((long) groupPosition) & PACKED_POSITION_INT_MASK_GROUP) << PACKED_POSITION_SHIFT_GROUP) | (childPosition & PACKED_POSITION_INT_MASK_CHILD);
    }

    /**
     * Returns the packed position representation of a group's position. See
     * {@link #getPackedPositionForChild(int, int)}.
     *
     * @param groupPosition The child's parent group's position.
     * @return The packed position representation of the group.
     */
    public static long getPackedPositionForGroup(int groupPosition) {
        // No need to OR a type in because PACKED_POSITION_GROUP == 0
        return ((((long) groupPosition) & PACKED_POSITION_INT_MASK_GROUP) << PACKED_POSITION_SHIFT_GROUP);
    }

    public void onRtlPropertiesChanged(int layoutDirection) {
        resolveIndicator();
        resolveChildIndicator();
    }

    /**
     * Resolve start/end indicator. start/end indicator always takes precedence over left/right
     * indicator when defined.
     */
    private void resolveIndicator() {
        if (null != mGroupIndicator) {
            mGroupIndicatorWidth = mGroupIndicator.getIntrinsicWidth();
            mGroupIndicatorHeight = mGroupIndicator.getIntrinsicHeight();
        } else {
            mGroupIndicatorWidth = 0;
            mGroupIndicatorHeight = 0;
        }
    }

    /**
     * Resolve start/end child indicator. start/end child indicator always takes precedence over
     * left/right child indicator when defined.
     */
    private void resolveChildIndicator() {
        if (null != mChildIndicator) {
            mChildIndicatorWidth = mChildIndicator.getIntrinsicWidth();
            mChildIndicatorHeight = mChildIndicator.getIntrinsicHeight();
        } else {
            mChildIndicatorWidth = 0;
            mChildIndicatorHeight = 0;
        }
    }

    protected void dispatchDraw(Canvas canvas) {
        // Draw children, etc.
        super.dispatchDraw(canvas);
        // If we have any indicators to draw, we do it here
        if ((mChildIndicator == null) && (mGroupIndicator == null)) {
            return;
        }
        int saveCount = 0;
        final int headerViewsCount = getHeaderViewsCount();
        final int lastChildFlPos = mItemCount - getFooterViewsCount() - headerViewsCount - 1;
        final int myRight = getRight();
        ExpandableHListConnector.PositionMetadata pos;
        View item;
        Drawable indicator;
        int left, right;
        // Start at a value that is neither child nor group
        int lastItemType = ~(ExpandableHListPosition.CHILD | ExpandableHListPosition.GROUP);
        final Rect indicatorRect = mIndicatorRect;
        // The "child" mentioned in the following two lines is this
        // View's child, not referring to an expandable list's
        // notion of a child (as opposed to a group)
        final int childCount = getChildCount();
        for (int i = 0, childFlPos = mFirstPosition - headerViewsCount; i < childCount; i++, childFlPos++) {
            if (childFlPos < 0) {
                // This child is header
                continue;
            } else if (childFlPos > lastChildFlPos) {
                // This child is footer, so are all subsequent children
                break;
            }
            item = getChildAt(i);
            left = item.getLeft();
            right = item.getRight();
            // This item isn't on the screen
            if ((right < 0) || (left > myRight)) continue;
            // Get more expandable list-related info for this item
            pos = mConnector.getUnflattenedPos(childFlPos);
            // If this item type and the previous item type are different, then we need to change
            // the left & right bounds
            if (pos.position.type != lastItemType) {
                if (pos.position.type == ExpandableHListPosition.CHILD) {
                    indicatorRect.top = item.getTop() + mChildIndicatorTop;
                    indicatorRect.bottom = item.getBottom() + mChildIndicatorTop;
                } else {
                    indicatorRect.top = item.getTop() + mIndicatorTop;
                    indicatorRect.bottom = item.getBottom() + mIndicatorTop;
                }
                lastItemType = pos.position.type;
            }
            if (indicatorRect.top != indicatorRect.bottom) {
                if (pos.position.type == ExpandableHListPosition.CHILD) {
                    indicatorRect.left = left + mChildIndicatorLeft;
                    indicatorRect.right = right + mChildIndicatorLeft;
                } else {
                    indicatorRect.left = left + mIndicatorLeft;
                    indicatorRect.right = right + mIndicatorLeft;
                }
                // Get the indicator (with its state set to the item's state)
                indicator = getIndicator(pos);
                if (indicator != null) {
                    if (pos.position.type == ExpandableHListPosition.CHILD) {
                        Gravity.apply(mChildIndicatorGravity, mChildIndicatorWidth, mChildIndicatorHeight, indicatorRect, mTempRect);
                    } else {
                        Gravity.apply(mIndicatorGravity, mGroupIndicatorWidth, mGroupIndicatorHeight, indicatorRect, mTempRect);
                    }
                    // Draw the indicator
                    indicator.setBounds(mTempRect);
                    indicator.draw(canvas);
                }
            }
            pos.recycle();
        }
    }

    /**
     * Gets the indicator for the item at the given position. If the indicator
     * is stateful, the state will be given to the indicator.
     *
     * @param pos The flat list position of the item whose indicator
     *            should be returned.
     * @return The indicator in the proper state.
     */
    private Drawable getIndicator(ExpandableHListConnector.PositionMetadata pos) {
        Drawable indicator;
        if (pos.position.type == ExpandableHListPosition.GROUP) {
            indicator = mGroupIndicator;
            if (indicator != null && indicator.isStateful()) {
                // Empty check based on availability of data.  If the groupMetadata isn't null,
                // we do a check on it. Otherwise, the group is collapsed so we consider it
                // empty for performance reasons.
                boolean isEmpty = (pos.groupMetadata == null) || (pos.groupMetadata.lastChildFlPos == pos.groupMetadata.flPos);
                final int stateSetIndex = (pos.isExpanded() ? 1 : 0) | // Expanded?
                        (isEmpty ? 2 : 0); // Empty?
                indicator.setState(GROUP_STATE_SETS[stateSetIndex]);
            }
        } else {
            indicator = mChildIndicator;
            if (indicator != null && indicator.isStateful()) {
                // No need for a state sets array for the child since it only has two states
                final int stateSet[] = pos.position.flatListPos == pos.groupMetadata.lastChildFlPos ? CHILD_LAST_STATE_SET : EMPTY_STATE_SET;
                indicator.setState(stateSet);
            }
        }
        return indicator;
    }

    /**
     * Sets the drawable that will be drawn adjacent to every child in the list. This will
     * be drawn using the same height as the normal divider ({@link #setDivider(Drawable)}) or
     * if it does not have an intrinsic height, the height set by {@link #setDividerWidth(int)}.
     *
     * @param childDivider The drawable to use.
     */
    public void setChildDivider(Drawable childDivider) {
        mChildDivider = childDivider;
    }

    void drawDivider(Canvas canvas, Rect bounds, int childIndex) {
        int flatListPosition = childIndex + mFirstPosition;
        // Only proceed as possible child if the divider isn't above all items (if it is above
        // all items, then the item below it has to be a group)
        if (flatListPosition >= 0) {
            final int adjustedPosition = getFlatPositionForConnector(flatListPosition);
            ExpandableHListConnector.PositionMetadata pos = mConnector.getUnflattenedPos(adjustedPosition);
            // If this item is a child, or it is a non-empty group that is expanded
            if ((pos.position.type == ExpandableHListPosition.CHILD) || (pos.isExpanded() && pos.groupMetadata.lastChildFlPos != pos.groupMetadata.flPos)) {
                // These are the cases where we draw the child divider
                final Drawable divider = mChildDivider;
                divider.setBounds(bounds);
                divider.draw(canvas);
                pos.recycle();
                return;
            }
            pos.recycle();
        }
        // Otherwise draw the default divider
        super.drawDivider(canvas, bounds, flatListPosition);
    }

    /**
     * This method should not be used, use {@link #getExpandableListAdapter()}.
     */
    public ListAdapter getAdapter() {
        /*
         * The developer should never really call this method on an
         * ExpandableListView, so it would be nice to throw a RuntimeException,
         * but AdapterView calls this
         */
        return super.getAdapter();
    }

    /**
     * Sets the adapter that provides data to this view.
     *
     * @param adapter The adapter that provides data to this view.
     */
    public void setAdapter(ExpandableListAdapter adapter) {
        // Set member variable
        mAdapter = adapter;
        if (adapter != null) {
            // Create the connector
            mConnector = new ExpandableHListConnector(adapter);
        } else {
            mConnector = null;
        }
        // Link the ListView (superclass) to the expandable list data through the connector
        super.setAdapter(mConnector);
    }

    /**
     * This overloaded method should not be used, instead use
     * {@link #setAdapter(ExpandableListAdapter)}.
     * <p/>
     * {@inheritDoc}
     */
    public void setAdapter(ListAdapter adapter) {
        throw new RuntimeException("For ExpandableListView, use setAdapter(ExpandableListAdapter) instead of " + "setAdapter(ListAdapter)");
    }

    /**
     * Register a callback to be invoked when an item has been clicked and the
     * caller prefers to receive a ListView-style position instead of a group
     * and/or child position. In most cases, the caller should use
     * {@link #setOnGroupClickListener} and/or {@link #setOnChildClickListener}.
     * <p/>
     * {@inheritDoc}
     */
    public void setOnItemClickListener(OnItemClickListener l) {
        super.setOnItemClickListener(l);
    }

    /**
     * Gets the adapter that provides data to this view.
     *
     * @return The adapter that provides data to this view.
     */
    public ExpandableListAdapter getExpandableListAdapter() {
        return mAdapter;
    }

    /**
     * @param position An absolute (including header and footer) flat list position.
     * @return true if the position corresponds to a header or a footer item.
     */
    private boolean isHeaderOrFooterPosition(int position) {
        final int footerViewsStart = mItemCount - getFooterViewsCount();
        return (position < getHeaderViewsCount() || position >= footerViewsStart);
    }

    /**
     * Converts an absolute item flat position into a group/child flat position, shifting according
     * to the number of header items.
     *
     * @param flatListPosition The absolute flat position
     * @return A group/child flat position as expected by the connector.
     */
    private int getFlatPositionForConnector(int flatListPosition) {
        return flatListPosition - getHeaderViewsCount();
    }

    /**
     * Converts a group/child flat position into an absolute flat position, that takes into account
     * the possible headers.
     *
     * @param flatListPosition The child/group flat position
     * @return An absolute flat position.
     */
    private int getAbsoluteFlatPosition(int flatListPosition) {
        return flatListPosition + getHeaderViewsCount();
    }

    public boolean performItemClick(View v, int position, long id) {
        // Ignore clicks in header/footers
        if (isHeaderOrFooterPosition(position)) {
            // Clicked on a header/footer, so ignore pass it on to super
            return super.performItemClick(v, position, id);
        }
        // Internally handle the item click
        final int adjustedPosition = getFlatPositionForConnector(position);
        return handleItemClick(v, adjustedPosition, id);
    }

    /**
     * This will either expand/collapse groups (if a group was clicked) or pass
     * on the click to the proper child (if a child was clicked)
     *
     * @param position The flat list position. This has already been factored to
     *                 remove the header/footer.
     * @param id       The ListAdapter ID, not the group or child ID.
     */
    boolean handleItemClick(View v, int position, long id) {
        final ExpandableHListConnector.PositionMetadata posMetadata = mConnector.getUnflattenedPos(position);
        id = getChildOrGroupId(posMetadata.position);
        boolean returnValue;
        if (posMetadata.position.type == ExpandableHListPosition.GROUP) {
            /* It's a group, so handle collapsing/expanding */
            /* It's a group click, so pass on event */
            if (mOnGroupClickListener != null) {
                if (mOnGroupClickListener.onGroupClick(this, v, posMetadata.position.groupPos, id)) {
                    posMetadata.recycle();
                    return true;
                }
            }
            if (posMetadata.isExpanded()) {
                /* Collapse it */
                mConnector.collapseGroup(posMetadata);
                playSoundEffect(SoundEffectConstants.CLICK);
                if (mOnGroupCollapseListener != null) {
                    mOnGroupCollapseListener.onGroupCollapse(posMetadata.position.groupPos);
                }
            } else {
                /* Expand it */
                mConnector.expandGroup(posMetadata);
                playSoundEffect(SoundEffectConstants.CLICK);
                if (mOnGroupExpandListener != null) {
                    mOnGroupExpandListener.onGroupExpand(posMetadata.position.groupPos);
                }
                final int groupPos = posMetadata.position.groupPos;
                final int groupFlatPos = posMetadata.position.flatListPos;
                final int shiftedGroupPosition = groupFlatPos + getHeaderViewsCount();
                smoothScrollToPosition(shiftedGroupPosition + mAdapter.getChildrenCount(groupPos), shiftedGroupPosition);
            }
            returnValue = true;
        } else {
            /* It's a child, so pass on event */
            if (mOnChildClickListener != null) {
                playSoundEffect(SoundEffectConstants.CLICK);
                return mOnChildClickListener.onChildClick(this, v, posMetadata.position.groupPos, posMetadata.position.childPos, id);
            }
            returnValue = false;
        }
        posMetadata.recycle();
        return returnValue;
    }

    /**
     * Expand a group in the grouped list view
     *
     * @param groupPos the group to be expanded
     * @return True if the group was expanded, false otherwise (if the group
     * was already expanded, this will return false)
     */
    public boolean expandGroup(int groupPos) {
        return expandGroup(groupPos, false);
    }

    /**
     * Expand a group in the grouped list view
     *
     * @param groupPos the group to be expanded
     * @param animate  true if the expanding group should be animated in
     * @return True if the group was expanded, false otherwise (if the group
     * was already expanded, this will return false)
     */
    public boolean expandGroup(int groupPos, boolean animate) {
        ExpandableHListPosition elGroupPos = ExpandableHListPosition.obtain(ExpandableHListPosition.GROUP, groupPos, -1, -1);
        ExpandableHListConnector.PositionMetadata pm = mConnector.getFlattenedPos(elGroupPos);
        elGroupPos.recycle();
        boolean retValue = mConnector.expandGroup(pm);
        if (mOnGroupExpandListener != null) {
            mOnGroupExpandListener.onGroupExpand(groupPos);
        }
        if (animate) {
            final int groupFlatPos = pm.position.flatListPos;
            final int shiftedGroupPosition = groupFlatPos + getHeaderViewsCount();
            smoothScrollToPosition(shiftedGroupPosition + mAdapter.getChildrenCount(groupPos), shiftedGroupPosition);
        }
        pm.recycle();
        return retValue;
    }

    /**
     * Collapse a group in the grouped list view
     *
     * @param groupPos position of the group to collapse
     * @return True if the group was collapsed, false otherwise (if the group
     * was already collapsed, this will return false)
     */
    public boolean collapseGroup(int groupPos) {
        boolean retValue = mConnector.collapseGroup(groupPos);
        if (mOnGroupCollapseListener != null) {
            mOnGroupCollapseListener.onGroupCollapse(groupPos);
        }
        return retValue;
    }

    public void setOnGroupCollapseListener(
            OnGroupCollapseListener onGroupCollapseListener) {
        mOnGroupCollapseListener = onGroupCollapseListener;
    }

    public void setOnGroupExpandListener(
            OnGroupExpandListener onGroupExpandListener) {
        mOnGroupExpandListener = onGroupExpandListener;
    }

    public void setOnGroupClickListener(OnGroupClickListener onGroupClickListener) {
        mOnGroupClickListener = onGroupClickListener;
    }

    public void setOnChildClickListener(OnChildClickListener onChildClickListener) {
        mOnChildClickListener = onChildClickListener;
    }

    /**
     * Converts a flat list position (the raw position of an item (child or group)
     * in the list) to a group and/or child position (represented in a
     * packed position). This is useful in situations where the caller needs to
     * use the underlying {@link android.widget.ListView}'s methods. Use
     * {@link ExpandableHListView#getPackedPositionType} ,
     * {@link ExpandableHListView#getPackedPositionChild},
     * {@link ExpandableHListView#getPackedPositionGroup} to unpack.
     *
     * @param flatListPosition The flat list position to be converted.
     * @return The group and/or child position for the given flat list position
     * in packed position representation. #PACKED_POSITION_VALUE_NULL if
     * the position corresponds to a header or a footer item.
     */
    public long getExpandableListPosition(int flatListPosition) {
        if (isHeaderOrFooterPosition(flatListPosition)) {
            return PACKED_POSITION_VALUE_NULL;
        }
        final int adjustedPosition = getFlatPositionForConnector(flatListPosition);
        ExpandableHListConnector.PositionMetadata pm = mConnector.getUnflattenedPos(adjustedPosition);
        long packedPos = pm.position.getPackedPosition();
        pm.recycle();
        return packedPos;
    }

    /**
     * Converts a group and/or child position to a flat list position. This is
     * useful in situations where the caller needs to use the underlying
     * {@link android.widget.ListView}'s methods.
     *
     * @param packedPosition The group and/or child positions to be converted in
     *                       packed position representation. Use
     *                       {@link #getPackedPositionForChild(int, int)} or
     *                       {@link #getPackedPositionForGroup(int)}.
     * @return The flat list position for the given child or group.
     */
    public int getFlatListPosition(long packedPosition) {
        ExpandableHListPosition elPackedPos = ExpandableHListPosition.obtainPosition(packedPosition);
        ExpandableHListConnector.PositionMetadata pm = mConnector.getFlattenedPos(elPackedPos);
        elPackedPos.recycle();
        final int flatListPosition = pm.position.flatListPos;
        pm.recycle();
        return getAbsoluteFlatPosition(flatListPosition);
    }

    /**
     * Gets the position of the currently selected group or child (along with
     * its type). Can return {@link #PACKED_POSITION_VALUE_NULL} if no selection.
     *
     * @return A packed position containing the currently selected group or
     * child's position and type. #PACKED_POSITION_VALUE_NULL if no selection
     * or if selection is on a header or a footer item.
     */
    public long getSelectedPosition() {
        final int selectedPos = getSelectedItemPosition();
        // The case where there is no selection (selectedPos == -1) is also handled here.
        return getExpandableListPosition(selectedPos);
    }

    /**
     * Gets the ID of the currently selected group or child. Can return -1 if no
     * selection.
     *
     * @return The ID of the currently selected group or child. -1 if no
     * selection.
     */
    public long getSelectedId() {
        long packedPos = getSelectedPosition();
        if (packedPos == PACKED_POSITION_VALUE_NULL) return -1;
        int groupPos = getPackedPositionGroup(packedPos);
        if (getPackedPositionType(packedPos) == PACKED_POSITION_TYPE_GROUP) {
            // It's a group
            return mAdapter.getGroupId(groupPos);
        } else {
            // It's a child
            return mAdapter.getChildId(groupPos, getPackedPositionChild(packedPos));
        }
    }

    /**
     * Sets the selection to the specified group.
     *
     * @param groupPosition The position of the group that should be selected.
     */
    public void setSelectedGroup(int groupPosition) {
        ExpandableHListPosition elGroupPos = ExpandableHListPosition.obtainGroupPosition(groupPosition);
        ExpandableHListConnector.PositionMetadata pm = mConnector.getFlattenedPos(elGroupPos);
        elGroupPos.recycle();
        final int absoluteFlatPosition = getAbsoluteFlatPosition(pm.position.flatListPos);
        super.setSelection(absoluteFlatPosition);
        pm.recycle();
    }

    /**
     * Sets the selection to the specified child. If the child is in a collapsed
     * group, the group will only be expanded and child subsequently selected if
     * shouldExpandGroup is set to true, otherwise the method will return false.
     *
     * @param groupPosition     The position of the group that contains the child.
     * @param childPosition     The position of the child within the group.
     * @param shouldExpandGroup Whether the child's group should be expanded if
     *                          it is collapsed.
     * @return Whether the selection was successfully set on the child.
     */
    public boolean setSelectedChild(int groupPosition, int childPosition, boolean shouldExpandGroup) {
        ExpandableHListPosition elChildPos = ExpandableHListPosition.obtainChildPosition(groupPosition, childPosition);
        ExpandableHListConnector.PositionMetadata flatChildPos = mConnector.getFlattenedPos(elChildPos);
        if (flatChildPos == null) {
            // The child's group isn't expanded
            // Shouldn't expand the group, so return false for we didn't set the selection
            if (!shouldExpandGroup) return false;
            expandGroup(groupPosition);
            flatChildPos = mConnector.getFlattenedPos(elChildPos);
            // Sanity check
            if (flatChildPos == null) {
                throw new IllegalStateException("Could not find child");
            }
        }
        int absoluteFlatPosition = getAbsoluteFlatPosition(flatChildPos.position.flatListPos);
        super.setSelection(absoluteFlatPosition);
        elChildPos.recycle();
        flatChildPos.recycle();
        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) {
        return mConnector.isGroupExpanded(groupPosition);
    }

    ContextMenuInfo createContextMenuInfo(View view, int flatListPosition, long id) {
        if (isHeaderOrFooterPosition(flatListPosition)) {
            // Return normal info for header/footer view context menus
            return new AdapterContextMenuInfo(view, flatListPosition, id);
        }
        final int adjustedPosition = getFlatPositionForConnector(flatListPosition);
        ExpandableHListConnector.PositionMetadata pm = mConnector.getUnflattenedPos(adjustedPosition);
        ExpandableHListPosition pos = pm.position;
        id = getChildOrGroupId(pos);
        long packedPosition = pos.getPackedPosition();
        pm.recycle();
        return new ExpandableListContextMenuInfo(view, packedPosition, id);
    }

    /**
     * Gets the ID of the group or child at the given <code>position</code>.
     * This is useful since there is no ListAdapter ID -> ExpandableListAdapter
     * ID conversion mechanism (in some cases, it isn't possible).
     *
     * @param position The position of the child or group whose ID should be
     *                 returned.
     */
    private long getChildOrGroupId(ExpandableHListPosition position) {
        if (position.type == ExpandableHListPosition.CHILD) {
            return mAdapter.getChildId(position.groupPos, position.childPos);
        } else {
            return mAdapter.getGroupId(position.groupPos);
        }
    }

    /**
     * Sets the indicator to be drawn next to a child.
     *
     * @param childIndicator The drawable to be used as an indicator. If the
     *                       child is the last child for a group, the state
     *                       {@link android.R.attr#state_last} will be set.
     */
    public void setChildIndicator(Drawable childIndicator) {
        mChildIndicator = childIndicator;
        resolveChildIndicator();
    }

    /**
     * Sets the indicator to be drawn next to a group.
     *
     * @param groupIndicator The drawable to be used as an indicator. If the
     *                       group is empty, the state {@link android.R.attr#state_empty} will be
     *                       set. If the group is expanded, the state
     *                       {@link android.R.attr#state_expanded} will be set.
     */
    public void setGroupIndicator(Drawable groupIndicator) {
        mGroupIndicator = groupIndicator;
        resolveIndicator();
    }

    public Parcelable onSaveInstanceState() {
        Parcelable superState = super.onSaveInstanceState();
        return new SavedState(superState, mConnector != null ? mConnector.getExpandedGroupMetadataList() : null);
    }

    public void onRestoreInstanceState(Parcelable state) {
        if (!(state instanceof SavedState)) {
            super.onRestoreInstanceState(state);
            return;
        }
        SavedState ss = (SavedState) state;
        super.onRestoreInstanceState(ss.getSuperState());
        if (mConnector != null && ss.expandedGroupMetadataList != null) {
            mConnector.setExpandedGroupMetadataList(ss.expandedGroupMetadataList);
        }
    }

    public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
        super.onInitializeAccessibilityEvent(event);
        event.setClassName(ExpandableHListView.class.getName());
    }

    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
        super.onInitializeAccessibilityNodeInfo(info);
        info.setClassName(ExpandableHListView.class.getName());
    }

    /**
     * Used for being notified when a group is collapsed
     */
    public interface OnGroupCollapseListener {
        /**
         * Callback method to be invoked when a group in this expandable list has
         * been collapsed.
         *
         * @param groupPosition The group position that was collapsed
         */
        void onGroupCollapse(int groupPosition);
    }

    /**
     * Used for being notified when a group is expanded
     */
    public interface OnGroupExpandListener {
        /**
         * Callback method to be invoked when a group in this expandable list has
         * been expanded.
         *
         * @param groupPosition The group position that was expanded
         */
        void onGroupExpand(int groupPosition);
    }

    /**
     * Interface definition for a callback to be invoked when a group in this
     * expandable list has been clicked.
     */
    public interface OnGroupClickListener {
        /**
         * Callback method to be invoked when a group in this expandable list has
         * been clicked.
         *
         * @param parent        The ExpandableHListConnector where the click happened
         * @param v             The view within the expandable list/ListView that was clicked
         * @param groupPosition The group position that was clicked
         * @param id            The row id of the group that was clicked
         * @return True if the click was handled
         */
        boolean onGroupClick(
                ExpandableHListView parent, View v, int groupPosition, long id);
    }

    /**
     * Interface definition for a callback to be invoked when a child in this
     * expandable list has been clicked.
     */
    public interface OnChildClickListener {
        /**
         * Callback method to be invoked when a child in this expandable list has
         * been clicked.
         *
         * @param parent        The ExpandableListView where the click happened
         * @param v             The view within the expandable list/ListView that was clicked
         * @param groupPosition The group position that contains the child that
         *                      was clicked
         * @param childPosition The child position within the group
         * @param id            The row id of the child that was clicked
         * @return True if the click was handled
         */
        boolean onChildClick(
                ExpandableHListView parent, View v, int groupPosition, int childPosition, long id);
    }

    /**
     * Extra menu information specific to an {@link ExpandableHListView} provided
     * to the
     * {@link android.view.View.OnCreateContextMenuListener#onCreateContextMenu(ContextMenu, View, ContextMenuInfo) }
     * callback when a context menu is brought up for this AdapterView.
     */
    public static class ExpandableListContextMenuInfo implements ContextMenu.ContextMenuInfo {
        /**
         * The view for which the context menu is being displayed. This
         * will be one of the children Views of this {@link ExpandableHListView}.
         */
        public View targetView;
        /**
         * The packed position in the list represented by the adapter for which
         * the context menu is being displayed. Use the methods
         * {@link ExpandableHListView#getPackedPositionType},
         * {@link ExpandableHListView#getPackedPositionChild}, and
         * {@link ExpandableHListView#getPackedPositionGroup} to unpack this.
         */
        public long packedPosition;
        /**
         * The ID of the item (group or child) for which the context menu is
         * being displayed.
         */
        public long id;

        public ExpandableListContextMenuInfo(View targetView, long packedPosition, long id) {
            this.targetView = targetView;
            this.packedPosition = packedPosition;
            this.id = id;
        }
    }

    static class SavedState extends BaseSavedState {
        public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
            public SavedState createFromParcel(Parcel in) {
                return new SavedState(in);
            }

            public SavedState[] newArray(int size) {
                return new SavedState[size];
            }
        };
        ArrayList<ExpandableHListConnector.GroupMetadata> expandedGroupMetadataList;

        /**
         * Constructor called from {@link ExpandableHListView#onSaveInstanceState()}
         */
        SavedState(
                Parcelable superState, ArrayList<ExpandableHListConnector.GroupMetadata> expandedGroupMetadataList) {
            super(superState);
            this.expandedGroupMetadataList = expandedGroupMetadataList;
        }

        /**
         * Constructor called from {@link #CREATOR}
         */
        private SavedState(Parcel in) {
            super(in);
            expandedGroupMetadataList = new ArrayList<ExpandableHListConnector.GroupMetadata>();
            in.readList(expandedGroupMetadataList, ExpandableHListConnector.class.getClassLoader());
        }

        public void writeToParcel(Parcel out, int flags) {
            super.writeToParcel(out, flags);
            out.writeList(expandedGroupMetadataList);
        }
    }
}