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

void sendPointerDown(final IBinder token, final int pointerId, final int x, final int y) {
    synchronized (mLock) {
        if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
            if (DEBUG_KEY) {
                Slog.d(TAG, this + ": sendPointerDown," +
                        " token=" + token + ", pointerId=" + pointerId);
            }
            final long idToken = Binder.clearCallingIdentity();
            try {
                if (mProviderMethods != null) {
                    mProviderMethods.sendPointerDown(TvRemoteProviderProxy.this, token,
                            pointerId, x, y);
                }
            } finally {
                Binder.restoreCallingIdentity(idToken);
            }
        } else {
            if (DEBUG) {
                Slog.w(TAG,
                        "sendPointerDown, Invalid connection or incorrect uid: " + Binder
                                .getCallingUid());
            }
        }
    }
}
 

private ArrayList<String> getCommittedFiles(int minNum, boolean inclCurrent,
        boolean inclCheckedIn) {
    File[] files = mBaseDir.listFiles();
    if (files == null || files.length <= minNum) {
        return null;
    }
    ArrayList<String> filesArray = new ArrayList<String>(files.length);
    String currentFile = mFile.getBaseFile().getPath();
    if (DEBUG) Slog.d(TAG, "Collecting " + files.length + " files except: " + currentFile);
    for (int i=0; i<files.length; i++) {
        File file = files[i];
        String fileStr = file.getPath();
        if (DEBUG) Slog.d(TAG, "Collecting: " + fileStr);
        if (!inclCheckedIn && fileStr.endsWith(STATE_FILE_CHECKIN_SUFFIX)) {
            if (DEBUG) Slog.d(TAG, "Skipping: already checked in");
            continue;
        }
        if (!inclCurrent && fileStr.equals(currentFile)) {
            if (DEBUG) Slog.d(TAG, "Skipping: current stats");
            continue;
        }
        filesArray.add(fileStr);
    }
    Collections.sort(filesArray);
    return filesArray;
}
 

@Override
public void run() {
    mScreenUpdatePending = false;

    int brightness = mScreenState != Display.STATE_OFF
            && mColorFadeLevel > 0f ? mScreenBrightness : 0;
    if (mPhotonicModulator.setState(mScreenState, brightness)) {
        if (DEBUG) {
            Slog.d(TAG, "Screen ready");
        }
        mScreenReady = true;
        invokeCleanListenerIfNeeded();
    } else {
        if (DEBUG) {
            Slog.d(TAG, "Screen not ready");
        }
    }
}
 

private void notifyListeners(@NonNull String packageName, @UserIdInt int userId) {
    if (DEBUG) {
        Slog.d(TAG, String.format(
                "Shortcut changes: package=%s, user=%d", packageName, userId));
    }
    injectPostToHandler(() -> {
        try {
            final ArrayList<ShortcutChangeListener> copy;
            synchronized (mLock) {
                if (!isUserUnlockedL(userId)) {
                    return;
                }

                copy = new ArrayList<>(mListeners);
            }
            // Note onShortcutChanged() needs to be called with the system service permissions.
            for (int i = copy.size() - 1; i >= 0; i--) {
                copy.get(i).onShortcutChanged(packageName, userId);
            }
        } catch (Exception ignore) {
        }
    });
}
 

private void fixateNewestUserKeyAuth(int userId)
        throws RemoteException {
    if (DEBUG) Slog.d(TAG, "fixateNewestUserKeyAuth: user=" + userId);
    final IStorageManager storageManager = mInjector.getStorageManager();
    final long callingId = Binder.clearCallingIdentity();
    try {
        storageManager.fixateNewestUserKeyAuth(userId);
    } finally {
        Binder.restoreCallingIdentity(callingId);
    }
}
 

private void setRegistered(boolean registered) {
    if (mRegistered == registered) return;
    if (DEBUG) Slog.d(TAG, "setRegistered " + registered);
    mRegistered = registered;
    if (mRegistered) {
        final IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_TIME_CHANGED);
        filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
        filter.addAction(ACTION_EVALUATE);
        registerReceiver(mReceiver, filter);
    } else {
        unregisterReceiver(mReceiver);
    }
}
 

