android-16.0.0_r2/s

/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.server.vibrator;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.os.CombinedVibration;
import android.os.SystemClock;
import android.os.vibrator.PrebakedSegment;
import android.os.vibrator.PrimitiveSegment;
import android.os.vibrator.PwlePoint;
import android.os.vibrator.RampSegment;
import android.util.Slog;
import android.util.SparseBooleanArray;

import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.FrameworkStatsLog;

/** Holds basic stats about the vibration playback and interaction with the vibrator HAL. */
final class VibrationStats {
    static final String TAG = "VibrationStats";

    // Milestone timestamps, using SystemClock.uptimeMillis(), for calculations.
    // - Create: time a vibration object was created, which is closer to when the service receives a
    //           vibrate request.
    // - Start: time a vibration started to play, which is closer to the time that the
    //          VibrationEffect started playing the very first segment.
    // - End: time a vibration ended with a status, even if it never started to play. This can be as
    //        soon as the vibrator HAL reports it has finished the last command, or before it has
    //        even started when the vibration is ignored or cancelled.
    // Created and ended times set by VibratorManagerService only, guarded by its lock.
    // Start time set by VibrationThread only (single-threaded).
    private long mCreateUptimeMillis;
    private long mStartUptimeMillis;
    private long mEndUptimeMillis;

    // Milestone timestamps, using unix epoch time, only to be used for debugging purposes and
    // to correlate with other system events. Any duration calculations should be done with the
    // {create/start/end}UptimeMillis counterparts so as not to be affected by discontinuities
    // created by RTC adjustments.
    // Set together with the *UptimeMillis counterparts.
    private long mCreateTimeDebug;
    private long mStartTimeDebug;
    private long mEndTimeDebug;

    // Vibration interruption tracking.
    // Set by VibratorManagerService only, guarded by its lock.
    private int mEndedByUid;
    private int mEndedByUsage;
    private int mInterruptedUsage;

    // Vibration parameters.
    // Set by VibrationThread only (single-threaded).
    private float mAdaptiveScale;

    // All following counters are set by VibrationThread only (single-threaded):
    // Counts how many times the VibrationEffect was repeated.
    private int mRepeatCount;
    // Total duration, in milliseconds, the vibrator was active with non-zero amplitude.
    private int mVibratorOnTotalDurationMillis;
    // Total number of primitives used in compositions.
    private int mVibrationCompositionTotalSize;
    private int mVibrationPwleTotalSize;
    // Counts how many times each IVibrator method was triggered by this vibration.
    private int mVibratorOnCount;
    private int mVibratorOffCount;
    private int mVibratorSetAmplitudeCount;
    private int mVibratorSetExternalControlCount;
    private int mVibratorPerformCount;
    private int mVibratorPerformVendorCount;
    private int mVibratorComposeCount;
    private int mVibratorComposePwleCount;

    // Ids of vibration effects and primitives used by this vibration, with support flag.
    // Set by VibrationThread only (single-threaded).
    private SparseBooleanArray mVibratorEffectsUsed = new SparseBooleanArray();
    private SparseBooleanArray mVibratorPrimitivesUsed = new SparseBooleanArray();

    VibrationStats() {
        mCreateUptimeMillis = SystemClock.uptimeMillis();
        mCreateTimeDebug = System.currentTimeMillis();
        // Set invalid UID and VibrationAttributes.USAGE values to indicate fields are unset.
        mEndedByUid = -1;
        mEndedByUsage = -1;
        mInterruptedUsage = -1;
    }

    StatsInfo toStatsInfo(int uid, int vibrationType, int usage, VibrationSession.Status status) {
        return new VibrationStats.StatsInfo(uid, vibrationType, usage, status, this);
    }

    long getCreateUptimeMillis() {
        return mCreateUptimeMillis;
    }

    long getStartUptimeMillis() {
        return mStartUptimeMillis;
    }

    long getEndUptimeMillis() {
        return mEndUptimeMillis;
    }

    long getCreateTimeDebug() {
        return mCreateTimeDebug;
    }

    long getStartTimeDebug() {
        return mStartTimeDebug;
    }

    long getEndTimeDebug() {
        return mEndTimeDebug;
    }

    /**
     * Duration calculated for debugging purposes, between the creation of a vibration and the
     * end time being reported, or -1 if the vibration has not ended.
     */
    long getDurationDebug() {
        return hasEnded() ? (mEndUptimeMillis - mCreateUptimeMillis) : -1;
    }

