Initial Contribution

samples/Home/src/com/example/android/home/Home.java

@@ -0,0 +1,690 @@
+/*
+ * 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.ContentResolver;
+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.content.res.Resources;
+import android.database.ContentObserver;
+import android.database.Cursor;
+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.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.PaintDrawable;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+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 android.net.Uri;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+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";
+
+    // 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 Handler mHandler = new Handler();
+
+    private final BroadcastReceiver mWallpaperReceiver = new WallpaperIntentReceiver();
+    private final BroadcastReceiver mApplicationsReceiver = new ApplicationsIntentReceiver();
+    private final ContentObserver mObserver = new FavoritesChangeObserver();
+
+    private GridView mGrid;
+
+    private LayoutAnimationController mShowLayoutAnimation;
+    private LayoutAnimationController mHideLayoutAnimation;
+
+    private boolean mBlockAnimation;
+
+    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();
+        registerContentObservers();
+
+        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);
+        }
+
+        getContentResolver().unregisterContentObserver(mObserver);
+        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);
+    }
+
+    /**
+     * Registers various content observers. The current implementation registers
+     * only a favorites observer to keep track of the favorites applications.
+     */
+    private void registerContentObservers() {
+        ContentResolver resolver = getContentResolver();
+        resolver.registerContentObserver(Uri.parse("content://" +
+                android.provider.Settings.AUTHORITY + "/favorites?notify=true"), true, mObserver);
+    }
+
+    /**
+     * 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(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) {
+            final Cursor c = getContentResolver().query(Uri.parse("content://" +
+                android.provider.Settings.AUTHORITY + "/favorites?notify=true"),
+                    null, null, null, "cellX");
+
+            final int intentIndex = c.getColumnIndexOrThrow("intent");
+            final int titleIndex = c.getColumnIndexOrThrow("title");
+            final int typeIndex = c.getColumnIndexOrThrow("itemType");
+
+            final PackageManager manager = getPackageManager();
+
+            ApplicationInfo info;
+            String intentDescription;
+
+            if (mFavorites == null) {
+                mFavorites = new LinkedList<ApplicationInfo>();
+            } else {
+                mFavorites.clear();
+            }
+
+            while (c.moveToNext()) {
+                final int itemType = c.getInt(typeIndex);
+
+                if (itemType == 0 || // 0 == application
+                    itemType == 1) { // 1 == shortcut
+
+                    intentDescription = c.getString(intentIndex);
+                    if (intentDescription == null) {
+                        continue;
+                    }
+
+                    Intent intent;
+                    try {
+                        intent = Intent.getIntent(intentDescription);
+                    } catch (java.net.URISyntaxException e) {
+                        continue;
+                    }
+                    info = getApplicationInfo(manager, intent);
+                    if (info != null) {
+                        info.title = c.getString(titleIndex);
+                        info.intent = intent;
+                        mFavorites.addFirst(info);
+                    }
+                }
+            }
+
+            c.close();
+        }
+
+        mApplicationsStack.setFavorites(mFavorites);
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * When the notification that favorites have changed is received, requests
+     * a favorites list refresh.
+     */
+    private void onFavoritesChanged() {
+        bindFavorites(false);
+    }
+
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        if (event.getAction() == KeyEvent.ACTION_DOWN) {
+            switch (event.getKeyCode()) {
+                case KeyEvent.KEYCODE_BACK:
+                    return true;
+                case KeyEvent.KEYCODE_HOME:
+                    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(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(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(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);
+        }
+    }
+
+    /**
+     * Receives notifications whenever the user favorites have changed.
+     */
+    private class FavoritesChangeObserver extends ContentObserver {
+        public FavoritesChangeObserver() {
+            super(mHandler);
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            onFavoritesChanged();
+        }
+    }
+
+    /**
+     * 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);
+            }
+
+            //final ImageView imageView = (ImageView) convertView.findViewById(R.id.icon);
+            Drawable icon = info.icon;
+
+            if (!info.filtered) {
+                final Resources resources = getContext().getResources();
+                int width = (int) resources.getDimension(android.R.dimen.app_icon_size);
+                int height = (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);
+        }
+    }
+}