Sandridge Go v2025.2.170190457 - C0143a.java 源代码

package com.microsoft.intune.mam.client.app.offline;

import android.annotation.TargetApi;
import android.app.Application;
import android.app.Fragment;
import android.app.assist.AssistContent;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.net.Uri;
import android.os.BadParcelableException;
import android.os.Bundle;
import android.util.AttributeSet;
import android.view.Menu;
import android.view.SearchEvent;
import android.view.View;
import com.microsoft.intune.mam.client.MAMIdentitySwitchResult;
import com.microsoft.intune.mam.client.app.AbstractC0128a;
import com.microsoft.intune.mam.client.app.ActivityBehaviorBase;
import com.microsoft.intune.mam.client.app.AppIdentitySwitchReason;
import com.microsoft.intune.mam.client.app.AppIdentitySwitchResult;
import com.microsoft.intune.mam.client.app.AppIdentitySwitchResultCallback;
import com.microsoft.intune.mam.client.app.HookedActivity;
import com.microsoft.intune.mam.client.app.IdentitySwitchOption;
import com.microsoft.intune.mam.client.app.data.AbstractUserDataWiper;
import com.microsoft.intune.mam.client.identity.IdentityParamConverter;
import com.microsoft.intune.mam.client.identity.MAMIdentity;
import com.microsoft.intune.mam.client.identity.MAMIdentityManager;
import com.microsoft.intune.mam.client.identity.MAMPolicyManagerBehavior;
import com.microsoft.intune.mam.policy.MAMEnrollmentManager;
import com.microsoft.intune.mam.policy.MAMEnrollmentStatusCache;
import com.microsoft.intune.mam.policy.MAMUserInfo;
import java.util.EnumSet;
import n5.AbstractC0489b;
import q5.EnumC0514b;

public final class C0143a extends ActivityBehaviorBase {
    public static final String e = "com.microsoft.intune.mam.OriginalFlags";
    private static final t5.e f = t5.f.a(C0143a.class);
    private static boolean g = false;
    private static boolean h = false;
    private HookedActivity a;
    private MAMEnrollmentStatusCache b;
    private boolean c;
    private final MAMIdentityManager d;

    class RunnableC0030a implements Runnable {
        RunnableC0030a() {
        }

        @Override
        public void run() {
            if (C0143a.this.g()) {
                return;
            }
            C0143a.f.x("Waited for wipes to complete, but not displaying blocking UI now. Recreating the activity...", new Object[0]);
            C0143a.this.a.asActivity().recreate();
        }
    }

    class b implements Runnable {
        final Runnable o;

        b(Runnable runnable) {
            this.o = runnable;
        }

        @Override
        public void run() {
            AbstractUserDataWiper.waitForWipesToComplete();
            C0143a.this.a.asActivity().runOnUiThread(this.o);
        }
    }

    public C0143a(MAMIdentityManager mAMIdentityManager, MAMEnrollmentStatusCache mAMEnrollmentStatusCache, IdentityParamConverter identityParamConverter) {
        super(identityParamConverter);
        this.c = false;
        this.d = mAMIdentityManager;
        this.b = mAMEnrollmentStatusCache;
    }

    private boolean d() {
        return g5.d.p() || com.microsoft.intune.mam.client.app.M.f();
    }

    private Intent e() {
        Intent intent = new Intent(this.a.asActivity(), (Class<?>) OfflineInstallCompanyPortalDialogActivity.class);
        intent.setFlags(268435456);
        intent.putExtra("activityLaunchBlocked", true);
        intent.putExtra("identityAuthority", i());
        return intent;
    }

    private Intent f(boolean z) {
        Intent intent = new Intent(this.a.asActivity(), (Class<?>) OfflineNotifyWipeActivity.class);
        intent.setFlags(268435456);
        if (z) {
            intent.putExtra("restartonfinish", true);
            intent.putExtra("android.intent.extra.INTENT", this.a.asActivity().getIntent());
        }
        return intent;
    }

