773 lines
26 KiB
Java
773 lines
26 KiB
Java
/*
|
|
* Copyright (C) 2007 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.example.android.home;
|
|
|
|
import android.app.Activity;
|
|
import android.app.ActivityManager;
|
|
import android.app.SearchManager;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.pm.ActivityInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
import android.graphics.PaintFlagsDrawFilter;
|
|
import android.graphics.PixelFormat;
|
|
import android.graphics.Rect;
|
|
import android.graphics.ColorFilter;
|
|
import android.graphics.drawable.BitmapDrawable;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.graphics.drawable.PaintDrawable;
|
|
import android.os.Bundle;
|
|
import android.os.Environment;
|
|
import android.util.Log;
|
|
import android.util.Xml;
|
|
import android.view.KeyEvent;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.animation.Animation;
|
|
import android.view.animation.AnimationUtils;
|
|
import android.view.animation.LayoutAnimationController;
|
|
import android.widget.AdapterView;
|
|
import android.widget.ArrayAdapter;
|
|
import android.widget.CheckBox;
|
|
import android.widget.GridView;
|
|
import android.widget.TextView;
|
|
|
|
import java.io.IOException;
|
|
import java.io.FileReader;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
|
|
public class Home extends Activity {
|
|
/**
|
|
* Tag used for logging errors.
|
|
*/
|
|
private static final String LOG_TAG = "Home";
|
|
|
|
/**
|
|
* Keys during freeze/thaw.
|
|
*/
|
|
private static final String KEY_SAVE_GRID_OPENED = "grid.opened";
|
|
|
|
private static final String DEFAULT_FAVORITES_PATH = "etc/favorites.xml";
|
|
|
|
private static final String TAG_FAVORITES = "favorites";
|
|
private static final String TAG_FAVORITE = "favorite";
|
|
private static final String TAG_PACKAGE = "package";
|
|
private static final String TAG_CLASS = "class";
|
|
|
|
// Identifiers for option menu items
|
|
private static final int MENU_WALLPAPER_SETTINGS = Menu.FIRST + 1;
|
|
private static final int MENU_SEARCH = MENU_WALLPAPER_SETTINGS + 1;
|
|
private static final int MENU_SETTINGS = MENU_SEARCH + 1;
|
|
|
|
/**
|
|
* Maximum number of recent tasks to query.
|
|
*/
|
|
private static final int MAX_RECENT_TASKS = 20;
|
|
|
|
private static boolean mWallpaperChecked;
|
|
private static ArrayList<ApplicationInfo> mApplications;
|
|
private static LinkedList<ApplicationInfo> mFavorites;
|
|
|
|
private final BroadcastReceiver mWallpaperReceiver = new WallpaperIntentReceiver();
|
|
private final BroadcastReceiver mApplicationsReceiver = new ApplicationsIntentReceiver();
|
|
|
|
private GridView mGrid;
|
|
|
|
private LayoutAnimationController mShowLayoutAnimation;
|
|
private LayoutAnimationController mHideLayoutAnimation;
|
|
|
|
private boolean mBlockAnimation;
|
|
|
|
private boolean mHomeDown;
|
|
private boolean mBackDown;
|
|
|
|
private View mShowApplications;
|
|
private CheckBox mShowApplicationsCheck;
|
|
|
|
private ApplicationsStackLayout mApplicationsStack;
|
|
|
|
private Animation mGridEntry;
|
|
private Animation mGridExit;
|
|
|
|
@Override
|
|
public void onCreate(Bundle icicle) {
|
|
super.onCreate(icicle);
|
|
|
|
setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
|
|
|
|
setContentView(R.layout.home);
|
|
|
|
registerIntentReceivers();
|
|
|
|
setDefaultWallpaper();
|
|
|
|
loadApplications(true);
|
|
|
|
bindApplications();
|
|
bindFavorites(true);
|
|
bindRecents();
|
|
bindButtons();
|
|
|
|
mGridEntry = AnimationUtils.loadAnimation(this, R.anim.grid_entry);
|
|
mGridExit = AnimationUtils.loadAnimation(this, R.anim.grid_exit);
|
|
}
|
|
|
|
@Override
|
|
protected void onNewIntent(Intent intent) {
|
|
super.onNewIntent(intent);
|
|
|
|
// Close the menu
|
|
if (Intent.ACTION_MAIN.equals(intent.getAction())) {
|
|
getWindow().closeAllPanels();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDestroy() {
|
|
super.onDestroy();
|
|
|
|
// Remove the callback for the cached drawables or we leak
|
|
// the previous Home screen on orientation change
|
|
final int count = mApplications.size();
|
|
for (int i = 0; i < count; i++) {
|
|
mApplications.get(i).icon.setCallback(null);
|
|
}
|
|
|
|
unregisterReceiver(mWallpaperReceiver);
|
|
unregisterReceiver(mApplicationsReceiver);
|
|
}
|
|
|
|
@Override
|
|
protected void onResume() {
|
|
super.onResume();
|
|
bindRecents();
|
|
}
|
|
|
|
@Override
|
|
protected void onRestoreInstanceState(Bundle state) {
|
|
super.onRestoreInstanceState(state);
|
|
final boolean opened = state.getBoolean(KEY_SAVE_GRID_OPENED, false);
|
|
if (opened) {
|
|
showApplications(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onSaveInstanceState(Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
outState.putBoolean(KEY_SAVE_GRID_OPENED, mGrid.getVisibility() == View.VISIBLE);
|
|
}
|
|
|
|
/**
|
|
* Registers various intent receivers. The current implementation registers
|
|
* only a wallpaper intent receiver to let other applications change the
|
|
* wallpaper.
|
|
*/
|
|
private void registerIntentReceivers() {
|
|
IntentFilter filter = new IntentFilter(Intent.ACTION_WALLPAPER_CHANGED);
|
|
registerReceiver(mWallpaperReceiver, filter);
|
|
|
|
filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
|
|
filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
|
|
filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
|
|
filter.addDataScheme("package");
|
|
registerReceiver(mApplicationsReceiver, filter);
|
|
}
|
|
|
|
/**
|
|
* Creates a new appplications adapter for the grid view and registers it.
|
|
*/
|
|
private void bindApplications() {
|
|
if (mGrid == null) {
|
|
mGrid = (GridView) findViewById(R.id.all_apps);
|
|
}
|
|
mGrid.setAdapter(new ApplicationsAdapter(this, mApplications));
|
|
mGrid.setSelection(0);
|
|
|
|
if (mApplicationsStack == null) {
|
|
mApplicationsStack = (ApplicationsStackLayout) findViewById(R.id.faves_and_recents);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Binds actions to the various buttons.
|
|
*/
|
|
private void bindButtons() {
|
|
mShowApplications = findViewById(R.id.show_all_apps);
|
|
mShowApplications.setOnClickListener(new ShowApplications());
|
|
mShowApplicationsCheck = (CheckBox) findViewById(R.id.show_all_apps_check);
|
|
|
|
mGrid.setOnItemClickListener(new ApplicationLauncher());
|
|
}
|
|
|
|
/**
|
|
* When no wallpaper was manually set, a default wallpaper is used instead.
|
|
*/
|
|
private void setDefaultWallpaper() {
|
|
if (!mWallpaperChecked) {
|
|
Drawable wallpaper = peekWallpaper();
|
|
if (wallpaper == null) {
|
|
try {
|
|
clearWallpaper();
|
|
} catch (IOException e) {
|
|
Log.e(LOG_TAG, "Failed to clear wallpaper " + e);
|
|
}
|
|
} else {
|
|
getWindow().setBackgroundDrawable(new ClippedDrawable(wallpaper));
|
|
}
|
|
mWallpaperChecked = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Refreshes the favorite applications stacked over the all apps button.
|
|
* The number of favorites depends on the user.
|
|
*/
|
|
private void bindFavorites(boolean isLaunching) {
|
|
if (!isLaunching || mFavorites == null) {
|
|
|
|
if (mFavorites == null) {
|
|
mFavorites = new LinkedList<ApplicationInfo>();
|
|
} else {
|
|
mFavorites.clear();
|
|
}
|
|
mApplicationsStack.setFavorites(mFavorites);
|
|
|
|
FileReader favReader;
|
|
|
|
// Environment.getRootDirectory() is a fancy way of saying ANDROID_ROOT or "/system".
|
|
final File favFile = new File(Environment.getRootDirectory(), DEFAULT_FAVORITES_PATH);
|
|
try {
|
|
favReader = new FileReader(favFile);
|
|
} catch (FileNotFoundException e) {
|
|
Log.e(LOG_TAG, "Couldn't find or open favorites file " + favFile);
|
|
return;
|
|
}
|
|
|
|
final Intent intent = new Intent(Intent.ACTION_MAIN, null);
|
|
intent.addCategory(Intent.CATEGORY_LAUNCHER);
|
|
|
|
final PackageManager packageManager = getPackageManager();
|
|
|
|
try {
|
|
final XmlPullParser parser = Xml.newPullParser();
|
|
parser.setInput(favReader);
|
|
|
|
beginDocument(parser, TAG_FAVORITES);
|
|
|
|
ApplicationInfo info;
|
|
|
|
while (true) {
|
|
nextElement(parser);
|
|
|
|
String name = parser.getName();
|
|
if (!TAG_FAVORITE.equals(name)) {
|
|
break;
|
|
}
|
|
|
|
final String favoritePackage = parser.getAttributeValue(null, TAG_PACKAGE);
|
|
final String favoriteClass = parser.getAttributeValue(null, TAG_CLASS);
|
|
|
|
final ComponentName cn = new ComponentName(favoritePackage, favoriteClass);
|
|
intent.setComponent(cn);
|
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
|
|
|
info = getApplicationInfo(packageManager, intent);
|
|
if (info != null) {
|
|
info.intent = intent;
|
|
mFavorites.addFirst(info);
|
|
}
|
|
}
|
|
} catch (XmlPullParserException e) {
|
|
Log.w(LOG_TAG, "Got exception parsing favorites.", e);
|
|
} catch (IOException e) {
|
|
Log.w(LOG_TAG, "Got exception parsing favorites.", e);
|
|
}
|
|
}
|
|
|
|
mApplicationsStack.setFavorites(mFavorites);
|
|
}
|
|
|
|
private static void beginDocument(XmlPullParser parser, String firstElementName)
|
|
throws XmlPullParserException, IOException {
|
|
|
|
int type;
|
|
while ((type = parser.next()) != XmlPullParser.START_TAG &&
|
|
type != XmlPullParser.END_DOCUMENT) {
|
|
// Empty
|
|
}
|
|
|
|
if (type != XmlPullParser.START_TAG) {
|
|
throw new XmlPullParserException("No start tag found");
|
|
}
|
|
|
|
if (!parser.getName().equals(firstElementName)) {
|
|
throw new XmlPullParserException("Unexpected start tag: found " + parser.getName() +
|
|
", expected " + firstElementName);
|
|
}
|
|
}
|
|
|
|
private static void nextElement(XmlPullParser parser) throws XmlPullParserException, IOException {
|
|
int type;
|
|
while ((type = parser.next()) != XmlPullParser.START_TAG &&
|
|
type != XmlPullParser.END_DOCUMENT) {
|
|
// Empty
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Refreshes the recently launched applications stacked over the favorites. The number
|
|
* of recents depends on how many favorites are present.
|
|
*/
|
|
private void bindRecents() {
|
|
final PackageManager manager = getPackageManager();
|
|
final ActivityManager tasksManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
|
|
final List<ActivityManager.RecentTaskInfo> recentTasks = tasksManager.getRecentTasks(
|
|
MAX_RECENT_TASKS, 0);
|
|
|
|
final int count = recentTasks.size();
|
|
final ArrayList<ApplicationInfo> recents = new ArrayList<ApplicationInfo>();
|
|
|
|
for (int i = count - 1; i >= 0; i--) {
|
|
final Intent intent = recentTasks.get(i).baseIntent;
|
|
|
|
if (Intent.ACTION_MAIN.equals(intent.getAction()) &&
|
|
!intent.hasCategory(Intent.CATEGORY_HOME)) {
|
|
|
|
ApplicationInfo info = getApplicationInfo(manager, intent);
|
|
if (info != null) {
|
|
info.intent = intent;
|
|
if (!mFavorites.contains(info)) {
|
|
recents.add(info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mApplicationsStack.setRecents(recents);
|
|
}
|
|
|
|
private static ApplicationInfo getApplicationInfo(PackageManager manager, Intent intent) {
|
|
final ResolveInfo resolveInfo = manager.resolveActivity(intent, 0);
|
|
|
|
if (resolveInfo == null) {
|
|
return null;
|
|
}
|
|
|
|
final ApplicationInfo info = new ApplicationInfo();
|
|
final ActivityInfo activityInfo = resolveInfo.activityInfo;
|
|
info.icon = activityInfo.loadIcon(manager);
|
|
if (info.title == null || info.title.length() == 0) {
|
|
info.title = activityInfo.loadLabel(manager);
|
|
}
|
|
if (info.title == null) {
|
|
info.title = "";
|
|
}
|
|
return info;
|
|
}
|
|
|
|
@Override
|
|
public void onWindowFocusChanged(boolean hasFocus) {
|
|
super.onWindowFocusChanged(hasFocus);
|
|
if (!hasFocus) {
|
|
mBackDown = mHomeDown = false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean dispatchKeyEvent(KeyEvent event) {
|
|
if (event.getAction() == KeyEvent.ACTION_DOWN) {
|
|
switch (event.getKeyCode()) {
|
|
case KeyEvent.KEYCODE_BACK:
|
|
mBackDown = true;
|
|
return true;
|
|
case KeyEvent.KEYCODE_HOME:
|
|
mHomeDown = true;
|
|
return true;
|
|
}
|
|
} else if (event.getAction() == KeyEvent.ACTION_UP) {
|
|
switch (event.getKeyCode()) {
|
|
case KeyEvent.KEYCODE_BACK:
|
|
if (!event.isCanceled()) {
|
|
// Do BACK behavior.
|
|
}
|
|
mBackDown = true;
|
|
return true;
|
|
case KeyEvent.KEYCODE_HOME:
|
|
if (!event.isCanceled()) {
|
|
// Do HOME behavior.
|
|
}
|
|
mHomeDown = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return super.dispatchKeyEvent(event);
|
|
}
|
|
|
|
@Override
|
|
public boolean onCreateOptionsMenu(Menu menu) {
|
|
super.onCreateOptionsMenu(menu);
|
|
|
|
menu.add(0, MENU_WALLPAPER_SETTINGS, 0, R.string.menu_wallpaper)
|
|
.setIcon(android.R.drawable.ic_menu_gallery)
|
|
.setAlphabeticShortcut('W');
|
|
menu.add(0, MENU_SEARCH, 0, R.string.menu_search)
|
|
.setIcon(android.R.drawable.ic_search_category_default)
|
|
.setAlphabeticShortcut(SearchManager.MENU_KEY);
|
|
menu.add(0, MENU_SETTINGS, 0, R.string.menu_settings)
|
|
.setIcon(android.R.drawable.ic_menu_preferences)
|
|
.setIntent(new Intent(android.provider.Settings.ACTION_SETTINGS));
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
switch (item.getItemId()) {
|
|
case MENU_WALLPAPER_SETTINGS:
|
|
startWallpaper();
|
|
return true;
|
|
case MENU_SEARCH:
|
|
onSearchRequested();
|
|
return true;
|
|
}
|
|
|
|
return super.onOptionsItemSelected(item);
|
|
}
|
|
|
|
private void startWallpaper() {
|
|
final Intent pickWallpaper = new Intent(Intent.ACTION_SET_WALLPAPER);
|
|
startActivity(Intent.createChooser(pickWallpaper, getString(R.string.menu_wallpaper)));
|
|
}
|
|
|
|
/**
|
|
* Loads the list of installed applications in mApplications.
|
|
*/
|
|
private void loadApplications(boolean isLaunching) {
|
|
if (isLaunching && mApplications != null) {
|
|
return;
|
|
}
|
|
|
|
PackageManager manager = getPackageManager();
|
|
|
|
Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
|
|
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
|
|
|
|
final List<ResolveInfo> apps = manager.queryIntentActivities(mainIntent, 0);
|
|
Collections.sort(apps, new ResolveInfo.DisplayNameComparator(manager));
|
|
|
|
if (apps != null) {
|
|
final int count = apps.size();
|
|
|
|
if (mApplications == null) {
|
|
mApplications = new ArrayList<ApplicationInfo>(count);
|
|
}
|
|
mApplications.clear();
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
ApplicationInfo application = new ApplicationInfo();
|
|
ResolveInfo info = apps.get(i);
|
|
|
|
application.title = info.loadLabel(manager);
|
|
application.setActivity(new ComponentName(
|
|
info.activityInfo.applicationInfo.packageName,
|
|
info.activityInfo.name),
|
|
Intent.FLAG_ACTIVITY_NEW_TASK
|
|
| Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
|
|
application.icon = info.activityInfo.loadIcon(manager);
|
|
|
|
mApplications.add(application);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows all of the applications by playing an animation on the grid.
|
|
*/
|
|
private void showApplications(boolean animate) {
|
|
if (mBlockAnimation) {
|
|
return;
|
|
}
|
|
mBlockAnimation = true;
|
|
|
|
mShowApplicationsCheck.toggle();
|
|
|
|
if (mShowLayoutAnimation == null) {
|
|
mShowLayoutAnimation = AnimationUtils.loadLayoutAnimation(
|
|
this, R.anim.show_applications);
|
|
}
|
|
|
|
// This enables a layout animation; if you uncomment this code, you need to
|
|
// comment the line mGrid.startAnimation() below
|
|
// mGrid.setLayoutAnimationListener(new ShowGrid());
|
|
// mGrid.setLayoutAnimation(mShowLayoutAnimation);
|
|
// mGrid.startLayoutAnimation();
|
|
|
|
if (animate) {
|
|
mGridEntry.setAnimationListener(new ShowGrid());
|
|
mGrid.startAnimation(mGridEntry);
|
|
}
|
|
|
|
mGrid.setVisibility(View.VISIBLE);
|
|
|
|
if (!animate) {
|
|
mBlockAnimation = false;
|
|
}
|
|
|
|
// ViewDebug.startHierarchyTracing("Home", mGrid);
|
|
}
|
|
|
|
/**
|
|
* Hides all of the applications by playing an animation on the grid.
|
|
*/
|
|
private void hideApplications() {
|
|
if (mBlockAnimation) {
|
|
return;
|
|
}
|
|
mBlockAnimation = true;
|
|
|
|
mShowApplicationsCheck.toggle();
|
|
|
|
if (mHideLayoutAnimation == null) {
|
|
mHideLayoutAnimation = AnimationUtils.loadLayoutAnimation(
|
|
this, R.anim.hide_applications);
|
|
}
|
|
|
|
mGridExit.setAnimationListener(new HideGrid());
|
|
mGrid.startAnimation(mGridExit);
|
|
mGrid.setVisibility(View.INVISIBLE);
|
|
mShowApplications.requestFocus();
|
|
|
|
// This enables a layout animation; if you uncomment this code, you need to
|
|
// comment the line mGrid.startAnimation() above
|
|
// mGrid.setLayoutAnimationListener(new HideGrid());
|
|
// mGrid.setLayoutAnimation(mHideLayoutAnimation);
|
|
// mGrid.startLayoutAnimation();
|
|
}
|
|
|
|
/**
|
|
* Receives intents from other applications to change the wallpaper.
|
|
*/
|
|
private class WallpaperIntentReceiver extends BroadcastReceiver {
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
getWindow().setBackgroundDrawable(new ClippedDrawable(getWallpaper()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Receives notifications when applications are added/removed.
|
|
*/
|
|
private class ApplicationsIntentReceiver extends BroadcastReceiver {
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
loadApplications(false);
|
|
bindApplications();
|
|
bindRecents();
|
|
bindFavorites(false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GridView adapter to show the list of all installed applications.
|
|
*/
|
|
private class ApplicationsAdapter extends ArrayAdapter<ApplicationInfo> {
|
|
private Rect mOldBounds = new Rect();
|
|
|
|
public ApplicationsAdapter(Context context, ArrayList<ApplicationInfo> apps) {
|
|
super(context, 0, apps);
|
|
}
|
|
|
|
@Override
|
|
public View getView(int position, View convertView, ViewGroup parent) {
|
|
final ApplicationInfo info = mApplications.get(position);
|
|
|
|
if (convertView == null) {
|
|
final LayoutInflater inflater = getLayoutInflater();
|
|
convertView = inflater.inflate(R.layout.application, parent, false);
|
|
}
|
|
|
|
Drawable icon = info.icon;
|
|
|
|
if (!info.filtered) {
|
|
//final Resources resources = getContext().getResources();
|
|
int width = 42;//(int) resources.getDimension(android.R.dimen.app_icon_size);
|
|
int height = 42;//(int) resources.getDimension(android.R.dimen.app_icon_size);
|
|
|
|
final int iconWidth = icon.getIntrinsicWidth();
|
|
final int iconHeight = icon.getIntrinsicHeight();
|
|
|
|
if (icon instanceof PaintDrawable) {
|
|
PaintDrawable painter = (PaintDrawable) icon;
|
|
painter.setIntrinsicWidth(width);
|
|
painter.setIntrinsicHeight(height);
|
|
}
|
|
|
|
if (width > 0 && height > 0 && (width < iconWidth || height < iconHeight)) {
|
|
final float ratio = (float) iconWidth / iconHeight;
|
|
|
|
if (iconWidth > iconHeight) {
|
|
height = (int) (width / ratio);
|
|
} else if (iconHeight > iconWidth) {
|
|
width = (int) (height * ratio);
|
|
}
|
|
|
|
final Bitmap.Config c =
|
|
icon.getOpacity() != PixelFormat.OPAQUE ?
|
|
Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;
|
|
final Bitmap thumb = Bitmap.createBitmap(width, height, c);
|
|
final Canvas canvas = new Canvas(thumb);
|
|
canvas.setDrawFilter(new PaintFlagsDrawFilter(Paint.DITHER_FLAG, 0));
|
|
// Copy the old bounds to restore them later
|
|
// If we were to do oldBounds = icon.getBounds(),
|
|
// the call to setBounds() that follows would
|
|
// change the same instance and we would lose the
|
|
// old bounds
|
|
mOldBounds.set(icon.getBounds());
|
|
icon.setBounds(0, 0, width, height);
|
|
icon.draw(canvas);
|
|
icon.setBounds(mOldBounds);
|
|
icon = info.icon = new BitmapDrawable(thumb);
|
|
info.filtered = true;
|
|
}
|
|
}
|
|
|
|
final TextView textView = (TextView) convertView.findViewById(R.id.label);
|
|
textView.setCompoundDrawablesWithIntrinsicBounds(null, icon, null, null);
|
|
textView.setText(info.title);
|
|
|
|
return convertView;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows and hides the applications grid view.
|
|
*/
|
|
private class ShowApplications implements View.OnClickListener {
|
|
public void onClick(View v) {
|
|
if (mGrid.getVisibility() != View.VISIBLE) {
|
|
showApplications(true);
|
|
} else {
|
|
hideApplications();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hides the applications grid when the layout animation is over.
|
|
*/
|
|
private class HideGrid implements Animation.AnimationListener {
|
|
public void onAnimationStart(Animation animation) {
|
|
}
|
|
|
|
public void onAnimationEnd(Animation animation) {
|
|
mBlockAnimation = false;
|
|
}
|
|
|
|
public void onAnimationRepeat(Animation animation) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows the applications grid when the layout animation is over.
|
|
*/
|
|
private class ShowGrid implements Animation.AnimationListener {
|
|
public void onAnimationStart(Animation animation) {
|
|
}
|
|
|
|
public void onAnimationEnd(Animation animation) {
|
|
mBlockAnimation = false;
|
|
// ViewDebug.stopHierarchyTracing();
|
|
}
|
|
|
|
public void onAnimationRepeat(Animation animation) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Starts the selected activity/application in the grid view.
|
|
*/
|
|
private class ApplicationLauncher implements AdapterView.OnItemClickListener {
|
|
public void onItemClick(AdapterView parent, View v, int position, long id) {
|
|
ApplicationInfo app = (ApplicationInfo) parent.getItemAtPosition(position);
|
|
startActivity(app.intent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* When a drawable is attached to a View, the View gives the Drawable its dimensions
|
|
* by calling Drawable.setBounds(). In this application, the View that draws the
|
|
* wallpaper has the same size as the screen. However, the wallpaper might be larger
|
|
* that the screen which means it will be automatically stretched. Because stretching
|
|
* a bitmap while drawing it is very expensive, we use a ClippedDrawable instead.
|
|
* This drawable simply draws another wallpaper but makes sure it is not stretched
|
|
* by always giving it its intrinsic dimensions. If the wallpaper is larger than the
|
|
* screen, it will simply get clipped but it won't impact performance.
|
|
*/
|
|
private class ClippedDrawable extends Drawable {
|
|
private final Drawable mWallpaper;
|
|
|
|
public ClippedDrawable(Drawable wallpaper) {
|
|
mWallpaper = wallpaper;
|
|
}
|
|
|
|
@Override
|
|
public void setBounds(int left, int top, int right, int bottom) {
|
|
super.setBounds(left, top, right, bottom);
|
|
// Ensure the wallpaper is as large as it really is, to avoid stretching it
|
|
// at drawing time
|
|
mWallpaper.setBounds(left, top, left + mWallpaper.getIntrinsicWidth(),
|
|
top + mWallpaper.getIntrinsicHeight());
|
|
}
|
|
|
|
public void draw(Canvas canvas) {
|
|
mWallpaper.draw(canvas);
|
|
}
|
|
|
|
public void setAlpha(int alpha) {
|
|
mWallpaper.setAlpha(alpha);
|
|
}
|
|
|
|
public void setColorFilter(ColorFilter cf) {
|
|
mWallpaper.setColorFilter(cf);
|
|
}
|
|
|
|
public int getOpacity() {
|
|
return mWallpaper.getOpacity();
|
|
}
|
|
}
|
|
}
|