/*

* 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 <limits.h>

#include "pushalarmhandler.h"

#include "pushdbhandler.h"

#include "logger.h"

#include "pushexception.h"

#include "pusherrorcodes.h"

#include "coreinterface.h"

#include "rtcinterface.h"

#include "pushtimerutils.h"

#include "pushconstant.h"

#include "javauid.h"

#include "javacommonutils.h"

using namespace java::push;

using namespace java::captain;

using namespace java::comms;

using namespace java::util;

using namespace std;

/**

 *

 */

PushAlarmHandler::PushAlarmHandler(java::captain::CoreInterface& aCore,

                                   PushAlarmUtilsInterface& aLaunchInstance,

                                   PushDBHandler& aDbHandler)

        : mCore(aCore),mPushDbHandler(aDbHandler),mPushTimer(NULL),mUtilsInstance(aLaunchInstance)

{

    JELOG2(EJavaPush);

    mPushTimer.reset(new PushTimerContainer(*aCore.getTimerServer(),*this));

}

/**

 *

 */

PushAlarmHandler::~PushAlarmHandler()

{

    JELOG2(EJavaPush);

    mNotLaunchedExpiredAlarms.clear();

}

/**

 *

 */

void PushAlarmHandler::readAndStartAlarms()

{

    JELOG2(EJavaPush);

    Uid emptyUid;

    readAndStartAlarms(emptyUid);

}

/**

 *

 */

void PushAlarmHandler::readAndStartAlarms(const Uid& aUid)

{

    JELOG2(EJavaPush);

    LOG1WSTR(EJavaPush,EInfo,"readAndStartAlarms(): Uid: %s",aUid.toString());

    try

    {

        std::list<DbAlarmData> alarms;

        mPushDbHandler.getAlarms(aUid,alarms);

        if (0 == alarms.size())

            return;

        mPushTimer->setAlarmTimers(alarms);

        alarms.clear();

    }

    catch (...)

    {

        ELOG(EJavaPush,"ERROR!!! Exception caught in the PushAlarmHandler::readAndStartAlarms()");

    }

}

/**

 *

 */

long long PushAlarmHandler::setAlarm(const Uid& aUid,const long long& aAlarmTimeInMilliSecs,

                                     bool aIsUidOfThisMidlet)

{

    JELOG2(EJavaPush);

    LOG1WSTR(EJavaPush,EInfo, "setAlarm() aUid: %s",aUid.toString());

    long long curTimeInMilliSecs = mPushTimer->getCurrentTime();

    long long curTimeInMilliSecsPlusSomeExtra =

        curTimeInMilliSecs + NO_NEED_TO_INITIALZE_TIMER_TIME_IN_MILLI_SECS;

    long long currentWakeUpTime = mPushTimer->getAlarmTime(aUid);

    //Alarm can be first deleted from the Storage and cancelled.

    if (0LL != currentWakeUpTime)

    {

        cancelAlarm(aUid);

        deleteAlarm(aUid);

    }

    if (aAlarmTimeInMilliSecs < curTimeInMilliSecsPlusSomeExtra)

    {

        LOG1(EJavaPush,EInfo,"aAlarmTimeInMilliSecs %lld",aAlarmTimeInMilliSecs);

        LOG1(EJavaPush,EInfo,"curTimeInMilliSecsPlusSomeExtra %lld",curTimeInMilliSecsPlusSomeExtra);

        //We can return 0 in the case wherein MIDlet registers alarm to itself and alarm is max.

        //'current time + 1'.

        if (false == aIsUidOfThisMidlet)

            handleLessOrEqualCurrentTimeOfOtherMidlet(curTimeInMilliSecs,aAlarmTimeInMilliSecs,aUid);

        //Zero is returned if alarm time has passed.

        if (curTimeInMilliSecs < aAlarmTimeInMilliSecs)

        {

            LOG(EJavaPush,EInfo,"Returns 0");

            return 0LL;

        }

        LOG(EJavaPush,EInfo,"Returns currentWakeUpTime");

        return currentWakeUpTime;

    }

    LOG(EJavaPush,EInfo,"Setting alarm");

    std::list<DbAlarmData> validAlarms;

    DbAlarmData newAlaramDataObj(aUid,aAlarmTimeInMilliSecs,false);

    validAlarms.push_back(newAlaramDataObj);

    mPushTimer->setAlarmTimers(validAlarms);

    validAlarms.clear();

    try

    {

        mPushDbHandler.storeAlarm(aUid,aAlarmTimeInMilliSecs);

    }

    catch (...)

    {

        cancelAlarm(aUid);

        throw;

    }

    return currentWakeUpTime;

}

