added initial nearby sharing app rewrite

sharing/linux/tui/BUILD

@@ -25,7 +25,22 @@ cc_binary(
     "main.cc",
   ],
   deps = [
-    ":app",
+    #":app",
+    "nearby_sharing_dbus_client"
+  ]
+)
+
+cc_library(
+  name ="nearby_sharing_dbus_client",
+  hdrs = [
+    'nearby_sharing_dbus_client.h'
+  ],
+  srcs = [
+    'nearby_sharing_dbus_client.cc'
+  ],
+  deps = [
+   "//sharing/linux/daemon:nearby_sharing_daemon",
+    "@sdbus_cpp",
   ]
 )
 

sharing/linux/tui/app.h

@@ -17,15 +17,11 @@ class TuiApp {
   int Run();
 
  private:
-  bool HandleEvent(Event event);
 
   ScreenInteractive screen_;
   ZenityFilePicker file_picker_;
-  Page current_page_ = Page::FilePicker;
   std::string hostname_;
   std::string selected_file_;
-  std::string incoming_share_device_name_ = "Lasan's A55";
-  ShareTargetType incoming_share_device_type_ = ShareTargetType::kPhone;
 };
 
 }  // namespace nearby::sharing::linux_tui

sharing/linux/tui/main.cc

@@ -1,6 +1,15 @@
-#include "sharing/linux/tui/app.h"
+#include "nearby_sharing_dbus_client.h"
+#include <sdbus-c++/IConnection.h>
 
 int main() {
-  nearby::sharing::linux_tui::TuiApp app;
-  return app.Run();
+  auto sharing =
+      NearbySharingService(sdbus::ServiceName("com.google.nearby.sharing"),
+                           sdbus::ObjectPath("/com/google/nearby/sharing"));
+
+  sharing.StartReceive();
+  sleep(10);
+  sharing.StopReceive();
+  //  nearby::sharing::linux_tui::TuiApp app;
+  // return app.Run();
+  return 0;
 }

sharing/linux/tui/nearby_sharing_dbus_client.cc

@@ -0,0 +1,143 @@
+#include "sharing/linux/tui/nearby_sharing_dbus_client.h"
+
+// Helper to extract a value from the map with a fallback if missing or type
+// mismatches
+template <typename T>
+T get_field(const std::map<std::string, sdbus::Variant>& map,
+            const std::string& key, T default_value = T{}) {
+  auto it = map.find(key);
+  if (it != map.end()) {
+    try {
+      return it->second.get<T>();
+    } catch (const sdbus::Error& e) {
+      // Log type mismatch error if necessary
+    }
+  }
+  return default_value;
+}
+
+// Helper for optional fields
+template <typename T>
+std::optional<T> get_optional_field(
+    const std::map<std::string, sdbus::Variant>& map, const std::string& key) {
+  auto it = map.find(key);
+  if (it != map.end()) {
+    try {
+      return it->second.get<T>();
+    } catch (const sdbus::Error& e) {
+      // Log type mismatch error if necessary
+    }
+  }
+  return std::nullopt;
+}
+
+// Converter: Map -> ShareTarget
+ShareTarget convertToShareTarget(
+    const std::map<std::string, sdbus::Variant>& map) {
+  ShareTarget target;
+  target.id = get_field<int64_t>(map, "id");
+  target.device_name = get_field<std::string>(map, "device_name");
+  target.type = get_field<int32_t>(map, "type");
+  target.is_incoming = get_field<bool>(map, "is_incoming");
+  target.is_known = get_field<bool>(map, "is_known");
+  target.device_id = get_field<std::string>(map, "device_id");
+  target.for_self_share = get_field<bool>(map, "for_self_share");
+  target.vendor_id = get_field<int32_t>(map, "vendor_id");
+  target.receive_disabled = get_field<bool>(map, "receive_disabled");
+  return target;
+}
+
+// Converter: Map -> Transfer
+Transfer convertToTransfer(const std::map<std::string, sdbus::Variant>& map) {
+  Transfer transfer;
+  transfer.status = get_field<std::string>(map, "status");
+  transfer.progress = get_field<int32_t>(map, "progress");
+  transfer.transferred_bytes = get_field<int64_t>(map, "transferred_bytes");
+  transfer.total_bytes = get_field<int64_t>(map, "total_bytes");
+  transfer.transfer_speed = get_field<int64_t>(map, "transfer_speed");
+  transfer.estimated_time_remaining =
+      get_field<int64_t>(map, "estimated_time_remaining");
+  transfer.total_attachments_count =
+      get_field<int32_t>(map, "total_attachments_count");
+  transfer.transferred_attachments_count =
+      get_field<int32_t>(map, "transferred_attachments_count");
+  transfer.is_final_status = get_field<bool>(map, "is_final_status");
+  transfer.is_self_share = get_field<bool>(map, "is_self_share");
+  transfer.binding_id = get_field<std::string>(map, "binding_id");
+
+  // Optional fields
+  transfer.token = get_optional_field<std::string>(map, "token");
+  transfer.in_progress_attachment_id =
+      get_optional_field<int64_t>(map, "in_progress_attachment_id");
+  transfer.in_progress_attachment_transferred_bytes =
+      get_optional_field<int64_t>(map,
+                                  "in_progress_attachment_transferred_bytes");
+  transfer.in_progress_attachment_total_bytes =
+      get_optional_field<int64_t>(map, "in_progress_attachment_total_bytes");
+  return transfer;
+}
+
+// Converter: Map -> Status
+Status convertToStatus(const std::map<std::string, sdbus::Variant>& map) {
+  Status status;
+  status.receive_registered = get_field<bool>(map, "receive_registered");
+  status.discovery_registered = get_field<bool>(map, "discovery_registered");
+  status.is_transferring = get_field<bool>(map, "is_transferring");
+  status.is_scanning = get_field<bool>(map, "is_scanning");
+  status.bluetooth_present = get_field<bool>(map, "bluetooth_present");
+  status.bluetooth_powered = get_field<bool>(map, "bluetooth_powered");
+  status.lan_connected = get_field<bool>(map, "lan_connected");
+
+  // Unpack aa{sv} (vector of maps) into vector of ShareTarget structs
+  auto it = map.find("targets");
+  if (it != map.end()) {
+    try {
+      auto raw_targets =
+          it->second.get<std::vector<std::map<std::string, sdbus::Variant>>>();
+      for (const auto& target_map : raw_targets) {
+        status.targets.push_back(convertToShareTarget(target_map));
+      }
+    } catch (const sdbus::Error& e) {
+      // Handle type mismatch for targets array
+    }
+  }
+  return status;
+}
+
+void NearbySharingService::onTargetDiscovered(
+    const std::map<std::string, sdbus::Variant>& share_target) {
+  auto target = convertToShareTarget(share_target);
+  targets_[target.id] = target;
+};
+
+void NearbySharingService::onTargetUpdated(
+    const std::map<std::string, sdbus::Variant>& share_target) {
+  auto target = convertToShareTarget(share_target);
+  targets_[target.id] = target;
+};
+
+void NearbySharingService::onTargetLost(
+    const std::map<std::string, sdbus::Variant>& share_target) {
+  auto target = convertToShareTarget(share_target);
+  if (targets_.find(target.id) != targets_.end()) {
+    targets_.erase(target.id);
+  }
+};
+
+void NearbySharingService::onIncomingTransfer(
+    const std::string& direction,
+    const std::map<std::string, sdbus::Variant>& share_target,
+    const std::map<std::string, sdbus::Variant>& transfer) {
+  auto target = convertToShareTarget(share_target);
+  auto incoming_transfer = convertToTransfer(transfer);
+
+  incoming_transfer_ = incoming_transfer;
+};
+
+void NearbySharingService::onTransferUpdate(
+    const std::string& direction,
+    const std::map<std::string, sdbus::Variant>& share_target,
+    const std::map<std::string, sdbus::Variant>& transfer) {};
+
+void NearbySharingService::onStatusChanged(
+    const std::map<std::string, sdbus::Variant>& share_target) {};

