package androidx.sharetarget;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.text.TextUtils;
import android.util.Log;
import androidx.annotation.AnyThread;
import androidx.annotation.RequiresApi;
import androidx.annotation.RestrictTo;
import androidx.annotation.WorkerThread;
import androidx.collection.ArrayMap;
import androidx.concurrent.futures.ResolvableFuture;
import androidx.core.content.pm.ShortcutInfoCompat;
import androidx.core.content.pm.ShortcutInfoCompatSaver;
import androidx.core.graphics.drawable.IconCompat;
import androidx.sharetarget.ShortcutsInfoSerialization;
import c.i.b.d.a.a;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@RequiresApi(19)
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
public class ShortcutInfoCompatSaverImpl extends ShortcutInfoCompatSaver<a<Void>> {
    private static final String DIRECTORY_BITMAPS = "ShortcutInfoCompatSaver_share_targets_bitmaps";
    private static final String DIRECTORY_TARGETS = "ShortcutInfoCompatSaver_share_targets";
    private static final int EXECUTOR_KEEP_ALIVE_TIME_SECS = 20;
    private static final String FILENAME_XML = "targets.xml";
    private static final Object GET_INSTANCE_LOCK = new Object();
    public static final String TAG = "ShortcutInfoCompatSaver";
    private static volatile ShortcutInfoCompatSaverImpl sInstance;
    public final File mBitmapsDir;
    public final ExecutorService mCacheUpdateService;
    public final Context mContext;
    private final ExecutorService mDiskIoService;
    public final Map<String, a<?>> mScheduledBitmapTasks = new ArrayMap();
    public final Map<String, ShortcutsInfoSerialization.ShortcutContainer> mShortcutsMap = new ArrayMap();
    public final File mTargetsXmlFile;

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$1  reason: invalid class name */
    public class AnonymousClass1 implements Runnable {
        public final /* synthetic */ File val$workingDirectory;

        public AnonymousClass1(File file) {
            this.val$workingDirectory = file;
        }

