Java Code Examples for android.util.Slog#i()

private void boostScreenBrightnessInternal(long eventTime, int uid) {
    synchronized (mLock) {
        if (!mSystemReady || mWakefulness == WAKEFULNESS_ASLEEP
                || eventTime < mLastScreenBrightnessBoostTime) {
            return;
        }

        Slog.i(TAG, "Brightness boost activated (uid " + uid +")...");
        mLastScreenBrightnessBoostTime = eventTime;
        if (!mScreenBrightnessBoostInProgress) {
            mScreenBrightnessBoostInProgress = true;
            mNotifier.onScreenBrightnessBoostChanged();
        }
        mDirty |= DIRTY_SCREEN_BRIGHTNESS_BOOST;

        userActivityNoUpdateLocked(eventTime,
                PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, uid);
        updatePowerStateLocked();
    }
}
 

/**
 * Timeout of a direct-call alarm delivery
 */
public void alarmTimedOut(IBinder who) {
    synchronized (mLock) {
        InFlight inflight = removeLocked(who);
        if (inflight != null) {
            // TODO: implement ANR policy for the target
            if (DEBUG_LISTENER_CALLBACK) {
                Slog.i(TAG, "Alarm listener " + who + " timed out in delivery");
            }
            updateTrackingLocked(inflight);
            mListenerFinishCount++;
        } else {
            if (DEBUG_LISTENER_CALLBACK) {
                Slog.i(TAG, "Spurious timeout of listener " + who);
            }
            mLog.w("Spurious timeout of listener " + who);
        }
    }
}
 

private void doRetry() {
    synchronized (mLock) {
        if (mConnection == null) {
            // We disconnected for good.  Don't attempt to retry.
            return;
        }
        if (!mRetrying) {
            // We successfully connected.  Don't attempt to retry.
            return;
        }
        Slog.i(TAG, "Attempting to reconnect " + mComponent + "...");
        // While frameworks may restart the remote Service if we stay bound, we have little
        // control of the backoff timing for reconnecting the service.  In the event of a
        // process crash, the backoff time can be very large (1-30 min), which is not
        // acceptable for the types of services this is used for.  Instead force an unbind/bind
        // sequence to cause a more immediate retry.
        disconnect();
        if (checkAndDeliverServiceDiedCbLocked()) {
            // No more retries.
            return;
        }
        queueRetryLocked();
        connect();
    }
}
 

/**
 * 回调所有 SystemService 的 onStartUser() 方法
 * @param userHandle
 */
public void startUser(final int userHandle) {
    Slog.i(TAG, "Calling onStartUser u" + userHandle);
    final int serviceLen = mServices.size();
    for (int i = 0; i < serviceLen; i++) {
        final SystemService service = mServices.get(i);
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "onStartUser "
                + service.getClass().getName());
        long time = SystemClock.elapsedRealtime();
        try {
            service.onStartUser(userHandle);
        } catch (Exception ex) {
            Slog.wtf(TAG, "Failure reporting start of user " + userHandle
                    + " to service " + service.getClass().getName(), ex);
        }
        warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStartUser ");
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
    }
}
 

@ServiceThreadOnly
void stopOneTouchRecord(int recorderAddress) {
    assertRunOnServiceThread();
    if (!mService.isControlEnabled()) {
        Slog.w(TAG, "Can not stop one touch record. CEC control is disabled.");
        announceOneTouchRecordResult(recorderAddress, ONE_TOUCH_RECORD_CEC_DISABLED);
        return;
    }

    if (!checkRecorder(recorderAddress)) {
        Slog.w(TAG, "Invalid recorder address:" + recorderAddress);
        announceOneTouchRecordResult(recorderAddress,
                ONE_TOUCH_RECORD_CHECK_RECORDER_CONNECTION);
        return;
    }

    // Remove one touch record action so that other one touch record can be started.
    removeAction(OneTouchRecordAction.class);
    mService.sendCecCommand(HdmiCecMessageBuilder.buildRecordOff(mAddress, recorderAddress));
    Slog.i(TAG, "Stop [One Touch Record]-Target:" + recorderAddress);
}
 

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    synchronized (mLock) {
        if (!mBound) {
            // Callback came in after PersistentConnection.unbind() was called.
            // We just ignore this.
            // (We've already called unbindService() already in unbind)
            Slog.w(mTag, "Connected: " + mComponentName.flattenToShortString()
                    + " u" + mUserId + " but not bound, ignore.");
            return;
        }
        Slog.i(mTag, "Connected: " + mComponentName.flattenToShortString()
                + " u" + mUserId);

        mIsConnected = true;
        mService = asInterface(service);
    }
}
 