sharing/linux/tui/nearby_sharing_dbus_client.h

@@ -0,0 +1,78 @@
+#include "sharing/linux/daemon/nearby_sharing_client.h"
+
+struct ShareTarget {
+    int64_t id;
+    std::string device_name;
+    int32_t type;
+    bool is_incoming;
+    bool is_known;
+    std::string device_id;
+    bool for_self_share;
+    int32_t vendor_id;
+    bool receive_disabled;
+};
+
+struct Transfer {
+    std::string status;
+    int32_t progress;
+    int64_t transferred_bytes;
+    int64_t total_bytes;
+    int64_t transfer_speed;
+    int64_t estimated_time_remaining;
+    int32_t total_attachments_count;
+    int32_t transferred_attachments_count;
+    bool is_final_status;
+    bool is_self_share;
+    std::string binding_id;
+    std::optional<std::string> token;
+    std::optional<int64_t> in_progress_attachment_id;
+    std::optional<int64_t> in_progress_attachment_transferred_bytes;
+    std::optional<int64_t> in_progress_attachment_total_bytes;
+};
+
+struct Status {
+    bool receive_registered;
+    bool discovery_registered;
+    bool is_transferring;
+    bool is_scanning;
+    bool bluetooth_present;
+    bool bluetooth_powered;
+    bool lan_connected;
+    
+    // aa{sv} maps to a vector of ShareTarget structs
+    std::vector<ShareTarget> targets;
+};
+
+
+class NearbySharingService
+    : public sdbus::ProxyInterfaces<com::google::nearby::sharing_proxy> {
+ public:
+  NearbySharingService(sdbus::ServiceName dest, sdbus::ObjectPath objectPath)
+      : ProxyInterfaces(std::move(dest), std::move(objectPath)) {
+    registerProxy();
+  }
+  ~NearbySharingService() { unregisterProxy(); }
+
+  void onTargetDiscovered(
+      const std::map<std::string, sdbus::Variant>& share_target) override;
+  void onTargetUpdated(
+      const std::map<std::string, sdbus::Variant>& share_target) override;
+  void onTargetLost(
+      const std::map<std::string, sdbus::Variant>& share_target) override;
+  void onIncomingTransfer(
+      const std::string& direction,
+      const std::map<std::string, sdbus::Variant>& share_target,
+      const std::map<std::string, sdbus::Variant>& transfer) override;
+  void onTransferUpdate(
+      const std::string& direction,
+      const std::map<std::string, sdbus::Variant>& share_target,
+      const std::map<std::string, sdbus::Variant>& transfer) override;
+  void onStatusChanged(
+      const std::map<std::string, sdbus::Variant>& status) override;
+
+ private:
+  Status status_;
+  std::map<int, ShareTarget> targets_;
+  Transfer outgoing_transfer_;
+  Transfer incoming_transfer_;
+};