blob: 47ba535fe972b68d063dd39a9372528aecf6f921 [file] [log] [blame]
/*
* Copyright (C) 2010 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.gallery3d.data;
import android.content.ContentResolver;
//import android.drm.DrmHelper;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory.Options;
import android.graphics.BitmapRegionDecoder;
import android.net.Uri;
import android.os.ParcelFileDescriptor;
import com.android.gallery3d.app.GalleryApp;
import com.android.gallery3d.app.PanoramaMetadataSupport;
import com.android.gallery3d.common.BitmapUtils;
import com.android.gallery3d.common.Utils;
import com.android.gallery3d.util.ThreadPool.CancelListener;
import com.android.gallery3d.util.ThreadPool.Job;
import com.android.gallery3d.util.ThreadPool.JobContext;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
public class UriImage extends MediaItem {
private static final String TAG = "UriImage";
private static final int STATE_INIT = 0;
private static final int STATE_DOWNLOADING = 1;
private static final int STATE_DOWNLOADED = 2;
private static final int STATE_ERROR = -1;
private final Uri mUri;
private final String mContentType;
private DownloadCache.Entry mCacheEntry;
private ParcelFileDescriptor mFileDescriptor;
private int mState = STATE_INIT;
private int mWidth;
private int mHeight;
private int mRotation;
private PanoramaMetadataSupport mPanoramaMetadata = new PanoramaMetadataSupport(this);
private GalleryApp mApplication;
// private String mFilePath;
public UriImage(GalleryApp application, Path path, Uri uri, String contentType) {
super(path, nextVersionNumber());
mUri = uri;
mApplication = Utils.checkNotNull(application);
mContentType = contentType;
// mFilePath = DrmHelper.getFilePath(mApplication.getAndroidContext(), uri);
}
@Override
public Job<Bitmap> requestImage(int type) {
return new BitmapJob(type);
}
@Override
public Job<BitmapRegionDecoder> requestLargeImage() {
return new RegionDecoderJob();
}
private void openFileOrDownloadTempFile(JobContext jc) {
int state = openOrDownloadInner(jc);
synchronized (this) {
mState = state;
if (mState != STATE_DOWNLOADED) {
if (mFileDescriptor != null) {
Utils.closeSilently(mFileDescriptor);
mFileDescriptor = null;
}
}
notifyAll();
}
}
private int openOrDownloadInner(JobContext jc) {
String scheme = mUri.getScheme();
if (ContentResolver.SCHEME_CONTENT.equals(scheme)
|| ContentResolver.SCHEME_ANDROID_RESOURCE.equals(scheme)
|| ContentResolver.SCHEME_FILE.equals(scheme)) {
try {
if (MIME_TYPE_JPEG.equalsIgnoreCase(mContentType)) {
InputStream is = mApplication.getContentResolver()
.openInputStream(mUri);
mRotation = Exif.getOrientation(is);
Utils.closeSilently(is);
}
mFileDescriptor = mApplication.getContentResolver()
.openFileDescriptor(mUri, "r");
if (jc.isCancelled()) return STATE_INIT;
return STATE_DOWNLOADED;
} catch (FileNotFoundException e) {
Log.w(TAG, "fail to open: " + mUri, e);
return STATE_ERROR;
}
} else {
try {
URL url = new URI(mUri.toString()).toURL();
mCacheEntry = mApplication.getDownloadCache().download(jc, url);
if (jc.isCancelled()) return STATE_INIT;
if (mCacheEntry == null) {
Log.w(TAG, "download failed " + url);
return STATE_ERROR;
}
if (MIME_TYPE_JPEG.equalsIgnoreCase(mContentType)) {
InputStream is = new FileInputStream(mCacheEntry.cacheFile);
mRotation = Exif.getOrientation(is);
Utils.closeSilently(is);
}
mFileDescriptor = ParcelFileDescriptor.open(
mCacheEntry.cacheFile, ParcelFileDescriptor.MODE_READ_ONLY);
return STATE_DOWNLOADED;
} catch (Throwable t) {
Log.w(TAG, "download error", t);
return STATE_ERROR;
}
}
}
private boolean prepareInputFile(JobContext jc) {
jc.setCancelListener(new CancelListener() {
@Override
public void onCancel() {
synchronized (this) {
notifyAll();
}
}
});
while (true) {
synchronized (this) {
if (jc.isCancelled()) return false;
if (mState == STATE_INIT) {
mState = STATE_DOWNLOADING;
// Then leave the synchronized block and continue.
} else if (mState == STATE_ERROR) {
return false;
} else if (mState == STATE_DOWNLOADED) {
return true;
} else /* if (mState == STATE_DOWNLOADING) */ {
try {
wait();
} catch (InterruptedException ex) {
// ignored.
}
continue;
}
}
// This is only reached for STATE_INIT->STATE_DOWNLOADING
openFileOrDownloadTempFile(jc);
}
}
private class RegionDecoderJob implements Job<BitmapRegionDecoder> {
@Override
public BitmapRegionDecoder run(JobContext jc) {
// if (DrmHelper.isDrmFile(getFilePath())) {
// BitmapRegionDecoder decoder = DrmHelper
// .createBitmapRegionDecoder(getFilePath(), false);
// mWidth = decoder.getWidth();
// mHeight = decoder.getHeight();
// return decoder;
// }
if (!prepareInputFile(jc)) return null;
BitmapRegionDecoder decoder = DecodeUtils.createBitmapRegionDecoder(
jc, mFileDescriptor.getFileDescriptor(), false);
mWidth = decoder.getWidth();
mHeight = decoder.getHeight();
return decoder;
}
}
private class BitmapJob implements Job<Bitmap> {
private int mType;
protected BitmapJob(int type) {
mType = type;
}
@Override
public Bitmap run(JobContext jc) {
// if (DrmHelper.isDrmFile(getFilePath())) {
// return DecodeUtils.ensureGLCompatibleBitmap(DrmHelper.getBitmap(getFilePath()));
// }
if (!prepareInputFile(jc)) return null;
int targetSize = MediaItem.getTargetSize(mType);
Options options = new Options();
options.inPreferredConfig = Config.ARGB_8888;
Bitmap bitmap = DecodeUtils.decodeThumbnail(jc,
mFileDescriptor.getFileDescriptor(), options, targetSize, mType);
if (jc.isCancelled() || bitmap == null) {
return null;
}
if (mType == MediaItem.TYPE_MICROTHUMBNAIL) {
bitmap = BitmapUtils.resizeAndCropCenter(bitmap, targetSize, true);
} else {
bitmap = BitmapUtils.resizeDownBySideLength(bitmap, targetSize, true);
}
return bitmap;
}
}
@Override
public int getSupportedOperations() {
int supported = 0;
// if (DrmHelper.isDrmFile(getFilePath())) {
// supported |= SUPPORT_DRM_INFO | SUPPORT_FULL_IMAGE;
// if (DrmHelper.isShareableDrmFile(getFilePath())) {
// supported |= SUPPORT_SHARE;
// }
// } else {
supported = SUPPORT_PRINT | SUPPORT_SETAS;
if (isSharable()) supported |= SUPPORT_SHARE;
if (BitmapUtils.isSupportedByRegionDecoder(mContentType)) {
supported |= SUPPORT_EDIT | SUPPORT_FULL_IMAGE;
}
// }
return supported;
}
@Override
public void getPanoramaSupport(PanoramaSupportCallback callback) {
mPanoramaMetadata.getPanoramaSupport(mApplication, callback);
}
@Override
public void clearCachedPanoramaSupport() {
mPanoramaMetadata.clearCachedValues();
}
private boolean isSharable() {
// We cannot grant read permission to the receiver since we put
// the data URI in EXTRA_STREAM instead of the data part of an intent
// And there are issues in MediaUploader and Bluetooth file sender to
// share a general image data. So, we only share for local file.
return ContentResolver.SCHEME_FILE.equals(mUri.getScheme());
}
@Override
public int getMediaType() {
// if (DrmHelper.isDrmFile(getFilePath())) {
// return MEDIA_TYPE_DRM_IMAGE;
// }
return MEDIA_TYPE_IMAGE;
}
@Override
public Uri getContentUri() {
return mUri;
}
@Override
public MediaDetails getDetails() {
MediaDetails details = super.getDetails();
if (mWidth != 0 && mHeight != 0) {
details.addDetail(MediaDetails.INDEX_WIDTH, mWidth);
details.addDetail(MediaDetails.INDEX_HEIGHT, mHeight);
}
if (mContentType != null) {
details.addDetail(MediaDetails.INDEX_MIMETYPE, mContentType);
}
if (ContentResolver.SCHEME_FILE.equals(mUri.getScheme())) {
String filePath = mUri.getPath();
details.addDetail(MediaDetails.INDEX_PATH, filePath);
MediaDetails.extractExifInfo(details, filePath);
}
return details;
}
@Override
public String getMimeType() {
return mContentType;
}
@Override
protected void finalize() throws Throwable {
try {
if (mFileDescriptor != null) {
Utils.closeSilently(mFileDescriptor);
}
} finally {
super.finalize();
}
}
@Override
public int getWidth() {
return 0;
}
@Override
public int getHeight() {
return 0;
}
@Override
public int getRotation() {
return mRotation;
}
// @Override
// public String getFilePath() {
// return mFilePath;
// }
}