/**

 *

 */

void PushAlarmHandler::handleLessOrEqualCurrentTimeOfOtherMidlet

(const long long& aCurTimeInMilliSecs,const long long& aAlarmTimeInMilliSecs,

 const Uid& aUid)

{

    JELOG2(EJavaPush);

    JavaTime currentTimeObj(aCurTimeInMilliSecs);

    JavaTime alarmTimeObj(aAlarmTimeInMilliSecs);

    //In this case alarm time is older than two weeks so MIDlet is not launched.

    bool flag = PushTimerUtils::isTimeOlderThanTwoWeeks(mPushTimer->getTimerServerInterface(),

                currentTimeObj,alarmTimeObj);

    if (true == flag)

        return;

    //In this case alarm time is less than 'currentTime + NO_NEED_TO_INITIALZE_TIMER_TIME_IN_MILLI_SECS'

    //or less than two weeks old so MIDlet is launched.

    timerExpired(aUid,aAlarmTimeInMilliSecs,false);

}

/**

 *

 */

void PushAlarmHandler::cancelAlarm(const java::util::Uid& aUid)

{

    JELOG2(EJavaPush);

    mPushTimer->cancelAlarm(aUid);

}

/**

 *

 */

void PushAlarmHandler::handleDriveWasMissingMidlets(const unsigned int aMediaId)

{

    JELOG2(EJavaPush);

    list<Uid> handledUidsList;

    uidAlarmTimeContainerIter_t iter = mNotLaunchedExpiredAlarms.begin();

    for (; iter != mNotLaunchedExpiredAlarms.end(); ++iter)

    {

        int mediaId = mUtilsInstance.getMediaIdByMidletUid(iter->first);

        if (mediaId == aMediaId)

        {

            handledUidsList.push_back(iter->first);

            TimerServerInterface* timerInterface = mCore.getTimerServer();

            JavaTime currentTime;

            timerInterface->getCurrentJavaTime(currentTime);

            JavaTime alarmTime(iter->second);

            bool flag = PushTimerUtils::isTimeOlderThanTwoWeeks(*timerInterface,

                        currentTime,alarmTime);

            if (true == flag)

            {

                deleteAlarm(iter->first);

            }

            else

            {

                //Now we know that alarm is less than current time but not

                //older than two weeks so MIDlet can be launched.

                timerExpired(iter->first,iter->second);

            }

        }//end if(mediaId == aMediaId)

    }//end for

    //Removing handled Uids from mNotLaunchedExpiredAlarms container.

    list<Uid>::iterator iter2 = handledUidsList.begin();

    for (; iter2 != handledUidsList.end(); ++iter2)

    {

        uidAlarmTimeContainerIter_t iter = mNotLaunchedExpiredAlarms.find((*iter2));

        if (iter != mNotLaunchedExpiredAlarms.end())

            mNotLaunchedExpiredAlarms.erase(iter);

    }

    handledUidsList.clear();

}

/**

 *

 */

void PushAlarmHandler::timerExpired(const Uid& aUid,const long long& aAlarmTime)

{

    timerExpired(aUid,aAlarmTime,true);

}

/**

 *

 */

void PushAlarmHandler::timerExpired(const Uid& aUid,const long long& aAlarmTime,

                                    bool aDeleteAlarmFromDb)

{

    JELOG2(EJavaPush);

    LOG1WSTR(EJavaPush,EInfo,"timerExpired(), Uid: %s",aUid.toString());

    bool driveAvailable =

        mUtilsInstance.launchMidlet(aUid,java::captain::RTC_LAUNCH_TYPE_AUTO_INVOCATION_C);

    if ((true == driveAvailable) && (true == aDeleteAlarmFromDb))

    {

        deleteAlarm(aUid);

    }

    else

    {

        mNotLaunchedExpiredAlarms.insert(std::pair<Uid,long long>(aUid,aAlarmTime));

    }

}

/**

 *

 */

void PushAlarmHandler::deleteAlarm(const java::util::Uid& aUid)

{

    JELOG2(EJavaPush);

    //Removing alarm from the db and internal "drive was not available when alarm expired"

    //list if uid exists in this list.

    try

    {

        mPushDbHandler.deleteAlarm(aUid);

    }

    catch (...)

    {

        //Exceptions are ignored in this case.

        ELOG(EJavaPush, "ERROR!!! Unexpected error occurred in the deletion of the alarm from the db");

    }

}