diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index 88c0bb5..5a892bc 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -137,6 +137,7 @@
 static constexpr int32_t kVendorClientState = ActivityManager::PROCESS_STATE_PERSISTENT_UI;
 
 const String8 CameraService::kOfflineDevice("offline-");
+const String16 CameraService::kWatchAllClientsFlag("all");
 
 // Set to keep track of logged service error events.
 static std::set<String8> sServiceErrorEventSet;
@@ -1788,7 +1789,8 @@
         LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
                 __FUNCTION__);
 
-        err = client->initialize(mCameraProviderManager, mMonitorTags);
+        String8 monitorTags = isClientWatched(client.get()) ? mMonitorTags : String8("");
+        err = client->initialize(mCameraProviderManager, monitorTags);
         if (err != OK) {
             ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
             // Errors could be from the HAL module open call or from AppOpsManager
@@ -1954,7 +1956,8 @@
             return BAD_VALUE;
         }
 
-        auto err = offlineClient->initialize(mCameraProviderManager, mMonitorTags);
+        String8 monitorTags = isClientWatched(offlineClient.get()) ? mMonitorTags : String8("");
+        auto err = offlineClient->initialize(mCameraProviderManager, monitorTags);
         if (err != OK) {
             ALOGE("%s: Could not initialize offline client.", __FUNCTION__);
             return err;
@@ -2620,6 +2623,7 @@
     for (auto& i : mActiveClientManager.getAll()) {
         auto clientSp = i->getValue();
         if (clientSp.get() == client) {
+            cacheClientTagDumpIfNeeded(client->mCameraIdStr, clientSp.get());
             mActiveClientManager.remove(i);
         }
     }
@@ -2696,7 +2700,11 @@
         return sp<BasicClient>{nullptr};
     }
 
-    return clientDescriptorPtr->getValue();
+    sp<BasicClient> client = clientDescriptorPtr->getValue();
+    if (client.get() != nullptr) {
+        cacheClientTagDumpIfNeeded(clientDescriptorPtr->getKey(), client.get());
+    }
+    return client;
 }
 
 void CameraService::doUserSwitch(const std::vector<int32_t>& newUserIds) {
@@ -4245,6 +4253,30 @@
     dprintf(fd, "\n");
 }
 