    /** Return true if vibration reported it has ended. */
    boolean hasEnded() {
        return mEndUptimeMillis > 0;
    }

    /** Return true if vibration reported it has started triggering the vibrator. */
    boolean hasStarted() {
        return mStartUptimeMillis > 0;
    }

    /**
     * Set the current system time as this vibration start time, for debugging purposes.
     *
     * <p>This indicates the vibration has started to interact with the vibrator HAL and the
     * device may start vibrating after this point.
     *
     * <p>This method will only accept given value if the start timestamp was never set.
     */
    void reportStarted() {
        if (hasEnded() || (mStartUptimeMillis != 0)) {
            // Vibration already started or ended, keep first time set and ignore this one.
            return;
        }
        mStartUptimeMillis = SystemClock.uptimeMillis();
        mStartTimeDebug = System.currentTimeMillis();
    }

    /**
     * Set status and end cause for this vibration to end, and the current system time as this
     * vibration end time, for debugging purposes.
     *
     * <p>This might be triggered before {@link #reportStarted()}, which indicates this
     * vibration was cancelled or ignored before it started triggering the vibrator.
     *
     * @return true if the status was accepted. This method will only accept given values if
     * the end timestamp was never set.
     */
    boolean reportEnded(@Nullable VibrationSession.CallerInfo endedBy) {
        if (hasEnded()) {
            // Vibration already ended, keep first ending stats set and ignore this one.
            return false;
        }
        if (endedBy != null) {
            mEndedByUid = endedBy.uid;
            mEndedByUsage = endedBy.attrs.getUsage();
        }
        mEndUptimeMillis = SystemClock.uptimeMillis();
        mEndTimeDebug = System.currentTimeMillis();

        return true;
    }

    /**
     * Report this vibration has interrupted another vibration.
     *
     * <p>This method will only accept the first value as the one that was interrupted by this
     * vibration, and will ignore all successive calls.
     */
    void reportInterruptedAnotherVibration(@NonNull VibrationSession.CallerInfo callerInfo) {
        if (mInterruptedUsage < 0) {
            mInterruptedUsage = callerInfo.attrs.getUsage();
        }
    }

    /** Report the adaptive scale that was applied to this vibration. */
    void reportAdaptiveScale(float scale) {
        // Only report adaptive scale if it was set for this vibration.
        if (Float.compare(scale, VibrationScaler.ADAPTIVE_SCALE_NONE) != 0) {
            mAdaptiveScale = scale;
        }
    }

    /** Report the vibration has looped a few more times. */
    void reportRepetition(int loops) {
        mRepeatCount += loops;
    }

    /** Report a call to vibrator method to turn on for given duration. */
    void reportVibratorOn(long halResult) {
        mVibratorOnCount++;

        if (halResult > 0) {
            // If HAL result is positive then it represents the actual duration it will be ON.
            mVibratorOnTotalDurationMillis += (int) halResult;
        }
    }

    /** Report a call to vibrator method to turn off. */
    void reportVibratorOff() {
        mVibratorOffCount++;
    }

    /** Report a call to vibrator method to change the vibration amplitude. */
    void reportSetAmplitude() {
        mVibratorSetAmplitudeCount++;
    }

    /** Report a call to vibrator method to trigger a vibration effect. */
    void reportPerformEffect(long halResult, PrebakedSegment prebaked) {
        mVibratorPerformCount++;

        if (halResult > 0) {
            // If HAL result is positive then it represents the actual duration of the vibration.
            mVibratorEffectsUsed.put(prebaked.getEffectId(), true);
            mVibratorOnTotalDurationMillis += (int) halResult;
        } else {
            // Effect unsupported or request failed.
            mVibratorEffectsUsed.put(prebaked.getEffectId(), false);
        }
    }

    /** Report a call to vibrator method to trigger a vendor vibration effect. */
    void reportPerformVendorEffect(long halResult) {
        mVibratorPerformVendorCount++;
    }

