diff --git a/core/java/android/os/Binder.java b/core/java/android/os/Binder.java
index 6178b2b..5533721 100644
--- a/core/java/android/os/Binder.java
+++ b/core/java/android/os/Binder.java
@@ -645,6 +645,17 @@
          * Called before onTransact.
          *
          * @return an object that will be passed back to #onTransactEnded (or null).
+         * @hide
+         */
+        @Nullable
+        default Object onTransactStarted(@NonNull IBinder binder, int transactionCode, int flags) {
+            return onTransactStarted(binder, transactionCode);
+        }
+
+        /**
+         * Called before onTransact.
+         *
+         * @return an object that will be passed back to #onTransactEnded (or null).
          */
         @Nullable
         Object onTransactStarted(@NonNull IBinder binder, int transactionCode);
diff --git a/core/java/android/os/BinderProxy.java b/core/java/android/os/BinderProxy.java
index 97c0a13..c74cef8 100644
--- a/core/java/android/os/BinderProxy.java
+++ b/core/java/android/os/BinderProxy.java
@@ -496,7 +496,7 @@
 
         if (transactListener != null) {
             final int origWorkSourceUid = Binder.getCallingWorkSourceUid();
-            session = transactListener.onTransactStarted(this, code);
+            session = transactListener.onTransactStarted(this, code, flags);
 
             // Allow the listener to update the work source uid. We need to update the request
             // header if the uid is updated.
diff --git a/packages/SystemUI/src/com/android/keyguard/CarrierTextController.java b/packages/SystemUI/src/com/android/keyguard/CarrierTextController.java
index 45126f3..107d5cc 100644
--- a/packages/SystemUI/src/com/android/keyguard/CarrierTextController.java
+++ b/packages/SystemUI/src/com/android/keyguard/CarrierTextController.java
@@ -19,6 +19,8 @@
 import static android.telephony.PhoneStateListener.LISTEN_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGE;
 import static android.telephony.PhoneStateListener.LISTEN_NONE;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
@@ -33,6 +35,8 @@
 import android.text.TextUtils;
 import android.util.Log;
 
+import androidx.annotation.VisibleForTesting;
+
 import com.android.internal.telephony.IccCardConstants;
 import com.android.internal.telephony.TelephonyIntents;
 import com.android.settingslib.WirelessUtils;
@@ -42,8 +46,6 @@
 import java.util.List;
 import java.util.Objects;
 
-import androidx.annotation.VisibleForTesting;
-
 /**
  * Controller that generates text including the carrier names and/or the status of all the SIM
  * interfaces in the device. Through a callback, the updates can be retrieved either as a list or
@@ -220,8 +222,9 @@
                 .getSystemService(Context.TELEPHONY_SERVICE));
         if (callback != null) {
             mCarrierTextCallback = callback;
-            if (ConnectivityManager.from(mContext).isNetworkSupported(
-                    ConnectivityManager.TYPE_MOBILE)) {
+            // TODO(b/140034799)
+            if (whitelistIpcs(() -> ConnectivityManager.from(mContext).isNetworkSupported(
+                    ConnectivityManager.TYPE_MOBILE))) {
                 mKeyguardUpdateMonitor = KeyguardUpdateMonitor.getInstance(mContext);
                 mKeyguardUpdateMonitor.registerCallback(mCallback);
                 mWakefulnessLifecycle.addObserver(mWakefulnessObserver);
diff --git a/packages/SystemUI/src/com/android/keyguard/EmergencyButton.java b/packages/SystemUI/src/com/android/keyguard/EmergencyButton.java
index 210b82d..979f3dc 100644
--- a/packages/SystemUI/src/com/android/keyguard/EmergencyButton.java
+++ b/packages/SystemUI/src/com/android/keyguard/EmergencyButton.java
@@ -16,6 +16,8 @@
 
 package com.android.keyguard;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.app.ActivityOptions;
 import android.app.ActivityTaskManager;
 import android.content.Context;
@@ -132,7 +134,7 @@
                 return false;
             }
         });
-        updateEmergencyCallButton();
+        whitelistIpcs(this::updateEmergencyCallButton);
     }
 
     @Override
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
index 169c97b..454f446 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
@@ -15,6 +15,8 @@
  */
 package com.android.keyguard;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.admin.DevicePolicyManager;
@@ -467,8 +469,8 @@
      * @param turningOff true if the device is being turned off
      */
     void showPrimarySecurityScreen(boolean turningOff) {
-        SecurityMode securityMode = mSecurityModel.getSecurityMode(
-                KeyguardUpdateMonitor.getCurrentUser());
+        SecurityMode securityMode = whitelistIpcs(() -> mSecurityModel.getSecurityMode(
+                KeyguardUpdateMonitor.getCurrentUser()));
         if (DEBUG) Log.v(TAG, "showPrimarySecurityScreen(turningOff=" + turningOff + ")");
         showSecurityScreen(securityMode);
     }
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityModel.java b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityModel.java
index 0cb6423..16e9ffc 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityModel.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityModel.java
@@ -15,6 +15,8 @@
  */
 package com.android.keyguard;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.app.admin.DevicePolicyManager;
 import android.content.Context;
 import android.telephony.SubscriptionManager;
@@ -67,7 +69,9 @@
             return SecurityMode.SimPin;
         }
 
