/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  rtcMessages
*
*/

#ifndef RTCMESSAGES_H
#define RTCMESSAGES_H

#include "logger.h"
#include "comms.h"
#include "commsmessage.h"

#include "javauid.h"

using namespace java::comms;

using java::util::Uid;

namespace java
{
namespace captain
{
// Message IDs of all RTC services
const int RTC_MSG_ID_LAUNCH_APPLICATION_REQ         = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 1; // 101
const int RTC_MSG_ID_TERMINATE_APPLICATION_REQ      = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 2; // 102
const int RTC_MSG_ID_APPLICATION_RUNNING_IND        = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 3; // 103
const int RTC_MSG_ID_APPLICATION_TERMINATED_IND     = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 4; // 104
const int RTC_MSG_ID_ADD_PUSH_CONNECTION_IND        = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 5; // 105

const int RTC_MSG_ID_SET_EXTRA_ARGUMENTS            = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 50; // 150
const int RTC_MSG_ID_GET_EXTRA_ARGUMENTS            = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 51; // 151
const int RTC_MSG_ID_GET_EXTRA_ARGUMENTS_ACK        = JAVACAPTAIN_MESSAGE_ID_RANGE_START_C + 52; // 152

const int RTC_LAUNCH_TYPE_NORMAL_C                    = 0;
const int RTC_LAUNCH_TYPE_PUSH_C                      = 1;
const int RTC_LAUNCH_TYPE_AUTO_INVOCATION_C           = 2;
const int RTC_LAUNCH_TYPE_BACKGROUND_C                = 3;
const int RTC_LAUNCH_TYPE_DEBUG_C                     = 4;
const int RTC_LAUNCH_TYPE_PREWARM_C                   = 5;

#define PREWARM_UID java::util::Uid(L"prewarm")

const int RTC_LAUNCH_OPTIONS_NONE_C                 = 0x00;
const int RTC_LAUNCH_OPTIONS_RUNNING_IND_REQ_C      = 0x01;
const int RTC_LAUNCH_OPTIONS_TERMINATE_IND_REQ_C    = 0x02;

const char* const RTC_LAUNCH_RUNTIME_MIDP_C         = "midp";

const int RTC_LAUNCH_OPTIONS_INDICATION_MASK        = RTC_LAUNCH_OPTIONS_RUNNING_IND_REQ_C |
        RTC_LAUNCH_OPTIONS_TERMINATE_IND_REQ_C;

const int RTC_TERMINATE_OPTIONS_NONE_C              = 0x00;
const int RTC_TERMINATE_OPTIONS_TERMINATE_IND_REQ_C = 0x02;

const int RTC_TERMINATE_OPTIONS_INDICATION_MASK     = RTC_TERMINATE_OPTIONS_TERMINATE_IND_REQ_C;

// Launch application request
inline void setLaunchApplicationReqParams(CommsMessage& aMessage,
        const Uid& aUid, const int& aType, const int& aOptions,
        const std::string& aRtc = RTC_LAUNCH_RUNTIME_MIDP_C,
        const std::wstring& aApplicationArguments = L"",
        const std::wstring& aRuntimeArguments = L"")
{
    aMessage.setModuleId(PLUGIN_ID_RTC_C);
    aMessage.setMessageId(RTC_MSG_ID_LAUNCH_APPLICATION_REQ);
    aMessage << aUid << aType << aOptions << aRtc;
    aMessage << aApplicationArguments << aRuntimeArguments;

    LOG4(EJavaCaptain, EInfoHeavyLoad,
         "RTC_MSG_ID_LAUNCH_APPLICATION_REQ (uid=%S, rtc=%s, type=%d, options=%d) encoded",
         aUid.toString().c_str(), aRtc.c_str(), aType, aOptions);
}

inline void getLaunchApplicationReqParams(CommsMessage& aMessage,
        Uid& aUid, int& aType, int& aOptions, std::string& aRtc,
        std::wstring& aApplicationArguments, std::wstring& aRuntimeArguments)
{
    if (aMessage.getMessageId() == RTC_MSG_ID_LAUNCH_APPLICATION_REQ)
    {
        aMessage >> aUid >> aType >> aOptions >> aRtc;
        aMessage >> aApplicationArguments >> aRuntimeArguments;

        LOG4(EJavaCaptain, EInfoHeavyLoad,
             "RTC_MSG_ID_LAUNCH_APPLICATION_REQ (uid=%S, rtc=%s, type=%d, options=%d) decoded",
             aUid.toString().c_str(), aRtc.c_str(), aType, aOptions);
    }
    else
    {
        ELOG2(EJavaCaptain, "wrong MessageId!: %d should be %d",
              aMessage.getMessageId(), RTC_MSG_ID_LAUNCH_APPLICATION_REQ);
    }
}

// Terminate application request
inline void setTerminateApplicationReqParams(CommsMessage& aMessage,
        const Uid& aUid, const int& aOptions)
{
    aMessage.setModuleId(PLUGIN_ID_RTC_C);
    aMessage.setMessageId(RTC_MSG_ID_TERMINATE_APPLICATION_REQ);
    aMessage << aUid << aOptions;
    LOG2(EJavaCaptain, EInfoHeavyLoad,
         "RTC_MSG_ID_TERMINATE_APPLICATION_REQ (uid=%S, options=%d) encoded",
         aUid.toString().c_str(), aOptions);
}
inline void getTerminateApplicationReqParams(CommsMessage& aMessage,
        Uid& aUid, int& aOptions)
{
    if (aMessage.getMessageId() == RTC_MSG_ID_TERMINATE_APPLICATION_REQ)
    {
        aMessage >> aUid >> aOptions;
        LOG2(EJavaCaptain, EInfoHeavyLoad,
             "RTC_MSG_ID_TERMINATE_APPLICATION_REQ (uid=%S, options=%d) decoded",
             aUid.toString().c_str(), aOptions);
    }
    else
    {
        ELOG2(EJavaCaptain, "wrong MessageId!: %d should be %d",
              aMessage.getMessageId(), RTC_MSG_ID_TERMINATE_APPLICATION_REQ);
    }
}

// Application running indication
inline void setApplicationRunningIndParams(CommsMessage& aMessage,
        const Uid& aUid, const int& aStatus, const int& aPid = 0)
{
    aMessage.setModuleId(PLUGIN_ID_RTC_C);
    aMessage.setMessageId(RTC_MSG_ID_APPLICATION_RUNNING_IND);
    aMessage << aUid << aStatus << aPid;
    LOG3(EJavaCaptain, EInfoHeavyLoad,
         "RTC_MSG_ID_APPLICATION_RUNNING_IND (uid=%S, status=%d, pid=%d) encoded",
         aUid.toString().c_str(), aStatus, aPid);
}
inline void getApplicationRunningIndParams(CommsMessage& aMessage,
        Uid& aUid, int& aStatus)
{
    if (aMessage.getMessageId() == RTC_MSG_ID_APPLICATION_RUNNING_IND)
    {
        aMessage >> aUid >> aStatus;
        LOG2(EJavaCaptain, EInfoHeavyLoad,
             "RTC_MSG_ID_APPLICATION_RUNNING_IND (uid=%S, status=%d) decoded",
             aUid.toString().c_str(), aStatus);
    }
    else
    {
        ELOG2(EJavaCaptain, "wrong MessageId!: %d should be %d",
              aMessage.getMessageId(), RTC_MSG_ID_APPLICATION_RUNNING_IND);
    }
}

// Application terminated indication
inline void setApplicationTerminatedIndParams(CommsMessage& aMessage,
        const Uid& aUid, const int& aStatus)
{
    aMessage.setModuleId(PLUGIN_ID_RTC_C);
    aMessage.setMessageId(RTC_MSG_ID_APPLICATION_TERMINATED_IND);
    aMessage << aUid << aStatus;
    LOG2(EJavaCaptain, EInfoHeavyLoad,
         "RTC_MSG_ID_APPLICATION_TERMINATED_IND (uid=%S, status=%d) encoded",
         aUid.toString().c_str(), aStatus);
}
inline void getApplicationTerminatedIndParams(CommsMessage& aMessage,
        Uid& aUid, int& aStatus)
{
    if (aMessage.getMessageId() == RTC_MSG_ID_APPLICATION_TERMINATED_IND)
    {
        aMessage >> aUid >> aStatus;
        LOG2(EJavaCaptain, EInfoHeavyLoad,
             "RTC_MSG_ID_APPLICATION_TERMINATED_IND (uid=%S, status=%d) decoded",
             aUid.toString().c_str(), aStatus);
    }
    else
    {
        ELOG2(EJavaCaptain, "wrong MessageId!: %d should be %d",
              aMessage.getMessageId(), RTC_MSG_ID_APPLICATION_TERMINATED_IND);
    }
}

// Indication of adding a new push listener to already running MIDlet
inline void setUpdatePushReqParams(CommsMessage& aMessage, const Uid& aUid)
{
    aMessage.setModuleId(PLUGIN_ID_RTC_PUSH_C);
    aMessage.setMessageId(RTC_MSG_ID_ADD_PUSH_CONNECTION_IND);
    aMessage << aUid;
}

inline void getUpdatePushReqParams(CommsMessage& aMessage, Uid& aUid)
{
    if (aMessage.getMessageId() == RTC_MSG_ID_ADD_PUSH_CONNECTION_IND)
    {
        aMessage >> aUid;
    }
    else
    {
        ELOG2(EJavaCaptain, "wrong MessageId!: %d should be %d",
              aMessage.getMessageId(), RTC_MSG_ID_ADD_PUSH_CONNECTION_IND);
    }
}

inline void setSetExtraArguments(CommsMessage& aMessage,
                                 const std::wstring& aRuntimeArguments,
                                 const std::wstring& aApplicationArguments)
{
    aMessage.setModuleId(PLUGIN_ID_RTC_C);
    aMessage.setMessageId(RTC_MSG_ID_SET_EXTRA_ARGUMENTS);

    aMessage << aRuntimeArguments << aApplicationArguments;
}

inline void getSetExtraArguments(CommsMessage& aMessage,
                                 std::wstring& aRuntimeArguments,
                                 std::wstring& aApplicationArguments)
{
    if (aMessage.getMessageId() == RTC_MSG_ID_SET_EXTRA_ARGUMENTS)
    {
        aMessage >> aRuntimeArguments >> aApplicationArguments;
    }
    else
    {
        ELOG2(EJavaCaptain, "wrong MessageId!: %d should be %d",
              aMessage.getMessageId(), RTC_MSG_ID_SET_EXTRA_ARGUMENTS);
    }
}

inline void setGetExtraArguments(CommsMessage& aMessage)
{
    aMessage.setModuleId(PLUGIN_ID_RTC_C);
    aMessage.setMessageId(RTC_MSG_ID_GET_EXTRA_ARGUMENTS);
}

// Not needed (yet) ; inline void getGetRuntimeAttributes()

inline void setGetExtraArgumentsAck(CommsMessage& aMessage,
                                    const std::wstring& aRuntimeArguments,
                                    const std::wstring& aApplicationArguments)
{
    aMessage.setModuleId(PLUGIN_ID_RTC_C);
    aMessage.setMessageId(RTC_MSG_ID_GET_EXTRA_ARGUMENTS_ACK);

    aMessage << aRuntimeArguments << aApplicationArguments;
}

inline void getGetExtraArgumentsAck(CommsMessage& aMessage,
                                    std::wstring& aRuntimeArguments,
                                    std::wstring& aApplicationArguments)
{
    if (aMessage.getMessageId() == RTC_MSG_ID_GET_EXTRA_ARGUMENTS_ACK)
    {
        aMessage >> aRuntimeArguments >> aApplicationArguments;
    }
    else
    {
        ELOG2(EJavaCaptain, "wrong MessageId!: %d should be %d",
              aMessage.getMessageId(), RTC_MSG_ID_GET_EXTRA_ARGUMENTS_ACK);
    }
}

} // namespace captain
} // namespace java

#endif // RTCMESSAGES_H