Building and Installing Tizen Application Widgets

// Sample C++ header file for your custom bridge
#ifndef _EXAMPLE_BRIDGE_WEB_H_
#define _EXAMPLE_BRIDGE_WEB_H_

#include "ExampleBridge.h"

#include <platform/YiWebMessagingBridge.h>
#include <platform/YiWebViewController.h>
#include <utility/YiRapidJSONUtility.h>
#include <utility/YiString.h>

#include <vector>

class CYIWebFileLoader;

class ExampleBridgeWeb : public ExampleBridge
{
public:
    ExampleBridgeWeb();
    virtual ~ExampleBridgeWeb();

    virtual void Init() override;
    virtual CYIString GetNickname() override;
    virtual bool SetNickname(const CYIString &nickname) override;
    virtual CYIString GetIPAddress() override;
    virtual std::vector<CYIString> GetLoadedScripts() override;

private:
    CYIWebMessagingBridge *GetWebMessagingBridge() const;
    CYIWebFileLoader *GetFileLoader() const;
    CYIWebMessagingBridge::FutureResponse CallStaticFunction(yi::rapidjson::Document &&message, const CYIString &functionName, yi::rapidjson::Value &&functionArgumentsValue, bool *pMessageSent);
    CYIWebMessagingBridge::FutureResponse CallInstanceFunction(yi::rapidjson::Document &&message, const CYIString &functionName, yi::rapidjson::Value &&functionArgumentsValue, bool *pMessageSent);
    uint64_t RegisterEventHandler(const CYIString &eventName, CYIWebMessagingBridge::EventCallback &&eventCallback);
    void UnregisterEventHandler(uint64_t &eventHandlerId);
    bool LoadScript();

    uint64_t m_sequentialNumberEventHandlerId;
    mutable std::unique_ptr<CYIWebViewController> m_pWebViewController;
};

#endif // _EXAMPLE_BRIDGE_WEB_H_

// Sample C++ source file for your custom bridge
#include "ExampleBridge_Web.h"

#include <logging/YiLogger.h>
#include <platform/YiWebBridgeLocator.h>
#include <platform/YiWebFileLoader.h>
#include <utility/YiError.h>

#include <chrono>

#define LOG_TAG "ExampleBridgeWeb"

static constexpr const char *EXAMPLE_BRIDGE_CLASS_NAME = "ExampleBridge";
static constexpr const char *EXAMPLE_BRIDGE_INSTANCE_ACCESSOR_NAME = "getInstance";
static constexpr std::chrono::milliseconds GET_IP_ADDRESS_RESPONSE_TIMEOUT_MS(5000);

CYIWebMessagingBridge *ExampleBridgeWeb::GetWebMessagingBridge() const
{
    CYIWebMessagingBridge *pWebMessagingBridge = CYIWebBridgeLocator::GetWebMessagingBridge();

    if (!pWebMessagingBridge)
    {
        if (!m_pWebViewController)
        {
            YI_LOGI(LOG_TAG, "No required web view controller provided, creating instance.");

            m_pWebViewController = std::move(CYIWebViewController::CreateIfSupported());

            YI_ASSERT(m_pWebViewController, LOG_TAG, "Failed to create required web view controller.");
        }

        pWebMessagingBridge = CYIWebBridgeLocator::GetWebMessagingBridge(m_pWebViewController.get());
    }

    YI_ASSERT(pWebMessagingBridge, LOG_TAG, "Web messaging bridge is not available on this platform, or web view controller state has changed.");

    return pWebMessagingBridge;
}

CYIWebFileLoader *ExampleBridgeWeb::GetFileLoader() const
{
    CYIWebFileLoader *pWebFileLoader = GetWebMessagingBridge()->GetFileLoader();

    YI_ASSERT(pWebFileLoader, LOG_TAG, "Web file loader is not available on this platform, or web view controller state has changed.");

    return pWebFileLoader;
}