-        final int security = mLockPatternUtils.getActivePasswordQuality(userId);
+        // TODO(b/140034863)
+        final int security = whitelistIpcs(() ->
+                mLockPatternUtils.getActivePasswordQuality(userId));
         switch (security) {
             case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC:
             case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX:
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardUpdateMonitor.java b/packages/SystemUI/src/com/android/keyguard/KeyguardUpdateMonitor.java
index 6da2a42..1714cd5 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardUpdateMonitor.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardUpdateMonitor.java
@@ -36,6 +36,7 @@
 import static com.android.internal.widget.LockPatternUtils.StrongAuthTracker.STRONG_AUTH_REQUIRED_AFTER_LOCKOUT;
 import static com.android.internal.widget.LockPatternUtils.StrongAuthTracker.STRONG_AUTH_REQUIRED_AFTER_TIMEOUT;
 import static com.android.internal.widget.LockPatternUtils.StrongAuthTracker.STRONG_AUTH_REQUIRED_AFTER_USER_LOCKDOWN;
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 
 import android.annotation.AnyThread;
 import android.annotation.MainThread;
@@ -997,9 +998,10 @@
     private boolean isFaceDisabled(int userId) {
         final DevicePolicyManager dpm =
                 (DevicePolicyManager) mContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
-        return dpm != null && (dpm.getKeyguardDisabledFeatures(null, userId)
+        // TODO(b/140035044)
+        return whitelistIpcs(() -> dpm != null && (dpm.getKeyguardDisabledFeatures(null, userId)
                 & DevicePolicyManager.KEYGUARD_DISABLE_FACE) != 0
-                || isSimPinSecure();
+                || isSimPinSecure());
     }
 
 
@@ -1884,9 +1886,10 @@
      * If face hardware is available, user has enrolled and enabled auth via setting.
      */
     public boolean isFaceAuthEnabledForUser(int userId) {
-        return mFaceManager != null && mFaceManager.isHardwareDetected()
+        // TODO(b/140034352)
+        return whitelistIpcs(() -> mFaceManager != null && mFaceManager.isHardwareDetected()
                 && mFaceManager.hasEnrolledTemplates(userId)
-                && mFaceSettingEnabledForUser.get(userId);
+                && mFaceSettingEnabledForUser.get(userId));
     }
 
     private void stopListeningForFingerprint() {
diff --git a/packages/SystemUI/src/com/android/keyguard/NumPadKey.java b/packages/SystemUI/src/com/android/keyguard/NumPadKey.java
index 08691ec..8109f47 100644
--- a/packages/SystemUI/src/com/android/keyguard/NumPadKey.java
+++ b/packages/SystemUI/src/com/android/keyguard/NumPadKey.java
@@ -16,6 +16,8 @@
 
 package com.android.keyguard;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.os.PowerManager;
@@ -90,7 +92,9 @@
         setOnClickListener(mListener);
         setOnHoverListener(new LiftToActivateListener(context));
 
-        mEnableHaptics = new LockPatternUtils(context).isTactileFeedbackEnabled();
+        // TODO(b/140043085)
+        mEnableHaptics = whitelistIpcs(() ->
+                new LockPatternUtils(context).isTactileFeedbackEnabled());
 
         mPM = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
         LayoutInflater inflater = (LayoutInflater) getContext().getSystemService(
diff --git a/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java b/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java
index ffa69fa..ce61a00 100644
--- a/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java
+++ b/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java
@@ -19,6 +19,7 @@
 import static android.app.StatusBarManager.DISABLE_NONE;
 import static android.provider.Settings.System.SHOW_BATTERY_PERCENT;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.util.SysuiLifecycle.viewAttachLifecycle;
 
 import static java.lang.annotation.RetentionPolicy.SOURCE;
@@ -382,9 +383,10 @@
 
     private void updateShowPercent() {
         final boolean showing = mBatteryPercentView != null;
-        final boolean systemSetting = 0 != Settings.System
+        // TODO(b/140051051)
+        final boolean systemSetting = 0 != whitelistIpcs(() -> Settings.System
                 .getIntForUser(getContext().getContentResolver(),
-                SHOW_BATTERY_PERCENT, 0, mUser);
+                SHOW_BATTERY_PERCENT, 0, mUser));
 
         if ((mShowPercentAvailable && systemSetting && mShowPercentMode != MODE_OFF)
                 || mShowPercentMode == MODE_ON || mShowPercentMode == MODE_ESTIMATE) {
diff --git a/packages/SystemUI/src/com/android/systemui/DejankUtils.java b/packages/SystemUI/src/com/android/systemui/DejankUtils.java
index bec8820..97578e1 100644
--- a/packages/SystemUI/src/com/android/systemui/DejankUtils.java
+++ b/packages/SystemUI/src/com/android/systemui/DejankUtils.java
@@ -16,39 +16,200 @@
 
 package com.android.systemui;
 
+import static android.os.IBinder.FLAG_ONEWAY;
+
+import static com.android.settingslib.utils.ThreadUtils.isMainThread;
+
+import android.annotation.MainThread;
+import android.os.Binder;
+import android.os.Binder.ProxyTransactListener;
+import android.os.Build;
 import android.os.Handler;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.os.StrictMode;
+import android.os.SystemProperties;
 import android.view.Choreographer;
 
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.systemui.util.Assert;
 
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Stack;
+import java.util.function.Supplier;
 
 /**
  * Utility class for methods used to dejank the UI.
  */
 public class DejankUtils {
 
+    public static final boolean STRICT_MODE_ENABLED = Build.IS_ENG
+            || SystemProperties.getBoolean("persist.sysui.strictmode", false);
     private static final Choreographer sChoreographer = Choreographer.getInstance();
     private static final Handler sHandler = new Handler();
     private static final ArrayList<Runnable> sPendingRunnables = new ArrayList<>();
+    private static Stack<String> sBlockingIpcs = new Stack<>();
+    private static boolean sTemporarilyIgnoreStrictMode;
+    private static final HashSet<String> sWhitelistedFrameworkClasses = new HashSet<>();
+    private static final Object sLock = new Object();
+    private static final ProxyTransactListener sProxy = new ProxyTransactListener() {
+        @Override
+        public Object onTransactStarted(IBinder binder, int transactionCode, int flags) {
+            synchronized (sLock) {
+                if ((flags & FLAG_ONEWAY) == FLAG_ONEWAY || sBlockingIpcs.empty()
+                        || !isMainThread() || sTemporarilyIgnoreStrictMode) {
+                    return null;
+                }
+
+                try {
+                    String description = binder.getInterfaceDescriptor();
+                    if (sWhitelistedFrameworkClasses.contains(description)) {
+                        return null;
+                    }
+                } catch (RemoteException e) {
+                    e.printStackTrace();
+                }
+
+                StrictMode.noteSlowCall("IPC detected on critical path: " + sBlockingIpcs.peek());
+                return null;
+            }
+        }
+
+        @Override
+        public Object onTransactStarted(IBinder binder, int transactionCode) {
+            return null;
+        }
+
+        @Override
+        public void onTransactEnded(Object o) {
+
+        }
+    };
 
     /**
      * Only for testing.
      */
     private static boolean sImmediate;
 
-    private static final Runnable sAnimationCallbackRunnable = new Runnable() {
-        @Override
-        public void run() {
-            for (int i = 0; i < sPendingRunnables.size(); i++) {
-                sHandler.post(sPendingRunnables.get(i));
-            }
-            sPendingRunnables.clear();
+    static {
+        if (STRICT_MODE_ENABLED) {
+            // Common IPCs that are ok to block the main thread.
+            sWhitelistedFrameworkClasses.add("android.view.IWindowSession");
+            sWhitelistedFrameworkClasses.add("com.android.internal.policy.IKeyguardStateCallback");
+            sWhitelistedFrameworkClasses.add("android.os.IPowerManager");
+            sWhitelistedFrameworkClasses.add("com.android.internal.statusbar.IStatusBarService");
+
+            Binder.setProxyTransactListener(sProxy);
+            StrictMode.ThreadPolicy.Builder builder = new StrictMode.ThreadPolicy.Builder()
+                    .detectCustomSlowCalls()
+                    .penaltyFlashScreen()
+                    .penaltyLog();
+            StrictMode.setThreadPolicy(builder.build());
         }
+    }
+
+    private static final Runnable sAnimationCallbackRunnable = () -> {
+        for (int i = 0; i < sPendingRunnables.size(); i++) {
+            sHandler.post(sPendingRunnables.get(i));
+        }
+        sPendingRunnables.clear();
     };
 
     /**
+     * Enable blocking-binder-call {@link StrictMode} for a {@link Runnable}.
+     *
+     * @param runnable Target.
+     */
+    @MainThread
+    public static void detectBlockingIpcs(Runnable runnable) {
+        if (STRICT_MODE_ENABLED && sBlockingIpcs.empty()) {
+            synchronized (sLock) {
+                sBlockingIpcs.push("detectBlockingIpcs");
+                try {
+                    runnable.run();
+                } finally {
+                    sBlockingIpcs.pop();
+                }
+            }
+        } else {
+            runnable.run();
+        }
+    }
+
+    /**
+     * Enable blocking-binder-call {@link StrictMode}.
+     *
+     * @param tag A key.
+     * @see #detectBlockingIpcs(Runnable)
+     */
+    @MainThread
+    public static void startDetectingBlockingIpcs(String tag) {
+        if (STRICT_MODE_ENABLED) {
+            synchronized (sLock) {
+                sBlockingIpcs.push(tag);
+            }
+        }
+    }
+
+    /**
+     * Stop IPC detection for a specific tag.
+     *
+     * @param tag The key.
+     * @see #startDetectingBlockingIpcs(String)
+     */
+    @MainThread
+    public static void stopDetectingBlockingIpcs(String tag) {
+        if (STRICT_MODE_ENABLED) {
+            synchronized (sLock) {
+                sBlockingIpcs.remove(tag);
+            }
+        }
+    }
+
+    /**
+     * Temporarily ignore blocking binder calls for contents of this {@link Runnable}.
+     *
+     * @param runnable Target.
+     */
+    @MainThread
+    public static void whitelistIpcs(Runnable runnable) {
+        if (STRICT_MODE_ENABLED && !sTemporarilyIgnoreStrictMode) {
+            synchronized (sLock) {
+                sTemporarilyIgnoreStrictMode = true;
+                try {
+                    runnable.run();
+                } finally {
+                    sTemporarilyIgnoreStrictMode = false;
+                }
+            }
+        } else {
+            runnable.run();
+        }
+    }
+
+    /**
+     * @see #whitelistIpcs(Runnable)
+     */
+    @MainThread
+    public static <T> T whitelistIpcs(Supplier<T> supplier) {
+        if (STRICT_MODE_ENABLED && !sTemporarilyIgnoreStrictMode) {
+            synchronized (sLock) {
+                sTemporarilyIgnoreStrictMode = true;
+                final T val;
+                try {
+                    val = supplier.get();
+                } finally {
+                    sTemporarilyIgnoreStrictMode = false;
+                }
+                return val;
+            }
+        } else {
+            return supplier.get();
+        }
+    }
+
+    /**
      * Executes {@code r} after performTraversals. Use this do to CPU heavy work for which the
      * timing is not critical for animation. The work is then scheduled at the same time
      * RenderThread is doing its thing, leading to better parallelization.
diff --git a/packages/SystemUI/src/com/android/systemui/SystemUIApplication.java b/packages/SystemUI/src/com/android/systemui/SystemUIApplication.java
index f8449ad..0b1fe69 100644
--- a/packages/SystemUI/src/com/android/systemui/SystemUIApplication.java
+++ b/packages/SystemUI/src/com/android/systemui/SystemUIApplication.java
@@ -74,7 +74,6 @@
         // the theme set there.
         setTheme(R.style.Theme_SystemUI);
 
-
         if (Process.myUserHandle().equals(UserHandle.SYSTEM)) {
             IntentFilter bootCompletedFilter = new IntentFilter(Intent.ACTION_BOOT_COMPLETED);
             bootCompletedFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
diff --git a/packages/SystemUI/src/com/android/systemui/assist/AssistHandleReminderExpBehavior.java b/packages/SystemUI/src/com/android/systemui/assist/AssistHandleReminderExpBehavior.java
index f9ddeae..28fae63 100644
--- a/packages/SystemUI/src/com/android/systemui/assist/AssistHandleReminderExpBehavior.java
+++ b/packages/SystemUI/src/com/android/systemui/assist/AssistHandleReminderExpBehavior.java
@@ -16,6 +16,8 @@
 
 package com.android.systemui.assist;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.app.ActivityManager;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
@@ -365,8 +367,9 @@
         long currentTimestamp = SystemClock.uptimeMillis();
         mLearningTimeElapsed += currentTimestamp - mLastLearningTimestamp;
         mLastLearningTimestamp = currentTimestamp;
-        Settings.Secure.putLong(
-                mContext.getContentResolver(), LEARNING_TIME_ELAPSED_KEY, mLearningTimeElapsed);
+        // TODO(b/140034473)
+        whitelistIpcs(() -> Settings.Secure.putLong(
+                mContext.getContentResolver(), LEARNING_TIME_ELAPSED_KEY, mLearningTimeElapsed));
 
         mIsLearned =
                 mLearningCount >= getLearningCount() || mLearningTimeElapsed >= getLearningTimeMs();
diff --git a/packages/SystemUI/src/com/android/systemui/assist/AssistManager.java b/packages/SystemUI/src/com/android/systemui/assist/AssistManager.java
index ac32d4d..c4feac1 100644
--- a/packages/SystemUI/src/com/android/systemui/assist/AssistManager.java
+++ b/packages/SystemUI/src/com/android/systemui/assist/AssistManager.java
@@ -1,5 +1,7 @@
 package com.android.systemui.assist;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.app.ActivityManager;
@@ -374,7 +376,8 @@
     }
 
     public boolean canVoiceAssistBeLaunchedFromKeyguard() {
-        return mAssistUtils.activeServiceSupportsLaunchFromKeyguard();
+        // TODO(b/140051519)
+        return whitelistIpcs(() -> mAssistUtils.activeServiceSupportsLaunchFromKeyguard());
     }
 
     public ComponentName getVoiceInteractorComponentName() {
@@ -442,7 +445,8 @@
     }
 
     public void onLockscreenShown() {
-        mAssistUtils.onLockscreenShown();
+        // TODO(b/140052478)
+        whitelistIpcs(mAssistUtils::onLockscreenShown);
     }
 
     public long getAssistHandleShowAndGoRemainingDurationMs() {
diff --git a/packages/SystemUI/src/com/android/systemui/assist/PhenotypeHelper.java b/packages/SystemUI/src/com/android/systemui/assist/PhenotypeHelper.java
index b3f57af..c21a717 100644
--- a/packages/SystemUI/src/com/android/systemui/assist/PhenotypeHelper.java
+++ b/packages/SystemUI/src/com/android/systemui/assist/PhenotypeHelper.java
@@ -16,6 +16,8 @@
 
 package com.android.systemui.assist;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.provider.DeviceConfig;
 
 import androidx.annotation.Nullable;
@@ -27,20 +29,24 @@
     public PhenotypeHelper() {}
 
     public long getLong(String name, long defaultValue) {
-        return DeviceConfig.getLong(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue);
+        return whitelistIpcs(() ->
+                DeviceConfig.getLong(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue));
     }
 
     public int getInt(String name, int defaultValue) {
-        return DeviceConfig.getInt(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue);
+        return whitelistIpcs(() ->
+                DeviceConfig.getInt(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue));
     }
 
     @Nullable
     public String getString(String name, @Nullable String defaultValue) {
-        return DeviceConfig.getString(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue);
+        return whitelistIpcs(() ->
+                DeviceConfig.getString(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue));
     }
 
     public boolean getBoolean(String name, boolean defaultValue) {
-        return DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue);
+        return whitelistIpcs(() ->
+                DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, name, defaultValue));
     }
 
     public void addOnPropertiesChangedListener(
diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java b/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java
index 36c3cc6..4016b59 100644
--- a/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java
+++ b/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java
@@ -25,6 +25,7 @@
 import static com.android.internal.widget.LockPatternUtils.StrongAuthTracker.STRONG_AUTH_REQUIRED_AFTER_DPM_LOCK_NOW;
 import static com.android.internal.widget.LockPatternUtils.StrongAuthTracker.STRONG_AUTH_REQUIRED_AFTER_LOCKOUT;
 import static com.android.internal.widget.LockPatternUtils.StrongAuthTracker.STRONG_AUTH_REQUIRED_AFTER_TIMEOUT;
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 
 import android.app.ActivityManager;
 import android.app.ActivityTaskManager;
@@ -643,26 +644,29 @@
 
         @Override
         public int getBouncerPromptReason() {
-            int currentUser = ActivityManager.getCurrentUser();
-            boolean trust = mTrustManager.isTrustUsuallyManaged(currentUser);
-            boolean biometrics = mUpdateMonitor.isUnlockingWithBiometricsPossible(currentUser);
-            boolean any = trust || biometrics;
-            KeyguardUpdateMonitor.StrongAuthTracker strongAuthTracker =
-                    mUpdateMonitor.getStrongAuthTracker();
-            int strongAuth = strongAuthTracker.getStrongAuthForUser(currentUser);
+            // TODO(b/140053364)
+            return whitelistIpcs(() -> {
+                int currentUser = ActivityManager.getCurrentUser();
+                boolean trust = mTrustManager.isTrustUsuallyManaged(currentUser);
+                boolean biometrics = mUpdateMonitor.isUnlockingWithBiometricsPossible(currentUser);
+                boolean any = trust || biometrics;
+                KeyguardUpdateMonitor.StrongAuthTracker strongAuthTracker =
+                        mUpdateMonitor.getStrongAuthTracker();
+                int strongAuth = strongAuthTracker.getStrongAuthForUser(currentUser);
 
-            if (any && !strongAuthTracker.hasUserAuthenticatedSinceBoot()) {
-                return KeyguardSecurityView.PROMPT_REASON_RESTART;
-            } else if (any && (strongAuth & STRONG_AUTH_REQUIRED_AFTER_TIMEOUT) != 0) {
-                return KeyguardSecurityView.PROMPT_REASON_TIMEOUT;
-            } else if (any && (strongAuth & STRONG_AUTH_REQUIRED_AFTER_DPM_LOCK_NOW) != 0) {
-                return KeyguardSecurityView.PROMPT_REASON_DEVICE_ADMIN;
-            } else if (trust && (strongAuth & SOME_AUTH_REQUIRED_AFTER_USER_REQUEST) != 0) {
-                return KeyguardSecurityView.PROMPT_REASON_USER_REQUEST;
-            } else if (any && (strongAuth & STRONG_AUTH_REQUIRED_AFTER_LOCKOUT) != 0) {
-                return KeyguardSecurityView.PROMPT_REASON_AFTER_LOCKOUT;
-            }
-            return KeyguardSecurityView.PROMPT_REASON_NONE;
+                if (any && !strongAuthTracker.hasUserAuthenticatedSinceBoot()) {
+                    return KeyguardSecurityView.PROMPT_REASON_RESTART;
+                } else if (any && (strongAuth & STRONG_AUTH_REQUIRED_AFTER_TIMEOUT) != 0) {
+                    return KeyguardSecurityView.PROMPT_REASON_TIMEOUT;
+                } else if (any && (strongAuth & STRONG_AUTH_REQUIRED_AFTER_DPM_LOCK_NOW) != 0) {
+                    return KeyguardSecurityView.PROMPT_REASON_DEVICE_ADMIN;
+                } else if (trust && (strongAuth & SOME_AUTH_REQUIRED_AFTER_USER_REQUEST) != 0) {
+                    return KeyguardSecurityView.PROMPT_REASON_USER_REQUEST;
+                } else if (any && (strongAuth & STRONG_AUTH_REQUIRED_AFTER_LOCKOUT) != 0) {
+                    return KeyguardSecurityView.PROMPT_REASON_AFTER_LOCKOUT;
+                }
+                return KeyguardSecurityView.PROMPT_REASON_NONE;
+            });
         }
 
         @Override
@@ -2172,18 +2176,21 @@
     }
 
     private void notifyDefaultDisplayCallbacks(boolean showing) {
-        int size = mKeyguardStateCallbacks.size();
-        for (int i = size - 1; i >= 0; i--) {
-            IKeyguardStateCallback callback = mKeyguardStateCallbacks.get(i);
-            try {
-                callback.onShowingStateChanged(showing);
-            } catch (RemoteException e) {
-                Slog.w(TAG, "Failed to call onShowingStateChanged", e);
-                if (e instanceof DeadObjectException) {
-                    mKeyguardStateCallbacks.remove(callback);
+        // TODO(b/140053364)
+        whitelistIpcs(() -> {
+            int size = mKeyguardStateCallbacks.size();
+            for (int i = size - 1; i >= 0; i--) {
+                IKeyguardStateCallback callback = mKeyguardStateCallbacks.get(i);
+                try {
+                    callback.onShowingStateChanged(showing);
+                } catch (RemoteException e) {
+                    Slog.w(TAG, "Failed to call onShowingStateChanged", e);
+                    if (e instanceof DeadObjectException) {
+                        mKeyguardStateCallbacks.remove(callback);
+                    }
                 }
             }
-        }
+        });
         updateInputRestrictedLocked();
         mUiOffloadThread.submit(() -> {
             mTrustManager.reportKeyguardShowingChanged();
diff --git a/packages/SystemUI/src/com/android/systemui/qs/QSCarrierGroup.java b/packages/SystemUI/src/com/android/systemui/qs/QSCarrierGroup.java
index 4571ef3..8c21dde 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/QSCarrierGroup.java
+++ b/packages/SystemUI/src/com/android/systemui/qs/QSCarrierGroup.java
@@ -16,6 +16,7 @@
 
 package com.android.systemui.qs;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.util.InjectionInflationController.VIEW_CONTEXT;
 
 import android.content.Context;
@@ -109,7 +110,8 @@
             return;
         }
         mListening = listening;
-        updateListeners();
+        // TODO(b/140053526)
+        whitelistIpcs(this::updateListeners);
     }
 
     @Override
diff --git a/packages/SystemUI/src/com/android/systemui/qs/QuickQSPanel.java b/packages/SystemUI/src/com/android/systemui/qs/QuickQSPanel.java
index f1e9c87..37113cf 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/QuickQSPanel.java
+++ b/packages/SystemUI/src/com/android/systemui/qs/QuickQSPanel.java
@@ -16,6 +16,7 @@
 
 package com.android.systemui.qs;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.util.InjectionInflationController.VIEW_CONTEXT;
 
 import android.content.Context;
@@ -164,7 +165,9 @@
     };
 
     public static int getNumQuickTiles(Context context) {
-        return Dependency.get(TunerService.class).getValue(NUM_QUICK_TILES, mDefaultMaxTiles);
+        // TODO(b/140052679)
+        return whitelistIpcs(() ->
+                Dependency.get(TunerService.class).getValue(NUM_QUICK_TILES, mDefaultMaxTiles));
     }
 
     void setDisabledByPolicy(boolean disabled) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java b/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java
index bba64d9..9ac7ae9 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java
@@ -16,6 +16,8 @@
 
 package com.android.systemui.statusbar;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.app.admin.DevicePolicyManager;
@@ -234,7 +236,8 @@
             return;
         }
 
-        if (!mDozing && mDevicePolicyManager.isDeviceManaged()) {
+        // TODO(b/140053632)
+        if (!mDozing && whitelistIpcs(mDevicePolicyManager::isDeviceManaged)) {
             final CharSequence organizationName =
                     mDevicePolicyManager.getDeviceOwnerOrganizationName();
             if (organizationName != null) {
@@ -381,7 +384,8 @@
             int userId = KeyguardUpdateMonitor.getCurrentUser();
             String trustGrantedIndication = getTrustGrantedIndication();
             String trustManagedIndication = getTrustManagedIndication();
-            if (!mUserManager.isUserUnlocked(userId)) {
+            // TODO(b/140053632)
+            if (!whitelistIpcs(() -> mUserManager.isUserUnlocked(userId))) {
                 mTextView.switchIndication(com.android.internal.R.string.lockscreen_storage_locked);
                 mTextView.setTextColor(mInitialTextColorState);
             } else if (!TextUtils.isEmpty(mTransientIndication)) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationLockscreenUserManagerImpl.java b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationLockscreenUserManagerImpl.java
index 802a7d2..107b24c 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationLockscreenUserManagerImpl.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationLockscreenUserManagerImpl.java
@@ -17,6 +17,8 @@
 
 import static android.app.admin.DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.app.ActivityManager;
 import android.app.KeyguardManager;
 import android.app.Notification;
@@ -323,8 +325,9 @@
     }
 
     private boolean hideSilentNotificationsOnLockscreen() {
-        return Settings.Secure.getInt(mContext.getContentResolver(),
-                Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1) == 0;
+        // TODO(b/140058091)
+        return whitelistIpcs(() -> Settings.Secure.getInt(mContext.getContentResolver(),
+                Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1) == 0);
     }
 
     private void setShowLockscreenNotifications(boolean show) {
@@ -515,8 +518,9 @@
         for (int i = currentProfiles.size() - 1; i >= 0; i--) {
             final int userId = currentProfiles.valueAt(i).id;
             boolean isProfilePublic = devicePublic;
-            boolean needsSeparateChallenge = mLockPatternUtils.isSeparateProfileChallengeEnabled(
-                    userId);
+            // TODO(b/140058091)
+            boolean needsSeparateChallenge = whitelistIpcs(() ->
+                    mLockPatternUtils.isSeparateProfileChallengeEnabled(userId));
             if (!devicePublic && userId != getCurrentUserId()
                     && needsSeparateChallenge && isSecure(userId)) {
                 // Keyguard.isDeviceLocked is updated asynchronously, assume that all profiles
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/StatusBarStateControllerImpl.java b/packages/SystemUI/src/com/android/systemui/statusbar/StatusBarStateControllerImpl.java
index f0eeb04..4422a81 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/StatusBarStateControllerImpl.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/StatusBarStateControllerImpl.java
@@ -24,6 +24,7 @@
 import android.view.animation.Interpolator;
 
 import com.android.internal.annotations.GuardedBy;
+import com.android.systemui.DejankUtils;
 import com.android.systemui.Dumpable;
 import com.android.systemui.Interpolators;
 import com.android.systemui.plugins.statusbar.StatusBarStateController.StateListener;
@@ -137,6 +138,8 @@
         recordHistoricalState(state, mState);
 
         synchronized (mListeners) {
+            String tag = getClass().getSimpleName() + "#setState(" + state + ")";
+            DejankUtils.startDetectingBlockingIpcs(tag);
             for (RankedListener rl : new ArrayList<>(mListeners)) {
                 rl.mListener.onStatePreChange(mState, state);
             }
@@ -149,6 +152,7 @@
             for (RankedListener rl : new ArrayList<>(mListeners)) {
                 rl.mListener.onStatePostChange();
             }
+            DejankUtils.stopDetectingBlockingIpcs(tag);
         }
 
         return true;
@@ -178,9 +182,12 @@
         mIsDozing = isDozing;
 
         synchronized (mListeners) {
+            String tag = getClass().getSimpleName() + "#setIsDozing";
+            DejankUtils.startDetectingBlockingIpcs(tag);
             for (RankedListener rl : new ArrayList<>(mListeners)) {
                 rl.mListener.onDozingChanged(isDozing);
             }
+            DejankUtils.stopDetectingBlockingIpcs(tag);
         }
 
         return true;
@@ -220,9 +227,12 @@
         mDozeAmount = dozeAmount;
         float interpolatedAmount = mDozeInterpolator.getInterpolation(dozeAmount);
         synchronized (mListeners) {
+            String tag = getClass().getSimpleName() + "#setDozeAmount";
+            DejankUtils.startDetectingBlockingIpcs(tag);
             for (RankedListener rl : new ArrayList<>(mListeners)) {
                 rl.mListener.onDozeAmountChanged(mDozeAmount, interpolatedAmount);
             }
+            DejankUtils.stopDetectingBlockingIpcs(tag);
         }
     }
 
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
index 80d36a1..23b4814 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
@@ -19,6 +19,7 @@
 import static android.view.accessibility.AccessibilityNodeInfo.ACTION_CLICK;
 import static android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.doze.util.BurnInHelperKt.getBurnInOffset;
 import static com.android.systemui.tuner.LockscreenFragment.LOCKSCREEN_LEFT_BUTTON;
 import static com.android.systemui.tuner.LockscreenFragment.LOCKSCREEN_LEFT_UNLOCK;
@@ -76,7 +77,6 @@
 import com.android.systemui.plugins.IntentButtonProvider.IntentButton;
 import com.android.systemui.plugins.IntentButtonProvider.IntentButton.IconState;
 import com.android.systemui.statusbar.KeyguardAffordanceView;
-import com.android.systemui.statusbar.KeyguardIndicationController;
 import com.android.systemui.statusbar.policy.AccessibilityController;
 import com.android.systemui.statusbar.policy.ExtensionController;
 import com.android.systemui.statusbar.policy.ExtensionController.Extension;
@@ -365,9 +365,11 @@
      * Resolves the intent to launch the camera application.
      */
     public ResolveInfo resolveCameraIntent() {
-        return mContext.getPackageManager().resolveActivityAsUser(getCameraIntent(),
-                PackageManager.MATCH_DEFAULT_ONLY,
-                KeyguardUpdateMonitor.getCurrentUser());
+        // TODO(b/140057230)
+        return whitelistIpcs(() ->
+                mContext.getPackageManager().resolveActivityAsUser(getCameraIntent(),
+                    PackageManager.MATCH_DEFAULT_ONLY,
+                    KeyguardUpdateMonitor.getCurrentUser()));
     }
 
     private void updateCameraVisibility() {
@@ -820,7 +822,9 @@
             KeyguardUpdateMonitor updateMonitor = KeyguardUpdateMonitor.getInstance(mContext);
             boolean canSkipBouncer = updateMonitor.getUserCanSkipBouncer(
                     KeyguardUpdateMonitor.getCurrentUser());
-            boolean secure = mLockPatternUtils.isSecure(KeyguardUpdateMonitor.getCurrentUser());
+            // TODO(b/140057230)
+            boolean secure = whitelistIpcs(() ->
+                    mLockPatternUtils.isSecure(KeyguardUpdateMonitor.getCurrentUser()));
             return (secure && !canSkipBouncer) ? SECURE_CAMERA_INTENT : INSECURE_CAMERA_INTENT;
         }
     }
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java
index dc9b373..2e7ba045c 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java
@@ -17,6 +17,7 @@
 package com.android.systemui.statusbar.phone;
 
 import static com.android.keyguard.KeyguardSecurityModel.SecurityMode;
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.plugins.ActivityStarter.OnDismissAction;
 
 import android.content.Context;
@@ -468,12 +469,15 @@
      * notifications on Keyguard, like SIM PIN/PUK.
      */
     public boolean needsFullscreenBouncer() {
-        ensureView();
-        if (mKeyguardView != null) {
-            SecurityMode mode = mKeyguardView.getSecurityMode();
-            return mode == SecurityMode.SimPin || mode == SecurityMode.SimPuk;
-        }
-        return false;
+        // TODO(b/140059518)
+        return whitelistIpcs(() -> {
+            ensureView();
+            if (mKeyguardView != null) {
+                SecurityMode mode = mKeyguardView.getSecurityMode();
+                return mode == SecurityMode.SimPin || mode == SecurityMode.SimPuk;
+            }
+            return false;
+        });
     }
 
     /**
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/MultiUserSwitch.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/MultiUserSwitch.java
index 1d4d0bd..dcc3107 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/MultiUserSwitch.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/MultiUserSwitch.java
@@ -16,6 +16,8 @@
 
 package com.android.systemui.statusbar.phone;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
+
 import android.app.admin.DevicePolicyManager;
 import android.content.Context;
 import android.os.UserManager;
@@ -98,25 +100,30 @@
         // Short-circuiting from UserManager. Needs to be extracted because of SystemUI boolean flag
         // qs_show_user_switcher_for_single_user
 
-        // The default in UserManager is to show the switcher. We want to not show it unless the
-        // user explicitly requests it in Settings
-        final boolean userSwitcherEnabled = Settings.Global.getInt(mContext.getContentResolver(),
-                Settings.Global.USER_SWITCHER_ENABLED, 0) != 0;
-
         // TODO(b/138661450) Move IPC calls to background
-        if (!userSwitcherEnabled
-                || !UserManager.supportsMultipleUsers()
-                || UserManager.isDeviceInDemoMode(mContext)
-                || mUserManager.hasUserRestriction(UserManager.DISALLOW_USER_SWITCH)) {
-            return false;
-        }
+        return whitelistIpcs(() -> {
+            // The default in UserManager is to show the switcher. We want to not show it unless the
+            // user explicitly requests it in Settings
+            final boolean userSwitcherEnabled = Settings.Global.getInt(
+                    mContext.getContentResolver(),
+                    Settings.Global.USER_SWITCHER_ENABLED, 0) != 0;
 
-        final boolean guestEnabled = !mContext.getSystemService(DevicePolicyManager.class)
-                .getGuestUserDisabled(null);
-        return mUserSwitcherController.getSwitchableUserCount() > 1
-                // If we cannot add guests even if they are enabled, do not show
-                || (guestEnabled && !mUserManager.hasUserRestriction(UserManager.DISALLOW_ADD_USER))
-                || mContext.getResources().getBoolean(R.bool.qs_show_user_switcher_for_single_user);
+            if (!userSwitcherEnabled
+                    || !UserManager.supportsMultipleUsers()
+                    || UserManager.isDeviceInDemoMode(mContext)
+                    || mUserManager.hasUserRestriction(UserManager.DISALLOW_USER_SWITCH)) {
+                return false;
+            }
+
+            final boolean guestEnabled = !mContext.getSystemService(DevicePolicyManager.class)
+                    .getGuestUserDisabled(null);
+            return mUserSwitcherController.getSwitchableUserCount() > 1
+                    // If we cannot add guests even if they are enabled, do not show
+                    || (guestEnabled && !mUserManager.hasUserRestriction(
+                    UserManager.DISALLOW_ADD_USER))
+                    || mContext.getResources().getBoolean(
+                    R.bool.qs_show_user_switcher_for_single_user);
+        });
     }
 
     private void registerListener() {
@@ -167,7 +174,8 @@
 
     private void refreshContentDescription() {
         String currentUser = null;
-        if (mUserManager.isUserSwitcherEnabled()
+        // TODO(b/138661450)
+        if (whitelistIpcs(mUserManager::isUserSwitcherEnabled)
                 && mUserSwitcherController != null) {
             currentUser = mUserSwitcherController.getCurrentUserName(mContext);
         }
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java
index c76cdcb..248bc75 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java
@@ -666,6 +666,7 @@
 
     @Override
     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        DejankUtils.startDetectingBlockingIpcs("NVP#onLayout");
         super.onLayout(changed, left, top, right, bottom);
         setIsFullWidth(mNotificationStackScroller.getWidth() == getWidth());
 
@@ -712,6 +713,7 @@
             mExpandAfterLayoutRunnable.run();
             mExpandAfterLayoutRunnable = null;
         }
+        DejankUtils.stopDetectingBlockingIpcs("NVP#onLayout");
     }
 
     private void updateGestureExclusionRect() {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
index 4c5b464..9fc3e47 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
@@ -25,6 +25,7 @@
 import static android.app.StatusBarManager.windowStateToString;
 import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.Dependency.ALLOW_NOTIFICATION_LONG_PRESS_NAME;
 import static com.android.systemui.Dependency.BG_HANDLER;
 import static com.android.systemui.Dependency.MAIN_HANDLER;
@@ -131,6 +132,7 @@
 import com.android.systemui.ActivityIntentHelper;
 import com.android.systemui.ActivityStarterDelegate;
 import com.android.systemui.AutoReinflateContainer;
+import com.android.systemui.DejankUtils;
 import com.android.systemui.DemoMode;
 import com.android.systemui.Dependency;
 import com.android.systemui.Dumpable;
@@ -3680,16 +3682,21 @@
 
         @Override
         public void onStartedGoingToSleep() {
+            String tag = "StatusBar#onStartedGoingToSleep";
+            DejankUtils.startDetectingBlockingIpcs(tag);
             updateNotificationPanelTouchState();
             notifyHeadsUpGoingToSleep();
             dismissVolumeDialog();
             mWakeUpCoordinator.setFullyAwake(false);
             mBypassHeadsUpNotifier.setFullyAwake(false);
             mKeyguardBypassController.onStartedGoingToSleep();
+            DejankUtils.stopDetectingBlockingIpcs(tag);
         }
 
         @Override
         public void onStartedWakingUp() {
+            String tag = "StatusBar#onStartedWakingUp";
+            DejankUtils.startDetectingBlockingIpcs(tag);
             mDeviceInteractive = true;
             mWakeUpCoordinator.setWakingUp(true);
             if (!mKeyguardBypassController.getBypassEnabled()) {
@@ -3704,6 +3711,7 @@
             // once we fully woke up.
             updateNotificationPanelTouchState();
             mPulseExpansionHandler.onStartedWakingUp();
+            DejankUtils.stopDetectingBlockingIpcs(tag);
         }
 
         @Override
@@ -3854,18 +3862,20 @@
     }
 
     boolean isCameraAllowedByAdmin() {
-        if (mDevicePolicyManager.getCameraDisabled(null,
-                mLockscreenUserManager.getCurrentUserId())) {
-            return false;
-        } else if (mStatusBarKeyguardViewManager == null ||
-                (isKeyguardShowing() && isKeyguardSecure())) {
-            // Check if the admin has disabled the camera specifically for the keyguard
-            return (mDevicePolicyManager.
-                    getKeyguardDisabledFeatures(null, mLockscreenUserManager.getCurrentUserId())
-                    & DevicePolicyManager.KEYGUARD_DISABLE_SECURE_CAMERA) == 0;
-        }
-
-        return true;
+        // TODO(b/140060745)
+        return whitelistIpcs(() -> {
+            if (mDevicePolicyManager.getCameraDisabled(null,
+                    mLockscreenUserManager.getCurrentUserId())) {
+                return false;
+            } else if (mStatusBarKeyguardViewManager == null
+                    || (isKeyguardShowing() && isKeyguardSecure())) {
+                // Check if the admin has disabled the camera specifically for the keyguard
+                return (mDevicePolicyManager.getKeyguardDisabledFeatures(null,
+                        mLockscreenUserManager.getCurrentUserId())
+                        & DevicePolicyManager.KEYGUARD_DISABLE_SECURE_CAMERA) == 0;
+            }
+            return true;
+        });
     }
 
     private boolean isGoingToSleep() {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java
index 0ef981b..e85b147 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java
@@ -18,6 +18,7 @@
 
 import static android.view.WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS;
 
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.statusbar.NotificationRemoteInputManager.ENABLE_REMOTE_INPUT;
 
 import android.app.ActivityManager;
@@ -370,12 +371,14 @@
             mWindowManager.updateViewLayout(mStatusBarView, mLp);
         }
         if (mHasTopUi != mHasTopUiChanged) {
-            try {
-                mActivityManager.setHasTopUi(mHasTopUiChanged);
-            } catch (RemoteException e) {
-                Log.e(TAG, "Failed to call setHasTopUi", e);
-            }
-            mHasTopUi = mHasTopUiChanged;
+            whitelistIpcs(() -> {
+                try {
+                    mActivityManager.setHasTopUi(mHasTopUiChanged);
+                } catch (RemoteException e) {
+                    Log.e(TAG, "Failed to call setHasTopUi", e);
+                }
+                mHasTopUi = mHasTopUiChanged;
+            });
         }
         notifyStateChangedCallbacks();
     }
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowView.java
index 6789930..7a81ed4 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowView.java
@@ -65,8 +65,6 @@
 import com.android.systemui.plugins.FalsingManager;
 import com.android.systemui.plugins.statusbar.StatusBarStateController;
 import com.android.systemui.statusbar.DragDownHelper;
-import com.android.systemui.statusbar.StatusBarState;
-import com.android.systemui.statusbar.notification.DynamicPrivacyController;
 import com.android.systemui.statusbar.notification.stack.NotificationStackScrollLayout;
 import com.android.systemui.statusbar.phone.ScrimController.ScrimVisibility;
 import com.android.systemui.tuner.TunerService;
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/UnlockMethodCache.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/UnlockMethodCache.java
index b1d6ca6..24ecd14 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/UnlockMethodCache.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/UnlockMethodCache.java
@@ -27,6 +27,7 @@
 import com.android.internal.widget.LockPatternUtils;
 import com.android.keyguard.KeyguardUpdateMonitor;
 import com.android.keyguard.KeyguardUpdateMonitorCallback;
+import com.android.systemui.DejankUtils;
 
 import java.io.PrintWriter;
 import java.util.ArrayList;
@@ -133,15 +134,20 @@
             mTrusted = trusted;
             mTrustManaged = trustManaged;
             mFaceAuthEnabled = faceAuthEnabled;
+            Trace.endSection();
             notifyListeners();
+        } else {
+            Trace.endSection();
         }
-        Trace.endSection();
     }
 
     private void notifyListeners() {
+        String tag = "UnlockMethodCache#notifyListeners";
+        DejankUtils.startDetectingBlockingIpcs(tag);
         for (OnUnlockMethodChangedListener listener : mListeners) {
             listener.onUnlockMethodStateChanged();
         }
+        DejankUtils.stopDetectingBlockingIpcs(tag);
     }
 
     public void dump(PrintWriter pw) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/policy/UserSwitcherController.java b/packages/SystemUI/src/com/android/systemui/statusbar/policy/UserSwitcherController.java
index 395add7..2e1e520 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/policy/UserSwitcherController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/policy/UserSwitcherController.java
@@ -17,6 +17,7 @@
 package com.android.systemui.statusbar.policy;
 
 import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
+import static com.android.systemui.DejankUtils.whitelistIpcs;
 import static com.android.systemui.Dependency.MAIN_HANDLER_NAME;
 
 import android.app.ActivityManager;
@@ -313,9 +314,10 @@
         // adb shell settings put system enable_fullscreen_user_switcher 1  # Turn it on.
         // Restart SystemUI or adb reboot.
         final int DEFAULT = -1;
+        // TODO(b/140061064)
         final int overrideUseFullscreenUserSwitcher =
-                Settings.System.getInt(mContext.getContentResolver(),
-                        "enable_fullscreen_user_switcher", DEFAULT);
+                whitelistIpcs(() -> Settings.System.getInt(mContext.getContentResolver(),
+                        "enable_fullscreen_user_switcher", DEFAULT));
         if (overrideUseFullscreenUserSwitcher != DEFAULT) {
             return overrideUseFullscreenUserSwitcher != 0;
         }
diff --git a/packages/SystemUI/src/com/android/systemui/tuner/TunerServiceImpl.java b/packages/SystemUI/src/com/android/systemui/tuner/TunerServiceImpl.java
index aa4dcc0..a55e2cf 100644
--- a/packages/SystemUI/src/com/android/systemui/tuner/TunerServiceImpl.java
+++ b/packages/SystemUI/src/com/android/systemui/tuner/TunerServiceImpl.java
@@ -34,6 +34,7 @@
 import android.util.ArraySet;
 
 import com.android.internal.util.ArrayUtils;
+import com.android.systemui.DejankUtils;
 import com.android.systemui.DemoMode;
 import com.android.systemui.qs.QSTileHost;
 import com.android.systemui.settings.CurrentUserTracker;
@@ -189,7 +190,8 @@
             mContentResolver.registerContentObserver(uri, false, mObserver, mCurrentUser);
         }
         // Send the first state.
-        String value = Settings.Secure.getStringForUser(mContentResolver, key, mCurrentUser);
+        String value = DejankUtils.whitelistIpcs(() -> Settings.Secure
+                .getStringForUser(mContentResolver, key, mCurrentUser));
         tunable.onTuningChanged(key, value);
     }
 
