gcam: Add placeholder image.

Bug: 11050749

Change-Id: I374c5919d6da0609fccd21c09775fa91894d5a24

2 files changed, 192 insertions, 1 deletions

diff --git a/src/com/android/camera/app/AppManagerFactory.java b/src/com/android/camera/app/AppManagerFactory.java
index 9c047aa55..43d2a00cd 100644
--- a/src/com/android/camera/app/AppManagerFactory.java
+++ b/src/com/android/camera/app/AppManagerFactory.java
@@ -16,9 +16,9 @@
 
 package com.android.camera.app;
 
-import android.app.Application;
 import android.content.Context;
 
+
 /**
  * A singleton class which provides application level utility
  * classes.
@@ -35,13 +35,19 @@ public class AppManagerFactory {
     }
 
     private PanoramaStitchingManager mPanoramaStitchingManager;
+    private PlaceholderManager mGcamProcessingManager;
 
     /** No public constructor. */
     private AppManagerFactory(Context ctx) {
         mPanoramaStitchingManager = new PanoramaStitchingManager(ctx);
+        mGcamProcessingManager = new PlaceholderManager(ctx);
     }
 
     public PanoramaStitchingManager getPanoramaStitchingManager() {
         return mPanoramaStitchingManager;
     }
+
+    public PlaceholderManager getGcamProcessingManager() {
+        return mGcamProcessingManager;
+    }
 }
diff --git a/src/com/android/camera/app/PlaceholderManager.java b/src/com/android/camera/app/PlaceholderManager.java
new file mode 100644
index 000000000..326f0be80
--- /dev/null
+++ b/src/com/android/camera/app/PlaceholderManager.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2013 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.app;
+
+import android.content.Context;
+import android.graphics.BitmapFactory;
+import android.location.Location;
+import android.net.Uri;
+
+import com.android.camera.ImageTaskManager;
+import com.android.camera.Storage;
+import com.android.camera.exif.ExifInterface;
+import com.android.camera.util.CameraUtil;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+public class PlaceholderManager implements ImageTaskManager {
+    private static final String TAG = "PlaceholderManager";
+
+    public static final String PLACEHOLDER_MIME_TYPE = "application/placeholder-image";
+    private final Context mContext;
+
+    final private ArrayList<WeakReference<TaskListener>> mListenerRefs;
+
+    public static class Session {
+        String outputTitle;
+        Uri outputUri;
+        long time;
+
+        Session(String title, Uri uri, long timestamp) {
+            outputTitle = title;
+            outputUri = uri;
+            time = timestamp;
+        }
+    }
+
+    public PlaceholderManager(Context context) {
+        mContext = context;
+        mListenerRefs = new ArrayList<WeakReference<TaskListener>>();
+    }
+
+    @Override
+    public void addTaskListener(TaskListener l) {
+        synchronized (mListenerRefs) {
+            if (findTaskListener(l) == -1) {
+                mListenerRefs.add(new WeakReference<TaskListener>(l));
+            }
+        }
+    }
+
+    @Override
+    public void removeTaskListener(TaskListener l) {
+        synchronized (mListenerRefs) {
+            int i = findTaskListener(l);
+            if (i != -1) {
+                mListenerRefs.remove(i);
+            }
+        }
+    }
+
+    @Override
+    public int getTaskProgress(Uri uri) {
+        return 0;
+    }
+
+    private int findTaskListener(TaskListener listener) {
+        int index = -1;
+        for (int i = 0; i < mListenerRefs.size(); i++) {
+            TaskListener l = mListenerRefs.get(i).get();
+            if (l != null && l == listener) {
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+
+    private Iterable<TaskListener> getListeners() {
+        return new Iterable<TaskListener>() {
+            @Override
+            public Iterator<TaskListener> iterator() {
+                return new ListenerIterator();
+            }
+        };
+    }
+
+    private class ListenerIterator implements Iterator<TaskListener> {
+        private int mIndex = 0;
+        private TaskListener mNext = null;
+
+        @Override
+        public boolean hasNext() {
+            while (mNext == null && mIndex < mListenerRefs.size()) {
+                mNext = mListenerRefs.get(mIndex).get();
+                if (mNext == null) {
+                    mListenerRefs.remove(mIndex);
+                }
+            }
+            return mNext != null;
+        }
+
+        @Override
+        public TaskListener next() {
+            hasNext(); // Populates mNext
+            mIndex++;
+            TaskListener next = mNext;
+            mNext = null;
+            return next;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public Session insertPlaceholder(String title, byte[] placeholder, long timestamp) {
+        if (title == null || placeholder == null) {
+            throw new IllegalArgumentException("Null argument passed to insertPlaceholder");
+        }
+
+        // Decode bounds
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inJustDecodeBounds = true;
+        BitmapFactory.decodeByteArray(placeholder, 0, placeholder.length, options);
+        int width = options.outWidth;
+        int height = options.outHeight;
+
+        if (width <= 0 || height <= 0) {
+            throw new IllegalArgumentException("Image had bad height/width");
+        }
+
+        Uri uri =
+                Storage.addImage(mContext.getContentResolver(), title, timestamp, null, 0, null,
+                        placeholder, width, height, PLACEHOLDER_MIME_TYPE);
+
+        if (uri == null) {
+            return null;
+        }
+
+        String filePath = uri.getPath();
+        synchronized (mListenerRefs) {
+            for (TaskListener l : getListeners()) {
+                l.onTaskQueued(filePath, uri);
+            }
+        }
+
+        return new Session(title, uri, timestamp);
+    }
+
+    public void replacePlaceholder(Session session, Location location, int orientation,
+            ExifInterface exif, byte[] jpeg, int width, int height, String mimeType) {
+
+        Storage.updateImage(session.outputUri, mContext.getContentResolver(), session.outputTitle,
+                session.time, location, orientation, exif, jpeg, width, height, mimeType);
+
+        synchronized (mListenerRefs) {
+            for (TaskListener l : getListeners()) {
+                l.onTaskDone(session.outputUri.getPath(), session.outputUri);
+            }
+        }
+        CameraUtil.broadcastNewPicture(mContext, session.outputUri);
+    }
+
+    public void removePlaceholder(Session session) {
+        Storage.deleteImage(mContext.getContentResolver(), session.outputUri);
+    }
+
+}