src.com.android.systemui.globalactions.ListGridLayout Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2019 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.systemui.globalactions;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import com.android.internal.annotations.VisibleForTesting;
/**
* Layout which uses nested LinearLayouts to create a grid with the following behavior:
*
* * Try to maintain a 'square' grid (equal number of columns and rows) based on the expected item
* count.
* * Determine the position and parent of any item by its index and the total item count.
* * Display and hide sub-lists as needed, depending on the expected item count.
*
* While we could implement this behavior with a GridLayout, it would take significantly more
* time and effort, and would require more substantial refactoring of the existing code in
* GlobalActionsDialog, since it would require manipulation of layout properties on the child items
* themselves.
*
*/
public class ListGridLayout extends LinearLayout {
private static final String TAG = "ListGridLayout";
private int mExpectedCount;
private int mCurrentCount = 0;
private boolean mSwapRowsAndColumns;
private boolean mReverseSublists;
private boolean mReverseItems;
// number of rows and columns to use for different numbers of items
private final int[][] mConfigs = {
// {rows, columns}
{0, 0}, // 0 items
{1, 1}, // 1 item
{1, 2}, // 2 items
{1, 3}, // 3 items
{2, 2}, // 4 items
{2, 3}, // 5 items
{2, 3}, // 6 items
{3, 3}, // 7 items
{3, 3}, // 8 items
{3, 3} // 9 items
};
public ListGridLayout(Context context, AttributeSet attrs) {
super(context, attrs);
}
/**
* Sets whether this grid should prioritize filling rows or columns first.
*/
public void setSwapRowsAndColumns(boolean swap) {
mSwapRowsAndColumns = swap;
}
/**
* Sets whether this grid should fill sublists in reverse order.
*/
public void setReverseSublists(boolean reverse) {
mReverseSublists = reverse;
}
/**
* Sets whether this grid should add items to sublists in reverse order.
* @param reverse
*/
public void setReverseItems(boolean reverse) {
mReverseItems = reverse;
}
/**
* Remove all items from this grid.
*/
public void removeAllItems() {
for (int i = 0; i < getChildCount(); i++) {
ViewGroup subList = getSublist(i);
if (subList != null) {
subList.removeAllViews();
subList.setVisibility(View.GONE);
}
}
mCurrentCount = 0;
}
/**
* Adds a view item to this grid, placing it in the correct sublist and ensuring that the
* sublist is visible.
*
* This function is stateful, since it tracks how many items have been added thus far, to
* determine which sublist they should be added to. To ensure that this works correctly, call
* removeAllItems() instead of removing views individually with removeView() to ensure that the
* counter gets reset correctly.
* @param item
*/
public void addItem(View item) {
ViewGroup parent = getParentView(mCurrentCount, mReverseSublists, mSwapRowsAndColumns);
if (mReverseItems) {
parent.addView(item, 0);
} else {
parent.addView(item);
}
parent.setVisibility(View.VISIBLE);
mCurrentCount++;
}
/**
* Get the parent view associated with the item which should be placed at the given position.
* @param index The index of the item.
* @param reverseSublists Reverse the order of sublists. Ordinarily, sublists fill from first to
* last, whereas setting this to true will fill them last to first.
* @param swapRowsAndColumns Swap the order in which rows and columns are filled. By default,
* columns fill first, adding one item to each row. Setting this to
* true will cause rows to fill first, adding one item to each column.
* @return
*/
@VisibleForTesting
protected ViewGroup getParentView(int index, boolean reverseSublists,
boolean swapRowsAndColumns) {
if (getRowCount() == 0 || index < 0) {
return null;
}
int targetIndex = Math.min(index, getMaxElementCount() - 1);
int row = getParentViewIndex(targetIndex, reverseSublists, swapRowsAndColumns);
return getSublist(row);
}
@VisibleForTesting
protected ViewGroup getSublist(int index) {
return (ViewGroup) getChildAt(index);
}
private int reverseSublistIndex(int index) {
return getChildCount() - (index + 1);
}
private int getParentViewIndex(int index, boolean reverseSublists, boolean swapRowsAndColumns) {
int sublistIndex;
int rows = getRowCount();
if (swapRowsAndColumns) {
sublistIndex = (int) Math.floor(index / rows);
} else {
sublistIndex = index % rows;
}
if (reverseSublists) {
sublistIndex = reverseSublistIndex(sublistIndex);
}
return sublistIndex;
}
/**
* Sets the expected number of items that this grid will be responsible for rendering.
*/
public void setExpectedCount(int count) {
mExpectedCount = count;
}
private int getMaxElementCount() {
return mConfigs.length - 1;
}
private int[] getConfig() {
if (mExpectedCount < 0) {
return mConfigs[0];
}
int targetElements = Math.min(getMaxElementCount(), mExpectedCount);
return mConfigs[targetElements];
}
/**
* Get the number of rows which will be used to render children.
*/
public int getRowCount() {
return getConfig()[0];
}
/**
* Get the number of columns which will be used to render children.
*/
public int getColumnCount() {
return getConfig()[1];
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy