consuming_device_agent.h

// Copyright 2018-present Network Optix, Inc. Licensed under MPL 2.0: www.mozilla.org/MPL/2.0/

#pragma once

#include <map>
#include <mutex>
#include <string>
#include <vector>

#include <nx/sdk/analytics/i_compound_metadata_packet.h>
#include <nx/sdk/analytics/i_compressed_video_packet.h>
#include <nx/sdk/analytics/i_consuming_device_agent.h>
#include <nx/sdk/analytics/i_custom_metadata_packet.h>
#include <nx/sdk/analytics/i_engine.h>
#include <nx/sdk/analytics/i_metadata_types.h>
#include <nx/sdk/analytics/i_uncompressed_video_frame.h>
#include <nx/sdk/helpers/log_utils.h>
#include <nx/sdk/helpers/ref_countable.h>
#include <nx/sdk/ptr.h>

namespace nx::sdk::analytics {

class ConsumingDeviceAgent: public RefCountable<IConsumingDeviceAgent>
{
protected:
    const LogUtils logUtils;

protected:
    ConsumingDeviceAgent(
        const IDeviceInfo* deviceInfo,
        bool enableOutput,
        const std::string& integrationInstanceId = "");

    virtual std::string manifestString() const = 0;

    virtual bool pushCompressedVideoFrame(Ptr<const ICompressedVideoPacket> /*videoFrame*/)
    {
        return true;
    }

    virtual bool pushUncompressedVideoFrame(Ptr<const IUncompressedVideoFrame> /*videoFrame*/)
    {
        return true;
    }

    virtual bool pushCustomMetadataPacket(
        Ptr<const ICustomMetadataPacket> /*customMetadataPacket*/)
    {
        return true;
    }

    virtual bool pullMetadataPackets(std::vector<Ptr<IMetadataPacket>>* /*metadataPackets*/)
    {
        return true;
    }

    void pushMetadataPacket(Ptr<IMetadataPacket> metadataPacket);

    void pushIntegrationDiagnosticEvent(
        IIntegrationDiagnosticEvent::Level level,
        std::string caption,
        std::string description) const;

    virtual nx::sdk::Result<const nx::sdk::ISettingsResponse*> settingsReceived()
    {
        return nullptr;
    }

    std::string settingValue(const std::string& settingName) const;

    std::map<std::string, std::string> currentSettings() const;

    void pushManifest(const std::string& pushManifest);

    virtual void finalize() override;

    virtual void doGetSettingsOnActiveSettingChange(
        Result<const IActiveSettingChangedResponse*>* /*outResult*/,
        const IActiveSettingChangedAction* /*activeSettingChangedAction*/) override
    {
    }

public:
    virtual ~ConsumingDeviceAgent() override;

//-------------------------------------------------------------------------------------------------
// Not intended to be used by the descendant.

public:
    virtual void setHandler(IHandler* handler) override;

protected:
    virtual void doPushDataPacket(Result<void>* outResult, IDataPacket* dataPacket) override;

    virtual void doSetSettings(
        Result<const ISettingsResponse*>* outResult, const IStringMap* settings) override;

    virtual void getIntegrationSideSettings(
        Result<const ISettingsResponse*>* /*outResult*/) const override
    {
    }

    virtual void getManifest(Result<const IString*>* outResult) const override;

    virtual void doSetNeededMetadataTypes(
        Result<void>* /*outResult*/, const IMetadataTypes* /*neededMetadataTypes*/) override
    {
    }

private:
    void logMetadataPacketIfNeeded(
        Ptr<const IMetadataPacket> metadataPacket,
        int packetIndex) const;

    void processMetadataPackets(const std::vector<Ptr<IMetadataPacket>>& metadataPackets);
    void processMetadataPacket(Ptr<IMetadataPacket> metadataPacket, int packetIndex = -1);

private:
    mutable std::mutex m_mutex;
    Ptr<IDeviceAgent::IHandler> m_handler;
    std::map<std::string, std::string> m_settings;
};

} // namespace nx::sdk::analytics