/*
 * Copyright (C) 2023 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.am;

import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_AUDIO;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_BLUETOOTH;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_CAMERA;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_CDM;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_LOCATION;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_MEDIA_PLAYBACK;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_MICROPHONE;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_PHONE_CALL;
import static android.app.ActivityManager.FOREGROUND_SERVICE_API_TYPE_USB;
import static android.os.Process.INVALID_UID;

import static com.android.internal.util.FrameworkStatsLog.FOREGROUND_SERVICE_STATE_CHANGED__FGS_START_API__FGSSTARTAPI_NA;

import android.annotation.IntDef;
import android.app.ActivityManager;
import android.app.ActivityManager.ForegroundServiceApiType;
import android.app.ForegroundServiceDelegationOptions;
import android.content.ComponentName;
import android.content.pm.ServiceInfo;
import android.os.Trace;
import android.util.ArrayMap;
import android.util.IntArray;
import android.util.LongArray;
import android.util.Slog;
import android.util.SparseArray;
import android.util.SparseIntArray;

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

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;

/**
 * Responsible for handling logging of API events
 * and associating APIs with currently running FGS.
 * Also tracks FGS that are currently running.
 */
public class ForegroundServiceTypeLoggerModule {

    private static final String TAG = "ForegroundServiceTypeLoggerModule";

    public static final int FGS_STATE_CHANGED_API_CALL = 4;

    public static final int FGS_API_BEGIN_WITH_FGS = 1;
    public static final int FGS_API_END_WITH_FGS = 2;
    public static final int FGS_API_END_WITHOUT_FGS = 3;
    public static final int FGS_API_PAUSE = 4;
    public static final int FGS_API_RESUME = 5;

    @IntDef(flag = false, prefix = { "FGS_API_" }, value = {
            FGS_API_BEGIN_WITH_FGS,
            FGS_API_END_WITH_FGS,
            FGS_API_END_WITHOUT_FGS,
            FGS_API_PAUSE,
            FGS_API_RESUME,
    })
    @Retention(RetentionPolicy.SOURCE)
    public @interface FgsApiState {}


    private static class UidState {
        // A stack that keeps a list of API calls by type.
        // This represents the ongoing open APIs
        // that are running on the system for each
        // app in the system. They are keyed
        // by the API type (represented as a number).
        final SparseArray<FgsApiRecord> mApiOpenCalls = new SparseArray<>();

        // This stack represents the last close call made per type
        // We only care about the last call made so we track the last close
        // call made per type. This way, once the FGS closes
        // we simply log the last API call made.
        final SparseArray<FgsApiRecord> mApiClosedCalls = new SparseArray<>();

        // Here we track how many APIs are opened before any FGS is running.
        // These counts will only be added to the open call count below if
        // an FGS is started. If an FGS is NOT started, then this count should
        // gradually hit zero as close calls are decremented.
        final SparseIntArray mOpenedWithoutFgsCount = new SparseIntArray();

        // Here we keep track of the count of in-flight calls.
        // We only want to log the first open call and the last
        // close call so that we get the largest duration
        // possible.
        final SparseIntArray mOpenWithFgsCount = new SparseIntArray();

        // A stack that keeps a list of API calls in the order
        // that they were called. This represents the ongoing
        // open APIs that are running on the system for each
        // app in the system. They are keyed by FGS Type
        // to another ordered map, keyed by the component name
        // to facilitate removing the record from the structure
        final SparseArray<ArrayMap<ComponentName, ServiceRecord>> mRunningFgs = new SparseArray<>();

        // A map of API types to last FGS stop call timestamps
        // We use this to get the duration an API was active after
        // the stop call.
        final SparseArray<Long> mLastFgsTimeStamp = new SparseArray<>();

        // A map of API types to first FGS start call timestamps
        // We use this to get the duration an API was active after
        // the stop call.
        final SparseArray<Long> mFirstFgsTimeStamp = new SparseArray<>();
    }

    // SparseArray that tracks all UIDs that have made various
    // API calls. Keyed by UID.
    private final SparseArray<UidState> mUids = new SparseArray<>();