boolean setEnabled(@NonNull final String packageName, final boolean enable,
        final int userId) {
    if (DEBUG) {
        Slog.d(TAG, String.format("setEnabled packageName=%s enable=%s userId=%d",
                    packageName, enable, userId));
    }

    final PackageInfo overlayPackage = mPackageManager.getPackageInfo(packageName, userId);
    if (overlayPackage == null) {
        return false;
    }

    // Ignore static overlays.
    if (overlayPackage.isStaticOverlayPackage()) {
        return false;
    }

    try {
        final OverlayInfo oi = mSettings.getOverlayInfo(packageName, userId);
        boolean modified = mSettings.setEnabled(packageName, userId, enable);
        modified |= updateState(oi.targetPackageName, oi.packageName, userId, 0);

        if (modified) {
            mListener.onOverlaysChanged(oi.targetPackageName, userId);
        }
        return true;
    } catch (OverlayManagerSettings.BadKeyException e) {
        return false;
    }
}
 

public SystemGesturesPointerEventListener(Context context, Callbacks callbacks) {
    mContext = context;
    mCallbacks = checkNull("callbacks", callbacks);
    mSwipeStartThreshold = checkNull("context", context).getResources()
            .getDimensionPixelSize(com.android.internal.R.dimen.status_bar_height);
    mSwipeDistanceThreshold = mSwipeStartThreshold;
    if (DEBUG) Slog.d(TAG,  "mSwipeStartThreshold=" + mSwipeStartThreshold
            + " mSwipeDistanceThreshold=" + mSwipeDistanceThreshold);
}
 

/**
 * Called when switching to a different foreground user.
 */
public void handleOnSwitchUser(int userHandle) {
    if (DBG) {
        Slog.d(TAG, "User " + userHandle + " switched");
    }
    mHandler.obtainMessage(MESSAGE_USER_SWITCHED, userHandle, 0).sendToTarget();
}
 

/**
 * Remove the provided job. Will also delete the job if it was persisted.
 * @param writeBack If true, the job will be deleted (if it was persisted) immediately.
 * @return Whether or not the job existed to be removed.
 */
public boolean remove(JobStatus jobStatus, boolean writeBack) {
    boolean removed = mJobSet.remove(jobStatus);
    if (!removed) {
        if (DEBUG) {
            Slog.d(TAG, "Couldn't remove job: didn't exist: " + jobStatus);
        }
        return false;
    }
    if (writeBack && jobStatus.isPersisted()) {
        maybeWriteStatusToDiskAsync();
    }
    return removed;
}
 

/**
 * @return true if the service is bound or in the process of being bound.
 *      Returns false otherwise.
 */
private boolean bindLocked() {
    if (isBoundLocked() || mBinding) {
        return true;
    }

    // TODO: Handle bind timeout.
    final boolean willBind;
    final long identity = Binder.clearCallingIdentity();
    try {
        ComponentName componentName =
                TextClassifierService.getServiceComponentName(mContext);
        if (componentName == null) {
            // Might happen if the storage is encrypted and the user is not unlocked
            return false;
        }
        Intent serviceIntent = new Intent(TextClassifierService.SERVICE_INTERFACE)
                .setComponent(componentName);
        Slog.d(LOG_TAG, "Binding to " + serviceIntent.getComponent());
        willBind = mContext.bindServiceAsUser(
                serviceIntent, mConnection,
                Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE,
                UserHandle.of(mUserId));
        mBinding = willBind;
    } finally {
        Binder.restoreCallingIdentity(identity);
    }
    return willBind;
}
 

public void attemptToRestoreIfNeededAndSave() {
    if (!mPackageInfo.isShadow()) {
        return; // Already installed, nothing to do.
    }
    final ShortcutService s = mShortcutUser.mService;
    if (!s.isPackageInstalled(mPackageName, mPackageUserId)) {
        if (ShortcutService.DEBUG) {
            Slog.d(TAG, String.format("Package still not installed: %s/u%d",
                    mPackageName, mPackageUserId));
        }
        return; // Not installed, no need to restore yet.
    }
    int restoreBlockReason;
    long currentVersionCode = ShortcutInfo.VERSION_CODE_UNKNOWN;

    if (!mPackageInfo.hasSignatures()) {
        s.wtf("Attempted to restore package " + mPackageName + "/u" + mPackageUserId
                + " but signatures not found in the restore data.");
        restoreBlockReason = ShortcutInfo.DISABLED_REASON_SIGNATURE_MISMATCH;
    } else {
        final PackageInfo pi = s.getPackageInfoWithSignatures(mPackageName, mPackageUserId);
        currentVersionCode = pi.getLongVersionCode();
        restoreBlockReason = mPackageInfo.canRestoreTo(s, pi, canRestoreAnyVersion());
    }

    if (ShortcutService.DEBUG) {
        Slog.d(TAG, String.format("Restoring package: %s/u%d (version=%d) %s for u%d",
                mPackageName, mPackageUserId, currentVersionCode,
                ShortcutInfo.getDisabledReasonDebugString(restoreBlockReason),
                getOwnerUserId()));
    }

    onRestored(restoreBlockReason);

    // Either way, it's no longer a shadow.
    mPackageInfo.setShadow(false);

    s.scheduleSaveUser(mPackageUserId);
}
 

