/*

* 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:

*

*/

#include <list>

#include <memory>

#include <string>

#include <time.h>

#include "pushregistryhandler.h"

#include "coreinterface.h"

#include "rtcinterface.h"

#include "commsendpoint.h"

#include "commsmessage.h"

#include "pushregistrymessages.h"

#include "javacommonutils.h"

#include "logger.h"

#include "pushconstant.h"

#include "pushexception.h"

#include "pusherrorcodes.h"

#include "pushdbhandler.h"

#include "pushdatacontainer.h"

#include "pushalarmhandler.h"

#include "javauid.h"

#include "booteventprovidermessages.h"

#include "mmceventprovidermessages.h"

using namespace java::push;

using namespace java::captain;

using namespace java::comms;

using namespace java::util;

using namespace java::fileutils;

using namespace std;

/*extern "C"*/

#ifdef __SYMBIAN32__

ExtensionPluginInterface* getExtensionPlugin()

{

#else

extern "C" ExtensionPluginInterface* getExtensionPlugin()

{

#endif

    return new PushRegistryHandler();

}

/**

 *

 */

OS_EXPORT PushRegistryHandler::PushRegistryHandler()

        :mCore(NULL),mPushDbHandler(new PushDBHandler()),mPushDataContainer(NULL),

        mPushAlarmHandler(NULL),mConnCompletedTimerContainer(NULL)

{

    JELOG2(EJavaPush);

    //LOG1(EJavaPush,EInfo,"PushRegistryHandler(), this: %d",this);

}

/**

 *

 */

OS_EXPORT PushRegistryHandler::~PushRegistryHandler()

{

    JELOG2(EJavaPush);

    mDriveInfo.clear();

    //LOG1(EJavaPush,EInfo,"~PushRegistryHandler(), this: %d",this);

}

/**

 *

 */

void PushRegistryHandler::startPlugin(java::captain::CoreInterface* aCore)

{

    JELOG2(EJavaPush);

    try

    {

        mCore = aCore;

        mCore->getComms()->registerListener(PLUGIN_ID_PUSH_REGISTRY_C,this);

        mPushDataContainer.reset(new PushDataContainer(*mCore,*mPushDbHandler));

        mPushAlarmHandler.reset(new PushAlarmHandler(*mCore,*this,*mPushDbHandler));

        mConnCompletedTimerContainer.reset

        (new PushConnCompletedTimerContainer(*aCore->getTimerServer(),*this));

    }

    catch (...)

    {

        ELOG(EJavaPush,"ERROR!!! Exception caught in the PushRegistryHandler::start() operation");

    }

}

/**

 *

 */

void PushRegistryHandler::stopPlugin()

{

    JELOG2(EJavaPush);

    mCore->getComms()->unregisterListener(PLUGIN_ID_PUSH_REGISTRY_C,this);

}

/**

 *

 */

ApplicationRuntimeEventsInterface* PushRegistryHandler::getApplicationRuntimeListener()

{

    return this;

}

/**

 *

 */

ApplicationManagementEventsInterface* PushRegistryHandler::getApplicationManagementListener()

{

    return this;

}

/**

 *

 */

EventConsumerInterface* PushRegistryHandler::getEventConsumer()

{

    return this;

}

/**

 *

 */

void PushRegistryHandler::processMessage(CommsMessage& aMessage)

{

    JELOG2(EJavaPush);

    switch (aMessage.getMessageId())

    {

    case IPC_PR_GET_ALL_PUSH_REGS:

    {

        handleGetAllPushRegsMsg(aMessage);

        break;

    }

    case IPC_PR_REGISTER_DYNAMIC_PUSH_CONN:

    {

        handleRegDynamicPushConnMsg(aMessage);

        break;

    }

    case IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN:

    {

        handleUnregDynamicPushConnMsg(aMessage);

        break;

    }

    case IPC_PR_REGISTER_ALARM:

    {

        handleRegisterAlarmMsg(aMessage);

        break;

    }

    case IPC_PR_ALL_CONNS_FAILED:

    {

        handleAllConnsFailedMsg(aMessage);

        break;

    }

    case IPC_PR_PENDING_STATUS:

    {

        handlePendingStatusMsg(aMessage);

        break;

    }

    case IPC_PR_LIST_CONNECTIONS:

    {

        handleListConnectionsMsg(aMessage);

        break;

    }

    case IPC_PR_DATA_OF_PUSH_CONN_QUERY:

    {

        handleDataOfPushConnQueryMsg(aMessage);

        break;

    }

    case IPC_PR_PUSH_URI_STARTS_WITH_QUERY:

    {

        handlePushUriStartsWithQueryMsg(aMessage);

        break;

    }

    case IPC_PR_CONN_COMPLETED:

    {

        handleConnCompletedMsg(aMessage);

        break;

    }

    default:

        ELOG1(EJavaPush, "ERROR!!! Unsupported method arrives to processMessage(): %d",

              aMessage.getMessageId());

    }//end switch

}

/**

 *

 */

void PushRegistryHandler::arLaunched(const Uid& /*aUID*/, const int& /*aRuntimeCommsAddress*/)

{

    JELOG2(EJavaPush);

    //Launch of the application does not interest push framework.

}

/**

 *

 */

void PushRegistryHandler::arTerminated(const Uid& aUID, const int& aExitCode)

{

    JELOG2(EJavaPush);

    LOG1WSTR(EJavaPush,EInfo,"arTerminated(), Uid: %s",aUID.toString());

    LOG1(EJavaPush,EInfo,"arTerminated(), aExitCode: %d",aExitCode);

    //MIDlet has been terminated so pending status of all its push connections

    //can be set to "not active" state.

    mPushDataContainer->clearPendingStatusesOfMidlet(aUID);

    bool flag = mPushDataContainer->isPushConnections(aUID);

    if (true == flag)

    {

        //aExitCode is non-zero if runtime has crashed. In that case MIDlet

        //is not launched as listening mode.

        if (0 != aExitCode)

        {

            ELOG1(EJavaPush,"ERROR!!! arTerminated(), aExitCode: %d",aExitCode);

            mPushDataContainer->setMidletDoNotLaunchList(aUID);

        }

        if (false == mPushDataContainer->isMidletInDoNotLaunchList(aUID))

        {

            //Launching an application.

            LOG(EJavaPush,EInfo,"arTerminated(), launching application in push mode");

            launchMidlet(aUID,java::captain::RTC_LAUNCH_TYPE_PUSH_C);

        }

    }//end if(true == flag)

}

/**

 *

 */

void PushRegistryHandler::amAdded(const uids_t& aUids)

{

    JELOG2(EJavaPush);

    //JavaCaptain calls this method when new application has been installed or

    //application's uid has been changed in the upgrade.

    for (uids_t::const_iterator iter = aUids.begin(); iter != aUids.end(); ++iter)

    {

        //Alarm case have to be checked in this situation because uid of the alarm might

        //be changed in the upgrade.

        readAppData((*iter),true);

    }//end for

}

/**

 *

 */

void PushRegistryHandler::amUpdated(const uids_t& aUids)

{

    JELOG2(EJavaPush);

    //JavaCaptain calls this operation when application's data has been updated

    //by Installer. In this situation uid of the appplication has not been updated.

    for (uids_t::const_iterator iter = aUids.begin(); iter != aUids.end(); ++iter)

    {

        deleteAppData((*iter),false);

        //Alarm does not have to be checked in this situation because uid of the

        //application has not been changed and Installer has not changed alarm.

        readAppData((*iter),false);

    }

}

/**

 *

 */

void PushRegistryHandler::amDeleted(const uids_t& aUids)

{

    JELOG2(EJavaPush);

    //JavaCaptain calls this method when application has been uninstalled.

    //Note: This is called also in the upgrade of the application if application's

    //uid has been changed.

    for (uids_t::const_iterator iter = aUids.begin(); iter != aUids.end(); ++iter)

    {

        deleteAppData((*iter),true);

    }//end for

}

/**

 *

 */

void PushRegistryHandler::event(const std::string& eventProvider,

                                java::comms::CommsMessage& aMsg)

{

    JELOG2(EJavaPush);

    try

    {

        if (eventProvider == BOOT_EVENT_PROVIDER)

        {

            LOG(EJavaPush, EInfo, "PushRegistryHandler::event() boot event received");

            int bootType = 0;

            getBootMessageParams(aMsg, bootType);

            //Read initial drive status. After that drive info status is updated

            //when mmc is inserted/deleted. JavaCaptain sends MMC_EVENT_PROVIDER event when mmc

            //status changes.

            mDriveInfo.clear();

            DriveUtilities::getAccesibleDrives(mDriveInfo);

            startPushMidlets();

            mPushAlarmHandler->readAndStartAlarms();

        }

        else if (eventProvider == MMC_EVENT_PROVIDER)

        {

            int operation = 0;

            driveInfo di;

            getMmcChangedMessageParams(aMsg, operation, di);

            LOG1(

                EJavaCaptain,

                EInfo,

                "PushRegistryHandler::event() mmc event received (operation=%d)",

                operation);

            switch (operation)

            {

            case DriveListenerInterface::REMOVABLE_MEDIA_INSERTED_C:

                manageDriveInsertion(di);

                break;

            case DriveListenerInterface::REMOVABLE_MEDIA_REMOVED_C:

                manageDriveRemoval(di);

                break;

            }

        }

    }

    catch (ExceptionBase& ex)

    {

        ELOG1(EJavaPush,"ERROR!!! PushRegistryHandler::event(): %s",ex.toString().c_str());

    }

    catch (...)

    {

        ELOG(EJavaPush,"ERROR!!! Exception caught in the PushRegistryHandler::event() operation");

    }

}

/**

 *

 */

void PushRegistryHandler::connCompletedTimerExpired(const java::comms::CommsMessage& aMsg)

{

    JELOG2(EJavaPush);

    try

    {

        CommsMessage unRegCompleted;

        unRegCompleted.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);

        unRegCompleted.setReceiver(aMsg.getSender());

        unRegCompleted.setModuleId(PLUGIN_ID_PUSH_CONTROLLER_C);

        unRegCompleted.setMessageId(IPC_PR_CONN_MANAGED_BY_OTHER_MIDLET);

        int retValue = mCore->getComms()->send(unRegCompleted);

        if (0 != retValue)

        {

            //Exception is not thrown from this situation.

            std::string errTxt("Sending IPC_PR_CONN_MANAGED_BY_OTHER_MIDLET comms request failed: ");

            errTxt.append(java::util::JavaCommonUtils::intToString(retValue));

            ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());

        }

    }

    catch (...)

    {

        ELOG(EJavaPush,

             "ERROR!!! Exception caught in the PushRegistryHandler::connCompletedTimerExpired() operation");

    }

}