    public boolean g() {
        Intent e2;
        boolean l = g5.d.l();
        boolean l2 = l();
        boolean d = d();
        boolean m = m();
        if (AbstractUserDataWiper.isWipeInProgress()) {
            f.m("Offline wipe in progress, we will need to notify when it is finished.", new Object[0]);
            this.a.startActivityForResultReal(f(true), -1);
        } else if (this.b.getSystemWipeNotice()) {
            f.m("System Wipe is triggered, displaying notification dialog now.", new Object[0]);
            this.a.startActivityForResultReal(f(false), -1);
        } else if (j()) {
            o(this.a.asActivity());
        } else {
            if (!d && !l2 && !l && !m) {
                return false;
            }
            t5.e eVar = f;
            eVar.m("OfflineActivityBehavior displaying blocking UI", new Object[0]);
            if (m) {
                eVar.m("Implicit Wipe just happened from external code, notifying user ...", new Object[0]);
                e2 = f(true);
            } else if (l) {
                e2 = e();
            } else if (d) {
                e2 = new Intent(this.a.asActivity(), (Class<?>) OfflineStartupBlockedActivity.class);
                e2.addFlags(32768);
                e2.putExtra("message", (CharSequence) (com.microsoft.intune.mam.client.app.M.f() ? com.microsoft.intune.mam.client.app.M.g() : null));
                e2.putExtra("identityAuthority", i());
            } else {
                MAMIdentity h2 = h();
                if (h2 == null) {
                    eVar.h(EnumC0514b.AGENT_REQUIRED_NO_PRIMARY_IDENTITY, "Company Portal is required but effective identity is null. This should not be possible.", new Object[0]);
                    return false;
                }
                this.a.onMAMCompanyPortalRequired(h2.rawUPN(), h2.aadId());
                if (!h2.equals(h()) || !l()) {
                    return false;
                }
                if (this.a.asActivity().isFinishing()) {
                    return true;
                }
                e2 = e();
            }
            this.a.startActivityForResultReal(e2, -1);
        }
        if (this.c) {
            this.a.asActivity().finish();
        } else {
            this.a.finishReal();
        }
        return true;
    }

    private MAMIdentity h() {
        MAMIdentity mAMOfflineIdentity = this.a.getMAMOfflineIdentity();
        if (mAMOfflineIdentity != null) {
            return mAMOfflineIdentity;
        }
        MAMIdentity processMAMIdentity = ((MAMPolicyManagerBehavior) A.u(MAMPolicyManagerBehavior.class)).getProcessMAMIdentity();
        if (processMAMIdentity != null) {
            return processMAMIdentity;
        }
        if (g5.d.n()) {
            return MAMIdentity.EMPTY;
        }
        MAMUserInfo mAMUserInfo = (MAMUserInfo) A.u(MAMUserInfo.class);
        return this.d.create(mAMUserInfo.getPrimaryUser(), mAMUserInfo.getPrimaryUserOID());
    }

    private String i() {
        MAMIdentity h2 = h();
        if (h2 != null) {
            return h2.authority();
        }
        return null;
    }

    public static boolean j() {
        return h;
    }

    private void k() {
        new Thread(new b(new RunnableC0030a()), "Intune MAM wipe").start();
    }

    private boolean l() {
        MAMEnrollmentManager.a registeredAccountStatus;
        MAMIdentity h2 = h();
        return MAMIdentity.isValid(h2) && (registeredAccountStatus = ((MAMEnrollmentManager) A.u(MAMEnrollmentManager.class)).getRegisteredAccountStatus(h2.rawUPN(), h2.aadId())) != null && registeredAccountStatus == MAMEnrollmentManager.a.COMPANY_PORTAL_REQUIRED;
    }

    private boolean m() {
        return this.b.getImplicitWipeNotice();
    }

    private boolean n() {
        if (l()) {
            return ((T) A.u(T.class)).s(h(), this.a.asActivity());
        }
        return false;
    }

    public static void o(Context context) {
        if (g) {
            return;
        }
        Intent intent = new Intent(context, (Class<?>) OfflineRestartRequiredActivity.class);
        intent.setFlags(805437440);
        context.startActivity(intent);
        g = true;
    }

    public static void p(Context context) {
        h = true;
        if (((AbstractC0128a) A.u(AbstractC0128a.class)).b()) {
            o(context);
        } else {
            com.microsoft.intune.mam.client.app.I.c();
        }
    }

    @Override
    public void attachBaseContext(HookedActivity hookedActivity, Context context) {
        this.a = hookedActivity;
        hookedActivity.attachBaseContextReal(context);
    }