@Override
public void onChange(boolean selfChange, Uri uri) {
    if (!Settings.Global.getUriFor(NETWORK_DEFAULT_DAILY_MULTIPATH_QUOTA_BYTES)
            .equals(uri)) {
        Slog.wtf(TAG, "Unexpected settings observation: " + uri);
    }
    if (DBG) Slog.d(TAG, "Settings change: updating budgets.");
    updateAllMultipathBudgets();
}
 

@Override
public boolean startMovingTask(IWindow window, float startX, float startY) {
    if (DEBUG_TASK_POSITIONING) Slog.d(
            TAG_WM, "startMovingTask: {" + startX + "," + startY + "}");

    long ident = Binder.clearCallingIdentity();
    try {
        return mService.mTaskPositioningController.startMovingTask(window, startX, startY);
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}
 

/**
 * Sends alarms that were blocked due to user applied background restrictions - either because
 * the user lifted those or the uid came to foreground.
 *
 * @param uid uid to filter on
 * @param packageName package to filter on, or null for all packages in uid
 */
void sendPendingBackgroundAlarmsLocked(int uid, String packageName) {
    final ArrayList<Alarm> alarmsForUid = mPendingBackgroundAlarms.get(uid);
    if (alarmsForUid == null || alarmsForUid.size() == 0) {
        return;
    }
    final ArrayList<Alarm> alarmsToDeliver;
    if (packageName != null) {
        if (DEBUG_BG_LIMIT) {
            Slog.d(TAG, "Sending blocked alarms for uid " + uid + ", package " + packageName);
        }
        alarmsToDeliver = new ArrayList<>();
        for (int i = alarmsForUid.size() - 1; i >= 0; i--) {
            final Alarm a = alarmsForUid.get(i);
            if (a.matches(packageName)) {
                alarmsToDeliver.add(alarmsForUid.remove(i));
            }
        }
        if (alarmsForUid.size() == 0) {
            mPendingBackgroundAlarms.remove(uid);
        }
    } else {
        if (DEBUG_BG_LIMIT) {
            Slog.d(TAG, "Sending blocked alarms for uid " + uid);
        }
        alarmsToDeliver = alarmsForUid;
        mPendingBackgroundAlarms.remove(uid);
    }
    deliverPendingBackgroundAlarmsLocked(alarmsToDeliver, SystemClock.elapsedRealtime());
}
 

private void initializeClientLocked(ClientRecord clientRecord) {
    if (DEBUG) {
        Slog.d(TAG, clientRecord + ": Registered");
    }
}
 

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 setSyncAutomatically(Account account, int userId, String providerName,
        boolean sync, @SyncExemption int syncExemptionFlag, int callingUid) {
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Slog.d(TAG, "setSyncAutomatically: " + /* account + */" provider " + providerName
                + ", user " + userId + " -> " + sync);
    }
    mLogger.log("Set sync auto account=", account,
            " user=", userId,
            " authority=", providerName,
            " value=", Boolean.toString(sync),
            " callingUid=", callingUid);
    synchronized (mAuthorities) {
        AuthorityInfo authority =
                getOrCreateAuthorityLocked(
                        new EndPoint(account, providerName, userId),
                        -1 /* ident */,
                        false);
        if (authority.enabled == sync) {
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                Slog.d(TAG, "setSyncAutomatically: already set to " + sync + ", doing nothing");
            }
            return;
        }
        // If the adapter was syncable but missing its initialization sync, set it to
        // uninitialized now. This is to give it a chance to run any one-time initialization
        // logic.
        if (sync && authority.syncable == AuthorityInfo.SYNCABLE_NOT_INITIALIZED) {
            authority.syncable = AuthorityInfo.NOT_INITIALIZED;
        }
        authority.enabled = sync;
        writeAccountInfoLocked();
    }

    if (sync) {
        requestSync(account, userId, SyncOperation.REASON_SYNC_AUTO, providerName,
                new Bundle(),
                syncExemptionFlag);
    }
    reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS);
    queueBackup();
}
 