@Override
public void onChange(boolean selfChange, Uri uri, @UserIdInt int userId) {
    if (mDeviceProvisionedUri.equals(uri)) {
        updateRegistration();

        if (isProvisioned()) {
            Slog.i(TAG, "Reporting device setup complete to IGateKeeperService");
            reportDeviceSetupComplete();
            clearFrpCredentialIfOwnerNotSecure();
        }
    } else if (mUserSetupCompleteUri.equals(uri)) {
        tryRemoveUserFromSpCacheLater(userId);
    }
}
 

/** Set the password for encrypting the master key.
 *  @param type One of the CRYPTO_TYPE_XXX consts defined in StorageManager.
 *  @param password The password to set.
 */
@Override
public int changeEncryptionPassword(int type, String password) {
    mContext.enforceCallingOrSelfPermission(Manifest.permission.CRYPT_KEEPER,
        "no permission to access the crypt keeper");

    if (StorageManager.isFileEncryptedNativeOnly()) {
        // Not supported on FBE devices
        return -1;
    }

    if (type == StorageManager.CRYPT_TYPE_DEFAULT) {
        password = "";
    } else if (TextUtils.isEmpty(password)) {
        throw new IllegalArgumentException("password cannot be empty");
    }

    if (DEBUG_EVENTS) {
        Slog.i(TAG, "changing encryption password...");
    }

    try {
        mVold.fdeChangePassword(type, password);
        return 0;
    } catch (Exception e) {
        Slog.wtf(TAG, e);
        return -1;
    }
}
 

private void logSurface(String msg, RuntimeException where) {
    String str = "  SURFACE " + msg + ": " + title;
    if (where != null) {
        Slog.i(TAG, str, where);
    } else {
        Slog.i(TAG, str);
    }
}
 

public void setAlpha(int alpha) {
    synchronized (mService.mWindowMap) {
        if (mAlpha == alpha) {
            return;
        }
        mAlpha = alpha;
        invalidate(null);
        if (DEBUG_VIEWPORT_WINDOW) {
            Slog.i(LOG_TAG, "ViewportWindow set alpha: " + alpha);
        }
    }
}
 

void updateChargingLocked(boolean charging) {
    if (DEBUG) Slog.i(TAG, "updateChargingLocked: charging=" + charging);
    if (!charging && mCharging) {
        mCharging = false;
        if (!mForceIdle) {
            becomeInactiveIfAppropriateLocked();
        }
    } else if (charging) {
        mCharging = charging;
        if (!mForceIdle) {
            becomeActiveLocked("charging", Process.myUid());
        }
    }
}
 

@ServiceThreadOnly
void addAndStartAction(final HdmiCecFeatureAction action) {
    assertRunOnServiceThread();
    mActions.add(action);
    if (mService.isPowerStandby() || !mService.isAddressAllocated()) {
        Slog.i(TAG, "Not ready to start action. Queued for deferred start:" + action);
        return;
    }
    action.start();
}
 

void reparent(TaskStack stack, int position, boolean moveParents) {
    if (stack == mStack) {
        throw new IllegalArgumentException(
                "task=" + this + " already child of stack=" + mStack);
    }
    if (DEBUG_STACK) Slog.i(TAG, "reParentTask: removing taskId=" + mTaskId
            + " from stack=" + mStack);
    EventLog.writeEvent(WM_TASK_REMOVED, mTaskId, "reParentTask");
    final DisplayContent prevDisplayContent = getDisplayContent();

    // If we are moving from the fullscreen stack to the pinned stack
    // then we want to preserve our insets so that there will not
    // be a jump in the area covered by system decorations. We rely
    // on the pinned animation to later unset this value.
    if (stack.inPinnedWindowingMode()) {
        mPreserveNonFloatingState = true;
    } else {
        mPreserveNonFloatingState = false;
    }

    getParent().removeChild(this);
    stack.addTask(this, position, showForAllUsers(), moveParents);

    // Relayout display(s).
    final DisplayContent displayContent = stack.getDisplayContent();
    displayContent.setLayoutNeeded();
    if (prevDisplayContent != displayContent) {
        onDisplayChanged(displayContent);
        prevDisplayContent.setLayoutNeeded();
    }
}
 