CYIWebMessagingBridge::FutureResponse ExampleBridgeWeb::CallStaticFunction(yi::rapidjson::Document &&message, const CYIString &functionName, yi::rapidjson::Value &&functionArgumentsValue, bool *pMessageSent)
{
    return GetWebMessagingBridge()->CallStaticFunctionWithArgs(std::move(message), EXAMPLE_BRIDGE_CLASS_NAME, functionName, std::move(functionArgumentsValue), pMessageSent);
}

CYIWebMessagingBridge::FutureResponse ExampleBridgeWeb::CallInstanceFunction(yi::rapidjson::Document &&message, const CYIString &functionName, yi::rapidjson::Value &&functionArgumentsValue, bool *pMessageSent)
{
    return GetWebMessagingBridge()->CallInstanceFunctionWithArgs(std::move(message), EXAMPLE_BRIDGE_CLASS_NAME, EXAMPLE_BRIDGE_INSTANCE_ACCESSOR_NAME, functionName, std::move(functionArgumentsValue), yi::rapidjson::Value(yi::rapidjson::kArrayType), pMessageSent);
}

uint64_t ExampleBridgeWeb::RegisterEventHandler(const CYIString &eventName, CYIWebMessagingBridge::EventCallback &&eventCallback)
{
    return GetWebMessagingBridge()->RegisterEventHandler(EXAMPLE_BRIDGE_CLASS_NAME, eventName, std::move(eventCallback));
}

void ExampleBridgeWeb::UnregisterEventHandler(uint64_t &eventHandlerId)
{
    GetWebMessagingBridge()->UnregisterEventHandler(eventHandlerId);
    eventHandlerId = 0;
}

bool ExampleBridgeWeb::LoadScript()
{
    static constexpr const char *SCRIPT_FILE_NAME = "ExampleBridge.js";

    CYIWebFileLoader *pFileLoader = GetWebMessagingBridge()->GetFileLoader();

    bool messageSent = false;
    CYIWebMessagingBridge::FutureResponse futureResponse = pFileLoader->LoadFile(SCRIPT_FILE_NAME, &messageSent);

    if (!messageSent)
    {
        YI_LOGE(LOG_TAG, "Failed to invoke web file loader load file function when attempting to load example bridge script.");
        return false;
    }

    bool valueAssigned = false;
    CYIWebMessagingBridge::Response response = futureResponse.Take(CYIWebMessagingBridge::DEFAULT_RESPONSE_TIMEOUT_MS, &valueAssigned);

    if (!valueAssigned)
    {
        YI_LOGE(LOG_TAG, "Did not receive a response from the web messaging bridge when attempting to load example bridge script!");
        return false;
    }

    if (response.HasError())
    {
        YI_LOGE(LOG_TAG, "%s", response.GetError()->GetStacktraceOrMessage().GetData());
        return false;
    }

    return true;
}

ExampleBridgeWeb::ExampleBridgeWeb()
    : m_sequentialNumberEventHandlerId(0)
{
    static constexpr const char *SEQUENTIAL_NUMBER_EVENT_NAME = "sequentialNumber";

    m_sequentialNumberEventHandlerId = RegisterEventHandler(SEQUENTIAL_NUMBER_EVENT_NAME, [this](yi::rapidjson::Document &&event) {
        if (event.HasMember(CYIWebMessagingBridge::EVENT_DATA_ATTRIBUTE_NAME) && event[CYIWebMessagingBridge::EVENT_DATA_ATTRIBUTE_NAME].IsInt())
        {
            SequentialNumber.Emit(event[CYIWebMessagingBridge::EVENT_DATA_ATTRIBUTE_NAME].GetInt());
        }
        else
        {
            YI_LOGE(LOG_TAG, "Invalid '%s' event data. JSON string for event: '%s'.", SEQUENTIAL_NUMBER_EVENT_NAME, CYIRapidJSONUtility::CreateStringFromValue(event).GetData());
        }
    });

    if (!LoadScript())
    {
        YI_ASSERT(false, LOG_TAG, "Failed to load example bridge script!");
    }
}

