Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/browser/browseractions/BrowserActionItem.java

@@ -0,0 +1,79 @@
+package androidx.browser.browseractions;
+
+import android.app.PendingIntent;
+import android.net.Uri;
+import androidx.annotation.DrawableRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class BrowserActionItem {
+
+    @Nullable
+    private final PendingIntent mAction;
+
+    @DrawableRes
+    private int mIconId;
+
+    @Nullable
+    private Uri mIconUri;
+
+    @Nullable
+    private Runnable mRunnableAction;
+    private final String mTitle;
+
+    public int getIconId() {
+        return this.mIconId;
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public Uri getIconUri() {
+        return this.mIconUri;
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public Runnable getRunnableAction() {
+        return this.mRunnableAction;
+    }
+
+    @NonNull
+    public String getTitle() {
+        return this.mTitle;
+    }
+
+    public BrowserActionItem(@NonNull String str, @NonNull PendingIntent pendingIntent, @DrawableRes int i) {
+        this.mTitle = str;
+        this.mAction = pendingIntent;
+        this.mIconId = i;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public BrowserActionItem(@NonNull String str, @NonNull PendingIntent pendingIntent, @NonNull Uri uri) {
+        this.mTitle = str;
+        this.mAction = pendingIntent;
+        this.mIconUri = uri;
+    }
+
+    public BrowserActionItem(@NonNull String str, @NonNull Runnable runnable) {
+        this.mTitle = str;
+        this.mAction = null;
+        this.mRunnableAction = runnable;
+    }
+
+    public BrowserActionItem(@NonNull String str, @NonNull PendingIntent pendingIntent) {
+        this(str, pendingIntent, 0);
+    }
+
+    @NonNull
+    public PendingIntent getAction() {
+        PendingIntent pendingIntent = this.mAction;
+        if (pendingIntent != null) {
+            return pendingIntent;
+        }
+        throw new IllegalStateException("Can't call getAction on BrowserActionItem with null action.");
+    }
+}

decompiled/sources/androidx/browser/browseractions/BrowserActionsFallbackMenuAdapter.java

@@ -0,0 +1,109 @@
+package androidx.browser.browseractions;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.text.TextUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+import androidx.annotation.NonNull;
+import androidx.browser.R;
+import androidx.core.content.res.ResourcesCompat;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+
+@Deprecated
+/* loaded from: classes.dex */
+class BrowserActionsFallbackMenuAdapter extends BaseAdapter {
+    private final Context mContext;
+    private final List<BrowserActionItem> mMenuItems;
+
+    @Override // android.widget.Adapter
+    public long getItemId(int i) {
+        return i;
+    }
+
+    public BrowserActionsFallbackMenuAdapter(List<BrowserActionItem> list, Context context) {
+        this.mMenuItems = list;
+        this.mContext = context;
+    }
+
+    @Override // android.widget.Adapter
+    public int getCount() {
+        return this.mMenuItems.size();
+    }
+
+    @Override // android.widget.Adapter
+    public Object getItem(int i) {
+        return this.mMenuItems.get(i);
+    }
+
+    @Override // android.widget.Adapter
+    public View getView(int i, View view, ViewGroup viewGroup) {
+        final ViewHolderItem viewHolderItem;
+        BrowserActionItem browserActionItem = this.mMenuItems.get(i);
+        if (view == null) {
+            view = LayoutInflater.from(this.mContext).inflate(R.layout.browser_actions_context_menu_row, (ViewGroup) null);
+            ImageView imageView = (ImageView) view.findViewById(R.id.browser_actions_menu_item_icon);
+            TextView textView = (TextView) view.findViewById(R.id.browser_actions_menu_item_text);
+            if (imageView == null || textView == null) {
+                throw new IllegalStateException("Browser Actions fallback UI does not contain necessary Views.");
+            }
+            viewHolderItem = new ViewHolderItem(imageView, textView);
+            view.setTag(viewHolderItem);
+        } else {
+            viewHolderItem = (ViewHolderItem) view.getTag();
+        }
+        final String title = browserActionItem.getTitle();
+        viewHolderItem.mText.setText(title);
+        if (browserActionItem.getIconId() != 0) {
+            viewHolderItem.mIcon.setImageDrawable(ResourcesCompat.getDrawable(this.mContext.getResources(), browserActionItem.getIconId(), null));
+        } else if (browserActionItem.getIconUri() != null) {
+            final ListenableFuture loadBitmap = BrowserServiceFileProvider.loadBitmap(this.mContext.getContentResolver(), browserActionItem.getIconUri());
+            loadBitmap.addListener(new Runnable() { // from class: androidx.browser.browseractions.BrowserActionsFallbackMenuAdapter.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    Bitmap bitmap;
+                    if (TextUtils.equals(title, viewHolderItem.mText.getText())) {
+                        try {
+                            bitmap = (Bitmap) loadBitmap.get();
+                        } catch (InterruptedException | ExecutionException unused) {
+                            bitmap = null;
+                        }
+                        if (bitmap != null) {
+                            viewHolderItem.mIcon.setVisibility(0);
+                            viewHolderItem.mIcon.setImageBitmap(bitmap);
+                        } else {
+                            viewHolderItem.mIcon.setVisibility(4);
+                            viewHolderItem.mIcon.setImageBitmap(null);
+                        }
+                    }
+                }
+            }, new Executor() { // from class: androidx.browser.browseractions.BrowserActionsFallbackMenuAdapter.2
+                @Override // java.util.concurrent.Executor
+                public void execute(@NonNull Runnable runnable) {
+                    runnable.run();
+                }
+            });
+        } else {
+            viewHolderItem.mIcon.setImageBitmap(null);
+            viewHolderItem.mIcon.setVisibility(4);
+        }
+        return view;
+    }
+
+    public static class ViewHolderItem {
+        final ImageView mIcon;
+        final TextView mText;
+
+        public ViewHolderItem(ImageView imageView, TextView textView) {
+            this.mIcon = imageView;
+            this.mText = textView;
+        }
+    }
+}

decompiled/sources/androidx/browser/browseractions/BrowserActionsFallbackMenuDialog.java

@@ -0,0 +1,61 @@
+package androidx.browser.browseractions;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.app.Dialog;
+import android.content.Context;
+import android.graphics.drawable.ColorDrawable;
+import android.view.MotionEvent;
+import android.view.View;
+import androidx.interpolator.view.animation.LinearOutSlowInInterpolator;
+
+@Deprecated
+/* loaded from: classes.dex */
+class BrowserActionsFallbackMenuDialog extends Dialog {
+    private static final long ENTER_ANIMATION_DURATION_MS = 250;
+    private static final long EXIT_ANIMATION_DURATION_MS = 150;
+    private final View mContentView;
+
+    public BrowserActionsFallbackMenuDialog(Context context, View view) {
+        super(context);
+        this.mContentView = view;
+    }
+
+    @Override // android.app.Dialog
+    public void show() {
+        getWindow().setBackgroundDrawable(new ColorDrawable(0));
+        startAnimation(true);
+        super.show();
+    }
+
+    @Override // android.app.Dialog
+    public boolean onTouchEvent(MotionEvent motionEvent) {
+        if (motionEvent.getAction() != 0) {
+            return false;
+        }
+        dismiss();
+        return true;
+    }
+
+    @Override // android.app.Dialog, android.content.DialogInterface
+    public void dismiss() {
+        startAnimation(false);
+    }
+
+    private void startAnimation(final boolean z) {
+        float f = z ? 0.0f : 1.0f;
+        float f2 = z ? 1.0f : 0.0f;
+        long j = z ? ENTER_ANIMATION_DURATION_MS : EXIT_ANIMATION_DURATION_MS;
+        this.mContentView.setScaleX(f);
+        this.mContentView.setScaleY(f);
+        this.mContentView.animate().scaleX(f2).scaleY(f2).setDuration(j).setInterpolator(new LinearOutSlowInInterpolator()).setListener(new AnimatorListenerAdapter() { // from class: androidx.browser.browseractions.BrowserActionsFallbackMenuDialog.1
+            @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+            public void onAnimationEnd(Animator animator) {
+                if (z) {
+                    return;
+                }
+                BrowserActionsFallbackMenuDialog.super.dismiss();
+            }
+        }).start();
+    }
+}

decompiled/sources/androidx/browser/browseractions/BrowserActionsFallbackMenuUi.java

@@ -0,0 +1,155 @@
+package androidx.browser.browseractions;
+
+import android.app.PendingIntent;
+import android.content.ClipData;
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.browser.R;
+import androidx.core.view.accessibility.AccessibilityEventCompat;
+import androidx.core.widget.TextViewCompat;
+import java.util.ArrayList;
+import java.util.List;
+
+@Deprecated
+/* loaded from: classes.dex */
+class BrowserActionsFallbackMenuUi implements AdapterView.OnItemClickListener {
+    private static final String TAG = "BrowserActionskMenuUi";
+
+    @Nullable
+    private BrowserActionsFallbackMenuDialog mBrowserActionsDialog;
+    final Context mContext;
+    private final List<BrowserActionItem> mMenuItems;
+
+    @Nullable
+    BrowserActionsFallMenuUiListener mMenuUiListener;
+    final Uri mUri;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @VisibleForTesting
+    public interface BrowserActionsFallMenuUiListener {
+        void onMenuShown(View view);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @VisibleForTesting
+    public void setMenuUiListener(@Nullable BrowserActionsFallMenuUiListener browserActionsFallMenuUiListener) {
+        this.mMenuUiListener = browserActionsFallMenuUiListener;
+    }
+
+    public BrowserActionsFallbackMenuUi(@NonNull Context context, @NonNull Uri uri, @NonNull List<BrowserActionItem> list) {
+        this.mContext = context;
+        this.mUri = uri;
+        this.mMenuItems = buildFallbackMenuItemList(list);
+    }
+
+    @NonNull
+    private List<BrowserActionItem> buildFallbackMenuItemList(List<BrowserActionItem> list) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(new BrowserActionItem(this.mContext.getString(R.string.fallback_menu_item_open_in_browser), buildOpenInBrowserAction()));
+        arrayList.add(new BrowserActionItem(this.mContext.getString(R.string.fallback_menu_item_copy_link), buildCopyAction()));
+        arrayList.add(new BrowserActionItem(this.mContext.getString(R.string.fallback_menu_item_share_link), buildShareAction()));
+        arrayList.addAll(list);
+        return arrayList;
+    }
+
+    private PendingIntent buildOpenInBrowserAction() {
+        return PendingIntent.getActivity(this.mContext, 0, new Intent("android.intent.action.VIEW", this.mUri), AccessibilityEventCompat.TYPE_VIEW_TARGETED_BY_SCROLL);
+    }
+
+    private PendingIntent buildShareAction() {
+        Intent intent = new Intent("android.intent.action.SEND");
+        intent.putExtra("android.intent.extra.TEXT", this.mUri.toString());
+        intent.setType("text/plain");
+        return PendingIntent.getActivity(this.mContext, 0, intent, AccessibilityEventCompat.TYPE_VIEW_TARGETED_BY_SCROLL);
+    }
+
+    private Runnable buildCopyAction() {
+        return new Runnable() { // from class: androidx.browser.browseractions.BrowserActionsFallbackMenuUi.1
+            @Override // java.lang.Runnable
+            public void run() {
+                ((ClipboardManager) BrowserActionsFallbackMenuUi.this.mContext.getSystemService("clipboard")).setPrimaryClip(ClipData.newPlainText("url", BrowserActionsFallbackMenuUi.this.mUri.toString()));
+                Toast.makeText(BrowserActionsFallbackMenuUi.this.mContext, BrowserActionsFallbackMenuUi.this.mContext.getString(R.string.copy_toast_msg), 0).show();
+            }
+        };
+    }
+
+    public void displayMenu() {
+        final View inflate = LayoutInflater.from(this.mContext).inflate(R.layout.browser_actions_context_menu_page, (ViewGroup) null);
+        BrowserActionsFallbackMenuDialog browserActionsFallbackMenuDialog = new BrowserActionsFallbackMenuDialog(this.mContext, initMenuView(inflate));
+        this.mBrowserActionsDialog = browserActionsFallbackMenuDialog;
+        browserActionsFallbackMenuDialog.setContentView(inflate);
+        if (this.mMenuUiListener != null) {
+            this.mBrowserActionsDialog.setOnShowListener(new DialogInterface.OnShowListener() { // from class: androidx.browser.browseractions.BrowserActionsFallbackMenuUi.2
+                @Override // android.content.DialogInterface.OnShowListener
+                public void onShow(DialogInterface dialogInterface) {
+                    BrowserActionsFallMenuUiListener browserActionsFallMenuUiListener = BrowserActionsFallbackMenuUi.this.mMenuUiListener;
+                    if (browserActionsFallMenuUiListener == null) {
+                        Log.e(BrowserActionsFallbackMenuUi.TAG, "Cannot trigger menu item listener, it is null");
+                    } else {
+                        browserActionsFallMenuUiListener.onMenuShown(inflate);
+                    }
+                }
+            });
+        }
+        this.mBrowserActionsDialog.show();
+    }
+
+    private BrowserActionsFallbackMenuView initMenuView(View view) {
+        BrowserActionsFallbackMenuView browserActionsFallbackMenuView = (BrowserActionsFallbackMenuView) view.findViewById(R.id.browser_actions_menu_view);
+        final TextView textView = (TextView) view.findViewById(R.id.browser_actions_header_text);
+        textView.setText(this.mUri.toString());
+        textView.setOnClickListener(new View.OnClickListener() { // from class: androidx.browser.browseractions.BrowserActionsFallbackMenuUi.3
+            @Override // android.view.View.OnClickListener
+            public void onClick(View view2) {
+                if (TextViewCompat.getMaxLines(textView) == Integer.MAX_VALUE) {
+                    textView.setMaxLines(1);
+                    textView.setEllipsize(TextUtils.TruncateAt.END);
+                } else {
+                    textView.setMaxLines(Integer.MAX_VALUE);
+                    textView.setEllipsize(null);
+                }
+            }
+        });
+        ListView listView = (ListView) view.findViewById(R.id.browser_actions_menu_items);
+        listView.setAdapter((ListAdapter) new BrowserActionsFallbackMenuAdapter(this.mMenuItems, this.mContext));
+        listView.setOnItemClickListener(this);
+        return browserActionsFallbackMenuView;
+    }
+
+    @Override // android.widget.AdapterView.OnItemClickListener
+    public void onItemClick(AdapterView<?> adapterView, View view, int i, long j) {
+        BrowserActionItem browserActionItem = this.mMenuItems.get(i);
+        if (browserActionItem.getAction() != null) {
+            try {
+                browserActionItem.getAction().send();
+            } catch (PendingIntent.CanceledException e) {
+                Log.e(TAG, "Failed to send custom item action", e);
+            }
+        } else if (browserActionItem.getRunnableAction() != null) {
+            browserActionItem.getRunnableAction().run();
+        }
+        BrowserActionsFallbackMenuDialog browserActionsFallbackMenuDialog = this.mBrowserActionsDialog;
+        if (browserActionsFallbackMenuDialog == null) {
+            Log.e(TAG, "Cannot dismiss dialog, it has already been dismissed.");
+        } else {
+            browserActionsFallbackMenuDialog.dismiss();
+        }
+    }
+}

decompiled/sources/androidx/browser/browseractions/BrowserActionsFallbackMenuView.java

@@ -0,0 +1,28 @@
+package androidx.browser.browseractions;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.LinearLayout;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.browser.R;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+@Deprecated
+/* loaded from: classes.dex */
+public class BrowserActionsFallbackMenuView extends LinearLayout {
+    private final int mBrowserActionsMenuMaxWidthPx;
+    private final int mBrowserActionsMenuMinPaddingPx;
+
+    public BrowserActionsFallbackMenuView(@NonNull Context context, @NonNull AttributeSet attributeSet) {
+        super(context, attributeSet);
+        this.mBrowserActionsMenuMinPaddingPx = getResources().getDimensionPixelOffset(R.dimen.browser_actions_context_menu_min_padding);
+        this.mBrowserActionsMenuMaxWidthPx = getResources().getDimensionPixelOffset(R.dimen.browser_actions_context_menu_max_width);
+    }
+
+    @Override // android.widget.LinearLayout, android.view.View
+    public void onMeasure(int i, int i2) {
+        super.onMeasure(View.MeasureSpec.makeMeasureSpec(Math.min(getResources().getDisplayMetrics().widthPixels - (this.mBrowserActionsMenuMinPaddingPx * 2), this.mBrowserActionsMenuMaxWidthPx), 1073741824), i2);
+    }
+}

decompiled/sources/androidx/browser/browseractions/BrowserActionsIntent.java

@@ -0,0 +1,268 @@
+package androidx.browser.browseractions;
+
+import android.annotation.SuppressLint;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ResolveInfo;
+import android.net.Uri;
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.core.content.ContextCompat;
+import androidx.core.view.accessibility.AccessibilityEventCompat;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class BrowserActionsIntent {
+    public static final String ACTION_BROWSER_ACTIONS_OPEN = "androidx.browser.browseractions.browser_action_open";
+    public static final String EXTRA_APP_ID = "androidx.browser.browseractions.APP_ID";
+    public static final String EXTRA_MENU_ITEMS = "androidx.browser.browseractions.extra.MENU_ITEMS";
+    public static final String EXTRA_SELECTED_ACTION_PENDING_INTENT = "androidx.browser.browseractions.extra.SELECTED_ACTION_PENDING_INTENT";
+    public static final String EXTRA_TYPE = "androidx.browser.browseractions.extra.TYPE";
+    public static final int ITEM_COPY = 3;
+    public static final int ITEM_DOWNLOAD = 2;
+    public static final int ITEM_INVALID_ITEM = -1;
+    public static final int ITEM_OPEN_IN_INCOGNITO = 1;
+    public static final int ITEM_OPEN_IN_NEW_TAB = 0;
+    public static final int ITEM_SHARE = 4;
+    public static final String KEY_ACTION = "androidx.browser.browseractions.ACTION";
+    public static final String KEY_ICON_ID = "androidx.browser.browseractions.ICON_ID";
+    private static final String KEY_ICON_URI = "androidx.browser.browseractions.ICON_URI";
+    public static final String KEY_TITLE = "androidx.browser.browseractions.TITLE";
+
+    @SuppressLint({"MinMaxConstant"})
+    public static final int MAX_CUSTOM_ITEMS = 5;
+    private static final String TAG = "BrowserActions";
+    private static final String TEST_URL = "https://www.example.com";
+    public static final int URL_TYPE_AUDIO = 3;
+    public static final int URL_TYPE_FILE = 4;
+    public static final int URL_TYPE_IMAGE = 1;
+    public static final int URL_TYPE_NONE = 0;
+    public static final int URL_TYPE_PLUGIN = 5;
+    public static final int URL_TYPE_VIDEO = 2;
+
+    @Nullable
+    private static BrowserActionsFallDialogListener sDialogListenter;
+
+    @NonNull
+    private final Intent mIntent;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @VisibleForTesting
+    public interface BrowserActionsFallDialogListener {
+        void onDialogShown();
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface BrowserActionsItemId {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface BrowserActionsUrlType {
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @VisibleForTesting
+    public static void setDialogShownListenter(BrowserActionsFallDialogListener browserActionsFallDialogListener) {
+        sDialogListenter = browserActionsFallDialogListener;
+    }
+
+    @NonNull
+    public Intent getIntent() {
+        return this.mIntent;
+    }
+
+    public BrowserActionsIntent(@NonNull Intent intent) {
+        this.mIntent = intent;
+    }
+
+    public static final class Builder {
+        private Context mContext;
+        private Uri mUri;
+        private final Intent mIntent = new Intent(BrowserActionsIntent.ACTION_BROWSER_ACTIONS_OPEN);
+        private int mType = 0;
+        private ArrayList<Bundle> mMenuItems = new ArrayList<>();
+
+        @Nullable
+        private PendingIntent mOnItemSelectedPendingIntent = null;
+        private List<Uri> mImageUris = new ArrayList();
+
+        @NonNull
+        public Builder setOnItemSelectedAction(@NonNull PendingIntent pendingIntent) {
+            this.mOnItemSelectedPendingIntent = pendingIntent;
+            return this;
+        }
+
+        @NonNull
+        public Builder setUrlType(int i) {
+            this.mType = i;
+            return this;
+        }
+
+        public Builder(@NonNull Context context, @NonNull Uri uri) {
+            this.mContext = context;
+            this.mUri = uri;
+        }
+
+        @NonNull
+        public Builder setCustomItems(@NonNull ArrayList<BrowserActionItem> arrayList) {
+            if (arrayList.size() > 5) {
+                throw new IllegalStateException("Exceeded maximum toolbar item count of 5");
+            }
+            for (int i = 0; i < arrayList.size(); i++) {
+                if (TextUtils.isEmpty(arrayList.get(i).getTitle()) || arrayList.get(i).getAction() == null) {
+                    throw new IllegalArgumentException("Custom item should contain a non-empty title and non-null intent.");
+                }
+                this.mMenuItems.add(getBundleFromItem(arrayList.get(i)));
+                if (arrayList.get(i).getIconUri() != null) {
+                    this.mImageUris.add(arrayList.get(i).getIconUri());
+                }
+            }
+            return this;
+        }
+
+        @NonNull
+        public Builder setCustomItems(@NonNull BrowserActionItem... browserActionItemArr) {
+            return setCustomItems(new ArrayList<>(Arrays.asList(browserActionItemArr)));
+        }
+
+        @NonNull
+        private Bundle getBundleFromItem(@NonNull BrowserActionItem browserActionItem) {
+            Bundle bundle = new Bundle();
+            bundle.putString(BrowserActionsIntent.KEY_TITLE, browserActionItem.getTitle());
+            bundle.putParcelable(BrowserActionsIntent.KEY_ACTION, browserActionItem.getAction());
+            if (browserActionItem.getIconId() != 0) {
+                bundle.putInt(BrowserActionsIntent.KEY_ICON_ID, browserActionItem.getIconId());
+            }
+            if (browserActionItem.getIconUri() != null) {
+                bundle.putParcelable(BrowserActionsIntent.KEY_ICON_URI, browserActionItem.getIconUri());
+            }
+            return bundle;
+        }
+
+        @NonNull
+        public BrowserActionsIntent build() {
+            this.mIntent.setData(this.mUri);
+            this.mIntent.putExtra(BrowserActionsIntent.EXTRA_TYPE, this.mType);
+            this.mIntent.putParcelableArrayListExtra(BrowserActionsIntent.EXTRA_MENU_ITEMS, this.mMenuItems);
+            this.mIntent.putExtra(BrowserActionsIntent.EXTRA_APP_ID, PendingIntent.getActivity(this.mContext, 0, new Intent(), AccessibilityEventCompat.TYPE_VIEW_TARGETED_BY_SCROLL));
+            PendingIntent pendingIntent = this.mOnItemSelectedPendingIntent;
+            if (pendingIntent != null) {
+                this.mIntent.putExtra(BrowserActionsIntent.EXTRA_SELECTED_ACTION_PENDING_INTENT, pendingIntent);
+            }
+            BrowserServiceFileProvider.grantReadPermission(this.mIntent, this.mImageUris, this.mContext);
+            return new BrowserActionsIntent(this.mIntent);
+        }
+    }
+
+    public static void openBrowserAction(@NonNull Context context, @NonNull Uri uri) {
+        launchIntent(context, new Builder(context, uri).build().getIntent());
+    }
+
+    public static void openBrowserAction(@NonNull Context context, @NonNull Uri uri, int i, @NonNull ArrayList<BrowserActionItem> arrayList, @NonNull PendingIntent pendingIntent) {
+        launchIntent(context, new Builder(context, uri).setUrlType(i).setCustomItems(arrayList).setOnItemSelectedAction(pendingIntent).build().getIntent());
+    }
+
+    public static void launchIntent(@NonNull Context context, @NonNull Intent intent) {
+        launchIntent(context, intent, getBrowserActionsIntentHandlers(context));
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @VisibleForTesting
+    public static void launchIntent(Context context, Intent intent, List<ResolveInfo> list) {
+        if (list == null || list.size() == 0) {
+            openFallbackBrowserActionsMenu(context, intent);
+            return;
+        }
+        int i = 0;
+        if (list.size() == 1) {
+            intent.setPackage(list.get(0).activityInfo.packageName);
+        } else {
+            ResolveInfo resolveActivity = context.getPackageManager().resolveActivity(new Intent("android.intent.action.VIEW", Uri.parse(TEST_URL)), 65536);
+            if (resolveActivity != null) {
+                String str = resolveActivity.activityInfo.packageName;
+                while (true) {
+                    if (i >= list.size()) {
+                        break;
+                    }
+                    if (str.equals(list.get(i).activityInfo.packageName)) {
+                        intent.setPackage(str);
+                        break;
+                    }
+                    i++;
+                }
+            }
+        }
+        ContextCompat.startActivity(context, intent, null);
+    }
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static List<ResolveInfo> getBrowserActionsIntentHandlers(@NonNull Context context) {
+        return context.getPackageManager().queryIntentActivities(new Intent(ACTION_BROWSER_ACTIONS_OPEN, Uri.parse(TEST_URL)), 131072);
+    }
+
+    private static void openFallbackBrowserActionsMenu(Context context, Intent intent) {
+        Uri data = intent.getData();
+        ArrayList parcelableArrayListExtra = intent.getParcelableArrayListExtra(EXTRA_MENU_ITEMS);
+        openFallbackBrowserActionsMenu(context, data, parcelableArrayListExtra != null ? parseBrowserActionItems(parcelableArrayListExtra) : null);
+    }
+
+    private static void openFallbackBrowserActionsMenu(Context context, Uri uri, List<BrowserActionItem> list) {
+        new BrowserActionsFallbackMenuUi(context, uri, list).displayMenu();
+        BrowserActionsFallDialogListener browserActionsFallDialogListener = sDialogListenter;
+        if (browserActionsFallDialogListener != null) {
+            browserActionsFallDialogListener.onDialogShown();
+        }
+    }
+
+    @NonNull
+    public static List<BrowserActionItem> parseBrowserActionItems(@NonNull ArrayList<Bundle> arrayList) {
+        BrowserActionItem browserActionItem;
+        ArrayList arrayList2 = new ArrayList();
+        for (int i = 0; i < arrayList.size(); i++) {
+            Bundle bundle = arrayList.get(i);
+            String string = bundle.getString(KEY_TITLE);
+            PendingIntent pendingIntent = (PendingIntent) bundle.getParcelable(KEY_ACTION);
+            int i2 = bundle.getInt(KEY_ICON_ID);
+            Uri uri = (Uri) bundle.getParcelable(KEY_ICON_URI);
+            if (!TextUtils.isEmpty(string) && pendingIntent != null) {
+                if (i2 != 0) {
+                    browserActionItem = new BrowserActionItem(string, pendingIntent, i2);
+                } else {
+                    browserActionItem = new BrowserActionItem(string, pendingIntent, uri);
+                }
+                arrayList2.add(browserActionItem);
+            } else {
+                throw new IllegalArgumentException("Custom item should contain a non-empty title and non-null intent.");
+            }
+        }
+        return arrayList2;
+    }
+
+    @Nullable
+    public static String getUntrustedCreatorPackageName(@NonNull Intent intent) {
+        PendingIntent pendingIntent = (PendingIntent) intent.getParcelableExtra(EXTRA_APP_ID);
+        if (pendingIntent != null) {
+            return pendingIntent.getTargetPackage();
+        }
+        return null;
+    }
+
+    @Nullable
+    @Deprecated
+    public static String getCreatorPackageName(@NonNull Intent intent) {
+        return getUntrustedCreatorPackageName(intent);
+    }
+}

decompiled/sources/androidx/browser/browseractions/BrowserServiceFileProvider.java

@@ -0,0 +1,228 @@
+package androidx.browser.browseractions;
+
+import android.content.ClipData;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.UiThread;
+import androidx.concurrent.futures.ResolvableFuture;
+import androidx.core.content.FileProvider;
+import androidx.core.util.AtomicFile;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+@Deprecated
+/* loaded from: classes.dex */
+public final class BrowserServiceFileProvider extends FileProvider {
+    private static final String AUTHORITY_SUFFIX = ".image_provider";
+    private static final String CLIP_DATA_LABEL = "image_provider_uris";
+    private static final String CONTENT_SCHEME = "content";
+    private static final String FILE_EXTENSION = ".png";
+    private static final String FILE_SUB_DIR = "image_provider";
+    private static final String FILE_SUB_DIR_NAME = "image_provider_images/";
+    private static final String LAST_CLEANUP_TIME_KEY = "last_cleanup_time";
+    private static final String TAG = "BrowserServiceFP";
+    static Object sFileCleanupLock = new Object();
+
+    public static class FileCleanupTask extends AsyncTask<Void, Void, Void> {
+        private static final long CLEANUP_REQUIRED_TIME_SPAN;
+        private static final long DELETION_FAILED_REATTEMPT_DURATION;
+        private static final long IMAGE_RETENTION_DURATION;
+        private final Context mAppContext;
+
+        static {
+            TimeUnit timeUnit = TimeUnit.DAYS;
+            IMAGE_RETENTION_DURATION = timeUnit.toMillis(7L);
+            CLEANUP_REQUIRED_TIME_SPAN = timeUnit.toMillis(7L);
+            DELETION_FAILED_REATTEMPT_DURATION = timeUnit.toMillis(1L);
+        }
+
+        public FileCleanupTask(Context context) {
+            this.mAppContext = context.getApplicationContext();
+        }
+
+        @Override // android.os.AsyncTask
+        public Void doInBackground(Void... voidArr) {
+            long currentTimeMillis;
+            SharedPreferences sharedPreferences = this.mAppContext.getSharedPreferences(this.mAppContext.getPackageName() + BrowserServiceFileProvider.AUTHORITY_SUFFIX, 0);
+            if (!shouldCleanUp(sharedPreferences)) {
+                return null;
+            }
+            synchronized (BrowserServiceFileProvider.sFileCleanupLock) {
+                try {
+                    File file = new File(this.mAppContext.getFilesDir(), BrowserServiceFileProvider.FILE_SUB_DIR);
+                    if (!file.exists()) {
+                        return null;
+                    }
+                    File[] listFiles = file.listFiles();
+                    long currentTimeMillis2 = System.currentTimeMillis() - IMAGE_RETENTION_DURATION;
+                    boolean z = true;
+                    for (File file2 : listFiles) {
+                        if (isImageFile(file2) && file2.lastModified() < currentTimeMillis2 && !file2.delete()) {
+                            Log.e(BrowserServiceFileProvider.TAG, "Fail to delete image: " + file2.getAbsoluteFile());
+                            z = false;
+                        }
+                    }
+                    if (z) {
+                        currentTimeMillis = System.currentTimeMillis();
+                    } else {
+                        currentTimeMillis = (System.currentTimeMillis() - CLEANUP_REQUIRED_TIME_SPAN) + DELETION_FAILED_REATTEMPT_DURATION;
+                    }
+                    SharedPreferences.Editor edit = sharedPreferences.edit();
+                    edit.putLong(BrowserServiceFileProvider.LAST_CLEANUP_TIME_KEY, currentTimeMillis);
+                    edit.apply();
+                    return null;
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        private static boolean isImageFile(File file) {
+            return file.getName().endsWith("..png");
+        }
+
+        private static boolean shouldCleanUp(SharedPreferences sharedPreferences) {
+            return System.currentTimeMillis() > sharedPreferences.getLong(BrowserServiceFileProvider.LAST_CLEANUP_TIME_KEY, System.currentTimeMillis()) + CLEANUP_REQUIRED_TIME_SPAN;
+        }
+    }
+
+    public static class FileSaveTask extends AsyncTask<String, Void, Void> {
+        private final Context mAppContext;
+        private final Bitmap mBitmap;
+        private final Uri mFileUri;
+        private final String mFilename;
+        private final ResolvableFuture<Uri> mResultFuture;
+
+        public FileSaveTask(Context context, String str, Bitmap bitmap, Uri uri, ResolvableFuture<Uri> resolvableFuture) {
+            this.mAppContext = context.getApplicationContext();
+            this.mFilename = str;
+            this.mBitmap = bitmap;
+            this.mFileUri = uri;
+            this.mResultFuture = resolvableFuture;
+        }
+
+        @Override // android.os.AsyncTask
+        public Void doInBackground(String... strArr) {
+            saveFileIfNeededBlocking();
+            return null;
+        }
+
+        @Override // android.os.AsyncTask
+        public void onPostExecute(Void r3) {
+            new FileCleanupTask(this.mAppContext).executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, new Void[0]);
+        }
+
+        private void saveFileIfNeededBlocking() {
+            File file = new File(this.mAppContext.getFilesDir(), BrowserServiceFileProvider.FILE_SUB_DIR);
+            synchronized (BrowserServiceFileProvider.sFileCleanupLock) {
+                try {
+                    if (!file.exists() && !file.mkdir()) {
+                        this.mResultFuture.setException(new IOException("Could not create file directory."));
+                        return;
+                    }
+                    File file2 = new File(file, this.mFilename + BrowserServiceFileProvider.FILE_EXTENSION);
+                    if (file2.exists()) {
+                        this.mResultFuture.set(this.mFileUri);
+                    } else {
+                        saveFileBlocking(file2);
+                    }
+                    file2.setLastModified(System.currentTimeMillis());
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        private void saveFileBlocking(File file) {
+            FileOutputStream fileOutputStream;
+            AtomicFile atomicFile = new AtomicFile(file);
+            try {
+                fileOutputStream = atomicFile.startWrite();
+            } catch (IOException e) {
+                e = e;
+                fileOutputStream = null;
+            }
+            try {
+                this.mBitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
+                fileOutputStream.close();
+                atomicFile.finishWrite(fileOutputStream);
+                this.mResultFuture.set(this.mFileUri);
+            } catch (IOException e2) {
+                e = e2;
+                atomicFile.failWrite(fileOutputStream);
+                this.mResultFuture.setException(e);
+            }
+        }
+    }
+
+    @NonNull
+    @UiThread
+    public static ResolvableFuture<Uri> saveBitmap(@NonNull Context context, @NonNull Bitmap bitmap, @NonNull String str, int i) {
+        String str2 = str + "_" + Integer.toString(i);
+        Uri generateUri = generateUri(context, str2);
+        ResolvableFuture<Uri> create = ResolvableFuture.create();
+        new FileSaveTask(context, str2, bitmap, generateUri, create).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, new String[0]);
+        return create;
+    }
+
+    private static Uri generateUri(Context context, String str) {
+        return new Uri.Builder().scheme("content").authority(context.getPackageName() + AUTHORITY_SUFFIX).path(FILE_SUB_DIR_NAME + str + FILE_EXTENSION).build();
+    }
+
+    public static void grantReadPermission(@NonNull Intent intent, @Nullable List<Uri> list, @NonNull Context context) {
+        if (list == null || list.size() == 0) {
+            return;
+        }
+        ContentResolver contentResolver = context.getContentResolver();
+        intent.addFlags(1);
+        ClipData newUri = ClipData.newUri(contentResolver, CLIP_DATA_LABEL, list.get(0));
+        for (int i = 1; i < list.size(); i++) {
+            newUri.addItem(new ClipData.Item(list.get(i)));
+        }
+        intent.setClipData(newUri);
+    }
+
+    @NonNull
+    public static ListenableFuture loadBitmap(@NonNull final ContentResolver contentResolver, @NonNull final Uri uri) {
+        final ResolvableFuture create = ResolvableFuture.create();
+        AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() { // from class: androidx.browser.browseractions.BrowserServiceFileProvider.1
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    ParcelFileDescriptor openFileDescriptor = contentResolver.openFileDescriptor(uri, "r");
+                    if (openFileDescriptor == null) {
+                        create.setException(new FileNotFoundException());
+                        return;
+                    }
+                    Bitmap decodeFileDescriptor = BitmapFactory.decodeFileDescriptor(openFileDescriptor.getFileDescriptor());
+                    openFileDescriptor.close();
+                    if (decodeFileDescriptor == null) {
+                        create.setException(new IOException("File could not be decoded."));
+                    } else {
+                        create.set(decodeFileDescriptor);
+                    }
+                } catch (IOException e) {
+                    create.setException(e);
+                }
+            }
+        });
+        return create;
+    }
+}