diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp
index a296d64..3a25e67 100644
--- a/core/jni/android_media_AudioSystem.cpp
+++ b/core/jni/android_media_AudioSystem.cpp
@@ -26,6 +26,7 @@
 #include <nativehelper/JNIHelp.h>
 #include "core_jni_helpers.h"
 
+#include <audiomanager/AudioManager.h>
 #include <media/AudioSystem.h>
 #include <media/AudioPolicy.h>
 #include <media/MicrophoneInfo.h>
@@ -353,7 +354,15 @@
 static jint
 android_media_AudioSystem_newAudioPlayerId(JNIEnv *env, jobject thiz)
 {
-    return AudioSystem::newAudioUniqueId(AUDIO_UNIQUE_ID_USE_PLAYER);
+    int id = AudioSystem::newAudioUniqueId(AUDIO_UNIQUE_ID_USE_CLIENT);
+    return id != AUDIO_UNIQUE_ID_ALLOCATE ? id : PLAYER_PIID_INVALID;
+}
+
+static jint
+android_media_AudioSystem_newAudioRecorderId(JNIEnv *env, jobject thiz)
+{
+    int id = AudioSystem::newAudioUniqueId(AUDIO_UNIQUE_ID_USE_CLIENT);
+    return id != AUDIO_UNIQUE_ID_ALLOCATE ? id : RECORD_RIID_INVALID;
 }
 
 static jint
@@ -470,9 +479,10 @@
 
     env->CallStaticVoidMethod(clazz,
                               gAudioPolicyEventHandlerMethods.postRecordConfigEventFromNative,
-                              event, (jint) clientInfo->uid, clientInfo->session,
-                              clientInfo->source, clientInfo->port_id, clientInfo->silenced,
-                              recParamArray, jClientEffects, jEffects, source);
+                              event, (jint) clientInfo->riid, (jint) clientInfo->uid,
+                              clientInfo->session, clientInfo->source, clientInfo->port_id,
+                              clientInfo->silenced, recParamArray, jClientEffects, jEffects,
+                              source);
     env->DeleteLocalRef(clazz);
     env->DeleteLocalRef(recParamArray);
     env->DeleteLocalRef(jClientEffects);
@@ -2246,6 +2256,7 @@
     {"isSourceActive",      "(I)Z",     (void *)android_media_AudioSystem_isSourceActive},
     {"newAudioSessionId",   "()I",      (void *)android_media_AudioSystem_newAudioSessionId},
     {"newAudioPlayerId",    "()I",      (void *)android_media_AudioSystem_newAudioPlayerId},
+    {"newAudioRecorderId",  "()I",      (void *)android_media_AudioSystem_newAudioRecorderId},
     {"setDeviceConnectionState", "(IILjava/lang/String;Ljava/lang/String;I)I", (void *)android_media_AudioSystem_setDeviceConnectionState},
     {"getDeviceConnectionState", "(ILjava/lang/String;)I",  (void *)android_media_AudioSystem_getDeviceConnectionState},
     {"handleDeviceConfigChange", "(ILjava/lang/String;Ljava/lang/String;I)I", (void *)android_media_AudioSystem_handleDeviceConfigChange},
@@ -2440,7 +2451,7 @@
                     "dynamicPolicyCallbackFromNative", "(ILjava/lang/String;I)V");
     gAudioPolicyEventHandlerMethods.postRecordConfigEventFromNative =
             GetStaticMethodIDOrDie(env, env->FindClass(kClassPathName),
-                    "recordingCallbackFromNative", "(IIIIIZ[I[Landroid/media/audiofx/AudioEffect$Descriptor;[Landroid/media/audiofx/AudioEffect$Descriptor;I)V");
+                    "recordingCallbackFromNative", "(IIIIIIZ[I[Landroid/media/audiofx/AudioEffect$Descriptor;[Landroid/media/audiofx/AudioEffect$Descriptor;I)V");
 
     jclass audioMixClass = FindClassOrDie(env, "android/media/audiopolicy/AudioMix");
     gAudioMixClass = MakeGlobalRefOrDie(env, audioMixClass);
diff --git a/media/java/android/media/AudioManager.java b/media/java/android/media/AudioManager.java
index f8e43437..bcc57d2 100644
--- a/media/java/android/media/AudioManager.java
+++ b/media/java/android/media/AudioManager.java
@@ -3766,9 +3766,24 @@
      * with frameworks/av/include/media/AudioPolicy.h
      */
     /** @hide */
