Adam Cohen
9c4949e12c
adjacent pages ->Fixing crash on phones Change-Id: I8ea97ce6d569c59b6d51b544dc10b0310d294b43
504 lines
17 KiB
Java
504 lines
17 KiB
Java
/*
|
|
* Copyright (C) 2010 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.launcher2;
|
|
|
|
import com.android.launcher.R;
|
|
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.util.AttributeSet;
|
|
import android.view.ActionMode;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.animation.AnimationUtils;
|
|
import android.widget.Checkable;
|
|
import android.widget.TextView;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
|
|
/**
|
|
* An implementation of PagedView that populates the pages of the workspace
|
|
* with all of the user's applications.
|
|
*/
|
|
public class AllAppsPagedView extends PagedView
|
|
implements AllAppsView, View.OnClickListener, View.OnLongClickListener, DragSource,
|
|
DropTarget, ActionMode.Callback {
|
|
|
|
private static final String TAG = "AllAppsPagedView";
|
|
private static final boolean DEBUG = false;
|
|
|
|
private static final int MENU_DELETE_APP = 1;
|
|
private static final int MENU_APP_INFO = 2;
|
|
|
|
private Launcher mLauncher;
|
|
private DragController mDragController;
|
|
|
|
// preserve compatibility with 3D all apps:
|
|
// 0.0 -> hidden
|
|
// 1.0 -> shown and opaque
|
|
// intermediate values -> partially shown & partially opaque
|
|
private float mZoom;
|
|
|
|
// set of all applications
|
|
private ArrayList<ApplicationInfo> mApps;
|
|
private ArrayList<ApplicationInfo> mFilteredApps;
|
|
|
|
// the types of applications to filter
|
|
static final int ALL_APPS_FLAG = -1;
|
|
private int mAppFilter = ALL_APPS_FLAG;
|
|
|
|
private final LayoutInflater mInflater;
|
|
|
|
private ViewGroup mOrigInfoButtonParent;
|
|
private LayoutParams mOrigInfoButtonLayoutParams;
|
|
|
|
private ViewGroup mOrigDeleteZoneParent;
|
|
private LayoutParams mOrigDeleteZoneLayoutParams;
|
|
|
|
public AllAppsPagedView(Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
public AllAppsPagedView(Context context, AttributeSet attrs) {
|
|
this(context, attrs, 0);
|
|
}
|
|
|
|
public AllAppsPagedView(Context context, AttributeSet attrs, int defStyle) {
|
|
super(context, attrs, defStyle);
|
|
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.PagedView, defStyle, 0);
|
|
mCellCountX = a.getInt(R.styleable.PagedView_cellCountX, 6);
|
|
mCellCountY = a.getInt(R.styleable.PagedView_cellCountY, 4);
|
|
mInflater = LayoutInflater.from(context);
|
|
a.recycle();
|
|
setSoundEffectsEnabled(false);
|
|
}
|
|
|
|
@Override
|
|
public void setLauncher(Launcher launcher) {
|
|
mLauncher = launcher;
|
|
mLauncher.setAllAppsPagedView(this);
|
|
}
|
|
|
|
@Override
|
|
public void setDragController(DragController dragger) {
|
|
mDragController = dragger;
|
|
}
|
|
|
|
public void setAppFilter(int filterType) {
|
|
mAppFilter = filterType;
|
|
if (mApps != null) {
|
|
mFilteredApps = rebuildFilteredApps(mApps);
|
|
setCurrentPage(0);
|
|
invalidatePageData();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void zoom(float zoom, boolean animate) {
|
|
mZoom = zoom;
|
|
cancelLongPress();
|
|
|
|
if (isVisible()) {
|
|
getParent().bringChildToFront(this);
|
|
setVisibility(View.VISIBLE);
|
|
if (animate) {
|
|
startAnimation(AnimationUtils.loadAnimation(getContext(),
|
|
R.anim.all_apps_2d_fade_in));
|
|
} else {
|
|
onAnimationEnd();
|
|
}
|
|
} else {
|
|
if (animate) {
|
|
startAnimation(AnimationUtils.loadAnimation(getContext(),
|
|
R.anim.all_apps_2d_fade_out));
|
|
} else {
|
|
onAnimationEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void onAnimationEnd() {
|
|
if (!isVisible()) {
|
|
setVisibility(View.GONE);
|
|
mZoom = 0.0f;
|
|
|
|
endChoiceMode();
|
|
} else {
|
|
mZoom = 1.0f;
|
|
}
|
|
|
|
if (mLauncher != null)
|
|
mLauncher.zoomed(mZoom);
|
|
}
|
|
|
|
private int getChildIndexForGrandChild(View v) {
|
|
final int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; ++i) {
|
|
final PagedViewCellLayout layout = (PagedViewCellLayout) getChildAt(i);
|
|
if (layout.indexOfChild(v) > -1) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public void onClick(View v) {
|
|
// if we are already in a choice mode, then just change the selection
|
|
if (v instanceof Checkable) {
|
|
if (!isChoiceMode(CHOICE_MODE_NONE)) {
|
|
Checkable c = (Checkable) v;
|
|
if (isChoiceMode(CHOICE_MODE_SINGLE)) {
|
|
// Uncheck all the other grandchildren, and toggle the clicked one
|
|
boolean wasChecked = c.isChecked();
|
|
resetCheckedGrandchildren();
|
|
c.setChecked(!wasChecked);
|
|
} else {
|
|
c.toggle();
|
|
}
|
|
if (getCheckedGrandchildren().size() == 0) {
|
|
endChoiceMode();
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// otherwise continue and launch the application
|
|
int childIndex = getChildIndexForGrandChild(v);
|
|
if (childIndex == getCurrentPage()) {
|
|
final ApplicationInfo app = (ApplicationInfo) v.getTag();
|
|
|
|
// animate some feedback to the click
|
|
animateClickFeedback(v, new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mLauncher.startActivitySafely(app.intent, app);
|
|
}
|
|
});
|
|
|
|
endChoiceMode();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onLongClick(View v) {
|
|
if (!v.isInTouchMode()) {
|
|
return false;
|
|
}
|
|
|
|
if (v instanceof Checkable) {
|
|
// In preparation for drag, we always reset the checked grand children regardless of
|
|
// what choice mode we are in
|
|
resetCheckedGrandchildren();
|
|
|
|
// Toggle the selection on the dragged app
|
|
Checkable c = (Checkable) v;
|
|
c.toggle();
|
|
}
|
|
|
|
// Start choice mode AFTER the item is selected
|
|
if (isChoiceMode(CHOICE_MODE_NONE)) {
|
|
startChoiceMode(CHOICE_MODE_SINGLE, this);
|
|
}
|
|
|
|
ApplicationInfo app = (ApplicationInfo) v.getTag();
|
|
app = new ApplicationInfo(app);
|
|
|
|
mDragController.startDrag(v, this, app, DragController.DRAG_ACTION_COPY);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onDropCompleted(View target, boolean success) {
|
|
// close the choice action mode if we have a proper drop
|
|
if (target != this) {
|
|
endChoiceMode();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isVisible() {
|
|
return mZoom > 0.001f;
|
|
}
|
|
|
|
@Override
|
|
public boolean isAnimating() {
|
|
return (getAnimation() != null);
|
|
}
|
|
|
|
private ArrayList<ApplicationInfo> rebuildFilteredApps(ArrayList<ApplicationInfo> apps) {
|
|
ArrayList<ApplicationInfo> filteredApps = new ArrayList<ApplicationInfo>();
|
|
if (mAppFilter == ALL_APPS_FLAG) {
|
|
return apps;
|
|
} else {
|
|
final int length = apps.size();
|
|
for (int i = 0; i < length; ++i) {
|
|
ApplicationInfo info = apps.get(i);
|
|
if ((info.flags & mAppFilter) > 0) {
|
|
filteredApps.add(info);
|
|
}
|
|
}
|
|
}
|
|
return filteredApps;
|
|
}
|
|
|
|
@Override
|
|
public void setApps(ArrayList<ApplicationInfo> list) {
|
|
mApps = list;
|
|
Collections.sort(mApps, LauncherModel.APP_NAME_COMPARATOR);
|
|
mFilteredApps = rebuildFilteredApps(mApps);
|
|
mPageViewIconCache.clear();
|
|
invalidatePageData();
|
|
}
|
|
|
|
private void addAppsWithoutInvalidate(ArrayList<ApplicationInfo> list) {
|
|
// we add it in place, in alphabetical order
|
|
final int count = list.size();
|
|
for (int i = 0; i < count; ++i) {
|
|
final ApplicationInfo info = list.get(i);
|
|
final int index = Collections.binarySearch(mApps, info, LauncherModel.APP_NAME_COMPARATOR);
|
|
if (index < 0) {
|
|
mApps.add(-(index + 1), info);
|
|
}
|
|
}
|
|
mFilteredApps = rebuildFilteredApps(mApps);
|
|
}
|
|
@Override
|
|
public void addApps(ArrayList<ApplicationInfo> list) {
|
|
addAppsWithoutInvalidate(list);
|
|
invalidatePageData();
|
|
}
|
|
|
|
private void removeAppsWithoutInvalidate(ArrayList<ApplicationInfo> list) {
|
|
// loop through all the apps and remove apps that have the same component
|
|
final int length = list.size();
|
|
for (int i = 0; i < length; ++i) {
|
|
final ApplicationInfo info = list.get(i);
|
|
int removeIndex = findAppByComponent(mApps, info);
|
|
if (removeIndex > -1) {
|
|
mApps.remove(removeIndex);
|
|
mPageViewIconCache.removeOutline(info);
|
|
}
|
|
}
|
|
mFilteredApps = rebuildFilteredApps(mApps);
|
|
}
|
|
@Override
|
|
public void removeApps(ArrayList<ApplicationInfo> list) {
|
|
removeAppsWithoutInvalidate(list);
|
|
invalidatePageData();
|
|
}
|
|
|
|
@Override
|
|
public void updateApps(ArrayList<ApplicationInfo> list) {
|
|
removeAppsWithoutInvalidate(list);
|
|
addAppsWithoutInvalidate(list);
|
|
invalidatePageData();
|
|
}
|
|
|
|
private int findAppByComponent(ArrayList<ApplicationInfo> list, ApplicationInfo item) {
|
|
ComponentName removeComponent = item.intent.getComponent();
|
|
final int length = list.size();
|
|
for (int i = 0; i < length; ++i) {
|
|
ApplicationInfo info = list.get(i);
|
|
if (info.intent.getComponent().equals(removeComponent)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public void dumpState() {
|
|
ApplicationInfo.dumpApplicationInfoList(TAG, "mApps", mApps);
|
|
}
|
|
|
|
@Override
|
|
public void surrender() {
|
|
// do nothing?
|
|
}
|
|
|
|
@Override
|
|
public void syncPages() {
|
|
// ensure that we have the right number of pages
|
|
int numPages = (int) Math.ceil((float) mFilteredApps.size() / (mCellCountX * mCellCountY));
|
|
int curNumPages = getChildCount();
|
|
// remove any extra pages after the "last" page
|
|
int extraPageDiff = curNumPages - numPages;
|
|
for (int i = 0; i < extraPageDiff; ++i) {
|
|
removeViewAt(numPages);
|
|
}
|
|
// add any necessary pages
|
|
for (int i = curNumPages; i < numPages; ++i) {
|
|
PagedViewCellLayout layout = new PagedViewCellLayout(getContext());
|
|
layout.setCellCount(mCellCountX, mCellCountY);
|
|
layout.setPadding(mPageLayoutPaddingLeft, mPageLayoutPaddingTop,
|
|
mPageLayoutPaddingRight, mPageLayoutPaddingBottom);
|
|
addView(layout);
|
|
}
|
|
|
|
// bound the current page
|
|
setCurrentPage(Math.max(0, Math.min(numPages - 1, getCurrentPage())));
|
|
}
|
|
|
|
@Override
|
|
public void syncPageItems(int page) {
|
|
// ensure that we have the right number of items on the pages
|
|
final int cellsPerPage = mCellCountX * mCellCountY;
|
|
final int startIndex = page * cellsPerPage;
|
|
final int endIndex = Math.min(startIndex + cellsPerPage, mFilteredApps.size());
|
|
PagedViewCellLayout layout = (PagedViewCellLayout) getChildAt(page);
|
|
|
|
final int curNumPageItems = layout.getChildCount();
|
|
final int numPageItems = endIndex - startIndex;
|
|
|
|
// remove any extra items
|
|
int extraPageItemsDiff = curNumPageItems - numPageItems;
|
|
for (int i = 0; i < extraPageItemsDiff; ++i) {
|
|
layout.removeViewAt(numPageItems);
|
|
}
|
|
// add any necessary items
|
|
for (int i = curNumPageItems; i < numPageItems; ++i) {
|
|
TextView text = (TextView) mInflater.inflate(R.layout.all_apps_paged_view_application, layout, false);
|
|
text.setOnClickListener(this);
|
|
text.setOnLongClickListener(this);
|
|
|
|
layout.addViewToCellLayout(text, -1, i,
|
|
new PagedViewCellLayout.LayoutParams(0, 0, 1, 1));
|
|
}
|
|
|
|
// actually reapply to the existing text views
|
|
for (int i = startIndex; i < endIndex; ++i) {
|
|
final int index = i - startIndex;
|
|
final ApplicationInfo info = mFilteredApps.get(i);
|
|
PagedViewIcon icon = (PagedViewIcon) layout.getChildAt(index);
|
|
icon.applyFromApplicationInfo(info, mPageViewIconCache);
|
|
|
|
PagedViewCellLayout.LayoutParams params =
|
|
(PagedViewCellLayout.LayoutParams) icon.getLayoutParams();
|
|
params.cellX = index % mCellCountX;
|
|
params.cellY = index / mCellCountX;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
|
|
mode.setTitle(R.string.cab_app_selection_text);
|
|
|
|
// Until the workspace has a selection mode and the CAB supports drag-and-drop, we
|
|
// take a hybrid approach: grab the views from the workspace and stuff them into the CAB.
|
|
// When the action mode is done, restore the views to their original place in the toolbar.
|
|
|
|
ApplicationInfoDropTarget infoButton =
|
|
(ApplicationInfoDropTarget) mLauncher.findViewById(R.id.info_button);
|
|
mOrigInfoButtonParent = (ViewGroup) infoButton.getParent();
|
|
mOrigInfoButtonLayoutParams = infoButton.getLayoutParams();
|
|
mOrigInfoButtonParent.removeView(infoButton);
|
|
infoButton.setManageVisibility(false);
|
|
infoButton.setVisibility(View.VISIBLE);
|
|
|
|
DeleteZone deleteZone = (DeleteZone) mLauncher.findViewById(R.id.delete_zone);
|
|
mOrigDeleteZoneParent = (ViewGroup) deleteZone.getParent();
|
|
mOrigDeleteZoneLayoutParams = deleteZone.getLayoutParams();
|
|
mOrigDeleteZoneParent.removeView(deleteZone);
|
|
deleteZone.setManageVisibility(false);
|
|
deleteZone.setVisibility(View.VISIBLE);
|
|
|
|
menu.add(0, MENU_APP_INFO, 0, R.string.cab_menu_app_info).setActionView(infoButton);
|
|
menu.add(0, MENU_DELETE_APP, 0, R.string.cab_menu_delete_app).setActionView(deleteZone);
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
|
|
mDragController.addDropTarget(this);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onDestroyActionMode(ActionMode mode) {
|
|
// Re-parent the drop targets into the toolbar, and restore their layout params
|
|
ApplicationInfoDropTarget infoButton =
|
|
(ApplicationInfoDropTarget) mLauncher.findViewById(R.id.info_button);
|
|
((ViewGroup) infoButton.getParent()).removeView(infoButton);
|
|
mOrigInfoButtonParent.addView(infoButton, mOrigInfoButtonLayoutParams);
|
|
infoButton.setVisibility(View.GONE);
|
|
infoButton.setManageVisibility(true);
|
|
|
|
DeleteZone deleteZone = (DeleteZone) mLauncher.findViewById(R.id.delete_zone);
|
|
((ViewGroup) deleteZone.getParent()).removeView(deleteZone);
|
|
mOrigDeleteZoneParent.addView(deleteZone, mOrigDeleteZoneLayoutParams);
|
|
deleteZone.setVisibility(View.GONE);
|
|
deleteZone.setManageVisibility(true);
|
|
|
|
mDragController.removeDropTarget(this);
|
|
endChoiceMode();
|
|
}
|
|
|
|
@Override
|
|
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
|
|
final int id = item.getItemId();
|
|
|
|
// Assumes that we are in CHOICE_MODE_SINGLE
|
|
final ApplicationInfo appInfo = (ApplicationInfo) getChosenItem();
|
|
|
|
if (id == MENU_APP_INFO) {
|
|
mLauncher.startApplicationDetailsActivity(appInfo.componentName);
|
|
} else if (id == MENU_DELETE_APP) {
|
|
mLauncher.startApplicationUninstallActivity(appInfo);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* We don't actually use AllAppsPagedView as a drop target... it's only used to intercept a drop
|
|
* to the workspace.
|
|
*/
|
|
@Override
|
|
public boolean acceptDrop(DragSource source, int x, int y, int xOffset, int yOffset,
|
|
DragView dragView, Object dragInfo) {
|
|
return false;
|
|
}
|
|
@Override
|
|
public DropTarget getDropTargetDelegate(DragSource source, int x, int y, int xOffset,
|
|
int yOffset, DragView dragView, Object dragInfo) {
|
|
return null;
|
|
}
|
|
@Override
|
|
public void onDragEnter(DragSource source, int x, int y, int xOffset, int yOffset,
|
|
DragView dragView, Object dragInfo) {}
|
|
@Override
|
|
public void onDragExit(DragSource source, int x, int y, int xOffset, int yOffset,
|
|
DragView dragView, Object dragInfo) {}
|
|
@Override
|
|
public void onDragOver(DragSource source, int x, int y, int xOffset, int yOffset,
|
|
DragView dragView, Object dragInfo) {}
|
|
@Override
|
|
public void onDrop(DragSource source, int x, int y, int xOffset, int yOffset,
|
|
DragView dragView, Object dragInfo) {}
|
|
|
|
public boolean isDropEnabled() {
|
|
return true;
|
|
}
|
|
}
|