/**

 *

 */

void PushRegistryHandler::handleGetAllPushRegsMsg(CommsMessage& aMsg)

{

    JELOG2(EJavaPush);

    Uid uid;

    try

    {

        readUidArg(aMsg,"IPC_PR_GET_ALL_PUSH_REGS",uid);

        std::list<PushRegData> listOfPushRegs;

        mPushDataContainer->getPushRegsOfMidlet(uid,listOfPushRegs);

        CommsMessage listOfPushRegsMsg;

        listOfPushRegsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);

        listOfPushRegsMsg.setReceiver(aMsg.getSender());

        listOfPushRegsMsg.setModuleId(PLUGIN_ID_PUSH_CONTROLLER_C);

        listOfPushRegsMsg.setMessageId(IPC_PR_LIST_OF_ALL_PUSH_REGS);

        listOfPushRegsMsg.setMessageRef(aMsg.getMessageRef());

        listOfPushRegsMsg << uid;

        listOfPushRegsMsg << NO_ERROR;

        listOfPushRegsMsg << "";

        std::list<PushRegData>::iterator iter;

        for (iter = listOfPushRegs.begin(); iter != listOfPushRegs.end(); ++iter)

        {

            LOG1(EJavaPush,EInfo, "handleGetAllPushRegsMsg() URI: %S",iter->mUri.c_str());

            listOfPushRegsMsg << iter->mUri;

            listOfPushRegsMsg << iter->mFilter;

        }//end for

        int retValue = mCore->getComms()->send(listOfPushRegsMsg);

        if (0 != retValue)

        {

            //Exception is not thrown from this situation.

            std::string errTxt("Sending IPC_PR_LIST_OF_ALL_PUSH_REGS comms request failed: ");

            errTxt.append(java::util::JavaCommonUtils::intToString(retValue));

            ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());

        }

    }

    catch (ExceptionBase& ex)

    {

        sendCommsResponseInErrorCase(ex,IPC_PR_LIST_OF_ALL_PUSH_REGS,uid,aMsg.getSender(),

                                     aMsg.getMessageRef());

    }

    catch (...)

    {

        ExceptionBase tmpBase(UNKNOWN_ERROR,"Unknown exception caught",

                              __FILE__,__FUNCTION__,__LINE__);

        sendCommsResponseInErrorCase(tmpBase,IPC_PR_LIST_OF_ALL_PUSH_REGS,uid,aMsg.getSender(),

                                     aMsg.getMessageRef());

    }

}

