services/core/java/com/android/server/am/BaseAppStateEventsTracker.java - platform/frameworks/base - Git at Google

 /*
  * 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.am;

 import android.annotation.NonNull;
 import android.annotation.UserIdInt;
 import android.app.ActivityManager;
 import android.content.Context;
 import android.os.PowerExemptionManager;
 import android.os.PowerExemptionManager.ReasonCode;
 import android.os.SystemClock;
 import android.os.UserHandle;
 import android.provider.DeviceConfig;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.SparseArray;

 import com.android.internal.annotations.GuardedBy;
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.server.am.BaseAppStateEvents.MaxTrackingDurationConfig;
 import com.android.server.am.BaseAppStateEventsTracker.BaseAppStateEventsPolicy;

 import java.io.PrintWriter;
 import java.lang.reflect.Constructor;
 import java.util.LinkedList;

 /**
  * Base class to track certain state event of apps.
  */
 abstract class BaseAppStateEventsTracker
         <T extends BaseAppStateEventsPolicy, U extends BaseAppStateEvents>
         extends BaseAppStateTracker<T> implements BaseAppStateEvents.Factory<U> {
     static final boolean DEBUG_BASE_APP_STATE_EVENTS_TRACKER = false;

     @GuardedBy("mLock")
     final UidProcessMap<U> mPkgEvents = new UidProcessMap<>();

     @GuardedBy("mLock")
     final ArraySet<Integer> mTopUids = new ArraySet<>();

     BaseAppStateEventsTracker(Context context, AppRestrictionController controller,
             Constructor<? extends Injector<T>> injector, Object outerContext) {
         super(context, controller, injector, outerContext);
     }

     @VisibleForTesting
     void reset() {
         synchronized (mLock) {
             mPkgEvents.clear();
             mTopUids.clear();
         }
     }

     @GuardedBy("mLock")
     U getUidEventsLocked(int uid) {
         U events = null;
         final ArrayMap<String, U> map = mPkgEvents.getMap().get(uid);
         if (map == null) {
             return null;
         }
         for (int i = map.size() - 1; i >= 0; i--) {
             final U event = map.valueAt(i);
             if (event != null) {
                 if (events == null) {
                     events = createAppStateEvents(uid, event.mPackageName);
                 }
                 events.add(event);
             }
         }
         return events;
     }

     void trim(long earliest) {
         synchronized (mLock) {
             trimLocked(earliest);
         }
     }

     @GuardedBy("mLock")
     void trimLocked(long earliest) {
         final SparseArray<ArrayMap<String, U>> map = mPkgEvents.getMap();
         for (int i = map.size() - 1; i >= 0; i--) {
             final ArrayMap<String, U> val = map.valueAt(i);
             for (int j = val.size() - 1; j >= 0; j--) {
                 final U v = val.valueAt(j);
                 v.trim(earliest);
                 if (v.isEmpty()) {
                     val.removeAt(j);
                 }
             }
             if (val.size() == 0) {
                 map.removeAt(i);
             }
         }
     }

     boolean isUidOnTop(int uid) {
         synchronized (mLock) {
             return mTopUids.contains(uid);
         }
     }

     @GuardedBy("mLock")
     void onUntrackingUidLocked(int uid) {
     }

     @Override
     void onUidProcStateChanged(final int uid, final int procState) {
         synchronized (mLock) {
             if (mPkgEvents.getMap().indexOfKey(uid) < 0) {
                 // If we're not tracking its events, ignore its UID state changes.
                 return;
             }
             onUidProcStateChangedUncheckedLocked(uid, procState);
         }
     }

     @GuardedBy("mLock")
     void onUidProcStateChangedUncheckedLocked(final int uid, final int procState) {
         if (procState < ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE) {
             mTopUids.add(uid);
         } else {
             mTopUids.remove(uid);
         }
     }

     @Override
     void onUidGone(final int uid) {
         synchronized (mLock) {
             mTopUids.remove(uid);
         }
     }

     @Override
     void onUidRemoved(final int uid) {
         synchronized (mLock) {
             mPkgEvents.getMap().remove(uid);
             onUntrackingUidLocked(uid);
         }
     }

     @Override
     void onUserRemoved(final @UserIdInt int userId) {
         synchronized (mLock) {
             final SparseArray<ArrayMap<String, U>> map = mPkgEvents.getMap();
             for (int i = map.size() - 1; i >= 0; i--) {
                 final int uid = map.keyAt(i);
                 if (UserHandle.getUserId(uid) == userId) {
                     map.removeAt(i);
                     onUntrackingUidLocked(uid);
                 }
             }
         }
     }

     @Override
     void dump(PrintWriter pw, String prefix) {
         final T policy = mInjector.getPolicy();
         synchronized (mLock) {
             final long now = SystemClock.elapsedRealtime();
             final SparseArray<ArrayMap<String, U>> map = mPkgEvents.getMap();
             for (int i = map.size() - 1; i >= 0; i--) {
                 final int uid = map.keyAt(i);
                 final ArrayMap<String, U> val = map.valueAt(i);
                 for (int j = val.size() - 1; j >= 0; j--) {
                     final String packageName = val.keyAt(j);
                     final U events = val.valueAt(j);
                     dumpEventHeaderLocked(pw, prefix, packageName, uid, events, policy);
                     dumpEventLocked(pw, prefix, events, now);
                 }
             }
         }
         dumpOthers(pw, prefix);
         policy.dump(pw, prefix);
     }

     void dumpOthers(PrintWriter pw, String prefix) {
     }

     @GuardedBy("mLock")
     void dumpEventHeaderLocked(PrintWriter pw, String prefix, String packageName, int uid, U events,
             T policy) {
         pw.print(prefix);
         pw.print("* ");
         pw.print(packageName);
         pw.print('/');
         pw.print(UserHandle.formatUid(uid));
         pw.print(" exemption=");
         pw.println(policy.getExemptionReasonString(packageName, uid, events.mExemptReason));
     }

     @GuardedBy("mLock")
     void dumpEventLocked(PrintWriter pw, String prefix, U events, long now) {
         events.dump(pw, "  " + prefix, now);
     }

     abstract static class BaseAppStateEventsPolicy<V extends BaseAppStateEventsTracker>
             extends BaseAppStatePolicy<V> implements MaxTrackingDurationConfig {
         /**
          * The key to the maximum duration we'd keep tracking, events earlier than that
          * will be discarded.
          */
         final @NonNull String mKeyMaxTrackingDuration;

         /**
          * The default to the {@link #mMaxTrackingDuration}.
          */
         final long mDefaultMaxTrackingDuration;

         /**
          * The maximum duration we'd keep tracking, events earlier than that will be discarded.
          */
         volatile long mMaxTrackingDuration;

         BaseAppStateEventsPolicy(@NonNull Injector<?> injector, @NonNull V tracker,
                 @NonNull String keyTrackerEnabled, boolean defaultTrackerEnabled,
                 @NonNull String keyMaxTrackingDuration, long defaultMaxTrackingDuration) {
             super(injector, tracker, keyTrackerEnabled, defaultTrackerEnabled);
             mKeyMaxTrackingDuration = keyMaxTrackingDuration;
             mDefaultMaxTrackingDuration = defaultMaxTrackingDuration;
         }

         @Override
         public void onPropertiesChanged(String name) {
             if (mKeyMaxTrackingDuration.equals(name)) {
                 updateMaxTrackingDuration();
             } else {
                 super.onPropertiesChanged(name);
             }
         }

         @Override
         public void onSystemReady() {
             super.onSystemReady();
             updateMaxTrackingDuration();
         }

         /**
          * Called when the maximum duration we'd keep tracking has been changed.
          */
         public abstract void onMaxTrackingDurationChanged(long maxDuration);

         void updateMaxTrackingDuration() {
             long max = DeviceConfig.getLong(
                     DeviceConfig.NAMESPACE_ACTIVITY_MANAGER,
                     mKeyMaxTrackingDuration, mDefaultMaxTrackingDuration);
             if (max != mMaxTrackingDuration) {
                 mMaxTrackingDuration = max;
                 onMaxTrackingDurationChanged(max);
             }
         }

         @Override
         public long getMaxTrackingDuration() {
             return mMaxTrackingDuration;
         }

         String getExemptionReasonString(String packageName, int uid, @ReasonCode int reason) {
             return PowerExemptionManager.reasonCodeToString(reason);
         }

         @Override
         void dump(PrintWriter pw, String prefix) {
             super.dump(pw, prefix);
             if (isEnabled()) {
                 pw.print(prefix);
                 pw.print(mKeyMaxTrackingDuration);
                 pw.print('=');
                 pw.println(mMaxTrackingDuration);
             }
         }
     }

     /**
      * Simple event table, with only one track of events.
      */
     static class SimplePackageEvents extends BaseAppStateTimeEvents {
         static final int DEFAULT_INDEX = 0;

         SimplePackageEvents(int uid, String packageName,
                 MaxTrackingDurationConfig maxTrackingDurationConfig) {
             super(uid, packageName, 1, TAG, maxTrackingDurationConfig);
             mEvents[DEFAULT_INDEX] = new LinkedList<Long>();
         }

         long getTotalEvents(long now) {
             return getTotalEvents(now, DEFAULT_INDEX);
         }

         long getTotalEventsSince(long since, long now) {
             return getTotalEventsSince(since, now, DEFAULT_INDEX);
         }

         @Override
         String formatEventTypeLabel(int index) {
             return "";
         }
     }
 }
	/*
	* 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.am;

	import android.annotation.NonNull;
	import android.annotation.UserIdInt;
	import android.app.ActivityManager;
	import android.content.Context;
	import android.os.PowerExemptionManager;
	import android.os.PowerExemptionManager.ReasonCode;
	import android.os.SystemClock;
	import android.os.UserHandle;
	import android.provider.DeviceConfig;
	import android.util.ArrayMap;
	import android.util.ArraySet;
	import android.util.SparseArray;

	import com.android.internal.annotations.GuardedBy;
	import com.android.internal.annotations.VisibleForTesting;
	import com.android.server.am.BaseAppStateEvents.MaxTrackingDurationConfig;
	import com.android.server.am.BaseAppStateEventsTracker.BaseAppStateEventsPolicy;

	import java.io.PrintWriter;
	import java.lang.reflect.Constructor;
	import java.util.LinkedList;

	/**
	* Base class to track certain state event of apps.
	*/
	abstract class BaseAppStateEventsTracker
	<T extends BaseAppStateEventsPolicy, U extends BaseAppStateEvents>
	extends BaseAppStateTracker<T> implements BaseAppStateEvents.Factory<U> {
	static final boolean DEBUG_BASE_APP_STATE_EVENTS_TRACKER = false;

	@GuardedBy("mLock")
	final UidProcessMap<U> mPkgEvents = new UidProcessMap<>();

	@GuardedBy("mLock")
	final ArraySet<Integer> mTopUids = new ArraySet<>();

	BaseAppStateEventsTracker(Context context, AppRestrictionController controller,
	Constructor<? extends Injector<T>> injector, Object outerContext) {
	super(context, controller, injector, outerContext);
	}

	@VisibleForTesting
	void reset() {
	synchronized (mLock) {
	mPkgEvents.clear();
	mTopUids.clear();
	}
	}

	@GuardedBy("mLock")
	U getUidEventsLocked(int uid) {
	U events = null;
	final ArrayMap<String, U> map = mPkgEvents.getMap().get(uid);
	if (map == null) {
	return null;
	}
	for (int i = map.size() - 1; i >= 0; i--) {
	final U event = map.valueAt(i);
	if (event != null) {
	if (events == null) {
	events = createAppStateEvents(uid, event.mPackageName);
	}
	events.add(event);
	}
	}
	return events;
	}

	void trim(long earliest) {
	synchronized (mLock) {
	trimLocked(earliest);
	}
	}

	@GuardedBy("mLock")
	void trimLocked(long earliest) {
	final SparseArray<ArrayMap<String, U>> map = mPkgEvents.getMap();
	for (int i = map.size() - 1; i >= 0; i--) {
	final ArrayMap<String, U> val = map.valueAt(i);
	for (int j = val.size() - 1; j >= 0; j--) {
	final U v = val.valueAt(j);
	v.trim(earliest);
	if (v.isEmpty()) {
	val.removeAt(j);
	}
	}
	if (val.size() == 0) {
	map.removeAt(i);
	}
	}
	}

	boolean isUidOnTop(int uid) {
	synchronized (mLock) {
	return mTopUids.contains(uid);
	}
	}

	@GuardedBy("mLock")
	void onUntrackingUidLocked(int uid) {
	}

	@Override
	void onUidProcStateChanged(final int uid, final int procState) {
	synchronized (mLock) {
	if (mPkgEvents.getMap().indexOfKey(uid) < 0) {
	// If we're not tracking its events, ignore its UID state changes.
	return;
	}
	onUidProcStateChangedUncheckedLocked(uid, procState);
	}
	}

	@GuardedBy("mLock")
	void onUidProcStateChangedUncheckedLocked(final int uid, final int procState) {
	if (procState < ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE) {
	mTopUids.add(uid);
	} else {
	mTopUids.remove(uid);
	}
	}

	@Override
	void onUidGone(final int uid) {
	synchronized (mLock) {
	mTopUids.remove(uid);
	}
	}

	@Override
	void onUidRemoved(final int uid) {
	synchronized (mLock) {
	mPkgEvents.getMap().remove(uid);
	onUntrackingUidLocked(uid);
	}
	}

	@Override
	void onUserRemoved(final @UserIdInt int userId) {
	synchronized (mLock) {
	final SparseArray<ArrayMap<String, U>> map = mPkgEvents.getMap();
	for (int i = map.size() - 1; i >= 0; i--) {
	final int uid = map.keyAt(i);
	if (UserHandle.getUserId(uid) == userId) {
	map.removeAt(i);
	onUntrackingUidLocked(uid);
	}
	}
	}
	}

	@Override
	void dump(PrintWriter pw, String prefix) {
	final T policy = mInjector.getPolicy();
	synchronized (mLock) {
	final long now = SystemClock.elapsedRealtime();
	final SparseArray<ArrayMap<String, U>> map = mPkgEvents.getMap();
	for (int i = map.size() - 1; i >= 0; i--) {
	final int uid = map.keyAt(i);
	final ArrayMap<String, U> val = map.valueAt(i);
	for (int j = val.size() - 1; j >= 0; j--) {
	final String packageName = val.keyAt(j);
	final U events = val.valueAt(j);
	dumpEventHeaderLocked(pw, prefix, packageName, uid, events, policy);
	dumpEventLocked(pw, prefix, events, now);
	}
	}
	}
	dumpOthers(pw, prefix);
	policy.dump(pw, prefix);
	}

	void dumpOthers(PrintWriter pw, String prefix) {
	}

	@GuardedBy("mLock")
	void dumpEventHeaderLocked(PrintWriter pw, String prefix, String packageName, int uid, U events,
	T policy) {
	pw.print(prefix);
	pw.print("* ");
	pw.print(packageName);
	pw.print('/');
	pw.print(UserHandle.formatUid(uid));
	pw.print(" exemption=");
	pw.println(policy.getExemptionReasonString(packageName, uid, events.mExemptReason));
	}

	@GuardedBy("mLock")
	void dumpEventLocked(PrintWriter pw, String prefix, U events, long now) {
	events.dump(pw, " " + prefix, now);
	}

	abstract static class BaseAppStateEventsPolicy<V extends BaseAppStateEventsTracker>
	extends BaseAppStatePolicy<V> implements MaxTrackingDurationConfig {
	/**
	* The key to the maximum duration we'd keep tracking, events earlier than that
	* will be discarded.
	*/
	final @NonNull String mKeyMaxTrackingDuration;

	/**
	* The default to the {@link #mMaxTrackingDuration}.
	*/
	final long mDefaultMaxTrackingDuration;

	/**
	* The maximum duration we'd keep tracking, events earlier than that will be discarded.
	*/
	volatile long mMaxTrackingDuration;

	BaseAppStateEventsPolicy(@NonNull Injector<?> injector, @NonNull V tracker,
	@NonNull String keyTrackerEnabled, boolean defaultTrackerEnabled,
	@NonNull String keyMaxTrackingDuration, long defaultMaxTrackingDuration) {
	super(injector, tracker, keyTrackerEnabled, defaultTrackerEnabled);
	mKeyMaxTrackingDuration = keyMaxTrackingDuration;
	mDefaultMaxTrackingDuration = defaultMaxTrackingDuration;
	}

	@Override
	public void onPropertiesChanged(String name) {
	if (mKeyMaxTrackingDuration.equals(name)) {
	updateMaxTrackingDuration();
	} else {
	super.onPropertiesChanged(name);
	}
	}

	@Override
	public void onSystemReady() {
	super.onSystemReady();
	updateMaxTrackingDuration();
	}

	/**
	* Called when the maximum duration we'd keep tracking has been changed.
	*/
	public abstract void onMaxTrackingDurationChanged(long maxDuration);

	void updateMaxTrackingDuration() {
	long max = DeviceConfig.getLong(
	DeviceConfig.NAMESPACE_ACTIVITY_MANAGER,
	mKeyMaxTrackingDuration, mDefaultMaxTrackingDuration);
	if (max != mMaxTrackingDuration) {
	mMaxTrackingDuration = max;
	onMaxTrackingDurationChanged(max);
	}
	}

	@Override
	public long getMaxTrackingDuration() {
	return mMaxTrackingDuration;
	}

	String getExemptionReasonString(String packageName, int uid, @ReasonCode int reason) {
	return PowerExemptionManager.reasonCodeToString(reason);
	}

	@Override
	void dump(PrintWriter pw, String prefix) {
	super.dump(pw, prefix);
	if (isEnabled()) {
	pw.print(prefix);
	pw.print(mKeyMaxTrackingDuration);
	pw.print('=');
	pw.println(mMaxTrackingDuration);
	}
	}
	}

	/**
	* Simple event table, with only one track of events.
	*/
	static class SimplePackageEvents extends BaseAppStateTimeEvents {
	static final int DEFAULT_INDEX = 0;

	SimplePackageEvents(int uid, String packageName,
	MaxTrackingDurationConfig maxTrackingDurationConfig) {
	super(uid, packageName, 1, TAG, maxTrackingDurationConfig);
	mEvents[DEFAULT_INDEX] = new LinkedList<Long>();
	}

	long getTotalEvents(long now) {
	return getTotalEvents(now, DEFAULT_INDEX);
	}

	long getTotalEventsSince(long since, long now) {
	return getTotalEventsSince(since, now, DEFAULT_INDEX);
	}

	@Override
	String formatEventTypeLabel(int index) {
	return "";
	}
	}
	}