ExampleBridgeWeb::~ExampleBridgeWeb()
{
}

void ExampleBridgeWeb::Init()
{
    static constexpr const char *FUNCTION_NAME = "init";

    bool messageSent = false;
    CYIWebMessagingBridge::FutureResponse futureResponse = CallInstanceFunction(yi::rapidjson::Document(), FUNCTION_NAME, yi::rapidjson::Value(yi::rapidjson::kArrayType), &messageSent);

    if (!messageSent)
    {
        YI_LOGE(LOG_TAG, "Failed to invoke %s function.", FUNCTION_NAME);
    }
    else
    {
        bool valueAssigned = false;
        CYIWebMessagingBridge::Response response = futureResponse.Take(CYIWebMessagingBridge::DEFAULT_RESPONSE_TIMEOUT_MS, &valueAssigned);

        if (!valueAssigned)
        {
            YI_LOGE(LOG_TAG, "%s did not receive a response from the web messaging bridge!", FUNCTION_NAME);
        }
        else if (response.HasError())
        {
            YI_LOGE(LOG_TAG, "%s", response.GetError()->GetMessage().GetData());
        }
    }
}

CYIString ExampleBridgeWeb::GetNickname()
{
    static constexpr const char *FUNCTION_NAME = "getNickname";

    bool messageSent = false;
    CYIWebMessagingBridge::FutureResponse futureResponse = CallInstanceFunction(yi::rapidjson::Document(), FUNCTION_NAME, yi::rapidjson::Value(yi::rapidjson::kArrayType), &messageSent);

    if (!messageSent)
    {
        YI_LOGE(LOG_TAG, "Failed to invoke %s function.", FUNCTION_NAME);
    }
    else
    {
        bool valueAssigned = false;
        CYIWebMessagingBridge::Response response = futureResponse.Take(CYIWebMessagingBridge::DEFAULT_RESPONSE_TIMEOUT_MS, &valueAssigned);

        if (!valueAssigned)
        {
            YI_LOGE(LOG_TAG, "%s did not receive a response from the web messaging bridge!", FUNCTION_NAME);
        }
        else if (response.HasError())
        {
            YI_LOGE(LOG_TAG, "%s", response.GetError()->GetMessage().GetData());
        }
        else
        {
            const yi::rapidjson::Value *pData = response.GetResult();

            if (!pData->IsString())
            {
                YI_LOGE(LOG_TAG, "%s expected a string type for result, received %s. JSON string for result: %s", FUNCTION_NAME, CYIRapidJSONUtility::TypeToString(pData->GetType()).GetData(), CYIRapidJSONUtility::CreateStringFromValue(*pData).GetData());
            }
            else
            {
                return pData->GetString();
            }
        }
    }

    return CYIString();
}

bool ExampleBridgeWeb::SetNickname(const CYIString &nickname)
{
    static constexpr const char *FUNCTION_NAME = "setNickname";

    bool messageSent = false;

    yi::rapidjson::Document command(yi::rapidjson::kObjectType);
    yi::rapidjson::Value arguments(yi::rapidjson::kArrayType);
    yi::rapidjson::MemoryPoolAllocator<yi::rapidjson::CrtAllocator> &allocator = command.GetAllocator();

    yi::rapidjson::Value nicknameValue(nickname.GetData(), allocator);
    arguments.PushBack(nicknameValue, allocator);

    CYIWebMessagingBridge::FutureResponse futureResponse = CallInstanceFunction(std::move(command), FUNCTION_NAME, std::move(arguments), &messageSent);

    if (!messageSent)
    {
        YI_LOGE(LOG_TAG, "Failed to invoke %s function.", FUNCTION_NAME);
    }
    else
    {
        bool valueAssigned = false;
        CYIWebMessagingBridge::Response response = futureResponse.Take(CYIWebMessagingBridge::DEFAULT_RESPONSE_TIMEOUT_MS, &valueAssigned);

        if (!valueAssigned)
        {
            YI_LOGE(LOG_TAG, "%s did not receive a response from the web messaging bridge!", FUNCTION_NAME);
        }
        else if (response.HasError())
        {
            YI_LOGE(LOG_TAG, "%s", response.GetError()->GetMessage().GetData());
        }
        else
        {
            return true;
        }
    }

    return false;
}

