| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.layoutlib.bridge.impl.binding; |
| |
| import com.android.ide.common.rendering.api.AdapterBinding; |
| import com.android.ide.common.rendering.api.DataBindingItem; |
| import com.android.ide.common.rendering.api.LayoutlibCallback; |
| import com.android.ide.common.rendering.api.ResourceReference; |
| import com.android.util.Pair; |
| |
| import android.database.DataSetObserver; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.ExpandableListAdapter; |
| import android.widget.HeterogeneousExpandableList; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| @SuppressWarnings("deprecation") |
| public class FakeExpandableAdapter implements ExpandableListAdapter, HeterogeneousExpandableList { |
| |
| private final LayoutlibCallback mCallback; |
| private final ResourceReference mAdapterRef; |
| private boolean mSkipCallbackParser = false; |
| |
| protected final List<AdapterItem> mItems = new ArrayList<AdapterItem>(); |
| |
| // don't use a set because the order is important. |
| private final List<ResourceReference> mGroupTypes = new ArrayList<ResourceReference>(); |
| private final List<ResourceReference> mChildrenTypes = new ArrayList<ResourceReference>(); |
| |
| public FakeExpandableAdapter(ResourceReference adapterRef, AdapterBinding binding, |
| LayoutlibCallback callback) { |
| mAdapterRef = adapterRef; |
| mCallback = callback; |
| |
| createItems(binding, binding.getItemCount(), binding.getRepeatCount(), mGroupTypes, 1); |
| } |
| |
| private void createItems(Iterable<DataBindingItem> iterable, final int itemCount, |
| final int repeatCount, List<ResourceReference> types, int depth) { |
| // Need an array to count for each type. |
| // This is likely too big, but is the max it can be. |
| int[] typeCount = new int[itemCount]; |
| |
| // we put several repeating sets. |
| for (int r = 0 ; r < repeatCount ; r++) { |
| // loop on the type of list items, and add however many for each type. |
| for (DataBindingItem dataBindingItem : iterable) { |
| ResourceReference viewRef = dataBindingItem.getViewReference(); |
| int typeIndex = types.indexOf(viewRef); |
| if (typeIndex == -1) { |
| typeIndex = types.size(); |
| types.add(viewRef); |
| } |
| |
| List<DataBindingItem> children = dataBindingItem.getChildren(); |
| int count = dataBindingItem.getCount(); |
| |
| // if there are children, we use the count as a repeat count for the children. |
| if (children.size() > 0) { |
| count = 1; |
| } |
| |
| int index = typeCount[typeIndex]; |
| typeCount[typeIndex] += count; |
| |
| for (int k = 0 ; k < count ; k++) { |
| AdapterItem item = new AdapterItem(dataBindingItem, typeIndex, mItems.size(), |
| index++); |
| mItems.add(item); |
| |
| if (children.size() > 0) { |
| createItems(dataBindingItem, depth + 1); |
| } |
| } |
| } |
| } |
| } |
| |
| private void createItems(DataBindingItem item, int depth) { |
| if (depth == 2) { |
| createItems(item, item.getChildren().size(), item.getCount(), mChildrenTypes, depth); |
| } |
| } |
| |
| private AdapterItem getChildItem(int groupPosition, int childPosition) { |
| AdapterItem item = mItems.get(groupPosition); |
| |
| List<AdapterItem> children = item.getChildren(); |
| return children.get(childPosition); |
| } |
| |
| // ---- ExpandableListAdapter |
| |
| @Override |
| public int getGroupCount() { |
| return mItems.size(); |
| } |
| |
| @Override |
| public int getChildrenCount(int groupPosition) { |
| AdapterItem item = mItems.get(groupPosition); |
| return item.getChildren().size(); |
| } |
| |
| @Override |
| public Object getGroup(int groupPosition) { |
| return mItems.get(groupPosition); |
| } |
| |
| @Override |
| public Object getChild(int groupPosition, int childPosition) { |
| return getChildItem(groupPosition, childPosition); |
| } |
| |
| @Override |
| public View getGroupView(int groupPosition, boolean isExpanded, View convertView, |
| ViewGroup parent) { |
| // we don't care about recycling here because we never scroll. |
| AdapterItem item = mItems.get(groupPosition); |
| Pair<View, Boolean> pair = AdapterHelper.getView(item, null /*parentItem*/, parent, |
| mCallback, mAdapterRef, mSkipCallbackParser); |
| mSkipCallbackParser = pair.getSecond(); |
| return pair.getFirst(); |
| } |
| |
| @Override |
| public View getChildView(int groupPosition, int childPosition, boolean isLastChild, |
| View convertView, ViewGroup parent) { |
| // we don't care about recycling here because we never scroll. |
| AdapterItem parentItem = mItems.get(groupPosition); |
| AdapterItem item = getChildItem(groupPosition, childPosition); |
| Pair<View, Boolean> pair = AdapterHelper.getView(item, parentItem, parent, mCallback, |
| mAdapterRef, mSkipCallbackParser); |
| mSkipCallbackParser = pair.getSecond(); |
| return pair.getFirst(); |
| } |
| |
| @Override |
| public long getGroupId(int groupPosition) { |
| return groupPosition; |
| } |
| |
| @Override |
| public long getChildId(int groupPosition, int childPosition) { |
| return childPosition; |
| } |
| |
| @Override |
| public long getCombinedGroupId(long groupId) { |
| return groupId << 16 | 0x0000FFFF; |
| } |
| |
| @Override |
| public long getCombinedChildId(long groupId, long childId) { |
| return groupId << 16 | childId; |
| } |
| |
| @Override |
| public boolean isChildSelectable(int groupPosition, int childPosition) { |
| return true; |
| } |
| |
| @Override |
| public void onGroupCollapsed(int groupPosition) { |
| // pass |
| } |
| |
| @Override |
| public void onGroupExpanded(int groupPosition) { |
| // pass |
| } |
| |
| @Override |
| public void registerDataSetObserver(DataSetObserver observer) { |
| // pass |
| } |
| |
| @Override |
| public void unregisterDataSetObserver(DataSetObserver observer) { |
| // pass |
| } |
| |
| @Override |
| public boolean hasStableIds() { |
| return true; |
| } |
| |
| @Override |
| public boolean areAllItemsEnabled() { |
| return true; |
| } |
| |
| @Override |
| public boolean isEmpty() { |
| return mItems.isEmpty(); |
| } |
| |
| // ---- HeterogeneousExpandableList |
| |
| @Override |
| public int getChildType(int groupPosition, int childPosition) { |
| return getChildItem(groupPosition, childPosition).getType(); |
| } |
| |
| @Override |
| public int getChildTypeCount() { |
| return mChildrenTypes.size(); |
| } |
| |
| @Override |
| public int getGroupType(int groupPosition) { |
| return mItems.get(groupPosition).getType(); |
| } |
| |
| @Override |
| public int getGroupTypeCount() { |
| return mGroupTypes.size(); |
| } |
| } |