    public ForegroundServiceTypeLoggerModule() {
    }

    /**
     * Used to log the start of a Foreground Service. The first API
     * call of the right type will also be associated and logged
     */
    public void logForegroundServiceStart(int uid, int pid, ServiceRecord record) {
        if (record.getComponentName() != null) {
            final String traceTag = record.getComponentName().flattenToString() + ":" + uid;
            Trace.asyncTraceForTrackBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, traceTag,
                    "foregroundService", record.foregroundServiceType);
        }
        // initialize the UID stack
        UidState uidState = mUids.get(uid);
        if (uidState == null) {
            uidState = new UidState();
            mUids.put(uid, uidState);
        }
        // grab the appropriate types
        final IntArray apiTypes =
                convertFgsTypeToApiTypes(record.foregroundServiceType);
        if (apiTypes.size() == 0) {
            Slog.w(TAG, "Foreground service start for UID: "
                    + uid + " does not have any types");
        }
        // now we need to iterate through the types
        // and insert the new record as needed
        final IntArray apiTypesFound = new IntArray();
        final LongArray timestampsFound = new LongArray();
        for (int i = 0, size = apiTypes.size(); i < size; i++) {
            final int apiType = apiTypes.get(i);
            int fgsIndex = uidState.mRunningFgs.indexOfKey(apiType);
            if (fgsIndex < 0) {
                uidState.mRunningFgs.put(apiType, new ArrayMap<>());
                fgsIndex = uidState.mRunningFgs.indexOfKey(apiType);
                uidState.mFirstFgsTimeStamp.put(apiType, System.currentTimeMillis());
            }
            final ArrayMap<ComponentName, ServiceRecord> fgsList =
                    uidState.mRunningFgs.valueAt(fgsIndex);
            fgsList.put(record.getComponentName(), record);
            // now we want to figure out if this FGS is associated with any currently open API

            // retrieve the last API call for the type if there is one
            if (uidState.mApiOpenCalls.contains(apiType)) {
                // update the open call count associated with an FGS
                // we want to dump the previously opened call count into the
                // opened with an FGS call count
                // then zero out the old count
                uidState.mOpenWithFgsCount
                        .put(apiType, uidState.mOpenedWithoutFgsCount.get(apiType));
                uidState.mOpenedWithoutFgsCount.put(apiType, 0);
                apiTypesFound.add(apiType);
                final FgsApiRecord call = uidState.mApiOpenCalls.get(apiType);
                timestampsFound.add(call.mTimeStart);
                // associate the call
                call.mIsAssociatedWithFgs = true;
                call.mAssociatedFgsRecord = record;

                // remove the APIs, since we've logged the API starts
                // so we don't need to log them again
                uidState.mApiOpenCalls.remove(apiType);
            }
        }
        if (apiTypesFound.size() != 0) {
            // log a state change
            for (int i = 0, size = apiTypesFound.size(); i < size; i++) {
                logFgsApiEvent(record,
                        FGS_STATE_CHANGED_API_CALL,
                        FGS_API_BEGIN_WITH_FGS,
                        apiTypesFound.get(i),
                        timestampsFound.get(i));
            }
        }
    }

    /**
     * Logs when an FGS stops. The last associated closed API event
     * will also be logged
     */
    public void logForegroundServiceStop(int uid, ServiceRecord record) {
        // we need to log all the API end events and remove the start events
        // then we remove the FGS from the various stacks
        // and also clean up the start calls stack by UID
        if (record.getComponentName() != null) {
            final String traceTag = record.getComponentName().flattenToString() + ":" + uid;
            Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                    traceTag, record.hashCode());
        }
        final IntArray apiTypes = convertFgsTypeToApiTypes(record.foregroundServiceType);
        final UidState uidState = mUids.get(uid);
        if (apiTypes.size() == 0) {
            Slog.w(TAG, "FGS stop call for: " + uid + " has no types!");
        }
        if (uidState == null) {
            Slog.w(TAG, "FGS stop call being logged with no start call for UID for UID "
                    + uid
                    + " in package " + record.packageName);
            return;
        }
        final ArrayList<Integer> apisFound = new ArrayList<>();
        final ArrayList<Long> timestampsFound = new ArrayList<>();
        for (int i = 0, size = apiTypes.size(); i < size; i++) {
            final int apiType = apiTypes.get(i);

            // remove the FGS record from the stack
            final ArrayMap<ComponentName, ServiceRecord> runningFgsOfType =
                    uidState.mRunningFgs.get(apiType);
            if (runningFgsOfType == null) {
                Slog.w(TAG, "Could not find appropriate running FGS for FGS stop for UID " + uid
                        + " in package " + record.packageName);
                continue;
            }

            runningFgsOfType.remove(record.getComponentName());
            if (runningFgsOfType.size() == 0) {
                // there's no more FGS running for this type, just get rid of it
                uidState.mRunningFgs.remove(apiType);
                // but we need to keep track of the timestamp in case an API stops
                uidState.mLastFgsTimeStamp.put(apiType, System.currentTimeMillis());
            }

            final int apiTypeIndex = uidState.mOpenWithFgsCount.indexOfKey(apiType);
            if (apiTypeIndex < 0) {
                Slog.w(TAG, "Logger should be tracking FGS types correctly for UID " + uid
                        + " in package " + record.packageName);
                continue;
            }
            // retrieve the eligible closed call
            // we only want to log if this is the only
            // open in flight call. If there are other calls,
            // we just skip logging
            final FgsApiRecord closedApi = uidState.mApiClosedCalls.get(apiType);
            if (closedApi != null
                    && uidState.mOpenWithFgsCount.valueAt(apiTypeIndex) == 0) {
                apisFound.add(apiType);
                timestampsFound.add(closedApi.mTimeStart);
                // remove the last API close call
                uidState.mApiClosedCalls.remove(apiType);
            }
        }
        if (!apisFound.isEmpty()) {
            // time to log the call
            for (int i = 0; i < apisFound.size(); i++) {
                logFgsApiEvent(record,
                        FGS_STATE_CHANGED_API_CALL,
                        FGS_API_END_WITH_FGS, apisFound.get(i), timestampsFound.get(i));
            }
        }
    }

    /**
     * Called to log an API start call. If any associated FGS
     * is running and this is the first open API call, then
     * the event is logged.
     */
    public long logForegroundServiceApiEventBegin(@ForegroundServiceApiType int apiType,
            int uid, int pid, String packageName) {
        final FgsApiRecord callStart =
                new FgsApiRecord(uid, pid, packageName, apiType, System.currentTimeMillis());
        UidState uidState = mUids.get(uid);
        if (uidState == null) {
            uidState = new UidState();
            mUids.put(uid, uidState);
        }
        // now we want to figure out if this call is associated with any FGS
        // is there an FGS?
        if (!hasValidActiveFgs(uid, apiType)) {
            // no FGS running currently, so this API
            // started without an FGS
            // initialize the started without FGS count if it isn't already
            int openWithoutFgsCountIndex =
                    uidState.mOpenedWithoutFgsCount.indexOfKey(apiType);

            if (openWithoutFgsCountIndex < 0) {
                uidState.mOpenedWithoutFgsCount.put(apiType, 0);
                openWithoutFgsCountIndex =
                        uidState.mOpenedWithoutFgsCount.indexOfKey(apiType);
            }
            // insert this record as the first open API call
            // IF we do not have one
            if (!uidState.mApiOpenCalls.contains(apiType)
                    || uidState.mOpenedWithoutFgsCount.valueAt(openWithoutFgsCountIndex) == 0) {
                uidState.mApiOpenCalls.put(apiType, callStart);
            }
            // now update the count of the open API calls
            // started without an FGS
            uidState.mOpenedWithoutFgsCount
                    .put(apiType, uidState.mOpenedWithoutFgsCount.get(apiType) + 1);
            return callStart.mTimeStart;
        }
        // so there is an FGS running
        // that we can associate with
        // we now need to update the count
        // for open calls that started
        // with an FGS
        int openWithFgsIndex = uidState.mOpenWithFgsCount.indexOfKey(apiType);

        if (openWithFgsIndex < 0) {
            uidState.mOpenWithFgsCount.put(apiType, 0);
            openWithFgsIndex = uidState.mOpenWithFgsCount.indexOfKey(apiType);
        }
        uidState.mOpenWithFgsCount
                .put(apiType, uidState.mOpenWithFgsCount.valueAt(openWithFgsIndex) + 1);
        final ArrayMap<ComponentName, ServiceRecord> fgsListMap = uidState.mRunningFgs.get(apiType);

        // now we get the relevant FGS to log with
        final int apiTypes = apiType;
        final long timestamps = callStart.mTimeStart;
        if (uidState.mOpenWithFgsCount.valueAt(openWithFgsIndex) == 1) {
            for (ServiceRecord record : fgsListMap.values()) {
                logFgsApiEvent(record,
                        FGS_STATE_CHANGED_API_CALL,
                        FGS_API_BEGIN_WITH_FGS,
                        apiTypes,
                        timestamps);
            }
        }
        return callStart.mTimeStart;
    }

    /**
     * Called to log the end of an API call. If this
     * is the last API close call, it will be logged
     * as an event.
     */
    public long logForegroundServiceApiEventEnd(@ForegroundServiceApiType int apiType,
            int uid, int pid) {
        // are there even FGS that we want to associate with?
        // if there's even an entry in the open call count,
        // then we should care, otherwise we assume
        // it's not related to any FGS
        UidState uidState = mUids.get(uid);
        if (uidState == null) {
            Slog.w(TAG, "API event end called before start!");
            return -1;
        }
        final int apiIndex = uidState.mOpenWithFgsCount.indexOfKey(apiType);
        if (apiIndex >= 0) {
            // are there any calls that started with an FGS?
            if (uidState.mOpenWithFgsCount.get(apiType) != 0) {
                // we should decrement the count, since we only
                // want to log the last close call
                uidState.mOpenWithFgsCount.put(apiType,
                        uidState.mOpenWithFgsCount.get(apiType) - 1);
            }
            // is there no FGS running and this is the last close call?
            if (!hasValidActiveFgs(uid, apiType)
                    && uidState.mOpenWithFgsCount.get(apiType) == 0) {
                // we just log that an event happened w/ no
                // FGS associated. This is to avoid dangling
                // events
                final long timestamp = System.currentTimeMillis();
                final int apiTypes = apiType;
                logFgsApiEventWithNoFgs(uid, FGS_API_END_WITHOUT_FGS, apiTypes, timestamp);
                // we should now remove the count, so as to signal that
                // there was never an FGS called that can be associated
                uidState.mOpenWithFgsCount.removeAt(apiIndex);
                return timestamp;
            }
        }
        // we know now that this call is not coming from an
        // open FGS associated API call. So it is likely
        // a part of an unassociated call that has now been
        // closed. So we decrement that count
        if (uidState.mOpenedWithoutFgsCount.indexOfKey(apiType) < 0) {
            // initialize if we don't contain
            uidState.mOpenedWithoutFgsCount.put(apiType, 0);
        }
        int apiOpenWithoutFgsCount = uidState.mOpenedWithoutFgsCount.get(apiType);
        if (apiOpenWithoutFgsCount != 0) {
            apiOpenWithoutFgsCount -= 1;
            if (apiOpenWithoutFgsCount == 0) {
                uidState.mApiOpenCalls.remove(apiType);
            }
            uidState.mOpenedWithoutFgsCount
                    .put(apiType, apiOpenWithoutFgsCount);
            return System.currentTimeMillis();
        }
        // This is a part of a valid active FGS
        // we should definitely update the pointer to the
        // last closed API call
        final SparseArray<FgsApiRecord> callsByUid = uidState.mApiClosedCalls;
        final FgsApiRecord closedCall =
                new FgsApiRecord(uid, pid, "", apiType, System.currentTimeMillis());
        uidState.mApiClosedCalls.put(apiType, closedCall);
        return closedCall.mTimeStart;
    }

    /**
     * Log an API state change. This is only to be used by media playback
     */
    public void logForegroundServiceApiStateChanged(@ForegroundServiceApiType int apiType,
            int uid, int pid, int state) {
        UidState uidState = mUids.get(uid);
        if (!uidState.mRunningFgs.contains(apiType)) {
            // if there is no FGS running for this type that could mean that
            // either the FGS was stopped a while ago or
            // that the API call was never run with an FGS
            return;
        }
        final ArrayMap<ComponentName, ServiceRecord> fgsRecords = uidState.mRunningFgs.get(apiType);
        final int apiTypes = apiType;
        final long timestamp = System.currentTimeMillis();
        for (ServiceRecord record : fgsRecords.values()) {
            logFgsApiEvent(record,
                    FGS_STATE_CHANGED_API_CALL,
                    state,
                    apiTypes,
                    timestamp);
        }
    }

    private IntArray convertFgsTypeToApiTypes(int fgsType) {
        final IntArray types = new IntArray();
        if ((fgsType & ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA)
                == ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA) {
            types.add(FOREGROUND_SERVICE_API_TYPE_CAMERA);
        }
        if ((fgsType & ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE)
                == ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE) {
            types.add(FOREGROUND_SERVICE_API_TYPE_BLUETOOTH);
            types.add(FOREGROUND_SERVICE_API_TYPE_USB);
            types.add(FOREGROUND_SERVICE_API_TYPE_CDM);
        }
        if ((fgsType & ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION)
                == ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION) {
            types.add(FOREGROUND_SERVICE_API_TYPE_LOCATION);
        }
        if ((fgsType & ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
                == ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK) {
            types.add(FOREGROUND_SERVICE_API_TYPE_AUDIO);
            types.add(FOREGROUND_SERVICE_API_TYPE_MEDIA_PLAYBACK);
        }
        if ((fgsType & ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE)
                == ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE) {
            types.add(FOREGROUND_SERVICE_API_TYPE_MICROPHONE);
        }
        if ((fgsType & ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL)
                == ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL) {
            types.add(FOREGROUND_SERVICE_API_TYPE_PHONE_CALL);
        }
        return types;
    }

    private boolean hasValidActiveFgs(int uid, @ForegroundServiceApiType int apiType) {
        UidState uidState = mUids.get(uid);
        if (uidState != null) {
            return uidState.mRunningFgs.contains(apiType);
        }
        return false;
    }

    /**
     * Logs an API event that occurred while an FGS was running
     */
    @VisibleForTesting
    public void logFgsApiEvent(ServiceRecord r, int fgsState,
            @FgsApiState int apiState,
            @ForegroundServiceApiType int apiType, long timestamp) {
        long apiDurationBeforeFgsStart = 0;
        long apiDurationAfterFgsEnd = 0;
        UidState uidState = mUids.get(r.appInfo.uid);
        if (uidState == null) {
            return;
        }
        if (uidState.mFirstFgsTimeStamp.contains(apiType)) {
            apiDurationBeforeFgsStart = uidState.mFirstFgsTimeStamp.get(apiType) - timestamp;
        }
        if (uidState.mLastFgsTimeStamp.contains(apiType)) {
            apiDurationAfterFgsEnd = timestamp - uidState.mLastFgsTimeStamp.get(apiType);
        }
        final int[] apiTypes = new int[1];
        apiTypes[0] = apiType;
        final long[] timeStamps = new long[1];
        timeStamps[0] = timestamp;
        FrameworkStatsLog.write(FrameworkStatsLog.FOREGROUND_SERVICE_STATE_CHANGED,
                r.appInfo.uid,
                r.shortInstanceName,
                fgsState, // FGS State
                r.isFgsAllowedWIU(), // allowWhileInUsePermissionInFgs
                r.getFgsAllowStart(), // fgsStartReasonCode
                r.appInfo.targetSdkVersion,
                r.mRecentCallingUid,
                0, // callerTargetSdkVersion
                r.mInfoTempFgsAllowListReason != null
                        ? r.mInfoTempFgsAllowListReason.mCallingUid : INVALID_UID,
                r.mFgsNotificationWasDeferred,
                r.mFgsNotificationShown,
                0, // durationMs
                r.mStartForegroundCount,
                ActivityManagerUtils.hashComponentNameForAtom(r.shortInstanceName),
                r.mFgsHasNotificationPermission,
                r.foregroundServiceType,
                0,
                r.mIsFgsDelegate,
                r.mFgsDelegation != null ? r.mFgsDelegation.mOptions.mClientUid : INVALID_UID,
                r.mFgsDelegation != null ? r.mFgsDelegation.mOptions.mDelegationService
                        : ForegroundServiceDelegationOptions.DELEGATION_SERVICE_DEFAULT,
                apiState,
                apiTypes,
                timeStamps,
                ActivityManager.PROCESS_STATE_UNKNOWN,
                ActivityManager.PROCESS_CAPABILITY_NONE,
                ActivityManager.PROCESS_STATE_UNKNOWN,
                ActivityManager.PROCESS_CAPABILITY_NONE,
                apiDurationBeforeFgsStart,
                apiDurationAfterFgsEnd,
                r.mAllowWhileInUsePermissionInFgsReasonNoBinding,
                r.mAllowWIUInBindService,
                r.mAllowWIUByBindings,
                r.mAllowStartForegroundNoBinding,
                r.mAllowStartInBindService,
                r.mAllowStartByBindings,
                FOREGROUND_SERVICE_STATE_CHANGED__FGS_START_API__FGSSTARTAPI_NA,
                false
        );
    }

    /**
     * Logs an API event that occurred while no FGS was running.
     * Only used to log API exit events
     */
    @VisibleForTesting
    public void logFgsApiEventWithNoFgs(int uid,
            @FgsApiState int apiState,
            @ForegroundServiceApiType int apiType, long timestamp) {
        long apiDurationAfterFgsEnd = 0;
        UidState uidState = mUids.get(uid);
        if (uidState == null) {
            return;
        }
        if (uidState.mLastFgsTimeStamp.contains(apiType)) {
            apiDurationAfterFgsEnd = timestamp - uidState.mLastFgsTimeStamp.get(apiType);
        }
        final int[] apiTypes = new int[1];
        apiTypes[0] = apiType;
        final long[] timeStamps = new long[1];
        timeStamps[0] = timestamp;
        FrameworkStatsLog.write(FrameworkStatsLog.FOREGROUND_SERVICE_STATE_CHANGED,
                uid,
                null,
                FGS_STATE_CHANGED_API_CALL,
                false, // allowWhileInUsePermissionInFgs
                0, // fgsStartReasonCode
                0,
                uid,
                0, // callerTargetSdkVersion
                0,
                false,
                false,
                0, // durationMs
                0,
                0,
                false,
                0,
                0,
                false,
                0,
                0,
                apiState,
                apiTypes,
                timeStamps,
                ActivityManager.PROCESS_STATE_UNKNOWN,
                ActivityManager.PROCESS_CAPABILITY_NONE,
                ActivityManager.PROCESS_STATE_UNKNOWN,
                ActivityManager.PROCESS_CAPABILITY_NONE,
                0,
                apiDurationAfterFgsEnd,
                0,
                0,
                0,
                0,
                0,
                0,
                FOREGROUND_SERVICE_STATE_CHANGED__FGS_START_API__FGSSTARTAPI_NA,
                false
        );
    }

    /**
     * Internal class for tracking open API calls
     */
    private static class FgsApiRecord {
        final int mUid; // the UID from where the API call came from
        final int mPid; // the PID from where the API call came from
        final String mPackageName; // the package name from where the API call came from
        @ForegroundServiceApiType
        int mType; // the type of API call (camera, etc)
        boolean mIsAssociatedWithFgs; // is it associated with an FGS?
        ServiceRecord mAssociatedFgsRecord; // the FGS it is associated with
        final long mTimeStart; // timestamp for the event

        FgsApiRecord(int uid,
                int pid,
                String packageName,
                @ForegroundServiceApiType int type,
                long timeStart) {
            this.mUid = uid;
            this.mPid = pid;
            this.mPackageName = packageName;
            this.mType = type;
            this.mTimeStart = timeStart;
        }
    }
}