mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-15 07:06:11 -04:00
385 lines
14 KiB
C++
385 lines
14 KiB
C++
// Copyright 2023 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 <filesystem>
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include <curl/curl.h>
|
|
#include <sdbus-c++/Error.h>
|
|
#include <sdbus-c++/Types.h>
|
|
|
|
#include "device_info.h"
|
|
#include "internal/platform/implementation/atomic_boolean.h"
|
|
#include "internal/platform/implementation/atomic_reference.h"
|
|
// #include "internal/platform/implementation/bluetooth_adapter.h"
|
|
#include "internal/platform/implementation/count_down_latch.h"
|
|
#include "internal/platform/implementation/http_loader.h"
|
|
#include "internal/platform/implementation/input_file.h"
|
|
#include "internal/platform/implementation/linux/atomic_boolean.h"
|
|
#include "internal/platform/implementation/linux/atomic_uint32.h"
|
|
// #include "internal/platform/implementation/linux/ble_medium.h"
|
|
// #include "internal/platform/implementation/linux/ble_v2_medium.h"
|
|
// #include "internal/platform/implementation/linux/bluetooth_adapter.h"
|
|
// #include "internal/platform/implementation/linux/bluetooth_classic_medium.h"
|
|
// #include "internal/platform/implementation/linux/bluez.h"
|
|
#include "internal/platform/implementation/linux/condition_variable.h"
|
|
#include "internal/platform/implementation/linux/dbus.h"
|
|
// #include "internal/platform/implementation/linux/generated/dbus/bluez/adapter_client.h"
|
|
#include "internal/platform/implementation/linux/mutex.h"
|
|
#include "internal/platform/implementation/linux/preferences_manager.h"
|
|
#include "internal/platform/implementation/linux/submittable_executor.h"
|
|
#include "internal/platform/implementation/linux/timer.h"
|
|
// #include "internal/platform/implementation/linux/wifi_direct.h"
|
|
// #include "internal/platform/implementation/linux/wifi_hotspot.h"
|
|
#include "internal/platform/implementation/linux/wifi_lan.h"
|
|
#include "internal/platform/implementation/linux/wifi_medium.h"
|
|
#include "internal/platform/implementation/platform.h"
|
|
#include "internal/platform/implementation/shared/count_down_latch.h"
|
|
#include "internal/platform/implementation/shared/file.h"
|
|
#include "internal/platform/implementation/submittable_executor.h"
|
|
// #include "internal/platform/implementation/wifi_hotspot.h"
|
|
#include "internal/platform/implementation/wifi_lan.h"
|
|
#include "internal/platform/payload_id.h"
|
|
#include "log_message.h"
|
|
#include "scheduled_executor.h"
|
|
|
|
namespace nearby {
|
|
namespace api {
|
|
std::string ImplementationPlatform::GetCustomSavePath(
|
|
const std::string &parent_folder, const std::string &file_name) {
|
|
auto fs = std::filesystem::path(parent_folder);
|
|
return fs / file_name;
|
|
}
|
|
|
|
std::string ImplementationPlatform::GetDownloadPath(
|
|
const std::string &parent_folder, const std::string &file_name) {
|
|
auto downloads = std::filesystem::path(getenv("XDG_DOWNLOAD_DIR"));
|
|
|
|
return downloads / std::filesystem::path(parent_folder).filename() /
|
|
std::filesystem::path(file_name).filename();
|
|
}
|
|
|
|
std::string ImplementationPlatform::GetDownloadPath(
|
|
const std::string &file_name) {
|
|
auto downloads = std::filesystem::path(getenv("XDG_DOWNLOAD_DIR"));
|
|
return downloads / std::filesystem::path(file_name).filename();
|
|
}
|
|
|
|
std::string ImplementationPlatform::GetAppDataPath(
|
|
const std::string &file_name) {
|
|
auto state = std::filesystem::path(getenv("XDG_STATE_HOME"));
|
|
return state / std::filesystem::path(file_name).filename();
|
|
}
|
|
|
|
OSName ImplementationPlatform::GetCurrentOS() { return OSName::kWindows; }
|
|
|
|
std::unique_ptr<api::AtomicBoolean> ImplementationPlatform::CreateAtomicBoolean(
|
|
bool initial_value) {
|
|
return std::make_unique<linux::AtomicBoolean>(initial_value);
|
|
}
|
|
|
|
std::unique_ptr<api::AtomicUint32> ImplementationPlatform::CreateAtomicUint32(
|
|
std::uint32_t value) {
|
|
return std::make_unique<linux::AtomicUint32>(value);
|
|
}
|
|
|
|
std::unique_ptr<api::CountDownLatch>
|
|
ImplementationPlatform::CreateCountDownLatch(std::int32_t count) {
|
|
return std::make_unique<shared::CountDownLatch>(count);
|
|
}
|
|
|
|
#pragma push_macro("CreateMutex")
|
|
#undef CreateMutex
|
|
std::unique_ptr<api::Mutex> ImplementationPlatform::CreateMutex(
|
|
Mutex::Mode mode) {
|
|
return std::make_unique<linux::Mutex>(mode);
|
|
}
|
|
#pragma pop_macro("CreateMutex")
|
|
|
|
std::unique_ptr<api::ConditionVariable>
|
|
ImplementationPlatform::CreateConditionVariable(api::Mutex *mutex) {
|
|
return std::make_unique<linux::ConditionVariable>(mutex);
|
|
}
|
|
|
|
std::unique_ptr<api::InputFile> ImplementationPlatform::CreateInputFile(
|
|
PayloadId id, std::int64_t total_size) {
|
|
auto path = GetDownloadPath(std::to_string(id));
|
|
return nearby::shared::IOFile::CreateInputFile(path, total_size);
|
|
}
|
|
|
|
std::unique_ptr<InputFile> ImplementationPlatform::CreateInputFile(
|
|
const std::string &file_path, size_t size) {
|
|
return nearby::shared::IOFile::CreateInputFile(file_path, size);
|
|
}
|
|
|
|
std::unique_ptr<OutputFile> ImplementationPlatform::CreateOutputFile(
|
|
PayloadId payload_id) {
|
|
return nearby::shared::IOFile::CreateOutputFile(
|
|
GetDownloadPath("", std::to_string(payload_id)));
|
|
}
|
|
|
|
std::unique_ptr<OutputFile> ImplementationPlatform::CreateOutputFile(
|
|
const std::string &file_path) {
|
|
std::filesystem::path path(file_path);
|
|
try {
|
|
std::filesystem::create_directories(path.parent_path());
|
|
} catch (std::filesystem::filesystem_error const &err) {
|
|
NEARBY_LOGS(ERROR) << __func__ << ": error creating directory tree "
|
|
<< path.parent_path() << ": " << err.what();
|
|
}
|
|
|
|
return nearby::shared::IOFile::CreateOutputFile(path.string());
|
|
}
|
|
|
|
std::unique_ptr<api::LogMessage> ImplementationPlatform::CreateLogMessage(
|
|
const char *file, int line, LogMessage::Severity severity) {
|
|
return std::make_unique<linux::LogMessage>(file, line, severity);
|
|
}
|
|
|
|
std::unique_ptr<api::SubmittableExecutor>
|
|
ImplementationPlatform::CreateSingleThreadExecutor() {
|
|
return std::make_unique<linux::SubmittableExecutor>();
|
|
}
|
|
|
|
std::unique_ptr<api::SubmittableExecutor>
|
|
ImplementationPlatform::CreateMultiThreadExecutor(
|
|
std::int32_t max_concurrency) {
|
|
return std::make_unique<linux::SubmittableExecutor>(max_concurrency);
|
|
}
|
|
|
|
std::unique_ptr<ScheduledExecutor>
|
|
ImplementationPlatform::CreateScheduledExecutor() {
|
|
return std::make_unique<linux::ScheduledExecutor>();
|
|
}
|
|
|
|
std::unique_ptr<api::BluetoothAdapter>
|
|
ImplementationPlatform::CreateBluetoothAdapter() {
|
|
// auto manager =
|
|
// linux::bluez::BluezObjectManager(linux::getSystemBusConnection());
|
|
// try {
|
|
// auto interfaces = manager.GetManagedObjects();
|
|
// for (auto &[object, properties] : interfaces) {
|
|
// if (properties.count(org::bluez::Adapter1_proxy::INTERFACE_NAME) == 1) {
|
|
// NEARBY_LOGS(INFO) << __func__ << ": found bluetooth adapter " << object;
|
|
// return std::make_unique<linux::BluetoothAdapter>(
|
|
// linux::getSystemBusConnection(), object);
|
|
// }
|
|
// }
|
|
// } catch (const sdbus::Error &e) {
|
|
// DBUS_LOG_METHOD_CALL_ERROR(&manager, "GetManagedObjects", e);
|
|
// return nullptr;
|
|
// }
|
|
|
|
// NEARBY_LOGS(ERROR) << __func__
|
|
// << ": couldn't find a bluetooth adapter on this system";
|
|
return nullptr; //TODO: implement bluetooth adapter
|
|
}
|
|
|
|
std::unique_ptr<api::BluetoothClassicMedium>
|
|
ImplementationPlatform::CreateBluetoothClassicMedium(
|
|
BluetoothAdapter &adapter) {
|
|
// return std::make_unique<linux::BluetoothClassicMedium>(
|
|
// linux::getSystemBusConnection(),
|
|
// dynamic_cast<linux::BluetoothAdapter &>(adapter));
|
|
return nullptr; //TODO: implement bluetooth classic medium
|
|
}
|
|
//
|
|
std::unique_ptr<BleMedium> ImplementationPlatform::CreateBleMedium(
|
|
BluetoothAdapter &) {
|
|
return nullptr; //TODO: implement ble medium
|
|
// return std::make_unique<linux::BleMedium>();
|
|
}
|
|
//
|
|
std::unique_ptr<api::ble_v2::BleMedium>
|
|
ImplementationPlatform::CreateBleV2Medium(api::BluetoothAdapter &adapter) {
|
|
// return std::make_unique<linux::BleV2Medium>();
|
|
return nullptr; //TODO: implement ble_v2 medium
|
|
}
|
|
|
|
namespace {
|
|
static std::unique_ptr<linux::NetworkManagerWifiMedium> createWifiMedium(
|
|
std::shared_ptr<linux::NetworkManager> nm) {
|
|
std::vector<sdbus::ObjectPath> device_paths;
|
|
|
|
try {
|
|
device_paths = nm->GetAllDevices();
|
|
} catch (const sdbus::Error &e) {
|
|
DBUS_LOG_METHOD_CALL_ERROR(nm, "GetAllDevices", e);
|
|
return nullptr;
|
|
}
|
|
|
|
auto manager =
|
|
linux::NetworkManagerObjectManager(linux::getSystemBusConnection());
|
|
|
|
std::map<sdbus::ObjectPath,
|
|
std::map<std::string, std::map<std::string, sdbus::Variant>>>
|
|
objects;
|
|
try {
|
|
objects = manager.GetManagedObjects();
|
|
} catch (const sdbus::Error &e) {
|
|
DBUS_LOG_METHOD_CALL_ERROR(nm, "GetManagedObjects", e);
|
|
return nullptr;
|
|
}
|
|
|
|
for (auto &device_path : device_paths) {
|
|
if (objects.count(device_path) == 1) {
|
|
auto device = objects[device_path];
|
|
if (device.count(org::freedesktop::NetworkManager::Device::
|
|
Wireless_proxy::INTERFACE_NAME) == 1) {
|
|
NEARBY_LOGS(INFO) << __func__
|
|
<< ": Found a wireless device at :" << device_path;
|
|
return std::make_unique<linux::NetworkManagerWifiMedium>(
|
|
nm, linux::getSystemBusConnection(), device_path);
|
|
}
|
|
}
|
|
}
|
|
|
|
NEARBY_LOGS(ERROR) << __func__
|
|
<< ": couldn't find a wireless device on this system";
|
|
return nullptr;
|
|
}
|
|
} // namespace
|
|
|
|
std::unique_ptr<api::WifiMedium> ImplementationPlatform::CreateWifiMedium() {
|
|
auto nm =
|
|
std::make_shared<linux::NetworkManager>(linux::getSystemBusConnection());
|
|
return createWifiMedium(nm);
|
|
}
|
|
|
|
std::unique_ptr<api::WifiLanMedium>
|
|
ImplementationPlatform::CreateWifiLanMedium() {
|
|
return std::make_unique<linux::WifiLanMedium>(
|
|
linux::getSystemBusConnection());
|
|
}
|
|
|
|
std::unique_ptr<api::WifiHotspotMedium>
|
|
ImplementationPlatform::CreateWifiHotspotMedium() {
|
|
return nullptr; //TODO: implement wifi hotspot medium
|
|
// auto nm =
|
|
// std::make_shared<linux::NetworkManager>(linux::getSystemBusConnection());
|
|
// auto wifiMedium = createWifiMedium(nm);
|
|
//
|
|
// if (wifiMedium == nullptr) {
|
|
// NEARBY_LOGS(ERROR) << __func__ << ": Could not create a WiFi medium";
|
|
// return nullptr;
|
|
// }
|
|
//
|
|
// return std::make_unique<linux::NetworkManagerWifiHotspotMedium>(
|
|
// linux::getSystemBusConnection(), nm, std::move(wifiMedium));
|
|
}
|
|
|
|
std::unique_ptr<api::WifiDirectMedium>
|
|
ImplementationPlatform::CreateWifiDirectMedium() {
|
|
return nullptr; //TODO: implement wifidirect medium
|
|
// auto nm =
|
|
// std::make_shared<linux::NetworkManager>(linux::getSystemBusConnection());
|
|
// auto wifiMedium = createWifiMedium(nm);
|
|
//
|
|
// if (wifiMedium == nullptr) {
|
|
// NEARBY_LOGS(ERROR) << __func__ << ": Could not create a WiFi medium";
|
|
// return nullptr;
|
|
// }
|
|
//
|
|
// return std::make_unique<linux::NetworkManagerWifiDirectMedium>(
|
|
// linux::getSystemBusConnection(), nm, std::move(wifiMedium));
|
|
}
|
|
|
|
std::unique_ptr<api::Timer> ImplementationPlatform::CreateTimer() {
|
|
return std::make_unique<linux::Timer>();
|
|
}
|
|
|
|
std::unique_ptr<api::DeviceInfo> ImplementationPlatform::CreateDeviceInfo() {
|
|
return std::make_unique<linux::DeviceInfo>(linux::getSystemBusConnection());
|
|
}
|
|
|
|
absl::StatusOr<api::WebResponse> ImplementationPlatform::SendRequest(
|
|
const WebRequest &request) {
|
|
if (request.body.size() >= (8 * 1024 * 1024)) {
|
|
return absl::Status(absl::StatusCode::kResourceExhausted,
|
|
"request body too large");
|
|
}
|
|
|
|
CURL *handle = curl_easy_init();
|
|
char errbuf[CURL_ERROR_SIZE];
|
|
errbuf[0] = '\0';
|
|
|
|
curl_easy_setopt(handle, CURLOPT_URL, request.url.c_str());
|
|
curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, errbuf);
|
|
|
|
if (request.method == "GET")
|
|
curl_easy_setopt(handle, CURLOPT_HTTPGET, 1L);
|
|
else if (request.method == "POST")
|
|
curl_easy_setopt(handle, CURLOPT_POST, 1L);
|
|
else
|
|
curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, request.method.c_str());
|
|
|
|
curl_easy_setopt(handle, CURLOPT_UPLOAD, request.body.c_str());
|
|
|
|
struct curl_slist *headers_slist = nullptr;
|
|
|
|
for (auto &[key, value] : request.headers) {
|
|
auto hdr = absl::StrCat(key, ": ", value);
|
|
auto temp = curl_slist_append(headers_slist, hdr.c_str());
|
|
if (temp == nullptr) {
|
|
if (headers_slist != nullptr) {
|
|
curl_slist_free_all(headers_slist);
|
|
}
|
|
return absl::Status(absl::StatusCode::kResourceExhausted,
|
|
"failed to append header to slist");
|
|
}
|
|
}
|
|
|
|
curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers_slist);
|
|
|
|
api::WebResponse response;
|
|
|
|
if (curl_easy_perform(handle) != CURLE_OK) {
|
|
NEARBY_LOGS(ERROR) << __func__
|
|
<< ": Error performing HTTP request: " << errbuf;
|
|
return absl::Status(absl::StatusCode::kUnknown, errbuf);
|
|
}
|
|
|
|
struct curl_header *prev = nullptr;
|
|
struct curl_header *h;
|
|
|
|
h = curl_easy_nextheader(handle, CURLH_HEADER, 0, prev);
|
|
while (h != nullptr) {
|
|
response.headers.emplace(h->name, h->value);
|
|
}
|
|
|
|
auto writefn = [](char *ptr, size_t size, size_t nmemb, void *userdata) {
|
|
std::string *body = static_cast<std::string *>(userdata);
|
|
body->append(ptr, size * nmemb);
|
|
};
|
|
|
|
curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, writefn);
|
|
curl_easy_setopt(handle, CURLOPT_WRITEDATA,
|
|
static_cast<void *>(&response.body));
|
|
long status;
|
|
curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &status);
|
|
response.status_code = status;
|
|
return response;
|
|
}
|
|
|
|
#ifndef NEARBY_CHROMIUM
|
|
std::unique_ptr<nearby::api::PreferencesManager>
|
|
ImplementationPlatform::CreatePreferencesManager(absl::string_view path) {
|
|
return std::make_unique<linux::PreferencesManager>(path);
|
|
}
|
|
#endif
|
|
|
|
} // namespace api
|
|
} // namespace nearby
|