| // Copyright 2020 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #ifndef SRC_CAMERA_BIN_DEVICE_DEVICE_IMPL_H_ | |
| #define SRC_CAMERA_BIN_DEVICE_DEVICE_IMPL_H_ | |
| #include <fuchsia/camera2/hal/cpp/fidl.h> | |
| #include <fuchsia/camera3/cpp/fidl.h> | |
| #include <fuchsia/sysmem/cpp/fidl.h> | |
| #include <fuchsia/ui/policy/cpp/fidl.h> | |
| #include <lib/fidl/cpp/binding.h> | |
| #include <lib/fpromise/barrier.h> | |
| #include <lib/fpromise/promise.h> | |
| #include <lib/fpromise/result.h> | |
| #include <lib/fpromise/scope.h> | |
| #include <lib/sys/cpp/component_context.h> | |
| #include <zircon/status.h> | |
| #include <zircon/types.h> | |
| #include <list> | |
| #include <map> | |
| #include <memory> | |
| #include <vector> | |
| #include "src/camera/bin/device/stream_impl.h" | |
| #include "src/camera/bin/device/sysmem_allocator.h" | |
| #include "src/camera/lib/hanging_get_helper/hanging_get_helper.h" | |
| namespace camera { | |
| // Represents a physical camera device, and serves multiple clients of the camera3.Device protocol. | |
| class DeviceImpl final : public fuchsia::ui::policy::MediaButtonsListener { | |
| public: | |
| // Creates a DeviceImpl using the given |controller|. | |
| // | |
| // References to |dispatcher|, |executor|, and |context| may be retained by the instance so the | |
| // caller must ensure these outlive the returned DeviceImpl. | |
| static fpromise::promise<std::unique_ptr<DeviceImpl>, zx_status_t> Create( | |
| async_dispatcher_t* dispatcher, fpromise::executor& executor, | |
| fuchsia::camera2::hal::ControllerHandle controller, | |
| fuchsia::sysmem2::AllocatorHandle allocator, | |
| fuchsia::ui::policy::DeviceListenerRegistryHandle registry, zx::event bad_state_event); | |
| DeviceImpl(async_dispatcher_t* dispatcher, fpromise::executor& executor, | |
| fuchsia::sysmem2::AllocatorHandle allocator, zx::event bad_state_event); | |
| ~DeviceImpl() override; | |
| // Returns a service handler for use with a service directory. | |
| fidl::InterfaceRequestHandler<fuchsia::camera3::Device> GetHandler(); | |
| async_dispatcher_t* dispatcher() const { return dispatcher_; } | |
| private: | |
| // Called by the request handler returned by GetHandler, i.e. when a new client connects to the | |
| // published service. | |
| void OnNewRequest(fidl::InterfaceRequest<fuchsia::camera3::Device> request); | |
| // Posts a task to bind a new client. | |
| void Bind(fidl::InterfaceRequest<fuchsia::camera3::Device> request); | |
| // Called if the underlying controller disconnects. | |
| void OnControllerDisconnected(zx_status_t status); | |
| // Posts a task to remove the client with the given id. | |
| void RemoveClient(uint64_t id); | |
| // Sets the current configuration to the provided index. | |
| void SetConfiguration(uint32_t index); | |
| // Set the software mute state. | |
| void SetSoftwareMuteState(bool muted, | |
| fuchsia::camera3::Device::SetSoftwareMuteStateCallback callback); | |
| // Toggles the streaming state of the controller if necessary. | |
| void UpdateControllerStreamingState(); | |
| // Posts a task to connect to a stream. | |
| void PostConnectToStream(uint32_t index, | |
| fidl::InterfaceRequest<fuchsia::camera3::Stream> request); | |
| // Connects to a stream. | |
| void ConnectToStream(uint32_t index, fidl::InterfaceRequest<fuchsia::camera3::Stream> request); | |
| // Called by a stream when it has sufficient information to connect to the legacy stream protocol. | |
| void OnStreamRequested(uint32_t index, fidl::InterfaceRequest<fuchsia::camera2::Stream> request, | |
| uint32_t format_index); | |
| // Called by a stream when it has received a buffer token from the legacy stream. | |
| void OnBuffersRequested(uint32_t index, fuchsia::sysmem2::BufferCollectionTokenHandle token, | |
| fit::function<void(uint32_t)> max_camping_buffers_callback); | |
| // |fuchsia::ui::policy::MediaButtonsListener| | |
| void OnEvent(fuchsia::ui::input::MediaButtonsEvent event, | |
| fuchsia::ui::policy::MediaButtonsListener::OnEventCallback callback) override; | |
| void OnMediaButtonsEvent(fuchsia::ui::input::MediaButtonsEvent event) override { | |
| FX_LOGS(ERROR) << "OnMediaButtonsEvent not implemented"; | |
| #ifndef NDEBUG | |
| ZX_PANIC("Not Implemented: OnMediaButtonsEvent"); | |
| #endif | |
| } | |
| // Represents a single client connection to the DeviceImpl class. | |
| class Client : public fuchsia::camera3::Device { | |
| public: | |
| Client(DeviceImpl& device, uint64_t id, | |
| fidl::InterfaceRequest<fuchsia::camera3::Device> request); | |
| ~Client() override; | |
| // Inform the client of a new configuration. | |
| void ConfigurationUpdated(uint32_t index); | |
| // Inform the client of a new mute state. | |
| void MuteUpdated(MuteState mute_state); | |
| private: | |
| // Closes |binding_| with the provided |status| epitaph, and removes the client instance from | |
| // the parent |clients_| map. | |
| void CloseConnection(zx_status_t status); | |
| // Called when the client endpoint of |binding_| is closed. | |
| void OnClientDisconnected(zx_status_t status); | |
| // |fuchsia::camera3::Device| | |
| void GetIdentifier(GetIdentifierCallback callback) override; | |
| void GetConfigurations(GetConfigurationsCallback callback) override; | |
| void GetConfigurations2(GetConfigurations2Callback callback) override; | |
| void WatchCurrentConfiguration(WatchCurrentConfigurationCallback callback) override; | |
| void SetCurrentConfiguration(uint32_t index) override; | |
| void WatchMuteState(WatchMuteStateCallback callback) override; | |
| void SetSoftwareMuteState(bool muted, SetSoftwareMuteStateCallback callback) override; | |
| void ConnectToStream(uint32_t index, | |
| fidl::InterfaceRequest<fuchsia::camera3::Stream> request) override; | |
| void Rebind(fidl::InterfaceRequest<fuchsia::camera3::Device> request) override; | |
| DeviceImpl& device_; | |
| std::string log_prefix_; | |
| uint64_t id_; | |
| fidl::Binding<fuchsia::camera3::Device> binding_; | |
| HangingGetHelper<uint32_t> configuration_; | |
| HangingGetHelper<MuteState> mute_state_; | |
| }; | |
| async_dispatcher_t* dispatcher_; | |
| fpromise::executor& executor_; | |
| SysmemAllocator sysmem_allocator_; | |
| zx::event bad_state_event_; | |
| fuchsia::camera2::hal::ControllerPtr controller_; | |
| fuchsia::ui::policy::DeviceListenerRegistryPtr registry_; | |
| fidl::Binding<fuchsia::ui::policy::MediaButtonsListener> button_listener_binding_; | |
| fuchsia::camera2::DeviceInfo device_info_; | |
| std::vector<fuchsia::camera2::hal::Config> configs_; | |
| std::vector<fuchsia::camera3::Configuration2> configurations_; | |
| std::vector<std::unique_ptr<MetricsReporter::ConfigurationRecord>> records_; | |
| std::map<uint64_t, std::unique_ptr<Client>> clients_; | |
| uint64_t client_id_next_ = 1; | |
| uint32_t current_configuration_index_ = 0; | |
| std::vector<zx::eventpair> deallocation_events_; | |
| fpromise::barrier deallocation_barrier_; | |
| bool deallocation_error_ = false; | |
| std::vector<std::unique_ptr<StreamImpl>> streams_; | |
| std::vector<uint64_t> stream_generations_; | |
| uint64_t stream_generation_next_ = 1; | |
| MuteState mute_state_; | |
| bool controller_streaming_ = true; | |
| std::shared_ptr<bool> alive_ = std::make_shared<bool>(true); | |
| // This should always be the last thing in the object so that the scope is destroyed first, | |
| // cancelling any scheduled tasks on executor_ before the rest of the members are destroyed. | |
| fpromise::scope scope_; | |
| friend class Client; | |
| }; | |
| } // namespace camera | |
| #endif // SRC_CAMERA_BIN_DEVICE_DEVICE_IMPL_H_ |