Set vendor ID in SharingLog metadata event.

PiperOrigin-RevId: 646992023

sharing/analytics/analytics_recorder.cc

@@ -32,7 +32,6 @@
 #include "sharing/proto/enums.pb.h"
 #include "sharing/share_target.h"
 #include "sharing/wifi_credentials_attachment.h"
-#include "google/protobuf/message_lite.h"
 #include "google/protobuf/repeated_ptr_field.h"
 
 namespace nearby {
@@ -1027,6 +1026,7 @@ std::unique_ptr<SharingLog> AnalyticsRecorder::CreateSharingLog(
   auto sharing_log = std::make_unique<SharingLog>();
   sharing_log->set_event_category(event_category);
   sharing_log->set_event_type(event_type);
+  sharing_log->mutable_event_metadata()->set_vendor_id(vendor_id_);
   return sharing_log;
 }
 

sharing/analytics/analytics_recorder.h

@@ -36,8 +36,9 @@ namespace analytics {
 
 class AnalyticsRecorder {
  public:
-  explicit AnalyticsRecorder(::nearby::analytics::EventLogger* event_logger)
-      : event_logger_(event_logger) {}
+  explicit AnalyticsRecorder(int32_t vendor_id,
+                             nearby::analytics::EventLogger* event_logger)
+      : vendor_id_(vendor_id), event_logger_(event_logger) {}
   ~AnalyticsRecorder() = default;
 
   void NewEstablishConnection(
@@ -209,6 +210,7 @@ class AnalyticsRecorder {
       location::nearby::proto::sharing::EventType event_type);
   void LogEvent(const nearby::sharing::analytics::proto::SharingLog& message);
 
+  const int32_t vendor_id_;
   nearby::analytics::EventLogger* event_logger_ = nullptr;
 };
 

sharing/analytics/analytics_recorder_test.cc

@@ -69,7 +69,7 @@ class AnalyticsRecorderTest : public ::testing::Test {
 
  private:
   MockEventLogger event_logger_;
-  AnalyticsRecorder analytics_recorder_{&event_logger_};
+  AnalyticsRecorder analytics_recorder_{/*vendor_id=*/0, &event_logger_};
 };
 
 TEST_F(AnalyticsRecorderTest, NewEstablishConnection) {

sharing/internal/api/BUILD

@@ -39,9 +39,9 @@ cc_library(
         "//sharing:__subpackages__",
     ],
     deps = [
-        "//internal/analytics:event_logger",
         "//internal/platform:types",
         "//internal/platform/implementation:account_manager",
+        "//sharing/analytics",
         "//sharing/proto:share_cc_proto",
         "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/status",
@@ -74,9 +74,9 @@ cc_library(
     visibility = ["//visibility:public"],
     deps = [
         ":platform",
-        "//internal/analytics:event_logger",
         "//internal/platform:types",
         "//internal/platform/implementation:account_manager",
+        "//sharing/analytics",
         "//sharing/proto:share_cc_proto",
         "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/status",

sharing/internal/api/mock_sharing_platform.h

@@ -21,10 +21,10 @@
 #include "gmock/gmock.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "internal/analytics/event_logger.h"
 #include "internal/platform/device_info.h"
 #include "internal/platform/implementation/account_manager.h"
 #include "internal/platform/task_runner.h"
+#include "sharing/analytics/analytics_recorder.h"
 #include "sharing/internal/api/app_info.h"
 #include "sharing/internal/api/bluetooth_adapter.h"
 #include "sharing/internal/api/fast_init_ble_beacon.h"
@@ -97,7 +97,9 @@ class MockSharingPlatform : public SharingPlatform {
               (absl::string_view database_path), (override));
   MOCK_METHOD(std::unique_ptr<SharingRpcClientFactory>,
               CreateSharingRpcClientFactory,
-              (nearby::analytics::EventLogger * event_logger), (override));
+              (nearby::sharing::analytics::AnalyticsRecorder *
+               analytics_recorder),
+              (override));
 };
 
 }  // namespace nearby::sharing::api

sharing/internal/api/sharing_platform.h

@@ -20,10 +20,10 @@
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "internal/analytics/event_logger.h"
 #include "internal/platform/device_info.h"
 #include "internal/platform/implementation/account_manager.h"
 #include "internal/platform/task_runner.h"
+#include "sharing/analytics/analytics_recorder.h"
 #include "sharing/internal/api/app_info.h"
 #include "sharing/internal/api/bluetooth_adapter.h"
 #include "sharing/internal/api/fast_init_ble_beacon.h"
@@ -95,7 +95,7 @@ class SharingPlatform {
 
   virtual std::unique_ptr<SharingRpcClientFactory>
   CreateSharingRpcClientFactory(
-      nearby::analytics::EventLogger* event_logger) = 0;
+      nearby::sharing::analytics::AnalyticsRecorder* analytics_recorder) = 0;
 };
 }  // namespace nearby::sharing::api
 

sharing/nearby_sharing_service_factory.cc

@@ -14,6 +14,7 @@
 
 #include "sharing/nearby_sharing_service_factory.h"
 
+#include <cstdint>
 #include <memory>
 #include <utility>
 
@@ -37,7 +38,7 @@ NearbySharingServiceFactory* NearbySharingServiceFactory::GetInstance() {
 }
 
 NearbySharingService* NearbySharingServiceFactory::CreateSharingService(
-    SharingPlatform& sharing_platform,
+    int32_t vendor_id, SharingPlatform& sharing_platform,
     ::nearby::analytics::EventLogger* event_logger) {
   if (nearby_sharing_service_ != nullptr) {
     return nullptr;
@@ -55,6 +56,7 @@ NearbySharingService* NearbySharingServiceFactory::CreateSharingService(
           sharing_platform.GetDeviceInfo(), event_logger_);
 
   nearby_sharing_service_ = std::make_unique<NearbySharingServiceImpl>(
+      vendor_id,
       std::move(service_thread),
       context_.get(), sharing_platform, decoder_.get(),
       std::move(nearby_connections_manager), event_logger_);

sharing/nearby_sharing_service_factory.h

@@ -15,6 +15,7 @@
 #ifndef THIRD_PARTY_NEARBY_SHARING_NEARBY_SHARING_SERVICE_FACTORY_H_
 #define THIRD_PARTY_NEARBY_SHARING_NEARBY_SHARING_SERVICE_FACTORY_H_
 
+#include <cstdint>
 #include <memory>
 
 #include "internal/analytics/event_logger.h"
@@ -31,6 +32,7 @@ class NearbySharingServiceFactory {
   static NearbySharingServiceFactory* GetInstance();
 
   NearbySharingService* CreateSharingService(
+      int32_t vendor_id,
       nearby::sharing::api::SharingPlatform& sharing_platform,
       ::nearby::analytics::EventLogger* event_logger);
 

sharing/nearby_sharing_service_impl.cc

@@ -186,8 +186,9 @@ OSType ToProtoOsType(::nearby::api::DeviceInfo::OsType os_type) {
 }  // namespace
 
 NearbySharingServiceImpl::NearbySharingServiceImpl(
-    std::unique_ptr<TaskRunner> service_thread, Context* context,
-    SharingPlatform& sharing_platform, NearbySharingDecoder* decoder,
+    int32_t vendor_id, std::unique_ptr<TaskRunner> service_thread,
+    Context* context, SharingPlatform& sharing_platform,
+    NearbySharingDecoder* decoder,
     std::unique_ptr<NearbyConnectionsManager> nearby_connections_manager,
     nearby::analytics::EventLogger* event_logger)
     : service_thread_(std::move(service_thread)),
@@ -197,8 +198,11 @@ NearbySharingServiceImpl::NearbySharingServiceImpl(
       account_manager_(sharing_platform.GetAccountManager()),
       decoder_(decoder),
       nearby_connections_manager_(std::move(nearby_connections_manager)),
+      analytics_recorder_(std::make_unique<analytics::AnalyticsRecorder>(
+          vendor_id, event_logger)),
       nearby_share_client_factory_(
-          sharing_platform.CreateSharingRpcClientFactory(event_logger)),
+          sharing_platform.CreateSharingRpcClientFactory(
+              analytics_recorder_.get())),
       profile_info_provider_(
           std::make_unique<NearbyShareProfileInfoProviderImpl>(
               device_info_, account_manager_)),
@@ -213,11 +217,9 @@ NearbySharingServiceImpl::NearbySharingServiceImpl(
           local_device_data_manager_.get())),
       nearby_fast_initiation_(
           NearbyFastInitiationImpl::Factory::Create(context_)),
-      analytics_recorder_(
-          std::make_unique<analytics::AnalyticsRecorder>(event_logger)),
       settings_(std::make_unique<NearbyShareSettings>(
           context_, context_->GetClock(), device_info_, preference_manager_,
-          local_device_data_manager_.get(), event_logger)),
+          local_device_data_manager_.get(), analytics_recorder_.get())),
       service_extension_(std::make_unique<NearbySharingServiceExtension>(
           context_, settings_.get())),
       app_info_(sharing_platform.CreateAppInfo()) {

sharing/nearby_sharing_service_impl.h

@@ -108,8 +108,8 @@ class NearbySharingServiceImpl
 
  public:
   NearbySharingServiceImpl(
-      std::unique_ptr<nearby::TaskRunner> service_thread, Context* context,
-      nearby::sharing::api::SharingPlatform& sharing_platform,
+      int32_t vendor_id, std::unique_ptr<nearby::TaskRunner> service_thread,
+      Context* context, nearby::sharing::api::SharingPlatform& sharing_platform,
       NearbySharingDecoder* decoder,
       std::unique_ptr<NearbyConnectionsManager> nearby_connections_manager,
       nearby::analytics::EventLogger* event_logger = nullptr);
@@ -480,8 +480,8 @@ class NearbySharingServiceImpl
   NearbySharingDecoder* const decoder_;
 
   std::unique_ptr<NearbyConnectionsManager> nearby_connections_manager_;
-  // Scanner which is non-null when we are performing a background scan for
-  // remote devices that are attempting to share.
+  // Used to create analytics events.
+  std::unique_ptr<analytics::AnalyticsRecorder> analytics_recorder_;
   std::unique_ptr<nearby::sharing::api::SharingRpcClientFactory>
       nearby_share_client_factory_;
   std::unique_ptr<NearbyShareProfileInfoProvider> profile_info_provider_;
@@ -490,9 +490,6 @@ class NearbySharingServiceImpl
   std::unique_ptr<NearbyShareCertificateManager> certificate_manager_;
   std::unique_ptr<NearbyFastInitiation> nearby_fast_initiation_;
 
-  // Used to create analytics events.
-  std::unique_ptr<analytics::AnalyticsRecorder> analytics_recorder_;
-
   // Used to maintain the settings of nearby sharing.
   std::unique_ptr<NearbyShareSettings> settings_;
 

sharing/nearby_sharing_service_impl_test.cc

@@ -436,8 +436,9 @@ class NearbySharingServiceImplTest : public testing::Test {
 
     fake_nearby_connections_manager_ = new FakeNearbyConnectionsManager();
     return std::make_unique<NearbySharingServiceImpl>(
-        std::move(task_runner), &fake_context_, mock_sharing_platform_,
-        &fake_decoder_, absl::WrapUnique(fake_nearby_connections_manager_));
+        /*vendor_id=*/0, std::move(task_runner), &fake_context_,
+        mock_sharing_platform_, &fake_decoder_,
+        absl::WrapUnique(fake_nearby_connections_manager_));
   }
 
   void SetVisibility(DeviceVisibility visibility) {

sharing/nearby_sharing_settings.cc

@@ -29,8 +29,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
-#include "internal/analytics/event_logger.h"
-#include "internal/flags/nearby_flags.h"
 #include "internal/platform/clock.h"
 #include "internal/platform/device_info.h"
 #include "internal/platform/mutex_lock.h"
@@ -39,7 +37,6 @@
 #include "sharing/common/compatible_u8_string.h"
 #include "sharing/common/nearby_share_enums.h"
 #include "sharing/common/nearby_share_prefs.h"
-#include "sharing/flags/generated/nearby_sharing_feature_flags.h"
 #include "sharing/internal/api/preference_manager.h"
 #include "sharing/internal/public/context.h"
 #include "sharing/internal/public/logging.h"
@@ -83,13 +80,12 @@ NearbyShareSettings::NearbyShareSettings(
     nearby::DeviceInfo& device_info,
     PreferenceManager& preference_manager,
     NearbyShareLocalDeviceDataManager* local_device_data_manager,
-    nearby::analytics::EventLogger* event_logger)
+    analytics::AnalyticsRecorder* analytics_recorder)
     : clock_(clock),
       device_info_(device_info),
       preference_manager_(preference_manager),
       local_device_data_manager_(local_device_data_manager),
-      analytics_recorder_(
-          std::make_unique<analytics::AnalyticsRecorder>(event_logger)) {
+      analytics_recorder_(analytics_recorder) {
   is_desctructing_ = std::make_shared<bool>(false);
   visibility_expiration_timer_ = context->CreateTimer();
   RestoreFallbackVisibility();
@@ -268,9 +264,11 @@ void NearbyShareSettings::SetEnabled(bool enabled) {
 void NearbyShareSettings::SetFastInitiationNotificationState(
     FastInitiationNotificationState state) {
   MutexLock lock(&mutex_);
-  analytics_recorder_->NewToggleShowNotification(
-      GetNotificationStatus(GetFastInitiationNotificationState()),
-      GetNotificationStatus(state));
+  if (analytics_recorder_ != nullptr) {
+    analytics_recorder_->NewToggleShowNotification(
+        GetNotificationStatus(GetFastInitiationNotificationState()),
+        GetNotificationStatus(state));
+  }
 
   preference_manager_.SetInteger(
       prefs::kNearbySharingFastInitiationNotificationStateName,
@@ -305,7 +303,9 @@ void NearbyShareSettings::ValidateDeviceName(
 void NearbyShareSettings::SetDeviceName(
     absl::string_view device_name,
     std::function<void(DeviceNameValidationResult)> callback) {
-  analytics_recorder_->NewSetDeviceName(device_name.size());
+  if (analytics_recorder_ != nullptr) {
+    analytics_recorder_->NewSetDeviceName(device_name.size());
+  }
   std::move(callback)(local_device_data_manager_->SetDeviceName(device_name));
 }
 
@@ -316,7 +316,9 @@ void NearbyShareSettings::GetDataUsage(
 
 void NearbyShareSettings::SetDataUsage(DataUsage data_usage) {
   MutexLock lock(&mutex_);
-  analytics_recorder_->NewSetDataUsage(GetDataUsage(), data_usage);
+  if (analytics_recorder_ != nullptr) {
+    analytics_recorder_->NewSetDataUsage(GetDataUsage(), data_usage);
+  }
   preference_manager_.SetInteger(prefs::kNearbySharingDataUsageName,
                                    static_cast<int>(data_usage));
 }
@@ -348,8 +350,10 @@ void NearbyShareSettings::SetVisibility(DeviceVisibility visibility,
       static_cast<DeviceVisibility>(preference_manager_.GetInteger(
           prefs::kNearbySharingBackgroundVisibilityName,
           static_cast<int>(prefs::kDefaultVisibility)));
-  analytics_recorder_->NewSetVisibility(last_visibility, visibility,
-                                        expiration / absl::Milliseconds(1));
+  if (analytics_recorder_ != nullptr) {
+    analytics_recorder_->NewSetVisibility(last_visibility, visibility,
+                                          expiration / absl::Milliseconds(1));
+  }
 
   NL_VLOG(1) << __func__
              << ": set visibility. visibility=" << static_cast<int>(visibility)
@@ -572,12 +576,16 @@ void NearbyShareSettings::SetIsAllContactsEnabled(
 
 void NearbyShareSettings::SendDesktopNotification(
     DesktopNotification event) const {
-  analytics_recorder_->NewSendDesktopNotification(event);
+  if (analytics_recorder_ != nullptr) {
+    analytics_recorder_->NewSendDesktopNotification(event);
+  }
 }
 
 void NearbyShareSettings::SendDesktopTransferEvent(
     DesktopTransferEventType event) const {
-  analytics_recorder_->NewSendDesktopTransferEvent(event);
+  if (analytics_recorder_ != nullptr) {
+    analytics_recorder_->NewSendDesktopTransferEvent(event);
+  }
 }
 
 bool NearbyShareSettings::is_fast_initiation_hardware_supported() {

sharing/nearby_sharing_settings.h

@@ -16,6 +16,7 @@
 #define THIRD_PARTY_NEARBY_SHARING_NEARBY_SHARING_SETTINGS_H_
 
 #include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -26,11 +27,11 @@
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
-#include "internal/analytics/event_logger.h"
 #include "internal/base/observer_list.h"
 #include "internal/platform/clock.h"
 #include "internal/platform/device_info.h"
 #include "internal/platform/mutex.h"
+#include "internal/platform/timer.h"
 #include "proto/sharing_enums.pb.h"
 #include "sharing/analytics/analytics_recorder.h"
 #include "sharing/common/nearby_share_enums.h"
@@ -136,7 +137,7 @@ class NearbyShareSettings
             }
             break;
           default:
-            LOG(FATAL) << "Invalid tag: " << this->tag;
+            NL_LOG(FATAL) << "Invalid tag: " << this->tag;
             break;
         }
         return result;
@@ -161,7 +162,7 @@ class NearbyShareSettings
       nearby::DeviceInfo& device_info,
       nearby::sharing::api::PreferenceManager& preference_manager,
       NearbyShareLocalDeviceDataManager* local_device_data_manager,
-      nearby::analytics::EventLogger* event_logger = nullptr);
+      analytics::AnalyticsRecorder* analytics_recorder = nullptr);
   ~NearbyShareSettings() override;
 
   // Internal synchronous getters for C++ clients
@@ -274,7 +275,7 @@ class NearbyShareSettings
   nearby::sharing::api::PreferenceManager& preference_manager_;
   NearbyShareLocalDeviceDataManager* const local_device_data_manager_;
   // Used to create analytics events.
-  std::unique_ptr<analytics::AnalyticsRecorder> analytics_recorder_;
+  analytics::AnalyticsRecorder* const analytics_recorder_;
 
   std::shared_ptr<bool> is_desctructing_ = nullptr;
   bool is_fast_initiation_hardware_supported_ ABSL_GUARDED_BY(mutex_) = false;