    @Override
    public boolean isLayoutInflaterFactoryInUse() {
        return false;
    }

    @Override
    public void onActivityResult(int i, int i2, Intent intent) {
        this.a.onMAMActivityResult(i, i2, intent);
    }

    @Override
    public void onCreate(Bundle bundle) {
        Intent intent = this.a.asActivity().getIntent();
        if (intent != null) {
            try {
                if (intent.hasExtra(e)) {
                    intent.setFlags(intent.getIntExtra(e, intent.getFlags()));
                }
            } catch (RuntimeException e2) {
                if (!(e2.getCause() instanceof ClassNotFoundException) && !(e2.getCause() instanceof BadParcelableException)) {
                    throw e2;
                }
                f.m("Exception when un-parceling intent extra, this can occur if a MAM app receives an intent that has a bad extra in it. This is not a MAM issue.We are just the first to hit it, continuing.", new Object[0]);
            }
        }
        if (g()) {
            ((AbstractC0489b) A.u(AbstractC0489b.class)).a(this.a.asActivity());
            this.a.onCreateReal(null);
        } else {
            this.a.onMAMCreate(bundle);
            this.c = true;
        }
    }

    @Override
    public boolean onCreateThumbnail(Bitmap bitmap, Canvas canvas) {
        return false;
    }

    @Override
    public View onCreateView(View view, String str, Context context, AttributeSet attributeSet) {
        return this.a.onMAMCreateView(view, str, context, attributeSet);
    }

    @Override
    public void onDestroy() {
        if (this.c) {
            this.a.onMAMDestroy();
        } else {
            this.a.onDestroyReal();
        }
    }

    @Override
    public void onMAMActivityResult(int i, int i2, Intent intent) {
        this.a.onActivityResultReal(i, i2, intent);
    }

    @Override
    public void onMAMCreate(Bundle bundle) {
        this.a.onCreateReal(bundle);
    }

    @Override
    public void onMAMDestroy() {
        this.a.onDestroyReal();
    }

    @Override
    public void onMAMIdentitySwitchRequired(MAMIdentity mAMIdentity, AppIdentitySwitchReason appIdentitySwitchReason, AppIdentitySwitchResultCallback appIdentitySwitchResultCallback) {
        appIdentitySwitchResultCallback.reportIdentitySwitchResult(AppIdentitySwitchResult.SUCCESS);
    }

    @Override
    public void onMAMNewIntent(Intent intent) {
        this.a.onNewIntentReal(intent);
    }

    @Override
    public void onMAMPause() {
        this.a.onPauseReal();
    }

    @Override
    public boolean onMAMPictureInPictureRequested() {
        return this.a.onPictureInPictureRequestedReal();
    }

    @Override
    public void onMAMPostCreate(Bundle bundle) {
        this.a.onPostCreateReal(bundle);
    }

    @Override
    public void onMAMPostResume() {
        this.a.onPostResumeReal();
    }

    @Override
    @TargetApi(23)
    public void onMAMProvideAssistContent(Object obj) {
        this.a.onProvideAssistContentReal((AssistContent) obj);
    }

    @Override
    public Uri onMAMProvideReferrer() {
        return this.a.onProvideReferrerReal();
    }

    @Override
    public void onMAMResume() {
        this.a.onResumeReal();
    }

    @Override
    public void onMAMSaveInstanceState(Bundle bundle) {
        this.a.onSaveInstanceStateReal(bundle);
    }

    @Override
    @TargetApi(23)
    public boolean onMAMSearchRequested(Object obj) {
        return this.a.onSearchRequestedReal((SearchEvent) obj);
    }

    @Override
    public void onMAMStateNotSaved() {
        this.a.onStateNotSavedReal();
    }

    @Override
    public void onMAMUserLeaveHint() {
        this.a.onUserLeaveHintReal();
    }

    @Override
    public void onNewIntent(Intent intent) {
        this.a.onMAMNewIntent(intent);
    }

    @Override
    public void onPause() {
        this.a.onMAMPause();
    }

    @Override
    public boolean onPictureInPictureRequested() {
        return this.c ? this.a.onMAMPictureInPictureRequested() : this.a.onPictureInPictureRequestedReal();
    }

