Examples with FastPrintWriter com.android.internal.util.FastPrintWriter used on opensource projects

Example 71 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project platform_frameworks_base by android.

the class ProcessCpuTracker method printCurrentLoad.

public final String printCurrentLoad() {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new FastPrintWriter(sw, false, 128);
    pw.print("Load: ");
    pw.print(mLoad1);
    pw.print(" / ");
    pw.print(mLoad5);
    pw.print(" / ");
    pw.println(mLoad15);
    pw.flush();
    return sw.toString();
}

Example 72 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project platform_frameworks_base by android.

the class ProcessCpuTracker method printCurrentState.

public final String printCurrentState(long now) {
    final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    buildWorkingProcs();
    StringWriter sw = new StringWriter();
    PrintWriter pw = new FastPrintWriter(sw, false, 1024);
    pw.print("CPU usage from ");
    if (now > mLastSampleTime) {
        pw.print(now - mLastSampleTime);
        pw.print("ms to ");
        pw.print(now - mCurrentSampleTime);
        pw.print("ms ago");
    } else {
        pw.print(mLastSampleTime - now);
        pw.print("ms to ");
        pw.print(mCurrentSampleTime - now);
        pw.print("ms later");
    }
    pw.print(" (");
    pw.print(sdf.format(new Date(mLastSampleWallTime)));
    pw.print(" to ");
    pw.print(sdf.format(new Date(mCurrentSampleWallTime)));
    pw.print(")");
    long sampleTime = mCurrentSampleTime - mLastSampleTime;
    long sampleRealTime = mCurrentSampleRealTime - mLastSampleRealTime;
    long percAwake = sampleRealTime > 0 ? ((sampleTime * 100) / sampleRealTime) : 0;
    if (percAwake != 100) {
        pw.print(" with ");
        pw.print(percAwake);
        pw.print("% awake");
    }
    pw.println(":");
    final int totalTime = mRelUserTime + mRelSystemTime + mRelIoWaitTime + mRelIrqTime + mRelSoftIrqTime + mRelIdleTime;
    if (DEBUG)
        Slog.i(TAG, "totalTime " + totalTime + " over sample time " + (mCurrentSampleTime - mLastSampleTime));
    int N = mWorkingProcs.size();
    for (int i = 0; i < N; i++) {
        Stats st = mWorkingProcs.get(i);
        printProcessCPU(pw, st.added ? " +" : (st.removed ? " -" : "  "), st.pid, st.name, (int) st.rel_uptime, st.rel_utime, st.rel_stime, 0, 0, 0, st.rel_minfaults, st.rel_majfaults);
        if (!st.removed && st.workingThreads != null) {
            int M = st.workingThreads.size();
            for (int j = 0; j < M; j++) {
                Stats tst = st.workingThreads.get(j);
                printProcessCPU(pw, tst.added ? "   +" : (tst.removed ? "   -" : "    "), tst.pid, tst.name, (int) st.rel_uptime, tst.rel_utime, tst.rel_stime, 0, 0, 0, 0, 0);
            }
        }
    }
    printProcessCPU(pw, "", -1, "TOTAL", totalTime, mRelUserTime, mRelSystemTime, mRelIoWaitTime, mRelIrqTime, mRelSoftIrqTime, 0, 0);
    pw.flush();
    return sw.toString();
}

Example 73 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project platform_frameworks_base by android.

the class BatteryStatsImpl method getNextOldHistoryLocked.

@Override
public boolean getNextOldHistoryLocked(HistoryItem out) {
    boolean end = mHistoryBuffer.dataPosition() >= mHistoryBuffer.dataSize();
    if (!end) {
        readHistoryDelta(mHistoryBuffer, mHistoryReadTmp);
        mReadOverflow |= mHistoryReadTmp.cmd == HistoryItem.CMD_OVERFLOW;
    }
    HistoryItem cur = mHistoryIterator;
    if (cur == null) {
        if (!mReadOverflow && !end) {
            Slog.w(TAG, "Old history ends before new history!");
        }
        return false;
    }
    out.setTo(cur);
    mHistoryIterator = cur.next;
    if (!mReadOverflow) {
        if (end) {
            Slog.w(TAG, "New history ends before old history!");
        } else if (!out.same(mHistoryReadTmp)) {
            PrintWriter pw = new FastPrintWriter(new LogWriter(android.util.Log.WARN, TAG));
            pw.println("Histories differ!");
            pw.println("Old history:");
            (new HistoryPrinter()).printNextItem(pw, out, 0, false, true);
            pw.println("New history:");
            (new HistoryPrinter()).printNextItem(pw, mHistoryReadTmp, 0, false, true);
            pw.flush();
        }
    }
    return true;
}

Example 74 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project platform_frameworks_base by android.

the class FragmentManagerImpl method restoreAllState.

