/* * Copyright (C) 2024 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.telecom; import static android.media.AudioPlaybackConfiguration.PLAYER_STATE_STARTED; import android.annotation.IntDef; import android.media.AudioAttributes; import android.media.AudioManager; import android.media.AudioManager.AudioPlaybackCallback; import android.media.AudioPlaybackConfiguration; import android.media.AudioRecord; import android.media.AudioRecordingConfiguration; import android.media.AudioTrack; import android.media.MediaRecorder; import android.os.Handler; import android.os.Process; import android.telecom.Log; import android.telecom.Logging.EventManager; import android.telecom.PhoneAccountHandle; import android.util.ArrayMap; import android.util.ArraySet; import android.util.LocalLog; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.util.IndentingPrintWriter; import com.android.server.telecom.metrics.TelecomMetricsController; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.text.SimpleDateFormat; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; /** * Monitors {@link AudioRecord}, {@link AudioTrack}, and {@link AudioManager#getMode()} to determine * the reliability of audio operations for a call. Augments the Telecom dumpsys with Telecom calls * with information about calls. */ public class CallAudioWatchdog extends CallsManagerListenerBase { /** * Bit flag set on a {@link CommunicationSession#sessionAttr} to indicate that the session has * audio recording resources. */ public static final int SESSION_ATTR_HAS_AUDIO_RECORD = 1 << 0; /** * Bit flag set on a {@link CommunicationSession#sessionAttr} to indicate that the session has * audio playback resources. */ public static final int SESSION_ATTR_HAS_AUDIO_PLAYBACK = 1 << 1; /** * Bit flag set on a {@link CommunicationSession#sessionAttr} to indicate that the uid for the * session has a phone account allocated. This helps us track cases where an app is telecom * capable but chooses not to use the telecom integration. */ public static final int SESSION_ATTR_HAS_PHONE_ACCOUNT = 1 << 2; @IntDef(prefix = { "SESSION_ATTR_" }, value = {SESSION_ATTR_HAS_AUDIO_RECORD, SESSION_ATTR_HAS_AUDIO_PLAYBACK, SESSION_ATTR_HAS_PHONE_ACCOUNT}, flag = true) @Retention(RetentionPolicy.SOURCE) public @interface SessionAttribute {} /** * Proxy for operations related to phone accounts. */ public interface PhoneAccountRegistrarProxy { /** * Determines if a specified {@code uid} has an associated phone account registered. * @param uid the uid. * @return {@code true} if there is a phone account registered, {@code false} otherwise */ boolean hasPhoneAccountForUid(int uid); /** * Given a {@link PhoneAccountHandle} determines the uid for the app owning the account. * @param handle The phone account; the phone account handle's package and userhandle are * ultimately used to find the associated uid. * @return the uid for the phone account. */ int getUidForPhoneAccountHandle(PhoneAccountHandle handle); } /** * Keyed on uid, tracks a communication session and whether there are audio record and playback * resources for that session. */ public class CommunicationSession { private int uid; @SessionAttribute private int sessionAttr; private ArrayMap> audioResourcesByType = new ArrayMap<>(); private EventManager.Loggable telecomCall; private long sessionStartMillis; private long sessionStartClockMillis; /** * @return {@code true} if audio record or playback is held for the session, {@code false} * otherwise. */ public boolean hasMediaResources() { return (getSessionAttr() & (SESSION_ATTR_HAS_AUDIO_RECORD | SESSION_ATTR_HAS_AUDIO_PLAYBACK)) != 0; } /** * Sets a bit enabled for the session. * @param bit the bit */ public void setBit(@SessionAttribute int bit) { setSessionAttr(getSessionAttr() | bit); } /** * Clears the specified bit for the session. * @param bit the bit */ public void clearBit(@SessionAttribute int bit) { setSessionAttr(getSessionAttr() & ~bit); } /** * Determines if a bit is set in the given bitmask. * @param mask the bitmask. * @param bit The bit * @return {@code true} if set, {@code false} otherwise. */ public static boolean isBitSet(@SessionAttribute int mask, @SessionAttribute int bit) { return (mask & bit) == bit; } /** * Determines if a bit is set for the current session. * @param bit The bit * @return {@code true} if set, {@code false} otherwise. */ public boolean isBitSet(@SessionAttribute int bit) { return isBitSet(getSessionAttr(), bit); } /** * Generate a string representing the session attributes bitmask, suitable for logging. * @param attr The session attributes. * @return String of bits! */ public static String sessionAttrToString(@SessionAttribute int attr) { return (isBitSet(attr, SESSION_ATTR_HAS_PHONE_ACCOUNT) ? "phac, " : "") + (isBitSet(attr, SESSION_ATTR_HAS_AUDIO_PLAYBACK) ? "ap, " : "") + (isBitSet(attr, SESSION_ATTR_HAS_AUDIO_RECORD) ? "ar, " : ""); } @Override public String toString() { return "CommSess{" + "uid=" + getUid() + ", created=" + SimpleDateFormat.getDateTimeInstance().format( new Date(getSessionStartClockMillis())) + ", attr=" + sessionAttrToString(getSessionAttr()) + ", callId=" + (getTelecomCall() != null ? getTelecomCall().getId() : "none") + ", duration=" + (mClockProxy.elapsedRealtime() - getSessionStartMillis())/1000 + '}'; } /** * The uid for the session. */ public int getUid() { return uid; } public void setUid(int uid) { this.uid = uid; } /** * The attributes for the session. */ public int getSessionAttr() { return sessionAttr; } public void setSessionAttr(int sessionAttr) { this.sessionAttr = sessionAttr; } /** * ArrayMap, keyed by {@link #SESSION_ATTR_HAS_AUDIO_PLAYBACK} and * {@link #SESSION_ATTR_HAS_AUDIO_RECORD}. For each, contains a set of the * {@link AudioManager} ids associated with active playback and recording sessions for a * uid. * * {@link AudioPlaybackConfiguration#getPlayerInterfaceId()} is used for audio playback; * per docs, this is an identifier unique for the lifetime of the player. * * {@link AudioRecordingConfiguration#getClientAudioSessionId()} is used for audio record * tracking; this is unique similar to the audio playback config. */ public ArrayMap> getAudioResourcesByType() { return audioResourcesByType; } public void setAudioResourcesByType( ArrayMap> audioResourcesByType) { this.audioResourcesByType = audioResourcesByType; } /** * The Telecom call this session is associated with; set if the call takes place during a * telecom call. */ public EventManager.Loggable getTelecomCall() { return telecomCall; } public void setTelecomCall(EventManager.Loggable telecomCall) { this.telecomCall = telecomCall; } /** * The time in {@link android.os.SystemClock#elapsedRealtime()} timebase when the session * started. Used only to determine duration. */ public long getSessionStartMillis() { return sessionStartMillis; } public void setSessionStartMillis(long sessionStartMillis) { this.sessionStartMillis = sessionStartMillis; } /** * The time in {@link System#currentTimeMillis()} timebase when the session started; used * to indicate the wall block time when the session started. */ public long getSessionStartClockMillis() { return sessionStartClockMillis; } public void setSessionStartClockMillis(long sessionStartClockMillis) { this.sessionStartClockMillis = sessionStartClockMillis; } } /** * Listener for AudioManager audio playback changes. Finds audio playback tagged for voice * communication. Updates the {@link #mCommunicationSessions} based on this data to track if * audio playback it taking place. * * Note: {@link AudioPlaybackCallback} reports information about audio playback for an app; if * an app releases audio playback resources, the list of audio playback configurations no longer * includes a {@link AudioPlaybackConfiguration} for that specific audio playback session. This * API semantic is why the code below is a bit confusing; in the listener we need to track all * the ids we've seen and then correlate that back to what we knew about it from the last * callback. * * An app may have MULTIPLE {@link AudioPlaybackConfiguration} for voip use-cases and switch * between them for a single call -- this was observed in live app testing. */ public class WatchdogAudioPlaybackCallback extends AudioPlaybackCallback { @Override public void onPlaybackConfigChanged(List configs) { Map> sessionIdentifiersByUid = new ArrayMap<>(); for (AudioPlaybackConfiguration config : configs) { Log.d(this, "onPlaybackConfigChanged: config=%s", config); // only track USAGE_VOICE_COMMUNICATION as this is for VOIP calls. if (config.getAudioAttributes() != null && config.getAudioAttributes().getUsage() == AudioAttributes.USAGE_VOICE_COMMUNICATION) { // Skip if the client's pid is same as myself if (config.getClientPid() == Process.myPid()) { continue; } // If an audio session is idle, we don't count it as playing. It must be in a // started state. boolean isPlaying = config.getPlayerState() == PLAYER_STATE_STARTED; maybeTrackAudioPlayback(config.getClientUid(), config.getPlayerInterfaceId(), isPlaying); if (isPlaying) { // Track the list of player id active for each uid; we use it later for // cleanup of stale sessions. putOrDefault(sessionIdentifiersByUid,config.getClientUid(), new ArraySet<>()).add(config.getPlayerInterfaceId()); } } } // The listener will drop uid/playerInterfaceIds no longer active, so we need to go back // and see if any sessions need to be removed now. cleanupAttributeForSessions(SESSION_ATTR_HAS_AUDIO_PLAYBACK, sessionIdentifiersByUid); } } /** * Similar to {@link WatchdogAudioPlaybackCallback}, tracks audio recording an app performs. * This code is handling the onRecordingConfigChanged event from the AudioManager. The event * is fired when the list of active recording configurations changes. In this case, the code * is only interested in recording configurations that are using the VOICE_COMMUNICATION * audio source. For these configurations, the code tracks the session identifiers and * potentially adds them to the SESSION_ATTR_HAS_AUDIO_RECORD attribute. The code also cleans * up the attribute for any sessions that are no longer active. * The same caveat/note applies here; a single app can have many audio recording sessions that * the app swaps between during a call. */ public class WatchdogAudioRecordCallback extends AudioManager.AudioRecordingCallback { @Override public void onRecordingConfigChanged(List configs) { List theConfigs = mAudioManager.getActiveRecordingConfigurations(); Map> sessionIdentifiersByUid = new ArrayMap<>(); for (AudioRecordingConfiguration config : theConfigs) { if (config.getClientAudioSource() == MediaRecorder.AudioSource.VOICE_COMMUNICATION) { putOrDefault(sessionIdentifiersByUid, config.getClientUid(), new ArraySet<>()).add(config.getClientAudioSessionId()); maybeTrackAudioRecord(config.getClientUid(), config.getClientAudioSessionId(), true); } } // The listener stops reporting audio sessions that go away, so we need to clean up the // session potentially. cleanupAttributeForSessions( SESSION_ATTR_HAS_AUDIO_RECORD, sessionIdentifiersByUid); } } // Proxies to make testing possible-ish. private final ClockProxy mClockProxy; private final PhoneAccountRegistrarProxy mPhoneAccountRegistrarProxy; private final WatchdogAudioPlaybackCallback mWatchdogAudioPlayback = new WatchdogAudioPlaybackCallback(); private final WatchdogAudioRecordCallback mWatchdogAudioRecordCallack = new WatchdogAudioRecordCallback(); private final AudioManager mAudioManager; private final Handler mHandler; // Guards access to mCommunicationSessions. private final Object mCommunicationSessionsLock = new Object(); /** * Key - UID of communication app. * Value - an instance of {@link CommunicationSession} tracking data for that uid. */ private final Map mCommunicationSessions = new ArrayMap<>(); // Local logs for tracking non-telecom calls. private final LocalLog mLocalLog = new LocalLog(30); private final TelecomMetricsController mMetricsController; public CallAudioWatchdog(AudioManager audioManager, PhoneAccountRegistrarProxy phoneAccountRegistrarProxy, ClockProxy clockProxy, Handler handler, TelecomMetricsController metricsController) { mPhoneAccountRegistrarProxy = phoneAccountRegistrarProxy; mClockProxy = clockProxy; mAudioManager = audioManager; mHandler = handler; mAudioManager.registerAudioPlaybackCallback(mWatchdogAudioPlayback, mHandler); mAudioManager.registerAudioRecordingCallback(mWatchdogAudioRecordCallack, mHandler); mMetricsController = metricsController; } /** * Tracks Telecom adding a call; we use this to associate a uid's sessions with a call. * Note: this is not 100% accurate if there are multiple calls -- we just associate with the * first call and leave it at that. It's not possible to know which audio sessions belong to * which Telecom calls. * @param call the Telecom call being added. */ @Override public void onCallAdded(Call call) { // Only track for voip calls. if (call.isSelfManaged() || call.isTransactionalCall()) { maybeTrackTelecomCall(call); } } @Override public void onCallRemoved(Call call) { // Only track for voip calls. if (call.isSelfManaged() || call.isTransactionalCall()) { maybeRemoveCall(call); } } @VisibleForTesting public WatchdogAudioPlaybackCallback getWatchdogAudioPlayback() { return mWatchdogAudioPlayback; } @VisibleForTesting public WatchdogAudioRecordCallback getWatchdogAudioRecordCallack() { return mWatchdogAudioRecordCallack; } @VisibleForTesting public Map getCommunicationSessions() { return mCommunicationSessions; } /** * Include info on audio stuff in the telecom dumpsys. * @param pw */ void dump(IndentingPrintWriter pw) { pw.println("CallAudioWatchdog:"); pw.increaseIndent(); pw.println("Active Sessions:"); pw.increaseIndent(); Collection sessions; synchronized (mCommunicationSessionsLock) { sessions = mCommunicationSessions.values(); } sessions.forEach(pw::println); pw.decreaseIndent(); pw.println("Audio sessions Sessions:"); pw.increaseIndent(); mLocalLog.dump(pw); pw.decreaseIndent(); pw.decreaseIndent(); } /** * Tracks audio playback for a uid. * @param uid the uid of the app having audio back change. * @param playerInterfaceId From {@link AudioPlaybackConfiguration#getPlayerInterfaceId()} (see * {@link CommunicationSession#audioResourcesByType} for keying info). * @param isPlaying {@code true} if audio is starting for the client. */ private void maybeTrackAudioPlayback(int uid, int playerInterfaceId, boolean isPlaying) { CommunicationSession session; synchronized (mCommunicationSessionsLock) { if (!isPlaying) { // A session can start in an idle state and never go active; in this case we will // not proactively add a new session; we'll just get one if it's already there. // When the session goes active we can add it then. session = getSession(uid); } else { // The playback is active, so we need to get or add a new communication session. session = getOrAddSession(uid); } } if (session == null) { return; } // First track individual player interface id playing status. if (isPlaying) { putOrDefault(session.getAudioResourcesByType(), SESSION_ATTR_HAS_AUDIO_PLAYBACK, new ArraySet<>()).add(playerInterfaceId); } else { putOrDefault(session.getAudioResourcesByType(), SESSION_ATTR_HAS_AUDIO_PLAYBACK, new ArraySet<>()).remove(playerInterfaceId); } // Keep the bitmask up to date so that we have quicker access to the audio playback state. int originalAttrs = session.getSessionAttr(); // If there are active audio playback clients, then the session has playback. if (!session.getAudioResourcesByType().get(SESSION_ATTR_HAS_AUDIO_PLAYBACK).isEmpty()) { session.setBit(SESSION_ATTR_HAS_AUDIO_PLAYBACK); } else { session.clearBit(SESSION_ATTR_HAS_AUDIO_PLAYBACK); } // If there was a change, log to a call if set. if (originalAttrs != session.getSessionAttr() && session.getTelecomCall() != null) { Log.addEvent(session.getTelecomCall(), LogUtils.Events.AUDIO_ATTR, CommunicationSession.sessionAttrToString(originalAttrs) + " -> " + CommunicationSession.sessionAttrToString( session.getSessionAttr())); } Log.d(this, "maybeTrackAudioPlayback: %s", session); } /** * Similar to {@link #maybeTrackAudioPlayback(int, int, boolean)}, except tracks audio records * for an app. * @param uid the app uid. * @param recordSessionID The recording session (per * @param isRecording {@code true} if recording, {@code false} otherwise. */ private void maybeTrackAudioRecord(int uid, int recordSessionID, boolean isRecording) { synchronized (mCommunicationSessionsLock) { CommunicationSession session = getOrAddSession(uid); // First track individual recording status. if (isRecording) { putOrDefault(session.getAudioResourcesByType(), SESSION_ATTR_HAS_AUDIO_RECORD, new ArraySet<>()).add(recordSessionID); } else { putOrDefault(session.getAudioResourcesByType(), SESSION_ATTR_HAS_AUDIO_RECORD, new ArraySet<>()).remove(recordSessionID); } int originalAttrs = session.getSessionAttr(); if (!session.getAudioResourcesByType().get(SESSION_ATTR_HAS_AUDIO_RECORD).isEmpty()) { session.setBit(SESSION_ATTR_HAS_AUDIO_RECORD); } else { session.clearBit(SESSION_ATTR_HAS_AUDIO_RECORD); } if (originalAttrs != session.getSessionAttr() && session.getTelecomCall() != null) { Log.addEvent(session.getTelecomCall(), LogUtils.Events.AUDIO_ATTR, CommunicationSession.sessionAttrToString(originalAttrs) + " -> " + CommunicationSession.sessionAttrToString( session.getSessionAttr())); } Log.d(this, "maybeTrackAudioRecord: %s", session); } } /** * Given a new Telecom call, start a new session or annotate an existing one with this call. * Helps to associated resources with a telecom call. * @param call the call! */ private void maybeTrackTelecomCall(Call call) { int uid = mPhoneAccountRegistrarProxy.getUidForPhoneAccountHandle( call.getTargetPhoneAccount()); CommunicationSession session; synchronized (mCommunicationSessionsLock) { session = getOrAddSession(uid); } session.setTelecomCall(call); Log.d(this, "maybeTrackTelecomCall: %s", session); Log.addEvent(session.getTelecomCall(), LogUtils.Events.AUDIO_ATTR, CommunicationSession.sessionAttrToString(session.getSessionAttr())); } /** * Given a telecom call, cleanup the session if there are no audio resources remaining for that * session. * @param call The call. */ private void maybeRemoveCall(Call call) { int uid = mPhoneAccountRegistrarProxy.getUidForPhoneAccountHandle( call.getTargetPhoneAccount()); CommunicationSession session; synchronized (mCommunicationSessionsLock) { session = getSession(uid); if (session == null) { return; } if (!session.hasMediaResources()) { mLocalLog.log(session.toString()); maybeLogMetrics(session); mCommunicationSessions.remove(uid); } } } /** * Returns an existing session for a uid, or {@code null} if none exists. * @param uid the uid, * @return The session found, or {@code null}. */ private CommunicationSession getSession(int uid) { return mCommunicationSessions.get(uid); } /** * Locates an existing session for the specified uid or creates a new one. * @param uid the uid * @return The session. */ private CommunicationSession getOrAddSession(int uid) { CommunicationSession session = mCommunicationSessions.get(uid); if (session != null) { Log.i(this, "getOrAddSession: uid=%d, ex, %s", uid, session); return session; } else { CommunicationSession newSession = new CommunicationSession(); newSession.setSessionStartMillis(mClockProxy.elapsedRealtime()); newSession.setSessionStartClockMillis(mClockProxy.currentTimeMillis()); newSession.setUid(uid); if (mPhoneAccountRegistrarProxy.hasPhoneAccountForUid(uid)) { newSession.setBit(SESSION_ATTR_HAS_PHONE_ACCOUNT); } mCommunicationSessions.put(uid, newSession); Log.i(this, "getOrAddSession: uid=%d, new, %s", uid, newSession); return newSession; } } /** * This method is used to cleanup any playback or recording sessions that may have went away * after the {@link AudioPlaybackConfiguration} or {@link AudioRecordingConfiguration} updates. * * {@link CommunicationSession#audioResourcesByType} is keyed by * {@link #SESSION_ATTR_HAS_AUDIO_RECORD} and {@link #SESSION_ATTR_HAS_AUDIO_PLAYBACK} and * contains a list of each of the record or playback sessions we've been tracking. * * @param bit the type of resources to cleanup. * @param sessionsByUid A map, keyed on uid of the set of play or record ids that were provided * in the most recent {@link AudioPlaybackConfiguration} or * {@link AudioRecordingConfiguration} update. */ private void cleanupAttributeForSessions(int bit, Map> sessionsByUid) { synchronized (mCommunicationSessionsLock) { // Use an iterator so we can do in-place removal. Iterator> iterator = mCommunicationSessions.entrySet().iterator(); // Lets loop through all the uids we're tracking and see that they still have an audio // resource of type {@code bit} in {@code sessionsByUid}. while (iterator.hasNext()) { Map.Entry next = iterator.next(); int existingUid = next.getKey(); CommunicationSession session = next.getValue(); // Get the set of sessions for this type, or emptyset if none present. Set sessionsForThisUid = sessionsByUid.getOrDefault(existingUid, Collections.emptySet()); // Update the known sessions of this resource type in the CommunicationSession. Set trackedSessions = putOrDefault(session.getAudioResourcesByType(), bit, new ArraySet<>()); trackedSessions.clear(); trackedSessions.addAll(sessionsForThisUid); // Set or unset the bit in the bitmask for quicker access. if (!trackedSessions.isEmpty()) { session.setBit(bit); } else { session.clearBit(bit); } // If audio resources are no longer held for a uid, then we'll clean up its // media session. if (!session.hasMediaResources() && session.getTelecomCall() == null) { Log.i(this, "cleanupAttributeForSessions: removing session %s", session); mLocalLog.log(session.toString()); maybeLogMetrics(session); iterator.remove(); } } } } /** * Generic method to put a key value to a map and set to a default it not found, in both cases * returning the value. * * This is a concession due to the fact that {@link Map#putIfAbsent(Object, Object)} returns * null if the default is set. 🙄 * * @param map The map. * @param key The key to find. * @param theDefault The default value for the key to use and return if nothing found. * @return The existing key value or the default after adding. * @param The map key * @param The map value */ private V putOrDefault(Map map, K key, V theDefault) { if (map.containsKey(key)) { return map.get(key); } map.put(key, theDefault); return theDefault; } /** * If this call has no associated Telecom {@link Call} and metrics are enabled, log this as a * non-telecom call. * @param session the session to log. */ private void maybeLogMetrics(CommunicationSession session) { if (mMetricsController != null && session.getTelecomCall() == null) { mMetricsController.getCallStats().onNonTelecomCallEnd( session.isBitSet(SESSION_ATTR_HAS_PHONE_ACCOUNT), session.getUid(), mClockProxy.elapsedRealtime() - session.getSessionStartMillis()); } } }