/* * 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 static com.android.server.am.ActivityManagerDebugConfig.TAG_AM; import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME; import static com.android.server.am.AppRestrictionController.DEVICE_CONFIG_SUBNAMESPACE_PREFIX; import static com.android.server.am.BaseAppStateTracker.ONE_DAY; import static com.android.server.am.BaseAppStateTracker.STATE_TYPE_MEDIA_SESSION; import android.annotation.NonNull; import android.content.Context; import android.media.session.MediaController; import android.media.session.MediaSessionManager.OnActiveSessionsChangedListener; import android.os.HandlerExecutor; import android.os.PowerExemptionManager.ReasonCode; import android.os.SystemClock; import android.os.UserHandle; import android.util.ArrayMap; import android.util.Slog; import android.util.SparseArray; import com.android.internal.app.ProcessMap; import com.android.server.am.AppMediaSessionTracker.AppMediaSessionPolicy; import com.android.server.am.AppRestrictionController.TrackerType; import com.android.server.am.BaseAppStateDurationsTracker.SimplePackageDurations; import com.android.server.am.BaseAppStateEventsTracker.BaseAppStateEventsPolicy; import java.io.PrintWriter; import java.lang.reflect.Constructor; import java.util.List; /** * The tracker for monitoring the active media sessions of apps. */ final class AppMediaSessionTracker extends BaseAppStateDurationsTracker { static final String TAG = TAG_WITH_CLASS_NAME ? "AppMediaSessionTracker" : TAG_AM; static final boolean DEBUG_MEDIA_SESSION_TRACKER = false; private final HandlerExecutor mHandlerExecutor; private final OnActiveSessionsChangedListener mSessionsChangedListener = this::handleMediaSessionChanged; // Unlocked since it's only accessed in single thread. private final ProcessMap mTmpMediaControllers = new ProcessMap<>(); AppMediaSessionTracker(Context context, AppRestrictionController controller) { this(context, controller, null, null); } AppMediaSessionTracker(Context context, AppRestrictionController controller, Constructor> injector, Object outerContext) { super(context, controller, injector, outerContext); mHandlerExecutor = new HandlerExecutor(mBgHandler); mInjector.setPolicy(new AppMediaSessionPolicy(mInjector, this)); } @Override public SimplePackageDurations createAppStateEvents(int uid, String packageName) { return new SimplePackageDurations(uid, packageName, mInjector.getPolicy()); } @Override public SimplePackageDurations createAppStateEvents(SimplePackageDurations other) { return new SimplePackageDurations(other); } private void onBgMediaSessionMonitorEnabled(boolean enabled) { if (enabled) { mInjector.getMediaSessionManager().addOnActiveSessionsChangedListener( null, UserHandle.ALL, mHandlerExecutor, mSessionsChangedListener); } else { mInjector.getMediaSessionManager().removeOnActiveSessionsChangedListener( mSessionsChangedListener); } } private void handleMediaSessionChanged(List controllers) { if (controllers != null) { synchronized (mLock) { final long now = SystemClock.elapsedRealtime(); for (MediaController controller : controllers) { final String packageName = controller.getPackageName(); final int uid = controller.getSessionToken().getUid(); SimplePackageDurations pkg = mPkgEvents.get(uid, packageName); if (pkg == null) { pkg = createAppStateEvents(uid, packageName); mPkgEvents.put(uid, packageName, pkg); } if (!pkg.isActive()) { pkg.addEvent(true, now); notifyListenersOnStateChange(pkg.mUid, pkg.mPackageName, true, now, STATE_TYPE_MEDIA_SESSION); } // Mark it as active, so we could filter out inactive ones below. mTmpMediaControllers.put(packageName, uid, Boolean.TRUE); if (DEBUG_MEDIA_SESSION_TRACKER) { Slog.i(TAG, "Active media session from " + packageName + "/" + UserHandle.formatUid(uid)); } } // Iterate the duration list and stop those inactive ones. final SparseArray> map = mPkgEvents.getMap(); for (int i = map.size() - 1; i >= 0; i--) { final ArrayMap val = map.valueAt(i); for (int j = val.size() - 1; j >= 0; j--) { final SimplePackageDurations pkg = val.valueAt(j); if (pkg.isActive() && mTmpMediaControllers.get(pkg.mPackageName, pkg.mUid) == null) { // This package has removed its controller, issue a stop event. pkg.addEvent(false, now); notifyListenersOnStateChange(pkg.mUid, pkg.mPackageName, false, now, STATE_TYPE_MEDIA_SESSION); } } } } mTmpMediaControllers.clear(); } else { synchronized (mLock) { // Issue stop event to all active trackers. final SparseArray> map = mPkgEvents.getMap(); final long now = SystemClock.elapsedRealtime(); for (int i = map.size() - 1; i >= 0; i--) { final ArrayMap val = map.valueAt(i); for (int j = val.size() - 1; j >= 0; j--) { final SimplePackageDurations pkg = val.valueAt(j); if (pkg.isActive()) { pkg.addEvent(false, now); notifyListenersOnStateChange(pkg.mUid, pkg.mPackageName, false, now, STATE_TYPE_MEDIA_SESSION); } } } } } } private void trimDurations() { final long now = SystemClock.elapsedRealtime(); trim(Math.max(0, now - mInjector.getPolicy().getMaxTrackingDuration())); } @Override @TrackerType int getType() { return AppRestrictionController.TRACKER_TYPE_MEDIA_SESSION; } @Override void dump(PrintWriter pw, String prefix) { pw.print(prefix); pw.println("APP MEDIA SESSION TRACKER:"); super.dump(pw, " " + prefix); } static final class AppMediaSessionPolicy extends BaseAppStateEventsPolicy { /** * Whether or not we should enable the monitoring on media sessions. */ static final String KEY_BG_MEADIA_SESSION_MONITOR_ENABLED = DEVICE_CONFIG_SUBNAMESPACE_PREFIX + "media_session_monitor_enabled"; /** * The maximum duration we'd keep tracking, events earlier than that will be discarded. */ static final String KEY_BG_MEDIA_SESSION_MONITOR_MAX_TRACKING_DURATION = DEVICE_CONFIG_SUBNAMESPACE_PREFIX + "media_session_monitor_max_tracking_duration"; /** * Default value to {@link #mTrackerEnabled}. */ static final boolean DEFAULT_BG_MEDIA_SESSION_MONITOR_ENABLED = true; /** * Default value to {@link #mBgMediaSessionMonitorMaxTrackingDurationMs}. */ static final long DEFAULT_BG_MEDIA_SESSION_MONITOR_MAX_TRACKING_DURATION = 4 * ONE_DAY; AppMediaSessionPolicy(@NonNull Injector injector, @NonNull AppMediaSessionTracker tracker) { super(injector, tracker, KEY_BG_MEADIA_SESSION_MONITOR_ENABLED, DEFAULT_BG_MEDIA_SESSION_MONITOR_ENABLED, KEY_BG_MEDIA_SESSION_MONITOR_MAX_TRACKING_DURATION, DEFAULT_BG_MEDIA_SESSION_MONITOR_MAX_TRACKING_DURATION); } @Override public void onTrackerEnabled(boolean enabled) { mTracker.onBgMediaSessionMonitorEnabled(enabled); } @Override public void onMaxTrackingDurationChanged(long maxDuration) { mTracker.mBgHandler.post(mTracker::trimDurations); } @Override String getExemptionReasonString(String packageName, int uid, @ReasonCode int reason) { // This tracker is a helper class for other trackers, we don't track exemptions here. return "n/a"; } @Override void dump(PrintWriter pw, String prefix) { pw.print(prefix); pw.println("APP MEDIA SESSION TRACKER POLICY SETTINGS:"); super.dump(pw, " " + prefix); } } }