cooliris/media/TimeBar.java

/*
 * Copyright (C) 2009 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.cooliris.media;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashMap;

import javax.microedition.khronos.opengles.GL11;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.NinePatch;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.util.SparseArray;
import android.view.MotionEvent;

import com.cooliris.app.App;
import com.cooliris.app.Res;
import com.cooliris.media.RenderView.Lists;

public final class TimeBar extends Layer implements MediaFeed.Listener {
    public static final int HEIGHT = 48;
    private static final int MARKER_SPACING_PIXELS = 50;
    private static final float AUTO_SCROLL_MARGIN = 100f;
    private static final Paint SRC_PAINT = new Paint();
    private Listener mListener = null;
    private MediaFeed mFeed = null;
    private float mTotalWidth = 0f;
    private float mPosition = 0f;
    private float mPositionAnim = 0f;
    private float mScroll = 0f;
    private float mScrollAnim = 0f;
    private boolean mInDrag = false;
    private float mDragX = 0f;

    private ArrayList<Marker> mMarkers = new ArrayList<Marker>();
    private ArrayList<Marker> mMarkersCopy = new ArrayList<Marker>();

    private static final int KNOB = Res.drawable.scroller_new;
    private static final int KNOB_PRESSED = Res.drawable.scroller_pressed_new;
    private final StringTexture.Config mMonthYearFormat = new StringTexture.Config();
    private final StringTexture.Config mDayFormat = new StringTexture.Config();
    private final SparseArray<StringTexture> mYearLabels = new SparseArray<StringTexture>();
    private StringTexture mDateUnknown;
    private final StringTexture[] mMonthLabels = new StringTexture[12];
    private final StringTexture[] mDayLabels = new StringTexture[32];
    private final StringTexture[] mOpaqueDayLabels = new StringTexture[32];
    private final StringTexture mDot = new StringTexture("");
    private final HashMap<MediaItem, Marker> mTracker = new HashMap<MediaItem, Marker>(1024);
    private int mState;
    private float mTextAlpha = 0.0f;
    private float mAnimTextAlpha = 0.0f;
    private boolean mShowTime;
    private NinePatch mBackground;
    private Rect mBackgroundRect;
    private BitmapTexture mBackgroundTexture;

    public interface Listener {
        public void onTimeChanged(TimeBar timebar);
    }

    TimeBar(Context context) {
        // Setup formatting for text labels.
        mMonthYearFormat.fontSize = 17f * App.PIXEL_DENSITY;
        mMonthYearFormat.bold = true;
        mMonthYearFormat.a = 0.85f;
        mDayFormat.fontSize = 17f * App.PIXEL_DENSITY;
        mDayFormat.a = 0.61f;
        regenerateStringsForContext(context);
        Bitmap background = BitmapFactory.decodeResource(context.getResources(), Res.drawable.popup);
        mBackground = new NinePatch(background, background.getNinePatchChunk(), null);
        mBackgroundRect = new Rect();
        SRC_PAINT.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
    }

    public void regenerateStringsForContext(Context context) {
        // Create textures for month names.
        String[] months = context.getResources().getStringArray(Res.array.months_abbreviated);
        for (int i = 0; i < months.length; ++i) {
            mMonthLabels[i] = new StringTexture(months[i], mMonthYearFormat);
        }

        for (int i = 0; i <= 31; ++i) {
            mDayLabels[i] = new StringTexture(Integer.toString(i), mDayFormat);
            mOpaqueDayLabels[i] = new StringTexture(Integer.toString(i), mMonthYearFormat);
        }
        mDateUnknown = new StringTexture(context.getResources().getString(Res.string.date_unknown), mMonthYearFormat);
        mBackgroundTexture = null;
    }

    public void setListener(Listener listener) {
        mListener = listener;
    }

    public void setFeed(MediaFeed feed, int state, boolean needsLayout) {
        mFeed = feed;
        mState = state;
        layout();
        if (needsLayout) {
            mPosition = 0;
            mScroll = getScrollForPosition(mPosition);
        }
    }

    @Override
    protected void onSizeChanged() {
        mScroll = getScrollForPosition(mPosition);
    }

    public MediaItem getItem() {
        synchronized (mMarkers) {
            // x is between 0 and 1.0f
            int numMarkers = mMarkers.size();
            if (numMarkers == 0)
                return null;
            int index = (int) (mPosition * (numMarkers));
            if (index >= numMarkers)
                index = numMarkers - 1;
            Marker marker = mMarkers.get(index);
            if (marker != null) {
                // we have to find the index of the media item depending upon
                // the value of mPosition
                float deltaBetweenMarkers = 1.0f / numMarkers;
                float increment = mPosition - index * deltaBetweenMarkers;
                // if (increment > deltaBetweenMarkers)
                // increment = deltaBetweenMarkers;
                // if (increment < 0)
                // increment = 0;
                ArrayList<MediaItem> items = marker.items;
                int numItems = items.size();
                if (numItems == 0)
                    return null;
                int itemIndex = (int) ((numItems) * increment / deltaBetweenMarkers);
                if (itemIndex >= numItems)
                    itemIndex = numItems - 1;
                return marker.items.get(itemIndex);
            }
        }
        return null;
    }

    private Marker getAnchorMarker() {
        synchronized (mMarkers) {
            // x is between 0 and 1.0f
            int numMarkers = mMarkers.size();
            if (numMarkers == 0)
                return null;
            int index = (int) (mPosition * (numMarkers));
            if (index >= numMarkers)
                index = numMarkers - 1;
            Marker marker = mMarkers.get(index);
            return marker;
        }
    }

    public void setItem(MediaItem item) {
        Marker marker = mTracker.get(item);
        if (marker != null) {
            float markerX = (mTotalWidth == 0.0f) ? 0.0f : marker.x / mTotalWidth;
            mPosition = Math.max(0.0f, Math.min(1.0f, markerX));
            mScroll = getScrollForPosition(mPosition);
        }
    }

    @SuppressWarnings("unchecked")
    private void layout() {
        if (mFeed != null) {
            // Clear existing markers.
            mTracker.clear();
            synchronized (mMarkers) {
                mMarkers.clear();
            }
            float scrollX = mScroll;
            // Place markers for every time interval that intersects one of the
            // clusters.
            // Markers for a full month would be for example: Jan 5 10 15 20 25
            // 30.
            MediaFeed feed = mFeed;
            int lastYear = -1;
            int lastMonth = -1;
            int lastDayBlock = -1;
            float dx = 0f;
            int increment = 12;
            MediaSet set = null;
            mShowTime = true;
            if (mState == GridLayer.STATE_GRID_VIEW) {
                set = feed.getFilteredSet();
                if (set == null) {
                    set = feed.getCurrentSet();
                }
            } else {
                increment = 2;
                if (!feed.hasExpandedMediaSet()) {
                    mShowTime = false;
                }
                set = new MediaSet();
                int numSlots = feed.getNumSlots();
                for (int i = 0; i < numSlots; ++i) {
                    MediaSet slotSet = feed.getSetForSlot(i);
                    if (slotSet != null) {
                        ArrayList<MediaItem> slotSetItems = slotSet.getItems();
                        if (slotSetItems != null && slotSet.getNumItems() > 0) {
                            MediaItem item = slotSetItems.get(0);
                            if (item != null) {
                                set.addItem(item);
                            }
                        }
                    }
                }
            }
            if (set != null) {
                GregorianCalendar time = new GregorianCalendar();
                ArrayList<MediaItem> items = set.getItems();
                if (items != null) {
                    items = (ArrayList<MediaItem>)items.clone();
                    int j = 0;
                    while (j < set.getNumItems()) {
                        final MediaItem item = items.get(j);
                        if (item == null)
                            continue;
                        time.setTimeInMillis(item.mDateTakenInMs);
                        // Detect year rollovers.
                        final int year = time.get(Calendar.YEAR);
                        if (year != lastYear) {
                            lastYear = year;
                            lastMonth = -1;
                            lastDayBlock = -1;
                        }
                        Marker marker = null;
                        // Detect month rollovers and emit a month marker.
                        final int month = time.get(Calendar.MONTH);
                        final int dayBlock = time.get(Calendar.DATE);
                        if (month != lastMonth) {
                            lastMonth = month;
                            lastDayBlock = -1;
                            marker = new Marker(dx, time.getTimeInMillis(), year, month, dayBlock, Marker.TYPE_MONTH, increment);
                            dx = addMarker(marker);
                        } else if (dayBlock != lastDayBlock) {
                            lastDayBlock = dayBlock;
                            if (dayBlock != 0) {
                                marker = new Marker(dx, time.getTimeInMillis(), year, month, dayBlock, Marker.TYPE_DAY, increment);
                                dx = addMarker(marker);
                            }
                        } else {
                            marker = new Marker(dx, time.getTimeInMillis(), year, month, dayBlock, Marker.TYPE_DOT, increment);
                            dx = addMarker(marker);
                        }
                        for (int k = 0; k < increment; ++k) {
                            int index = k + j;
                            if (index < 0)
                                continue;
                            if (index >= items.size())
                                break;
                            if (index == items.size() - 1 && k != 0)
                                break;
                            MediaItem thisItem = items.get(index);
                            marker.items.add(thisItem);
                            mTracker.put(thisItem, marker);
                        }
                        if (j == items.size() - 1)
                            break;
                        j += increment;
                        if (j >= items.size() - 1)
                            j = items.size() - 1;
                    }
                }
                mTotalWidth = dx - MARKER_SPACING_PIXELS * App.PIXEL_DENSITY;
            }
            mPosition = getPositionForScroll(scrollX);
            mPositionAnim = mPosition;
            synchronized (mMarkersCopy) {
                int numMarkers = mMarkers.size();
                mMarkersCopy.clear();
                mMarkersCopy.ensureCapacity(numMarkers);
                for (int i = 0; i < numMarkers; ++i) {
                    mMarkersCopy.add(mMarkers.get(i));
                }
            }
        }
    }

    private float addMarker(Marker marker) {
        mMarkers.add(marker);
        return marker.x + MARKER_SPACING_PIXELS * App.PIXEL_DENSITY;
    }

    /*
     * private float getKnobXForPosition(float position) { return position *
     * (mTotalWidth - mKnob.getWidth()); }
     *
     * private float getPositionForKnobX(float knobX) { return Math.max(0f,
     * Math.min(1f, knobX / (mTotalWidth - mKnob.getWidth()))); }
     *
     * private float getScrollForPosition(float position) { return position *
     * (mTotalWidth - mWidth);// - (1f - 2f * position) * MARKER_SPACING_PIXELS;
     * }
     */

    private float getScrollForPosition(float position) {
        // Map position [0, 1] to scroll [-visibleWidth/2, totalWidth -
        // visibleWidth/2].
        // This has the effect of centering the scroll knob on screen.
        float halfWidth = mWidth * 0.5f;
        float positionInv = 1f - position;
        float centered = positionInv * -halfWidth + position * (mTotalWidth - halfWidth);
        return centered;
    }

    private float getPositionForScroll(float scroll) {
        float halfWidth = mWidth * 0.5f;
        if (mTotalWidth == 0)
            return 0;
        return ((scroll + halfWidth) / (mTotalWidth));
    }

    private float getKnobXForPosition(float position) {
        return position * mTotalWidth;
    }

    private float getPositionForKnobX(float knobX) {
        float normKnobX = (mTotalWidth == 0) ? 0 : knobX / mTotalWidth;
        return Math.max(0f, Math.min(1f, normKnobX));
    }

    @Override
    public boolean update(RenderView view, float dt) {
        // Update animations.
        final float ratio = Math.min(1f, 10f * dt);
        final float invRatio = 1f - ratio;
        mPositionAnim = ratio * mPosition + invRatio * mPositionAnim;
        mScrollAnim = ratio * mScroll + invRatio * mScrollAnim;
        // Handle autoscroll.
        if (mInDrag) {
            final float x = getKnobXForPosition(mPosition) - mScrollAnim;
            float velocity;
            float autoScrollMargin = AUTO_SCROLL_MARGIN * App.PIXEL_DENSITY;
            if (x < autoScrollMargin) {
                velocity = -(float) Math.pow((1f - x / autoScrollMargin), 2);
            } else if (x > mWidth - autoScrollMargin) {
                velocity = (float) Math.pow(1f - (mWidth - x) / autoScrollMargin, 2);
            } else {
                velocity = 0;
            }
            mScroll += velocity * 400f * dt;
            mPosition = getPositionForKnobX(mDragX + mScroll);
            mTextAlpha = 1.0f;
        } else {
            mTextAlpha = 0.0f;
        }
        mAnimTextAlpha = FloatUtils.animate(mAnimTextAlpha, mTextAlpha, dt);
        return mAnimTextAlpha != mTextAlpha;
    }

    @Override
    public void renderBlended(RenderView view, GL11 gl) {
        final float originX = mX;
        final float originY = mY;
        final float scrollOffset = mScrollAnim;
        final float scrolledOriginX = originX - scrollOffset;
        final float position = mPositionAnim;
        final int knobId = mInDrag ? KNOB_PRESSED : KNOB;
        final Texture knob = view.getResource(knobId);
        // Draw the scroller knob.
        if (!mShowTime) {
            if (view.bind(knob)) {
                final float knobWidth = knob.getWidth();
                view.draw2D(scrolledOriginX + getKnobXForPosition(position) - knobWidth * 0.5f, originY, 0f, knobWidth, knob
                        .getHeight());
            }
        } else {
            if (view.bind(knob)) {
                final float knobWidth = knob.getWidth();
                final float knobHeight = knob.getHeight();
                view.draw2D(scrolledOriginX + getKnobXForPosition(position) - knobWidth * 0.5f, view.getHeight() - knobHeight, 0f,
                        knobWidth, knobHeight);
            }
            // we draw the current time on top of the knob
            if (mInDrag || mAnimTextAlpha != 0.0f) {
                Marker anchor = getAnchorMarker();
                if (anchor != null) {
                    Texture month = mMonthLabels[anchor.month];
                    Texture day = mOpaqueDayLabels[anchor.day];
                    Texture year = getYearLabel(anchor.year);
                    boolean validDate = true;
                    if (anchor.year <= 1970) {
                        month = mDateUnknown;
                        day = null;
                        year = null;
                        validDate = false;
                    }
                    view.loadTexture(month);
                    if (validDate) {
                        view.loadTexture(day);
                        view.loadTexture(year);
                    }
                    int numPixelsBufferX = 70;
                    float expectedWidth = month.getWidth()
                            + ((validDate) ? (day.getWidth() + year.getWidth() + 10 * App.PIXEL_DENSITY) : 0);
                    if ((expectedWidth + numPixelsBufferX * App.PIXEL_DENSITY) != mBackgroundRect.right) {
                        mBackgroundRect.right = (int) (expectedWidth + numPixelsBufferX * App.PIXEL_DENSITY);
                        mBackgroundRect.bottom = (int) (month.getHeight() + 20 * App.PIXEL_DENSITY);
                        try {
                            Bitmap bitmap = Bitmap.createBitmap(mBackgroundRect.right, mBackgroundRect.bottom,
                                    Bitmap.Config.ARGB_8888);
                            Canvas canvas = new Canvas();
                            canvas.setBitmap(bitmap);
                            mBackground.draw(canvas, mBackgroundRect, SRC_PAINT);
                            mBackgroundTexture = new BitmapTexture(bitmap);
                            view.loadTexture(mBackgroundTexture);
                            bitmap.recycle();
                        } catch (OutOfMemoryError e) {
                            // Do nothing.
                        }
                    }
                    gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_MODULATE);
                    gl.glColor4f(mAnimTextAlpha, mAnimTextAlpha, mAnimTextAlpha, mAnimTextAlpha);
                    float x = (view.getWidth() - expectedWidth - numPixelsBufferX * App.PIXEL_DENSITY) / 2;
                    float y = (view.getHeight() - 10 * App.PIXEL_DENSITY) * 0.5f;
                    if (mBackgroundTexture != null) {
                        view.draw2D(mBackgroundTexture, x, y);
                    }
                    y = view.getHeight() * 0.5f;
                    x = (view.getWidth() - expectedWidth) / 2;
                    view.draw2D(month, x, y);
                    if (validDate) {
                        x += month.getWidth() + 3 * App.PIXEL_DENSITY;
                        view.draw2D(day, x, y);
                        x += day.getWidth() + 7 * App.PIXEL_DENSITY;
                        view.draw2D(year, x, y);
                    }
                    if (mAnimTextAlpha != 1f) {
                        gl.glColor4f(1f, 1f, 1f, 1f);
                    }
                    gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_REPLACE);
                }
            }
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // Set position on touch movement.
        mDragX = event.getX();
        mPosition = getPositionForKnobX(mDragX + mScroll);

        // Notify the listener.
        if (mListener != null) {
            mListener.onTimeChanged(this);
        }

        // Update state when touch begins and ends.
        switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            mInDrag = true;
            break;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
            // mScroll = getScrollForPosition(mPosition);
            mInDrag = false;

            // Clamp to the nearest marker.
            setItem(getItem());
        default:
            break;
        }

        return true;
    }

    public void onFeedChanged(MediaFeed feed, boolean needsLayout) {
        layout();
    }

    private static final class Marker {
        Marker(float x, long time, int year, int month, int day, int type, int expectedCapacity) {
            this.x = x;
            this.year = year;
            this.month = month;
            this.day = day;
            this.items = new ArrayList<MediaItem>(expectedCapacity);
        }

        public static final int TYPE_MONTH = 1;
        public static final int TYPE_DAY = 2;
        public static final int TYPE_DOT = 3;
        public ArrayList<MediaItem> items;
        public final float x;
        public final int year;
        public final int month;
        public final int day;
    }

    @Override
    public void generate(RenderView view, Lists lists) {
        lists.updateList.add(this);
        lists.blendedList.add(this);
        lists.hitTestList.add(this);
    }

    public void onFeedAboutToChange(MediaFeed feed) {
        // nothing needs to be done
        return;
    }

    private StringTexture getYearLabel(int year) {
        if (year <= 1970)
            return mDot;
        StringTexture label = mYearLabels.get(year);
        if (label == null) {
            label = new StringTexture(Integer.toString(year), mMonthYearFormat);
            mYearLabels.put(year, label);
        }
        return label;
    }

    public boolean isDragged() {
        return mInDrag;
    }
}