/**
 * Creates a new {@code CeDatabaseHelper}. If pre-N db file is present at the old location,
 * it also performs migration to the new CE database.
 */
static CeDatabaseHelper create(
        Context context,
        File preNDatabaseFile,
        File ceDatabaseFile) {
    boolean newDbExists = ceDatabaseFile.exists();
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "CeDatabaseHelper.create ceDatabaseFile=" + ceDatabaseFile
                + " oldDbExists=" + preNDatabaseFile.exists()
                + " newDbExists=" + newDbExists);
    }
    boolean removeOldDb = false;
    if (!newDbExists && preNDatabaseFile.exists()) {
        removeOldDb = migratePreNDbToCe(preNDatabaseFile, ceDatabaseFile);
    }
    // Try to open and upgrade if necessary
    CeDatabaseHelper ceHelper = new CeDatabaseHelper(context, ceDatabaseFile.getPath());
    ceHelper.getWritableDatabase();
    ceHelper.close();
    if (removeOldDb) {
        Slog.i(TAG, "Migration complete - removing pre-N db " + preNDatabaseFile);
        if (!SQLiteDatabase.deleteDatabase(preNDatabaseFile)) {
            Slog.e(TAG, "Cannot remove pre-N db " + preNDatabaseFile);
        }
    }
    return ceHelper;
}
 

private void processDisconnect(final ServiceConnection connection) {
    synchronized (mLock) {
        // The wallpaper disappeared.  If this isn't a system-default one, track
        // crashes and fall back to default if it continues to misbehave.
        if (connection == mWallpaper.connection) {
            final ComponentName wpService = mWallpaper.wallpaperComponent;
            if (!mWallpaper.wallpaperUpdating
                    && mWallpaper.userId == mCurrentUserId
                    && !Objects.equals(mDefaultWallpaperComponent, wpService)
                    && !Objects.equals(mImageWallpaper, wpService)) {
                // There is a race condition which causes
                // {@link #mWallpaper.wallpaperUpdating} to be false even if it is
                // currently updating since the broadcast notifying us is async.
                // This race is overcome by the general rule that we only reset the
                // wallpaper if its service was shut down twice
                // during {@link #MIN_WALLPAPER_CRASH_TIME} millis.
                if (mWallpaper.lastDiedTime != 0
                        && mWallpaper.lastDiedTime + MIN_WALLPAPER_CRASH_TIME
                        > SystemClock.uptimeMillis()) {
                    Slog.w(TAG, "Reverting to built-in wallpaper!");
                    clearWallpaperLocked(true, FLAG_SYSTEM, mWallpaper.userId, null);
                } else {
                    mWallpaper.lastDiedTime = SystemClock.uptimeMillis();

                    clearWallpaperComponentLocked(mWallpaper);
                    if (bindWallpaperComponentLocked(
                            wpService, false, false, mWallpaper, null)) {
                        mWallpaper.connection.scheduleTimeoutLocked();
                    } else {
                        Slog.w(TAG, "Reverting to built-in wallpaper!");
                        clearWallpaperLocked(true, FLAG_SYSTEM, mWallpaper.userId, null);
                    }
                }
                final String flattened = wpService.flattenToString();
                EventLog.writeEvent(EventLogTags.WP_WALLPAPER_CRASHED,
                        flattened.substring(0, Math.min(flattened.length(),
                                MAX_WALLPAPER_COMPONENT_LOG_LENGTH)));
            }
        } else {
            if (DEBUG_LIVE) {
                Slog.i(TAG, "Wallpaper changed during disconnect tracking; ignoring");
            }
        }
    }
}
 

@Override
public void onRecognitionPaused() {
    Slog.i(TAG, "onRecognitionPaused");
    mHandler.sendEmptyMessage(MSG_DETECTION_PAUSE);
}
 

