diff --git a/services/oboeservice/AAudioClientTracker.h b/services/oboeservice/AAudioClientTracker.h
index 447665b..e74c8bf 100644
--- a/services/oboeservice/AAudioClientTracker.h
+++ b/services/oboeservice/AAudioClientTracker.h
@@ -38,6 +38,8 @@
 
     void unregisterClient(pid_t pid);
 
+    int32_t getStreamCount(pid_t pid);
+
     aaudio_result_t registerClientStream(pid_t pid,
                                          android::sp<AAudioServiceStreamBase> serviceStream);
 
@@ -53,11 +55,17 @@
     }
 
 private:
+
+    /**
+     * One per process.
+     */
     class NotificationClient : public IBinder::DeathRecipient {
     public:
         NotificationClient(pid_t pid);
         virtual ~NotificationClient();
 
+        int32_t getStreamCount();
+
         aaudio_result_t registerClientStream(android::sp<AAudioServiceStreamBase> serviceStream);
 
         aaudio_result_t unregisterClientStream(android::sp<AAudioServiceStreamBase> serviceStream);
