import java.io.File;
import java.io.InputStream;
import java.lang.ref.WeakReference;
+import java.net.FileNameMap;
+import java.net.URLConnection;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;
import android.accounts.Account;
import android.accounts.AccountManager;
import android.content.Context;
+import android.content.SharedPreferences;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Point;
+import android.graphics.Canvas;
+import android.graphics.Paint;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.media.ThumbnailUtils;
import android.net.Uri;
import android.os.AsyncTask;
+import android.preference.PreferenceManager;
import android.view.Display;
import android.view.View;
import android.view.WindowManager;
import com.owncloud.android.ui.adapter.DiskLruImageCache;
import com.owncloud.android.utils.BitmapUtils;
import com.owncloud.android.utils.DisplayUtils;
+import com.owncloud.android.utils.FileStorageUtils;
/**
* Manager for concurrent access to thumbnails cache.
private static final String TAG = ThumbnailsCacheManager.class.getSimpleName();
private static final String CACHE_FOLDER = "thumbnailCache";
+ private static final Integer CACHE_SIZE_MB = 10;
private static final Object mThumbnailsDiskCacheLock = new Object();
private static DiskLruImageCache mThumbnailCache = null;
private static boolean mThumbnailCacheStarting = true;
- private static final int DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB
private static final CompressFormat mCompressFormat = CompressFormat.JPEG;
private static final int mCompressQuality = 70;
private static OwnCloudClient mClient = null;
if (mThumbnailCache == null) {
try {
+ SharedPreferences appPrefs =
+ PreferenceManager.getDefaultSharedPreferences(MainApp.getAppContext());
+ // due to backward compatibility
+ Integer cacheSize = CACHE_SIZE_MB * 1024 * 1024;
+ try {
+ cacheSize = appPrefs.getInt("pref_cache_size", cacheSize);
+ } catch (ClassCastException e) {
+ String temp = appPrefs.getString("pref_cache_size",
+ cacheSize.toString());
+ cacheSize = Integer.decode(temp) * 1024 * 1024;
+ }
+
// Check if media is mounted or storage is built-in, if so,
// try and use external cache dir; otherwise use internal cache dir
final String cachePath =
final File diskCacheDir = new File(cachePath);
mThumbnailCache = new DiskLruImageCache(
diskCacheDir,
- DISK_CACHE_SIZE,
+ cacheSize,
mCompressFormat,
mCompressQuality
);
return null;
}
+ /**
+ * Sets max size of cache
+ * @param maxSize in MB
+ * @return
+ */
+ public static boolean setMaxSize(long maxSize){
+ if (mThumbnailCache != null){
+ mThumbnailCache.setMaxSize(maxSize * 1024 * 1024);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Shows max cache size
+ * @return max cache size in MB.
+ */
+ public static long getMaxSize(){
+ if (mThumbnailCache == null) {
+ new ThumbnailsCacheManager.InitDiskCacheTask().execute();
+ }
+ return mThumbnailCache.getMaxSize() / 1024 / 1024;
+ }
+
public static class ThumbnailGenerationTask extends AsyncTask<Object, Void, Bitmap> {
private final WeakReference<ImageView> mImageViewReference;
private WeakReference<ProgressBar> mProgressWheelRef;
if (mFile instanceof OCFile) {
thumbnail = doOCFileInBackground(mIsThumbnail);
+
+ if (((OCFile) mFile).isVideo()){
+ thumbnail = addVideoOverlay(thumbnail);
+ }
} else if (mFile instanceof File) {
thumbnail = doFileInBackground(mIsThumbnail);
- } else {
- // do nothing
+
+ String url = ((File) mFile).getAbsolutePath();
+ String mMimeType = FileStorageUtils.getMimeTypeFromName(url);
+
+ if (mMimeType != null && mMimeType.startsWith("video/")){
+ thumbnail = addVideoOverlay(thumbnail);
+ }
+ //} else { do nothing
}
}catch(Throwable t){
}
}
imageView.setImageBitmap(bitmap);
- imageView.setVisibility(View.VISIBLE);
+ // imageView.setVisibility(View.VISIBLE);
}
}
}
}
private Bitmap doFileInBackground(Boolean mIsThumbnail) {
- Bitmap thumbnail = null;
File file = (File)mFile;
- final String imageKey = String.valueOf(file.hashCode());
+ // distinguish between thumbnail and resized image
+ String temp = String.valueOf(file.hashCode());
+ if (mIsThumbnail){
+ temp = "t" + temp;
+ } else {
+ temp = "r" + temp;
+ }
+
+ final String imageKey = temp;
// Check disk cache in background thread
- thumbnail = getBitmapFromDiskCache(imageKey);
+ Bitmap thumbnail = getBitmapFromDiskCache(imageKey);
// Not found in disk cache
if (thumbnail == null) {
return null;
}
+ public static Bitmap addVideoOverlay(Bitmap thumbnail){
+ Bitmap playButton = BitmapFactory.decodeResource(MainApp.getAppContext().getResources(),
+ R.drawable.view_play);
+
+ Bitmap resizedPlayButton = Bitmap.createScaledBitmap(playButton,
+ (int) (thumbnail.getWidth() * 0.3),
+ (int) (thumbnail.getHeight() * 0.3), true);
+
+ Bitmap resultBitmap = Bitmap.createBitmap(thumbnail.getWidth(),
+ thumbnail.getHeight(),
+ Bitmap.Config.ARGB_8888);
+
+ Canvas c = new Canvas(resultBitmap);
+
+ // compute visual center of play button, according to resized image
+ int x1 = resizedPlayButton.getWidth();
+ int y1 = resizedPlayButton.getHeight() / 2;
+ int x2 = 0;
+ int y2 = resizedPlayButton.getWidth();
+ int x3 = 0;
+ int y3 = 0;
+
+ double ym = ( ((Math.pow(x3,2) - Math.pow(x1,2) + Math.pow(y3,2) - Math.pow(y1,2)) *
+ (x2 - x1)) - (Math.pow(x2,2) - Math.pow(x1,2) + Math.pow(y2,2) -
+ Math.pow(y1,2)) * (x3 - x1) ) / (2 * ( ((y3 - y1) * (x2 - x1)) -
+ ((y2 - y1) * (x3 - x1)) ));
+ double xm = ( (Math.pow(x2,2) - Math.pow(x1,2)) + (Math.pow(y2,2) - Math.pow(y1,2)) -
+ (2*ym*(y2 - y1)) ) / (2*(x2 - x1));
+
+ // offset to top left
+ double ox = - xm;
+ double oy = thumbnail.getHeight() - ym;
+
+
+ c.drawBitmap(thumbnail, 0, 0, null);
+
+ Paint p = new Paint();
+ p.setAlpha(230);
+
+ c.drawBitmap(resizedPlayButton, (float) ((thumbnail.getWidth() / 2) + ox),
+ (float) ((thumbnail.getHeight() / 2) - ym), p);
+
+ return resultBitmap;
+ }
+
public static class AsyncDrawable extends BitmapDrawable {
private final WeakReference<ThumbnailGenerationTask> bitmapWorkerTaskReference;
projects / pub / Android / ownCloud.git / blobdiff