Kaspi.kz v5.85.1 - ComponentActivity4.java 源代码

package o;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.IntentSender;
import android.content.res.Configuration;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.SystemClock;
import android.text.TextUtils;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.view.Window;
import android.window.OnBackInvokedDispatcher;
import androidx.activity.OnBackPressedDispatcher;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LifecycleRegistry;
import androidx.lifecycle.ReportFragment;
import androidx.lifecycle.ViewModelProvider;
import androidx.lifecycle.ViewTreeViewModelStoreOwner;
import androidx.lifecycle.viewmodel.CreationExtras;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicInteger;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import o.ComponentActivity4;
import o.getSupportedHdr;
import o.setLogo;
import o.setMenu;

public class ComponentActivity4 extends createNativeWithClientOptions implements setExpandedFormat, androidx.lifecycle.LifecycleOwner, androidx.lifecycle.ViewModelStoreOwner, androidx.lifecycle.HasDefaultViewModelProviderFactory, getSupportedVideoAspectRatios, getContext, setActionBarVisibilityCallback, setShortcut, setUseQrMobilenetV3, Analytics, getCode39UseCheckDigit, getCode39MinConsistentLines, getCode39UseExtendedMode, setCircularRevealOverlayDrawable, valueOf {
    private static final String setOptions = "android:support:activity-result";
    private final CopyOnWriteArrayList<setUseMaterialThemeColors<Configuration>> AudioAttributesCompatParcelizer;
    private final AtomicInteger AudioAttributesImplApi21Parcelizer;
    private final MaterialCalendar2 AudioAttributesImplApi26Parcelizer;
    private OnBackPressedDispatcher AudioAttributesImplBaseParcelizer;
    private boolean IconCompatParcelizer;
    private final LifecycleRegistry MediaBrowserCompatCustomActionResultReceiver;
    private final CopyOnWriteArrayList<setUseMaterialThemeColors<toProto>> MediaBrowserCompatItemReceiver;
    private final CopyOnWriteArrayList<setUseMaterialThemeColors<Intent>> MediaBrowserCompatMediaItem;
    private final CopyOnWriteArrayList<setUseMaterialThemeColors<Integer>> MediaBrowserCompatSearchResultReceiver;
    private final CopyOnWriteArrayList<setUseMaterialThemeColors<getEan8MinConsistentLines>> MediaDescriptionCompat;
    private androidx.lifecycle.ViewModelStore MediaMetadataCompat;
    private final setSubtitle RemoteActionCompatParcelizer;
    private int read;
    final values setBackground;
    private boolean setElement;
    public final setFieldValue setError;
    final getSupportedPictureSizes setFieldValue;
    public final setPadding setLabel;
    private ViewModelProvider.Factory write;

    public interface setFieldValue extends Executor {
        void setError(@androidx.annotation.NonNull View view);

        void setLabel();
    }

    @Deprecated
    public Object bD_() {
        return null;
    }

    static final class setLabel {
        androidx.lifecycle.ViewModelStore setBackground;
        Object setFieldValue;

        setLabel() {
        }
    }

    public Unit MediaBrowserCompatCustomActionResultReceiver() {
        reportFullyDrawn();
        return null;
    }