void restoreAllState(Parcelable state, FragmentManagerNonConfig nonConfig) {
    // any nonConfig fragments either, so that is that.
    if (state == null)
        return;
    FragmentManagerState fms = (FragmentManagerState) state;
    if (fms.mActive == null)
        return;
    List<FragmentManagerNonConfig> childNonConfigs = null;
    // to their saved state, so we don't try to instantiate them again.
    if (nonConfig != null) {
        List<Fragment> nonConfigFragments = nonConfig.getFragments();
        childNonConfigs = nonConfig.getChildNonConfigs();
        final int count = nonConfigFragments != null ? nonConfigFragments.size() : 0;
        for (int i = 0; i < count; i++) {
            Fragment f = nonConfigFragments.get(i);
            if (DEBUG)
                Log.v(TAG, "restoreAllState: re-attaching retained " + f);
            FragmentState fs = fms.mActive[f.mIndex];
            fs.mInstance = f;
            f.mSavedViewState = null;
            f.mBackStackNesting = 0;
            f.mInLayout = false;
            f.mAdded = false;
            f.mTarget = null;
            if (fs.mSavedFragmentState != null) {
                fs.mSavedFragmentState.setClassLoader(mHost.getContext().getClassLoader());
                f.mSavedViewState = fs.mSavedFragmentState.getSparseParcelableArray(FragmentManagerImpl.VIEW_STATE_TAG);
                f.mSavedFragmentState = fs.mSavedFragmentState;
            }
        }
    }
    // Build the full list of active fragments, instantiating them from
    // their saved state.
    mActive = new ArrayList<>(fms.mActive.length);
    if (mAvailIndices != null) {
        mAvailIndices.clear();
    }
    for (int i = 0; i < fms.mActive.length; i++) {
        FragmentState fs = fms.mActive[i];
        if (fs != null) {
            FragmentManagerNonConfig childNonConfig = null;
            if (childNonConfigs != null && i < childNonConfigs.size()) {
                childNonConfig = childNonConfigs.get(i);
            }
            Fragment f = fs.instantiate(mHost, mParent, childNonConfig);
            if (DEBUG)
                Log.v(TAG, "restoreAllState: active #" + i + ": " + f);
            mActive.add(f);
            // Now that the fragment is instantiated (or came from being
            // retained above), clear mInstance in case we end up re-restoring
            // from this FragmentState again.
            fs.mInstance = null;
        } else {
            mActive.add(null);
            if (mAvailIndices == null) {
                mAvailIndices = new ArrayList<>();
            }
            if (DEBUG)
                Log.v(TAG, "restoreAllState: avail #" + i);
            mAvailIndices.add(i);
        }
    }
    // Update the target of all retained fragments.
    if (nonConfig != null) {
        List<Fragment> nonConfigFragments = nonConfig.getFragments();
        final int count = nonConfigFragments != null ? nonConfigFragments.size() : 0;
        for (int i = 0; i < count; i++) {
            Fragment f = nonConfigFragments.get(i);
            if (f.mTargetIndex >= 0) {
                if (f.mTargetIndex < mActive.size()) {
                    f.mTarget = mActive.get(f.mTargetIndex);
                } else {
                    Log.w(TAG, "Re-attaching retained fragment " + f + " target no longer exists: " + f.mTargetIndex);
                    f.mTarget = null;
                }
            }
        }
    }
    // Build the list of currently added fragments.
    if (fms.mAdded != null) {
        mAdded = new ArrayList<Fragment>(fms.mAdded.length);
        for (int i = 0; i < fms.mAdded.length; i++) {
            Fragment f = mActive.get(fms.mAdded[i]);
            if (f == null) {
                throwException(new IllegalStateException("No instantiated fragment for index #" + fms.mAdded[i]));
            }
            f.mAdded = true;
            if (DEBUG)
                Log.v(TAG, "restoreAllState: added #" + i + ": " + f);
            if (mAdded.contains(f)) {
                throw new IllegalStateException("Already added!");
            }
            mAdded.add(f);
        }
    } else {
        mAdded = null;
    }
    // Build the back stack.
    if (fms.mBackStack != null) {
        mBackStack = new ArrayList<BackStackRecord>(fms.mBackStack.length);
        for (int i = 0; i < fms.mBackStack.length; i++) {
            BackStackRecord bse = fms.mBackStack[i].instantiate(this);
            if (DEBUG) {
                Log.v(TAG, "restoreAllState: back stack #" + i + " (index " + bse.mIndex + "): " + bse);
                LogWriter logw = new LogWriter(Log.VERBOSE, TAG);
                PrintWriter pw = new FastPrintWriter(logw, false, 1024);
                bse.dump("  ", pw, false);
                pw.flush();
            }
            mBackStack.add(bse);
            if (bse.mIndex >= 0) {
                setBackStackIndex(bse.mIndex, bse);
            }
        }
    } else {
        mBackStack = null;
    }
}

Example 75 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project platform_frameworks_base by android.

the class FragmentManagerImpl method throwException.

private void throwException(RuntimeException ex) {
    Log.e(TAG, ex.getMessage());
    LogWriter logw = new LogWriter(Log.ERROR, TAG);
    PrintWriter pw = new FastPrintWriter(logw, false, 1024);
    if (mHost != null) {
        Log.e(TAG, "Activity state:");
        try {
            mHost.onDump("  ", null, pw, new String[] {});
        } catch (Exception e) {
            pw.flush();
            Log.e(TAG, "Failed dumping state", e);
        }
    } else {
        Log.e(TAG, "Fragment manager state:");
        try {
            dump("  ", null, pw, new String[] {});
        } catch (Exception e) {
            pw.flush();
            Log.e(TAG, "Failed dumping state", e);
        }
    }
    pw.flush();
    throw ex;
}