Files
Flexera-Launcher/src/com/android/launcher3/model/data/FolderInfo.java
T
Jeremy Sim 9109e43f02 Allow app pairs in folders
This CL substantially refactors folders to be able to take contents of type AppPairInfo. App pairs can now be moved in and out of folders, and launch from folders.

This CL contains only logic and model changes; animation and style changes (for dropping items into folders, color changes to app pair surfaces, etc.) will be in a following CL. Another CL (hopefully) will contain tests. I'm planning to submit them together, but this patch should also be able to stand alone with no issues (except janky transitions).

Bug: 315731527
Flag: ACONFIG com.android.wm.shell.enable_app_pairs TRUNKFOOD
Test: Manual, more to follow in another CL.
Change-Id: I73732fcaefbdc61bf6e02a5be365962b8bbc3e41
(cherry picked from commit a596f589c4)
Merged-In: I73732fcaefbdc61bf6e02a5be365962b8bbc3e41
2024-04-11 03:51:53 +00:00

397 lines
13 KiB
Java

/*
* Copyright (C) 2008 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.launcher3.model.data;
import static android.text.TextUtils.isEmpty;
import static androidx.core.util.Preconditions.checkNotNull;
import static com.android.launcher3.logger.LauncherAtom.Attribute.EMPTY_LABEL;
import static com.android.launcher3.logger.LauncherAtom.Attribute.MANUAL_LABEL;
import static com.android.launcher3.logger.LauncherAtom.Attribute.SUGGESTED_LABEL;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.android.launcher3.LauncherSettings;
import com.android.launcher3.Utilities;
import com.android.launcher3.folder.Folder;
import com.android.launcher3.folder.FolderNameInfos;
import com.android.launcher3.logger.LauncherAtom;
import com.android.launcher3.logger.LauncherAtom.Attribute;
import com.android.launcher3.logger.LauncherAtom.FolderIcon;
import com.android.launcher3.logger.LauncherAtom.FromState;
import com.android.launcher3.logger.LauncherAtom.ToState;
import com.android.launcher3.model.ModelWriter;
import com.android.launcher3.util.ContentWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.OptionalInt;
import java.util.stream.IntStream;
/**
* Represents a folder containing shortcuts or apps.
*/
public class FolderInfo extends CollectionInfo {
public static final int NO_FLAGS = 0x00000000;
/**
* The folder is locked in sorted mode
*/
public static final int FLAG_ITEMS_SORTED = 0x00000001;
/**
* It is a work folder
*/
public static final int FLAG_WORK_FOLDER = 0x00000002;
/**
* The multi-page animation has run for this folder
*/
public static final int FLAG_MULTI_PAGE_ANIMATION = 0x00000004;
public static final int FLAG_MANUAL_FOLDER_NAME = 0x00000008;
/**
* Different states of folder label.
*/
public enum LabelState {
// Folder's label is not yet assigned( i.e., title == null). Eligible for auto-labeling.
UNLABELED(Attribute.UNLABELED),
// Folder's label is empty(i.e., title == ""). Not eligible for auto-labeling.
EMPTY(EMPTY_LABEL),
// Folder's label is one of the non-empty suggested values.
SUGGESTED(SUGGESTED_LABEL),
// Folder's label is non-empty, manually entered by the user
// and different from any of suggested values.
MANUAL(MANUAL_LABEL);
private final LauncherAtom.Attribute mLogAttribute;
LabelState(Attribute logAttribute) {
this.mLogAttribute = logAttribute;
}
}
public static final String EXTRA_FOLDER_SUGGESTIONS = "suggest";
public int options;
public FolderNameInfos suggestedFolderNames;
/**
* The apps and shortcuts
*/
private final ArrayList<ItemInfo> contents = new ArrayList<>();
private ArrayList<FolderListener> mListeners = new ArrayList<>();
public FolderInfo() {
itemType = LauncherSettings.Favorites.ITEM_TYPE_FOLDER;
}
/** Adds a app or shortcut to the contents ArrayList without animation. */
@Override
public void add(@NonNull ItemInfo item) {
add(item, false /* animate */);
}
/**
* Add an app or shortcut
*
* @param item
*/
public void add(ItemInfo item, boolean animate) {
add(item, getContents().size(), animate);
}
/**
* Add an app or shortcut for a specified rank.
*/
public void add(ItemInfo item, int rank, boolean animate) {
if (!Folder.willAccept(item)) {
throw new RuntimeException("tried to add an illegal type into a folder");
}
rank = Utilities.boundToRange(rank, 0, getContents().size());
getContents().add(rank, item);
for (int i = 0; i < mListeners.size(); i++) {
mListeners.get(i).onAdd(item, rank);
}
itemsChanged(animate);
}
/**
* Remove an app or shortcut. Does not change the DB.
*
* @param item
*/
public void remove(ItemInfo item, boolean animate) {
removeAll(Collections.singletonList(item), animate);
}
/**
* Remove all matching app or shortcut. Does not change the DB.
*/
public void removeAll(List<ItemInfo> items, boolean animate) {
contents.removeAll(items);
for (int i = 0; i < mListeners.size(); i++) {
mListeners.get(i).onRemove(items);
}
itemsChanged(animate);
}
/**
* Returns the folder's contents as an ArrayList of {@link ItemInfo}. Includes
* {@link WorkspaceItemInfo} and {@link AppPairInfo}s.
*/
@NonNull
@Override
public ArrayList<ItemInfo> getContents() {
return contents;
}
/**
* Returns the folder's contents as an ArrayList of {@link WorkspaceItemInfo}. Note: Does not
* return any {@link AppPairInfo}s contained in the folder, instead collects *their* contents
* and adds them to the ArrayList.
*/
@Override
public ArrayList<WorkspaceItemInfo> getAppContents() {
ArrayList<WorkspaceItemInfo> workspaceItemInfos = new ArrayList<>();
for (ItemInfo item : contents) {
if (item instanceof WorkspaceItemInfo wii) {
workspaceItemInfos.add(wii);
} else if (item instanceof AppPairInfo api) {
workspaceItemInfos.addAll(api.getAppContents());
}
}
return workspaceItemInfos;
}
@Override
public void onAddToDatabase(@NonNull ContentWriter writer) {
super.onAddToDatabase(writer);
writer.put(LauncherSettings.Favorites.OPTIONS, options);
}
public void addListener(FolderListener listener) {
mListeners.add(listener);
}
public void removeListener(FolderListener listener) {
mListeners.remove(listener);
}
public void itemsChanged(boolean animate) {
for (int i = 0; i < mListeners.size(); i++) {
mListeners.get(i).onItemsChanged(animate);
}
}
public interface FolderListener {
void onAdd(ItemInfo item, int rank);
void onRemove(List<ItemInfo> item);
void onItemsChanged(boolean animate);
}
public boolean hasOption(int optionFlag) {
return (options & optionFlag) != 0;
}
/**
* @param option flag to set or clear
* @param isEnabled whether to set or clear the flag
* @param writer if not null, save changes to the db.
*/
public void setOption(int option, boolean isEnabled, ModelWriter writer) {
int oldOptions = options;
if (isEnabled) {
options |= option;
} else {
options &= ~option;
}
if (writer != null && oldOptions != options) {
writer.updateItemInDatabase(this);
}
}
@Override
protected String dumpProperties() {
return String.format("%s; labelState=%s", super.dumpProperties(), getLabelState());
}
@NonNull
@Override
public LauncherAtom.ItemInfo buildProto(@Nullable CollectionInfo cInfo) {
FolderIcon.Builder folderIcon = FolderIcon.newBuilder()
.setCardinality(getContents().size());
if (LabelState.SUGGESTED.equals(getLabelState())) {
folderIcon.setLabelInfo(title.toString());
}
return getDefaultItemInfoBuilder()
.setFolderIcon(folderIcon)
.setRank(rank)
.addItemAttributes(getLabelState().mLogAttribute)
.setContainerInfo(getContainerInfo())
.build();
}
@Override
public void setTitle(@Nullable CharSequence title, ModelWriter modelWriter) {
// Updating label from null to empty is considered as false touch.
// Retaining null title(ie., UNLABELED state) allows auto-labeling when new items added.
if (isEmpty(title) && this.title == null) {
return;
}
// Updating title to same value does not change any states.
if (title != null && title.equals(this.title)) {
return;
}
this.title = title;
LabelState newLabelState =
title == null ? LabelState.UNLABELED
: title.length() == 0 ? LabelState.EMPTY :
getAcceptedSuggestionIndex().isPresent() ? LabelState.SUGGESTED
: LabelState.MANUAL;
if (newLabelState.equals(LabelState.MANUAL)) {
options |= FLAG_MANUAL_FOLDER_NAME;
} else {
options &= ~FLAG_MANUAL_FOLDER_NAME;
}
if (modelWriter != null) {
modelWriter.updateItemInDatabase(this);
}
}
/**
* Returns current state of the current folder label.
*/
public LabelState getLabelState() {
return title == null ? LabelState.UNLABELED
: title.length() == 0 ? LabelState.EMPTY :
hasOption(FLAG_MANUAL_FOLDER_NAME) ? LabelState.MANUAL
: LabelState.SUGGESTED;
}
@NonNull
@Override
public ItemInfo makeShallowCopy() {
FolderInfo folderInfo = new FolderInfo();
folderInfo.copyFrom(this);
return folderInfo;
}
@Override
public void copyFrom(@NonNull ItemInfo info) {
super.copyFrom(info);
if (info instanceof FolderInfo fi) {
contents.addAll(fi.getContents());
}
}
/**
* Returns index of the accepted suggestion.
*/
public OptionalInt getAcceptedSuggestionIndex() {
String newLabel = checkNotNull(title,
"Expected valid folder label, but found null").toString();
if (suggestedFolderNames == null || !suggestedFolderNames.hasSuggestions()) {
return OptionalInt.empty();
}
CharSequence[] labels = suggestedFolderNames.getLabels();
return IntStream.range(0, labels.length)
.filter(index -> !isEmpty(labels[index])
&& newLabel.equalsIgnoreCase(
labels[index].toString()))
.sequential()
.findFirst();
}
/**
* Returns {@link FromState} based on current {@link #title}.
*/
public LauncherAtom.FromState getFromLabelState() {
switch (getLabelState()){
case EMPTY:
return LauncherAtom.FromState.FROM_EMPTY;
case MANUAL:
return LauncherAtom.FromState.FROM_CUSTOM;
case SUGGESTED:
return LauncherAtom.FromState.FROM_SUGGESTED;
case UNLABELED:
default:
return LauncherAtom.FromState.FROM_STATE_UNSPECIFIED;
}
}
/**
* Returns {@link ToState} based on current {@link #title}.
*/
public LauncherAtom.ToState getToLabelState() {
if (title == null) {
return LauncherAtom.ToState.TO_STATE_UNSPECIFIED;
}
// TODO: if suggestedFolderNames is null then it infrastructure issue, not
// ranking issue. We should log these appropriately.
if (suggestedFolderNames == null || !suggestedFolderNames.hasSuggestions()) {
return title.length() > 0
? LauncherAtom.ToState.TO_CUSTOM_WITH_EMPTY_SUGGESTIONS
: LauncherAtom.ToState.TO_EMPTY_WITH_EMPTY_SUGGESTIONS;
}
boolean hasValidPrimary = suggestedFolderNames != null && suggestedFolderNames.hasPrimary();
if (title.length() == 0) {
return hasValidPrimary ? LauncherAtom.ToState.TO_EMPTY_WITH_VALID_PRIMARY
: LauncherAtom.ToState.TO_EMPTY_WITH_VALID_SUGGESTIONS_AND_EMPTY_PRIMARY;
}
OptionalInt accepted_suggestion_index = getAcceptedSuggestionIndex();
if (!accepted_suggestion_index.isPresent()) {
return hasValidPrimary ? LauncherAtom.ToState.TO_CUSTOM_WITH_VALID_PRIMARY
: LauncherAtom.ToState.TO_CUSTOM_WITH_VALID_SUGGESTIONS_AND_EMPTY_PRIMARY;
}
switch (accepted_suggestion_index.getAsInt()) {
case 0:
return LauncherAtom.ToState.TO_SUGGESTION0;
case 1:
return hasValidPrimary ? LauncherAtom.ToState.TO_SUGGESTION1_WITH_VALID_PRIMARY
: LauncherAtom.ToState.TO_SUGGESTION1_WITH_EMPTY_PRIMARY;
case 2:
return hasValidPrimary ? LauncherAtom.ToState.TO_SUGGESTION2_WITH_VALID_PRIMARY
: LauncherAtom.ToState.TO_SUGGESTION2_WITH_EMPTY_PRIMARY;
case 3:
return hasValidPrimary ? LauncherAtom.ToState.TO_SUGGESTION3_WITH_VALID_PRIMARY
: LauncherAtom.ToState.TO_SUGGESTION3_WITH_EMPTY_PRIMARY;
default:
// fall through
}
return LauncherAtom.ToState.TO_STATE_UNSPECIFIED;
}
}