blob: 442c82d17f5ea3346f842a69b9bbcebb648fba27 [file] [log] [blame]
#include "include/private/dvr/display_client.h"
#include <cutils/native_handle.h>
#include <log/log.h>
#include <pdx/default_transport/client_channel.h>
#include <pdx/default_transport/client_channel_factory.h>
#include <pdx/status.h>
#include <mutex>
#include <private/dvr/display_protocol.h>
#include <private/dvr/native_buffer.h>
using android::pdx::ErrorStatus;
using android::pdx::LocalHandle;
using android::pdx::LocalChannelHandle;
using android::pdx::Status;
using android::pdx::Transaction;
using android::pdx::rpc::IfAnyOf;
namespace android {
namespace dvr {
namespace display {
Surface::Surface(LocalChannelHandle channel_handle, int* error)
: BASE{pdx::default_transport::ClientChannel::Create(
std::move(channel_handle))} {
auto status = InvokeRemoteMethod<DisplayProtocol::GetSurfaceInfo>();
if (!status) {
ALOGE("Surface::Surface: Failed to get surface info: %s",
status.GetErrorMessage().c_str());
Close(status.error());
if (error)
*error = status.error();
}
surface_id_ = status.get().surface_id;
z_order_ = status.get().z_order;
visible_ = status.get().visible;
}
Surface::Surface(const SurfaceAttributes& attributes, int* error)
: BASE{pdx::default_transport::ClientChannelFactory::Create(
DisplayProtocol::kClientPath),
kInfiniteTimeout} {
auto status = InvokeRemoteMethod<DisplayProtocol::CreateSurface>(attributes);
if (!status) {
ALOGE("Surface::Surface: Failed to create display surface: %s",
status.GetErrorMessage().c_str());
Close(status.error());
if (error)
*error = status.error();
}
surface_id_ = status.get().surface_id;
z_order_ = status.get().z_order;
visible_ = status.get().visible;
}
Status<void> Surface::SetVisible(bool visible) {
return SetAttributes(
{{SurfaceAttribute::Visible, SurfaceAttributeValue{visible}}});
}
Status<void> Surface::SetZOrder(int z_order) {
return SetAttributes(
{{SurfaceAttribute::ZOrder, SurfaceAttributeValue{z_order}}});
}
Status<void> Surface::SetAttributes(const SurfaceAttributes& attributes) {
auto status = InvokeRemoteMethod<DisplayProtocol::SetAttributes>(attributes);
if (!status) {
ALOGE(
"Surface::SetAttributes: Failed to set display surface "
"attributes: %s",
status.GetErrorMessage().c_str());
return status.error_status();
}
// Set the local cached copies of the attributes we care about from the full
// set of attributes sent to the display service.
for (const auto& attribute : attributes) {
const auto& key = attribute.first;
const auto* variant = &attribute.second;
bool invalid_value = false;
switch (key) {
case SurfaceAttribute::Visible:
invalid_value =
!IfAnyOf<int32_t, int64_t, bool>::Get(variant, &visible_);
break;
case SurfaceAttribute::ZOrder:
invalid_value = !IfAnyOf<int32_t>::Get(variant, &z_order_);
break;
}
if (invalid_value) {
ALOGW(
"Surface::SetAttributes: Failed to set display surface "
"attribute %d because of incompatible type: %d",
key, variant->index());
}
}
return {};
}
Status<std::unique_ptr<ProducerQueue>> Surface::CreateQueue(
uint32_t width, uint32_t height, uint32_t format, size_t metadata_size) {
ALOGD_IF(TRACE, "Surface::CreateQueue: Creating empty queue.");
auto status = InvokeRemoteMethod<DisplayProtocol::CreateQueue>(
ProducerQueueConfigBuilder()
.SetDefaultWidth(width)
.SetDefaultHeight(height)
.SetDefaultFormat(format)
.SetMetadataSize(metadata_size)
.Build());
if (!status) {
ALOGE("Surface::CreateQueue: Failed to create queue: %s",
status.GetErrorMessage().c_str());
return status.error_status();
}
auto producer_queue = ProducerQueue::Import(status.take());
if (!producer_queue) {
ALOGE("Surface::CreateQueue: Failed to import producer queue!");
return ErrorStatus(ENOMEM);
}
return {std::move(producer_queue)};
}
Status<std::unique_ptr<ProducerQueue>> Surface::CreateQueue(
uint32_t width, uint32_t height, uint32_t layer_count, uint32_t format,
uint64_t usage, size_t capacity, size_t metadata_size) {
ALOGD_IF(TRACE,
"Surface::CreateQueue: width=%u height=%u layer_count=%u format=%u "
"usage=%" PRIx64 " capacity=%zu",
width, height, layer_count, format, usage, capacity);
auto status = CreateQueue(width, height, format, metadata_size);
if (!status)
return status.error_status();
auto producer_queue = status.take();
ALOGD_IF(TRACE, "Surface::CreateQueue: Allocating %zu buffers...", capacity);
auto allocate_status = producer_queue->AllocateBuffers(
width, height, layer_count, format, usage, capacity);
if (!allocate_status) {
ALOGE("Surface::CreateQueue: Failed to allocate buffer on queue_id=%d: %s",
producer_queue->id(), allocate_status.GetErrorMessage().c_str());
return allocate_status.error_status();
}
return {std::move(producer_queue)};
}
DisplayClient::DisplayClient(int* error)
: BASE(pdx::default_transport::ClientChannelFactory::Create(
DisplayProtocol::kClientPath),
kInfiniteTimeout) {
if (error)
*error = Client::error();
}
Status<Metrics> DisplayClient::GetDisplayMetrics() {
return InvokeRemoteMethod<DisplayProtocol::GetMetrics>();
}
Status<std::string> DisplayClient::GetConfigurationData(
ConfigFileType config_type) {
auto status =
InvokeRemoteMethod<DisplayProtocol::GetConfigurationData>(config_type);
if (!status && status.error() != ENOENT) {
ALOGE(
"DisplayClient::GetConfigurationData: Unable to get"
"configuration data. Error: %s",
status.GetErrorMessage().c_str());
}
return status;
}
Status<std::unique_ptr<Surface>> DisplayClient::CreateSurface(
const SurfaceAttributes& attributes) {
int error;
if (auto client = Surface::Create(attributes, &error))
return {std::move(client)};
else
return ErrorStatus(error);
}
pdx::Status<std::unique_ptr<IonBuffer>> DisplayClient::SetupGlobalBuffer(
DvrGlobalBufferKey key, size_t size, uint64_t usage) {
auto status =
InvokeRemoteMethod<DisplayProtocol::SetupGlobalBuffer>(key, size, usage);
if (!status) {
ALOGE(
"DisplayClient::SetupGlobalBuffer: Failed to create the global buffer "
"%s",
status.GetErrorMessage().c_str());
return status.error_status();
}
auto ion_buffer = std::make_unique<IonBuffer>();
auto native_buffer_handle = status.take();
const int ret = native_buffer_handle.Import(ion_buffer.get());
if (ret < 0) {
ALOGE(
"DisplayClient::GetGlobalBuffer: Failed to import global buffer: "
"key=%d; error=%s",
key, strerror(-ret));
return ErrorStatus(-ret);
}
return {std::move(ion_buffer)};
}
pdx::Status<void> DisplayClient::DeleteGlobalBuffer(DvrGlobalBufferKey key) {
auto status = InvokeRemoteMethod<DisplayProtocol::DeleteGlobalBuffer>(key);
if (!status) {
ALOGE("DisplayClient::DeleteGlobalBuffer Failed: %s",
status.GetErrorMessage().c_str());
}
return status;
}
Status<std::unique_ptr<IonBuffer>> DisplayClient::GetGlobalBuffer(
DvrGlobalBufferKey key) {
auto status = InvokeRemoteMethod<DisplayProtocol::GetGlobalBuffer>(key);
if (!status) {
ALOGE(
"DisplayClient::GetGlobalBuffer: Failed to get named buffer: key=%d; "
"error=%s",
key, status.GetErrorMessage().c_str());
return status.error_status();
}
auto ion_buffer = std::make_unique<IonBuffer>();
auto native_buffer_handle = status.take();
const int ret = native_buffer_handle.Import(ion_buffer.get());
if (ret < 0) {
ALOGE(
"DisplayClient::GetGlobalBuffer: Failed to import global buffer: "
"key=%d; error=%s",
key, strerror(-ret));
return ErrorStatus(-ret);
}
return {std::move(ion_buffer)};
}
Status<bool> DisplayClient::IsVrAppRunning() {
return InvokeRemoteMethod<DisplayProtocol::IsVrAppRunning>();
}
} // namespace display
} // namespace dvr
} // namespace android