-    public final static int RECORD_CONFIG_EVENT_START = 1;
+    public static final int RECORD_CONFIG_EVENT_NONE = -1;
     /** @hide */
-    public final static int RECORD_CONFIG_EVENT_STOP = 0;
+    public static final int RECORD_CONFIG_EVENT_START = 0;
+    /** @hide */
+    public static final int RECORD_CONFIG_EVENT_STOP = 1;
+    /** @hide */
+    public static final int RECORD_CONFIG_EVENT_UPDATE = 2;
+    /** @hide */
+    public static final int RECORD_CONFIG_EVENT_DEATH = 3;
+    /**
+     * keep in sync with frameworks/native/include/audiomanager/AudioManager.h
+     */
+    /** @hide */
+    public static final int RECORD_RIID_INVALID = -1;
+    /** @hide */
+    public static final int RECORDER_STATE_STARTED = 0;
+    /** @hide */
+    public static final int RECORDER_STATE_STOPPED = 1;
 
     /**
      * All operations on this list are sync'd on mRecordCallbackLock.
diff --git a/media/java/android/media/AudioRecordingConfiguration.java b/media/java/android/media/AudioRecordingConfiguration.java
index 82bcbc1..74e6618 100644
--- a/media/java/android/media/AudioRecordingConfiguration.java
+++ b/media/java/android/media/AudioRecordingConfiguration.java
@@ -157,7 +157,7 @@
         return new AudioRecordingConfiguration( /*anonymized uid*/ -1,
                 in.mClientSessionId, in.mClientSource, in.mClientFormat,
                 in.mDeviceFormat, in.mPatchHandle, "" /*empty package name*/,
-                in.mClientPortId, in.mClientSilenced, in.mDeviceSource, in.mClientEffects,
+                /*anonymized portId*/ -1, in.mClientSilenced, in.mDeviceSource, in.mClientEffects,
                 in.mDeviceEffects);
     }
 
@@ -270,11 +270,12 @@
     }
 
     /**
+     * @hide
      * Returns the system unique ID assigned for the AudioRecord object corresponding to this
      * AudioRecordingConfiguration client.
      * @return the port ID.
      */
