正在查看： Plus 12 v10.13.1.1 应用的 ImageLoader.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
Plus 12 v10.13.1.1 - ImageLoader.java 源代码
package org.telegram.messenger;
import android.annotation.TargetApi;
import android.app.ActivityManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffColorFilter;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.GradientDrawable;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.SystemClock;
import android.text.TextUtils;
import android.util.SparseArray;
import androidx.core.graphics.ColorUtils;
import j$.util.concurrent.ConcurrentHashMap;
import j$.util.function.Consumer;
import j$.util.stream.Stream;
import j$.wrappers.$r8;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.UnknownHostException;
import java.nio.file.CopyOption;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.zip.GZIPInputStream;
import org.json.JSONArray;
import org.json.JSONObject;
import org.telegram.DispatchQueuePriority;
import org.telegram.messenger.FileLoader;
import org.telegram.messenger.FilePathDatabase;
import org.telegram.messenger.ImageLoader;
import org.telegram.messenger.ImageReceiver;
import org.telegram.tgnet.TLObject;
import org.telegram.tgnet.TLRPC;
import org.telegram.ui.ActionBar.PlusSettings;
import org.telegram.ui.Cells.ChatMessageCell;
import org.telegram.ui.Components.AnimatedFileDrawable;
import org.telegram.ui.Components.BackgroundGradientDrawable;
import org.telegram.ui.Components.MotionBackgroundDrawable;
import org.telegram.ui.Components.RLottieDrawable;
public class ImageLoader {
public static final String AUTOPLAY_FILTER = "g";
public static final int CACHE_TYPE_CACHE = 1;
public static final int CACHE_TYPE_ENCRYPTED = 2;
public static final int CACHE_TYPE_NONE = 0;
private static final boolean DEBUG_MODE = false;
private boolean canForce8888;
private LruCache<BitmapDrawable> lottieMemCache;
private LruCache<BitmapDrawable> memCache;
private LruCache<BitmapDrawable> smallImagesMemCache;
private LruCache<BitmapDrawable> wallpaperMemCache;
private static ThreadLocal<byte[]> bytesLocal = new ThreadLocal<>();
private static ThreadLocal<byte[]> bytesThumbLocal = new ThreadLocal<>();
private static byte[] header = new byte[12];
private static byte[] headerThumb = new byte[12];
private static volatile ImageLoader Instance = null;
private HashMap<String, Integer> bitmapUseCounts = new HashMap<>();
public ArrayList<AnimatedFileDrawable> cachedAnimatedFileDrawables = new ArrayList<>();
private HashMap<String, CacheImage> imageLoadingByUrl = new HashMap<>();
private HashMap<String, CacheImage> imageLoadingByUrlPframe = new HashMap<>();
public ConcurrentHashMap<String, CacheImage> imageLoadingByKeys = new ConcurrentHashMap<>();
public HashSet<String> imageLoadingKeys = new HashSet<>();
private SparseArray<CacheImage> imageLoadingByTag = new SparseArray<>();
private HashMap<String, ThumbGenerateInfo> waitingForQualityThumb = new HashMap<>();
private SparseArray<String> waitingForQualityThumbByTag = new SparseArray<>();
private LinkedList<HttpImageTask> httpTasks = new LinkedList<>();
private LinkedList<ArtworkLoadTask> artworkTasks = new LinkedList<>();
private DispatchQueuePriority cacheOutQueue = new DispatchQueuePriority("cacheOutQueue");
private DispatchQueue cacheThumbOutQueue = new DispatchQueue("cacheThumbOutQueue");
private DispatchQueue thumbGeneratingQueue = new DispatchQueue("thumbGeneratingQueue");
private DispatchQueue imageLoadQueue = new DispatchQueue("imageLoadQueue");
private HashMap<String, String> replacedBitmaps = new HashMap<>();
private ConcurrentHashMap<String, long[]> fileProgresses = new ConcurrentHashMap<>();
private HashMap<String, ThumbGenerateTask> thumbGenerateTasks = new HashMap<>();
private HashMap<String, Integer> forceLoadingImages = new HashMap<>();
private int currentHttpTasksCount = 0;
private int currentArtworkTasksCount = 0;
private ConcurrentHashMap<String, WebFile> testWebFile = new ConcurrentHashMap<>();
private LinkedList<HttpFileTask> httpFileLoadTasks = new LinkedList<>();
private HashMap<String, HttpFileTask> httpFileLoadTasksByKeys = new HashMap<>();
private HashMap<String, Runnable> retryHttpsTasks = new HashMap<>();
private int currentHttpFileLoadTasksCount = 0;
private String ignoreRemoval = null;
private volatile long lastCacheOutTime = 0;
private int lastImageNum = 0;
private File telegramPath = null;
public static boolean hasAutoplayFilter(String s) {
if (s == null) {
return false;
}
String[] split = s.split("_");
for (int i = 0; i < split.length; i++) {
if (AUTOPLAY_FILTER.equals(split[i]) || "pframe".equals(split[i])) {
return true;
}
}
return false;
}
public static Drawable createStripedBitmap(ArrayList<TLRPC.PhotoSize> thumbs) {
for (int i = 0; i < thumbs.size(); i++) {
if (thumbs.get(i) instanceof TLRPC.TL_photoStrippedSize) {
return new BitmapDrawable(ApplicationLoader.applicationContext.getResources(), getStrippedPhotoBitmap(((TLRPC.TL_photoStrippedSize) thumbs.get(i)).bytes, "b"));
}
}
return null;
}
public static boolean isSdCardPath(File videoFile) {
return !TextUtils.isEmpty(SharedConfig.storageCacheDir) && videoFile.getAbsolutePath().startsWith(SharedConfig.storageCacheDir);
}
public void moveToFront(String key) {
if (key == null) {
return;
}
if (this.lottieMemCache.get(key) != null) {
this.lottieMemCache.moveToFront(key);
}
if (this.memCache.get(key) != null) {
this.memCache.moveToFront(key);
}
if (this.smallImagesMemCache.get(key) != null) {
this.smallImagesMemCache.moveToFront(key);
}
}
public void putThumbsToCache(ArrayList<MessageThumb> updateMessageThumbs) {
for (int i = 0; i < updateMessageThumbs.size(); i++) {
putImageToCache(updateMessageThumbs.get(i).drawable, updateMessageThumbs.get(i).key, true);
}
}
public LruCache<BitmapDrawable> getLottieMemCahce() {
return this.lottieMemCache;
}
public static class ThumbGenerateInfo {
private boolean big;
private String filter;
private ArrayList<ImageReceiver> imageReceiverArray;
private ArrayList<Integer> imageReceiverGuidsArray;
private TLRPC.Document parentDocument;
private ThumbGenerateInfo() {
this.imageReceiverArray = new ArrayList<>();
this.imageReceiverGuidsArray = new ArrayList<>();
}
}
public class HttpFileTask extends AsyncTask<Void, Void, Boolean> {
private int currentAccount;
private String ext;
private int fileSize;
private long lastProgressTime;
private File tempFile;
private String url;
private RandomAccessFile fileOutputStream = null;
private boolean canRetry = true;
public HttpFileTask(String url, File tempFile, String ext, int currentAccount) {
this.url = url;
this.tempFile = tempFile;
this.ext = ext;
this.currentAccount = currentAccount;
}
private void reportProgress(final long uploadedSize, final long totalSize) {
long elapsedRealtime = SystemClock.elapsedRealtime();
if (uploadedSize != totalSize) {
long j = this.lastProgressTime;
if (j != 0 && j >= elapsedRealtime - 100) {
return;
}
}
this.lastProgressTime = elapsedRealtime;
Utilities.stageQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpFileTask.this.lambda$reportProgress$1(uploadedSize, totalSize);
}
});
}
public void lambda$reportProgress$1(final long j, final long j2) {
ImageLoader.this.fileProgresses.put(this.url, new long[]{j, j2});
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpFileTask.this.lambda$reportProgress$0(j, j2);
}
});
}
public void lambda$reportProgress$0(long j, long j2) {
NotificationCenter.getInstance(this.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileLoadProgressChanged, this.url, Long.valueOf(j), Long.valueOf(j2));
}
@Override
public java.lang.Boolean doInBackground(java.lang.Void... r12) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.HttpFileTask.doInBackground(java.lang.Void[]):java.lang.Boolean");
}
@Override
public void onPostExecute(Boolean result) {
ImageLoader.this.runHttpFileLoadTasks(this, result.booleanValue() ? 2 : 1);
}
@Override
public void onCancelled() {
ImageLoader.this.runHttpFileLoadTasks(this, 2);
}
}
public class ArtworkLoadTask extends AsyncTask<Void, Void, String> {
private CacheImage cacheImage;
private boolean canRetry = true;
private HttpURLConnection httpConnection;
private boolean small;
public ArtworkLoadTask(CacheImage cacheImage) {
this.cacheImage = cacheImage;
this.small = Uri.parse(cacheImage.imageLocation.path).getQueryParameter("s") != null;
}
@Override
public String doInBackground(Void... voids) {
InputStream inputStream;
ByteArrayOutputStream byteArrayOutputStream;
InputStream inputStream2;
ByteArrayOutputStream byteArrayOutputStream2;
JSONArray jSONArray;
int read;
int responseCode;
try {
try {
HttpURLConnection httpURLConnection = (HttpURLConnection) new URL(this.cacheImage.imageLocation.path.replace("athumb://", "https://")).openConnection();
this.httpConnection = httpURLConnection;
httpURLConnection.setConnectTimeout(5000);
this.httpConnection.setReadTimeout(5000);
this.httpConnection.connect();
try {
HttpURLConnection httpURLConnection2 = this.httpConnection;
if (httpURLConnection2 != null && (responseCode = httpURLConnection2.getResponseCode()) != 200 && responseCode != 202 && responseCode != 304) {
this.canRetry = false;
}
} catch (Exception e) {
FileLog.e(e, false);
}
inputStream2 = this.httpConnection.getInputStream();
try {
byteArrayOutputStream2 = new ByteArrayOutputStream();
try {
byte[] bArr = new byte[32768];
while (!isCancelled() && (read = inputStream2.read(bArr)) > 0) {
byteArrayOutputStream2.write(bArr, 0, read);
}
this.canRetry = false;
jSONArray = new JSONObject(new String(byteArrayOutputStream2.toByteArray())).getJSONArray("results");
} catch (Throwable th) {
inputStream = inputStream2;
th = th;
byteArrayOutputStream = byteArrayOutputStream2;
try {
if (th instanceof SocketTimeoutException) {
if (ApplicationLoader.isNetworkOnline()) {
this.canRetry = false;
}
} else if (th instanceof UnknownHostException) {
this.canRetry = false;
} else if (th instanceof SocketException) {
if (th.getMessage() != null && th.getMessage().contains("ECONNRESET")) {
this.canRetry = false;
}
} else if (th instanceof FileNotFoundException) {
this.canRetry = false;
}
FileLog.e(th, false);
try {
HttpURLConnection httpURLConnection3 = this.httpConnection;
if (httpURLConnection3 != null) {
httpURLConnection3.disconnect();
}
} catch (Throwable unused) {
}
if (inputStream != null) {
try {
inputStream.close();
} catch (Throwable th2) {
FileLog.e(th2);
}
}
if (byteArrayOutputStream != null) {
byteArrayOutputStream.close();
}
return null;
} catch (Throwable th3) {
try {
HttpURLConnection httpURLConnection4 = this.httpConnection;
if (httpURLConnection4 != null) {
httpURLConnection4.disconnect();
}
} catch (Throwable unused2) {
}
if (inputStream != null) {
try {
inputStream.close();
} catch (Throwable th4) {
FileLog.e(th4);
}
}
if (byteArrayOutputStream != null) {
try {
byteArrayOutputStream.close();
} catch (Exception unused3) {
}
}
throw th3;
}
}
} catch (Throwable th5) {
byteArrayOutputStream = null;
inputStream = inputStream2;
th = th5;
}
} catch (Throwable th6) {
th = th6;
inputStream = null;
byteArrayOutputStream = null;
}
} catch (Exception unused4) {
}
if (jSONArray.length() <= 0) {
try {
HttpURLConnection httpURLConnection5 = this.httpConnection;
if (httpURLConnection5 != null) {
httpURLConnection5.disconnect();
}
} catch (Throwable unused5) {
}
if (inputStream2 != null) {
try {
inputStream2.close();
} catch (Throwable th7) {
FileLog.e(th7);
}
}
byteArrayOutputStream2.close();
return null;
}
String string = jSONArray.getJSONObject(0).getString("artworkUrl100");
if (this.small) {
try {
HttpURLConnection httpURLConnection6 = this.httpConnection;
if (httpURLConnection6 != null) {
httpURLConnection6.disconnect();
}
} catch (Throwable unused6) {
}
if (inputStream2 != null) {
try {
inputStream2.close();
} catch (Throwable th8) {
FileLog.e(th8);
}
}
try {
byteArrayOutputStream2.close();
} catch (Exception unused7) {
}
return string;
}
String replace = string.replace("100x100", "600x600");
try {
HttpURLConnection httpURLConnection7 = this.httpConnection;
if (httpURLConnection7 != null) {
httpURLConnection7.disconnect();
}
} catch (Throwable unused8) {
}
if (inputStream2 != null) {
try {
inputStream2.close();
} catch (Throwable th9) {
FileLog.e(th9);
}
}
try {
byteArrayOutputStream2.close();
} catch (Exception unused9) {
}
return replace;
}
@Override
public void onPostExecute(final String result) {
if (result != null) {
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.ArtworkLoadTask.this.lambda$onPostExecute$0(result);
}
});
} else if (this.canRetry) {
ImageLoader.this.artworkLoadError(this.cacheImage.url);
}
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.ArtworkLoadTask.this.lambda$onPostExecute$1();
}
});
}
public void lambda$onPostExecute$0(String str) {
CacheImage cacheImage = this.cacheImage;
cacheImage.httpTask = ImageLoader.this.new HttpImageTask(cacheImage, 0, str);
ImageLoader.this.httpTasks.add(this.cacheImage.httpTask);
ImageLoader.this.runHttpTasks(false);
}
public void lambda$onPostExecute$1() {
ImageLoader.this.runArtworkTasks(true);
}
public void lambda$onCancelled$2() {
ImageLoader.this.runArtworkTasks(true);
}
@Override
public void onCancelled() {
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.ArtworkLoadTask.this.lambda$onCancelled$2();
}
});
}
}
public class HttpImageTask extends AsyncTask<Void, Void, Boolean> {
private CacheImage cacheImage;
private boolean canRetry = true;
private RandomAccessFile fileOutputStream;
private HttpURLConnection httpConnection;
private long imageSize;
private long lastProgressTime;
private String overrideUrl;
public static void lambda$doInBackground$2(TLObject tLObject, TLRPC.TL_error tL_error) {
}
public HttpImageTask(CacheImage cacheImage, long size) {
this.cacheImage = cacheImage;
this.imageSize = size;
}
public HttpImageTask(CacheImage cacheImage, int size, String url) {
this.cacheImage = cacheImage;
this.imageSize = size;
this.overrideUrl = url;
}
private void reportProgress(final long uploadedSize, final long totalSize) {
long elapsedRealtime = SystemClock.elapsedRealtime();
if (uploadedSize != totalSize) {
long j = this.lastProgressTime;
if (j != 0 && j >= elapsedRealtime - 100) {
return;
}
}
this.lastProgressTime = elapsedRealtime;
Utilities.stageQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$reportProgress$1(uploadedSize, totalSize);
}
});
}
public void lambda$reportProgress$1(final long j, final long j2) {
ImageLoader.this.fileProgresses.put(this.cacheImage.url, new long[]{j, j2});
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$reportProgress$0(j, j2);
}
});
}
public void lambda$reportProgress$0(long j, long j2) {
NotificationCenter.getInstance(this.cacheImage.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileLoadProgressChanged, this.cacheImage.url, Long.valueOf(j), Long.valueOf(j2));
}
@Override
public java.lang.Boolean doInBackground(java.lang.Void... r13) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.HttpImageTask.doInBackground(java.lang.Void[]):java.lang.Boolean");
}
@Override
public void onPostExecute(final Boolean result) {
if (result.booleanValue() || !this.canRetry) {
ImageLoader imageLoader = ImageLoader.this;
CacheImage cacheImage = this.cacheImage;
imageLoader.fileDidLoaded(cacheImage.url, cacheImage.finalFilePath, 0);
} else {
ImageLoader.this.httpFileLoadError(this.cacheImage.url);
}
Utilities.stageQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$onPostExecute$4(result);
}
});
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$onPostExecute$5();
}
}, this.cacheImage.priority);
}
public void lambda$onPostExecute$4(final Boolean bool) {
ImageLoader.this.fileProgresses.remove(this.cacheImage.url);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$onPostExecute$3(bool);
}
});
}
public void lambda$onPostExecute$3(Boolean bool) {
if (bool.booleanValue()) {
NotificationCenter notificationCenter = NotificationCenter.getInstance(this.cacheImage.currentAccount);
int i = NotificationCenter.fileLoaded;
CacheImage cacheImage = this.cacheImage;
notificationCenter.lambda$postNotificationNameOnUIThread$1(i, cacheImage.url, cacheImage.finalFilePath);
return;
}
NotificationCenter.getInstance(this.cacheImage.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileLoadFailed, this.cacheImage.url, 2);
}
public void lambda$onPostExecute$5() {
ImageLoader.this.runHttpTasks(true);
}
public void lambda$onCancelled$6() {
ImageLoader.this.runHttpTasks(true);
}
@Override
public void onCancelled() {
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$onCancelled$6();
}
}, this.cacheImage.priority);
Utilities.stageQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$onCancelled$8();
}
});
}
public void lambda$onCancelled$8() {
ImageLoader.this.fileProgresses.remove(this.cacheImage.url);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.HttpImageTask.this.lambda$onCancelled$7();
}
});
}
public void lambda$onCancelled$7() {
NotificationCenter.getInstance(this.cacheImage.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileLoadFailed, this.cacheImage.url, 1);
}
}
public class ThumbGenerateTask implements Runnable {
private ThumbGenerateInfo info;
private int mediaType;
private File originalPath;
public ThumbGenerateTask(int type, File path, ThumbGenerateInfo i) {
this.mediaType = type;
this.originalPath = path;
this.info = i;
}
private void removeTask() {
ThumbGenerateInfo thumbGenerateInfo = this.info;
if (thumbGenerateInfo == null) {
return;
}
final String attachFileName = FileLoader.getAttachFileName(thumbGenerateInfo.parentDocument);
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.ThumbGenerateTask.this.lambda$removeTask$0(attachFileName);
}
});
}
public void lambda$removeTask$0(String str) {
ImageLoader.this.thumbGenerateTasks.remove(str);
}
@Override
public void run() {
int min;
Bitmap createScaledBitmap;
try {
if (this.info == null) {
removeTask();
return;
}
final String str = "q_" + this.info.parentDocument.dc_id + "_" + this.info.parentDocument.id;
File file = new File(FileLoader.getDirectory(4), str + ".jpg");
if (!file.exists() && this.originalPath.exists()) {
if (this.info.big) {
Point point = AndroidUtilities.displaySize;
min = Math.max(point.x, point.y);
} else {
Point point2 = AndroidUtilities.displaySize;
min = Math.min(180, Math.min(point2.x, point2.y) / 4);
}
int i = this.mediaType;
Bitmap bitmap = null;
if (i == 0) {
float f = min;
bitmap = ImageLoader.loadBitmap(this.originalPath.toString(), null, f, f, false);
} else {
int i2 = 2;
if (i == 2) {
String file2 = this.originalPath.toString();
if (!this.info.big) {
i2 = 1;
}
bitmap = SendMessagesHelper.createVideoThumbnail(file2, i2);
} else if (i == 3) {
String lowerCase = this.originalPath.toString().toLowerCase();
if (lowerCase.endsWith("mp4")) {
String file3 = this.originalPath.toString();
if (!this.info.big) {
i2 = 1;
}
bitmap = SendMessagesHelper.createVideoThumbnail(file3, i2);
} else if (lowerCase.endsWith(".jpg") || lowerCase.endsWith(".jpeg") || lowerCase.endsWith(".png") || lowerCase.endsWith(".gif")) {
float f2 = min;
bitmap = ImageLoader.loadBitmap(lowerCase, null, f2, f2, false);
}
}
}
if (bitmap == null) {
removeTask();
return;
}
int width = bitmap.getWidth();
int height = bitmap.getHeight();
if (width != 0 && height != 0) {
float f3 = width;
float f4 = min;
float f5 = height;
float min2 = Math.min(f3 / f4, f5 / f4);
if (min2 > 1.0f && (createScaledBitmap = Bitmaps.createScaledBitmap(bitmap, (int) (f3 / min2), (int) (f5 / min2), true)) != bitmap) {
bitmap.recycle();
bitmap = createScaledBitmap;
}
FileOutputStream fileOutputStream = new FileOutputStream(file);
bitmap.compress(Bitmap.CompressFormat.JPEG, this.info.big ? 83 : 60, fileOutputStream);
try {
fileOutputStream.close();
} catch (Exception e) {
FileLog.e(e);
}
final BitmapDrawable bitmapDrawable = new BitmapDrawable(bitmap);
final ArrayList arrayList = new ArrayList(this.info.imageReceiverArray);
final ArrayList arrayList2 = new ArrayList(this.info.imageReceiverGuidsArray);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.ThumbGenerateTask.this.lambda$run$1(str, arrayList, bitmapDrawable, arrayList2);
}
});
return;
}
removeTask();
return;
}
removeTask();
} catch (Throwable th) {
FileLog.e(th);
removeTask();
}
}
public void lambda$run$1(String str, ArrayList arrayList, BitmapDrawable bitmapDrawable, ArrayList arrayList2) {
removeTask();
if (this.info.filter != null) {
str = str + "@" + this.info.filter;
}
for (int i = 0; i < arrayList.size(); i++) {
((ImageReceiver) arrayList.get(i)).setImageBitmapByKey(bitmapDrawable, str, 0, false, ((Integer) arrayList2.get(i)).intValue());
}
ImageLoader.this.memCache.put(str, bitmapDrawable);
}
}
public static String decompressGzip(File file) {
StringBuilder sb = new StringBuilder();
if (file == null) {
return BuildConfig.APP_CENTER_HASH;
}
try {
GZIPInputStream gZIPInputStream = new GZIPInputStream(new FileInputStream(file));
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(gZIPInputStream, "UTF-8"));
while (true) {
try {
String readLine = bufferedReader.readLine();
if (readLine != null) {
sb.append(readLine);
} else {
String sb2 = sb.toString();
bufferedReader.close();
gZIPInputStream.close();
return sb2;
}
} finally {
}
}
} finally {
}
} catch (Exception unused) {
return BuildConfig.APP_CENTER_HASH;
}
}
public class CacheOutTask implements Runnable {
private CacheImage cacheImage;
private boolean isCancelled;
private Thread runningThread;
private final Object sync = new Object();
public CacheOutTask(CacheImage image) {
this.cacheImage = image;
}
@Override
public void run() {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.CacheOutTask.run():void");
}
private Bitmap applyWallpaperSetting(Bitmap bitmap, TLRPC.WallPaper wallPaper) {
int i;
if (!wallPaper.pattern || wallPaper.settings == null) {
TLRPC.WallPaperSettings wallPaperSettings = wallPaper.settings;
return (wallPaperSettings == null || !wallPaperSettings.blur) ? bitmap : Utilities.blurWallpaper(bitmap);
}
Bitmap createBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(createBitmap);
TLRPC.WallPaperSettings wallPaperSettings2 = wallPaper.settings;
boolean z = true;
if (wallPaperSettings2.second_background_color == 0) {
i = AndroidUtilities.getPatternColor(wallPaperSettings2.background_color);
canvas.drawColor(ColorUtils.setAlphaComponent(wallPaper.settings.background_color, 255));
} else if (wallPaperSettings2.third_background_color == 0) {
int alphaComponent = ColorUtils.setAlphaComponent(wallPaperSettings2.background_color, 255);
int alphaComponent2 = ColorUtils.setAlphaComponent(wallPaper.settings.second_background_color, 255);
int averageColor = AndroidUtilities.getAverageColor(alphaComponent, alphaComponent2);
GradientDrawable gradientDrawable = new GradientDrawable(BackgroundGradientDrawable.getGradientOrientation(wallPaper.settings.rotation), new int[]{alphaComponent, alphaComponent2});
gradientDrawable.setBounds(0, 0, createBitmap.getWidth(), createBitmap.getHeight());
gradientDrawable.draw(canvas);
i = averageColor;
} else {
int alphaComponent3 = ColorUtils.setAlphaComponent(wallPaperSettings2.background_color, 255);
int alphaComponent4 = ColorUtils.setAlphaComponent(wallPaper.settings.second_background_color, 255);
int alphaComponent5 = ColorUtils.setAlphaComponent(wallPaper.settings.third_background_color, 255);
int i2 = wallPaper.settings.fourth_background_color;
int alphaComponent6 = i2 == 0 ? 0 : ColorUtils.setAlphaComponent(i2, 255);
int patternColor = MotionBackgroundDrawable.getPatternColor(alphaComponent3, alphaComponent4, alphaComponent5, alphaComponent6);
MotionBackgroundDrawable motionBackgroundDrawable = new MotionBackgroundDrawable();
motionBackgroundDrawable.setColors(alphaComponent3, alphaComponent4, alphaComponent5, alphaComponent6);
motionBackgroundDrawable.setBounds(0, 0, createBitmap.getWidth(), createBitmap.getHeight());
motionBackgroundDrawable.setPatternBitmap(wallPaper.settings.intensity, bitmap);
motionBackgroundDrawable.draw(canvas);
i = patternColor;
z = false;
}
if (z) {
Paint paint = new Paint(2);
paint.setColorFilter(new PorterDuffColorFilter(i, PorterDuff.Mode.SRC_IN));
paint.setAlpha((int) ((wallPaper.settings.intensity / 100.0f) * 255.0f));
canvas.drawBitmap(bitmap, 0.0f, 0.0f, paint);
}
return createBitmap;
}
private void loadLastFrame(RLottieDrawable lottieDrawable, int w, int h, boolean lastFrame, boolean reaction) {
Bitmap createBitmap;
Canvas canvas;
Drawable bitmapDrawable;
if (lastFrame && reaction) {
float f = w * 1.2f;
float f2 = h * 1.2f;
createBitmap = Bitmap.createBitmap((int) f, (int) f2, Bitmap.Config.ARGB_8888);
canvas = new Canvas(createBitmap);
canvas.scale(2.0f, 2.0f, f / 2.0f, f2 / 2.0f);
} else {
createBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
canvas = new Canvas(createBitmap);
}
lottieDrawable.prepareForGenerateCache();
Bitmap createBitmap2 = Bitmap.createBitmap(lottieDrawable.getIntrinsicWidth(), lottieDrawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
lottieDrawable.setGeneratingFrame(lastFrame ? lottieDrawable.getFramesCount() - 1 : 0);
lottieDrawable.getNextFrame(createBitmap2);
lottieDrawable.releaseForGenerateCache();
canvas.save();
if (!lastFrame || !reaction) {
canvas.scale(createBitmap2.getWidth() / w, createBitmap2.getHeight() / h, w / 2.0f, h / 2.0f);
}
Paint paint = new Paint(1);
paint.setFilterBitmap(true);
if (lastFrame && reaction) {
canvas.drawBitmap(createBitmap2, (createBitmap.getWidth() - createBitmap2.getWidth()) / 2.0f, (createBitmap.getHeight() - createBitmap2.getHeight()) / 2.0f, paint);
bitmapDrawable = new ImageReceiver.ReactionLastFrame(createBitmap);
} else {
canvas.drawBitmap(createBitmap2, 0.0f, 0.0f, paint);
bitmapDrawable = new BitmapDrawable(createBitmap);
}
lottieDrawable.recycle(false);
createBitmap2.recycle();
onPostExecute(bitmapDrawable);
}
private void onPostExecute(final Drawable drawable) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.CacheOutTask.this.lambda$onPostExecute$1(drawable);
}
});
}
public void lambda$onPostExecute$1(Drawable drawable) {
final String str;
boolean z = false;
final Drawable drawable2 = null;
r2 = null;
r2 = null;
r2 = null;
String str2 = null;
if (drawable instanceof RLottieDrawable) {
RLottieDrawable rLottieDrawable = (RLottieDrawable) drawable;
Drawable drawable3 = (Drawable) ImageLoader.this.lottieMemCache.get(this.cacheImage.key);
if (drawable3 == null) {
ImageLoader.this.lottieMemCache.put(this.cacheImage.key, rLottieDrawable);
drawable = rLottieDrawable;
} else {
rLottieDrawable.recycle(false);
drawable = drawable3;
}
if (drawable != null) {
ImageLoader.this.incrementUseCount(this.cacheImage.key);
str2 = this.cacheImage.key;
}
} else if (drawable instanceof AnimatedFileDrawable) {
AnimatedFileDrawable animatedFileDrawable = (AnimatedFileDrawable) drawable;
if (animatedFileDrawable.isWebmSticker) {
BitmapDrawable fromLottieCache = ImageLoader.this.getFromLottieCache(this.cacheImage.key);
if (fromLottieCache == null) {
ImageLoader.this.lottieMemCache.put(this.cacheImage.key, animatedFileDrawable);
drawable = animatedFileDrawable;
} else {
animatedFileDrawable.recycle();
drawable = fromLottieCache;
}
ImageLoader.this.incrementUseCount(this.cacheImage.key);
str2 = this.cacheImage.key;
}
} else if (drawable instanceof BitmapDrawable) {
BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
BitmapDrawable fromMemCache = ImageLoader.this.getFromMemCache(this.cacheImage.key);
boolean z2 = true;
if (fromMemCache == null) {
if (this.cacheImage.key.endsWith("_f")) {
ImageLoader.this.wallpaperMemCache.put(this.cacheImage.key, bitmapDrawable);
} else {
if (!this.cacheImage.key.endsWith("_isc") && bitmapDrawable.getBitmap().getWidth() <= AndroidUtilities.density * 80.0f && bitmapDrawable.getBitmap().getHeight() <= AndroidUtilities.density * 80.0f) {
ImageLoader.this.smallImagesMemCache.put(this.cacheImage.key, bitmapDrawable);
} else {
ImageLoader.this.memCache.put(this.cacheImage.key, bitmapDrawable);
}
z = true;
}
z2 = z;
drawable = bitmapDrawable;
} else {
AndroidUtilities.recycleBitmap(bitmapDrawable.getBitmap());
drawable = fromMemCache;
}
if (drawable != null && z2) {
ImageLoader.this.incrementUseCount(this.cacheImage.key);
str2 = this.cacheImage.key;
}
} else {
str = null;
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.CacheOutTask.this.lambda$onPostExecute$0(drawable2, str);
}
}, this.cacheImage.priority);
}
String str3 = str2;
drawable2 = drawable;
str = str3;
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.CacheOutTask.this.lambda$onPostExecute$0(drawable2, str);
}
}, this.cacheImage.priority);
}
public void lambda$onPostExecute$0(Drawable drawable, String str) {
this.cacheImage.setImageAndClear(drawable, str);
}
public void cancel() {
synchronized (this.sync) {
try {
this.isCancelled = true;
Thread thread = this.runningThread;
if (thread != null) {
thread.interrupt();
}
} catch (Exception unused) {
}
}
}
}
public boolean isAnimatedAvatar(String filter) {
return filter != null && filter.endsWith("avatar");
}
private boolean isPFrame(String filter) {
return filter != null && filter.endsWith("pframe");
}
public BitmapDrawable getFromMemCache(String key) {
BitmapDrawable bitmapDrawable = this.memCache.get(key);
if (bitmapDrawable == null) {
bitmapDrawable = this.smallImagesMemCache.get(key);
}
if (bitmapDrawable == null) {
bitmapDrawable = this.wallpaperMemCache.get(key);
}
return bitmapDrawable == null ? getFromLottieCache(key) : bitmapDrawable;
}
public static Bitmap getStrippedPhotoBitmap(byte[] photoBytes, String filter) {
int length = (photoBytes.length - 3) + Bitmaps.header.length + Bitmaps.footer.length;
byte[] bArr = bytesLocal.get();
if (bArr == null || bArr.length < length) {
bArr = null;
}
if (bArr == null) {
bArr = new byte[length];
bytesLocal.set(bArr);
}
byte[] bArr2 = Bitmaps.header;
System.arraycopy(bArr2, 0, bArr, 0, bArr2.length);
System.arraycopy(photoBytes, 3, bArr, Bitmaps.header.length, photoBytes.length - 3);
System.arraycopy(Bitmaps.footer, 0, bArr, (Bitmaps.header.length + photoBytes.length) - 3, Bitmaps.footer.length);
bArr[164] = photoBytes[1];
bArr[166] = photoBytes[2];
BitmapFactory.Options options = new BitmapFactory.Options();
boolean z = !TextUtils.isEmpty(filter) && filter.contains("r");
options.inPreferredConfig = (SharedConfig.deviceIsHigh() || z) ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;
Bitmap decodeByteArray = BitmapFactory.decodeByteArray(bArr, 0, length, options);
if (z) {
Bitmap createBitmap = Bitmap.createBitmap(decodeByteArray.getWidth(), decodeByteArray.getHeight(), decodeByteArray.getConfig());
Canvas canvas = new Canvas(createBitmap);
canvas.save();
canvas.scale(1.2f, 1.2f, decodeByteArray.getWidth() / 2.0f, decodeByteArray.getHeight() / 2.0f);
canvas.drawBitmap(decodeByteArray, 0.0f, 0.0f, (Paint) null);
canvas.restore();
Path path = new Path();
path.addCircle(decodeByteArray.getWidth() / 2.0f, decodeByteArray.getHeight() / 2.0f, Math.min(decodeByteArray.getWidth(), decodeByteArray.getHeight()) / 2.0f, Path.Direction.CW);
canvas.clipPath(path);
canvas.drawBitmap(decodeByteArray, 0.0f, 0.0f, (Paint) null);
decodeByteArray.recycle();
decodeByteArray = createBitmap;
}
if (decodeByteArray != null && !TextUtils.isEmpty(filter) && filter.contains("b")) {
Utilities.blurBitmap(decodeByteArray, 3, 1, decodeByteArray.getWidth(), decodeByteArray.getHeight(), decodeByteArray.getRowBytes());
}
return decodeByteArray;
}
public class CacheImage {
public ArtworkLoadTask artworkTask;
public CacheOutTask cacheTask;
public int cacheType;
public int currentAccount;
public File encryptionKeyPath;
public String ext;
public String filter;
public ArrayList<String> filters;
public File finalFilePath;
public HttpImageTask httpTask;
public ImageLocation imageLocation;
public ArrayList<ImageReceiver> imageReceiverArray;
public ArrayList<Integer> imageReceiverGuidsArray;
public int imageType;
public boolean isPFrame;
public String key;
public ArrayList<String> keys;
public Object parentObject;
public int priority;
public Runnable runningTask;
public SecureDocument secureDocument;
public long size;
public File tempFilePath;
public int type;
public ArrayList<Integer> types;
public String url;
private CacheImage() {
this.priority = 1;
this.imageReceiverArray = new ArrayList<>();
this.imageReceiverGuidsArray = new ArrayList<>();
this.keys = new ArrayList<>();
this.filters = new ArrayList<>();
this.types = new ArrayList<>();
}
public void addImageReceiver(ImageReceiver imageReceiver, String key, String filter, int type, int guid) {
int indexOf = this.imageReceiverArray.indexOf(imageReceiver);
if (indexOf >= 0 && Objects.equals(this.imageReceiverArray.get(indexOf).getImageKey(), key)) {
this.imageReceiverGuidsArray.set(indexOf, Integer.valueOf(guid));
return;
}
this.imageReceiverArray.add(imageReceiver);
this.imageReceiverGuidsArray.add(Integer.valueOf(guid));
this.keys.add(key);
this.filters.add(filter);
this.types.add(Integer.valueOf(type));
ImageLoader.this.imageLoadingByTag.put(imageReceiver.getTag(type), this);
}
public void replaceImageReceiver(ImageReceiver imageReceiver, String key, String filter, int type, int guid) {
int indexOf = this.imageReceiverArray.indexOf(imageReceiver);
if (indexOf == -1) {
return;
}
if (this.types.get(indexOf).intValue() != type) {
ArrayList<ImageReceiver> arrayList = this.imageReceiverArray;
indexOf = arrayList.subList(indexOf + 1, arrayList.size()).indexOf(imageReceiver);
if (indexOf == -1) {
return;
}
}
this.imageReceiverGuidsArray.set(indexOf, Integer.valueOf(guid));
this.keys.set(indexOf, key);
this.filters.set(indexOf, filter);
}
public void setImageReceiverGuid(ImageReceiver imageReceiver, int guid) {
int indexOf = this.imageReceiverArray.indexOf(imageReceiver);
if (indexOf == -1) {
return;
}
this.imageReceiverGuidsArray.set(indexOf, Integer.valueOf(guid));
}
public void removeImageReceiver(ImageReceiver imageReceiver) {
int i = this.type;
int i2 = 0;
while (i2 < this.imageReceiverArray.size()) {
ImageReceiver imageReceiver2 = this.imageReceiverArray.get(i2);
if (imageReceiver2 == null || imageReceiver2 == imageReceiver) {
this.imageReceiverArray.remove(i2);
this.imageReceiverGuidsArray.remove(i2);
this.keys.remove(i2);
this.filters.remove(i2);
i = this.types.remove(i2).intValue();
if (imageReceiver2 != null) {
ImageLoader.this.imageLoadingByTag.remove(imageReceiver2.getTag(i));
}
i2--;
}
i2++;
}
if (this.imageReceiverArray.isEmpty()) {
if (this.imageLocation != null && !ImageLoader.this.forceLoadingImages.containsKey(this.key)) {
ImageLocation imageLocation = this.imageLocation;
if (imageLocation.location != null) {
FileLoader.getInstance(this.currentAccount).cancelLoadFile(this.imageLocation.location, this.ext);
} else if (imageLocation.document != null) {
FileLoader.getInstance(this.currentAccount).cancelLoadFile(this.imageLocation.document);
} else if (imageLocation.secureDocument != null) {
FileLoader.getInstance(this.currentAccount).cancelLoadFile(this.imageLocation.secureDocument);
} else if (imageLocation.webFile != null) {
FileLoader.getInstance(this.currentAccount).cancelLoadFile(this.imageLocation.webFile);
}
}
if (this.cacheTask != null) {
if (i == 1) {
ImageLoader.this.cacheThumbOutQueue.cancelRunnable(this.cacheTask);
} else {
ImageLoader.this.cacheOutQueue.cancelRunnable(this.cacheTask);
ImageLoader.this.cacheOutQueue.cancelRunnable(this.runningTask);
}
this.cacheTask.cancel();
this.cacheTask = null;
}
if (this.httpTask != null) {
ImageLoader.this.httpTasks.remove(this.httpTask);
this.httpTask.cancel(true);
this.httpTask = null;
}
if (this.artworkTask != null) {
ImageLoader.this.artworkTasks.remove(this.artworkTask);
this.artworkTask.cancel(true);
this.artworkTask = null;
}
if (this.url != null) {
ImageLoader.this.imageLoadingByUrl.remove(this.url);
}
if (this.url != null) {
ImageLoader.this.imageLoadingByUrlPframe.remove(this.url);
}
String str = this.key;
if (str != null) {
ImageLoader.this.imageLoadingByKeys.remove(str);
ImageLoader.this.imageLoadingKeys.remove(ImageLoader.cutFilter(this.key));
}
}
}
public void changePriority(int i) {
TLRPC.Document document;
?? r6;
TLObject tLObject;
TLRPC.TL_fileLocationToBeDeprecated tL_fileLocationToBeDeprecated;
TLRPC.TL_fileLocationToBeDeprecated tL_fileLocationToBeDeprecated2;
?? r9;
?? r7;
ImageLocation imageLocation = this.imageLocation;
if (imageLocation != null) {
TLRPC.TL_fileLocationToBeDeprecated tL_fileLocationToBeDeprecated3 = imageLocation.location;
if (tL_fileLocationToBeDeprecated3 != null) {
r9 = this.ext;
tL_fileLocationToBeDeprecated = tL_fileLocationToBeDeprecated3;
document = null;
r6 = null;
r7 = 0;
} else {
TLRPC.Document document2 = imageLocation.document;
if (document2 != null) {
document = document2;
r6 = null;
} else {
SecureDocument secureDocument = imageLocation.secureDocument;
if (secureDocument != null) {
r6 = secureDocument;
document = null;
tL_fileLocationToBeDeprecated2 = null;
tL_fileLocationToBeDeprecated = tL_fileLocationToBeDeprecated2;
tLObject = tL_fileLocationToBeDeprecated2;
r9 = tL_fileLocationToBeDeprecated;
r7 = tLObject;
} else {
TLObject tLObject2 = imageLocation.webFile;
if (tLObject2 != null) {
tLObject = tLObject2;
document = null;
r6 = null;
tL_fileLocationToBeDeprecated = null;
r9 = tL_fileLocationToBeDeprecated;
r7 = tLObject;
} else {
document = null;
r6 = null;
}
}
}
tL_fileLocationToBeDeprecated2 = r6;
tL_fileLocationToBeDeprecated = tL_fileLocationToBeDeprecated2;
tLObject = tL_fileLocationToBeDeprecated2;
r9 = tL_fileLocationToBeDeprecated;
r7 = tLObject;
}
FileLoader.getInstance(this.currentAccount).changePriority(i, document, r6, r7, tL_fileLocationToBeDeprecated, r9, null);
}
}
public void setImageAndClear(final Drawable image, final String decrementKey) {
if (image != null) {
final ArrayList arrayList = new ArrayList(this.imageReceiverArray);
final ArrayList arrayList2 = new ArrayList(this.imageReceiverGuidsArray);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.CacheImage.this.lambda$setImageAndClear$0(image, arrayList, arrayList2, decrementKey);
}
});
}
for (int i = 0; i < this.imageReceiverArray.size(); i++) {
ImageLoader.this.imageLoadingByTag.remove(this.imageReceiverArray.get(i).getTag(this.type));
}
this.imageReceiverArray.clear();
this.imageReceiverGuidsArray.clear();
if (this.url != null) {
ImageLoader.this.imageLoadingByUrl.remove(this.url);
}
if (this.url != null) {
ImageLoader.this.imageLoadingByUrlPframe.remove(this.url);
}
String str = this.key;
if (str != null) {
ImageLoader.this.imageLoadingByKeys.remove(str);
ImageLoader.this.imageLoadingKeys.remove(ImageLoader.cutFilter(this.key));
}
}
public void lambda$setImageAndClear$0(android.graphics.drawable.Drawable r10, java.util.ArrayList r11, java.util.ArrayList r12, java.lang.String r13) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.CacheImage.lambda$setImageAndClear$0(android.graphics.drawable.Drawable, java.util.ArrayList, java.util.ArrayList, java.lang.String):void");
}
}
public static ImageLoader getInstance() {
ImageLoader imageLoader = Instance;
if (imageLoader == null) {
synchronized (ImageLoader.class) {
imageLoader = Instance;
if (imageLoader == null) {
imageLoader = new ImageLoader();
Instance = imageLoader;
}
}
}
return imageLoader;
}
public ImageLoader() {
this.thumbGeneratingQueue.setPriority(1);
int memoryClass = ((ActivityManager) ApplicationLoader.applicationContext.getSystemService("activity")).getMemoryClass();
boolean z = memoryClass >= 192;
this.canForce8888 = z;
int min = Math.min(z ? 30 : 15, memoryClass / 7) * 1024 * 1024;
float f = min;
this.memCache = new LruCache<BitmapDrawable>((int) (0.8f * f)) {
@Override
public int sizeOf(String key, BitmapDrawable value) {
return ImageLoader.this.sizeOfBitmapDrawable(value);
}
@Override
public void entryRemoved(boolean evicted, String key, final BitmapDrawable oldValue, BitmapDrawable newValue) {
if (ImageLoader.this.ignoreRemoval == null || !ImageLoader.this.ignoreRemoval.equals(key)) {
Integer num = (Integer) ImageLoader.this.bitmapUseCounts.get(key);
if (num == null || num.intValue() == 0) {
Bitmap bitmap = oldValue.getBitmap();
if (bitmap.isRecycled()) {
return;
}
ArrayList arrayList = new ArrayList();
arrayList.add(bitmap);
AndroidUtilities.recycleBitmaps(arrayList);
}
}
}
};
this.smallImagesMemCache = new LruCache<BitmapDrawable>((int) (f * 0.2f)) {
@Override
public int sizeOf(String key, BitmapDrawable value) {
return ImageLoader.this.sizeOfBitmapDrawable(value);
}
@Override
public void entryRemoved(boolean evicted, String key, final BitmapDrawable oldValue, BitmapDrawable newValue) {
if (ImageLoader.this.ignoreRemoval == null || !ImageLoader.this.ignoreRemoval.equals(key)) {
Integer num = (Integer) ImageLoader.this.bitmapUseCounts.get(key);
if (num == null || num.intValue() == 0) {
Bitmap bitmap = oldValue.getBitmap();
if (bitmap.isRecycled()) {
return;
}
ArrayList arrayList = new ArrayList();
arrayList.add(bitmap);
AndroidUtilities.recycleBitmaps(arrayList);
}
}
}
};
this.wallpaperMemCache = new LruCache<BitmapDrawable>(min / 4) {
@Override
public int sizeOf(String key, BitmapDrawable value) {
return ImageLoader.this.sizeOfBitmapDrawable(value);
}
};
this.lottieMemCache = new LruCache<BitmapDrawable>(10485760) {
@Override
public int sizeOf(String key, BitmapDrawable value) {
return ImageLoader.this.sizeOfBitmapDrawable(value);
}
@Override
public BitmapDrawable put(String key, BitmapDrawable value) {
if (value instanceof AnimatedFileDrawable) {
ImageLoader.this.cachedAnimatedFileDrawables.add((AnimatedFileDrawable) value);
}
return (BitmapDrawable) super.put(key, (String) value);
}
@Override
public void entryRemoved(boolean evicted, String key, final BitmapDrawable oldValue, BitmapDrawable newValue) {
Integer num = (Integer) ImageLoader.this.bitmapUseCounts.get(key);
boolean z2 = oldValue instanceof AnimatedFileDrawable;
if (z2) {
ImageLoader.this.cachedAnimatedFileDrawables.remove((AnimatedFileDrawable) oldValue);
}
if (num == null || num.intValue() == 0) {
if (z2) {
((AnimatedFileDrawable) oldValue).recycle();
}
if (oldValue instanceof RLottieDrawable) {
((RLottieDrawable) oldValue).recycle(false);
}
}
}
};
SparseArray sparseArray = new SparseArray();
File cacheDir = AndroidUtilities.getCacheDir();
if (!cacheDir.isDirectory()) {
try {
cacheDir.mkdirs();
} catch (Exception e) {
FileLog.e(e);
}
}
AndroidUtilities.createEmptyFile(new File(cacheDir, ".nomedia"));
sparseArray.put(4, cacheDir);
for (int i = 0; i < UserConfig.MAX_ACCOUNT_COUNT; i++) {
FileLoader.getInstance(i).setDelegate(new AnonymousClass5(i));
}
FileLoader.setMediaDirs(sparseArray);
AnonymousClass6 anonymousClass6 = new AnonymousClass6();
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("android.intent.action.MEDIA_BAD_REMOVAL");
intentFilter.addAction("android.intent.action.MEDIA_CHECKING");
intentFilter.addAction("android.intent.action.MEDIA_EJECT");
intentFilter.addAction("android.intent.action.MEDIA_MOUNTED");
intentFilter.addAction("android.intent.action.MEDIA_NOFS");
intentFilter.addAction("android.intent.action.MEDIA_REMOVED");
intentFilter.addAction("android.intent.action.MEDIA_SHARED");
intentFilter.addAction("android.intent.action.MEDIA_UNMOUNTABLE");
intentFilter.addAction("android.intent.action.MEDIA_UNMOUNTED");
intentFilter.addDataScheme("file");
try {
ApplicationLoader.applicationContext.registerReceiver(anonymousClass6, intentFilter);
} catch (Throwable unused) {
}
checkMediaPaths();
}
public class AnonymousClass5 implements FileLoader.FileLoaderDelegate {
public final int val$currentAccount;
public AnonymousClass5(final int val$currentAccount) {
this.val$currentAccount = val$currentAccount;
}
@Override
public void fileUploadProgressChanged(FileUploadOperation operation, final String location, final long uploadedSize, final long totalSize, final boolean isEncrypted) {
ImageLoader.this.fileProgresses.put(location, new long[]{uploadedSize, totalSize});
long elapsedRealtime = SystemClock.elapsedRealtime();
long j = operation.lastProgressUpdateTime;
if (j == 0 || j < elapsedRealtime - 100 || uploadedSize == totalSize) {
operation.lastProgressUpdateTime = elapsedRealtime;
final int i = this.val$currentAccount;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.lambda$fileUploadProgressChanged$0(i, location, uploadedSize, totalSize, isEncrypted);
}
});
}
}
public static void lambda$fileUploadProgressChanged$0(int i, String str, long j, long j2, boolean z) {
NotificationCenter.getInstance(i).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileUploadProgressChanged, str, Long.valueOf(j), Long.valueOf(j2), Boolean.valueOf(z));
}
@Override
public void fileDidUploaded(final String location, final TLRPC.InputFile inputFile, final TLRPC.InputEncryptedFile inputEncryptedFile, final byte[] key, final byte[] iv, final long totalFileSize) {
DispatchQueue dispatchQueue = Utilities.stageQueue;
final int i = this.val$currentAccount;
dispatchQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.this.lambda$fileDidUploaded$2(i, location, inputFile, inputEncryptedFile, key, iv, totalFileSize);
}
});
}
public static void lambda$fileDidUploaded$1(int i, String str, TLRPC.InputFile inputFile, TLRPC.InputEncryptedFile inputEncryptedFile, byte[] bArr, byte[] bArr2, long j) {
NotificationCenter.getInstance(i).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileUploaded, str, inputFile, inputEncryptedFile, bArr, bArr2, Long.valueOf(j));
}
public void lambda$fileDidUploaded$2(final int i, final String str, final TLRPC.InputFile inputFile, final TLRPC.InputEncryptedFile inputEncryptedFile, final byte[] bArr, final byte[] bArr2, final long j) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.lambda$fileDidUploaded$1(i, str, inputFile, inputEncryptedFile, bArr, bArr2, j);
}
});
ImageLoader.this.fileProgresses.remove(str);
}
@Override
public void fileDidFailedUpload(final String location, final boolean isEncrypted) {
DispatchQueue dispatchQueue = Utilities.stageQueue;
final int i = this.val$currentAccount;
dispatchQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.this.lambda$fileDidFailedUpload$4(i, location, isEncrypted);
}
});
}
public static void lambda$fileDidFailedUpload$3(int i, String str, boolean z) {
NotificationCenter.getInstance(i).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileUploadFailed, str, Boolean.valueOf(z));
}
public void lambda$fileDidFailedUpload$4(final int i, final String str, final boolean z) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.lambda$fileDidFailedUpload$3(i, str, z);
}
});
ImageLoader.this.fileProgresses.remove(str);
}
@Override
public void fileDidLoaded(final String location, final File finalFile, final Object parentObject, final int type) {
ImageLoader.this.fileProgresses.remove(location);
final int i = this.val$currentAccount;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.this.lambda$fileDidLoaded$5(finalFile, location, i, parentObject, type);
}
});
}
public void lambda$fileDidLoaded$5(File file, String str, int i, Object obj, int i2) {
FilePathDatabase.FileMeta fileMetadataFromParent;
int i3;
if (file != null && ((str.endsWith(".mp4") || str.endsWith(".jpg")) && (fileMetadataFromParent = FileLoader.getFileMetadataFromParent(i, obj)) != null)) {
MessageObject messageObject = obj instanceof MessageObject ? (MessageObject) obj : null;
long j = fileMetadataFromParent.dialogId;
if (j >= 0) {
i3 = 1;
} else {
i3 = ChatObject.isChannelAndNotMegaGroup(MessagesController.getInstance(i).getChat(Long.valueOf(-j))) ? 4 : 2;
}
if (SaveToGallerySettingsHelper.needSave(i3, fileMetadataFromParent, messageObject, i)) {
AndroidUtilities.addMediaToGallery(file.toString());
}
}
NotificationCenter.getInstance(i).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileLoaded, str, file);
ImageLoader.this.fileDidLoaded(str, file, i2);
}
@Override
public void fileDidFailedLoad(final String location, final int canceled) {
ImageLoader.this.fileProgresses.remove(location);
final int i = this.val$currentAccount;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.this.lambda$fileDidFailedLoad$6(location, canceled, i);
}
});
}
public void lambda$fileDidFailedLoad$6(String str, int i, int i2) {
ImageLoader.this.fileDidFailedLoad(str, i);
NotificationCenter.getInstance(i2).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileLoadFailed, str, Integer.valueOf(i));
}
@Override
public void fileLoadProgressChanged(final FileLoadOperation operation, final String location, final long uploadedSize, final long totalSize) {
ImageLoader.this.fileProgresses.put(location, new long[]{uploadedSize, totalSize});
if (!ImageLoader.this.imageLoadingByUrlPframe.isEmpty() && operation.checkPrefixPreloadFinished()) {
ImageLoader.this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.this.lambda$fileLoadProgressChanged$7(location, operation);
}
});
}
long elapsedRealtime = SystemClock.elapsedRealtime();
long j = operation.lastProgressUpdateTime;
if (j == 0 || j < elapsedRealtime - 500 || uploadedSize == 0) {
operation.lastProgressUpdateTime = elapsedRealtime;
final int i = this.val$currentAccount;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass5.lambda$fileLoadProgressChanged$8(i, location, uploadedSize, totalSize);
}
});
}
}
public void lambda$fileLoadProgressChanged$7(String str, FileLoadOperation fileLoadOperation) {
CacheImage cacheImage = (CacheImage) ImageLoader.this.imageLoadingByUrlPframe.remove(str);
if (cacheImage == null) {
return;
}
ImageLoader.this.imageLoadingByUrl.remove(str);
ArrayList arrayList = new ArrayList();
for (int i = 0; i < cacheImage.imageReceiverArray.size(); i++) {
String str2 = cacheImage.keys.get(i);
String str3 = cacheImage.filters.get(i);
int intValue = cacheImage.types.get(i).intValue();
ImageReceiver imageReceiver = cacheImage.imageReceiverArray.get(i);
int intValue2 = cacheImage.imageReceiverGuidsArray.get(i).intValue();
CacheImage cacheImage2 = (CacheImage) ImageLoader.this.imageLoadingByKeys.get(str2);
if (cacheImage2 == null) {
cacheImage2 = new CacheImage();
cacheImage2.priority = cacheImage.priority;
cacheImage2.secureDocument = cacheImage.secureDocument;
cacheImage2.currentAccount = cacheImage.currentAccount;
cacheImage2.finalFilePath = fileLoadOperation.getCurrentFile();
cacheImage2.parentObject = cacheImage.parentObject;
cacheImage2.isPFrame = cacheImage.isPFrame;
cacheImage2.key = str2;
cacheImage2.imageLocation = cacheImage.imageLocation;
cacheImage2.type = intValue;
cacheImage2.ext = cacheImage.ext;
cacheImage2.encryptionKeyPath = cacheImage.encryptionKeyPath;
cacheImage2.cacheTask = ImageLoader.this.new CacheOutTask(cacheImage2);
cacheImage2.filter = str3;
cacheImage2.imageType = cacheImage.imageType;
cacheImage2.cacheType = cacheImage.cacheType;
ImageLoader.this.imageLoadingByKeys.put(str2, cacheImage2);
ImageLoader.this.imageLoadingKeys.add(ImageLoader.cutFilter(str2));
arrayList.add(cacheImage2.cacheTask);
}
cacheImage2.addImageReceiver(imageReceiver, str2, str3, intValue, intValue2);
}
for (int i2 = 0; i2 < arrayList.size(); i2++) {
CacheOutTask cacheOutTask = (CacheOutTask) arrayList.get(i2);
if (cacheOutTask.cacheImage.type == 1) {
ImageLoader.this.cacheThumbOutQueue.postRunnable(cacheOutTask);
} else {
ImageLoader.this.cacheOutQueue.postRunnable(cacheOutTask, cacheOutTask.cacheImage.priority);
}
}
}
public static void lambda$fileLoadProgressChanged$8(int i, String str, long j, long j2) {
NotificationCenter.getInstance(i).lambda$postNotificationNameOnUIThread$1(NotificationCenter.fileLoadProgressChanged, str, Long.valueOf(j), Long.valueOf(j2));
}
}
public class AnonymousClass6 extends BroadcastReceiver {
public AnonymousClass6() {
}
@Override
public void onReceive(Context arg0, Intent intent) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("file system changed");
}
Runnable runnable = new Runnable() {
@Override
public final void run() {
ImageLoader.AnonymousClass6.this.lambda$onReceive$0();
}
};
if ("android.intent.action.MEDIA_UNMOUNTED".equals(intent.getAction())) {
AndroidUtilities.runOnUIThread(runnable, 1000L);
} else {
runnable.run();
}
}
public void lambda$onReceive$0() {
ImageLoader.this.checkMediaPaths();
}
}
public int sizeOfBitmapDrawable(BitmapDrawable value) {
if (value instanceof AnimatedFileDrawable) {
AnimatedFileDrawable animatedFileDrawable = (AnimatedFileDrawable) value;
return Math.max(animatedFileDrawable.getIntrinsicHeight() * value.getIntrinsicWidth() * 4 * 3, animatedFileDrawable.getRenderingHeight() * animatedFileDrawable.getRenderingWidth() * 4 * 3);
}
if (value instanceof RLottieDrawable) {
return value.getIntrinsicWidth() * value.getIntrinsicHeight() * 4 * 2;
}
return value.getBitmap().getByteCount();
}
public void checkMediaPaths() {
checkMediaPaths(null);
}
public void checkMediaPaths(final Runnable after) {
this.cacheOutQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$checkMediaPaths$1(after);
}
});
}
public void lambda$checkMediaPaths$1(final Runnable runnable) {
final SparseArray<File> createMediaPaths = createMediaPaths();
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.lambda$checkMediaPaths$0(createMediaPaths, runnable);
}
});
}
public static void lambda$checkMediaPaths$0(SparseArray sparseArray, Runnable runnable) {
FileLoader.setMediaDirs(sparseArray);
if (runnable != null) {
runnable.run();
}
}
public void addTestWebFile(String url, WebFile webFile) {
if (url == null || webFile == null) {
return;
}
this.testWebFile.put(url, webFile);
}
public void removeTestWebFile(String url) {
if (url == null) {
return;
}
this.testWebFile.remove(url);
}
@TargetApi(26)
private static void moveDirectory(File source, final File target) {
if (source.exists()) {
if (target.exists() || target.mkdir()) {
try {
Stream convert = $r8.wrapper.java.util.stream.Stream.-V-WRP.convert(Files.list(source.toPath()));
try {
convert.forEach(new Consumer() {
public final void accept(Object obj) {
ImageLoader.lambda$moveDirectory$2(target, (java.nio.file.Path) obj);
}
public Consumer andThen(Consumer consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
});
convert.close();
} finally {
}
} catch (Exception e) {
FileLog.e(e);
}
}
}
}
public static void lambda$moveDirectory$2(File file, java.nio.file.Path path) {
File file2 = new File(file, path.getFileName().toString());
if (Files.isDirectory(path, new LinkOption[0])) {
moveDirectory(path.toFile(), file2);
return;
}
try {
Files.move(path, file2.toPath(), new CopyOption[0]);
} catch (Exception e) {
FileLog.e(e);
}
}
public String getTelegramPath() {
return this.telegramPath.getAbsolutePath();
}
public File getTelegramPathFile() {
return this.telegramPath;
}
public android.util.SparseArray<java.io.File> createMediaPaths() {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.createMediaPaths():android.util.SparseArray");
}
private File getPublicStorageDir() {
File file = ApplicationLoader.applicationContext.getExternalMediaDirs()[0];
if (!TextUtils.isEmpty(SharedConfig.storageCacheDir)) {
for (int i = 0; i < ApplicationLoader.applicationContext.getExternalMediaDirs().length; i++) {
File file2 = ApplicationLoader.applicationContext.getExternalMediaDirs()[i];
if (file2 != null && file2.getPath().startsWith(SharedConfig.storageCacheDir)) {
file = ApplicationLoader.applicationContext.getExternalMediaDirs()[i];
}
}
}
return file;
}
private boolean canMoveFiles(File from, File to, int type) {
File file;
File file2;
byte[] bArr;
RandomAccessFile randomAccessFile;
boolean renameTo;
RandomAccessFile randomAccessFile2 = null;
try {
try {
if (type == 0) {
file = new File(from, "000000000_999999_temp.f");
file2 = new File(to, "000000000_999999.f");
} else {
if (type != 3 && type != 5 && type != 6) {
if (type == 1) {
file = new File(from, "000000000_999999_temp.f");
file2 = new File(to, "000000000_999999.f");
} else if (type == 2) {
file = new File(from, "000000000_999999_temp.f");
file2 = new File(to, "000000000_999999.f");
} else if (type == 7) {
file = new File(from, "000000000_999999_temp.f");
file2 = new File(to, "000000000_999999.f");
} else {
file2 = null;
file = null;
}
}
file = new File(from, "000000000_999999_temp.f");
file2 = new File(to, "000000000_999999.f");
}
bArr = new byte[1024];
file.createNewFile();
randomAccessFile = new RandomAccessFile(file, "rws");
} catch (Throwable th) {
th = th;
}
} catch (Exception e) {
e = e;
}
try {
randomAccessFile.write(bArr);
randomAccessFile.close();
renameTo = file.renameTo(file2);
if (!renameTo && PlusSettings.getStorage() > 0) {
renameTo = AndroidUtilities.moveFile(file, file2, false);
}
file.delete();
file2.delete();
} catch (Exception e2) {
e = e2;
randomAccessFile2 = randomAccessFile;
FileLog.e(e);
if (randomAccessFile2 != null) {
try {
randomAccessFile2.close();
} catch (Exception e3) {
FileLog.e(e3);
}
}
} catch (Throwable th2) {
th = th2;
randomAccessFile2 = randomAccessFile;
if (randomAccessFile2 != null) {
try {
randomAccessFile2.close();
} catch (Exception e4) {
FileLog.e(e4);
}
}
throw th;
}
return renameTo;
}
public Float getFileProgress(String location) {
long[] jArr;
if (location == null || (jArr = (long[]) this.fileProgresses.get(location)) == null) {
return null;
}
if (jArr[1] == 0) {
return Float.valueOf(0.0f);
}
return Float.valueOf(Math.min(1.0f, jArr[0] / jArr[1]));
}
public long[] getFileProgressSizes(String location) {
if (location == null) {
return null;
}
return (long[]) this.fileProgresses.get(location);
}
public String getReplacedKey(String oldKey) {
if (oldKey == null) {
return null;
}
return this.replacedBitmaps.get(oldKey);
}
private void performReplace(String oldKey, String newKey) {
LruCache<BitmapDrawable> lruCache = this.memCache;
BitmapDrawable bitmapDrawable = lruCache.get(oldKey);
if (bitmapDrawable == null) {
lruCache = this.smallImagesMemCache;
bitmapDrawable = lruCache.get(oldKey);
}
this.replacedBitmaps.put(oldKey, newKey);
if (bitmapDrawable != null) {
BitmapDrawable bitmapDrawable2 = lruCache.get(newKey);
boolean z = false;
if (bitmapDrawable2 != null && bitmapDrawable2.getBitmap() != null && bitmapDrawable.getBitmap() != null) {
Bitmap bitmap = bitmapDrawable2.getBitmap();
Bitmap bitmap2 = bitmapDrawable.getBitmap();
if (bitmap.getWidth() > bitmap2.getWidth() || bitmap.getHeight() > bitmap2.getHeight()) {
z = true;
}
}
if (!z) {
this.ignoreRemoval = oldKey;
lruCache.remove(oldKey);
lruCache.put(newKey, bitmapDrawable);
this.ignoreRemoval = null;
} else {
lruCache.remove(oldKey);
}
}
Integer num = this.bitmapUseCounts.get(oldKey);
if (num != null) {
this.bitmapUseCounts.put(newKey, num);
this.bitmapUseCounts.remove(oldKey);
}
}
public void incrementUseCount(String key) {
Integer num = this.bitmapUseCounts.get(key);
if (num == null) {
this.bitmapUseCounts.put(key, 1);
} else {
this.bitmapUseCounts.put(key, Integer.valueOf(num.intValue() + 1));
}
}
public boolean decrementUseCount(String key) {
Integer num = this.bitmapUseCounts.get(key);
if (num == null) {
return true;
}
if (num.intValue() == 1) {
this.bitmapUseCounts.remove(key);
return true;
}
this.bitmapUseCounts.put(key, Integer.valueOf(num.intValue() - 1));
return false;
}
public void removeImage(String key) {
this.bitmapUseCounts.remove(key);
this.memCache.remove(key);
this.smallImagesMemCache.remove(key);
}
public boolean isInMemCache(String key, boolean animated) {
return animated ? getFromLottieCache(key) != null : getFromMemCache(key) != null;
}
public void clearMemory() {
this.smallImagesMemCache.evictAll();
this.memCache.evictAll();
this.lottieMemCache.evictAll();
}
private void removeFromWaitingForThumb(int TAG, ImageReceiver imageReceiver) {
String str = this.waitingForQualityThumbByTag.get(TAG);
if (str != null) {
ThumbGenerateInfo thumbGenerateInfo = this.waitingForQualityThumb.get(str);
if (thumbGenerateInfo != null) {
int indexOf = thumbGenerateInfo.imageReceiverArray.indexOf(imageReceiver);
if (indexOf >= 0) {
thumbGenerateInfo.imageReceiverArray.remove(indexOf);
thumbGenerateInfo.imageReceiverGuidsArray.remove(indexOf);
}
if (thumbGenerateInfo.imageReceiverArray.isEmpty()) {
this.waitingForQualityThumb.remove(str);
}
}
this.waitingForQualityThumbByTag.remove(TAG);
}
}
public void changeFileLoadingPriorityForImageReceiver(final ImageReceiver imageReceiver) {
if (imageReceiver == null) {
return;
}
final int fileLoadingPriority = imageReceiver.getFileLoadingPriority();
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$changeFileLoadingPriorityForImageReceiver$3(imageReceiver, fileLoadingPriority);
}
});
}
public void lambda$changeFileLoadingPriorityForImageReceiver$3(ImageReceiver imageReceiver, int i) {
CacheImage cacheImage;
int i2 = 0;
while (true) {
int i3 = 3;
if (i2 >= 3) {
return;
}
if (i2 == 0) {
i3 = 1;
} else if (i2 == 1) {
i3 = 0;
}
int tag = imageReceiver.getTag(i3);
if (tag != 0 && (cacheImage = this.imageLoadingByTag.get(tag)) != null) {
cacheImage.changePriority(i);
}
i2++;
}
}
public void cancelLoadingForImageReceiver(final ImageReceiver imageReceiver, final boolean cancelAll) {
if (imageReceiver == null) {
return;
}
ArrayList<Runnable> loadingOperations = imageReceiver.getLoadingOperations();
if (!loadingOperations.isEmpty()) {
for (int i = 0; i < loadingOperations.size(); i++) {
this.imageLoadQueue.cancelRunnable(loadingOperations.get(i));
}
loadingOperations.clear();
}
imageReceiver.addLoadingImageRunnable(null);
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$cancelLoadingForImageReceiver$4(cancelAll, imageReceiver);
}
});
}
public void lambda$cancelLoadingForImageReceiver$4(boolean z, ImageReceiver imageReceiver) {
int i = 0;
while (true) {
int i2 = 3;
if (i >= 3) {
return;
}
if (i > 0 && !z) {
return;
}
if (i == 0) {
i2 = 1;
} else if (i == 1) {
i2 = 0;
}
int tag = imageReceiver.getTag(i2);
if (tag != 0) {
if (i == 0) {
removeFromWaitingForThumb(tag, imageReceiver);
}
CacheImage cacheImage = this.imageLoadingByTag.get(tag);
if (cacheImage != null) {
cacheImage.removeImageReceiver(imageReceiver);
}
}
i++;
}
}
public BitmapDrawable getImageFromMemory(TLObject fileLocation, String httpUrl, String filter) {
String str = null;
if (fileLocation == null && httpUrl == null) {
return null;
}
if (httpUrl != null) {
str = Utilities.MD5(httpUrl);
} else if (fileLocation instanceof TLRPC.FileLocation) {
TLRPC.FileLocation fileLocation2 = (TLRPC.FileLocation) fileLocation;
str = fileLocation2.volume_id + "_" + fileLocation2.local_id;
} else if (fileLocation instanceof TLRPC.Document) {
TLRPC.Document document = (TLRPC.Document) fileLocation;
str = document.dc_id + "_" + document.id;
} else if (fileLocation instanceof SecureDocument) {
SecureDocument secureDocument = (SecureDocument) fileLocation;
str = secureDocument.secureFile.dc_id + "_" + secureDocument.secureFile.id;
} else if (fileLocation instanceof WebFile) {
str = Utilities.MD5(((WebFile) fileLocation).url);
}
if (filter != null) {
str = str + "@" + filter;
}
return getFromMemCache(str);
}
public void lambda$replaceImageInCache$5(final String oldKey, final String newKey, final ImageLocation newLocation) {
ArrayList<String> filterKeys;
for (int i = 0; i < 2; i++) {
if (i == 0) {
filterKeys = this.memCache.getFilterKeys(oldKey);
} else {
filterKeys = this.smallImagesMemCache.getFilterKeys(oldKey);
}
if (filterKeys != null) {
for (int i2 = 0; i2 < filterKeys.size(); i2++) {
String str = filterKeys.get(i2);
String str2 = oldKey + "@" + str;
String str3 = newKey + "@" + str;
performReplace(str2, str3);
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.didReplacedPhotoInMemCache, str2, str3, newLocation);
}
} else {
performReplace(oldKey, newKey);
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.didReplacedPhotoInMemCache, oldKey, newKey, newLocation);
}
}
}
public static String cutFilter(String key) {
if (key == null) {
return null;
}
int indexOf = key.indexOf(64);
return indexOf >= 0 ? key.substring(0, indexOf) : key;
}
public void replaceImageInCache(final String oldKey, final String newKey, final ImageLocation newLocation, boolean post) {
if (post) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$replaceImageInCache$5(oldKey, newKey, newLocation);
}
});
} else {
lambda$replaceImageInCache$5(oldKey, newKey, newLocation);
}
}
public void putImageToCache(BitmapDrawable bitmap, String key, boolean smallImage) {
if (smallImage) {
this.smallImagesMemCache.put(key, bitmap);
} else {
this.memCache.put(key, bitmap);
}
}
private void generateThumb(int mediaType, File originalPath, ThumbGenerateInfo info) {
if ((mediaType != 0 && mediaType != 2 && mediaType != 3) || originalPath == null || info == null) {
return;
}
if (this.thumbGenerateTasks.get(FileLoader.getAttachFileName(info.parentDocument)) == null) {
this.thumbGeneratingQueue.postRunnable(new ThumbGenerateTask(mediaType, originalPath, info));
}
}
public void cancelForceLoadingForImageReceiver(final ImageReceiver imageReceiver) {
final String imageKey;
if (imageReceiver == null || (imageKey = imageReceiver.getImageKey()) == null) {
return;
}
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$cancelForceLoadingForImageReceiver$6(imageKey);
}
});
}
public void lambda$cancelForceLoadingForImageReceiver$6(String str) {
this.forceLoadingImages.remove(str);
}
private void createLoadOperationForImageReceiver(final ImageReceiver imageReceiver, final String key, final String url, final String ext, final ImageLocation imageLocation, final String filter, final long size, final int cacheType, final int type, final int thumb, final int guid) {
if (imageReceiver == null || url == null || key == null || imageLocation == null) {
return;
}
int tag = imageReceiver.getTag(type);
if (tag == 0) {
tag = this.lastImageNum;
imageReceiver.setTag(tag, type);
int i = this.lastImageNum + 1;
this.lastImageNum = i;
if (i == Integer.MAX_VALUE) {
this.lastImageNum = 0;
}
}
final int i2 = tag;
final boolean isNeedsQualityThumb = imageReceiver.isNeedsQualityThumb();
final Object parentObject = imageReceiver.getParentObject();
final TLRPC.Document qualityThumbDocument = imageReceiver.getQualityThumbDocument();
final boolean isShouldGenerateQualityThumb = imageReceiver.isShouldGenerateQualityThumb();
final int currentAccount = imageReceiver.getCurrentAccount();
final boolean z = type == 0 && imageReceiver.isCurrentKeyQuality();
Runnable runnable = new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$createLoadOperationForImageReceiver$7(thumb, url, key, i2, imageReceiver, guid, filter, type, imageLocation, z, parentObject, currentAccount, qualityThumbDocument, isNeedsQualityThumb, isShouldGenerateQualityThumb, ext, cacheType, size);
}
};
this.imageLoadQueue.postRunnable(runnable, imageReceiver.getFileLoadingPriority() == 0 ? 0L : 1L);
imageReceiver.addLoadingImageRunnable(runnable);
}
public void lambda$createLoadOperationForImageReceiver$7(int r25, java.lang.String r26, java.lang.String r27, int r28, org.telegram.messenger.ImageReceiver r29, int r30, java.lang.String r31, int r32, org.telegram.messenger.ImageLocation r33, boolean r34, java.lang.Object r35, int r36, org.telegram.tgnet.TLRPC.Document r37, boolean r38, boolean r39, java.lang.String r40, int r41, long r42) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.lambda$createLoadOperationForImageReceiver$7(int, java.lang.String, java.lang.String, int, org.telegram.messenger.ImageReceiver, int, java.lang.String, int, org.telegram.messenger.ImageLocation, boolean, java.lang.Object, int, org.telegram.tgnet.TLRPC$Document, boolean, boolean, java.lang.String, int, long):void");
}
public void preloadArtwork(final String athumbUrl) {
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$preloadArtwork$8(athumbUrl);
}
});
}
public void lambda$preloadArtwork$8(String str) {
String httpUrlExtension = getHttpUrlExtension(str, "jpg");
String str2 = Utilities.MD5(str) + "." + httpUrlExtension;
File file = new File(FileLoader.getDirectory(4), str2);
if (file.exists()) {
return;
}
ImageLocation forPath = ImageLocation.getForPath(str);
CacheImage cacheImage = new CacheImage();
cacheImage.type = 1;
cacheImage.key = Utilities.MD5(str);
cacheImage.filter = null;
cacheImage.imageLocation = forPath;
cacheImage.ext = httpUrlExtension;
cacheImage.parentObject = null;
int i = forPath.imageType;
if (i != 0) {
cacheImage.imageType = i;
}
cacheImage.url = str2;
this.imageLoadingByUrl.put(str2, cacheImage);
String MD5 = Utilities.MD5(forPath.path);
cacheImage.tempFilePath = new File(FileLoader.getDirectory(4), MD5 + "_temp.jpg");
cacheImage.finalFilePath = file;
ArtworkLoadTask artworkLoadTask = new ArtworkLoadTask(cacheImage);
cacheImage.artworkTask = artworkLoadTask;
this.artworkTasks.add(artworkLoadTask);
runArtworkTasks(false);
}
public void loadImageForImageReceiver(ImageReceiver imageReceiver) {
loadImageForImageReceiver(imageReceiver, null);
}
public void loadImageForImageReceiver(org.telegram.messenger.ImageReceiver r37, java.util.List<org.telegram.messenger.ImageReceiver> r38) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.loadImageForImageReceiver(org.telegram.messenger.ImageReceiver, java.util.List):void");
}
private Drawable findInPreloadImageReceivers(String imageKey, List<ImageReceiver> receivers) {
if (receivers == null) {
return null;
}
for (int i = 0; i < receivers.size(); i++) {
ImageReceiver imageReceiver = receivers.get(i);
if (imageKey.equals(imageReceiver.getImageKey())) {
return imageReceiver.getImageDrawable();
}
if (imageKey.equals(imageReceiver.getMediaKey())) {
return imageReceiver.getMediaDrawable();
}
}
return null;
}
public BitmapDrawable getFromLottieCache(String imageKey) {
BitmapDrawable bitmapDrawable = this.lottieMemCache.get(imageKey);
if (!(bitmapDrawable instanceof AnimatedFileDrawable) || !((AnimatedFileDrawable) bitmapDrawable).isRecycled()) {
return bitmapDrawable;
}
this.lottieMemCache.remove(imageKey);
return null;
}
private boolean useLottieMemCache(ImageLocation imageLocation, String key) {
if (key.endsWith("_firstframe") || key.endsWith("_lastframe")) {
return false;
}
return (imageLocation != null && (MessageObject.isAnimatedStickerDocument(imageLocation.document, true) || imageLocation.imageType == 1 || MessageObject.isVideoSticker(imageLocation.document))) || isAnimatedAvatar(key);
}
public boolean hasLottieMemCache(String key) {
LruCache<BitmapDrawable> lruCache = this.lottieMemCache;
return lruCache != null && lruCache.contains(key);
}
public void httpFileLoadError(final String location) {
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$httpFileLoadError$9(location);
}
});
}
public void lambda$httpFileLoadError$9(String str) {
CacheImage cacheImage = this.imageLoadingByUrl.get(str);
if (cacheImage == null) {
return;
}
HttpImageTask httpImageTask = cacheImage.httpTask;
if (httpImageTask != null) {
HttpImageTask httpImageTask2 = new HttpImageTask(httpImageTask.cacheImage, httpImageTask.imageSize);
cacheImage.httpTask = httpImageTask2;
this.httpTasks.add(httpImageTask2);
}
runHttpTasks(false);
}
public void artworkLoadError(final String location) {
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$artworkLoadError$10(location);
}
});
}
public void lambda$artworkLoadError$10(String str) {
CacheImage cacheImage = this.imageLoadingByUrl.get(str);
if (cacheImage == null) {
return;
}
ArtworkLoadTask artworkLoadTask = cacheImage.artworkTask;
if (artworkLoadTask != null) {
ArtworkLoadTask artworkLoadTask2 = new ArtworkLoadTask(artworkLoadTask.cacheImage);
cacheImage.artworkTask = artworkLoadTask2;
this.artworkTasks.add(artworkLoadTask2);
}
runArtworkTasks(false);
}
public void fileDidLoaded(final String location, final File finalFile, final int mediaType) {
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$fileDidLoaded$11(location, mediaType, finalFile);
}
});
}
public void lambda$fileDidLoaded$11(String str, int i, File file) {
ThumbGenerateInfo thumbGenerateInfo = this.waitingForQualityThumb.get(str);
if (thumbGenerateInfo != null && thumbGenerateInfo.parentDocument != null) {
generateThumb(i, file, thumbGenerateInfo);
this.waitingForQualityThumb.remove(str);
}
CacheImage cacheImage = this.imageLoadingByUrl.get(str);
if (cacheImage == null) {
return;
}
this.imageLoadingByUrl.remove(str);
this.imageLoadingByUrlPframe.remove(str);
ArrayList arrayList = new ArrayList();
for (int i2 = 0; i2 < cacheImage.imageReceiverArray.size(); i2++) {
String str2 = cacheImage.keys.get(i2);
String str3 = cacheImage.filters.get(i2);
int intValue = cacheImage.types.get(i2).intValue();
ImageReceiver imageReceiver = cacheImage.imageReceiverArray.get(i2);
int intValue2 = cacheImage.imageReceiverGuidsArray.get(i2).intValue();
CacheImage cacheImage2 = (CacheImage) this.imageLoadingByKeys.get(str2);
if (cacheImage2 == null) {
cacheImage2 = new CacheImage();
cacheImage2.priority = cacheImage.priority;
cacheImage2.secureDocument = cacheImage.secureDocument;
cacheImage2.currentAccount = cacheImage.currentAccount;
cacheImage2.finalFilePath = file;
cacheImage2.parentObject = cacheImage.parentObject;
cacheImage2.isPFrame = cacheImage.isPFrame;
cacheImage2.key = str2;
cacheImage2.cacheType = cacheImage.cacheType;
cacheImage2.imageLocation = cacheImage.imageLocation;
cacheImage2.type = intValue;
cacheImage2.ext = cacheImage.ext;
cacheImage2.encryptionKeyPath = cacheImage.encryptionKeyPath;
cacheImage2.cacheTask = new CacheOutTask(cacheImage2);
cacheImage2.filter = str3;
cacheImage2.imageType = cacheImage.imageType;
this.imageLoadingByKeys.put(str2, cacheImage2);
this.imageLoadingKeys.add(cutFilter(str2));
arrayList.add(cacheImage2.cacheTask);
}
cacheImage2.addImageReceiver(imageReceiver, str2, str3, intValue, intValue2);
}
for (int i3 = 0; i3 < arrayList.size(); i3++) {
CacheOutTask cacheOutTask = (CacheOutTask) arrayList.get(i3);
if (cacheOutTask.cacheImage.type == 1) {
this.cacheThumbOutQueue.postRunnable(cacheOutTask);
} else {
this.cacheOutQueue.postRunnable(cacheOutTask, cacheOutTask.cacheImage.priority);
}
}
}
public void fileDidFailedLoad(final String location, int canceled) {
if (canceled == 1) {
return;
}
this.imageLoadQueue.postRunnable(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$fileDidFailedLoad$12(location);
}
});
}
public void lambda$fileDidFailedLoad$12(String str) {
CacheImage cacheImage = this.imageLoadingByUrl.get(str);
if (cacheImage != null) {
cacheImage.setImageAndClear(null, null);
}
}
public void runHttpTasks(boolean complete) {
if (complete) {
this.currentHttpTasksCount--;
}
while (this.currentHttpTasksCount < 4 && !this.httpTasks.isEmpty()) {
HttpImageTask poll = this.httpTasks.poll();
if (poll != null) {
poll.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null, null, null);
this.currentHttpTasksCount++;
}
}
}
public void runArtworkTasks(boolean complete) {
if (complete) {
this.currentArtworkTasksCount--;
}
while (this.currentArtworkTasksCount < 4 && !this.artworkTasks.isEmpty()) {
try {
this.artworkTasks.poll().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null, null, null);
this.currentArtworkTasksCount++;
} catch (Throwable unused) {
runArtworkTasks(false);
}
}
}
public boolean isLoadingHttpFile(String url) {
return this.httpFileLoadTasksByKeys.containsKey(url);
}
public static String getHttpFileName(String url) {
return Utilities.MD5(url);
}
public static File getHttpFilePath(String url, String defaultExt) {
String httpUrlExtension = getHttpUrlExtension(url, defaultExt);
return new File(FileLoader.getDirectory(4), Utilities.MD5(url) + "." + httpUrlExtension);
}
public void loadHttpFile(String url, String defaultExt, int currentAccount) {
if (url == null || url.length() == 0 || this.httpFileLoadTasksByKeys.containsKey(url)) {
return;
}
String httpUrlExtension = getHttpUrlExtension(url, defaultExt);
File file = new File(FileLoader.getDirectory(4), Utilities.MD5(url) + "_temp." + httpUrlExtension);
file.delete();
HttpFileTask httpFileTask = new HttpFileTask(url, file, httpUrlExtension, currentAccount);
this.httpFileLoadTasks.add(httpFileTask);
this.httpFileLoadTasksByKeys.put(url, httpFileTask);
runHttpFileLoadTasks(null, 0);
}
public void cancelLoadHttpFile(String url) {
HttpFileTask httpFileTask = this.httpFileLoadTasksByKeys.get(url);
if (httpFileTask != null) {
httpFileTask.cancel(true);
this.httpFileLoadTasksByKeys.remove(url);
this.httpFileLoadTasks.remove(httpFileTask);
}
Runnable runnable = this.retryHttpsTasks.get(url);
if (runnable != null) {
AndroidUtilities.cancelRunOnUIThread(runnable);
}
runHttpFileLoadTasks(null, 0);
}
public void runHttpFileLoadTasks(final HttpFileTask oldTask, final int reason) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$runHttpFileLoadTasks$14(oldTask, reason);
}
});
}
public void lambda$runHttpFileLoadTasks$14(HttpFileTask httpFileTask, int i) {
if (httpFileTask != null) {
this.currentHttpFileLoadTasksCount--;
}
if (httpFileTask != null) {
if (i == 1) {
if (httpFileTask.canRetry) {
final HttpFileTask httpFileTask2 = new HttpFileTask(httpFileTask.url, httpFileTask.tempFile, httpFileTask.ext, httpFileTask.currentAccount);
Runnable runnable = new Runnable() {
@Override
public final void run() {
ImageLoader.this.lambda$runHttpFileLoadTasks$13(httpFileTask2);
}
};
this.retryHttpsTasks.put(httpFileTask.url, runnable);
AndroidUtilities.runOnUIThread(runnable, 1000L);
} else {
this.httpFileLoadTasksByKeys.remove(httpFileTask.url);
NotificationCenter.getInstance(httpFileTask.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.httpFileDidFailedLoad, httpFileTask.url, 0);
}
} else if (i == 2) {
this.httpFileLoadTasksByKeys.remove(httpFileTask.url);
File file = new File(FileLoader.getDirectory(4), Utilities.MD5(httpFileTask.url) + "." + httpFileTask.ext);
if (!httpFileTask.tempFile.renameTo(file)) {
file = httpFileTask.tempFile;
}
NotificationCenter.getInstance(httpFileTask.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.httpFileDidLoad, httpFileTask.url, file.toString());
}
}
while (this.currentHttpFileLoadTasksCount < 2 && !this.httpFileLoadTasks.isEmpty()) {
this.httpFileLoadTasks.poll().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null, null, null);
this.currentHttpFileLoadTasksCount++;
}
}
public void lambda$runHttpFileLoadTasks$13(HttpFileTask httpFileTask) {
this.httpFileLoadTasks.add(httpFileTask);
runHttpFileLoadTasks(null, 0);
}
public static boolean shouldSendImageAsDocument(String path, Uri uri) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
if (path == null && uri != null && uri.getScheme() != null) {
if (uri.getScheme().contains("file")) {
path = uri.getPath();
} else {
try {
path = AndroidUtilities.getPath(uri);
} catch (Throwable th) {
FileLog.e(th);
}
}
}
if (path != null) {
BitmapFactory.decodeFile(path, options);
} else if (uri != null) {
try {
InputStream openInputStream = ApplicationLoader.applicationContext.getContentResolver().openInputStream(uri);
BitmapFactory.decodeStream(openInputStream, null, options);
openInputStream.close();
} catch (Throwable th2) {
FileLog.e(th2);
return false;
}
}
float f = options.outWidth;
float f2 = options.outHeight;
return f / f2 > 10.0f || f2 / f > 10.0f;
}
public static android.graphics.Bitmap loadBitmap(java.lang.String r17, android.net.Uri r18, float r19, float r20, boolean r21) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.loadBitmap(java.lang.String, android.net.Uri, float, float, boolean):android.graphics.Bitmap");
}
public static void fillPhotoSizeWithBytes(TLRPC.PhotoSize photoSize) {
if (photoSize != null) {
byte[] bArr = photoSize.bytes;
if (bArr == null || bArr.length == 0) {
try {
RandomAccessFile randomAccessFile = new RandomAccessFile(FileLoader.getInstance(UserConfig.selectedAccount).getPathToAttach(photoSize, true), "r");
if (((int) randomAccessFile.length()) < 20000) {
byte[] bArr2 = new byte[(int) randomAccessFile.length()];
photoSize.bytes = bArr2;
randomAccessFile.readFully(bArr2, 0, bArr2.length);
}
} catch (Throwable th) {
FileLog.e(th);
}
}
}
}
private static org.telegram.tgnet.TLRPC.PhotoSize scaleAndSaveImageInternal(org.telegram.tgnet.TLRPC.PhotoSize r2, android.graphics.Bitmap r3, android.graphics.Bitmap.CompressFormat r4, boolean r5, int r6, int r7, float r8, float r9, float r10, int r11, boolean r12, boolean r13, boolean r14) throws java.lang.Exception {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.ImageLoader.scaleAndSaveImageInternal(org.telegram.tgnet.TLRPC$PhotoSize, android.graphics.Bitmap, android.graphics.Bitmap$CompressFormat, boolean, int, int, float, float, float, int, boolean, boolean, boolean):org.telegram.tgnet.TLRPC$PhotoSize");
}
public static class AnonymousClass7 {
public static final int[] $SwitchMap$android$graphics$Bitmap$CompressFormat;
static {
int[] iArr = new int[Bitmap.CompressFormat.values().length];
$SwitchMap$android$graphics$Bitmap$CompressFormat = iArr;
try {
iArr[Bitmap.CompressFormat.WEBP.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
$SwitchMap$android$graphics$Bitmap$CompressFormat[Bitmap.CompressFormat.WEBP_LOSSY.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
try {
$SwitchMap$android$graphics$Bitmap$CompressFormat[Bitmap.CompressFormat.WEBP_LOSSLESS.ordinal()] = 3;
} catch (NoSuchFieldError unused3) {
}
}
}
public static TLRPC.PhotoSize scaleAndSaveImage(Bitmap bitmap, float maxWidth, float maxHeight, int quality, boolean cache) {
return scaleAndSaveImage(null, bitmap, Bitmap.CompressFormat.JPEG, false, maxWidth, maxHeight, quality, cache, 0, 0, false);
}
public static TLRPC.PhotoSize scaleAndSaveImage(TLRPC.PhotoSize photoSize, Bitmap bitmap, float maxWidth, float maxHeight, int quality, boolean cache, boolean forceCacheDir) {
return scaleAndSaveImage(photoSize, bitmap, Bitmap.CompressFormat.JPEG, false, maxWidth, maxHeight, quality, cache, 0, 0, forceCacheDir);
}
public static TLRPC.PhotoSize scaleAndSaveImage(Bitmap bitmap, float maxWidth, float maxHeight, int quality, boolean cache, int minWidth, int minHeight) {
return scaleAndSaveImage(null, bitmap, Bitmap.CompressFormat.JPEG, false, maxWidth, maxHeight, quality, cache, minWidth, minHeight, false);
}
public static TLRPC.PhotoSize scaleAndSaveImage(Bitmap bitmap, float maxWidth, float maxHeight, boolean progressive, int quality, boolean cache, int minWidth, int minHeight) {
return scaleAndSaveImage(null, bitmap, Bitmap.CompressFormat.JPEG, progressive, maxWidth, maxHeight, quality, cache, minWidth, minHeight, false);
}
public static TLRPC.PhotoSize scaleAndSaveImage(Bitmap bitmap, Bitmap.CompressFormat compressFormat, float maxWidth, float maxHeight, int quality, boolean cache, int minWidth, int minHeight) {
return scaleAndSaveImage(null, bitmap, compressFormat, false, maxWidth, maxHeight, quality, cache, minWidth, minHeight, false);
}
public static TLRPC.PhotoSize scaleAndSaveImage(TLRPC.PhotoSize photoSize, Bitmap bitmap, Bitmap.CompressFormat compressFormat, boolean progressive, float maxWidth, float maxHeight, int quality, boolean cache, int minWidth, int minHeight, boolean forceCacheDir) {
float f;
boolean z;
int i;
int i2;
float max;
if (bitmap == null) {
return null;
}
float width = bitmap.getWidth();
float height = bitmap.getHeight();
if (width != 0.0f && height != 0.0f) {
float max2 = Math.max(width / maxWidth, height / maxHeight);
if (minWidth != 0 && minHeight != 0) {
float f2 = minWidth;
if (width < f2 || height < minHeight) {
if (width >= f2 || height <= minHeight) {
if (width > f2) {
float f3 = minHeight;
if (height < f3) {
max = height / f3;
}
}
max = Math.max(width / f2, height / minHeight);
} else {
max = width / f2;
}
f = max;
z = true;
i = (int) (width / f);
i2 = (int) (height / f);
if (i2 != 0 && i != 0) {
try {
return scaleAndSaveImageInternal(photoSize, bitmap, compressFormat, progressive, i, i2, width, height, f, quality, cache, z, forceCacheDir);
} catch (Throwable th) {
FileLog.e(th);
getInstance().clearMemory();
System.gc();
try {
return scaleAndSaveImageInternal(photoSize, bitmap, compressFormat, progressive, i, i2, width, height, f, quality, cache, z, forceCacheDir);
} catch (Throwable th2) {
FileLog.e(th2);
}
}
}
}
}
f = max2;
z = false;
i = (int) (width / f);
i2 = (int) (height / f);
if (i2 != 0) {
return scaleAndSaveImageInternal(photoSize, bitmap, compressFormat, progressive, i, i2, width, height, f, quality, cache, z, forceCacheDir);
}
}
return null;
}
public static String getHttpUrlExtension(String url, String defaultExt) {
String lastPathSegment = Uri.parse(url).getLastPathSegment();
if (!TextUtils.isEmpty(lastPathSegment) && lastPathSegment.length() > 1) {
url = lastPathSegment;
}
int lastIndexOf = url.lastIndexOf(46);
String substring = lastIndexOf != -1 ? url.substring(lastIndexOf + 1) : null;
return (substring == null || substring.length() == 0 || substring.length() > 4) ? defaultExt : substring;
}
public static void saveMessageThumbs(TLRPC.Message message) {
TLRPC.PhotoSize findPhotoCachedSize;
byte[] bArr;
TLRPC.PhotoSize tL_photoSize_layer127;
if (message.media == null || (findPhotoCachedSize = findPhotoCachedSize(message)) == null || (bArr = findPhotoCachedSize.bytes) == null || bArr.length == 0) {
return;
}
TLRPC.FileLocation fileLocation = findPhotoCachedSize.location;
if (fileLocation == null || (fileLocation instanceof TLRPC.TL_fileLocationUnavailable)) {
TLRPC.TL_fileLocationToBeDeprecated tL_fileLocationToBeDeprecated = new TLRPC.TL_fileLocationToBeDeprecated();
findPhotoCachedSize.location = tL_fileLocationToBeDeprecated;
tL_fileLocationToBeDeprecated.volume_id = -2147483648L;
tL_fileLocationToBeDeprecated.local_id = SharedConfig.getLastLocalId();
}
int i = 0;
if (findPhotoCachedSize.h <= 50 && findPhotoCachedSize.w <= 50) {
tL_photoSize_layer127 = new TLRPC.TL_photoStrippedSize();
tL_photoSize_layer127.location = findPhotoCachedSize.location;
tL_photoSize_layer127.bytes = findPhotoCachedSize.bytes;
tL_photoSize_layer127.h = findPhotoCachedSize.h;
tL_photoSize_layer127.w = findPhotoCachedSize.w;
} else {
boolean z = true;
File pathToAttach = FileLoader.getInstance(UserConfig.selectedAccount).getPathToAttach(findPhotoCachedSize, true);
if (MessageObject.shouldEncryptPhotoOrVideo(UserConfig.selectedAccount, message)) {
pathToAttach = new File(pathToAttach.getAbsolutePath() + ".enc");
} else {
z = false;
}
if (!pathToAttach.exists()) {
if (z) {
try {
RandomAccessFile randomAccessFile = new RandomAccessFile(new File(FileLoader.getInternalCacheDir(), pathToAttach.getName() + ".key"), "rws");
long length = randomAccessFile.length();
byte[] bArr2 = new byte[32];
byte[] bArr3 = new byte[16];
if (length > 0 && length % 48 == 0) {
randomAccessFile.read(bArr2, 0, 32);
randomAccessFile.read(bArr3, 0, 16);
} else {
Utilities.random.nextBytes(bArr2);
Utilities.random.nextBytes(bArr3);
randomAccessFile.write(bArr2);
randomAccessFile.write(bArr3);
}
randomAccessFile.close();
Utilities.aesCtrDecryptionByteArray(findPhotoCachedSize.bytes, bArr2, bArr3, 0, r8.length, 0);
} catch (Exception e) {
FileLog.e(e);
}
}
RandomAccessFile randomAccessFile2 = new RandomAccessFile(pathToAttach, "rws");
randomAccessFile2.write(findPhotoCachedSize.bytes);
randomAccessFile2.close();
}
tL_photoSize_layer127 = new TLRPC.TL_photoSize_layer127();
tL_photoSize_layer127.w = findPhotoCachedSize.w;
tL_photoSize_layer127.h = findPhotoCachedSize.h;
tL_photoSize_layer127.location = findPhotoCachedSize.location;
tL_photoSize_layer127.size = findPhotoCachedSize.size;
tL_photoSize_layer127.type = findPhotoCachedSize.type;
}
TLRPC.MessageMedia messageMedia = message.media;
if (messageMedia instanceof TLRPC.TL_messageMediaPhoto) {
int size = messageMedia.photo.sizes.size();
while (i < size) {
if (message.media.photo.sizes.get(i) instanceof TLRPC.TL_photoCachedSize) {
message.media.photo.sizes.set(i, tL_photoSize_layer127);
return;
}
i++;
}
return;
}
if (messageMedia instanceof TLRPC.TL_messageMediaDocument) {
int size2 = messageMedia.document.thumbs.size();
while (i < size2) {
if (((TLRPC.PhotoSize) message.media.document.thumbs.get(i)) instanceof TLRPC.TL_photoCachedSize) {
message.media.document.thumbs.set(i, tL_photoSize_layer127);
return;
}
i++;
}
return;
}
if (messageMedia instanceof TLRPC.TL_messageMediaWebPage) {
int size3 = messageMedia.webpage.photo.sizes.size();
while (i < size3) {
if (message.media.webpage.photo.sizes.get(i) instanceof TLRPC.TL_photoCachedSize) {
message.media.webpage.photo.sizes.set(i, tL_photoSize_layer127);
return;
}
i++;
}
}
}
private static TLRPC.PhotoSize findPhotoCachedSize(TLRPC.Message message) {
TLRPC.PhotoSize photoSize;
TLRPC.MessageMedia messageMedia = message.media;
int i = 0;
if (messageMedia instanceof TLRPC.TL_messageMediaPhoto) {
int size = messageMedia.photo.sizes.size();
while (i < size) {
photoSize = message.media.photo.sizes.get(i);
if (!(photoSize instanceof TLRPC.TL_photoCachedSize)) {
i++;
}
}
return null;
}
if (messageMedia instanceof TLRPC.TL_messageMediaDocument) {
TLRPC.Document document = messageMedia.document;
if (document == null) {
return null;
}
int size2 = document.thumbs.size();
while (i < size2) {
photoSize = (TLRPC.PhotoSize) message.media.document.thumbs.get(i);
if (!(photoSize instanceof TLRPC.TL_photoCachedSize)) {
i++;
}
}
return null;
}
if (messageMedia instanceof TLRPC.TL_messageMediaWebPage) {
TLRPC.Photo photo = messageMedia.webpage.photo;
if (photo == null) {
return null;
}
int size3 = photo.sizes.size();
while (i < size3) {
photoSize = message.media.webpage.photo.sizes.get(i);
if (!(photoSize instanceof TLRPC.TL_photoCachedSize)) {
i++;
}
}
return null;
}
if (!(messageMedia instanceof TLRPC.TL_messageMediaInvoice)) {
return null;
}
TLRPC.MessageExtendedMedia messageExtendedMedia = messageMedia.extended_media;
if (messageExtendedMedia instanceof TLRPC.TL_messageExtendedMediaPreview) {
return ((TLRPC.TL_messageExtendedMediaPreview) messageExtendedMedia).thumb;
}
return null;
return photoSize;
}
public static void saveMessagesThumbs(ArrayList<TLRPC.Message> messages) {
if (messages == null || messages.isEmpty()) {
return;
}
for (int i = 0; i < messages.size(); i++) {
saveMessageThumbs(messages.get(i));
}
}
public static MessageThumb generateMessageThumb(TLRPC.Message message) {
int i;
int i2;
Bitmap strippedPhotoBitmap;
byte[] bArr;
TLRPC.PhotoSize findPhotoCachedSize = findPhotoCachedSize(message);
if (findPhotoCachedSize != null && (bArr = findPhotoCachedSize.bytes) != null && bArr.length != 0) {
File pathToAttach = FileLoader.getInstance(UserConfig.selectedAccount).getPathToAttach(findPhotoCachedSize, true);
TLRPC.TL_photoSize_layer127 tL_photoSize_layer127 = new TLRPC.TL_photoSize_layer127();
tL_photoSize_layer127.w = findPhotoCachedSize.w;
tL_photoSize_layer127.h = findPhotoCachedSize.h;
tL_photoSize_layer127.location = findPhotoCachedSize.location;
tL_photoSize_layer127.size = findPhotoCachedSize.size;
tL_photoSize_layer127.type = findPhotoCachedSize.type;
if (pathToAttach.exists() && message.grouped_id == 0) {
org.telegram.ui.Components.Point messageSize = ChatMessageCell.getMessageSize(findPhotoCachedSize.w, findPhotoCachedSize.h);
String format = String.format(Locale.US, "%d_%d@%d_%d_b", Long.valueOf(findPhotoCachedSize.location.volume_id), Integer.valueOf(findPhotoCachedSize.location.local_id), Integer.valueOf((int) (messageSize.x / AndroidUtilities.density)), Integer.valueOf((int) (messageSize.y / AndroidUtilities.density)));
if (!getInstance().isInMemCache(format, false)) {
String path = pathToAttach.getPath();
float f = messageSize.x;
float f2 = AndroidUtilities.density;
Bitmap loadBitmap = loadBitmap(path, null, (int) (f / f2), (int) (messageSize.y / f2), false);
if (loadBitmap != null) {
Utilities.blurBitmap(loadBitmap, 3, 1, loadBitmap.getWidth(), loadBitmap.getHeight(), loadBitmap.getRowBytes());
float f3 = messageSize.x;
float f4 = AndroidUtilities.density;
Bitmap createScaledBitmap = Bitmaps.createScaledBitmap(loadBitmap, (int) (f3 / f4), (int) (messageSize.y / f4), true);
if (createScaledBitmap != loadBitmap) {
loadBitmap.recycle();
loadBitmap = createScaledBitmap;
}
return new MessageThumb(format, new BitmapDrawable(loadBitmap));
}
}
}
} else {
TLRPC.MessageMedia messageMedia = message.media;
if (messageMedia instanceof TLRPC.TL_messageMediaDocument) {
int size = messageMedia.document.thumbs.size();
for (int i3 = 0; i3 < size; i3++) {
TLRPC.PhotoSize photoSize = (TLRPC.PhotoSize) message.media.document.thumbs.get(i3);
if (photoSize instanceof TLRPC.TL_photoStrippedSize) {
TLRPC.PhotoSize closestPhotoSizeWithSize = FileLoader.getClosestPhotoSizeWithSize(message.media.document.thumbs, 320);
if (closestPhotoSizeWithSize == null) {
int i4 = 0;
while (true) {
if (i4 >= message.media.document.attributes.size()) {
i = 0;
i2 = 0;
break;
}
if (message.media.document.attributes.get(i4) instanceof TLRPC.TL_documentAttributeVideo) {
TLRPC.TL_documentAttributeVideo tL_documentAttributeVideo = (TLRPC.TL_documentAttributeVideo) message.media.document.attributes.get(i4);
i2 = tL_documentAttributeVideo.h;
i = tL_documentAttributeVideo.w;
break;
}
i4++;
}
} else {
i2 = closestPhotoSizeWithSize.h;
i = closestPhotoSizeWithSize.w;
}
org.telegram.ui.Components.Point messageSize2 = ChatMessageCell.getMessageSize(i, i2);
String format2 = String.format(Locale.US, "%s_false@%d_%d_b", ImageLocation.getStrippedKey(message, message, photoSize), Integer.valueOf((int) (messageSize2.x / AndroidUtilities.density)), Integer.valueOf((int) (messageSize2.y / AndroidUtilities.density)));
if (!getInstance().isInMemCache(format2, false) && (strippedPhotoBitmap = getStrippedPhotoBitmap(photoSize.bytes, null)) != null) {
Utilities.blurBitmap(strippedPhotoBitmap, 3, 1, strippedPhotoBitmap.getWidth(), strippedPhotoBitmap.getHeight(), strippedPhotoBitmap.getRowBytes());
float f5 = messageSize2.x;
float f6 = AndroidUtilities.density;
Bitmap createScaledBitmap2 = Bitmaps.createScaledBitmap(strippedPhotoBitmap, (int) (f5 / f6), (int) (messageSize2.y / f6), true);
if (createScaledBitmap2 != strippedPhotoBitmap) {
strippedPhotoBitmap.recycle();
strippedPhotoBitmap = createScaledBitmap2;
}
return new MessageThumb(format2, new BitmapDrawable(strippedPhotoBitmap));
}
}
}
}
}
return null;
}
public void onFragmentStackChanged() {
for (int i = 0; i < this.cachedAnimatedFileDrawables.size(); i++) {
this.cachedAnimatedFileDrawables.get(i).repeatCount = 0;
}
}
public DispatchQueuePriority getCacheOutQueue() {
return this.cacheOutQueue;
}
public static class MessageThumb {
public BitmapDrawable drawable;
public String key;
public MessageThumb(String key, BitmapDrawable bitmapDrawable) {
this.key = key;
this.drawable = bitmapDrawable;
}
}
}