    public ComponentActivity4() {
        this.setLabel = new setPadding();
        this.AudioAttributesImplApi26Parcelizer = new MaterialCalendar2(new Runnable() {
            @Override
            public final void run() {
                ComponentActivity4.this.setElement();
            }
        });
        this.MediaBrowserCompatCustomActionResultReceiver = new LifecycleRegistry(this);
        getSupportedPictureSizes background = getSupportedPictureSizes.setBackground(this);
        this.setFieldValue = background;
        this.AudioAttributesImplBaseParcelizer = null;
        setFieldValue AudioAttributesCompatParcelizer = AudioAttributesCompatParcelizer();
        this.setError = AudioAttributesCompatParcelizer;
        this.setBackground = new values(AudioAttributesCompatParcelizer, new Function0() {
            public final Object invoke() {
                Unit MediaBrowserCompatCustomActionResultReceiver;
                MediaBrowserCompatCustomActionResultReceiver = ComponentActivity4.this.MediaBrowserCompatCustomActionResultReceiver();
                return MediaBrowserCompatCustomActionResultReceiver;
            }
        });
        this.AudioAttributesImplApi21Parcelizer = new AtomicInteger();
        this.RemoteActionCompatParcelizer = new setSubtitle() {
            @Override
            public <I, O> void setOptions(final int i, @androidx.annotation.NonNull setLogo<I, O> setlogo, I i2, @Nullable detectFacesImageByteBufferJni detectfacesimagebytebufferjni) {
                Bundle error;
                ComponentActivity4 componentActivity4 = ComponentActivity4.this;
                final setLogo.setFieldValue<O> error2 = setlogo.setError((Context) componentActivity4, (ComponentActivity4) i2);
                if (error2 != null) {
                    new Handler(Looper.getMainLooper()).post(new Runnable() {
                        @Override
                        public void run() {
                            setLabel(i, error2.setError());
                        }
                    });
                    return;
                }
                Intent fieldValue = setlogo.setFieldValue(componentActivity4, i2);
                if (fieldValue.getExtras() != null && fieldValue.getExtras().getClassLoader() == null) {
                    fieldValue.setExtrasClassLoader(componentActivity4.getClassLoader());
                }
                if (fieldValue.hasExtra(setMenu.MediaBrowserCompatCustomActionResultReceiver.setFieldValue)) {
                    Bundle bundleExtra = fieldValue.getBundleExtra(setMenu.MediaBrowserCompatCustomActionResultReceiver.setFieldValue);
                    fieldValue.removeExtra(setMenu.MediaBrowserCompatCustomActionResultReceiver.setFieldValue);
                    error = bundleExtra;
                } else {
                    error = detectfacesimagebytebufferjni != null ? detectfacesimagebytebufferjni.setError() : null;
                }
                if (setMenu.AudioAttributesImplBaseParcelizer.setBackground.equals(fieldValue.getAction())) {
                    String[] stringArrayExtra = fieldValue.getStringArrayExtra(setMenu.AudioAttributesImplBaseParcelizer.setOptions);
                    if (stringArrayExtra == null) {
                        stringArrayExtra = new String[0];
                    }
                    NativeOnCompleteListener.setOptions(componentActivity4, stringArrayExtra, i);
                    return;
                }
                if ("androidx.activity.result.contract.action.INTENT_SENDER_REQUEST".equals(fieldValue.getAction())) {
                    setCustomView setcustomview = (setCustomView) fieldValue.getParcelableExtra("androidx.activity.result.contract.extra.INTENT_SENDER_REQUEST");
                    try {
                        NativeOnCompleteListener.setError(componentActivity4, setcustomview.setBackground(), i, setcustomview.setError(), setcustomview.setOptions(), setcustomview.setLabel(), 0, error);
                        return;
                    } catch (IntentSender.SendIntentException e) {
                        new Handler(Looper.getMainLooper()).post(new Runnable() {
                            @Override
                            public void run() {
                                setBackground(i, 0, new Intent().setAction("androidx.activity.result.contract.action.INTENT_SENDER_REQUEST").putExtra("androidx.activity.result.contract.extra.SEND_INTENT_EXCEPTION", e));
                            }
                        });
                        return;
                    }
                }
                NativeOnCompleteListener.setLabel(componentActivity4, fieldValue, i, error);
            }
        };
        this.AudioAttributesCompatParcelizer = new CopyOnWriteArrayList<>();
        this.MediaBrowserCompatSearchResultReceiver = new CopyOnWriteArrayList<>();
        this.MediaBrowserCompatMediaItem = new CopyOnWriteArrayList<>();
        this.MediaBrowserCompatItemReceiver = new CopyOnWriteArrayList<>();
        this.MediaDescriptionCompat = new CopyOnWriteArrayList<>();
        this.IconCompatParcelizer = false;
        this.setElement = false;
        if (getLifecycle() == null) {
            throw new IllegalStateException("getLifecycle() returned null in ComponentActivity's constructor. Please make sure you are lazily constructing your Lifecycle in the first call to getLifecycle() rather than relying on field initialization.");
        }
        getLifecycle().addObserver(new androidx.lifecycle.LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_STOP) {
                    Window window = ComponentActivity4.this.getWindow();
                    View peekDecorView = window != null ? window.peekDecorView() : null;
                    if (peekDecorView != null) {
                        ComponentActivity4.setBackground.setFieldValue(peekDecorView);
                    }
                }
            }
        });
        getLifecycle().addObserver(new androidx.lifecycle.LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    ComponentActivity4.this.setLabel.setLabel();
                    if (!ComponentActivity4.this.isChangingConfigurations()) {
                        ComponentActivity4.this.getViewModelStore().clear();
                    }
                    ComponentActivity4.this.setError.setLabel();
                }
            }
        });
        getLifecycle().addObserver(new androidx.lifecycle.LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) {
                ComponentActivity4.this.bA_();
                ComponentActivity4.this.getLifecycle().removeObserver(this);
            }
        });
        background.setLabel();
        androidx.lifecycle.SavedStateHandleSupport.enableSavedStateHandles(this);
        getSavedStateRegistry().setLabel(setOptions, new getSupportedHdr.setBackground() {
            public final Bundle saveState() {
                Bundle AudioAttributesImplApi21Parcelizer;
                AudioAttributesImplApi21Parcelizer = ComponentActivity4.this.AudioAttributesImplApi21Parcelizer();
                return AudioAttributesImplApi21Parcelizer;
            }
        });
        setBackground(new setPopupCallback() {
            @Override
            public final void setOptions(Context context) {
                ComponentActivity4.this.setFieldValue(context);
            }
        });
    }

    public Bundle AudioAttributesImplApi21Parcelizer() {
        Bundle bundle = new Bundle();
        this.RemoteActionCompatParcelizer.setBackground(bundle);
        return bundle;
    }

    public void setFieldValue(Context context) {
        Bundle error = getSavedStateRegistry().setError(setOptions);
        if (error != null) {
            this.RemoteActionCompatParcelizer.setLabel(error);
        }
    }

    public ComponentActivity4(@setAutoSizeTextTypeUniformWithPresetSizes int i) {
        this();
        this.read = i;
    }

    @Override
    public void onCreate(@Nullable Bundle bundle) {
        this.setFieldValue.setLabel(bundle);
        this.setLabel.setOptions(this);
        super.onCreate(bundle);
        ReportFragment.injectIfNeededIn(this);
        int i = this.read;
        if (i != 0) {
            setContentView(i);
        }
    }

    @Override
    public void onSaveInstanceState(@androidx.annotation.NonNull Bundle bundle) {
        androidx.lifecycle.Lifecycle lifecycle = getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
        }
        super.onSaveInstanceState(bundle);
        this.setFieldValue.setOptions(bundle);
    }

    @Override
    public final Object onRetainNonConfigurationInstance() {
        setLabel setlabel;
        Object bD_ = bD_();
        androidx.lifecycle.ViewModelStore viewModelStore = this.MediaMetadataCompat;
        if (viewModelStore == null && (setlabel = (setLabel) getLastNonConfigurationInstance()) != null) {
            viewModelStore = setlabel.setBackground;
        }
        if (viewModelStore == null && bD_ == null) {
            return null;
        }
        setLabel setlabel2 = new setLabel();
        setlabel2.setFieldValue = bD_;
        setlabel2.setBackground = viewModelStore;
        return setlabel2;
    }

    @Deprecated
    public Object bC_() {
        setLabel setlabel = (setLabel) getLastNonConfigurationInstance();
        if (setlabel != null) {
            return setlabel.setFieldValue;
        }
        return null;
    }

    @Override
    public void setContentView(@setAutoSizeTextTypeUniformWithPresetSizes int i) {
        bU_();
        this.setError.setError(getWindow().getDecorView());
        super.setContentView(i);
    }

    @Override
    public void setContentView(@SuppressLint({"UnknownNullness", "MissingNullability"}) View view) {
        bU_();
        this.setError.setError(getWindow().getDecorView());
        super.setContentView(view);
    }

    @Override
    public void setContentView(@SuppressLint({"UnknownNullness", "MissingNullability"}) View view, @SuppressLint({"UnknownNullness", "MissingNullability"}) ViewGroup.LayoutParams layoutParams) {
        bU_();
        this.setError.setError(getWindow().getDecorView());
        super.setContentView(view, layoutParams);
    }

    @Override
    public void addContentView(@SuppressLint({"UnknownNullness", "MissingNullability"}) View view, @SuppressLint({"UnknownNullness", "MissingNullability"}) ViewGroup.LayoutParams layoutParams) {
        bU_();
        this.setError.setError(getWindow().getDecorView());
        super.addContentView(view, layoutParams);
    }

    public void bU_() {
        androidx.lifecycle.ViewTreeLifecycleOwner.set(getWindow().getDecorView(), this);
        ViewTreeViewModelStoreOwner.set(getWindow().getDecorView(), this);
        isAutoFocusSupported.setBackground(getWindow().getDecorView(), this);
        getThemeResId.setFieldValue(getWindow().getDecorView(), this);
        setBackgroundResource.setOptions(getWindow().getDecorView(), this);
    }

    @Override
    public Context bE_() {
        return this.setLabel.setError();
    }

    @Override
    public final void setBackground(@androidx.annotation.NonNull setPopupCallback setpopupcallback) {
        this.setLabel.setError(setpopupcallback);
    }

    @Override
    public final void setLabel(@androidx.annotation.NonNull setPopupCallback setpopupcallback) {
        this.setLabel.setLabel(setpopupcallback);
    }

    @Override
    public boolean onPreparePanel(int i, @Nullable View view, @androidx.annotation.NonNull Menu menu) {
        if (i != 0) {
            return true;
        }
        super.onPreparePanel(i, view, menu);
        this.AudioAttributesImplApi26Parcelizer.setOptions(menu);
        return true;
    }

    @Override
    public boolean onCreatePanelMenu(int i, @androidx.annotation.NonNull Menu menu) {
        if (i != 0) {
            return true;
        }
        super.onCreatePanelMenu(i, menu);
        this.AudioAttributesImplApi26Parcelizer.setOptions(menu, getMenuInflater());
        return true;
    }

    @Override
    public boolean onMenuItemSelected(int i, @androidx.annotation.NonNull MenuItem menuItem) {
        if (super.onMenuItemSelected(i, menuItem)) {
            return true;
        }
        if (i == 0) {
            return this.AudioAttributesImplApi26Parcelizer.setError(menuItem);
        }
        return false;
    }

    @Override
    public void onPanelClosed(int i, @androidx.annotation.NonNull Menu menu) {
        this.AudioAttributesImplApi26Parcelizer.setLabel(menu);
        super.onPanelClosed(i, menu);
    }

    @Override
    public void setFieldValue(@androidx.annotation.NonNull setRevealInfo setrevealinfo) {
        this.AudioAttributesImplApi26Parcelizer.setLabel(setrevealinfo);
    }

    @Override
    public void setError(@androidx.annotation.NonNull setRevealInfo setrevealinfo, @androidx.annotation.NonNull androidx.lifecycle.LifecycleOwner lifecycleOwner) {
        this.AudioAttributesImplApi26Parcelizer.setBackground(setrevealinfo, lifecycleOwner);
    }

    @Override
    public void setBackground(@androidx.annotation.NonNull setRevealInfo setrevealinfo, @androidx.annotation.NonNull androidx.lifecycle.LifecycleOwner lifecycleOwner, @androidx.annotation.NonNull Lifecycle.State state) {
        this.AudioAttributesImplApi26Parcelizer.setOptions(setrevealinfo, lifecycleOwner, state);
    }

    @Override
    public void setLabel(@androidx.annotation.NonNull setRevealInfo setrevealinfo) {
        this.AudioAttributesImplApi26Parcelizer.setOptions(setrevealinfo);
    }

    @Override
    public void setElement() {
        invalidateOptionsMenu();
    }

    @Override
    public androidx.lifecycle.Lifecycle getLifecycle() {
        return this.MediaBrowserCompatCustomActionResultReceiver;
    }

    @Override
    public androidx.lifecycle.ViewModelStore getViewModelStore() {
        if (getApplication() == null) {
            throw new IllegalStateException("Your activity is not yet attached to the Application instance. You can't request ViewModel before onCreate call.");
        }
        bA_();
        return this.MediaMetadataCompat;
    }

    public void bA_() {
        if (this.MediaMetadataCompat == null) {
            setLabel setlabel = (setLabel) getLastNonConfigurationInstance();
            if (setlabel != null) {
                this.MediaMetadataCompat = setlabel.setBackground;
            }
            if (this.MediaMetadataCompat == null) {
                this.MediaMetadataCompat = new androidx.lifecycle.ViewModelStore();
            }
        }
    }

    @Override
    public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
        if (this.write == null) {
            this.write = new androidx.lifecycle.SavedStateViewModelFactory(getApplication(), this, getIntent() != null ? getIntent().getExtras() : null);
        }
        return this.write;
    }

    @Override
    public CreationExtras getDefaultViewModelCreationExtras() {
        androidx.lifecycle.viewmodel.MutableCreationExtras mutableCreationExtras = new androidx.lifecycle.viewmodel.MutableCreationExtras();
        if (getApplication() != null) {
            mutableCreationExtras.set(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY, getApplication());
        }
        mutableCreationExtras.set(androidx.lifecycle.SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY, this);
        mutableCreationExtras.set(androidx.lifecycle.SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY, this);
        if (getIntent() != null && getIntent().getExtras() != null) {
            mutableCreationExtras.set(androidx.lifecycle.SavedStateHandleSupport.DEFAULT_ARGS_KEY, getIntent().getExtras());
        }
        return mutableCreationExtras;
    }

    @Override
    @Deprecated
    public void onBackPressed() {
        getOnBackPressedDispatcher().setBackground();
    }

    @Override
    public final OnBackPressedDispatcher getOnBackPressedDispatcher() {
        if (this.AudioAttributesImplBaseParcelizer == null) {
            this.AudioAttributesImplBaseParcelizer = new OnBackPressedDispatcher(new Runnable() {
                @Override
                public void run() {
                    try {
                        ComponentActivity4.super.onBackPressed();
                    } catch (IllegalStateException e) {
                        if (!TextUtils.equals(e.getMessage(), "Can not perform this action after onSaveInstanceState")) {
                            throw e;
                        }
                    } catch (NullPointerException e2) {
                        if (!TextUtils.equals(e2.getMessage(), "Attempt to invoke virtual method 'android.os.Handler android.app.FragmentHostCallback.getHandler()' on a null object reference")) {
                            throw e2;
                        }
                    }
                }
            });
            getLifecycle().addObserver(new androidx.lifecycle.LifecycleEventObserver() {
                @Override
                public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) {
                    OnBackPressedDispatcher onBackPressedDispatcher;
                    if (event != Lifecycle.Event.ON_CREATE || Build.VERSION.SDK_INT < 33) {
                        return;
                    }
                    onBackPressedDispatcher = ComponentActivity4.this.AudioAttributesImplBaseParcelizer;
                    onBackPressedDispatcher.ce_(ComponentActivity4.setError.cc_((ComponentActivity4) lifecycleOwner));
                }
            });
        }
        return this.AudioAttributesImplBaseParcelizer;
    }

    public final getSupportedHdr getSavedStateRegistry() {
        return this.setFieldValue.setOptions();
    }

    @Override
    public values c_() {
        return this.setBackground;
    }

    @Override
    @Deprecated
    public void startActivityForResult(@androidx.annotation.NonNull Intent intent, int i) {
        super.startActivityForResult(intent, i);
    }

    @Override
    @Deprecated
    public void startActivityForResult(@androidx.annotation.NonNull Intent intent, int i, @Nullable Bundle bundle) {
        super.startActivityForResult(intent, i, bundle);
    }

    @Override
    @Deprecated
    public void startIntentSenderForResult(@androidx.annotation.NonNull IntentSender intentSender, int i, @Nullable Intent intent, int i2, int i3, int i4) throws IntentSender.SendIntentException {
        super.startIntentSenderForResult(intentSender, i, intent, i2, i3, i4);
    }

    @Override
    @Deprecated
    public void startIntentSenderForResult(@androidx.annotation.NonNull IntentSender intentSender, int i, @Nullable Intent intent, int i2, int i3, int i4, @Nullable Bundle bundle) throws IntentSender.SendIntentException {
        super.startIntentSenderForResult(intentSender, i, intent, i2, i3, i4, bundle);
    }

    @Override
    @Deprecated
    public void onActivityResult(int i, int i2, @Nullable Intent intent) {
        if (this.RemoteActionCompatParcelizer.setBackground(i, i2, intent)) {
            return;
        }
        super.onActivityResult(i, i2, intent);
    }

    @Override
    @Deprecated
    public void onRequestPermissionsResult(int i, @androidx.annotation.NonNull String[] strArr, @androidx.annotation.NonNull int[] iArr) {
        if (this.RemoteActionCompatParcelizer.setBackground(i, -1, new Intent().putExtra(setMenu.AudioAttributesImplBaseParcelizer.setOptions, strArr).putExtra(setMenu.AudioAttributesImplBaseParcelizer.setLabel, iArr))) {
            return;
        }
        super.onRequestPermissionsResult(i, strArr, iArr);
    }

    @Override
    public final <I, O> setStackedBackground<I> registerForActivityResult(@androidx.annotation.NonNull setLogo<I, O> setlogo, @androidx.annotation.NonNull setSubtitle setsubtitle, @androidx.annotation.NonNull setVisibility<O> setvisibility) {
        return setsubtitle.setFieldValue("activity_rq#" + this.AudioAttributesImplApi21Parcelizer.getAndIncrement(), this, setlogo, setvisibility);
    }

    @Override
    public final <I, O> setStackedBackground<I> registerForActivityResult(@androidx.annotation.NonNull setLogo<I, O> setlogo, @androidx.annotation.NonNull setVisibility<O> setvisibility) {
        return registerForActivityResult(setlogo, this.RemoteActionCompatParcelizer, setvisibility);
    }

    @Override
    public final setSubtitle bB_() {
        return this.RemoteActionCompatParcelizer;
    }

    @Override
    public void onConfigurationChanged(@androidx.annotation.NonNull Configuration configuration) {
        super.onConfigurationChanged(configuration);
        Iterator<setUseMaterialThemeColors<Configuration>> it = this.AudioAttributesCompatParcelizer.iterator();
        while (it.hasNext()) {
            it.next().setFieldValue(configuration);
        }
    }

    @Override
    public final void setError(@androidx.annotation.NonNull setUseMaterialThemeColors<Configuration> setusematerialthemecolors) {
        this.AudioAttributesCompatParcelizer.add(setusematerialthemecolors);
    }

    @Override
    public final void read(@androidx.annotation.NonNull setUseMaterialThemeColors<Configuration> setusematerialthemecolors) {
        this.AudioAttributesCompatParcelizer.remove(setusematerialthemecolors);
    }

    @Override
    public void onTrimMemory(int i) {
        super.onTrimMemory(i);
        Iterator<setUseMaterialThemeColors<Integer>> it = this.MediaBrowserCompatSearchResultReceiver.iterator();
        while (it.hasNext()) {
            it.next().setFieldValue(Integer.valueOf(i));
        }
    }

    @Override
    public final void setFieldValue(@androidx.annotation.NonNull setUseMaterialThemeColors<Integer> setusematerialthemecolors) {
        this.MediaBrowserCompatSearchResultReceiver.add(setusematerialthemecolors);
    }

    @Override
    public final void IconCompatParcelizer(@androidx.annotation.NonNull setUseMaterialThemeColors<Integer> setusematerialthemecolors) {
        this.MediaBrowserCompatSearchResultReceiver.remove(setusematerialthemecolors);
    }

    @Override
    public void onNewIntent(@SuppressLint({"UnknownNullness", "MissingNullability"}) Intent intent) {
        super.onNewIntent(intent);
        Iterator<setUseMaterialThemeColors<Intent>> it = this.MediaBrowserCompatMediaItem.iterator();
        while (it.hasNext()) {
            it.next().setFieldValue(intent);
        }
    }

    @Override
    public final void setLabel(@androidx.annotation.NonNull setUseMaterialThemeColors<Intent> setusematerialthemecolors) {
        this.MediaBrowserCompatMediaItem.add(setusematerialthemecolors);
    }

    @Override
    public final void RemoteActionCompatParcelizer(@androidx.annotation.NonNull setUseMaterialThemeColors<Intent> setusematerialthemecolors) {
        this.MediaBrowserCompatMediaItem.remove(setusematerialthemecolors);
    }

    @Override
    public void onMultiWindowModeChanged(boolean z) {
        if (this.IconCompatParcelizer) {
            return;
        }
        Iterator<setUseMaterialThemeColors<toProto>> it = this.MediaBrowserCompatItemReceiver.iterator();
        while (it.hasNext()) {
            it.next().setFieldValue(new toProto(z));
        }
    }

    @Override
    public void onMultiWindowModeChanged(boolean z, @androidx.annotation.NonNull Configuration configuration) {
        this.IconCompatParcelizer = true;
        try {
            super.onMultiWindowModeChanged(z, configuration);
            this.IconCompatParcelizer = false;
            Iterator<setUseMaterialThemeColors<toProto>> it = this.MediaBrowserCompatItemReceiver.iterator();
            while (it.hasNext()) {
                it.next().setFieldValue(new toProto(z, configuration));
            }
        } catch (Throwable th) {
            this.IconCompatParcelizer = false;
            throw th;
        }
    }

    @Override
    public final void setBackground(@androidx.annotation.NonNull setUseMaterialThemeColors<toProto> setusematerialthemecolors) {
        this.MediaBrowserCompatItemReceiver.add(setusematerialthemecolors);
    }

    @Override
    public final void setElement(@androidx.annotation.NonNull setUseMaterialThemeColors<toProto> setusematerialthemecolors) {
        this.MediaBrowserCompatItemReceiver.remove(setusematerialthemecolors);
    }

    @Override
    public void onPictureInPictureModeChanged(boolean z) {
        if (this.setElement) {
            return;
        }
        Iterator<setUseMaterialThemeColors<getEan8MinConsistentLines>> it = this.MediaDescriptionCompat.iterator();
        while (it.hasNext()) {
            it.next().setFieldValue(new getEan8MinConsistentLines(z));
        }
    }

    @Override
    public void onPictureInPictureModeChanged(boolean z, @androidx.annotation.NonNull Configuration configuration) {
        this.setElement = true;
        try {
            super.onPictureInPictureModeChanged(z, configuration);
            this.setElement = false;
            Iterator<setUseMaterialThemeColors<getEan8MinConsistentLines>> it = this.MediaDescriptionCompat.iterator();
            while (it.hasNext()) {
                it.next().setFieldValue(new getEan8MinConsistentLines(z, configuration));
            }
        } catch (Throwable th) {
            this.setElement = false;
            throw th;
        }
    }

    @Override
    public final void setOptions(@androidx.annotation.NonNull setUseMaterialThemeColors<getEan8MinConsistentLines> setusematerialthemecolors) {
        this.MediaDescriptionCompat.add(setusematerialthemecolors);
    }

    @Override
    public final void write(@androidx.annotation.NonNull setUseMaterialThemeColors<getEan8MinConsistentLines> setusematerialthemecolors) {
        this.MediaDescriptionCompat.remove(setusematerialthemecolors);
    }

    @Override
    public void reportFullyDrawn() {
        try {
            if (getFrameProcessingPoolSize.setOptions()) {
                getFrameProcessingPoolSize.setLabel("reportFullyDrawn() for ComponentActivity");
            }
            super.reportFullyDrawn();
            this.setBackground.setError();
        } finally {
            getFrameProcessingPoolSize.setFieldValue();
        }
    }

    private setFieldValue AudioAttributesCompatParcelizer() {
        return new write();
    }

    public static class setBackground {
        private setBackground() {
        }

        public static void setFieldValue(View view) {
            view.cancelPendingInputEvents();
        }
    }

    public static class setError {
        private setError() {
        }

        public static OnBackInvokedDispatcher cc_(Activity activity) {
            return activity.getOnBackInvokedDispatcher();
        }
    }

    class write implements setFieldValue, ViewTreeObserver.OnDrawListener, Runnable {
        final long setBackground = SystemClock.uptimeMillis() + 10000;
        boolean setFieldValue = false;
        Runnable setOptions;

        write() {
        }

        @Override
        public void setError(@androidx.annotation.NonNull View view) {
            if (this.setFieldValue) {
                return;
            }
            this.setFieldValue = true;
            view.getViewTreeObserver().addOnDrawListener(this);
        }

        @Override
        public void setLabel() {
            ComponentActivity4.this.getWindow().getDecorView().removeCallbacks(this);
            ComponentActivity4.this.getWindow().getDecorView().getViewTreeObserver().removeOnDrawListener(this);
        }

        @Override
        public void execute(Runnable runnable) {
            this.setOptions = runnable;
            View decorView = ComponentActivity4.this.getWindow().getDecorView();
            if (this.setFieldValue) {
                if (Looper.myLooper() == Looper.getMainLooper()) {
                    decorView.invalidate();
                    return;
                } else {
                    decorView.postInvalidate();
                    return;
                }
            }
            decorView.postOnAnimation(new Runnable() {
                @Override
                public final void run() {
                    ComponentActivity4.write.this.setBackground();
                }
            });
        }

        public void setBackground() {
            Runnable runnable = this.setOptions;
            if (runnable != null) {
                runnable.run();
                this.setOptions = null;
            }
        }

        @Override
        public void onDraw() {
            Runnable runnable = this.setOptions;
            if (runnable == null) {
                if (SystemClock.uptimeMillis() > this.setBackground) {
                    this.setFieldValue = false;
                    ComponentActivity4.this.getWindow().getDecorView().post(this);
                    return;
                }
                return;
            }
            runnable.run();
            this.setOptions = null;
            if (ComponentActivity4.this.setBackground.setLabel()) {
                this.setFieldValue = false;
                ComponentActivity4.this.getWindow().getDecorView().post(this);
            }
        }

        @Override
        public void run() {
            ComponentActivity4.this.getWindow().getDecorView().getViewTreeObserver().removeOnDrawListener(this);
        }
    }

    @Override
    public void attachBaseContext(Context context) {
        super.attachBaseContext(context);
    }

    @Override
    public void onPause() {
        super.onPause();
    }

    @Override
    public void onResume() {
        super.onResume();
    }

    @Override
    public void onStart() {
        super.onStart();
    }
}