Merge "Another way to keep track number of foreground services in the device."...

import java.util.List;

import java.util.Objects;

import java.util.Set;

import java.util.concurrent.atomic.AtomicReference;

import java.util.function.Predicate;

public final class ActiveServices {

                    | ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE

                    | ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION;

    // Keep track of number of foreground services and number of apps that have foreground

    // services in the device. This field is made to be directly accessed without holding AMS lock.

    static final AtomicReference<Pair<Integer, Integer>> sNumForegroundServices =

            new AtomicReference(new Pair<>(0, 0));

    // Foreground service is stopped for unknown reason.

    static final int FGS_STOP_REASON_UNKNOWN = 0;

    // Foreground service is stopped by app calling Service.stopForeground().

        final ArrayList<ServiceRecord> mStartingBackground = new ArrayList<>();

        final ArrayMap<String, ActiveForegroundApp> mActiveForegroundApps = new ArrayMap<>();

        boolean mActiveForegroundAppsChanged;

        static final int MSG_BG_START_TIMEOUT = 1;

                        logFGSStateChangeLocked(r,

                                FrameworkStatsLog.FOREGROUND_SERVICE_STATE_CHANGED__STATE__ENTER,

                                0, FGS_STOP_REASON_UNKNOWN);

                        updateNumForegroundServicesLocked();

                    }

                    // Even if the service is already a FGS, we need to update the notification,

                    // so we need to call it again.

                    mAm.updateLruProcessLocked(r.app, false, null);

                    updateServiceForegroundLocked(r.app.mServices, true);

                }

                updateNumForegroundServicesLocked();

            }

        }

    }

        }

        smap.ensureNotStartingBackgroundLocked(r);

        updateNumForegroundServicesLocked();

    }

    private void dropFgsNotificationStateLocked(ServiceRecord r) {

                fgsStopReasonToString(fgsStopReason));

    }

    private void updateNumForegroundServicesLocked() {

        sNumForegroundServices.set(mAm.mProcessList.getNumForegroundServices());

    }

    boolean canAllowWhileInUsePermissionInFgsLocked(int callingPid, int callingUid,

            String callingPackage) {

        return shouldAllowFgsWhileInUsePermissionLocked(callingPackage, callingPid, callingUid,

                                                < LmkdStatsReporter.KILL_OCCURRED_MSG_SIZE) {

                                            return false;

                                        }

                                        Pair<Integer, Integer> temp = getNumForegroundServices();

                                        final int totalForegroundServices = temp.first;

                                        final int procsWithForegroundServices = temp.second;

                                        // Note: directly access

                                        // ActiveServices.sNumForegroundServices, do not try to

                                        // hold AMS lock here, otherwise it is a potential deadlock.

                                        Pair<Integer, Integer> foregroundServices =

                                                ActiveServices.sNumForegroundServices.get();

                                        LmkdStatsReporter.logKillOccurred(inputData,

                                                totalForegroundServices,

                                                procsWithForegroundServices);

                                                foregroundServices.first,

                                                foregroundServices.second);

                                        return true;

                                    case LMK_STATE_CHANGED:

                                        if (receivedLen