diff --git a/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/ConfigureStreamsRet.aidl b/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/ConfigureStreamsRet.aidl
index 5535a30..670f7d2 100644
--- a/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/ConfigureStreamsRet.aidl
+++ b/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/ConfigureStreamsRet.aidl
@@ -35,5 +35,4 @@
 @VintfStability
 parcelable ConfigureStreamsRet {
   android.hardware.camera.device.HalStream[] halStreams;
-  boolean enableHalBufferManager = false;
 }
diff --git a/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/HalStream.aidl b/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/HalStream.aidl
index a5784bc..3ae261d 100644
--- a/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/HalStream.aidl
+++ b/camera/device/aidl/aidl_api/android.hardware.camera.device/current/android/hardware/camera/device/HalStream.aidl
@@ -42,4 +42,5 @@
   android.hardware.graphics.common.Dataspace overrideDataSpace;
   String physicalCameraId;
   boolean supportOffline;
+  boolean enableHalBufferManager;
 }
diff --git a/camera/device/aidl/android/hardware/camera/device/ConfigureStreamsRet.aidl b/camera/device/aidl/android/hardware/camera/device/ConfigureStreamsRet.aidl
index 8f462ec..702901f 100644
--- a/camera/device/aidl/android/hardware/camera/device/ConfigureStreamsRet.aidl
+++ b/camera/device/aidl/android/hardware/camera/device/ConfigureStreamsRet.aidl
@@ -34,9 +34,4 @@
      * overridden format, maximum buffers etc.
      */
     HalStream[] halStreams;
-    /**
-     * A boolean informing the camera framework whether the HAL buffer manager
-     * must be used for the session configured.
-     */
-    boolean enableHalBufferManager = false;
 }
diff --git a/camera/device/aidl/android/hardware/camera/device/HalStream.aidl b/camera/device/aidl/android/hardware/camera/device/HalStream.aidl
index 25a80bc..fac89e6 100644
--- a/camera/device/aidl/android/hardware/camera/device/HalStream.aidl
+++ b/camera/device/aidl/android/hardware/camera/device/HalStream.aidl
@@ -127,4 +127,24 @@
      *
      */
     boolean supportOffline;
+
+    /**
+     * Whether the buffers for this stream are HAL buffer managed.
+     *
+     * If ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION is
+     * ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE, this field
+     * must be set by the HAL to inform the camera framework, whether output buffers for this
+     * stream will be HAL buffer managed - i.e. requested through the
+     * ICameraDeviceCallback.requestStreamsBuffers() API. Only the output buffers for the streams
+     * that have this field set to 'true' will be HAL buffer managed. The output buffers for other
+     * streams will be managed by the camera framework.
+     *
+     * If the value of ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION is
+     * ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_AIDL_DEVICE, the camera framework
+     * will ignore this field and assume that all output streams are hal buffer managed.
+     *
+     * If ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION is not set at all, the camera framework
+     * will ignore this field and assume output buffers are managed by the camera framework.
+     */
+    boolean enableHalBufferManager;
 }