    @Override
    public void onPostCreate(Bundle bundle) {
        if (this.c) {
            this.a.onMAMPostCreate(bundle);
        } else {
            this.a.onPostCreateReal(bundle);
        }
    }

    @Override
    public void onPostResume() {
        this.a.onMAMPostResume();
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        if (this.c) {
            return this.a.onMAMPrepareOptionsMenu(menu);
        }
        f.m("Not calling onMAMPrepareOptionsMenu(), blocking UI is being displayed.", new Object[0]);
        return this.a.onPrepareOptionsMenuReal(menu);
    }

    @Override
    public void onProvideAssistContent(Object obj) {
        this.a.onMAMRawProvideAssistContent(obj);
    }

    @Override
    public Uri onProvideReferrer() {
        return this.a.onMAMProvideReferrer();
    }

    @Override
    public void onResume() {
        if (!n()) {
            this.a.onMAMResume();
        } else {
            ((AbstractC0489b) A.u(AbstractC0489b.class)).b(this.a.asActivity());
            this.a.onResumeReal();
        }
    }

    @Override
    public void onSaveInstanceState(Bundle bundle) {
        this.a.onMAMSaveInstanceState(bundle);
    }

    @Override
    public boolean onSearchRequested(Object obj) {
        return this.a.onMAMRawSearchRequested(obj);
    }

    @Override
    public void onStateNotSaved() {
        this.a.onMAMStateNotSaved();
    }

    @Override
    public void onSwitchMAMIdentityComplete(MAMIdentitySwitchResult mAMIdentitySwitchResult) {
        if (mAMIdentitySwitchResult != MAMIdentitySwitchResult.SUCCEEDED) {
            f.m("Identity switch failed, finishing the activity.", new Object[0]);
            this.a.asActivity().finish();
        }
    }

    @Override
    public void onUserLeaveHint() {
        if (this.c) {
            this.a.onMAMUserLeaveHint();
        } else {
            this.a.onUserLeaveHintReal();
        }
    }

    @Override
    public void registerActivityLifecycleCallbacks(Application.ActivityLifecycleCallbacks activityLifecycleCallbacks) {
        this.a.registerActivityLifecycleCallbacksReal(com.microsoft.intune.mam.client.app.I.e(activityLifecycleCallbacks, true));
    }

    @Override
    public void startActivities(Intent[] intentArr, Bundle bundle) {
        this.a.startActivitiesReal(intentArr, bundle);
    }

    @Override
    public void startActivityForResult(Intent intent, int i) {
        this.a.startActivityForResultReal(intent, i);
    }

    @Override
    public void startActivityFromFragment(Fragment fragment, Intent intent, int i) {
        this.a.startActivityFromFragmentReal(fragment, intent, i);
    }

    @Override
    public boolean startActivityIfNeeded(Intent intent, int i) {
        return this.a.startActivityIfNeededReal(intent, i);
    }

    @Override
    public void switchMAMIdentity(MAMIdentity mAMIdentity, EnumSet<IdentitySwitchOption> enumSet) {
        MAMIdentity mAMOfflineIdentity = this.a.getMAMOfflineIdentity();
        this.a.setMAMOfflineIdentity(mAMIdentity);
        this.a.onSwitchMAMIdentityComplete(MAMIdentitySwitchResult.SUCCEEDED);
        if (mAMOfflineIdentity == null || !mAMOfflineIdentity.equals(mAMIdentity)) {
            g();
        }
    }

    @Override
    public void unregisterActivityLifecycleCallbacks(Application.ActivityLifecycleCallbacks activityLifecycleCallbacks) {
        this.a.unregisterActivityLifecycleCallbacksReal(com.microsoft.intune.mam.client.app.I.f(activityLifecycleCallbacks));
    }

    @Override
    public void startActivityForResult(Intent intent, int i, Bundle bundle) {
        this.a.startActivityForResultReal(intent, i, bundle);
    }

    @Override
    public void startActivityFromFragment(Fragment fragment, Intent intent, int i, Bundle bundle) {
        this.a.startActivityFromFragmentReal(fragment, intent, i, bundle);
    }

    @Override
    public boolean startActivityIfNeeded(Intent intent, int i, Bundle bundle) {
        return this.a.startActivityIfNeededReal(intent, i, bundle);
    }
}