/**

 *

 */

void PushRegistryHandler::handleRegDynamicPushConnMsg(CommsMessage& aMsg)

{

    JELOG2(EJavaPush);

    Uid uid;

    try

    {

        readUidArg(aMsg,"IPC_PR_REGISTER_DYNAMIC_PUSH_CONN",uid);

        std::wstring pushUri;

        readWStrArg(aMsg,"IPC_PR_REGISTER_DYNAMIC_PUSH_CONN",pushUri);

        std::wstring midletName;

        readWStrArg(aMsg,"IPC_PR_REGISTER_DYNAMIC_PUSH_CONN",midletName);

        std::wstring filter;

        readWStrArg(aMsg,"IPC_PR_REGISTER_DYNAMIC_PUSH_CONN",filter);

        int isUidOfThisMidlet = readIntAsBooleanArg(aMsg,"IPC_PR_REGISTER_DYNAMIC_PUSH_CONN");

        mPushDataContainer->storeDynamicPushRegistration(uid,pushUri,midletName,filter);

        if (0 == isUidOfThisMidlet)

        {

            LOG1WSTR(EJavaPush,EInfo,"handleRegDynamicPushConnMsg() Uid: %s",uid.toString());

            mConnCompletedTimerContainer->setTimer(pushUri,aMsg);

            launchMidlet(uid,java::captain::RTC_LAUNCH_TYPE_PUSH_C);

        }

        sendCommsResponseInSuccessCase(IPC_PR_REGISTER_DYNAMIC_PUSH_CONN_REPLY,uid,aMsg.getSender(),

                                       aMsg.getMessageRef());

    }

    catch (ExceptionBase& ex)

    {

        sendCommsResponseInErrorCase(ex,IPC_PR_REGISTER_DYNAMIC_PUSH_CONN_REPLY,uid,aMsg.getSender(),

                                     aMsg.getMessageRef());

    }

    catch (...)

    {

        ExceptionBase tmpBase(UNKNOWN_ERROR,"Unknown exception caught",

                              __FILE__,__FUNCTION__,__LINE__);

        sendCommsResponseInErrorCase(tmpBase,IPC_PR_REGISTER_DYNAMIC_PUSH_CONN_REPLY,uid,aMsg.getSender(),

                                     aMsg.getMessageRef());

    }

}