CYIString ExampleBridgeWeb::GetIPAddress()
{
    static constexpr const char *FUNCTION_NAME = "getIPAddress";

    bool messageSent = false;
    CYIWebMessagingBridge::FutureResponse futureResponse = CallInstanceFunction(yi::rapidjson::Document(), FUNCTION_NAME, yi::rapidjson::Value(yi::rapidjson::kArrayType), &messageSent);

    if (!messageSent)
    {
        YI_LOGE(LOG_TAG, "Failed to invoke %s function.", FUNCTION_NAME);
    }
    else
    {
        bool valueAssigned = false;
        CYIWebMessagingBridge::Response response = futureResponse.Take(GET_IP_ADDRESS_RESPONSE_TIMEOUT_MS.count(), &valueAssigned);

        if (!valueAssigned)
        {
            YI_LOGE(LOG_TAG, "%s did not receive a response from the web messaging bridge!", FUNCTION_NAME);
        }
        else if (response.HasError())
        {
            YI_LOGE(LOG_TAG, "%s", response.GetError()->GetMessage().GetData());
        }
        else
        {
            const yi::rapidjson::Value *pData = response.GetResult();

            if (!pData->IsString())
            {
                YI_LOGE(LOG_TAG, "%s expected a string type for result, received %s. JSON string for result: %s", FUNCTION_NAME, CYIRapidJSONUtility::TypeToString(pData->GetType()).GetData(), CYIRapidJSONUtility::CreateStringFromValue(*pData).GetData());
            }
            else
            {
                return pData->GetString();
            }
        }
    }

    return CYIString();
}

std::vector<CYIString> ExampleBridgeWeb::GetLoadedScripts()
{
    static constexpr const char *FUNCTION_NAME = "getLoadedScripts";

    std::vector<CYIString> loadedScripts;

    bool messageSent = false;
    CYIWebMessagingBridge::FutureResponse futureResponse = CallStaticFunction(yi::rapidjson::Document(), FUNCTION_NAME, yi::rapidjson::Value(yi::rapidjson::kArrayType), &messageSent);

    if (!messageSent)
    {
        YI_LOGE(LOG_TAG, "Failed to invoke %s function.", FUNCTION_NAME);
    }
    else
    {
        bool valueAssigned = false;
        CYIWebMessagingBridge::Response response = futureResponse.Take(CYIWebMessagingBridge::DEFAULT_RESPONSE_TIMEOUT_MS, &valueAssigned);

        if (!valueAssigned)
        {
            YI_LOGE(LOG_TAG, "GetLoadedScripts did not receive a response from the web messaging bridge!");
        }
        else if (response.HasError())
        {
            YI_LOGE(LOG_TAG, "%s", response.GetError()->GetMessage().GetData());
        }
        else
        {
            const yi::rapidjson::Value *pData = response.GetResult();

            if (!pData->IsArray())
            {
                YI_LOGE(LOG_TAG, "GetLoadedScripts expected an array type for result, received %s. JSON string for result: %s", CYIRapidJSONUtility::TypeToString(pData->GetType()).GetData(), CYIRapidJSONUtility::CreateStringFromValue(*pData).GetData());
            }
            else
            {
                for (uint32_t i = 0; i < pData->Size(); i++)
                {
                    if ((*pData)[i].IsString())
                    {
                        loadedScripts.emplace_back((*pData)[i].GetString());
                    }
                    else
                    {
                        YI_LOGW(LOG_TAG, "GetLoadedScripts encountered an invalid script name at index %u, expected string but received %s. JSON string for element: %s", i, CYIRapidJSONUtility::TypeToString((*pData)[i].GetType()).GetData(), CYIRapidJSONUtility::CreateStringFromValue((*pData)[i]).GetData());
                    }
                }
            }
        }
    }

    return loadedScripts;
}