public void kill() {
    if (DEBUG_STATE) Slog.v(TAG, "Kill!");
    if (mSurfaceControl != null) {
        if (SHOW_TRANSACTIONS ||
                SHOW_SURFACE_ALLOC) Slog.i(TAG_WM,
                        "  FREEZE " + mSurfaceControl + ": DESTROY");
        mSurfaceControl.destroy();
        mSurfaceControl = null;
    }
    if (mCustomBlackFrame != null) {
        mCustomBlackFrame.kill();
        mCustomBlackFrame = null;
    }
    if (mExitingBlackFrame != null) {
        mExitingBlackFrame.kill();
        mExitingBlackFrame = null;
    }
    if (mEnteringBlackFrame != null) {
        mEnteringBlackFrame.kill();
        mEnteringBlackFrame = null;
    }
    if (TWO_PHASE_ANIMATION) {
        if (mStartExitAnimation != null) {
            mStartExitAnimation.cancel();
            mStartExitAnimation = null;
        }
        if (mStartEnterAnimation != null) {
            mStartEnterAnimation.cancel();
            mStartEnterAnimation = null;
        }
        if (mFinishExitAnimation != null) {
            mFinishExitAnimation.cancel();
            mFinishExitAnimation = null;
        }
        if (mFinishEnterAnimation != null) {
            mFinishEnterAnimation.cancel();
            mFinishEnterAnimation = null;
        }
    }
    if (USE_CUSTOM_BLACK_FRAME) {
        if (mStartFrameAnimation != null) {
            mStartFrameAnimation.cancel();
            mStartFrameAnimation = null;
        }
        if (mRotateFrameAnimation != null) {
            mRotateFrameAnimation.cancel();
            mRotateFrameAnimation = null;
        }
        if (mFinishFrameAnimation != null) {
            mFinishFrameAnimation.cancel();
            mFinishFrameAnimation = null;
        }
    }
    if (mRotateExitAnimation != null) {
        mRotateExitAnimation.cancel();
        mRotateExitAnimation = null;
    }
    if (mRotateEnterAnimation != null) {
        mRotateEnterAnimation.cancel();
        mRotateEnterAnimation = null;
    }
}
 

