IpcCommon.h

/*
* If not stated otherwise in this file or this component's LICENSE file the
* following copyright and licenses apply:
*
* Copyright 2020 Sky UK
*
* 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.
*/
/*
 * IpcCommon.h
 *
 *  Created on: 5 Jun 2015
 *      Author: riyadh
 */
 
#ifndef AI_IPC_IPCCOMMON_H
#define AI_IPC_IPCCOMMON_H
 
#include "IpcVariantList.h"
 
#include <sys/types.h>
 
#include <string>
#include <map>
#include <vector>
#include <functional>
#include <memory>
 
namespace AI_IPC
{
 
struct RemoteEntry
{
    enum Type
    {
       METHOD,
       SIGNAL
    };
 
    Type type;
    std::string service;
    std::string object;
    std::string interface;
    std::string name;
 
    bool isValid() const
    {
        if (object.empty() || interface.empty() || name.empty())
            return false;
        if ((type == METHOD) && service.empty())
            return false;
        return true;
    }
 
    operator bool() const
    {
        return isValid();
    }
 
protected:
    RemoteEntry(Type type_)
        : type(type_) {}
 
    RemoteEntry(Type type_, const std::string& service_, const std::string& object_, const std::string& interface_, const std::string& name_)
        : type(type_), service(service_), object(object_), interface(interface_), name(name_) {}
};
 
struct Method : public RemoteEntry
{
    Method()
        : RemoteEntry(METHOD) {}
 
    Method(const std::string& service_, const std::string& object_, const std::string& interface_, const std::string& name_)
        : RemoteEntry(METHOD, service_, object_, interface_, name_) {}
 
};
 
struct Signal : public RemoteEntry
{
    Signal()
        : RemoteEntry(SIGNAL) {}
 
    Signal(const std::string& object_, const std::string& interface_, const std::string& name_)
        : RemoteEntry(SIGNAL, std::string(), object_, interface_, name_) {}
};
 
class IAsyncReplySender
{
public:
    virtual ~IAsyncReplySender() = default;
 
    virtual VariantList getMethodCallArguments() const = 0;
 
    virtual bool sendReply(const VariantList& replyArgs) = 0;
 
    virtual uid_t getSenderUid() const = 0;
 
    virtual std::string getSenderName() const = 0;
};
 
class IAsyncReplyGetter
{
public:
    virtual ~IAsyncReplyGetter() = default;
 
    virtual bool getReply(VariantList& argList) = 0;
};
 
typedef enum
{
    MethodCallEvent,
    MethodReturnEvent,
    SignalEvent,
    ErrorEvent,
} EventType;
 
typedef std::function<void(std::shared_ptr<IAsyncReplySender>)> MethodHandler;
 
typedef std::function<void(const VariantList&)> SignalHandler;
 
typedef std::function<void(EventType,
                           unsigned int,
                           const std::string&,
                           const std::string&,
                           const std::string&,
                           const std::string&,
                           const std::string&,
                           const VariantList&)> MonitorHandler;
 
}
 
#endif /* AI_IPC_IPCCOMMON_H */