        @Override // java.lang.Runnable
        public void run() {
            try {
                ShortcutInfoCompatSaverImpl.ensureDir(this.val$workingDirectory);
                ShortcutInfoCompatSaverImpl.ensureDir(ShortcutInfoCompatSaverImpl.this.mBitmapsDir);
                ShortcutInfoCompatSaverImpl shortcutInfoCompatSaverImpl = ShortcutInfoCompatSaverImpl.this;
                shortcutInfoCompatSaverImpl.mShortcutsMap.putAll(ShortcutsInfoSerialization.loadFromXml(shortcutInfoCompatSaverImpl.mTargetsXmlFile, shortcutInfoCompatSaverImpl.mContext));
                ShortcutInfoCompatSaverImpl.this.deleteDanglingBitmaps(new ArrayList(ShortcutInfoCompatSaverImpl.this.mShortcutsMap.values()));
            } catch (Exception e) {
                Log.w("ShortcutInfoCompatSaver", "ShortcutInfoCompatSaver started with an exceptions ", e);
            }
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$10  reason: invalid class name */
    public class AnonymousClass10 implements Runnable {
        public final /* synthetic */ List val$containers;

        public AnonymousClass10(List list) {
            this.val$containers = list;
        }

        @Override // java.lang.Runnable
        public void run() {
            ShortcutInfoCompatSaverImpl.this.deleteDanglingBitmaps(this.val$containers);
            ShortcutsInfoSerialization.saveAsXml(this.val$containers, ShortcutInfoCompatSaverImpl.this.mTargetsXmlFile);
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$11  reason: invalid class name */
    public class AnonymousClass11 implements Runnable {
        public final /* synthetic */ a val$future;
        public final /* synthetic */ ResolvableFuture val$output;

        public AnonymousClass11(a aVar, ResolvableFuture resolvableFuture) {
            this.val$future = aVar;
            this.val$output = resolvableFuture;
        }

        @Override // java.lang.Runnable
        public void run() {
            try {
                this.val$future.get();
                this.val$output.set(null);
            } catch (Exception e) {
                this.val$output.setException(e);
            }
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$2  reason: invalid class name */
    public class AnonymousClass2 implements Runnable {
        public final /* synthetic */ List val$idList;
        public final /* synthetic */ ResolvableFuture val$result;

        public AnonymousClass2(List list, ResolvableFuture resolvableFuture) {
            this.val$idList = list;
            this.val$result = resolvableFuture;
        }

        @Override // java.lang.Runnable
        public void run() {
            for (String str : this.val$idList) {
                ShortcutInfoCompatSaverImpl.this.mShortcutsMap.remove(str);
                a<?> remove = ShortcutInfoCompatSaverImpl.this.mScheduledBitmapTasks.remove(str);
                if (remove != null) {
                    remove.cancel(false);
                }
            }
            ShortcutInfoCompatSaverImpl.this.scheduleSyncCurrentState(this.val$result);
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$3  reason: invalid class name */
    public class AnonymousClass3 implements Runnable {
        public final /* synthetic */ ResolvableFuture val$result;

        public AnonymousClass3(ResolvableFuture resolvableFuture) {
            this.val$result = resolvableFuture;
        }

        @Override // java.lang.Runnable
        public void run() {
            ShortcutInfoCompatSaverImpl.this.mShortcutsMap.clear();
            for (a<?> aVar : ShortcutInfoCompatSaverImpl.this.mScheduledBitmapTasks.values()) {
                aVar.cancel(false);
            }
            ShortcutInfoCompatSaverImpl.this.mScheduledBitmapTasks.clear();
            ShortcutInfoCompatSaverImpl.this.scheduleSyncCurrentState(this.val$result);
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$4  reason: invalid class name */
    public class AnonymousClass4 implements Callable<ArrayList<ShortcutInfoCompat>> {
        public AnonymousClass4() {
        }

        @Override // java.util.concurrent.Callable
        public ArrayList<ShortcutInfoCompat> call() {
            ArrayList<ShortcutInfoCompat> arrayList = new ArrayList<>();
            for (ShortcutsInfoSerialization.ShortcutContainer shortcutContainer : ShortcutInfoCompatSaverImpl.this.mShortcutsMap.values()) {
                arrayList.add(new ShortcutInfoCompat.Builder(shortcutContainer.mShortcutInfo).build());
            }
            return arrayList;
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$5  reason: invalid class name */
    public class AnonymousClass5 implements Callable<ShortcutsInfoSerialization.ShortcutContainer> {
        public final /* synthetic */ String val$shortcutId;

        public AnonymousClass5(String str) {
            this.val$shortcutId = str;
        }

        @Override // java.util.concurrent.Callable
        public ShortcutsInfoSerialization.ShortcutContainer call() {
            return ShortcutInfoCompatSaverImpl.this.mShortcutsMap.get(this.val$shortcutId);
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$6  reason: invalid class name */
    public class AnonymousClass6 implements Callable<Bitmap> {
        public final /* synthetic */ ShortcutsInfoSerialization.ShortcutContainer val$container;

        public AnonymousClass6(ShortcutsInfoSerialization.ShortcutContainer shortcutContainer) {
            this.val$container = shortcutContainer;
        }

        @Override // java.util.concurrent.Callable
        public Bitmap call() {
            return BitmapFactory.decodeFile(this.val$container.mBitmapPath);
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$7  reason: invalid class name */
    public class AnonymousClass7 implements Runnable {
        public final /* synthetic */ List val$copy;
        public final /* synthetic */ ResolvableFuture val$result;

        /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$7$1  reason: invalid class name */
        public class AnonymousClass1 implements Runnable {
            public final /* synthetic */ a val$future;
            public final /* synthetic */ String val$id;

            public AnonymousClass1(String str, a aVar) {
                this.val$id = str;
                this.val$future = aVar;
            }

            @Override // java.lang.Runnable
            public void run() {
                ShortcutInfoCompatSaverImpl.this.mScheduledBitmapTasks.remove(this.val$id);
                if (!this.val$future.isCancelled()) {
                    try {
                        this.val$future.get();
                    } catch (Exception e) {
                        AnonymousClass7.this.val$result.setException(e);
                    }
                }
            }
        }

        public AnonymousClass7(List list, ResolvableFuture resolvableFuture) {
            this.val$copy = list;
            this.val$result = resolvableFuture;
        }

        @Override // java.lang.Runnable
        public void run() {
            for (ShortcutInfoCompat shortcutInfoCompat : this.val$copy) {
                Set<String> categories = shortcutInfoCompat.getCategories();
                if (categories != null && !categories.isEmpty()) {
                    ShortcutsInfoSerialization.ShortcutContainer containerFrom = ShortcutInfoCompatSaverImpl.this.containerFrom(shortcutInfoCompat);
                    Bitmap bitmap = containerFrom.mBitmapPath != null ? shortcutInfoCompat.getIcon().getBitmap() : null;
                    String id2 = shortcutInfoCompat.getId();
                    ShortcutInfoCompatSaverImpl.this.mShortcutsMap.put(id2, containerFrom);
                    if (bitmap != null) {
                        a<Void> scheduleBitmapSaving = ShortcutInfoCompatSaverImpl.this.scheduleBitmapSaving(bitmap, containerFrom.mBitmapPath);
                        a<?> put = ShortcutInfoCompatSaverImpl.this.mScheduledBitmapTasks.put(id2, scheduleBitmapSaving);
                        if (put != null) {
                            put.cancel(false);
                        }
                        scheduleBitmapSaving.addListener(new AnonymousClass1(id2, scheduleBitmapSaving), ShortcutInfoCompatSaverImpl.this.mCacheUpdateService);
                    }
                }
            }
            ShortcutInfoCompatSaverImpl.this.scheduleSyncCurrentState(this.val$result);
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$8  reason: invalid class name */
    public class AnonymousClass8 implements Runnable {
        public final /* synthetic */ Bitmap val$bitmap;
        public final /* synthetic */ String val$path;

        public AnonymousClass8(Bitmap bitmap, String str) {
            this.val$bitmap = bitmap;
            this.val$path = str;
        }

        @Override // java.lang.Runnable
        public void run() {
            ShortcutInfoCompatSaverImpl.this.saveBitmap(this.val$bitmap, this.val$path);
        }
    }

    /* renamed from: androidx.sharetarget.ShortcutInfoCompatSaverImpl$9  reason: invalid class name */
    public class AnonymousClass9 implements Runnable {
        public final /* synthetic */ ResolvableFuture val$result;
        public final /* synthetic */ Runnable val$runnable;

        public AnonymousClass9(ResolvableFuture resolvableFuture, Runnable runnable) {
            this.val$result = resolvableFuture;
            this.val$runnable = runnable;
        }

        @Override // java.lang.Runnable
        public void run() {
            if (!this.val$result.isCancelled()) {
                try {
                    this.val$runnable.run();
                    this.val$result.set(null);
                } catch (Exception e) {
                    this.val$result.setException(e);
                }
            }
        }
    }

    @AnyThread
    public ShortcutInfoCompatSaverImpl(Context context, ExecutorService executorService, ExecutorService executorService2) {
        this.mContext = context.getApplicationContext();
        this.mCacheUpdateService = executorService;
        this.mDiskIoService = executorService2;
        File file = new File(context.getFilesDir(), "ShortcutInfoCompatSaver_share_targets");
        this.mBitmapsDir = new File(file, "ShortcutInfoCompatSaver_share_targets_bitmaps");
        this.mTargetsXmlFile = new File(file, "targets.xml");
        executorService.submit(new AnonymousClass1(file));
    }

    @AnyThread
    public static ExecutorService createExecutorService() {
        return new ThreadPoolExecutor(0, 1, 20, TimeUnit.SECONDS, new LinkedBlockingQueue());
    }

    public static boolean ensureDir(File file) {
        if (file.exists() && !file.isDirectory() && !file.delete()) {
            return false;
        }
        if (!file.exists()) {
            return file.mkdirs();
        }
        return true;
    }

    @AnyThread
    public static ShortcutInfoCompatSaverImpl getInstance(Context context) {
        if (sInstance == null) {
            synchronized (GET_INSTANCE_LOCK) {
                if (sInstance == null) {
                    sInstance = new ShortcutInfoCompatSaverImpl(context, createExecutorService(), createExecutorService());
                }
            }
        }
        return sInstance;
    }

    private a<Void> submitDiskOperation(Runnable runnable) {
        ResolvableFuture create = ResolvableFuture.create();
        this.mDiskIoService.submit(new AnonymousClass9(create, runnable));
        return create;
    }

    @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
    @AnyThread
    public a<Void> addShortcuts(List<ShortcutInfoCompat> list) {
        ArrayList arrayList = new ArrayList(list.size());
        for (ShortcutInfoCompat shortcutInfoCompat : list) {
            arrayList.add(new ShortcutInfoCompat.Builder(shortcutInfoCompat).build());
        }
        ResolvableFuture create = ResolvableFuture.create();
        this.mCacheUpdateService.submit(new AnonymousClass7(arrayList, create));
        return create;
    }

    /* JADX WARNING: Code restructure failed: missing block: B:7:0x0012, code lost:
        if (r2 != 5) goto L_0x003b;
     */
    public ShortcutsInfoSerialization.ShortcutContainer containerFrom(ShortcutInfoCompat shortcutInfoCompat) {
        String str;
        String str2;
        IconCompat icon = shortcutInfoCompat.getIcon();
        if (icon != null) {
            int type = icon.getType();
            if (type != 1) {
                if (type == 2) {
                    str2 = this.mContext.getResources().getResourceName(icon.getResId());
                    str = null;
                    return new ShortcutsInfoSerialization.ShortcutContainer(new ShortcutInfoCompat.Builder(shortcutInfoCompat).setIcon(null).build(), str2, str);
                }
            }
            str = new File(this.mBitmapsDir, UUID.randomUUID().toString()).getAbsolutePath();
            str2 = null;
            return new ShortcutsInfoSerialization.ShortcutContainer(new ShortcutInfoCompat.Builder(shortcutInfoCompat).setIcon(null).build(), str2, str);
        }
        str2 = null;
        str = null;
        return new ShortcutsInfoSerialization.ShortcutContainer(new ShortcutInfoCompat.Builder(shortcutInfoCompat).setIcon(null).build(), str2, str);
    }

    public void deleteDanglingBitmaps(List<ShortcutsInfoSerialization.ShortcutContainer> list) {
        ArrayList arrayList = new ArrayList();
        for (ShortcutsInfoSerialization.ShortcutContainer shortcutContainer : list) {
            if (!TextUtils.isEmpty(shortcutContainer.mBitmapPath)) {
                arrayList.add(shortcutContainer.mBitmapPath);
            }
        }
        File[] listFiles = this.mBitmapsDir.listFiles();
        for (File file : listFiles) {
            if (!arrayList.contains(file.getAbsolutePath())) {
                file.delete();
            }
        }
    }

    @WorkerThread
    public IconCompat getShortcutIcon(String str) throws Exception {
        Bitmap bitmap;
        ShortcutsInfoSerialization.ShortcutContainer shortcutContainer = (ShortcutsInfoSerialization.ShortcutContainer) this.mCacheUpdateService.submit(new AnonymousClass5(str)).get();
        if (shortcutContainer == null) {
            return null;
        }
        if (!TextUtils.isEmpty(shortcutContainer.mResourceName)) {
            int i = 0;
            try {
                i = this.mContext.getResources().getIdentifier(shortcutContainer.mResourceName, null, null);
            } catch (Exception unused) {
            }
            if (i != 0) {
                return IconCompat.createWithResource(this.mContext, i);
            }
        }
        if (TextUtils.isEmpty(shortcutContainer.mBitmapPath) || (bitmap = (Bitmap) this.mDiskIoService.submit(new AnonymousClass6(shortcutContainer)).get()) == null) {
            return null;
        }
        return IconCompat.createWithBitmap(bitmap);
    }

    @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
    @WorkerThread
    public List<ShortcutInfoCompat> getShortcuts() throws Exception {
        return (List) this.mCacheUpdateService.submit(new AnonymousClass4()).get();
    }

    @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
    @AnyThread
    public a<Void> removeAllShortcuts() {
        ResolvableFuture create = ResolvableFuture.create();
        this.mCacheUpdateService.submit(new AnonymousClass3(create));
        return create;
    }

    @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
    @AnyThread
    public a<Void> removeShortcuts(List<String> list) {
        ArrayList arrayList = new ArrayList(list);
        ResolvableFuture create = ResolvableFuture.create();
        this.mCacheUpdateService.submit(new AnonymousClass2(arrayList, create));
        return create;
    }

    @WorkerThread
    public void saveBitmap(Bitmap bitmap, String str) {
        if (bitmap == null) {
            throw new IllegalArgumentException("bitmap is null");
        } else if (!TextUtils.isEmpty(str)) {
            try {
                FileOutputStream fileOutputStream = new FileOutputStream(new File(str));
                try {
                    if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream)) {
                        fileOutputStream.close();
                        return;
                    }
                    Log.wtf("ShortcutInfoCompatSaver", "Unable to compress bitmap");
                    throw new RuntimeException("Unable to compress bitmap for saving " + str);
                } catch (Throwable th) {
                    th.addSuppressed(th);
                }
            } catch (IOException | OutOfMemoryError | RuntimeException e) {
                Log.wtf("ShortcutInfoCompatSaver", "Unable to write bitmap to file", e);
                throw new RuntimeException(c.d.b.a.a.t("Unable to write bitmap to file ", str), e);
            }
        } else {
            throw new IllegalArgumentException("path is empty");
        }
        throw th;
    }

    public a<Void> scheduleBitmapSaving(Bitmap bitmap, String str) {
        return submitDiskOperation(new AnonymousClass8(bitmap, str));
    }

    public void scheduleSyncCurrentState(ResolvableFuture<Void> resolvableFuture) {
        a<Void> submitDiskOperation = submitDiskOperation(new AnonymousClass10(new ArrayList(this.mShortcutsMap.values())));
        submitDiskOperation.addListener(new AnonymousClass11(submitDiskOperation, resolvableFuture), this.mCacheUpdateService);
    }
}