public static ZenModeConfig readXml(XmlPullParser parser)
        throws XmlPullParserException, IOException {
    int type = parser.getEventType();
    if (type != XmlPullParser.START_TAG) return null;
    String tag = parser.getName();
    if (!ZEN_TAG.equals(tag)) return null;
    final ZenModeConfig rt = new ZenModeConfig();
    rt.version = safeInt(parser, ZEN_ATT_VERSION, XML_VERSION);
    rt.user = safeInt(parser, ZEN_ATT_USER, rt.user);
    boolean readSuppressedEffects = false;
    while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
        tag = parser.getName();
        if (type == XmlPullParser.END_TAG && ZEN_TAG.equals(tag)) {
            return rt;
        }
        if (type == XmlPullParser.START_TAG) {
            if (ALLOW_TAG.equals(tag)) {
                rt.allowCalls = safeBoolean(parser, ALLOW_ATT_CALLS,
                        DEFAULT_ALLOW_CALLS);
                rt.allowRepeatCallers = safeBoolean(parser, ALLOW_ATT_REPEAT_CALLERS,
                        DEFAULT_ALLOW_REPEAT_CALLERS);
                rt.allowMessages = safeBoolean(parser, ALLOW_ATT_MESSAGES,
                        DEFAULT_ALLOW_MESSAGES);
                rt.allowReminders = safeBoolean(parser, ALLOW_ATT_REMINDERS,
                        DEFAULT_ALLOW_REMINDERS);
                rt.allowEvents = safeBoolean(parser, ALLOW_ATT_EVENTS, DEFAULT_ALLOW_EVENTS);
                final int from = safeInt(parser, ALLOW_ATT_FROM, -1);
                final int callsFrom = safeInt(parser, ALLOW_ATT_CALLS_FROM, -1);
                final int messagesFrom = safeInt(parser, ALLOW_ATT_MESSAGES_FROM, -1);
                if (isValidSource(callsFrom) && isValidSource(messagesFrom)) {
                    rt.allowCallsFrom = callsFrom;
                    rt.allowMessagesFrom = messagesFrom;
                } else if (isValidSource(from)) {
                    Slog.i(TAG, "Migrating existing shared 'from': " + sourceToString(from));
                    rt.allowCallsFrom = from;
                    rt.allowMessagesFrom = from;
                } else {
                    rt.allowCallsFrom = DEFAULT_CALLS_SOURCE;
                    rt.allowMessagesFrom = DEFAULT_SOURCE;
                }
                rt.allowAlarms = safeBoolean(parser, ALLOW_ATT_ALARMS, DEFAULT_ALLOW_ALARMS);
                rt.allowMedia = safeBoolean(parser, ALLOW_ATT_MEDIA,
                        DEFAULT_ALLOW_MEDIA);
                rt.allowSystem = safeBoolean(parser, ALLOW_ATT_SYSTEM, DEFAULT_ALLOW_SYSTEM);

                // migrate old suppressed visual effects fields, if they still exist in the xml
                Boolean allowWhenScreenOff = unsafeBoolean(parser, ALLOW_ATT_SCREEN_OFF);
                if (allowWhenScreenOff != null) {
                    readSuppressedEffects = true;
                    if (allowWhenScreenOff) {
                        rt.suppressedVisualEffects |= SUPPRESSED_EFFECT_LIGHTS
                                | SUPPRESSED_EFFECT_FULL_SCREEN_INTENT;
                    }
                }
                Boolean allowWhenScreenOn = unsafeBoolean(parser, ALLOW_ATT_SCREEN_ON);
                if (allowWhenScreenOn != null) {
                    readSuppressedEffects = true;
                    if (allowWhenScreenOn) {
                        rt.suppressedVisualEffects |= SUPPRESSED_EFFECT_PEEK;
                    }
                }
                if (readSuppressedEffects) {
                    Slog.d(TAG, "Migrated visual effects to " + rt.suppressedVisualEffects);
                }
            } else if (DISALLOW_TAG.equals(tag) && !readSuppressedEffects) {
                // only read from suppressed visual effects field if we haven't just migrated
                // the values from allowOn/allowOff, lest we wipe out those settings
                rt.suppressedVisualEffects = safeInt(parser, DISALLOW_ATT_VISUAL_EFFECTS,
                        DEFAULT_SUPPRESSED_VISUAL_EFFECTS);
            } else if (MANUAL_TAG.equals(tag)) {
                rt.manualRule = readRuleXml(parser);
            } else if (AUTOMATIC_TAG.equals(tag)) {
                final String id = parser.getAttributeValue(null, RULE_ATT_ID);
                final ZenRule automaticRule = readRuleXml(parser);
                if (id != null && automaticRule != null) {
                    automaticRule.id = id;
                    rt.automaticRules.put(id, automaticRule);
                }
            } else if (STATE_TAG.equals(tag)) {
                rt.areChannelsBypassingDnd = safeBoolean(parser,
                        STATE_ATT_CHANNELS_BYPASSING_DND, DEFAULT_CHANNELS_BYPASSING_DND);
            }
        }
    }
    throw new IllegalStateException("Failed to reach END_DOCUMENT");
}
 