// Sample C++ source file for your custom bridge base class
#include "ExampleBridge.h"

ExampleBridge::ExampleBridge() = default;

ExampleBridge::~ExampleBridge() = default;

void ExampleBridge::Init()
{
}

// Sample C++ header file for your custom bridge base class
#ifndef _EXAMPLE_BRIDGE_H_
#define _EXAMPLE_BRIDGE_H_

#include <signal/YiSignal.h>
#include <utility/YiString.h>

class ExampleBridge
{
public:
    ExampleBridge();
    virtual ~ExampleBridge();

    virtual void Init();
    virtual CYIString GetNickname() = 0;
    virtual bool SetNickname(const CYIString &nickname) = 0;
    virtual CYIString GetIPAddress() = 0;
    virtual std::vector<CYIString> GetLoadedScripts() = 0;

    CYISignal<int32_t /* sequentialNumber */> SequentialNumber;
};

#endif // _EXAMPLE_BRIDGE_H_

// Sample C++ source file for your custom bridge locator
#include "ExampleBridgeLocator.h"

#include "ExampleBridge.h"

#include <framework/YiPredef.h>

#define LOG_TAG "ExampleBridgeLocator"

#if defined(YI_TIZEN_NACL) || defined(YI_UWP)
#    include "ExampleBridge_Web.h"
#endif

static std::unique_ptr<ExampleBridge> s_pCachedExampleBridge = nullptr;

ExampleBridge *ExampleBridgeLocator::GetExampleBridge()
{
    if (!s_pCachedExampleBridge)
    {
#if defined(YI_TIZEN_NACL) || defined(YI_UWP)
        s_pCachedExampleBridge = std::make_unique<ExampleBridgeWeb>();
#endif

        if (s_pCachedExampleBridge)
        {
            s_pCachedExampleBridge->Init();
        }
    }

    return s_pCachedExampleBridge.get();
}

// Sample C++ header file for your custom bridge locator
#ifndef _EXAMPLE_BRIDGE_LOCATOR_H_
#define _EXAMPLE_BRIDGE_LOCATOR_H_

#include "ExampleBridge.h"

class ExampleBridgeLocator
{
public:
    static ExampleBridge *GetExampleBridge();
};

#endif // _EXAMPLE_BRIDGE_LOCATOR_H_

// C++ code snippet demonstrating how to use your custom bridge
ExampleBridge *pExampleBridge = ExampleBridgeLocator::GetExampleBridge();

if (pExampleBridge)
{
    pExampleBridge->SequentialNumber.Connect([](int32_t sequentialNumber) {
        YI_LOGI(LOG_TAG, "Sequential Number Event #%d!", sequentialNumber);
    });

    CYIString nickname(pExampleBridge->GetNickname());

    YI_LOGI(LOG_TAG, "Default Nickname: '%s'.", nickname.GetData());

    pExampleBridge->SetNickname("Awesome Bridge");

    CYIString newNickname(pExampleBridge->GetNickname());

    YI_LOGI(LOG_TAG, "New Nickname: '%s'.", newNickname.GetData());

    CYIString ipAddress(pExampleBridge->GetIPAddress());

    YI_LOGI(LOG_TAG, "IP Address: '%s'.", ipAddress.GetData());

    std::vector<CYIString> loadedScripts = pExampleBridge->GetLoadedScripts();

    YI_LOGI(LOG_TAG, "%s Scripts Loaded:", CYIString::FromValue(loadedScripts.size()).GetData());

    for (size_t i = 0; i < loadedScripts.size(); i++)
    {
        YI_LOGI(LOG_TAG, "%s. %s", CYIString::FromValue(i + 1).GetData(), loadedScripts[i].GetData());
    }
}
else
{
    YI_LOGW(LOG_TAG, "Example bridge not available for current platform!");
}