void firewallChainEnabled(int chain, boolean enabled) {
    synchronized (mLock) {
        if (LOGD) Slog.d(TAG, getFirewallChainEnabledLog(chain, enabled));
        mEventsBuffer.firewallChainEnabled(chain, enabled);
    }
}
 

private void updateAmbientLux(long time) {
    // If the light sensor was just turned on then immediately update our initial
    // estimate of the current ambient light level.
    if (!mAmbientLuxValid) {
        final long timeWhenSensorWarmedUp =
            mLightSensorWarmUpTimeConfig + mLightSensorEnableTime;
        if (time < timeWhenSensorWarmedUp) {
            if (DEBUG) {
                Slog.d(TAG, "updateAmbientLux: Sensor not  ready yet: " +
                        "time=" + time + ", " +
                        "timeWhenSensorWarmedUp=" + timeWhenSensorWarmedUp);
            }
            mHandler.sendEmptyMessageAtTime(MSG_UPDATE_AMBIENT_LUX,
                    timeWhenSensorWarmedUp);
            return;
        }
        setAmbientLux(calculateAmbientLux(time, AMBIENT_LIGHT_SHORT_HORIZON_MILLIS));
        mAmbientLuxValid = true;
        if (DEBUG) {
            Slog.d(TAG, "updateAmbientLux: Initializing: " +
                    "mAmbientLightRingBuffer=" + mAmbientLightRingBuffer + ", " +
                    "mAmbientLux=" + mAmbientLux);
        }
        updateAutoBrightness(true);
    }

    long nextBrightenTransition = nextAmbientLightBrighteningTransition(time);
    long nextDarkenTransition = nextAmbientLightDarkeningTransition(time);
    // Essentially, we calculate both a slow ambient lux, to ensure there's a true long-term
    // change in lighting conditions, and a fast ambient lux to determine what the new
    // brightness situation is since the slow lux can be quite slow to converge.
    //
    // Note that both values need to be checked for sufficient change before updating the
    // proposed ambient light value since the slow value might be sufficiently far enough away
    // from the fast value to cause a recalculation while its actually just converging on
    // the fast value still.
    float slowAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_LONG_HORIZON_MILLIS);
    float fastAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_SHORT_HORIZON_MILLIS);

    if ((slowAmbientLux >= mAmbientBrighteningThreshold
            && fastAmbientLux >= mAmbientBrighteningThreshold
            && nextBrightenTransition <= time)
            || (slowAmbientLux <= mAmbientDarkeningThreshold
                    && fastAmbientLux <= mAmbientDarkeningThreshold
                    && nextDarkenTransition <= time)) {
        setAmbientLux(fastAmbientLux);
        if (DEBUG) {
            Slog.d(TAG, "updateAmbientLux: " +
                    ((fastAmbientLux > mAmbientLux) ? "Brightened" : "Darkened") + ": "
                    + "mAmbientBrighteningThreshold=" + mAmbientBrighteningThreshold + ", "
                    + "mAmbientLightRingBuffer=" + mAmbientLightRingBuffer + ", "
                    + "mAmbientLux=" + mAmbientLux);
        }
        updateAutoBrightness(true);
        nextBrightenTransition = nextAmbientLightBrighteningTransition(time);
        nextDarkenTransition = nextAmbientLightDarkeningTransition(time);
    }
    long nextTransitionTime = Math.min(nextDarkenTransition, nextBrightenTransition);
    // If one of the transitions is ready to occur, but the total weighted ambient lux doesn't
    // exceed the necessary threshold, then it's possible we'll get a transition time prior to
    // now. Rather than continually checking to see whether the weighted lux exceeds the
    // threshold, schedule an update for when we'd normally expect another light sample, which
    // should be enough time to decide whether we should actually transition to the new
    // weighted ambient lux or not.
    nextTransitionTime =
            nextTransitionTime > time ? nextTransitionTime : time + mNormalLightSensorRate;
    if (DEBUG) {
        Slog.d(TAG, "updateAmbientLux: Scheduling ambient lux update for " +
                nextTransitionTime + TimeUtils.formatUptime(nextTransitionTime));
    }
    mHandler.sendEmptyMessageAtTime(MSG_UPDATE_AMBIENT_LUX, nextTransitionTime);
}