private VerifyCredentialResponse spBasedDoVerifyCredential(String userCredential, int
        credentialType, boolean hasChallenge, long challenge, int userId,
        ICheckCredentialProgressCallback progressCallback) throws RemoteException {
    if (DEBUG) Slog.d(TAG, "spBasedDoVerifyCredential: user=" + userId);
    if (credentialType == LockPatternUtils.CREDENTIAL_TYPE_NONE) {
        userCredential = null;
    }

    final AuthenticationResult authResult;
    VerifyCredentialResponse response;
    synchronized (mSpManager) {
        if (!isSyntheticPasswordBasedCredentialLocked(userId)) {
            return null;
        }
        if (userId == USER_FRP) {
            return mSpManager.verifyFrpCredential(getGateKeeperService(),
                    userCredential, credentialType, progressCallback);
        }

        long handle = getSyntheticPasswordHandleLocked(userId);
        authResult = mSpManager.unwrapPasswordBasedSyntheticPassword(
                getGateKeeperService(), handle, userCredential, userId, progressCallback);

        if (authResult.credentialType != credentialType) {
            Slog.e(TAG, "Credential type mismatch.");
            return VerifyCredentialResponse.ERROR;
        }
        response = authResult.gkResponse;
        // credential has matched
        if (response.getResponseCode() == VerifyCredentialResponse.RESPONSE_OK) {
            // perform verifyChallenge with synthetic password which generates the real GK auth
            // token and response for the current user
            response = mSpManager.verifyChallenge(getGateKeeperService(), authResult.authToken,
                    challenge, userId);
            if (response.getResponseCode() != VerifyCredentialResponse.RESPONSE_OK) {
                // This shouldn't really happen: the unwrapping of SP succeeds, but SP doesn't
                // match the recorded GK password handle.
                Slog.wtf(TAG, "verifyChallenge with SP failed.");
                return VerifyCredentialResponse.ERROR;
            }
        }
    }

    if (response.getResponseCode() == VerifyCredentialResponse.RESPONSE_OK) {
        notifyActivePasswordMetricsAvailable(userCredential, userId);
        unlockKeystore(authResult.authToken.deriveKeyStorePassword(), userId);

        final byte[] secret = authResult.authToken.deriveDiskEncryptionKey();
        Slog.i(TAG, "Unlocking user " + userId + " with secret only, length " + secret.length);
        unlockUser(userId, null, secret);

        activateEscrowTokens(authResult.authToken, userId);

        if (isManagedProfileWithSeparatedLock(userId)) {
            TrustManager trustManager =
                    (TrustManager) mContext.getSystemService(Context.TRUST_SERVICE);
            trustManager.setDeviceLockedForUser(userId, false);
        }
        mStrongAuth.reportSuccessfulStrongAuthUnlock(userId);

        onAuthTokenKnownForUser(userId, authResult.authToken);
    } else if (response.getResponseCode() == VerifyCredentialResponse.RESPONSE_RETRY) {
        if (response.getTimeout() > 0) {
            requireStrongAuth(STRONG_AUTH_REQUIRED_AFTER_LOCKOUT, userId);
        }
    }

    return response;
}
 

public void onWindowTransitionLocked(WindowState windowState, int transition) {
    if (DEBUG_WINDOW_TRANSITIONS) {
        Slog.i(LOG_TAG, "Window transition: "
                + AppTransition.appTransitionToString(transition)
                + " displayId: " + windowState.getDisplayId());
    }
    final boolean magnifying = mMagnifedViewport.isMagnifyingLocked();
    final int type = windowState.mAttrs.type;
    switch (transition) {
        case WindowManagerPolicy.TRANSIT_ENTER:
        case WindowManagerPolicy.TRANSIT_SHOW: {
            if (!magnifying) {
                break;
            }
            switch (type) {
                case WindowManager.LayoutParams.TYPE_APPLICATION:
                case WindowManager.LayoutParams.TYPE_DRAWN_APPLICATION:
                case WindowManager.LayoutParams.TYPE_APPLICATION_PANEL:
                case WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA:
                case WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL:
                case WindowManager.LayoutParams.TYPE_APPLICATION_ABOVE_SUB_PANEL:
                case WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG:
                case WindowManager.LayoutParams.TYPE_SEARCH_BAR:
                case WindowManager.LayoutParams.TYPE_PHONE:
                case WindowManager.LayoutParams.TYPE_SYSTEM_ALERT:
                case WindowManager.LayoutParams.TYPE_TOAST:
                case WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY:
                case WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY:
                case WindowManager.LayoutParams.TYPE_PRIORITY_PHONE:
                case WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG:
                case WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG:
                case WindowManager.LayoutParams.TYPE_SYSTEM_ERROR:
                case WindowManager.LayoutParams.TYPE_VOLUME_OVERLAY:
                case WindowManager.LayoutParams.TYPE_QS_DIALOG:
                case WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL: {
                    Rect magnifiedRegionBounds = mTempRect2;
                    mMagnifedViewport.getMagnifiedFrameInContentCoordsLocked(
                            magnifiedRegionBounds);
                    Rect touchableRegionBounds = mTempRect1;
                    windowState.getTouchableRegion(mTempRegion1);
                    mTempRegion1.getBounds(touchableRegionBounds);
                    if (!magnifiedRegionBounds.intersect(touchableRegionBounds)) {
                        mCallbacks.onRectangleOnScreenRequested(
                                touchableRegionBounds.left,
                                touchableRegionBounds.top,
                                touchableRegionBounds.right,
                                touchableRegionBounds.bottom);
                    }
                } break;
            } break;
        }
    }
}