Zepto v25.1.4 - ScreenFragment.java 源代码

package com.swmansion.rnscreens;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.widget.FrameLayout;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import androidx.media3.exoplayer.audio.e;
import com.facebook.react.bridge.ReactContext;
import com.facebook.react.bridge.UiThreadUtil;
import com.facebook.react.uimanager.UIManagerHelper;
import com.facebook.react.uimanager.events.EventDispatcher;
import com.swmansion.rnscreens.events.HeaderBackButtonClickedEvent;
import com.swmansion.rnscreens.events.ScreenDismissedEvent;
import com.swmansion.rnscreens.events.ScreenTransitionProgressEvent;
import in.juspay.hypersdk.core.PaymentConstants;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.SourceDebugExtension;

@Metadata
@SourceDebugExtension
public class ScreenFragment extends Fragment implements ScreenFragmentWrapper {
    public static final int U = 0;
    public final Screen N;
    public final ArrayList O;
    public boolean P;
    public float Q;
    public boolean R;
    public boolean S;
    public boolean T;

    @Metadata
    public static final class Companion {
    }

    @Metadata
    public static final class ScreenLifecycleEvent {
        public static final ScreenLifecycleEvent a;
        public static final ScreenLifecycleEvent b;
        public static final ScreenLifecycleEvent c;

        public static final ScreenLifecycleEvent f2759d;

        public static final ScreenLifecycleEvent[] f2760e;

        static {
            ScreenLifecycleEvent screenLifecycleEvent = new ScreenLifecycleEvent("DID_APPEAR", 0);
            a = screenLifecycleEvent;
            ScreenLifecycleEvent screenLifecycleEvent2 = new ScreenLifecycleEvent("WILL_APPEAR", 1);
            b = screenLifecycleEvent2;
            ScreenLifecycleEvent screenLifecycleEvent3 = new ScreenLifecycleEvent("DID_DISAPPEAR", 2);
            c = screenLifecycleEvent3;
            ScreenLifecycleEvent screenLifecycleEvent4 = new ScreenLifecycleEvent("WILL_DISAPPEAR", 3);
            f2759d = screenLifecycleEvent4;
            f2760e = new ScreenLifecycleEvent[]{screenLifecycleEvent, screenLifecycleEvent2, screenLifecycleEvent3, screenLifecycleEvent4};
        }

        public static ScreenLifecycleEvent valueOf(String str) {
            return (ScreenLifecycleEvent) Enum.valueOf(ScreenLifecycleEvent.class, str);
        }

        public static ScreenLifecycleEvent[] values() {
            return (ScreenLifecycleEvent[]) f2760e.clone();
        }
    }

    @Metadata
    public static final class ScreensFrameLayout extends FrameLayout {
        @Override
        public final void clearFocus() {
            if (getVisibility() != 4) {
                super.clearFocus();
            }
        }
    }

    @Metadata
    public class WhenMappings {
        static {
            int[] iArr = new int[ScreenLifecycleEvent.values().length];
            try {
                iArr[1] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[0] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                iArr[3] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                iArr[2] = 4;
            } catch (NoSuchFieldError unused4) {
            }
        }
    }

    public ScreenFragment() {
        this.O = new ArrayList();
        this.Q = -1.0f;
        this.R = true;
        this.S = true;
        throw new IllegalStateException("Screen fragments should never be restored. Follow instructions from https://github.com/software-mansion/react-native-screens/issues/17#issuecomment-424704067 to properly configure your main activity.");
    }

    public static final void M(ViewGroup view) {
        Intrinsics.checkNotNullParameter(view, "view");
        ViewParent parent = view.getParent();
        if (parent != null) {
            ViewGroup viewGroup = (ViewGroup) parent;
            viewGroup.endViewTransition(view);
            viewGroup.removeView(view);
        }
        view.setVisibility(0);
    }

    @Override
    public final ReactContext B() {
        if (getContext() instanceof ReactContext) {
            ReactContext context = getContext();
            Intrinsics.f(context, "null cannot be cast to non-null type com.facebook.react.bridge.ReactContext");
            return context;
        }
        if (r().getContext() instanceof ReactContext) {
            ReactContext context2 = r().getContext();
            Intrinsics.f(context2, "null cannot be cast to non-null type com.facebook.react.bridge.ReactContext");
            return context2;
        }
        for (ViewParent container = r().getContainer(); container != null; container = container.getParent()) {
            if (container instanceof Screen) {
                Screen screen = (Screen) container;
                if (screen.getContext() instanceof ReactContext) {
                    ReactContext context3 = screen.getContext();
                    Intrinsics.f(context3, "null cannot be cast to non-null type com.facebook.react.bridge.ReactContext");
                    return context3;
                }
            }
        }
        return null;
    }

    public final void H() {
        ReactContext context = r().getContext();
        Intrinsics.f(context, "null cannot be cast to non-null type com.facebook.react.bridge.ReactContext");
        ReactContext reactContext = context;
        int d2 = UIManagerHelper.d(reactContext);
        EventDispatcher b = UIManagerHelper.b(reactContext, r().getId());
        if (b != null) {
            b.g(new HeaderBackButtonClickedEvent(d2, r().getId()));
        }
    }

    public final void I(com.swmansion.rnscreens.ScreenFragment.ScreenLifecycleEvent r7, com.swmansion.rnscreens.ScreenFragmentWrapper r8) {
        throw new UnsupportedOperationException("Method not decompiled: com.swmansion.rnscreens.ScreenFragment.I(com.swmansion.rnscreens.ScreenFragment$ScreenLifecycleEvent, com.swmansion.rnscreens.ScreenFragmentWrapper):void");
    }