    /** Report a call to vibrator method to trigger a vibration as a composition of primitives. */
    void reportComposePrimitives(long halResult, PrimitiveSegment[] primitives) {
        mVibratorComposeCount++;
        mVibrationCompositionTotalSize += primitives.length;

        if (halResult > 0) {
            // If HAL result is positive then it represents the actual duration of the vibration.
            // Remove the requested delays to update the total time the vibrator was ON.
            for (PrimitiveSegment primitive : primitives) {
                halResult -= primitive.getDelay();
                mVibratorPrimitivesUsed.put(primitive.getPrimitiveId(), true);
            }
            if (halResult > 0) {
                mVibratorOnTotalDurationMillis += (int) halResult;
            }
        } else {
            // One or more primitives were unsupported, or request failed.
            for (PrimitiveSegment primitive : primitives) {
                mVibratorPrimitivesUsed.put(primitive.getPrimitiveId(), false);
            }
        }
    }

    /** Report a call to vibrator method to trigger a vibration as a PWLE. */
    void reportComposePwle(long halResult, RampSegment[] segments) {
        mVibratorComposePwleCount++;
        mVibrationPwleTotalSize += segments.length;

        if (halResult > 0) {
            // If HAL result is positive then it represents the actual duration of the vibration.
            // Remove the zero-amplitude segments to update the total time the vibrator was ON.
            for (RampSegment ramp : segments) {
                if ((ramp.getStartAmplitude() == 0) && (ramp.getEndAmplitude() == 0)) {
                    halResult -= ramp.getDuration();
                }
            }
            if (halResult > 0) {
                mVibratorOnTotalDurationMillis += (int) halResult;
            }
        }
    }

    /** Report a call to vibrator method to trigger a vibration as a PWLE. */
    void reportComposePwle(long halResult, PwlePoint[] pwlePoints) {
        mVibratorComposePwleCount++;
        mVibrationPwleTotalSize += pwlePoints.length;

        if (halResult > 0) {
            // If HAL result is positive then it represents the actual duration of the vibration.
            // Remove the zero-amplitude segments to update the total time the vibrator was ON.
            for (int i = 0; i < pwlePoints.length - 1; i++) {
                PwlePoint current = pwlePoints[i];
                PwlePoint next = pwlePoints[i + 1];

                if (current.getAmplitude() == 0 && next.getAmplitude() == 0) {
                    halResult -= next.getTimeMillis();
                }
            }

            if (halResult > 0) {
                mVibratorOnTotalDurationMillis += (int) halResult;
            }
        }
    }

    /**
     * Increment the stats for total number of times the {@code setExternalControl} method was
     * triggered in the vibrator HAL.
     */
    void reportSetExternalControl() {
        mVibratorSetExternalControlCount++;
    }

    /**
     * Immutable metrics about this vibration, to be kept in memory until it can be pushed through
     * {@link com.android.internal.util.FrameworkStatsLog} as a
     * {@link com.android.internal.util.FrameworkStatsLog#VIBRATION_REPORTED}.
     */
    public static final class StatsInfo {
        public final int uid;
        public final int vibrationType;
        public final int usage;
        public final int status;
        public final float adaptiveScale;
        public final boolean endedBySameUid;
        public final int endedByUsage;
        public final int interruptedUsage;
        public final int repeatCount;
        public final int totalDurationMillis;
        public final int vibratorOnMillis;
        public final int startLatencyMillis;
        public final int endLatencyMillis;
        public final int halComposeCount;
        public final int halComposePwleCount;
        public final int halOnCount;
        public final int halOffCount;
        public final int halPerformCount;
        public final int halPerformVendorCount;
        public final int halSetAmplitudeCount;
        public final int halSetExternalControlCount;
        public final int halCompositionSize;
        public final int halPwleSize;
        public final int[] halSupportedCompositionPrimitivesUsed;
        public final int[] halSupportedEffectsUsed;
        public final int[] halUnsupportedCompositionPrimitivesUsed;
        public final int[] halUnsupportedEffectsUsed;
        private boolean mIsWritten;