/**

 *

 */

void PushRegistryHandler::handleUnregDynamicPushConnMsg(CommsMessage& aMsg)

{

    JELOG2(EJavaPush);

    Uid uid;

    try

    {

        readUidArg(aMsg,"IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN",uid);

        std::wstring pushUri;

        readWStrArg(aMsg,"IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN",pushUri);

        int isUidOfThisMidlet = readIntAsBooleanArg(aMsg,"IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN");

        mPushDataContainer->unregisterDynamicPushRegistration(uid,pushUri);

        if (0 == isUidOfThisMidlet)

        {

            LOG1WSTR(EJavaPush,EInfo,"handleUnregDynamicPushConnMsg() Uid: %s",uid.toString());

            mConnCompletedTimerContainer->setTimer(pushUri,aMsg);

            launchMidlet(uid,java::captain::RTC_LAUNCH_TYPE_PUSH_C);

        }

        sendCommsResponseInSuccessCase(IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN_REPLY,uid,aMsg.getSender(),

                                       aMsg.getMessageRef());

    }

    catch (ExceptionBase& ex)

    {

        sendCommsResponseInErrorCase(ex,IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN_REPLY,uid,aMsg.getSender(),

                                     aMsg.getMessageRef());

    }

    catch (...)

    {

        ExceptionBase tmpBase(UNKNOWN_ERROR,"Unknown exception caught",

                              __FILE__,__FUNCTION__,__LINE__);

        sendCommsResponseInErrorCase(tmpBase,IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN_REPLY,uid,aMsg.getSender(),

                                     aMsg.getMessageRef());

    }

}

/**

 *

 */

void PushRegistryHandler::handleRegisterAlarmMsg(CommsMessage& aMsg)

{