+void CameraService::cacheClientTagDumpIfNeeded(const char *cameraId, BasicClient* client) {
+    Mutex::Autolock lock(mLogLock);
+    if (!isClientWatchedLocked(client)) { return; }
+
+    std::vector<std::string> dumpVector;
+    client->dumpWatchedEventsToVector(dumpVector);
+
+    if (dumpVector.empty()) { return; }
+
+    std::string dumpString;
+    size_t i = dumpVector.size();
+
+    // Store the string in reverse order (latest last)
+    while (i > 0) {
+         i--;
+         dumpString += cameraId;
+         dumpString += ":";
+         dumpString += dumpVector[i]; // implicitly ends with '\n'
+    }
+
+    const String16 &packageName = client->getPackageName();
+    mWatchedClientsDumpCache[packageName] = dumpString;
+}
+
 void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) {
     Mutex::Autolock al(mTorchClientMapMutex);
     for (size_t i = 0; i < mTorchClientMap.size(); i++) {
@@ -4697,44 +4729,81 @@
     return OK;
 }
 
-status_t CameraService::handleWatchCommand(const Vector<String16>& args, int out) {
-    if (args.size() == 3 && args[1] == String16("start")) {
-        return startWatchingTags(args[2], out);
+status_t CameraService::handleWatchCommand(const Vector<String16>& args, int outFd) {
+    if (args.size() >= 3 && args[1] == String16("start")) {
+        return startWatchingTags(args, outFd);
     } else if (args.size() == 2 && args[1] == String16("dump")) {
-        return camera3::CameraTraces::dump(out);
+        return camera3::CameraTraces::dump(outFd);
     } else if (args.size() == 2 && args[1] == String16("stop")) {
-        return stopWatchingTags(out);
-    } else if (args.size() >= 2 && args[1] == String16("live")) {
-        return printWatchedTagsUntilInterrupt(args, out);
+        return stopWatchingTags(outFd);
+    } else if (args.size() >= 2 && args[1] == String16("print")) {
+        return printWatchedTags(args, outFd);
     }
-    dprintf(out, "Camera service watch commands:\n"
-                 "  start <comma_separated_tag_list> starts watching the provided tags\n"
-                 "                                   recognizes shorthands like '3a'\n"
+    dprintf(outFd, "Camera service watch commands:\n"
+                 "  start -m <comma_separated_tag_list> [-c <comma_separated_client_list>]\n"
+                 "        starts watching the provided tags for clients with provided package\n"
+                 "        recognizes tag shorthands like '3a'\n"
+                 "        watches all clients if no client is passed, or if 'all' is listed\n"
                  "  dump dumps camera trace\n"
                  "  stop stops watching all tags\n"
-                 "  live prints the monitored information in real time\n"
-                 "        Hit Ctrl+C to stop.\n");
+                 "  print [-n <refresh_interval_ms>]\n"
+                 "        prints the monitored information in real time\n"
+                 "        Hit Ctrl+C to exit\n");
   return BAD_VALUE;
 }
 
-status_t CameraService::startWatchingTags(const String16 &tags, int outFd) {
+status_t CameraService::startWatchingTags(const Vector<String16> &args, int outFd) {
+    Mutex::Autolock lock(mLogLock);
+    size_t tagsIdx; // index of '-m'
+    String16 tags("");
+    for (tagsIdx = 2; tagsIdx < args.size() && args[tagsIdx] != String16("-m"); tagsIdx++);
+    if (tagsIdx < args.size() - 1) {
+        tags = args[tagsIdx + 1];
+    } else {
+        dprintf(outFd, "No tags provided.\n");
+        return BAD_VALUE;
+    }
+
+    size_t clientsIdx; // index of '-c'
+    String16 clients = kWatchAllClientsFlag; // watch all clients if no clients are provided
+    for (clientsIdx = 2; clientsIdx < args.size() && args[clientsIdx] != String16("-c");
+         clientsIdx++);
+    if (clientsIdx < args.size() - 1) {
+        clients = args[clientsIdx + 1];
+    }
+    parseClientsToWatchLocked(String8(clients));
+
     // track tags to initialize future clients with the monitoring information
     mMonitorTags = String8(tags);
 
+    bool serviceLock = tryLock(mServiceLock);
+    int numWatchedClients = 0;
     auto cameraClients = mActiveClientManager.getAll();
     for (const auto &clientDescriptor: cameraClients) {
         if (clientDescriptor == nullptr) { continue; }
         sp<BasicClient> client = clientDescriptor->getValue();
         if (client.get() == nullptr) { continue; }
-        client->startWatchingTags(mMonitorTags, outFd);
+
+        if (isClientWatchedLocked(client.get())) {
+            client->startWatchingTags(mMonitorTags, outFd);
+            numWatchedClients++;
+        }
     }
+    dprintf(outFd, "Started watching %d active clients\n", numWatchedClients);
+
+    if (serviceLock) { mServiceLock.unlock(); }
     return OK;
 }
 
 status_t CameraService::stopWatchingTags(int outFd) {
     // clear mMonitorTags to prevent new clients from monitoring tags at initialization
+    Mutex::Autolock lock(mLogLock);
     mMonitorTags = String8::empty();
 
+    mWatchedClientPackages.clear();
+    mWatchedClientsDumpCache.clear();
+
+    bool serviceLock = tryLock(mServiceLock);
     auto cameraClients = mActiveClientManager.getAll();
     for (const auto &clientDescriptor : cameraClients) {
         if (clientDescriptor == nullptr) { continue; }
@@ -4742,18 +4811,17 @@
         if (client.get() == nullptr) { continue; }
         client->stopWatchingTags(outFd);
     }
+    dprintf(outFd, "Stopped watching all clients.\n");
+    if (serviceLock) { mServiceLock.unlock(); }
     return OK;
 }
 
-status_t CameraService::printWatchedTagsUntilInterrupt(const Vector<String16> &args, int outFd) {
+status_t CameraService::printWatchedTags(const Vector<String16> &args, int outFd) {
+    // Figure outFd refresh interval, if present in args
     useconds_t refreshTimeoutMs = 1000; // refresh every 1s by default
-
     if (args.size() > 2) {
-        size_t intervalIdx; // index of refresh interval argument
-        for (intervalIdx = 2;
-             intervalIdx < args.size()
-                && String16("-n") != args[intervalIdx]
-                && String16("--interval") != args[intervalIdx];
+        size_t intervalIdx; // index of '-n'
+        for (intervalIdx = 2; intervalIdx < args.size() && String16("-n") != args[intervalIdx];
              intervalIdx++);
 
         size_t intervalValIdx = intervalIdx + 1;
@@ -4763,6 +4831,43 @@
         }
     }
 
+    mLogLock.lock();
+    bool serviceLock = tryLock(mServiceLock);
+    // get all watched clients that are currently connected
+    std::set<String16> connectedMoniterdClients;
+    for (const auto &clientDescriptor: mActiveClientManager.getAll()) {
+        if (clientDescriptor == nullptr) { continue; }
+
+        sp<BasicClient> client = clientDescriptor->getValue();
+        if (client.get() == nullptr) { continue; }
+        if (!isClientWatchedLocked(client.get())) { continue; }
+
+        connectedMoniterdClients.emplace(client->getPackageName());
+    }
+    if (serviceLock) { mServiceLock.unlock(); }
+
+    // Print entries in mWatchedClientsDumpCache for clients that are not connected
+    for (const auto &kv: mWatchedClientsDumpCache) {
+        const String16 &package = kv.first;
+        if (connectedMoniterdClients.find(package) != connectedMoniterdClients.end()) {
+            continue;
+        }
+
+        dprintf(outFd, "Client: %s\n", String8(package).string());
+        dprintf(outFd, "%s\n", kv.second.c_str());
+    }
+    mLogLock.unlock();
+
+    if (connectedMoniterdClients.empty()) {
+        dprintf(outFd, "No watched client active.\n");
+        return OK;
+    }
+
+    // For connected watched clients, print monitored tags live
+    return printWatchedTagsUntilInterrupt(refreshTimeoutMs  * 1000, outFd);
+}
+
+status_t CameraService::printWatchedTagsUntilInterrupt(useconds_t refreshMicros, int outFd) {
     std::unordered_map<std::string, std::string> cameraToLastEvent;
     auto cameraClients = mActiveClientManager.getAll();
 
@@ -4774,6 +4879,7 @@
     dprintf(outFd, "Press Ctrl + C to exit...\n\n");
     while (true) {
         for (const auto& clientDescriptor : cameraClients) {
+            Mutex::Autolock lock(mLogLock);
             if (clientDescriptor == nullptr) { continue; }
             const char* cameraId = clientDescriptor->getKey().string();
 
@@ -4782,6 +4888,7 @@
 
             sp<BasicClient> client = clientDescriptor->getValue();
             if (client.get() == nullptr) { continue; }
+            if (!isClientWatchedLocked(client.get())) { continue; }
 
             std::vector<std::string> latestEvents;
             client->dumpWatchedEventsToVector(latestEvents);
@@ -4795,7 +4902,7 @@
                 cameraToLastEvent[cameraId] = latestEvents[0];
             }
         }
-        usleep(refreshTimeoutMs * 1000);  // convert ms to us
+        usleep(refreshMicros);  // convert ms to us
     }
     return OK;
 }
@@ -4825,6 +4932,30 @@
     } while (idxToPrint != 0);
 }
 
+void CameraService::parseClientsToWatchLocked(String8 clients) {
+    mWatchedClientPackages.clear();
+
+    const char *allSentinel = String8(kWatchAllClientsFlag).string();
+
+    char *tokenized = clients.lockBuffer(clients.size());
+    char *savePtr;
+    char *nextClient = strtok_r(tokenized, ",", &savePtr);
+
+    while (nextClient != nullptr) {
+        if (strcmp(nextClient, allSentinel) == 0) {
+            // Don't need to track any other package if 'all' is present
+            mWatchedClientPackages.clear();
+            mWatchedClientPackages.emplace(kWatchAllClientsFlag);
+            break;
+        }
+
+        // track package names
+        mWatchedClientPackages.emplace(nextClient);
+        nextClient = strtok_r(nullptr, ",", &savePtr);
+    }
+    clients.unlockBuffer();
+}
+
 status_t CameraService::printHelp(int out) {
     return dprintf(out, "Camera service commands:\n"
         "  get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
@@ -4841,6 +4972,16 @@
         "  help print this message\n");
 }
 
+bool CameraService::isClientWatched(const BasicClient *client) {
+    Mutex::Autolock lock(mLogLock);
+    return isClientWatchedLocked(client);
+}
+
+bool CameraService::isClientWatchedLocked(const BasicClient *client) {
+    return mWatchedClientPackages.find(kWatchAllClientsFlag) != mWatchedClientPackages.end() ||
+           mWatchedClientPackages.find(client->getPackageName()) != mWatchedClientPackages.end();
+}
+
 int32_t CameraService::updateAudioRestriction() {
     Mutex::Autolock lock(mServiceLock);
     return updateAudioRestrictionLocked();
diff --git a/services/camera/libcameraservice/CameraService.h b/services/camera/libcameraservice/CameraService.h
index f701d30..c5ab7cb 100644
--- a/services/camera/libcameraservice/CameraService.h
+++ b/services/camera/libcameraservice/CameraService.h
@@ -829,6 +829,14 @@
     RingBuffer<String8> mEventLog;
     Mutex mLogLock;
 
+    // set of client package names to watch. if this set contains 'all', then all clients will
+    // be watched. Access should be guarded by mLogLock
+    std::set<String16> mWatchedClientPackages;
+    // cache of last monitored tags dump immediately before the client disconnects. If a client
+    // re-connects, its entry is not updated until it disconnects again. Access should be guarded
+    // by mLogLock
+    std::map<String16, std::string> mWatchedClientsDumpCache;
+
     // The last monitored tags set by client
     String8 mMonitorTags;
 
@@ -961,6 +969,8 @@
      */
     void dumpEventLog(int fd);
 
+    void cacheClientTagDumpIfNeeded(const char *cameraId, BasicClient *client);
+
     /**
      * This method will acquire mServiceLock
      */
@@ -1154,17 +1164,21 @@
     status_t handleSetCameraMute(const Vector<String16>& args);
 
     // Handle 'watch' command as passed through 'cmd'
-    status_t handleWatchCommand(const Vector<String16> &args, int out);
+    status_t handleWatchCommand(const Vector<String16> &args, int outFd);
 
-    // Enable tag monitoring of the given tags in all attached clients
-    status_t startWatchingTags(const String16 &tags, int outFd);
+    // Enable tag monitoring of the given tags in provided clients
+    status_t startWatchingTags(const Vector<String16> &args, int outFd);
 
-    // Disable tag monitoring in all attached clients
+    // Disable tag monitoring
     status_t stopWatchingTags(int outFd);
 
-    // Print events of monitored tags in all attached devices as they are captured
+    // Print events of monitored tags in all cached and attached clients
+    status_t printWatchedTags(const Vector<String16> &args, int outFd);
+
+    // Print events of monitored tags in all attached clients as they are captured. New events are
+    // fetched every `refreshMicros` us
     // NOTE: This function does not terminate unless interrupted.
-    status_t printWatchedTagsUntilInterrupt(const Vector<String16> &args, int outFd);
+    status_t printWatchedTagsUntilInterrupt(useconds_t refreshMicros, int outFd);
 
     // Print all events in vector `events' that came after lastPrintedEvent
     static void printNewWatchedEvents(int outFd,
@@ -1173,9 +1187,23 @@
                                       const std::vector<std::string> &events,
                                       const std::string &lastPrintedEvent);
 
+    // Parses comma separated clients list and adds them to mWatchedClientPackages.
+    // Does not acquire mLogLock before modifying mWatchedClientPackages. It is the caller's
+    // responsibility to acquire mLogLock before calling this function.
+    void parseClientsToWatchLocked(String8 clients);
+
     // Prints the shell command help
     status_t printHelp(int out);
 
+    // Returns true if client should monitor tags based on the contents of mWatchedClientPackages.
+    // Acquires mLogLock before querying mWatchedClientPackages.
+    bool isClientWatched(const BasicClient *client);
+
+    // Returns true if client should monitor tags based on the contents of mWatchedClientPackages.
+    // Does not acquire mLogLock before querying mWatchedClientPackages. It is the caller's
+    // responsibility to acquire mLogLock before calling this functions.
+    bool isClientWatchedLocked(const BasicClient *client);
+
     /**
      * Get the current system time as a formatted string.
      */
@@ -1206,6 +1234,10 @@
     // Use separate keys for offline devices.
     static const String8 kOfflineDevice;
 
+    // Sentinel value to be stored in `mWatchedClientsPackages` to indicate that all clients should
+    // be watched.
+    static const String16 kWatchAllClientsFlag;
+
     // TODO: right now each BasicClient holds one AppOpsManager instance.
     // We can refactor the code so all of clients share this instance
     AppOpsManager mAppOps;