added stream payload type to nearby_connections_api

sharing/linux/BUILD

@@ -71,6 +71,7 @@ cc_library(
     alwayslink = True,
     visibility = ["//visibility:public"],
     deps = [
+        "//internal/platform:base",
         ":linux_sharing_platform",
         "//internal/base:file_path",
         "//sharing/internal/public:nearby_context",
@@ -95,6 +96,7 @@ cc_binary(
         "-Wl,--exclude-libs,ALL",
     ],
     deps = [
+        "//internal/platform:base",
         ":linux_sharing_platform",
         "//internal/base:file_path",
         "//internal/platform/implementation:platform",

sharing/linux/nearby_connections_api.cc

@@ -254,6 +254,10 @@ NearbyConnectionsApi::Payload ToFacadePayload(
       facade_payload.type = NearbyConnectionsApi::PayloadType::kBytes;
       facade_payload.bytes = payload.content.bytes_payload.bytes;
       break;
+    case nearby::sharing::PayloadContent::Type::kStream:
+      facade_payload.type = NearbyConnectionsApi::PayloadType::kStream;
+      facade_payload.stream_bytes = payload.content.stream_payload.bytes;
+      break;
     case nearby::sharing::PayloadContent::Type::kFile:
       facade_payload.type = NearbyConnectionsApi::PayloadType::kFile;
       facade_payload.file_path =
@@ -261,7 +265,6 @@ NearbyConnectionsApi::Payload ToFacadePayload(
       facade_payload.parent_folder = payload.content.file_payload.parent_folder;
       break;
     case nearby::sharing::PayloadContent::Type::kUnknown:
-    case nearby::sharing::PayloadContent::Type::kStream:
       facade_payload.type = NearbyConnectionsApi::PayloadType::kUnknown;
       break;
   }
@@ -277,6 +280,13 @@ std::unique_ptr<nearby::sharing::Payload> ToNativePayload(
     case NearbyConnectionsApi::PayloadType::kFile:
       return std::make_unique<nearby::sharing::Payload>(
           payload.id, FilePath(payload.file_path), payload.parent_folder);
+    case NearbyConnectionsApi::PayloadType::kStream: {
+      nearby::sharing::StreamPayload stream_payload;
+      stream_payload.bytes = std::move(payload.stream_bytes);
+      stream_payload.input_stream = std::move(payload.stream_input);
+      return std::make_unique<nearby::sharing::Payload>(payload.id,
+                                                        std::move(stream_payload));
+    }
     case NearbyConnectionsApi::PayloadType::kUnknown:
       return nullptr;
   }

sharing/linux/nearby_connections_api.h

@@ -13,6 +13,8 @@
 #include <string>
 #include <vector>
 
+#include "internal/platform/input_stream.h"
+
 namespace nearby {
 namespace sharing {
 
@@ -77,6 +79,7 @@ class __attribute__((visibility("default"))) NearbyConnectionsApi {
     kUnknown = 0,
     kBytes = 1,
     kFile = 2,
+    kStream = 3,
   };
 
   enum class PayloadStatus {
@@ -156,6 +159,8 @@ class __attribute__((visibility("default"))) NearbyConnectionsApi {
     int64_t id = 0;
     PayloadType type = PayloadType::kUnknown;
     std::vector<uint8_t> bytes;
+    std::vector<uint8_t> stream_bytes;
+    std::shared_ptr<nearby::InputStream> stream_input;
     std::string file_path;
     std::string parent_folder;
 
@@ -176,6 +181,23 @@ class __attribute__((visibility("default"))) NearbyConnectionsApi {
       payload.parent_folder = std::move(parent_folder);
       return payload;
     }
+
+    static Payload FromStream(int64_t id, std::vector<uint8_t> stream_bytes) {
+      Payload payload;
+      payload.id = id;
+      payload.type = PayloadType::kStream;
+      payload.stream_bytes = std::move(stream_bytes);
+      return payload;
+    }
+
+    static Payload FromInputStream(int64_t id,
+                                   std::shared_ptr<nearby::InputStream> stream_input) {
+      Payload payload;
+      payload.id = id;
+      payload.type = PayloadType::kStream;
+      payload.stream_input = std::move(stream_input);
+      return payload;
+    }
   };
 
   struct Listener {

sharing/linux/nearby_connections_api_test.cc

@@ -1,8 +1,10 @@
 #include "sharing/linux/nearby_connections_api.h"
 
+#include <memory>
 #include <vector>
 
 #include "gtest/gtest.h"
+#include "internal/platform/pipe.h"
 
 namespace nearby::sharing {
 namespace {
@@ -14,6 +16,7 @@ TEST(NearbyConnectionsApiTest, PayloadFromBytesSetsFields) {
   EXPECT_EQ(payload.id, 42);
   EXPECT_EQ(payload.type, NearbyConnectionsApi::PayloadType::kBytes);
   EXPECT_EQ(payload.bytes, (std::vector<uint8_t>{1, 2, 3}));
+  EXPECT_TRUE(payload.stream_bytes.empty());
   EXPECT_TRUE(payload.file_path.empty());
 }
 
@@ -26,6 +29,34 @@ TEST(NearbyConnectionsApiTest, PayloadFromFileSetsFields) {
   EXPECT_EQ(payload.file_path, "/tmp/test.txt");
   EXPECT_EQ(payload.parent_folder, "tmp");
   EXPECT_TRUE(payload.bytes.empty());
+  EXPECT_TRUE(payload.stream_bytes.empty());
+}
+
+TEST(NearbyConnectionsApiTest, PayloadFromStreamSetsFields) {
+  NearbyConnectionsApi::Payload payload =
+      NearbyConnectionsApi::Payload::FromStream(9, {4, 5, 6});
+
+  EXPECT_EQ(payload.id, 9);
+  EXPECT_EQ(payload.type, NearbyConnectionsApi::PayloadType::kStream);
+  EXPECT_EQ(payload.stream_bytes, (std::vector<uint8_t>{4, 5, 6}));
+  EXPECT_TRUE(payload.bytes.empty());
+  EXPECT_TRUE(payload.file_path.empty());
+}
+
+TEST(NearbyConnectionsApiTest, PayloadFromInputStreamSetsFields) {
+  auto [input, output] = CreatePipe();
+  (void)output;
+
+  NearbyConnectionsApi::Payload payload =
+      NearbyConnectionsApi::Payload::FromInputStream(
+          10, std::shared_ptr<nearby::InputStream>(std::move(input)));
+
+  EXPECT_EQ(payload.id, 10);
+  EXPECT_EQ(payload.type, NearbyConnectionsApi::PayloadType::kStream);
+  EXPECT_TRUE(payload.stream_bytes.empty());
+  EXPECT_NE(payload.stream_input, nullptr);
+  EXPECT_TRUE(payload.bytes.empty());
+  EXPECT_TRUE(payload.file_path.empty());
 }
 
 TEST(NearbyConnectionsApiTest, StatusCodeToStringCoversRepresentativeValues) {

sharing/linux/qml_tray_app/file_share_state.cc

@@ -78,7 +78,6 @@ void FileShareState::AddOrUpdateTransfer(
       {QStringLiteral("filePath"), file_path},
   };
 
-  qInfo() << "qDiscovered targets" << discoveredTargets();
   if (transfer_row_by_target_.contains(target_id)) {
     const int row_index = transfer_row_by_target_.value(target_id);
     if (row_index >= 0 && row_index < transfers_.size()) {