// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/dbus/gesture_properties_service_provider.h"
#include <memory>
#include <utility>
#include "base/functional/bind.h"
#include "base/logging.h"
#include "dbus/message.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
#include "ui/ozone/public/input_controller.h"
#include "ui/ozone/public/ozone_platform.h"
namespace ash {
GesturePropertiesServiceProvider::GesturePropertiesServiceProvider()
: weak_ptr_factory_(this) {}
GesturePropertiesServiceProvider::~GesturePropertiesServiceProvider() = default;
void GesturePropertiesServiceProvider::Start(
scoped_refptr<dbus::ExportedObject> exported_object) {
auto on_exported =
base::BindRepeating(&GesturePropertiesServiceProvider::OnExported,
weak_ptr_factory_.GetWeakPtr());
exported_object->ExportMethod(
chromeos::kGesturePropertiesServiceInterface,
chromeos::kGesturePropertiesServiceListDevicesMethod,
base::BindRepeating(&GesturePropertiesServiceProvider::ListDevices,
weak_ptr_factory_.GetWeakPtr()),
on_exported);
exported_object->ExportMethod(
chromeos::kGesturePropertiesServiceInterface,
chromeos::kGesturePropertiesServiceListPropertiesMethod,
base::BindRepeating(&GesturePropertiesServiceProvider::ListProperties,
weak_ptr_factory_.GetWeakPtr()),
on_exported);
exported_object->ExportMethod(
chromeos::kGesturePropertiesServiceInterface,
chromeos::kGesturePropertiesServiceGetPropertyMethod,
base::BindRepeating(&GesturePropertiesServiceProvider::GetProperty,
weak_ptr_factory_.GetWeakPtr()),
on_exported);
exported_object->ExportMethod(
chromeos::kGesturePropertiesServiceInterface,
chromeos::kGesturePropertiesServiceSetPropertyMethod,
base::BindRepeating(&GesturePropertiesServiceProvider::SetProperty,
weak_ptr_factory_.GetWeakPtr()),
on_exported);
}
void GesturePropertiesServiceProvider::OnExported(
const std::string& interface_name,
const std::string& method_name,
bool success) {
if (!success)
LOG(ERROR) << "Failed to export " << interface_name << "." << method_name;
}
namespace {
void GetPropertyCallback(dbus::MethodCall* method_call,
std::unique_ptr<dbus::Response> response,
dbus::ExportedObject::ResponseSender response_sender,
bool is_read_only,
ui::ozone::mojom::GesturePropValuePtr values) {
if (values.is_null()) {
std::move(response_sender)
.Run(dbus::ErrorResponse::FromMethodCall(
method_call, DBUS_ERROR_INVALID_ARGS,
"The device ID or property name specified was not found."));
return;
}
dbus::MessageWriter writer(response.get());
dbus::MessageWriter variant_writer(nullptr);
dbus::MessageWriter array_writer(nullptr);
writer.AppendBool(is_read_only);
switch (values->which()) {
case ui::ozone::mojom::GesturePropValue::Tag::kInts: {
writer.AppendUint32(values->get_ints().size());
writer.OpenVariant("ai", &variant_writer);
variant_writer.AppendArrayOfInt32s(values->get_ints());
writer.CloseContainer(&variant_writer);
break;
}
case ui::ozone::mojom::GesturePropValue::Tag::kShorts: {
writer.AppendUint32(values->get_shorts().size());
writer.OpenVariant("an", &variant_writer);
variant_writer.OpenArray("n", &array_writer);
for (int16_t value : values->get_shorts()) {
array_writer.AppendInt16(value);
}
variant_writer.CloseContainer(&array_writer);
writer.CloseContainer(&variant_writer);
break;
}
case ui::ozone::mojom::GesturePropValue::Tag::kBools: {
writer.AppendUint32(values->get_bools().size());
writer.OpenVariant("ab", &variant_writer);
variant_writer.OpenArray("b", &array_writer);
for (bool value : values->get_bools()) {
array_writer.AppendBool(value);
}
variant_writer.CloseContainer(&array_writer);
writer.CloseContainer(&variant_writer);
break;
}
case ui::ozone::mojom::GesturePropValue::Tag::kStr: {
writer.AppendUint32(1);
writer.AppendVariantOfString(values->get_str());
break;
}
case ui::ozone::mojom::GesturePropValue::Tag::kReals: {
writer.AppendUint32(values->get_reals().size());
writer.OpenVariant("ad", &variant_writer);
variant_writer.AppendArrayOfDoubles(values->get_reals());
writer.CloseContainer(&variant_writer);
break;
}
default: {
// This should never happen.
LOG(WARNING) << "No value set on GesturePropValue union; not returning "
"values to GetProperty call.";
writer.AppendUint32(0);
break;
}
}
std::move(response_sender).Run(std::move(response));
}
void SetPropertyCallback(dbus::MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender,
ui::ozone::mojom::SetGesturePropErrorCode error) {
std::string error_message;
switch (error) {
case ui::ozone::mojom::SetGesturePropErrorCode::SUCCESS:
std::move(response_sender)
.Run(dbus::Response::FromMethodCall(method_call));
return;
case ui::ozone::mojom::SetGesturePropErrorCode::NOT_FOUND:
error_message = "The device ID or property name specified was not found.";
break;
case ui::ozone::mojom::SetGesturePropErrorCode::READ_ONLY:
error_message = "That property is read-only.";
break;
case ui::ozone::mojom::SetGesturePropErrorCode::TYPE_MISMATCH:
error_message =
"The property is of a different type than the value(s) "
"provided.";
break;
case ui::ozone::mojom::SetGesturePropErrorCode::SIZE_MISMATCH:
error_message =
"The property has a different number of values to that "
"provided.";
break;
case ui::ozone::mojom::SetGesturePropErrorCode::UNKNOWN_ERROR:
default:
error_message = "An unknown error occurred.";
break;
}
LOG(ERROR) << "SetProperty error: " << error_message;
std::move(response_sender)
.Run(dbus::ErrorResponse::FromMethodCall(
method_call, DBUS_ERROR_INVALID_ARGS, error_message));
}
void ListDevicesCallback(std::unique_ptr<dbus::Response> response,
dbus::ExportedObject::ResponseSender response_sender,
const base::flat_map<int, std::string>& result) {
dbus::MessageWriter writer(response.get());
writer.AppendUint32(result.size());
dbus::MessageWriter dict_writer(nullptr);
writer.OpenArray("{is}", &dict_writer);
for (const auto& pair : result) {
dbus::MessageWriter dict_entry_writer(nullptr);
dict_writer.OpenDictEntry(&dict_entry_writer);
dict_entry_writer.AppendInt32(pair.first);
dict_entry_writer.AppendString(pair.second);
dict_writer.CloseContainer(&dict_entry_writer);
}
writer.CloseContainer(&dict_writer);
std::move(response_sender).Run(std::move(response));
}
void ListPropertiesCallback(
std::unique_ptr<dbus::Response> response,
dbus::ExportedObject::ResponseSender response_sender,
const std::vector<std::string>& result) {
dbus::MessageWriter writer(response.get());
writer.AppendUint32(result.size());
writer.AppendArrayOfStrings(result);
std::move(response_sender).Run(std::move(response));
}
} // namespace
void GesturePropertiesServiceProvider::ListDevices(
dbus::MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender) {
std::unique_ptr<dbus::Response> response =
dbus::Response::FromMethodCall(method_call);
GetService()->ListDevices(base::BindOnce(
&ListDevicesCallback, std::move(response), std::move(response_sender)));
}
void GesturePropertiesServiceProvider::ListProperties(
dbus::MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender) {
dbus::MessageReader reader(method_call);
int32_t device_id;
if (!reader.PopInt32(&device_id)) {
std::move(response_sender)
.Run(dbus::ErrorResponse::FromMethodCall(
method_call, DBUS_ERROR_INVALID_ARGS,
"The device ID (int32) is missing."));
return;
}
std::unique_ptr<dbus::Response> response =
dbus::Response::FromMethodCall(method_call);
GetService()->ListProperties(
device_id, base::BindOnce(&ListPropertiesCallback, std::move(response),
std::move(response_sender)));
}
void GesturePropertiesServiceProvider::GetProperty(
dbus::MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender) {
dbus::MessageReader reader(method_call);
int32_t device_id;
std::string property_name;
if (!reader.PopInt32(&device_id) || !reader.PopString(&property_name)) {
std::move(response_sender)
.Run(dbus::ErrorResponse::FromMethodCall(
method_call, DBUS_ERROR_INVALID_ARGS,
"The device ID (int32) and/or property name (string) is missing."));
return;
}
std::unique_ptr<dbus::Response> response =
dbus::Response::FromMethodCall(method_call);
GetService()->GetProperty(
device_id, property_name,
base::BindOnce(&GetPropertyCallback, method_call, std::move(response),
std::move(response_sender)));
}
static ui::ozone::mojom::GesturePropValuePtr GesturePropValueFromVariant(
dbus::MessageReader* variant_reader,
std::string* error_message) {
std::string string_value;
if (variant_reader->PopString(&string_value)) {
return ui::ozone::mojom::GesturePropValue::NewStr(string_value);
}
dbus::MessageReader array_reader(nullptr);
if (!variant_reader->PopArray(&array_reader)) {
*error_message =
"Value(s) should be specified either as a string or an "
"array of the appropriate type.";
return nullptr;
}
switch (array_reader.GetDataType()) {
case dbus::Message::DataType::INT32: {
std::vector<int32_t> values = {};
int32_t value;
while (array_reader.PopInt32(&value)) {
values.push_back(value);
}
return ui::ozone::mojom::GesturePropValue::NewInts(values);
}
case dbus::Message::DataType::INT16: {
std::vector<int16_t> values = {};
int16_t value;
while (array_reader.PopInt16(&value)) {
values.push_back(value);
}
return ui::ozone::mojom::GesturePropValue::NewShorts(values);
}
case dbus::Message::DataType::BOOL: {
std::vector<bool> values = {};
bool value;
while (array_reader.PopBool(&value)) {
values.push_back(value);
}
return ui::ozone::mojom::GesturePropValue::NewBools(values);
}
case dbus::Message::DataType::DOUBLE: {
std::vector<double> values = {};
double value;
while (array_reader.PopDouble(&value)) {
values.push_back(value);
}
return ui::ozone::mojom::GesturePropValue::NewReals(values);
}
case dbus::Message::DataType::STRING: {
*error_message =
"String properties can only have one value, and so "
"should not be specified as arrays.";
return nullptr;
}
default: {
*error_message =
"Unsupported D-Bus value type; supported types are "
"int32, int16, bool, double, and string.";
return nullptr;
}
}
}
void GesturePropertiesServiceProvider::SetProperty(
dbus::MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender) {
dbus::MessageReader reader(method_call);
int32_t device_id;
std::string property_name;
if (!reader.PopInt32(&device_id) || !reader.PopString(&property_name)) {
std::move(response_sender)
.Run(dbus::ErrorResponse::FromMethodCall(
method_call, DBUS_ERROR_INVALID_ARGS,
"The device ID (int32) and/or property name (string) is missing."));
return;
}
if (!reader.HasMoreData()) {
std::move(response_sender)
.Run(dbus::ErrorResponse::FromMethodCall(
method_call, DBUS_ERROR_INVALID_ARGS, "No value(s) specified."));
return;
}
std::string error_message;
ui::ozone::mojom::GesturePropValuePtr values =
GesturePropValueFromVariant(&reader, &error_message);
if (values.is_null()) {
std::move(response_sender)
.Run(dbus::ErrorResponse::FromMethodCall(
method_call, DBUS_ERROR_INVALID_ARGS, error_message));
return;
}
GetService()->SetProperty(device_id, property_name, std::move(values),
base::BindOnce(&SetPropertyCallback, method_call,
std::move(response_sender)));
}
ui::ozone::mojom::GesturePropertiesService*
GesturePropertiesServiceProvider::GetService() {
if (service_for_test_ != nullptr)
return service_for_test_;
if (!service_.is_bound()) {
ui::OzonePlatform::GetInstance()
->GetInputController()
->GetGesturePropertiesService(service_.BindNewPipeAndPassReceiver());
}
return service_.get();
}
} // namespace ash
Codebase Browser
chromium