-    int getClientPortId() {
+    public int getClientPortId() {
         return mClientPortId;
     }
 
diff --git a/media/java/android/media/AudioSystem.java b/media/java/android/media/AudioSystem.java
index d105fa3..987db8b 100644
--- a/media/java/android/media/AudioSystem.java
+++ b/media/java/android/media/AudioSystem.java
@@ -220,6 +220,11 @@
      */
     public static native int newAudioPlayerId();
 
+    /**
+     * Returns a new unused audio recorder ID
+     */
+    public static native int newAudioRecorderId();
+
 
     /*
      * Sets a group generic audio configuration parameters. The use of these parameters
@@ -347,6 +352,7 @@
         /**
          * Callback for recording activity notifications events
          * @param event
+         * @param riid recording identifier
          * @param uid uid of the client app performing the recording
          * @param session
          * @param source
@@ -361,7 +367,7 @@
          *          6: patch handle
          * @param packName package name of the client app performing the recording. NOT SUPPORTED
          */
-        void onRecordingConfigurationChanged(int event, int uid, int session, int source,
+        void onRecordingConfigurationChanged(int event, int riid, int uid, int session, int source,
                         int portId, boolean silenced, int[] recordingFormat,
                         AudioEffect.Descriptor[] clienteffects, AudioEffect.Descriptor[] effects,
                         int activeSource, String packName);
@@ -379,16 +385,23 @@
     /**
      * Callback from native for recording configuration updates.
      * @param event
+     * @param riid
+     * @param uid
      * @param session
      * @param source
+     * @param portId
+     * @param silenced
      * @param recordingFormat see
-     *     {@link AudioRecordingCallback#onRecordingConfigurationChanged(int, int, int, int, int,\
-     boolean, int[], AudioEffect.Descriptor[], AudioEffect.Descriptor[], int, String)}
+     *     {@link AudioRecordingCallback#onRecordingConfigurationChanged(int, int, int, int, int, \
+     int, boolean, int[], AudioEffect.Descriptor[], AudioEffect.Descriptor[], int, String)}
      *     for the description of the record format.
+     * @param cleintEffects
+     * @param effects
+     * @param activeSource
      */
     @UnsupportedAppUsage
-    private static void recordingCallbackFromNative(int event, int uid, int session, int source,
-                          int portId, boolean silenced, int[] recordingFormat,
+    private static void recordingCallbackFromNative(int event, int riid, int uid, int session,
+                          int source, int portId, boolean silenced, int[] recordingFormat,
                           AudioEffect.Descriptor[] clientEffects, AudioEffect.Descriptor[] effects,
                           int activeSource) {
         AudioRecordingCallback cb = null;
@@ -401,7 +414,7 @@
 
         if (cb != null) {
             // TODO receive package name from native
-            cb.onRecordingConfigurationChanged(event, uid, session, source, portId, silenced,
+            cb.onRecordingConfigurationChanged(event, riid, uid, session, source, portId, silenced,
                                         recordingFormat, clientEffects, effects, activeSource, "");
         }
     }
diff --git a/media/java/android/media/IAudioService.aidl b/media/java/android/media/IAudioService.aidl
index 85de00a..81ddcdb4 100644
--- a/media/java/android/media/IAudioService.aidl
+++ b/media/java/android/media/IAudioService.aidl
@@ -60,6 +60,10 @@
 
     oneway void releasePlayer(in int piid);
 
+    int trackRecorder(in IBinder recorder);
+
+    oneway void recorderEvent(in int riid, in int event);
+
     // Java-only methods below.
 
     oneway void adjustSuggestedStreamVolume(int direction, int suggestedStreamType, int flags,
diff --git a/services/core/java/com/android/server/audio/AudioService.java b/services/core/java/com/android/server/audio/AudioService.java
index d3af8f07..e38defd 100644
--- a/services/core/java/com/android/server/audio/AudioService.java
+++ b/services/core/java/com/android/server/audio/AudioService.java
@@ -409,16 +409,16 @@
     private final AudioSystem.ErrorCallback mAudioSystemCallback = new AudioSystem.ErrorCallback() {
         public void onError(int error) {
             switch (error) {
-            case AudioSystem.AUDIO_STATUS_SERVER_DIED:
-                mRecordMonitor.clear();
+                case AudioSystem.AUDIO_STATUS_SERVER_DIED:
+                    mRecordMonitor.onAudioServerDied();
 
-                sendMsg(mAudioHandler, MSG_AUDIO_SERVER_DIED,
-                        SENDMSG_NOOP, 0, 0, null, 0);
-                sendMsg(mAudioHandler, MSG_DISPATCH_AUDIO_SERVER_STATE,
-                        SENDMSG_QUEUE, 0, 0, null, 0);
-                break;
-            default:
-                break;
+                    sendMsg(mAudioHandler, MSG_AUDIO_SERVER_DIED,
+                            SENDMSG_NOOP, 0, 0, null, 0);
+                    sendMsg(mAudioHandler, MSG_DISPATCH_AUDIO_SERVER_STATE,
+                            SENDMSG_QUEUE, 0, 0, null, 0);
+                    break;
+                default:
+                    break;
             }
         }
     };
@@ -6943,6 +6943,23 @@
         return mRecordMonitor.getActiveRecordingConfigurations(isPrivileged);
     }
 
+    //======================
+    // Audio recording state notification from clients
+    //======================
+    /**
+     * Track a recorder provided by the client
+     */
+    public int trackRecorder(IBinder recorder) {
+        return mRecordMonitor.trackRecorder(recorder);
+    }
+
+    /**
+     * Receive an event from the client about a tracked recorder
+     */
+    public void recorderEvent(int riid, int event) {
+        mRecordMonitor.recorderEvent(riid, event);
+    }
+
     public void disableRingtoneSync(final int userId) {
         final int callingUserId = UserHandle.getCallingUserId();
         if (callingUserId != userId) {
diff --git a/services/core/java/com/android/server/audio/RecordingActivityMonitor.java b/services/core/java/com/android/server/audio/RecordingActivityMonitor.java
index 87b272b..69d1ea7 100644
--- a/services/core/java/com/android/server/audio/RecordingActivityMonitor.java
+++ b/services/core/java/com/android/server/audio/RecordingActivityMonitor.java
@@ -33,7 +33,6 @@
 import java.text.DateFormat;
 import java.util.ArrayList;
 import java.util.Date;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 
@@ -50,50 +49,148 @@
     // playback configurations that do not contain uid/package name information.
     private boolean mHasPublicClients = false;
 
-    private HashMap<Integer, AudioRecordingConfiguration> mRecordConfigs =
-            new HashMap<Integer, AudioRecordingConfiguration>();
+    static final class RecordingState {
+        private final int mRiid;
+        private final RecorderDeathHandler mDeathHandler;
+        private boolean mIsActive;
+        private AudioRecordingConfiguration mConfig;
+
+        RecordingState(int riid, RecorderDeathHandler handler) {
+            mRiid = riid;
+            mDeathHandler = handler;
+        }
+
+        RecordingState(AudioRecordingConfiguration config) {
+            mRiid = AudioManager.RECORD_RIID_INVALID;
+            mDeathHandler = null;
+            mConfig = config;
+        }
+
+        int getRiid() {
+            return mRiid;
+        }
+
+        int getPortId() {
+            return mConfig != null ? mConfig.getClientPortId() : -1;
+        }
+
+        AudioRecordingConfiguration getConfig() {
+            return mConfig;
+        }
+
+        boolean hasDeathHandler() {
+            return mDeathHandler != null;
+        }
+
+        boolean isActiveConfiguration() {
+            return mIsActive && mConfig != null;
+        }
+
+        // returns true if status of an active recording has changed
+        boolean setActive(boolean active) {
+            if (mIsActive == active) return false;
+            mIsActive = active;
+            return mConfig != null;
+        }
+
+        // returns true if an active recording has been updated
+        boolean setConfig(AudioRecordingConfiguration config) {
+            if (config.equals(mConfig)) return false;
+            mConfig = config;
+            return mIsActive;
+        }
+
+        void dump(PrintWriter pw) {
+            pw.println("riid " + mRiid + "; active? " + mIsActive);
+            if (mConfig != null) {
+                mConfig.dump(pw);
+            } else {
+                pw.println("  no config");
+            }
+        }
+    }
+    private List<RecordingState> mRecordStates = new ArrayList<RecordingState>();
 
     private final PackageManager mPackMan;
 
     RecordingActivityMonitor(Context ctxt) {
         RecMonitorClient.sMonitor = this;
+        RecorderDeathHandler.sMonitor = this;
         mPackMan = ctxt.getPackageManager();
     }
 
     /**
      * Implementation of android.media.AudioSystem.AudioRecordingCallback
      */
-    public void onRecordingConfigurationChanged(int event, int uid, int session, int source,
-                                                int portId, boolean silenced, int[] recordingInfo,
+    public void onRecordingConfigurationChanged(int event, int riid, int uid, int session,
+                                                int source, int portId, boolean silenced,
+                                                int[] recordingInfo,
                                                 AudioEffect.Descriptor[] clientEffects,
                                                 AudioEffect.Descriptor[] effects,
                                                 int activeSource, String packName) {
+        final AudioRecordingConfiguration config = createRecordingConfiguration(
+                uid, session, source, recordingInfo,
+                portId, silenced, activeSource, clientEffects, effects);
         if (MediaRecorder.isSystemOnlyAudioSource(source)) {
-            // still want to log event, it just won't appear in recording configurations
-            sEventLogger.log(new RecordingEvent(event, uid, session, source, packName)
-                    .printLog(TAG));
+            // still want to log event, it just won't appear in recording configurations;
+            sEventLogger.log(new RecordingEvent(event, riid, config).printLog(TAG));
             return;
         }
-        String clientEffectName =  clientEffects.length == 0 ? "None" : clientEffects[0].name;
-        String effectName =  effects.length == 0 ? "None" : effects[0].name;
-
-        final List<AudioRecordingConfiguration> configsSystem =
-                updateSnapshot(event, uid, session, source, recordingInfo,
-                portId, silenced, activeSource, clientEffects, effects);
-        if (configsSystem != null){
-            dispatchCallbacks(configsSystem);
-        }
+        dispatchCallbacks(updateSnapshot(event, riid, config));
     }
+
+    /**
+     * Track a recorder provided by the client
+     */
+    public int trackRecorder(IBinder recorder) {
+        if (recorder == null) {
+            Log.e(TAG, "trackRecorder called with null token");
+            return AudioManager.RECORD_RIID_INVALID;
+        }
+        final int newRiid = AudioSystem.newAudioRecorderId();
+        RecorderDeathHandler handler = new RecorderDeathHandler(newRiid, recorder);
+        if (!handler.init()) {
+            // probably means that the AudioRecord has already died
+            return AudioManager.RECORD_RIID_INVALID;
+        }
+        synchronized (mRecordStates) {
+            mRecordStates.add(new RecordingState(newRiid, handler));
+        }
+        // a newly added record is inactive, no change in active configs is possible.
+        return newRiid;
+    }
+
+    /**
+     * Receive an event from the client about a tracked recorder
+     */
+    public void recorderEvent(int riid, int event) {
+        int configEvent = event == AudioManager.RECORDER_STATE_STARTED
+                ? AudioManager.RECORD_CONFIG_EVENT_START :
+                event == AudioManager.RECORDER_STATE_STOPPED
+                ? AudioManager.RECORD_CONFIG_EVENT_STOP : AudioManager.RECORD_CONFIG_EVENT_NONE;
+        if (riid == AudioManager.RECORD_RIID_INVALID
+                || configEvent == AudioManager.RECORD_CONFIG_EVENT_NONE) {
+            sEventLogger.log(new RecordingEvent(event, riid, null).printLog(TAG));
+            return;
+        }
+        dispatchCallbacks(updateSnapshot(configEvent, riid, null));
+    }
+
+    void unregisterRecorder(int riid) {
+        dispatchCallbacks(updateSnapshot(AudioManager.RECORD_CONFIG_EVENT_DEATH, riid, null));
+    }
+
     private void dispatchCallbacks(List<AudioRecordingConfiguration> configs) {
+        if (configs == null) { // null means "no changes"
+            return;
+        }
         synchronized (mClients) {
             // list of recording configurations for "public consumption". It is only computed if
             // there are non-system recording activity listeners.
             final List<AudioRecordingConfiguration> configsPublic = mHasPublicClients
                     ? anonymizeForPublicConsumption(configs) :
                       new ArrayList<AudioRecordingConfiguration>();
-            final Iterator<RecMonitorClient> clientIterator = mClients.iterator();
-            while (clientIterator.hasNext()) {
-                final RecMonitorClient rmc = clientIterator.next();
+            for (RecMonitorClient rmc : mClients) {
                 try {
                     if (rmc.mIsPrivileged) {
                         rmc.mDispatcherCb.dispatchRecordingConfigChange(configs);
@@ -108,12 +205,12 @@
     }
 
     protected void dump(PrintWriter pw) {
-        // players
+        // recorders
         pw.println("\nRecordActivityMonitor dump time: "
                 + DateFormat.getTimeInstance().format(new Date()));
-        synchronized(mRecordConfigs) {
-            for (AudioRecordingConfiguration conf : mRecordConfigs.values()) {
-                conf.dump(pw);
+        synchronized (mRecordStates) {
+            for (RecordingState state : mRecordStates) {
+                state.dump(pw);
             }
         }
         pw.println("\n");
@@ -121,7 +218,7 @@
         sEventLogger.dump(pw);
     }
 
-    private ArrayList<AudioRecordingConfiguration> anonymizeForPublicConsumption(
+    private static ArrayList<AudioRecordingConfiguration> anonymizeForPublicConsumption(
             List<AudioRecordingConfiguration> sysConfigs) {
         ArrayList<AudioRecordingConfiguration> publicConfigs =
                 new ArrayList<AudioRecordingConfiguration>();
@@ -136,11 +233,30 @@
         AudioSystem.setRecordingCallback(this);
     }
 
-    void clear() {
-        synchronized (mRecordConfigs) {
-            mRecordConfigs.clear();
+    void onAudioServerDied() {
+        // Remove all RecordingState entries that do not have a death handler (that means
+        // they are tracked by the Audio Server). If there were active entries among removed,
+        // dispatch active configuration changes.
+        List<AudioRecordingConfiguration> configs = null;
+        synchronized (mRecordStates) {
+            boolean configChanged = false;
+            for (Iterator<RecordingState> it = mRecordStates.iterator(); it.hasNext(); ) {
+                RecordingState state = it.next();
+                if (!state.hasDeathHandler()) {
+                    if (state.isActiveConfiguration()) {
+                        configChanged = true;
+                        sEventLogger.log(new RecordingEvent(
+                                        AudioManager.RECORD_CONFIG_EVENT_DEATH,
+                                        state.getRiid(), state.getConfig()));
+                    }
+                    it.remove();
+                }
+            }
+            if (configChanged) {
+                configs = getActiveRecordingConfigurations(true /*isPrivileged*/);
+            }
         }
-        dispatchCallbacks(new ArrayList<AudioRecordingConfiguration>());
+        dispatchCallbacks(configs);
     }
 
     void registerRecordingCallback(IRecordingConfigDispatcher rcdb, boolean isPrivileged) {
@@ -181,21 +297,25 @@
     }
 
     List<AudioRecordingConfiguration> getActiveRecordingConfigurations(boolean isPrivileged) {
-        synchronized(mRecordConfigs) {
-            if (isPrivileged) {
-                return new ArrayList<AudioRecordingConfiguration>(mRecordConfigs.values());
-            } else {
-                final List<AudioRecordingConfiguration> configsPublic =
-                        anonymizeForPublicConsumption(
-                            new ArrayList<AudioRecordingConfiguration>(mRecordConfigs.values()));
-                return configsPublic;
+        List<AudioRecordingConfiguration> configs = new ArrayList<AudioRecordingConfiguration>();
+        synchronized (mRecordStates) {
+            for (RecordingState state : mRecordStates) {
+                if (state.isActiveConfiguration()) {
+                    configs.add(state.getConfig());
+                }
             }
         }
+        // AudioRecordingConfiguration objects never get updated. If config changes,
+        // the reference to the config is set in RecordingState.
+        if (!isPrivileged) {
+            configs = anonymizeForPublicConsumption(configs);
+        }
+        return configs;
     }
 
     /**
-     * Update the internal "view" of the active recording sessions
-     * @param event
+     * Create a recording configuration from the provided parameters
+     * @param uid
      * @param session
      * @param source
      * @param recordingFormat see
@@ -207,82 +327,133 @@
      * @param activeSource
      * @param clientEffects
      * @param effects
+     * @return null a configuration object.
+     */
+    private AudioRecordingConfiguration createRecordingConfiguration(int uid,
+            int session, int source, int[] recordingInfo, int portId, boolean silenced,
+            int activeSource, AudioEffect.Descriptor[] clientEffects,
+            AudioEffect.Descriptor[] effects) {
+        final AudioFormat clientFormat = new AudioFormat.Builder()
+                .setEncoding(recordingInfo[0])
+                // FIXME this doesn't support index-based masks
+                .setChannelMask(recordingInfo[1])
+                .setSampleRate(recordingInfo[2])
+                .build();
+        final AudioFormat deviceFormat = new AudioFormat.Builder()
+                .setEncoding(recordingInfo[3])
+                // FIXME this doesn't support index-based masks
+                .setChannelMask(recordingInfo[4])
+                .setSampleRate(recordingInfo[5])
+                .build();
+        final int patchHandle = recordingInfo[6];
+        final String[] packages = mPackMan.getPackagesForUid(uid);
+        final String packageName;
+        if (packages != null && packages.length > 0) {
+            packageName = packages[0];
+        } else {
+            packageName = "";
+        }
+        return new AudioRecordingConfiguration(uid, session, source,
+                clientFormat, deviceFormat, patchHandle, packageName,
+                portId, silenced, activeSource, clientEffects, effects);
+    }
+
+    /**
+     * Update the internal "view" of the active recording sessions
+     * @param event RECORD_CONFIG_EVENT_...
+     * @param riid
+     * @param config
      * @return null if the list of active recording sessions has not been modified, a list
      *     with the current active configurations otherwise.
      */
-    private List<AudioRecordingConfiguration> updateSnapshot(int event, int uid, int session,
-            int source, int[] recordingInfo, int portId, boolean silenced, int activeSource,
-            AudioEffect.Descriptor[] clientEffects, AudioEffect.Descriptor[] effects) {
-        final boolean configChanged;
-        final ArrayList<AudioRecordingConfiguration> configs;
-        synchronized(mRecordConfigs) {
-            switch (event) {
-            case AudioManager.RECORD_CONFIG_EVENT_STOP:
-                // return failure if an unknown recording session stopped
-                configChanged = (mRecordConfigs.remove(new Integer(portId)) != null);
-                if (configChanged) {
-                    sEventLogger.log(new RecordingEvent(event, uid, session, source, null));
-                }
-                break;
-            case AudioManager.RECORD_CONFIG_EVENT_START:
-                final AudioFormat clientFormat = new AudioFormat.Builder()
-                        .setEncoding(recordingInfo[0])
-                        // FIXME this doesn't support index-based masks
-                        .setChannelMask(recordingInfo[1])
-                        .setSampleRate(recordingInfo[2])
-                        .build();
-                final AudioFormat deviceFormat = new AudioFormat.Builder()
-                        .setEncoding(recordingInfo[3])
-                        // FIXME this doesn't support index-based masks
-                        .setChannelMask(recordingInfo[4])
-                        .setSampleRate(recordingInfo[5])
-                        .build();
-                final int patchHandle = recordingInfo[6];
-                final Integer portIdKey = new Integer(portId);
-
-                final String[] packages = mPackMan.getPackagesForUid(uid);
-                final String packageName;
-                if (packages != null && packages.length > 0) {
-                    packageName = packages[0];
+    private List<AudioRecordingConfiguration> updateSnapshot(
+            int event, int riid, AudioRecordingConfiguration config) {
+        List<AudioRecordingConfiguration> configs = null;
+        synchronized (mRecordStates) {
+            int stateIndex = -1;
+            if (riid != AudioManager.RECORD_RIID_INVALID) {
+                stateIndex = findStateByRiid(riid);
+            } else if (config != null) {
+                stateIndex = findStateByPortId(config.getClientPortId());
+            }
+            if (stateIndex == -1) {
+                if (event == AudioManager.RECORD_CONFIG_EVENT_START && config != null) {
+                    // First time registration for a recorder tracked by AudioServer.
+                    mRecordStates.add(new RecordingState(config));
+                    stateIndex = mRecordStates.size() - 1;
                 } else {
-                    packageName = "";
-                }
-                final AudioRecordingConfiguration updatedConfig =
-                        new AudioRecordingConfiguration(uid, session, source,
-                                clientFormat, deviceFormat, patchHandle, packageName,
-                                portId, silenced, activeSource, clientEffects, effects);
-
-                if (mRecordConfigs.containsKey(portIdKey)) {
-                    if (updatedConfig.equals(mRecordConfigs.get(portIdKey))) {
-                        configChanged = false;
-                    } else {
-                        // config exists but has been modified
-                        mRecordConfigs.remove(portIdKey);
-                        mRecordConfigs.put(portIdKey, updatedConfig);
-                        configChanged = true;
+                    if (config == null) {
+                        // Records tracked by clients must be registered first via trackRecorder.
+                        Log.e(TAG, String.format(
+                                        "Unexpected event %d for riid %d", event, riid));
                     }
-                } else {
-                    mRecordConfigs.put(portIdKey, updatedConfig);
-                    configChanged = true;
+                    return configs;
                 }
-                if (configChanged) {
-                    sEventLogger.log(new RecordingEvent(event, uid, session, source, packageName));
-                }
-                break;
-            default:
-                Log.e(TAG, String.format("Unknown event %d for session %d, source %d",
-                        event, session, source));
-                configChanged = false;
+            }
+            final RecordingState state = mRecordStates.get(stateIndex);
+
+            boolean configChanged;
+            switch (event) {
+                case AudioManager.RECORD_CONFIG_EVENT_START:
+                    configChanged = state.setActive(true);
+                    if (config != null) { // ??? Can remove ???
+                        configChanged = state.setConfig(config) || configChanged;
+                    }
+                    break;
+                case AudioManager.RECORD_CONFIG_EVENT_UPDATE:
+                    // For this event config != null
+                    configChanged = state.setConfig(config);
+                    break;
+                case AudioManager.RECORD_CONFIG_EVENT_STOP:
+                    configChanged = state.setActive(false);
+                    if (!state.hasDeathHandler()) {
+                        // A recorder tracked by AudioServer has to be removed now so it
+                        // does not leak. It will be re-registered if recording starts again.
+                        mRecordStates.remove(stateIndex);
+                    }
+                    break;
+                case AudioManager.RECORD_CONFIG_EVENT_DEATH:
+                    configChanged = state.isActiveConfiguration();
+                    mRecordStates.remove(stateIndex);
+                    break;
+                default:
+                    Log.e(TAG, String.format("Unknown event %d for riid %d / portid %d",
+                                    event, riid, state.getPortId()));
+                    configChanged = false;
             }
             if (configChanged) {
-                configs = new ArrayList<AudioRecordingConfiguration>(mRecordConfigs.values());
-            } else {
-                configs = null;
+                sEventLogger.log(new RecordingEvent(event, riid, state.getConfig()));
+                configs = getActiveRecordingConfigurations(true /*isPrivileged*/);
             }
         }
         return configs;
     }
 
+    // riid is assumed to be valid
+    private int findStateByRiid(int riid) {
+        synchronized (mRecordStates) {
+            for (int i = 0; i < mRecordStates.size(); i++) {
+                if (mRecordStates.get(i).getRiid() == riid) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private int findStateByPortId(int portId) {
+        // Lookup by portId is unambiguous only for recordings managed by the Audio Server.
+        synchronized (mRecordStates) {
+            for (int i = 0; i < mRecordStates.size(); i++) {
+                if (!mRecordStates.get(i).hasDeathHandler()
+                        && mRecordStates.get(i).getPortId() == portId) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
     /**
      * Inner class to track clients that want to be notified of recording updates
      */
@@ -319,28 +490,80 @@
         }
     }
 
+    private static final class RecorderDeathHandler implements IBinder.DeathRecipient {
+
+        // can afford to be static because only one RecordingActivityMonitor ever instantiated
+        static RecordingActivityMonitor sMonitor;
+
+        final int mRiid;
+        private final IBinder mRecorderToken;
+
+        RecorderDeathHandler(int riid, IBinder recorderToken) {
+            mRiid = riid;
+            mRecorderToken = recorderToken;
+        }
+
+        public void binderDied() {
+            sMonitor.unregisterRecorder(mRiid);
+        }
+
+        boolean init() {
+            try {
+                mRecorderToken.linkToDeath(this, 0);
+                return true;
+            } catch (RemoteException e) {
+                Log.w(TAG, "Could not link to recorder death", e);
+                return false;
+            }
+        }
+    }
+
     /**
      * Inner class for recording event logging
      */
     private static final class RecordingEvent extends AudioEventLogger.Event {
         private final int mRecEvent;
+        private final int mRIId;
         private final int mClientUid;
         private final int mSession;
         private final int mSource;
         private final String mPackName;
 
-        RecordingEvent(int event, int uid, int session, int source, String packName) {
+        RecordingEvent(int event, int riid, AudioRecordingConfiguration config) {
             mRecEvent = event;
-            mClientUid = uid;
-            mSession = session;
-            mSource = source;
-            mPackName = packName;
+            mRIId = riid;
+            if (config != null) {
+                mClientUid = config.getClientUid();
+                mSession = config.getClientAudioSessionId();
+                mSource = config.getClientAudioSource();
+                mPackName = config.getClientPackageName();
+            } else {
+                mClientUid = -1;
+                mSession = -1;
+                mSource = -1;
+                mPackName = null;
+            }
+        }
+
+        private static String recordEventToString(int recEvent) {
+            switch (recEvent) {
+                case AudioManager.RECORD_CONFIG_EVENT_START:
+                    return "start";
+                case AudioManager.RECORD_CONFIG_EVENT_UPDATE:
+                    return "update";
+                case AudioManager.RECORD_CONFIG_EVENT_STOP:
+                    return "stop";
+                case AudioManager.RECORD_CONFIG_EVENT_DEATH:
+                    return "death";
+                default:
+                    return "unknown (" + recEvent + ")";
+            }
         }
 
         @Override
         public String eventToString() {
-            return new StringBuilder("rec ").append(
-                        mRecEvent == AudioManager.RECORD_CONFIG_EVENT_START ? "start" : "stop ")
+            return new StringBuilder("rec ").append(recordEventToString(mRecEvent))
+                    .append(" riid:").append(mRIId)
                     .append(" uid:").append(mClientUid)
                     .append(" session:").append(mSession)
                     .append(" src:").append(MediaRecorder.toLogFriendlyAudioSource(mSource))
@@ -349,5 +572,5 @@
     }
 
     private static final AudioEventLogger sEventLogger = new AudioEventLogger(50,
-            "recording activity as reported through AudioSystem.AudioRecordingCallback");
+            "recording activity received by AudioService");
 }