        StatsInfo(int uid, int vibrationType, int usage, VibrationSession.Status status,
                VibrationStats stats) {
            this.uid = uid;
            this.vibrationType = vibrationType;
            this.usage = usage;
            this.status = status.getProtoEnumValue();
            this.adaptiveScale = stats.mAdaptiveScale;
            endedBySameUid = (uid == stats.mEndedByUid);
            endedByUsage = stats.mEndedByUsage;
            interruptedUsage = stats.mInterruptedUsage;
            repeatCount = stats.mRepeatCount;

            // Consider this vibration is being completed now.
            long completionUptimeMillis = SystemClock.uptimeMillis();

            // This duration goes from the time this object was created until the time it was
            // completed. We can use latencies to detect the times between first and last
            // interaction with vibrator.
            totalDurationMillis =
                    (int) Math.max(0,  completionUptimeMillis - stats.mCreateUptimeMillis);
            vibratorOnMillis = stats.mVibratorOnTotalDurationMillis;

            if (stats.hasStarted()) {
                // We only measure latencies for vibrations that actually triggered the vibrator.
                startLatencyMillis =
                        (int) Math.max(0, stats.mStartUptimeMillis - stats.mCreateUptimeMillis);
                endLatencyMillis =
                        (int) Math.max(0, completionUptimeMillis - stats.mEndUptimeMillis);
            } else {
                startLatencyMillis = endLatencyMillis = 0;
            }

            halComposeCount = stats.mVibratorComposeCount;
            halComposePwleCount = stats.mVibratorComposePwleCount;
            halOnCount = stats.mVibratorOnCount;
            halOffCount = stats.mVibratorOffCount;
            halPerformCount = stats.mVibratorPerformCount;
            halPerformVendorCount = stats.mVibratorPerformVendorCount;
            halSetAmplitudeCount = stats.mVibratorSetAmplitudeCount;
            halSetExternalControlCount = stats.mVibratorSetExternalControlCount;
            halCompositionSize = stats.mVibrationCompositionTotalSize;
            halPwleSize = stats.mVibrationPwleTotalSize;
            halSupportedCompositionPrimitivesUsed =
                    filteredKeys(stats.mVibratorPrimitivesUsed, /* supported= */ true);
            halSupportedEffectsUsed =
                    filteredKeys(stats.mVibratorEffectsUsed, /* supported= */ true);
            halUnsupportedCompositionPrimitivesUsed =
                    filteredKeys(stats.mVibratorPrimitivesUsed, /* supported= */ false);
            halUnsupportedEffectsUsed =
                    filteredKeys(stats.mVibratorEffectsUsed, /* supported= */ false);
        }

        @VisibleForTesting
        boolean isWritten() {
            return mIsWritten;
        }

        void writeVibrationReported() {
            if (mIsWritten) {
                Slog.wtf(TAG, "Writing same vibration stats multiple times for uid=" + uid);
            }
            mIsWritten = true;
            // Mapping from this MetricInfo representation and the atom proto VibrationReported.
            FrameworkStatsLog.write_non_chained(
                    FrameworkStatsLog.VIBRATION_REPORTED,
                    uid, null, vibrationType, usage, status, endedBySameUid, endedByUsage,
                    interruptedUsage, repeatCount, totalDurationMillis, vibratorOnMillis,
                    startLatencyMillis, endLatencyMillis, halComposeCount, halComposePwleCount,
                    halOnCount, halOffCount, halPerformCount, halSetAmplitudeCount,
                    halSetExternalControlCount, halSupportedCompositionPrimitivesUsed,
                    halSupportedEffectsUsed, halUnsupportedCompositionPrimitivesUsed,
                    halUnsupportedEffectsUsed, halCompositionSize, halPwleSize, adaptiveScale,
                    halPerformVendorCount);
        }

        private static int[] filteredKeys(SparseBooleanArray supportArray, boolean supported) {
            int count = 0;
            for (int i = 0; i < supportArray.size(); i++) {
                if (supportArray.valueAt(i) == supported) count++;
            }
            if (count == 0) {
                return null;
            }
            int pos = 0;
            int[] res = new int[count];
            for (int i = 0; i < supportArray.size(); i++) {
                if (supportArray.valueAt(i) == supported) {
                    res[pos++] = supportArray.keyAt(i);
                }
            }
            return res;
        }

        /**
         * Returns the vibration type value from {@code ReportedVibration} that best represents this
         * {@link CombinedVibration}.
         *
         * <p>This does not include external vibrations, as those are not represented by a single
         * vibration effect.
         */
        public static int findVibrationType(@Nullable CombinedVibration effect) {
            if (effect == null) {
                return FrameworkStatsLog.VIBRATION_REPORTED__VIBRATION_TYPE__SINGLE;
            }
            if (effect.hasVendorEffects()) {
                return FrameworkStatsLog.VIBRATION_REPORTED__VIBRATION_TYPE__VENDOR;
            }
            if (effect.getDuration() == Long.MAX_VALUE) {
                return FrameworkStatsLog.VIBRATION_REPORTED__VIBRATION_TYPE__REPEATED;
            }
            return FrameworkStatsLog.VIBRATION_REPORTED__VIBRATION_TYPE__SINGLE;
        }
    }
}