Initial Contribution

1 files changed, 425 insertions, 0 deletions

diff --git a/src/com/android/camera/SlideShow.java b/src/com/android/camera/SlideShow.java
new file mode 100644
index 0000000..ee6c7be
--- /dev/null
+++ b/src/com/android/camera/SlideShow.java
@@ -0,0 +1,425 @@
+/*
+ * 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.android.camera;
+
+import static android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Paint;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.drawable.BitmapDrawable;
+import android.net.Uri;
+import android.os.Environment;
+import android.os.Handler;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.os.Message;
+import android.view.View;
+import android.view.Window;
+import android.widget.ImageView;
+import android.widget.ViewSwitcher;
+import android.widget.Gallery.LayoutParams;
+
+import android.view.WindowManager;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import com.android.camera.ImageManager.IGetBitmap_cancelable;
+import com.android.camera.ImageManager.IImage;
+import com.android.camera.ImageManager.IImageList;
+
+import android.view.MotionEvent;
+
+public class SlideShow extends Activity implements ViewSwitcher.ViewFactory
+{
+    static final private String TAG = "SlideShow";
+    static final int sLag = 2000;
+    static final int sNextImageInterval = 3000;
+    private ImageManager.IImageList mImageList;
+    private int mCurrentPosition = 0;
+    private ImageView mSwitcher;
+    private boolean mPosted = false;
+    
+    @Override
+    protected void onCreate(Bundle icicle)
+    {
+        super.onCreate(icicle);
+        Window wp = getWindow();
+        wp.setFlags(FLAG_KEEP_SCREEN_ON, FLAG_KEEP_SCREEN_ON);
+        
+        setContentView(R.layout.slide_show);
+        
+        mSwitcher = (ImageView)findViewById(R.id.imageview);
+        if (android.util.Config.LOGV)
+            Log.v(TAG, "mSwitcher " + mSwitcher);
+    }
+    
+    @Override
+    protected void onResume()
+    {
+        super.onResume();
+
+        if (mImageList == null) {
+            mImageList = new FileImageList();
+            mCurrentPosition = 0;
+        }
+        loadImage();
+    }
+    
+    @Override
+    protected void onPause() {
+        super.onPause();
+        cancelPost();
+    }
+    
+    static public class ImageViewTouch extends ImageView {
+        class xy {
+            public xy(float xIn, float yIn) {
+                x = xIn;
+                y = yIn;
+                timeAdded = System.currentTimeMillis();
+            }
+            public xy(MotionEvent e) {
+                x = e.getX();
+                y = e.getY();
+                timeAdded = System.currentTimeMillis();
+            }
+            float x,y;
+            long timeAdded;
+        }
+        
+        SlideShow mSlideShow;
+        Paint mPaints[] = new Paint[1];
+        ArrayList<xy> mPoints = new ArrayList<xy>();
+        boolean mDown;
+        
+        public ImageViewTouch(Context context) {
+            super(context);
+            mSlideShow = (SlideShow) context;
+            setScaleType(ImageView.ScaleType.CENTER);
+            setupPaint();
+        }
+        
+        public ImageViewTouch(Context context, AttributeSet attrs) {
+            super(context, attrs);
+            mSlideShow = (SlideShow) context;
+            setScaleType(ImageView.ScaleType.CENTER);
+            setupPaint();
+        }
+        
+        private void setupPaint() {
+            for (int i = 0; i < mPaints.length; i++) {
+                Paint p = new Paint();
+                p.setARGB(255, 255, 255, 0);
+                p.setAntiAlias(true);
+                p.setStyle(Paint.Style.FILL);
+                p.setStrokeWidth(3F);
+                mPaints[i] = p;
+            }
+        }
+        
+        private void addEvent(MotionEvent event) {
+            long now = System.currentTimeMillis();
+            mPoints.add(new xy(event));
+            for (int i = 0; i < event.getHistorySize(); i++)
+                mPoints.add(new xy(event.getHistoricalX(i), event.getHistoricalY(i)));
+            while (mPoints.size() > 0) {
+                xy ev = mPoints.get(0);
+                if (now - ev.timeAdded < sLag)
+                    break;
+                mPoints.remove(0);
+            }
+        }
+        
+        public boolean onTouchEvent(MotionEvent event) {
+            addEvent(event);
+            switch (event.getAction()) {
+                case MotionEvent.ACTION_DOWN:
+                    mDown = true;
+                    mSlideShow.cancelPost();
+                    postInvalidate();
+                    break;
+                case MotionEvent.ACTION_UP:
+                    mDown = false;
+                    postInvalidate();
+                    break;
+                case MotionEvent.ACTION_MOVE:
+                    mSlideShow.cancelPost();
+                    postInvalidate();
+                    break;
+            }
+            return true;
+        }
+
+        protected void onDraw(Canvas canvas) {
+            super.onDraw(canvas);
+
+            boolean didPaint = false;
+            long now = System.currentTimeMillis();
+            for (xy ev: mPoints) {
+                Paint p = mPaints[0];
+                long delta = now - ev.timeAdded;
+                if (delta > sLag)
+                    continue;
+                
+                int alpha2 = Math.max(0, 255 - (255 * (int)delta / sLag));
+                if (alpha2 == 0)
+                    continue;
+                p.setAlpha(alpha2);
+                canvas.drawCircle(ev.x, ev.y, 2, p);
+                didPaint = true;
+            }
+            if (didPaint && !mDown)
+                postInvalidate();
+        }
+    }
+
+    
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_DPAD_LEFT:
+                cancelPost();
+                loadPreviousImage();
+                return true;
+                
+            case KeyEvent.KEYCODE_DPAD_RIGHT:
+                cancelPost();
+                loadNextImage();
+                return true;
+                
+            case KeyEvent.KEYCODE_DPAD_CENTER:
+                if (mPosted) 
+                    cancelPost();
+                else
+                    loadNextImage();
+                return true;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+    
+    private void cancelPost() {
+        mHandler.removeCallbacks(mNextImageRunnable);
+        mPosted = false;
+    }
+    
+    private void post() {
+        mHandler.postDelayed(mNextImageRunnable, sNextImageInterval);
+        mPosted = true;
+    }
+
+    private void loadImage() {
+        ImageManager.IImage image = mImageList.getImageAt(mCurrentPosition);
+        if (image == null)
+            return;
+        
+        Bitmap bitmap = image.thumbBitmap();
+        if (bitmap == null)
+            return;
+
+        mSwitcher.setImageDrawable(new BitmapDrawable(bitmap));
+        post();
+    }
+    
+    private Runnable mNextImageRunnable = new Runnable() {
+        public void run() {
+            if (android.util.Config.LOGV)
+                Log.v(TAG, "mNextImagerunnable called");
+            loadNextImage();
+        }
+    };
+    
+    private void loadNextImage() {
+        if (++mCurrentPosition >= mImageList.getCount())
+            mCurrentPosition = 0;
+        loadImage();
+    }
+    
+    private void loadPreviousImage() {
+        if (mCurrentPosition == 0)
+            mCurrentPosition = mImageList.getCount() - 1;
+        else
+            mCurrentPosition -= 1;
+
+        loadImage();
+    }
+
+    public View makeView() {
+        ImageView i = new ImageView(this);
+        i.setBackgroundColor(0xFF000000);
+        i.setScaleType(ImageView.ScaleType.FIT_CENTER);
+        i.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
+        return i;
+    }
+    
+    private final Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+        }
+    };
+
+    class FileImageList implements IImageList {
+        public HashMap<String, String> getBucketIds() {
+            throw new UnsupportedOperationException();
+        }
+
+        public void checkThumbnails(ThumbCheckCallback cb) {
+            // TODO Auto-generated method stub
+            
+        }
+
+        public void commitChanges() {
+            // TODO Auto-generated method stub
+            
+        }
+
+        public void removeOnChangeListener(OnChange changeCallback) {
+            // TODO Auto-generated method stub
+            
+        }
+
+        public void setOnChangeListener(OnChange changeCallback, Handler h) {
+            // TODO Auto-generated method stub
+            
+        }
+
+        private ArrayList<FileImage> mImages = new ArrayList<FileImage>();
+        // image uri ==> Image object
+        private HashMap<Long, IImage> mCache = new HashMap<Long, IImage>();
+
+        class FileImage extends ImageManager.SimpleBaseImage {
+            long mId;
+            String mPath;
+
+            FileImage(long id, String path) {
+                mId = id;
+                mPath = path;
+            }
+
+            public long imageId() {
+                return mId;
+            }
+            
+            public String getDataPath() {
+                return mPath;
+            }
+
+            public Bitmap fullSizeBitmap(int targetWidthOrHeight) {
+                return BitmapFactory.decodeFile(mPath);
+            }
+
+            public IGetBitmap_cancelable fullSizeBitmap_cancelable(int targetWidthOrHeight) {
+                return null;
+            }
+            
+            public Bitmap thumbBitmap() {
+                Bitmap b = fullSizeBitmap(320);
+                Matrix m = new Matrix();
+                float scale = 320F / (float) b.getWidth();
+                m.setScale(scale, scale);
+                Bitmap scaledBitmap = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), m, true);
+                return scaledBitmap;
+            }
+            
+            public Bitmap miniThumbBitmap() {
+                return thumbBitmap();
+            }
+
+            public long fullSizeImageId() {
+                return mId;
+            }
+        }
+
+        private void enumerate(String path, ArrayList<String> list) {
+            File f = new File(path);
+            if (f.isDirectory()) {
+                String [] children = f.list();
+                if (children != null) {
+                    for (int i = 0; i < children.length; i++) {
+                        if (children[i].charAt(0) != '.')
+                            enumerate(path + "/" + children[i], list);
+                    }
+                }
+            } else {
+                if (path.endsWith(".jpeg") || path.endsWith(".jpg") || path.endsWith(".png")) {
+                    if (f.length() > 0) {
+                        list.add(path);
+                    }
+                }
+            }
+        }
+
+        public FileImageList() {
+            ArrayList<String> list = new ArrayList<String>();
+            enumerate(Environment.getExternalStorageDirectory().getPath(), list);
+            enumerate("/data/images", list);
+
+            for (int i = 0; i < list.size(); i++) {
+                FileImage img = new FileImage(i, list.get(i));
+                mCache.put((long)i, img);
+                mImages.add(img);
+            }
+        }
+
+        public IImage getImageAt(int i) {
+            if (i >= mImages.size())
+                return null;
+
+            return mImages.get(i);
+        }
+
+        public IImage getImageForUri(Uri uri) {
+            // TODO make this a hash lookup
+            int count = getCount();
+            for (int i = 0; i < count; i++) {
+                IImage image = getImageAt(i);
+                if (image.fullSizeImageUri().equals(uri)) {
+                    return image;
+                }
+            }
+            return null;
+        }
+
+        public IImage getImageWithId(long id) {
+            throw new UnsupportedOperationException();
+        }
+
+        public void removeImageAt(int i) {
+            throw new UnsupportedOperationException();
+        }
+
+        public boolean removeImage(IImage image) {
+            throw new UnsupportedOperationException();
+        }
+
+        public int getCount() {
+            return mImages.size();
+        }
+        
+        public void deactivate() {
+            // nothing to do here
+        }
+    }
+
+}