/*

* Copyright (c) 2007 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:  MRUI alarm info handler object implementation

*

*/

//<cmail>

#include "emailtrace.h"

#include "cesmralarminfohandler.h"

#include "esmrdef.h"

//</cmail>

#include "mesmrmeetingrequestentry.h"

#include <coemain.h>

#include <barsread.h>

#include <barsc.h>

#include <calentry.h>

#include <calalarm.h>

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

// ESMRAlarmInfo module literal definition

_LIT( KTESMRAlarmInfoPanicTxt, "ESMRAlarmInfo" );

/** ESMRAlarmInfo panic code definitions */

enum TESMRAlarmInfoPanic

    {

    // Coe environment does not exist

    EESMRAlarmInfoCoeNotExist

    };

void Panic( TESMRAlarmInfoPanic aPanic )

    {

    User::Panic( KTESMRAlarmInfoPanicTxt, aPanic );

    }

#endif

// Definition for no alarm

const TInt KNoAlarm( -1 );

/**

 * Compares two alarm info objects.

 *

 * @param aLhs Left hand side alarm info object.

 * @param aRhs Right hand side alarm info object.

 * @return ETrue if objects matches by iRelativeAlarmInSeconds member.

 */

TBool CompareByAlarmTime(

        const TESMRAlarmInfo& aLhs,

        const TESMRAlarmInfo& aRhs )

    {

    if ( aLhs.iRelativeAlarmInSeconds == aRhs.iRelativeAlarmInSeconds )

        {

        return ETrue;

        }

    return EFalse;

    }

}  // namespace

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CESMRRecurrenceInfoHandler::CESMRAlarmInfoHandler

// ---------------------------------------------------------------------------

//

inline CESMRAlarmInfoHandler::CESMRAlarmInfoHandler()

    {

    FUNC_LOG;

    // No implementation yet

    }

// ---------------------------------------------------------------------------

// CESMRAlarmInfoHandler::~CESMRAlarmInfoHandler

// ---------------------------------------------------------------------------

//

EXPORT_C CESMRAlarmInfoHandler::~CESMRAlarmInfoHandler()

    {

    FUNC_LOG;

    iAlarmInfos.Reset();

    iAlarmInfos.Close();

    }

// ---------------------------------------------------------------------------

// CESMRAlarmInfoHandler::NewL

// ---------------------------------------------------------------------------

//

EXPORT_C CESMRAlarmInfoHandler* CESMRAlarmInfoHandler::NewL()

    {

    FUNC_LOG;

    CESMRAlarmInfoHandler* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CESMRAlarmInfoHandler::NewLC

// ---------------------------------------------------------------------------

//

EXPORT_C CESMRAlarmInfoHandler* CESMRAlarmInfoHandler::NewLC()

    {

    FUNC_LOG;

    CESMRAlarmInfoHandler* self =

            new (ELeave) CESMRAlarmInfoHandler();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// CESMRAlarmInfoHandler::ConstructL

// ---------------------------------------------------------------------------

//

void CESMRAlarmInfoHandler::ConstructL()

    {

    FUNC_LOG;

    // No implementation yet

    }

// ---------------------------------------------------------------------------

// CESMRAlarmInfoHandler::ReadFromResourceL

// ---------------------------------------------------------------------------

//

EXPORT_C void CESMRAlarmInfoHandler::ReadFromResourceL(

        const TDesC& aResourceFile,

        TInt aResouceId )

    {

    FUNC_LOG;

    iAlarmInfos.Reset();

    TFileName resourceFileName(aResourceFile);

    CCoeEnv* coeEnv = CCoeEnv::Static();

    __ASSERT_DEBUG( coeEnv, Panic(EESMRAlarmInfoCoeNotExist) );

    RResourceFile alarmInfoResourceFile;

    alarmInfoResourceFile.OpenL(

            coeEnv->FsSession(),

            resourceFileName);

    CleanupClosePushL( alarmInfoResourceFile );

    alarmInfoResourceFile.ConfirmSignatureL();

    HBufC8* resourceIdBuffer =

            alarmInfoResourceFile.AllocReadLC( aResouceId );

    // Construct resource reader

    TResourceReader reader;

    reader.SetBuffer(resourceIdBuffer);

    TInt alarmInfoCount( reader.ReadInt16() );

    for (TInt i(0); i < alarmInfoCount; ++i )

        {

        TESMRAlarmInfo alarmInfo;

        alarmInfo.iAlarmIdValue =

                static_cast<TESMRAlarmValue>( reader.ReadInt16() );

        alarmInfo.iRelativeAlarmInSeconds = reader.ReadInt32();

        User::LeaveIfError( iAlarmInfos.Append( alarmInfo) );

        }

    CleanupStack::PopAndDestroy( resourceIdBuffer );

    CleanupStack::PopAndDestroy( &alarmInfoResourceFile );

    coeEnv = NULL;

    }

// ---------------------------------------------------------------------------

// CESMRAlarmInfoHandler::GetAlarmInfoObjectL

// ---------------------------------------------------------------------------

//

EXPORT_C void CESMRAlarmInfoHandler::GetAlarmInfoObjectL(

        const CCalEntry& aEntry,

        TESMRAlarmInfo& aAlarmInfo )

    {

    FUNC_LOG;

    TESMRAlarmInfo alarmInfo;

    alarmInfo.iRelativeAlarmInSeconds = KNoAlarm;

    // Ownership transferred to us

    CCalAlarm* alarm = aEntry.AlarmL();

    CleanupStack::PushL( alarm );

    if ( alarm )

        {

        alarmInfo.iRelativeAlarmInSeconds =

            alarm->TimeOffset().Int();

        }

    CleanupStack::PopAndDestroy( alarm );

    TInt pos( iAlarmInfos.Find(alarmInfo, CompareByAlarmTime) );

    if ( KErrNotFound != pos )

        {

        aAlarmInfo = iAlarmInfos[pos];

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

// ---------------------------------------------------------------------------

// CESMRAlarmInfoHandler::GetAbsoluteAlarmTimeL

// ---------------------------------------------------------------------------

//

EXPORT_C void CESMRAlarmInfoHandler::GetAbsoluteAlarmTimeL(

        CCalEntry& aEntry,

        TTime& aAbsoluteAlarmTime )

    {

    FUNC_LOG;

    // Ownership transferred to us

    CCalAlarm* alarm = aEntry.AlarmL();

    if ( !alarm )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PushL( alarm );

    aAbsoluteAlarmTime =

            aEntry.StartTimeL().TimeLocalL() - alarm->TimeOffset();

    CleanupStack::PopAndDestroy( alarm );

    }

// EOF