Move IntroductionFrame handing to ShareTargetInfo.

PiperOrigin-RevId: 644192822

Author: ftsui

sharing/BUILD

@@ -199,7 +199,9 @@ cc_library(
         "//sharing/common:compatible_u8_string",
         "//sharing/internal/public:logging",
         "//sharing/internal/public:types",
+        "//sharing/proto:wire_format_cc_proto",
         "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/types:span",
@@ -350,6 +352,17 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "attachment_compare",
+    testonly = True,
+    srcs = ["attachment_compare.cc"],
+    hdrs = ["attachment_compare.h"],
+    deps = [
+        ":attachments",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
 cc_test(
     name = "advertisement_test",
     srcs = ["advertisement_test.cc"],
@@ -721,6 +734,7 @@ cc_test(
     name = "attachment_container_test",
     srcs = ["attachment_container_test.cc"],
     deps = [
+        ":attachment_compare",
         ":attachments",
         "@com_github_protobuf_matchers//protobuf-matchers",
         "@com_google_googletest//:gtest_main",
@@ -755,3 +769,22 @@ cc_test(
         "@com_google_googletest//:gtest_main",
     ],
 )
+
+cc_test(
+    name = "incoming_share_target_info_test",
+    srcs = ["incoming_share_target_info_test.cc"],
+    deps = [
+        ":attachment_compare",
+        ":attachments",
+        ":share_target_info",
+        ":transfer_metadata",
+        ":types",
+        "//internal/platform/implementation/g3",  # fixdeps: keep
+        "//sharing/internal/public:logging",
+        "//sharing/proto:wire_format_cc_proto",
+        "//third_party/protobuf",
+        "@com_github_protobuf_matchers//protobuf-matchers",
+        "@com_google_absl//absl/strings:string_view",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

sharing/attachment_compare.cc

@@ -0,0 +1,50 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sharing/attachment_compare.h"
+#include "sharing/file_attachment.h"
+#include "sharing/text_attachment.h"
+#include "sharing/wifi_credentials_attachment.h"
+
+namespace nearby::sharing {
+
+bool operator==(const TextAttachment& lhs, const TextAttachment& rhs) {
+  return lhs.id() == rhs.id() && lhs.family() == rhs.family() &&
+         lhs.size() == rhs.size() && lhs.batch_id() == rhs.batch_id() &&
+         lhs.source_type() == rhs.source_type() && lhs.type() == rhs.type() &&
+         lhs.text_title() == rhs.text_title() &&
+         lhs.text_body() == rhs.text_body() &&
+         lhs.mime_type() == rhs.mime_type();
+}
+
+bool operator==(const FileAttachment& lhs, const FileAttachment& rhs) {
+  return lhs.id() == rhs.id() && lhs.family() == rhs.family() &&
+         lhs.size() == rhs.size() && lhs.batch_id() == rhs.batch_id() &&
+         lhs.source_type() == rhs.source_type() &&
+         lhs.file_name() == rhs.file_name() &&
+         lhs.mime_type() == rhs.mime_type() && lhs.type() == rhs.type() &&
+         lhs.file_path() == rhs.file_path() &&
+         lhs.parent_folder() == rhs.parent_folder();
+}
+
+bool operator==(const WifiCredentialsAttachment& lhs,
+                const WifiCredentialsAttachment& rhs) {
+  return lhs.id() == rhs.id() && lhs.family() == rhs.family() &&
+         lhs.size() == rhs.size() && lhs.batch_id() == rhs.batch_id() &&
+         lhs.ssid() == rhs.ssid() &&
+         lhs.security_type() == rhs.security_type() &&
+         lhs.password() == rhs.password() && lhs.is_hidden() == rhs.is_hidden();
+}
+
+}  // namespace nearby::sharing

sharing/attachment_compare.h

@@ -0,0 +1,31 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef THIRD_PARTY_NEARBY_SHARING_ATTACHMENT_COMPARE_H_
+#define THIRD_PARTY_NEARBY_SHARING_ATTACHMENT_COMPARE_H_
+
+#include "sharing/file_attachment.h"
+#include "sharing/text_attachment.h"
+#include "sharing/wifi_credentials_attachment.h"
+
+namespace nearby::sharing {
+
+bool operator==(const TextAttachment& lhs, const TextAttachment& rhs);
+bool operator==(const FileAttachment& lhs, const FileAttachment& rhs);
+bool operator==(const WifiCredentialsAttachment& lhs,
+                const WifiCredentialsAttachment& rhs);
+
+}  // namespace nearby::sharing
+
+#endif  // THIRD_PARTY_NEARBY_SHARING_ATTACHMENT_COMPARE_H_

sharing/attachment_container.cc

@@ -50,6 +50,17 @@ int64_t AttachmentContainer::GetTotalAttachmentsSize() const {
   return size_in_bytes;
 }
 
+int64_t AttachmentContainer::GetStorageSize() const {
+  int64_t size_in_bytes = 0;
+
+  // Only files require disk storage.
+  for (const auto& file : file_attachments_) {
+    size_in_bytes += file.size();
+  }
+
+  return size_in_bytes;
+}
+
 void AttachmentContainer::ClearAttachments() {
   // Reset file paths for file attachments.
   for (auto& file : file_attachments_)
@@ -66,6 +77,12 @@ void AttachmentContainer::ClearAttachments() {
   }
 }
 
+void AttachmentContainer::Clear() {
+  file_attachments_.clear();
+  text_attachments_.clear();
+  wifi_credentials_attachments_.clear();
+}
+
 std::vector<int64_t> AttachmentContainer::GetAttachmentIds() const {
   std::vector<int64_t> attachment_ids;
 

sharing/attachment_container.h

@@ -83,6 +83,9 @@ class AttachmentContainer {
   // Returns the total size of all attachments.
   int64_t GetTotalAttachmentsSize() const;
 
+  // Returns the total size of all attachments on disk.
+  int64_t GetStorageSize() const;
+
   // Returns true if there are any attachments.
   bool HasAttachments() const {
     return !text_attachments_.empty() || !file_attachments_.empty() ||
@@ -93,6 +96,9 @@ class AttachmentContainer {
   // place.
   void ClearAttachments();
 
+  // Delete all attachments.
+  void Clear();
+
   // Returns the list of attachment IDs of attachments in this container.
   std::vector<int64_t> GetAttachmentIds() const;
 

sharing/attachment_container_test.cc

@@ -23,40 +23,12 @@
 #include "protobuf-matchers/protocol-buffer-matchers.h"
 #include "gtest/gtest.h"
 #include "sharing/attachment.h"
+#include "sharing/attachment_compare.h"  // IWYU pragma: keep
 #include "sharing/file_attachment.h"
 #include "sharing/text_attachment.h"
 #include "sharing/wifi_credentials_attachment.h"
 
 namespace nearby::sharing {
-
-bool operator==(const TextAttachment& lhs, const TextAttachment& rhs) {
-  return lhs.id() == rhs.id() && lhs.family() == rhs.family() &&
-         lhs.size() == rhs.size() && lhs.batch_id() == rhs.batch_id() &&
-         lhs.source_type() == rhs.source_type() && lhs.type() == rhs.type() &&
-         lhs.text_title() == rhs.text_title() &&
-         lhs.text_body() == rhs.text_body() &&
-         lhs.mime_type() == rhs.mime_type();
-}
-
-bool operator==(const FileAttachment& lhs, const FileAttachment& rhs) {
-  return lhs.id() == rhs.id() && lhs.family() == rhs.family() &&
-         lhs.size() == rhs.size() && lhs.batch_id() == rhs.batch_id() &&
-         lhs.source_type() == rhs.source_type() &&
-         lhs.file_name() == rhs.file_name() &&
-         lhs.mime_type() == rhs.mime_type() && lhs.type() == rhs.type() &&
-         lhs.file_path() == rhs.file_path() &&
-         lhs.parent_folder() == rhs.parent_folder();
-}
-
-bool operator==(const WifiCredentialsAttachment& lhs,
-                const WifiCredentialsAttachment& rhs) {
-  return lhs.id() == rhs.id() && lhs.family() == rhs.family() &&
-         lhs.size() == rhs.size() && lhs.batch_id() == rhs.batch_id() &&
-         lhs.ssid() == rhs.ssid() &&
-         lhs.security_type() == rhs.security_type() &&
-         lhs.password() == rhs.password() && lhs.is_hidden() == rhs.is_hidden();
-}
-
 namespace {
 
 using testing::Eq;
@@ -209,6 +181,17 @@ TEST_F(AttachmentContainerTest, ClearAttachments) {
               IsFalse());
 }
 
+TEST_F(AttachmentContainerTest, Clear) {
+  AttachmentContainer container(std::vector<TextAttachment>{text1_, text2_},
+                                std::vector<FileAttachment>{file1_},
+                                std::vector<WifiCredentialsAttachment>{wifi1_});
+  EXPECT_THAT(container.HasAttachments(), IsTrue());
+
+  container.Clear();
+
+  EXPECT_THAT(container.HasAttachments(), IsFalse());
+}
+
 TEST_F(AttachmentContainerTest, GetAttachmentIds) {
   AttachmentContainer container(std::vector<TextAttachment>{text1_, text2_},
                                 std::vector<FileAttachment>{file1_},
@@ -222,6 +205,16 @@ TEST_F(AttachmentContainerTest, GetAttachmentIds) {
                                    wifi1_.id()));
 }
 
+TEST_F(AttachmentContainerTest, GetStorageSize) {
+  AttachmentContainer container(std::vector<TextAttachment>{text1_, text2_},
+                                std::vector<FileAttachment>{file1_},
+                                std::vector<WifiCredentialsAttachment>{wifi1_});
+
+  int64_t storage_size = container.GetStorageSize();
+
+  EXPECT_THAT(storage_size, Eq(file1_.size()));
+}
+
 }  // namespace
 
 }  // namespace nearby::sharing

sharing/incoming_share_target_info.cc

@@ -14,17 +14,31 @@
 
 #include "sharing/incoming_share_target_info.h"
 
+#include <cstdint>
 #include <functional>
+#include <limits>
+#include <optional>
 #include <string>
 #include <utility>
 
+#include "sharing/attachment_container.h"
+#include "sharing/constants.h"
+#include "sharing/file_attachment.h"
+#include "sharing/internal/public/logging.h"
 #include "sharing/nearby_connection.h"
+#include "sharing/proto/wire_format.pb.h"
 #include "sharing/share_target.h"
 #include "sharing/share_target_info.h"
+#include "sharing/text_attachment.h"
 #include "sharing/transfer_metadata.h"
+#include "sharing/wifi_credentials_attachment.h"
 
-namespace nearby {
-namespace sharing {
+namespace nearby::sharing {
+namespace {
+
+using ::nearby::sharing::service::proto::IntroductionFrame;
+
+}  // namespace
 
 IncomingShareTargetInfo::IncomingShareTargetInfo(
     std::string endpoint_id, const ShareTarget& share_target,
@@ -52,5 +66,77 @@ bool IncomingShareTargetInfo::OnNewConnection(NearbyConnection* connection) {
   return true;
 }
 
-}  // namespace sharing
-}  // namespace nearby
+std::optional<TransferMetadata::Status>
+IncomingShareTargetInfo::ProcessIntroduction(
+    const IntroductionFrame& introduction_frame) {
+  int64_t file_size_sum = 0;
+  AttachmentContainer& container = mutable_attachment_container();
+  for (const auto& file : introduction_frame.file_metadata()) {
+    if (file.size() <= 0) {
+      NL_LOG(WARNING)
+          << __func__
+          << ": Ignore introduction, due to invalid attachment size";
+      return TransferMetadata::Status::kUnsupportedAttachmentType;
+    }
+
+    NL_VLOG(1) << __func__ << ": Found file attachment: id=" << file.id()
+               << ", type= " << file.type() << ", size=" << file.size()
+               << ", payload_id=" << file.payload_id()
+               << ", parent_folder=" << file.parent_folder()
+               << ", mime_type=" << file.mime_type();
+    container.AddFileAttachment(
+        FileAttachment(file.id(), file.size(), file.name(), file.mime_type(),
+                       file.type(), file.parent_folder()));
+    SetAttachmentPayloadId(file.id(), file.payload_id());
+
+    if (std::numeric_limits<int64_t>::max() - file.size() < file_size_sum) {
+      NL_LOG(WARNING) << __func__
+                      << ": Ignoring introduction, total file size overflowed "
+                         "64 bit integer.";
+      container.Clear();
+      return TransferMetadata::Status::kNotEnoughSpace;
+    }
+    file_size_sum += file.size();
+  }
+
+  for (const auto& text : introduction_frame.text_metadata()) {
+    if (text.size() <= 0) {
+      NL_LOG(WARNING)
+          << __func__
+          << ": Ignore introduction, due to invalid attachment size";
+      return TransferMetadata::Status::kUnsupportedAttachmentType;
+    }
+
+    NL_VLOG(1) << __func__ << ": Found text attachment: id=" << text.id()
+               << ", type= " << text.type() << ", size=" << text.size()
+               << ", payload_id=" << text.payload_id();
+    container.AddTextAttachment(
+        TextAttachment(text.id(), text.type(), text.text_title(), text.size()));
+    SetAttachmentPayloadId(text.id(), text.payload_id());
+  }
+
+  if (kSupportReceivingWifiCredentials) {
+    for (const auto& wifi_credentials :
+         introduction_frame.wifi_credentials_metadata()) {
+      NL_VLOG(1) << __func__ << ": Found WiFi credentials attachment: id="
+                 << wifi_credentials.id()
+                 << ", ssid= " << wifi_credentials.ssid()
+                 << ", payload_id=" << wifi_credentials.payload_id();
+      container.AddWifiCredentialsAttachment(WifiCredentialsAttachment(
+          wifi_credentials.id(), wifi_credentials.ssid(),
+          wifi_credentials.security_type()));
+      SetAttachmentPayloadId(wifi_credentials.id(),
+                             wifi_credentials.payload_id());
+    }
+  }
+
+  if (!container.HasAttachments()) {
+    NL_LOG(WARNING) << __func__
+                    << ": No attachment is found for this share target. It can "
+                       "be result of unrecognizable attachment type";
+    return TransferMetadata::Status::kUnsupportedAttachmentType;
+  }
+  return std::nullopt;
+}
+
+}  // namespace nearby::sharing