@nativescript/core 9.0.0-next-10-06-2025-18277360121 → 9.0.0-next-10-09-2025-18367604937

package/platforms/android/java/org/nativescript/widgets/image/Cache.java

@@ -1,471 +0,0 @@
-/*
- * Copyright (C) 2012 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 org.nativescript.widgets.image;
-
-import android.Manifest;
-import android.annotation.TargetApi;
-import android.content.Context;
-import android.content.pm.PackageManager;
-import android.graphics.Bitmap;
-import android.graphics.Bitmap.Config;
-import android.graphics.BitmapFactory;
-import android.os.Build.VERSION_CODES;
-import android.os.Environment;
-import android.os.StatFs;
-import android.util.Log;
-import android.util.LruCache;
-
-import java.io.File;
-import java.lang.ref.SoftReference;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-/**
- * This class handles disk and memory caching of bitmaps in conjunction with the
- * {@link Worker} class and its subclasses. Use
- * {@link Cache#getInstance(CacheParams)} to get an instance of this
- * class, although usually a cache should be added directly to an {@link Worker} by calling
- * {@link Worker#addImageCache(Cache)}.
- */
-public class Cache {
-	private static final String TAG = "JS";
-
-	// Default memory cache size in kilobytes
-	private static final int DEFAULT_MEM_CACHE_SIZE = 1024 * 5; // 5MB
-
-	// Constants to easily toggle various caches
-	private static final boolean DEFAULT_MEM_CACHE_ENABLED = true;
-	private static final boolean DEFAULT_DISK_CACHE_ENABLED = true;
-
-	private static Cache instance;
-	private HashMap<String, Integer> mMemoryCacheUsage;
-	private LruCache<String, Bitmap> mMemoryCache;
-	private CacheParams mParams;
-
-	private Set<SoftReference<Bitmap>> mReusableBitmaps;
-
-	/**
-	 * Create a new Cache object using the specified parameters. This should not be
-	 * called directly by other classes, instead use
-	 * {@link Cache#getInstance(CacheParams)} to fetch an Cache
-	 * instance.
-	 */
-	private Cache() {
-	}
-
-	/**
-	 * Return an {@link Cache} instance.
-	 *
-	 * @return An existing retained Cache object or a new one if one did not exist
-	 */
-	public static Cache getInstance(CacheParams cacheParams) {
-		if (instance == null) {
-			instance = new Cache();
-		}
-
-		if (instance.mParams != cacheParams) {
-			instance.init(cacheParams);
-		}
-
-		return instance;
-	}
-
-	/**
-	 * Initialize the cache, providing all parameters.
-	 *
-	 * @param cacheParams The cache parameters to initialize the cache
-	 */
-	private void init(CacheParams cacheParams) {
-		clearCache();
-		if (mReusableBitmaps != null) {
-			mReusableBitmaps.clear();
-			mReusableBitmaps = null;
-		}
-
-		mParams = cacheParams;
-
-		// Set up memory cache
-		if (mParams.memoryCacheEnabled) {
-			if (Worker.debuggable > 0) {
-				Log.v(TAG, "Memory cache created (size = " + mParams.memCacheSize + ")");
-			}
-
-			// If we're running on Honeycomb or newer, create a set of reusable bitmaps that can be
-			// populated into the inBitmap field of BitmapFactory.Options. Note that the set is
-			// of SoftReferences which will actually not be very effective due to the garbage
-			// collector being aggressive clearing Soft/WeakReferences. A better approach
-			// would be to use a strongly references bitmaps, however this would require some
-			// balancing of memory usage between this set and the bitmap LruCache. It would also
-			// require knowledge of the expected size of the bitmaps. From Honeycomb to JellyBean
-			// the size would need to be precise, from KitKat onward the size would just need to
-			// be the upper bound (due to changes in how inBitmap can re-use bitmaps).
-			if (Utils.hasHoneycomb()) {
-				mReusableBitmaps =
-					Collections.synchronizedSet(new HashSet<SoftReference<Bitmap>>());
-			}
-
-			mMemoryCacheUsage = new HashMap<String, Integer>();
-			mMemoryCache = new LruCache<String, Bitmap>(mParams.memCacheSize) {
-
-				/**
-				 * Notify the removed entry that is no longer being cached
-				 */
-				@Override
-				protected void entryRemoved(boolean evicted, String key,
-																		Bitmap oldValue, Bitmap newValue) {
-					Integer count = mMemoryCacheUsage.get(key);
-					if (Utils.hasHoneycomb() && (count == null || count == 0)) {
-						// We're running on Honeycomb or later, so add the bitmap
-						// to a SoftReference set for possible use with inBitmap later
-						mReusableBitmaps.add(new SoftReference<Bitmap>(oldValue));
-					}
-				}
-
-				/**
-				 * Measure item size in kilobytes rather than units which is more practical
-				 * for a bitmap cache
-				 */
-				@Override
-				protected int sizeOf(String key, Bitmap value) {
-					final int bitmapSize = getBitmapSize(value) / 1024;
-					return bitmapSize == 0 ? 1 : bitmapSize;
-				}
-			};
-		}
-	}
-
-	/**
-	 * Adds a bitmap to both memory and disk cache.
-	 *
-	 * @param data  Unique identifier for the bitmap to store
-	 * @param value The bitmap drawable to store
-	 */
-	public void addBitmapToCache(String data, Bitmap value) {
-		if (data == null || value == null) {
-			return;
-		}
-
-		// Add to memory cache
-		if (mMemoryCache != null) {
-			Bitmap currentValue = mMemoryCache.get(data);
-			// NOTE: If we have existing we probably loaded it sync so we don't want to add the new one,
-			// because this will make the previous bitmap free for reuse but it is used somewhere.
-			// Probably won't happen often.
-			if (currentValue == null) {
-				Integer count = mMemoryCacheUsage.get(data);
-				// NOTE: count should be null here.
-				mMemoryCacheUsage.put(data, count == null ? 1 : count + 1);
-				mMemoryCache.put(data, value);
-			}
-		}
-	}
-
-	/**
-	 * Get from memory cache.
-	 *
-	 * @param data Unique identifier for which item to get
-	 * @return The bitmap if found in cache, null otherwise
-	 */
-	public Bitmap getBitmapFromMemCache(String data) {
-		Bitmap memValue = null;
-
-		if (mMemoryCache != null) {
-			memValue = mMemoryCache.get(data);
-			if (memValue != null) {
-				Integer count = mMemoryCacheUsage.get(data);
-				mMemoryCacheUsage.put(data, count == null ? 1 : count + 1);
-			}
-		}
-
-		if (Worker.debuggable > 0 && memValue != null) {
-			Log.v(TAG, "Memory cache hit");
-		}
-
-		return memValue;
-	}
-
-	public void reduceDisplayedCounter(String uri) {
-		if (mMemoryCache != null) {
-			Integer count = mMemoryCacheUsage.get(uri);
-			if (count != null) {
-				if (count == 1) {
-					mMemoryCacheUsage.remove(uri);
-				} else {
-					mMemoryCacheUsage.put(uri, count - 1);
-				}
-			}
-		}
-	}
-
-	/**
-	 * @param options - BitmapFactory.Options with out* options populated
-	 * @return Bitmap that case be used for inBitmap
-	 */
-	protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
-		//BEGIN_INCLUDE(get_bitmap_from_reusable_set)
-		Bitmap bitmap = null;
-
-		if (mReusableBitmaps != null && !mReusableBitmaps.isEmpty()) {
-			synchronized (mReusableBitmaps) {
-				final Iterator<SoftReference<Bitmap>> iterator = mReusableBitmaps.iterator();
-				Bitmap item;
-
-				while (iterator.hasNext()) {
-					item = iterator.next().get();
-
-					if (null != item && item.isMutable()) {
-						// Check to see it the item can be used for inBitmap
-						if (canUseForInBitmap(item, options)) {
-							bitmap = item;
-
-							// Remove from reusable set so it can't be used again
-							iterator.remove();
-							break;
-						}
-					} else {
-						// Remove from the set if the reference has been cleared.
-						iterator.remove();
-					}
-				}
-			}
-		}
-
-		return bitmap;
-		//END_INCLUDE(get_bitmap_from_reusable_set)
-	}
-
-	/**
-	 * Clears both the memory and disk cache associated with this Cache object. Note that
-	 * this includes disk access so this should not be executed on the main/UI thread.
-	 */
-	public void clearCache() {
-		if (mMemoryCache != null) {
-			mMemoryCache.evictAll();
-			if (Worker.debuggable > 0) {
-				Log.v(TAG, "Memory cache cleared");
-			}
-		}
-		if (mMemoryCacheUsage != null) {
-			mMemoryCacheUsage.clear();
-		}
-
-		mMemoryCacheUsage = null;
-		mMemoryCache = null;
-	}
-
-	/**
-	 * A holder class that contains cache parameters.
-	 */
-	public static class CacheParams {
-		public int memCacheSize = DEFAULT_MEM_CACHE_SIZE;
-		public boolean memoryCacheEnabled = DEFAULT_MEM_CACHE_ENABLED;
-		public boolean diskCacheEnabled = DEFAULT_DISK_CACHE_ENABLED;
-
-		/**
-		 * Sets the memory cache size based on a percentage of the max available VM memory.
-		 * Eg. setting percent to 0.2 would set the memory cache to one fifth of the available
-		 * memory. Throws {@link IllegalArgumentException} if percent is < 0.01 or > .8.
-		 * memCacheSize is stored in kilobytes instead of bytes as this will eventually be passed
-		 * to construct a LruCache which takes an int in its constructor.
-		 * <p>
-		 * This value should be chosen carefully based on a number of factors
-		 * Refer to the corresponding Android Training class for more discussion:
-		 * http://developer.android.com/training/displaying-bitmaps/
-		 *
-		 * @param percent Percent of available app memory to use to size memory cache
-		 */
-		public void setMemCacheSizePercent(float percent) {
-			if (percent < 0.01f || percent > 0.8f) {
-				throw new IllegalArgumentException("setMemCacheSizePercent - percent must be "
-					+ "between 0.01 and 0.8 (inclusive)");
-			}
-			memCacheSize = Math.round(percent * Runtime.getRuntime().maxMemory() / 1024);
-		}
-	}
-
-	/**
-	 * @param candidate     - Bitmap to check
-	 * @param targetOptions - Options that have the out* value populated
-	 * @return true if <code>candidate</code> can be used for inBitmap re-use with
-	 * <code>targetOptions</code>
-	 */
-	@TargetApi(VERSION_CODES.KITKAT)
-	private static boolean canUseForInBitmap(
-		Bitmap candidate, BitmapFactory.Options targetOptions) {
-		//BEGIN_INCLUDE(can_use_for_inbitmap)
-		if (!Utils.hasKitKat()) {
-			// On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
-			return candidate.getWidth() == targetOptions.outWidth
-				&& candidate.getHeight() == targetOptions.outHeight
-				&& targetOptions.inSampleSize == 1;
-		}
-
-		// From Android 4.4 (KitKat) onward we can re-use if the byte size of the new bitmap
-		// is smaller than the reusable bitmap candidate allocation byte count.
-		int width = targetOptions.outWidth / targetOptions.inSampleSize;
-		int height = targetOptions.outHeight / targetOptions.inSampleSize;
-		int byteCount = width * height * getBytesPerPixel(candidate.getConfig());
-		return byteCount <= candidate.getAllocationByteCount();
-		//END_INCLUDE(can_use_for_inbitmap)
-	}
-
-	/**
-	 * Return the byte usage per pixel of a bitmap based on its configuration.
-	 *
-	 * @param config The bitmap configuration.
-	 * @return The byte usage per pixel.
-	 */
-	private static int getBytesPerPixel(Config config) {
-		if (config == Config.ARGB_8888) {
-			return 4;
-		} else if (config == Config.RGB_565) {
-			return 2;
-		} else if (config == Config.ARGB_4444) {
-			return 2;
-		} else if (config == Config.ALPHA_8) {
-			return 1;
-		}
-		return 1;
-	}
-
-	/**
-	 * Get a usable cache directory (external if available, internal otherwise).
-	 *
-	 * @param context    The context to use
-	 * @param uniqueName A unique directory name to append to the cache dir
-	 * @return The cache dir
-	 */
-	public static File getDiskCacheDir(Context context, String uniqueName) {
-		// Check if media is mounted or storage is built-in, if so, try and use external cache dir
-		// otherwise use internal cache dir
-		final File cacheFilePath = Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) ||
-			!isExternalStorageRemovable() ? getExternalCacheDir(context) : context.getCacheDir();
-		// In case there is no external storage isExternalStorageRemovable returns False and we get Null from getExternalCacheDir.
-		// If this is the case - fall back to internal cache dir.
-		final String cachePath = cacheFilePath != null ? cacheFilePath.getPath() : context.getCacheDir().getPath();
-		return new File(cachePath + File.separator + uniqueName);
-	}
-
-	/**
-	 * A hashing method that changes a string (like a URL) into a hash suitable for using as a
-	 * disk filename.
-	 */
-	public static String hashKeyForDisk(String key) {
-		String cacheKey;
-		try {
-			final MessageDigest mDigest = MessageDigest.getInstance("MD5");
-			mDigest.update(key.getBytes());
-			cacheKey = bytesToHexString(mDigest.digest());
-		} catch (NoSuchAlgorithmException e) {
-			cacheKey = String.valueOf(key.hashCode());
-		}
-		return cacheKey;
-	}
-
-	private static String bytesToHexString(byte[] bytes) {
-		// http://stackoverflow.com/questions/332079
-		StringBuilder sb = new StringBuilder();
-		for (int i = 0; i < bytes.length; i++) {
-			String hex = Integer.toHexString(0xFF & bytes[i]);
-			if (hex.length() == 1) {
-				sb.append('0');
-			}
-			sb.append(hex);
-		}
-		return sb.toString();
-	}
-
-	/**
-	 * Get the size in bytes of a bitmap in a BitmapDrawable. Note that from Android 4.4 (KitKat)
-	 * onward this returns the allocated memory size of the bitmap which can be larger than the
-	 * actual bitmap data byte count (in the case it was re-used).
-	 *
-	 * @param bitmap
-	 * @return size in bytes
-	 */
-	@TargetApi(VERSION_CODES.KITKAT)
-	public static int getBitmapSize(Bitmap bitmap) {
-		// From KitKat onward use getAllocationByteCount() as allocated bytes can potentially be
-		// larger than bitmap byte count.
-		if (Utils.hasKitKat()) {
-			return bitmap.getAllocationByteCount();
-		}
-
-		if (Utils.hasHoneycombMR1()) {
-			return bitmap.getByteCount();
-		}
-
-		// Pre HC-MR1
-		return bitmap.getRowBytes() * bitmap.getHeight();
-	}
-
-	/**
-	 * Check if external storage is built-in or removable.
-	 *
-	 * @return True if external storage is removable (like an SD card), false
-	 * otherwise.
-	 */
-	@TargetApi(VERSION_CODES.GINGERBREAD)
-	public static boolean isExternalStorageRemovable() {
-		if (Utils.hasGingerbread()) {
-			return Environment.isExternalStorageRemovable();
-		}
-		return true;
-	}
-
-	/**
-	 * Get the external app cache directory.
-	 *
-	 * @param context The context to use
-	 * @return The external cache dir
-	 */
-	@TargetApi(VERSION_CODES.FROYO)
-	public static File getExternalCacheDir(Context context) {
-		if (Utils.hasFroyo()) {
-			if (Utils.hasKitKat() ||
-				context.checkPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE, android.os.Process.myPid(), android.os.Process.myUid()) == PackageManager.PERMISSION_GRANTED) {
-				return context.getExternalCacheDir();
-			}
-
-			return null;
-		}
-
-		// Before Froyo we need to construct the external cache dir ourselves
-		final String cacheDir = "/Android/data/" + context.getPackageName() + "/cache/";
-		return new File(Environment.getExternalStorageDirectory().getPath() + cacheDir);
-	}
-
-	/**
-	 * Check how much usable space is available at a given path.
-	 *
-	 * @param path The path to check
-	 * @return The space available in bytes
-	 */
-	@TargetApi(VERSION_CODES.GINGERBREAD)
-	public static long getUsableSpace(File path) {
-		if (Utils.hasGingerbread()) {
-			return path.getUsableSpace();
-		}
-		final StatFs stats = new StatFs(path.getPath());
-		return (long) stats.getBlockSize() * (long) stats.getAvailableBlocks();
-	}
-}