| // |
| // Copyright 2015 Google, Inc. |
| // |
| // 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: |
| // |
| // http://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. |
| // |
| |
| #pragma once |
| |
| #include <memory> |
| |
| #include <base/macros.h> |
| #include <base/memory/ref_counted.h> |
| |
| namespace bluetooth { |
| class Adapter; |
| } // namespace bluetooth |
| |
| namespace ipc { |
| |
| class IPCHandler; |
| |
| // IPCManager is a class for initializing and running supported IPC mechanisms. |
| // It manages the life-time of different IPC flavors that are available on the |
| // system. There are two flavors: a Linux sequential packet domain socket based |
| // system and one based on the Binder-based android.bluetooth framework. |
| class IPCManager { |
| public: |
| // Possible IPC types. |
| enum Type { |
| TYPE_LINUX, // IPC based on a Linux sequential packet domain socket |
| TYPE_BINDER, // IPC based on the Binder |
| TYPE_DBUS // IPC based on the DBus |
| }; |
| |
| // Interface for observing events from an IPC mechanism. These methods will be |
| // called on the thread that started the particular IPC type. |
| class Delegate { |
| public: |
| Delegate() = default; |
| virtual ~Delegate() = default; |
| |
| // Called when an IPC mechanism has successfully started and is ready for |
| // client connections. |
| virtual void OnIPCHandlerStarted(Type type) = 0; |
| |
| // Called when an IPC mechanism has stopped. This may happen due to an error |
| // in initialization or due to a regular shut down routine. |
| virtual void OnIPCHandlerStopped(Type type) = 0; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(Delegate); |
| }; |
| |
| explicit IPCManager(bluetooth::Adapter* adapter); |
| ~IPCManager(); |
| |
| // Initialize the underlying IPC handler based on |type|, if that type has not |
| // yet been initialized and returns true on success. Returns false if that |
| // type has already been initialized or an error occurs. |
| // |
| // If TYPE_LINUX is given, the file path to use for the domain socket will be |
| // obtained from the global Settings object. Hence, the Settings object must |
| // have been initialized before calling this method. |
| // |
| // |delegate| must out-live the IPCManager and the underlying handler. Users |
| // can guarantee proper clean up by deallocating |delegate| when or after |
| // Delegate::OnIPCHandlerStopped is called. It is safe to destroy |delegate| |
| // after destroying the IPCManager instance, as the destructor will join and |
| // clean up all underlying threads. |
| bool Start(Type type, Delegate* delegate); |
| |
| // Returns true if an IPC type has been initialized. |
| bool BinderStarted() const; |
| bool LinuxStarted() const; |
| bool DBusStarted() const; |
| |
| private: |
| IPCManager() = default; |
| |
| // Pointers to the different IPC handler classes. These are initialized and |
| // owned by us. |
| scoped_refptr<IPCHandler> binder_handler_; |
| scoped_refptr<IPCHandler> linux_handler_; |
| scoped_refptr<IPCHandler> dbus_handler_; |
| |
| // The Bluetooth adapter instance. This is owned by Daemon so we keep a raw |
| // pointer to it. |
| bluetooth::Adapter* adapter_; |
| |
| DISALLOW_COPY_AND_ASSIGN(IPCManager); |
| }; |
| |
| } // namespace ipc |