Android example source code file (GridScenario.java)

This example Android source code file (GridScenario.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Android by Example" ^TM.

Java - Android tags/keywords

activity, android, baseadapter, collections, double, google, gridscenario, gridview, map, myadapter, object, os, params, string, textview, ui, unuseddeclaration, view, viewgroup, widget

The GridScenario.java Android example source code

/*
 * 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 android.util;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.AbsListView;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.GridView;
import android.widget.ListAdapter;
import android.widget.TextView;

import com.google.android.collect.Maps;

import java.util.Map;

/**
 * Utility base class for creating various GridView scenarios.  Configurable by the number
 * of items, how tall each item should be (in relation to the screen height), and
 * what item should start with selection.
 */
public abstract class GridScenario extends Activity {

    private GridView mGridView;

    private int mNumItems;

    private int mStartingSelectionPosition;
    private double mItemScreenSizeFactor;
    private Map<Integer, Double> mOverrideItemScreenSizeFactors = Maps.newHashMap();

    private int mScreenHeight;

    private boolean mStackFromBottom;

    private int mColumnWidth;
    
    private int mNumColumns;
    
    private int mStretchMode;

    private int mVerticalSpacing;

    public GridView getGridView() {
        return mGridView;
    }

    protected int getScreenHeight() {
        return mScreenHeight;
    }
    
    /**
     * @return The initial number of items in the grid as specified by the scenario.
     * This number may change over time.
     */
    protected int getInitialNumItems() {
        return mNumItems;
    }
    
    /**
     * @return The desired height of 1 item, ignoring overrides
     */
    public int getDesiredItemHeight() {
        return (int) (mScreenHeight * mItemScreenSizeFactor);
    }

    /**
     * Better way to pass in optional params than a honkin' paramater list :)
     */
    public static class Params {
        private int mNumItems = 4;
        private int mStartingSelectionPosition = -1;
        private double mItemScreenSizeFactor = 1 / 5;

        private Map<Integer, Double> mOverrideItemScreenSizeFactors = Maps.newHashMap();

        private boolean mStackFromBottom = false;
        private boolean mMustFillScreen = true;

        private int mColumnWidth = 0;
        private int mNumColumns = GridView.AUTO_FIT;
        private int mStretchMode = GridView.STRETCH_COLUMN_WIDTH;
        private int mVerticalSpacing = 0;

        /**
         * Set the number of items in the grid.
         */
        public Params setNumItems(int numItems) {
            mNumItems = numItems;
            return this;
        }

        /**
         * Set the position that starts selected.
         *
         * @param startingSelectionPosition The selected position within the adapter's data set.
         * Pass -1 if you do not want to force a selection.
         * @return
         */
        public Params setStartingSelectionPosition(int startingSelectionPosition) {
            mStartingSelectionPosition = startingSelectionPosition;
            return this;
        }

        /**
         * Set the factor that determines how tall each item is in relation to the
         * screen height.
         */
        public Params setItemScreenSizeFactor(double itemScreenSizeFactor) {
            mItemScreenSizeFactor = itemScreenSizeFactor;
            return this;
        }

        /**
         * Override the item screen size factor for a particular item.  Useful for
         * creating grids with non-uniform item height.
         * @param position The position in the grid.
         * @param itemScreenSizeFactor The screen size factor to use for the height.
         */
        public Params setPositionScreenSizeFactorOverride(
                int position, double itemScreenSizeFactor) {
            mOverrideItemScreenSizeFactors.put(position, itemScreenSizeFactor);
            return this;
        }

        /**
         * Sets the stacking direction
         * @param stackFromBottom
         * @return
         */
        public Params setStackFromBottom(boolean stackFromBottom) {
            mStackFromBottom = stackFromBottom;
            return this;
        }

        /**
         * Sets whether the sum of the height of the grid items must be at least the
         * height of the grid view.
         */
        public Params setMustFillScreen(boolean fillScreen) {
            mMustFillScreen = fillScreen;
            return this;
        }

        /**
         * Sets the individual width of each column.
         *
         * @param requestedWidth the width in pixels of the column
         */
        public Params setColumnWidth(int requestedWidth) {
            mColumnWidth = requestedWidth;
            return this;
        }

        /**
         * Sets the number of columns in the grid.
         */
        public Params setNumColumns(int numColumns) {
            mNumColumns = numColumns;
            return this;
        }
        
        /**
         * Sets the stretch mode.
         */
        public Params setStretchMode(int stretchMode) {
            mStretchMode = stretchMode;
            return this;
        }
        
        /**
         * Sets the spacing between rows in the grid
         */
        public Params setVerticalSpacing(int verticalSpacing) {
            mVerticalSpacing  = verticalSpacing;
            return this;
        }
    }

    /**
     * How each scenario customizes its behavior.
     * @param params
     */
    protected abstract void init(Params params);
    
    /**
     * Override this to provide an different adapter for your scenario
     * @return The adapter that this scenario will use
     */
    protected ListAdapter createAdapter() {
        return new MyAdapter();
    }

    /**
     * Override this if you want to know when something has been selected (perhaps
     * more importantly, that {@link android.widget.AdapterView.OnItemSelectedListener} has
     * been triggered).
     */
    @SuppressWarnings({ "UnusedDeclaration" })
    protected void positionSelected(int positon) {

    }

    /**
     * Override this if you want to know that nothing is selected.
     */
    protected void nothingSelected() {

    }

    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        // turn off title bar
        requestWindowFeature(Window.FEATURE_NO_TITLE);

        mScreenHeight = getWindowManager().getDefaultDisplay().getHeight();

        final Params params = new Params();
        init(params);

        readAndValidateParams(params);

        mGridView = new GridView(this);
        mGridView.setLayoutParams(new ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.MATCH_PARENT));
        mGridView.setDrawSelectorOnTop(false);
        if (mNumColumns >= GridView.AUTO_FIT) {
            mGridView.setNumColumns(mNumColumns);
        }
        if (mColumnWidth > 0) {
            mGridView.setColumnWidth(mColumnWidth);
        }
        if (mVerticalSpacing > 0) {
            mGridView.setVerticalSpacing(mVerticalSpacing);
        }
        mGridView.setStretchMode(mStretchMode);
        mGridView.setAdapter(createAdapter());
        if (mStartingSelectionPosition >= 0) {
            mGridView.setSelection(mStartingSelectionPosition);
        }
        mGridView.setPadding(10, 10, 10, 10);
        mGridView.setStackFromBottom(mStackFromBottom);

        mGridView.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
            public void onItemSelected(AdapterView parent, View v, int position, long id) {
                positionSelected(position);
            }

            public void onNothingSelected(AdapterView parent) {
                nothingSelected();
            }
        });

        setContentView(mGridView);
    }
    
    

    /**
     * Read in and validate all of the params passed in by the scenario.
     * @param params
     */
    private void readAndValidateParams(Params params) {
        if (params.mMustFillScreen ) {
            double totalFactor = 0.0;
            for (int i = 0; i < params.mNumItems; i++) {
                if (params.mOverrideItemScreenSizeFactors.containsKey(i)) {
                    totalFactor += params.mOverrideItemScreenSizeFactors.get(i);
                } else {
                    totalFactor += params.mItemScreenSizeFactor;
                }
            }
            if (totalFactor < 1.0) {
                throw new IllegalArgumentException("grid items must combine to be at least " +
                        "the height of the screen.  this is not the case with " + params.mNumItems
                        + " items and " + params.mItemScreenSizeFactor + " screen factor and " +
                        "screen height of " + mScreenHeight);
            }
        }

        mNumItems = params.mNumItems;
        mStartingSelectionPosition = params.mStartingSelectionPosition;
        mItemScreenSizeFactor = params.mItemScreenSizeFactor;

        mOverrideItemScreenSizeFactors.putAll(params.mOverrideItemScreenSizeFactors);

        mStackFromBottom = params.mStackFromBottom;
        mColumnWidth = params.mColumnWidth;
        mNumColumns = params.mNumColumns;
        mStretchMode = params.mStretchMode;
        mVerticalSpacing = params.mVerticalSpacing;
    }

    public final String getValueAtPosition(int position) {
        return "postion " + position;
    }

    /**
     * Create a view for a grid item.  Override this to create a custom view beyond
     * the simple focusable / unfocusable text view.
     * @param position The position.
     * @param parent The parent
     * @param desiredHeight The height the view should be to respect the desired item
     *   to screen height ratio.
     * @return a view for the grid.
     */
    protected View createView(int position, ViewGroup parent, int desiredHeight) {
        TextView result = new TextView(parent.getContext());
        result.setHeight(desiredHeight);
        result.setText(getValueAtPosition(position));
        final ViewGroup.LayoutParams lp = new AbsListView.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.WRAP_CONTENT);
        result.setLayoutParams(lp);
        result.setId(position);
        result.setBackgroundColor(0x55ffffff);
        return result;
    }



    private class MyAdapter extends BaseAdapter {
        public int getCount() {
            return mNumItems;
        }

        public Object getItem(int position) {
            return getValueAtPosition(position);
        }

        public long getItemId(int position) {
            return position;
        }

        public View getView(int position, View convertView, ViewGroup parent) {
            if (convertView != null) {
                ((TextView) convertView).setText(getValueAtPosition(position));
                convertView.setId(position);
                return convertView;
            }

            int desiredHeight = getDesiredItemHeight();
            if (mOverrideItemScreenSizeFactors.containsKey(position)) {
                desiredHeight = (int) (mScreenHeight * mOverrideItemScreenSizeFactors.get(position));
            }
            return createView(position, parent, desiredHeight);
        }
    }
}