diff --git a/camera/provider/aidl/vts/VtsAidlHalCameraProvider_TargetTest.cpp b/camera/provider/aidl/vts/VtsAidlHalCameraProvider_TargetTest.cpp
index e335853..720a9d4 100644
--- a/camera/provider/aidl/vts/VtsAidlHalCameraProvider_TargetTest.cpp
+++ b/camera/provider/aidl/vts/VtsAidlHalCameraProvider_TargetTest.cpp
@@ -656,7 +656,6 @@
     for (const auto& cameraDeviceIds : concurrentDeviceCombinations) {
         std::vector<CameraIdAndStreamCombination> cameraIdsAndStreamCombinations;
         std::vector<CameraTestInfo> cameraTestInfos;
-        size_t i = 0;
         for (const auto& id : cameraDeviceIds.combination) {
             CameraTestInfo cti;
             auto it = idToNameMap.find(id);
@@ -707,7 +706,6 @@
             cameraIdAndStreamCombination.cameraId = id;
             cameraIdAndStreamCombination.streamConfiguration = cti.config;
             cameraIdsAndStreamCombinations.push_back(cameraIdAndStreamCombination);
-            i++;
             cameraTestInfos.push_back(cti);
         }
         // Now verify that concurrent streams are supported
@@ -1572,7 +1570,7 @@
 
         std::vector<HalStream> halStreams;
         bool supportsPartialResults = false;
-        bool useHalBufManager = false;
+        std::set<int32_t> halBufManagedStreamIds;
         int32_t partialResultCount = 0;
         Stream previewStream;
         std::shared_ptr<DeviceCb> cb;
@@ -1580,7 +1578,7 @@
         configurePreviewStreams(
                 name, mProvider, &previewThreshold, physicalIds, &mSession, &previewStream,
                 &halStreams /*out*/, &supportsPartialResults /*out*/, &partialResultCount /*out*/,
-                &useHalBufManager /*out*/, &cb /*out*/, 0 /*streamConfigCounter*/, true);
+                &halBufManagedStreamIds /*out*/, &cb /*out*/, 0 /*streamConfigCounter*/, true);
         if (mSession == nullptr) {
             // stream combination not supported by HAL, skip test for device
             continue;
@@ -1617,7 +1615,9 @@
         size_t k = 0;
         for (const auto& halStream : halStreams) {
             buffer_handle_t buffer_handle;
-            if (useHalBufManager) {
+            bool useHalBufManagerForStream =
+                    halBufManagedStreamIds.find(halStream.id) != halBufManagedStreamIds.end();
+            if (useHalBufManagerForStream) {
                 outputBuffers[k] = {halStream.id,     /*bufferId*/ 0, NativeHandle(),
                                     BufferStatus::OK, NativeHandle(), NativeHandle()};
             } else {
@@ -1721,10 +1721,13 @@
         defaultPreviewSettings.unlock(settingsBuffer);
         filteredSettings.unlock(filteredSettingsBuffer);
 
-        if (useHalBufManager) {
-            std::vector<int32_t> streamIds(halStreams.size());
-            for (size_t i = 0; i < streamIds.size(); i++) {
-                streamIds[i] = halStreams[i].id;
+        if (halBufManagedStreamIds.size() != 0) {
+            std::vector<int32_t> streamIds;
+            for (size_t i = 0; i < halStreams.size(); i++) {
+                int32_t streamId = halStreams[i].id;
+                if (halBufManagedStreamIds.find(streamId) != halBufManagedStreamIds.end()) {
+                    streamIds.emplace_back(streamId);
+                }
             }
             verifyBuffersReturned(mSession, streamIds, cb);
         }
@@ -1788,7 +1791,7 @@
 
         std::vector<HalStream> halStreams;
         bool supportsPartialResults = false;
-        bool useHalBufManager = false;
+        std::set<int32_t> halBufManagedStreamIds;
         int32_t partialResultCount = 0;
         Stream previewStream;
         std::shared_ptr<DeviceCb> cb;
@@ -1800,8 +1803,8 @@
                         GRALLOC1_CONSUMER_USAGE_CPU_READ);
             previewStream.dataSpace = Dataspace::UNKNOWN;
             configureStreams(name, mProvider, format, &mSession, &previewStream, &halStreams,
-                             &supportsPartialResults, &partialResultCount, &useHalBufManager, &cb,
-                             0, /*maxResolution*/ true);
+                             &supportsPartialResults, &partialResultCount, &halBufManagedStreamIds,
+                             &cb, 0, /*maxResolution*/ true);
             ASSERT_NE(mSession, nullptr);
 
             ::aidl::android::hardware::common::fmq::MQDescriptor<
@@ -1832,7 +1835,9 @@
             size_t k = 0;
             for (const auto& halStream : halStreams) {
                 buffer_handle_t buffer_handle;
-                if (useHalBufManager) {
+                bool halBufManagerUsed =
+                        halBufManagedStreamIds.find(halStream.id) != halBufManagedStreamIds.end();
+                if (halBufManagerUsed) {
                     outputBuffers[k] = {halStream.id,   0,
                                         NativeHandle(), BufferStatus::OK,
                                         NativeHandle(), NativeHandle()};
@@ -1884,10 +1889,12 @@
                 ASSERT_FALSE(inflightReq->errorCodeValid);
                 ASSERT_NE(inflightReq->resultOutputBuffers.size(), 0u);
             }
-            if (useHalBufManager) {
-                std::vector<int32_t> streamIds(halStreams.size());
-                for (size_t i = 0; i < streamIds.size(); i++) {
-                    streamIds[i] = halStreams[i].id;
+            if (halBufManagedStreamIds.size()) {
+                std::vector<int32_t> streamIds;
+                for (size_t i = 0; i < halStreams.size(); i++) {
+                    if (contains(halBufManagedStreamIds, halStreams[i].id)) {
+                        streamIds.emplace_back(halStreams[i].id);
+                    }
                 }
                 verifyBuffersReturned(mSession, streamIds, cb);
             }
@@ -1949,7 +1956,7 @@
 
         std::vector<HalStream> halStreams;
         bool supportsPartialResults = false;
-        bool useHalBufManager = false;
+        std::set<int32_t> halBufManagedStreamIds;
         int32_t partialResultCount = 0;
         Stream previewStream;
         std::shared_ptr<DeviceCb> cb;
@@ -1960,7 +1967,7 @@
             previewStream.dataSpace = getDataspace(PixelFormat::IMPLEMENTATION_DEFINED);
             configureStreams(name, mProvider, PixelFormat::IMPLEMENTATION_DEFINED, &mSession,
                              &previewStream, &halStreams, &supportsPartialResults,
-                             &partialResultCount, &useHalBufManager, &cb, 0,
+                             &partialResultCount, &halBufManagedStreamIds, &cb, 0,
                              /*maxResolution*/ false, profile);
             ASSERT_NE(mSession, nullptr);
 
@@ -1999,7 +2006,7 @@
                 auto bufferId = requestId + 1; // Buffer id value 0 is not valid
                 for (const auto& halStream : halStreams) {
                     buffer_handle_t buffer_handle;
-                    if (useHalBufManager) {
+                    if (contains(halBufManagedStreamIds, halStream.id)) {
                         outputBuffers[k] = {halStream.id,   0,
                                             NativeHandle(), BufferStatus::OK,
                                             NativeHandle(), NativeHandle()};
@@ -2065,10 +2072,12 @@
                 verify10BitMetadata(mHandleImporter, *inflightReq, profile);
             }
 
-            if (useHalBufManager) {
-                std::vector<int32_t> streamIds(halStreams.size());
-                for (size_t i = 0; i < streamIds.size(); i++) {
-                    streamIds[i] = halStreams[i].id;
+            if (halBufManagedStreamIds.size() != 0) {
+                std::vector<int32_t> streamIds;
+                for (size_t i = 0; i < halStreams.size(); i++) {
+                    if (contains(halBufManagedStreamIds, halStreams[i].id)) {
+                        streamIds.emplace_back(halStreams[i].id);
+                    }
                 }
                 mSession->signalStreamFlush(streamIds, /*streamConfigCounter*/ 0);
                 cb->waitForBuffersReturned();
@@ -2400,11 +2409,11 @@
         std::vector<HalStream> halStreams;
         std::shared_ptr<DeviceCb> cb;
         int32_t jpegBufferSize;
-        bool useHalBufManager;
+        std::set<int32_t> halBufManagedStreamIds;
         configureOfflineStillStream(name, mProvider, &threshold, &mSession /*out*/, &stream /*out*/,
                                     &halStreams /*out*/, &supportsPartialResults /*out*/,
                                     &partialResultCount /*out*/, &cb /*out*/,
-                                    &jpegBufferSize /*out*/, &useHalBufManager /*out*/);
+                                    &jpegBufferSize /*out*/, &halBufManagedStreamIds /*out*/);
 
         auto ret = mSession->constructDefaultRequestSettings(RequestTemplate::STILL_CAPTURE,
                                                              &settings);
@@ -2440,7 +2449,7 @@
             StreamBuffer& outputBuffer = outputBuffers[0];
 
             std::unique_lock<std::mutex> l(mLock);
-            if (useHalBufManager) {
+            if (contains(halBufManagedStreamIds, halStream.id)) {
                 outputBuffer = {halStream.id,  0, NativeHandle(), BufferStatus::OK, NativeHandle(),
                                 NativeHandle()};
             } else {
diff --git a/camera/provider/aidl/vts/camera_aidl_test.cpp b/camera/provider/aidl/vts/camera_aidl_test.cpp
index 8e72b3f..bb9068e 100644
--- a/camera/provider/aidl/vts/camera_aidl_test.cpp
+++ b/camera/provider/aidl/vts/camera_aidl_test.cpp
@@ -2209,7 +2209,6 @@
     int64_t bufferId = 1;
     int32_t frameNumber = 1;
     CameraMetadata settings;
-
     for (const auto& name : cameraDeviceNames) {
         Stream testStream;
         std::vector<HalStream> halStreams;
@@ -2499,12 +2498,19 @@
 
 ndk::ScopedAStatus CameraAidlTest::configureStreams(std::shared_ptr<ICameraDeviceSession>& session,
                                                     const StreamConfiguration& config,
-                                                    bool sessionHalBufferManager,
-                                                    bool* useHalBufManager,
+                                                    BufferManagerType bufferManagerType,
+                                                    std::set<int32_t>* halBufManagedStreamIds,
                                                     std::vector<HalStream>* halStreams) {
     auto ret = ndk::ScopedAStatus::ok();
     ConfigureStreamsRet aidl_return;
-    if (sessionHalBufferManager) {
+    int32_t interfaceVersion = -1;
+    ret = session->getInterfaceVersion(&interfaceVersion);
+    if (!ret.isOk()) {
+        return ret;
+    }
+
+    if (flags::session_hal_buf_manager() &&
+        (bufferManagerType == BufferManagerType::SESSION && interfaceVersion >= 3)) {
         ret = session->configureStreamsV2(config, &aidl_return);
     } else {
         ret = session->configureStreams(config, halStreams);
@@ -2512,10 +2518,16 @@
     if (!ret.isOk()) {
         return ret;
     }
-    if (sessionHalBufferManager) {
-        *useHalBufManager = aidl_return.enableHalBufferManager;
+    if (flags::session_hal_buf_manager() && bufferManagerType == BufferManagerType::SESSION) {
         *halStreams = std::move(aidl_return.halStreams);
     }
+    for (const auto& halStream : *halStreams) {
+        if ((flags::session_hal_buf_manager() && bufferManagerType == BufferManagerType::SESSION &&
+             halStream.enableHalBufferManager) ||
+            bufferManagerType == BufferManagerType::HAL) {
+            halBufManagedStreamIds->insert(halStream.id);
+        }
+    }
     return ndk::ScopedAStatus::ok();
 }
 
@@ -2572,16 +2584,16 @@
     ASSERT_TRUE(ret.isOk());
     ASSERT_NE(*session, nullptr);
 
-    *useHalBufManager = false;
-    bool sessionHalBufferManager = false;
+    BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
     status = find_camera_metadata_ro_entry(
             staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
     if ((0 == status) && (entry.count == 1)) {
-        *useHalBufManager = (entry.data.u8[0] ==
-                             ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
-        sessionHalBufferManager =
-                (entry.data.u8[0] ==
-                 ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
+        if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
+            bufferManagerType = BufferManagerType::HAL;
+        } else if (entry.data.u8[0] ==
+                   ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
+            bufferManagerType = BufferManagerType::SESSION;
+        }
     }
 
     outputPreviewStreams.clear();
@@ -2640,7 +2652,8 @@
         ASSERT_EQ(supported, true);
 
         std::vector<HalStream> halConfigs;
-        ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager,
+        std::set<int32_t> halBufManagedStreamIds;
+        ret = configureStreams(*session, config, bufferManagerType, &halBufManagedStreamIds,
                                &halConfigs);
         ALOGI("configureStreams returns status: %d:%d", ret.getExceptionCode(),
               ret.getServiceSpecificError());
@@ -2648,6 +2661,7 @@
         ASSERT_EQ(1u, halConfigs.size());
         halStreams->clear();
         halStreams->push_back(halConfigs[0]);
+        *useHalBufManager = halBufManagedStreamIds.size() != 0;
         if (*useHalBufManager) {
             std::vector<Stream> ss(1);
             std::vector<HalStream> hs(1);
@@ -2774,6 +2788,7 @@
         overrideRotateAndCrop(&request.settings);
         request.outputBuffers = std::vector<StreamBuffer>(1);
         StreamBuffer& outputBuffer = request.outputBuffers[0];
+
         if (useHalBufManager) {
             outputBuffer = {halStreams[0].id,
                             /*bufferId*/ 0,   NativeHandle(), BufferStatus::OK,
@@ -2892,14 +2907,14 @@
         const AvailableStream* previewThreshold, const std::unordered_set<std::string>& physicalIds,
         std::shared_ptr<ICameraDeviceSession>* session, Stream* previewStream,
         std::vector<HalStream>* halStreams, bool* supportsPartialResults,
-        int32_t* partialResultCount, bool* useHalBufManager, std::shared_ptr<DeviceCb>* cb,
-        int32_t streamConfigCounter, bool allowUnsupport) {
+        int32_t* partialResultCount, std::set<int32_t>* halBufManagedStreamIds,
+        std::shared_ptr<DeviceCb>* cb, int32_t streamConfigCounter, bool allowUnsupport) {
     ASSERT_NE(nullptr, session);
     ASSERT_NE(nullptr, halStreams);
     ASSERT_NE(nullptr, previewStream);
     ASSERT_NE(nullptr, supportsPartialResults);
     ASSERT_NE(nullptr, partialResultCount);
-    ASSERT_NE(nullptr, useHalBufManager);
+    ASSERT_NE(nullptr, halBufManagedStreamIds);
     ASSERT_NE(nullptr, cb);
 
     ASSERT_FALSE(physicalIds.empty());
@@ -2936,16 +2951,16 @@
     ASSERT_TRUE(ret.isOk());
     ASSERT_NE(*session, nullptr);
 
-    *useHalBufManager = false;
-    bool sessionHalBufferManager = false;
+    BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
     status = find_camera_metadata_ro_entry(
             staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
     if ((0 == status) && (entry.count == 1)) {
-        *useHalBufManager = (entry.data.u8[0] ==
-                             ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
-        sessionHalBufferManager =
-                (entry.data.u8[0] ==
-                 ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
+        if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
+            bufferManagerType = BufferManagerType::HAL;
+        } else if (entry.data.u8[0] ==
+                   ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
+            bufferManagerType = BufferManagerType::SESSION;
+        }
     }
 
     outputPreviewStreams.clear();
@@ -3000,18 +3015,21 @@
 
     config.streamConfigCounter = streamConfigCounter;
     std::vector<HalStream> halConfigs;
-    ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager,
+    ret = configureStreams(*session, config, bufferManagerType, halBufManagedStreamIds,
                            &halConfigs);
 
     ASSERT_TRUE(ret.isOk());
     ASSERT_EQ(physicalIds.size(), halConfigs.size());
     *halStreams = halConfigs;
-    if (*useHalBufManager) {
-        std::vector<Stream> ss(physicalIds.size());
-        std::vector<HalStream> hs(physicalIds.size());
+    if (halBufManagedStreamIds->size() != 0) {
+        // Only include the streams that are HAL buffer managed
+        std::vector<Stream> ss;
+        std::vector<HalStream> hs;
         for (size_t i = 0; i < physicalIds.size(); i++) {
-            ss[i] = streams[i];
-            hs[i] = halConfigs[i];
+            if (contains(*halBufManagedStreamIds, halConfigs[i].id)) {
+                ss.emplace_back(streams[i]);
+                hs.emplace_back(halConfigs[i]);
+            }
         }
         (*cb)->setCurrentStreamConfig(ss, hs);
     }
@@ -3029,22 +3047,20 @@
     cb->waitForBuffersReturned();
 }
 
-void CameraAidlTest::configureStreams(const std::string& name,
-                                      const std::shared_ptr<ICameraProvider>& provider,
-                                      PixelFormat format,
-                                      std::shared_ptr<ICameraDeviceSession>* session,
-                                      Stream* previewStream, std::vector<HalStream>* halStreams,
-                                      bool* supportsPartialResults, int32_t* partialResultCount,
-                                      bool* useHalBufManager, std::shared_ptr<DeviceCb>* outCb,
-                                      uint32_t streamConfigCounter, bool maxResolution,
-                                      RequestAvailableDynamicRangeProfilesMap dynamicRangeProf,
-                                      RequestAvailableColorSpaceProfilesMap colorSpaceProf) {
+void CameraAidlTest::configureStreams(
+        const std::string& name, const std::shared_ptr<ICameraProvider>& provider,
+        PixelFormat format, std::shared_ptr<ICameraDeviceSession>* session, Stream* previewStream,
+        std::vector<HalStream>* halStreams, bool* supportsPartialResults,
+        int32_t* partialResultCount, std::set<int32_t>* halBufManagedStreamIds,
+        std::shared_ptr<DeviceCb>* outCb, uint32_t streamConfigCounter, bool maxResolution,
+        RequestAvailableDynamicRangeProfilesMap dynamicRangeProf,
+        RequestAvailableColorSpaceProfilesMap colorSpaceProf) {
     ASSERT_NE(nullptr, session);
     ASSERT_NE(nullptr, halStreams);
     ASSERT_NE(nullptr, previewStream);
     ASSERT_NE(nullptr, supportsPartialResults);
     ASSERT_NE(nullptr, partialResultCount);
-    ASSERT_NE(nullptr, useHalBufManager);
+    ASSERT_NE(nullptr, halBufManagedStreamIds);
     ASSERT_NE(nullptr, outCb);
 
     ALOGI("configureStreams: Testing camera device %s", name.c_str());
@@ -3081,16 +3097,16 @@
     ASSERT_TRUE(ret.isOk());
     ASSERT_NE(*session, nullptr);
 
-    *useHalBufManager = false;
-    bool sessionHalBufferManager = false;
+    BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
     status = find_camera_metadata_ro_entry(
             staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
     if ((0 == status) && (entry.count == 1)) {
-        *useHalBufManager = (entry.data.u8[0] ==
-                             ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
-        sessionHalBufferManager =
-                (entry.data.u8[0] ==
-                 ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
+        if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
+            bufferManagerType = BufferManagerType::HAL;
+        } else if (entry.data.u8[0] ==
+                   ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
+            bufferManagerType = BufferManagerType::SESSION;
+        }
     }
 
     outputStreams.clear();
@@ -3144,11 +3160,11 @@
     ASSERT_TRUE(ret.isOk());
     ASSERT_EQ(supported, true);
 
-    ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager, halStreams);
+    ret = configureStreams(*session, config, bufferManagerType, halBufManagedStreamIds, halStreams);
 
     ASSERT_TRUE(ret.isOk());
 
-    if (*useHalBufManager) {
+    if (halBufManagedStreamIds->size() != 0) {
         std::vector<Stream> ss(1);
         std::vector<HalStream> hs(1);
         ss[0] = streams[0];
@@ -3493,7 +3509,7 @@
         const AvailableStream* threshold, std::shared_ptr<ICameraDeviceSession>* session,
         Stream* stream, std::vector<HalStream>* halStreams, bool* supportsPartialResults,
         int32_t* partialResultCount, std::shared_ptr<DeviceCb>* outCb, int32_t* jpegBufferSize,
-        bool* useHalBufManager) {
+        std::set<int32_t>* halBufManagedStreamIds) {
     ASSERT_NE(nullptr, session);
     ASSERT_NE(nullptr, halStreams);
     ASSERT_NE(nullptr, stream);
@@ -3501,7 +3517,7 @@
     ASSERT_NE(nullptr, partialResultCount);
     ASSERT_NE(nullptr, outCb);
     ASSERT_NE(nullptr, jpegBufferSize);
-    ASSERT_NE(nullptr, useHalBufManager);
+    ASSERT_NE(nullptr, halBufManagedStreamIds);
 
     std::vector<AvailableStream> outputStreams;
     std::shared_ptr<ICameraDevice> cameraDevice;
@@ -3528,16 +3544,16 @@
         *supportsPartialResults = (*partialResultCount > 1);
     }
 
-    *useHalBufManager = false;
-    bool sessionHalBufferManager = false;
+    BufferManagerType bufferManagerType = BufferManagerType::FRAMEWORK;
     status = find_camera_metadata_ro_entry(
             staticMeta, ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry);
     if ((0 == status) && (entry.count == 1)) {
-        *useHalBufManager = (entry.data.u8[0] ==
-                             ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
-        sessionHalBufferManager =
-                (entry.data.u8[0] ==
-                 ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE);
+        if (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5) {
+            bufferManagerType = BufferManagerType::HAL;
+        } else if (entry.data.u8[0] ==
+                   ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE) {
+            bufferManagerType = BufferManagerType::SESSION;
+        }
     }
 
     auto st = getJpegBufferSize(staticMeta, jpegBufferSize);
@@ -3590,11 +3606,11 @@
 
     StreamConfiguration config = {streams, StreamConfigurationMode::NORMAL_MODE, CameraMetadata()};
 
-    ret = configureStreams(*session, config, sessionHalBufferManager, useHalBufManager, halStreams);
+    ret = configureStreams(*session, config, bufferManagerType, halBufManagedStreamIds, halStreams);
 
     ASSERT_TRUE(ret.isOk());
 
-    if (*useHalBufManager) {
+    if (halBufManagedStreamIds->size() != 0) {
         (*outCb)->setCurrentStreamConfig(streams, *halStreams);
     }
 
@@ -3697,7 +3713,7 @@
 
         std::vector<HalStream> halStreams;
         bool supportsPartialResults = false;
-        bool useHalBufManager = false;
+        std::set<int32_t> halBufManagedStreamIds;
         int32_t partialResultCount = 0;
         Stream previewStream;
         std::shared_ptr<DeviceCb> cb;
@@ -3706,7 +3722,7 @@
                 GRALLOC1_CONSUMER_USAGE_HWCOMPOSER);
         configureStreams(name, mProvider, PixelFormat::IMPLEMENTATION_DEFINED, &mSession,
                          &previewStream, &halStreams, &supportsPartialResults, &partialResultCount,
-                         &useHalBufManager, &cb, 0,
+                         &halBufManagedStreamIds, &cb, 0,
                          /*maxResolution*/ false, dynamicRangeProfile, colorSpace);
         ASSERT_NE(mSession, nullptr);
 
@@ -3745,7 +3761,7 @@
             auto bufferId = requestId + 1;  // Buffer id value 0 is not valid
             for (const auto& halStream : halStreams) {
                 buffer_handle_t buffer_handle;
-                if (useHalBufManager) {
+                if (contains(halBufManagedStreamIds, halStream.id)) {
                     outputBuffers[k] = {halStream.id,   0,
                                         NativeHandle(), BufferStatus::OK,
                                         NativeHandle(), NativeHandle()};
@@ -3812,10 +3828,12 @@
             }
         }
 
-        if (useHalBufManager) {
-            std::vector<int32_t> streamIds(halStreams.size());
+        if (halBufManagedStreamIds.size() != 0) {
+            std::vector<int32_t> streamIds;
             for (size_t i = 0; i < streamIds.size(); i++) {
-                streamIds[i] = halStreams[i].id;
+                if (contains(halBufManagedStreamIds, halStreams[i].id)) {
+                    streamIds.emplace_back(halStreams[i].id);
+                }
             }
             mSession->signalStreamFlush(streamIds, /*streamConfigCounter*/ 0);
             cb->waitForBuffersReturned();
diff --git a/camera/provider/aidl/vts/camera_aidl_test.h b/camera/provider/aidl/vts/camera_aidl_test.h
index b51544f..86f0c9b 100644
--- a/camera/provider/aidl/vts/camera_aidl_test.h
+++ b/camera/provider/aidl/vts/camera_aidl_test.h
@@ -99,6 +99,11 @@
 
 class DeviceCb;  // Forward declare to break circular header dependency
 
+template <typename T>
+bool contains(const std::set<T>& container, T value) {
+    return container.find(value) != container.end();
+}
+
 class CameraAidlTest : public ::testing::TestWithParam<std::string> {
   public:
     enum SystemCameraKind {
@@ -121,6 +126,8 @@
         HIDDEN_SECURE_CAMERA
     };
 
+    enum BufferManagerType { FRAMEWORK = 0, HAL, SESSION };
+
     struct AvailableStream {
         int32_t width;
         int32_t height;
@@ -200,11 +207,12 @@
             std::shared_ptr<ICameraDeviceSession>* session /*out*/, Stream* stream /*out*/,
             std::vector<HalStream>* halStreams, bool* supportsPartialResults /*out*/,
             int32_t* partialResultCount /*out*/, std::shared_ptr<DeviceCb>* outCb /*out*/,
-            int32_t* jpegBufferSize /*out*/, bool* useHalBufManager /*out*/);
+            int32_t* jpegBufferSize /*out*/, std::set<int32_t>* halBufManagedStreamIds /*out*/);
 
     ndk::ScopedAStatus configureStreams(std::shared_ptr<ICameraDeviceSession>& session,
                                         const StreamConfiguration& config,
-                                        bool sessionHalBufferManager, bool* useHalBufManager,
+                                        BufferManagerType bufferManagerType,
+                                        std::set<int32_t>* halBufManagedStreamIds,
                                         std::vector<HalStream>* halStreams);
 
     void configureStreams(
@@ -212,8 +220,9 @@
             PixelFormat format, std::shared_ptr<ICameraDeviceSession>* session /*out*/,
             Stream* previewStream /*out*/, std::vector<HalStream>* halStreams /*out*/,
             bool* supportsPartialResults /*out*/, int32_t* partialResultCount /*out*/,
-            bool* useHalBufManager /*out*/, std::shared_ptr<DeviceCb>* outCb /*out*/,
-            uint32_t streamConfigCounter, bool maxResolution,
+            std::set<int32_t>* halBufManagedStreamIds /*out*/,
+            std::shared_ptr<DeviceCb>* outCb /*out*/, uint32_t streamConfigCounter,
+            bool maxResolution,
             RequestAvailableDynamicRangeProfilesMap dynamicRangeProf =
                     RequestAvailableDynamicRangeProfilesMap::
                             ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
@@ -227,7 +236,7 @@
             const std::unordered_set<std::string>& physicalIds,
             std::shared_ptr<ICameraDeviceSession>* session /*out*/, Stream* previewStream /*out*/,
             std::vector<HalStream>* halStreams /*out*/, bool* supportsPartialResults /*out*/,
-            int32_t* partialResultCount /*out*/, bool* useHalBufManager /*out*/,
+            int32_t* partialResultCount /*out*/, std::set<int32_t>* halBufManagedStreamIds /*out*/,
             std::shared_ptr<DeviceCb>* cb /*out*/, int32_t streamConfigCounter = 0,
             bool allowUnsupport = false);