    public final void J(float f2, boolean z) {
        if (!(this instanceof ScreenStackFragment) || this.Q == f2) {
            return;
        }
        float max = Math.max(0.0f, Math.min(1.0f, f2));
        this.Q = max;
        short s = (short) (max == 0.0f ? 1 : max == 1.0f ? 2 : 3);
        ScreenContainer container = r().getContainer();
        boolean goingForward = container instanceof ScreenStack ? ((ScreenStack) container).getGoingForward() : false;
        ReactContext context = r().getContext();
        Intrinsics.f(context, "null cannot be cast to non-null type com.facebook.react.bridge.ReactContext");
        ReactContext reactContext = context;
        EventDispatcher b = UIManagerHelper.b(reactContext, r().getId());
        if (b != null) {
            b.g(new ScreenTransitionProgressEvent(UIManagerHelper.d(reactContext), r().getId(), this.Q, z, goingForward, s));
        }
    }

    public final void K(boolean z) {
        this.T = !z;
        Fragment parentFragment = getParentFragment();
        if (parentFragment == null || ((parentFragment instanceof ScreenFragment) && !((ScreenFragment) parentFragment).T)) {
            if (isResumed()) {
                UiThreadUtil.runOnUiThread(new e(z, this, 5));
            } else if (z) {
                I(ScreenLifecycleEvent.c, this);
                J(1.0f, true);
            } else {
                I(ScreenLifecycleEvent.f2759d, this);
                J(0.0f, true);
            }
        }
    }

    public void L() {
        K(true);
    }

    @Override
    public final void b(ScreenLifecycleEvent event) {
        ScreenFragmentWrapper fragmentWrapper;
        Intrinsics.checkNotNullParameter(event, "event");
        ArrayList arrayList = this.O;
        ArrayList arrayList2 = new ArrayList();
        for (Object obj : arrayList) {
            if (((ScreenContainer) obj).getScreenCount() > 0) {
                arrayList2.add(obj);
            }
        }
        Iterator it = arrayList2.iterator();
        while (it.hasNext()) {
            Screen topScreen = ((ScreenContainer) it.next()).getTopScreen();
            if (topScreen != null && (fragmentWrapper = topScreen.getFragmentWrapper()) != null) {
                I(event, fragmentWrapper);
            }
        }
    }

    @Override
    public final void e(ScreenLifecycleEvent event) {
        Intrinsics.checkNotNullParameter(event, "event");
        int ordinal = event.ordinal();
        if (ordinal == 0) {
            this.S = false;
            return;
        }
        if (ordinal == 1) {
            this.R = false;
        } else if (ordinal == 2) {
            this.S = true;
        } else {
            if (ordinal != 3) {
                return;
            }
            this.R = true;
        }
    }

    public View onCreateView(LayoutInflater inflater, ViewGroup viewGroup, Bundle bundle) {
        Intrinsics.checkNotNullParameter(inflater, "inflater");
        r().setLayoutParams(new FrameLayout.LayoutParams(-1, -1));
        Context context = getContext();
        if (context == null) {
            return null;
        }
        Intrinsics.checkNotNullParameter(context, "context");
        ScreensFrameLayout screensFrameLayout = new ScreensFrameLayout(context);
        Screen r = r();
        M(r);
        screensFrameLayout.addView(r);
        return screensFrameLayout;
    }

    public final void onDestroy() {
        super.onDestroy();
        ScreenContainer container = r().getContainer();
        if (container == null || !container.c(this)) {
            ReactContext context = r().getContext();
            if (context instanceof ReactContext) {
                int d2 = UIManagerHelper.d(context);
                EventDispatcher b = UIManagerHelper.b(context, r().getId());
                if (b != null) {
                    b.g(new ScreenDismissedEvent(d2, r().getId()));
                }
            }
        }
        this.O.clear();
    }

    public final void onResume() {
        super.onResume();
        if (this.P) {
            this.P = false;
            ScreenWindowTraits.j(r(), t(), B());
        }
    }

    @Override
    public final Screen r() {
        Screen screen = this.N;
        if (screen != null) {
            return screen;
        }
        Intrinsics.n(PaymentConstants.Event.SCREEN);
        throw null;
    }

    @Override
    public final Activity t() {
        Fragment fragment;
        FragmentActivity activity;
        FragmentActivity activity2 = getActivity();
        if (activity2 != null) {
            return activity2;
        }
        ReactContext context = r().getContext();
        if (context instanceof ReactContext) {
            ReactContext reactContext = context;
            if (reactContext.getCurrentActivity() != null) {
                return reactContext.getCurrentActivity();
            }
        }
        for (ViewParent container = r().getContainer(); container != null; container = container.getParent()) {
            if ((container instanceof Screen) && (fragment = ((Screen) container).getFragment()) != null && (activity = fragment.getActivity()) != null) {
                return activity;
            }
        }
        return null;
    }

    @Override
    public final ScreenFragment u() {
        return this;
    }

    @Override
    public final List w() {
        return this.O;
    }

    @Override
    public final void x(ScreenContainer container) {
        Intrinsics.checkNotNullParameter(container, "container");
        this.O.add(container);
    }

    @Override
    public void y() {
        FragmentActivity activity = getActivity();
        if (activity == null) {
            this.P = true;
        } else {
            ScreenWindowTraits.j(r(), activity, B());
        }
    }

    @Override
    public final void z(ScreenContainer container) {
        Intrinsics.checkNotNullParameter(container, "container");
        this.O.remove(container);
    }

    public ScreenFragment(Screen screenView) {
        Intrinsics.checkNotNullParameter(screenView, "screenView");
        this.O = new ArrayList();
        this.Q = -1.0f;
        this.R = true;
        this.S = true;
        Intrinsics.checkNotNullParameter(screenView, "<set-?>");
        this.N = screenView;
    }
}