141 lines
5.9 KiB
C++
141 lines
5.9 KiB
C++
// Copyright 2016 The Android Open Source Project
|
|
//
|
|
// 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.
|
|
|
|
#ifndef LIBWEAVED_SERVICE_H_
|
|
#define LIBWEAVED_SERVICE_H_
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <base/callback.h>
|
|
#include <base/compiler_specific.h>
|
|
#include <base/macros.h>
|
|
#include <brillo/errors/error.h>
|
|
#include <libweaved/command.h>
|
|
#include <libweaved/export.h>
|
|
|
|
namespace brillo {
|
|
class MessageLoop;
|
|
} // namespace brillo
|
|
|
|
namespace weaved {
|
|
|
|
// A weaved service is an abstract interface representing an instance of weave
|
|
// services for a particular client daemon. Apart from providing an API to
|
|
// weaved process, it manages resources specific for an instance of the client.
|
|
// For example, when a client exits, it removes any resources (e.g. components)
|
|
// that were added by this client from the weaved's component tree.
|
|
class LIBWEAVED_EXPORT Service {
|
|
public:
|
|
// Callback type for AddCommandHandler.
|
|
using CommandHandlerCallback =
|
|
base::Callback<void(std::unique_ptr<Command> command)>;
|
|
|
|
// Callback type for AddPairingInfoListener.
|
|
struct PairingInfo {
|
|
std::string session_id;
|
|
std::string pairing_mode;
|
|
std::string pairing_code;
|
|
};
|
|
using PairingInfoCallback =
|
|
base::Callback<void(const PairingInfo* pairing_info)>;
|
|
|
|
Service() = default;
|
|
virtual ~Service() = default;
|
|
|
|
// Adds a new component instance to device.
|
|
// |component| is a component name being added.
|
|
// |traits| is a list of trait names this component supports.
|
|
virtual bool AddComponent(const std::string& component,
|
|
const std::vector<std::string>& traits,
|
|
brillo::ErrorPtr* error) = 0;
|
|
|
|
// Sets handler for new commands added to the queue for a given |component|.
|
|
// |command_name| is the name of the command to handle (e.g. "reboot").
|
|
// |trait_name| is the name of a trait the command belongs to (e.g. "base").
|
|
// Each command can have no more than one handler.
|
|
virtual void AddCommandHandler(const std::string& component,
|
|
const std::string& trait_name,
|
|
const std::string& command_name,
|
|
const CommandHandlerCallback& callback) = 0;
|
|
|
|
// Sets a number of state properties for a given |component|.
|
|
// |dict| is a dictionary containing property-name/property-value pairs.
|
|
virtual bool SetStateProperties(const std::string& component,
|
|
const base::DictionaryValue& dict,
|
|
brillo::ErrorPtr* error) = 0;
|
|
|
|
// Sets value of the single property.
|
|
// |component| is a path to the component to set the property value to.
|
|
// |trait_name| is the name of the trait this property is part of.
|
|
// |property_name| is the property name.
|
|
virtual bool SetStateProperty(const std::string& component,
|
|
const std::string& trait_name,
|
|
const std::string& property_name,
|
|
const base::Value& value,
|
|
brillo::ErrorPtr* error) = 0;
|
|
|
|
// Specifies a callback to be invoked when the device enters/exist pairing
|
|
// mode. The |pairing_info| parameter is set to a pointer to pairing
|
|
// information on starting the pairing session and is nullptr when the pairing
|
|
// session ends.
|
|
virtual void SetPairingInfoListener(const PairingInfoCallback& callback) = 0;
|
|
|
|
// Service creation functionality.
|
|
// Subscription is a base class for an object responsible for life-time
|
|
// management for the service. The service instance is kept alive for as long
|
|
// as the service connection is alive. See comments for Service::Connect for
|
|
// more details.
|
|
class Subscription {
|
|
public:
|
|
virtual ~Subscription() = default;
|
|
|
|
protected:
|
|
Subscription() = default;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(Subscription);
|
|
};
|
|
|
|
using ConnectionCallback =
|
|
base::Callback<void(const std::weak_ptr<Service>& service)>;
|
|
|
|
// Creates an instance of weaved service asynchronously. This not only creates
|
|
// the service class instance but also establishes an RPC connection to
|
|
// weaved daemon. Upon connection having been established, a |callback| is
|
|
// invoked and an instance of Service is passed to it as an argument.
|
|
// The service instance provided to the callback is a weak pointer to the
|
|
// actual service which may be destroyed at any time if RPC connection to
|
|
// weaved is lost. If this happens, a connection is re-established and the
|
|
// |callback| is called again with a new instance of the service.
|
|
// Therefore, if locking the |service| produces nullptr, this means that the
|
|
// service got disconnected, so no further action can be taken. Since the
|
|
// |callback| will be invoked with the new service instance when connection
|
|
// is re-established, it's a good idea to update the device state on each
|
|
// invocation of the callback (along with registering command handlers, etc).
|
|
// IMPORTANT: Keep the returned subscription object around for as long as the
|
|
// service is needed. As soon as the subscription is destroyed, the connection
|
|
// to weaved is terminated and the service instance is discarded.
|
|
static std::unique_ptr<Subscription> Connect(
|
|
brillo::MessageLoop* message_loop,
|
|
const ConnectionCallback& callback) WARN_UNUSED_RESULT;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(Service);
|
|
};
|
|
|
|
} // namespace weaved
|
|
|
|
#endif // LIBWEAVED_SERVICE_H_
|