/*
* 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:  This is the source file for the CClkUiAlarmModel class.
*
*/

// System includes
#include <asclisession.h>
#include <almconst.h>
#include <wakeupalarm.h>

// User includes
#include "clkuimdlbase.h"
#include "clkuialarmmodel.h"
#include "clkuialarmlistener.h"

// Constants

// Literals

// ---------------------------------------------------------
// CClkUiAlarmModel::NewL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C CClkUiAlarmModel* CClkUiAlarmModel::NewL( MClkModelObserver* aObserver,
                                                   TInt aListenerPriority )
    {
    CClkUiAlarmModel *self = new( ELeave ) CClkUiAlarmModel;
    
    CleanupStack::PushL( self );
    self->ConstructL( aObserver, aListenerPriority );
    CleanupStack::Pop( self );
    
    return self;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::~CClkUiAlarmModel
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C CClkUiAlarmModel::~CClkUiAlarmModel()
    {
    // Stop the listener first and close the session with alarm server.
    Stop();
    iAlarmSrvSes.Close();
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ProcessListenerL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClkUiAlarmModel::ProcessListenerL( TInt aStatus )
    {
    if( ( KErrNone != aStatus ) &&
        ( KErrCancel != aStatus ) )
        {
        NotifyL( aStatus );
        }
    else
        {
        NotifyL( KErrNone );
        }
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::GetClkAlarmIds
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C void CClkUiAlarmModel::GetClkAlarmIds( RArray< TAlarmId >& aAlarmIds )
    {
    // Return the alarm ids of category clock.
    TRAP_IGNORE( iAlarmSrvSes.GetAlarmIdListForCategoryL( KAlarmClockOne, aAlarmIds ) );
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::DeleteClockAlarm
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TInt CClkUiAlarmModel::DeleteClockAlarm( TAlarmId aAlarmId )
    {
    // Pass the request to the server.
    TInt errorVal = iAlarmSrvSes.AlarmDelete( aAlarmId );
    
    return errorVal;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::StopClockAlarm
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TInt CClkUiAlarmModel::AlarmRemoveSnooze ( TAlarmId aAlarmId )
    {

    TInt returnVal( KErrNone );
    SClkAlarmInfo alarmInfo;
    returnVal = ClockAlarmInfo( aAlarmId, alarmInfo);
    if ( returnVal != KErrNone )
        {
        return returnVal;
        }
    returnVal = iAlarmSrvSes.AlarmDelete( aAlarmId );
    if ( returnVal != KErrNone )
        {
        return returnVal;
        }
    alarmInfo.iState = EAlarmStateInPreparation;
    alarmInfo.iAlarmTime = alarmInfo.iOrigExpiryTime;
    return ClockAlarmSet( alarmInfo );    
    
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ClockAlarmEnable
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TInt CClkUiAlarmModel::ClockAlarmEnable( TAlarmId aAlarmId, TAlarmStatus aStatus )
    {
    TInt returnVal( KErrNone );
    
    // If the alarm is enabled, we first disable it and then enable it.
    if( EAlarmStatusEnabled == aStatus )
        {
        returnVal = iAlarmSrvSes.SetAlarmStatus( aAlarmId, EAlarmStatusDisabled );
        
        if( KErrNone == returnVal )
            {
            returnVal = iAlarmSrvSes.SetAlarmStatus( aAlarmId, aStatus );
            }
        }
    // If the request is to disable the alarm, we just do the same.
    else
        {
        returnVal = iAlarmSrvSes.SetAlarmStatus( aAlarmId, aStatus );
        }
    
    return returnVal;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ClockAlarmStatus
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TAlarmStatus CClkUiAlarmModel::ClockAlarmStatus( TAlarmId aAlarmId ) const
    {
    TAlarmStatus alarmStatus;
    
    // Pass the request to the server.
    iAlarmSrvSes.GetAlarmStatus( aAlarmId, alarmStatus );
    
    return alarmStatus;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ClockAlarmType
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TInt CClkUiAlarmModel::ClockAlarmType( TAlarmCategory& aCategory, TAlarmId aAlarmId ) const
    {
    return ( iAlarmSrvSes.GetAlarmCategory( aAlarmId, aCategory ) );
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ClockAlarmSet
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TInt CClkUiAlarmModel::ClockAlarmSet( const SClkAlarmInfo& aAlarmInfo )
    {
    TASShdAlarm newAlarm;
    
    // Build the alarm properties from the info provided.
    newAlarm.Category()           = KAlarmClockOne;
    newAlarm.Message()            = aAlarmInfo.iMessage;
    newAlarm.OriginalExpiryTime() = aAlarmInfo.iAlarmTime;
    newAlarm.RepeatDefinition()   = aAlarmInfo.iRepeat;
    newAlarm.SoundName()          = aAlarmInfo.iSound;
    newAlarm.NextDueTime()        = aAlarmInfo.iAlarmTime;
    
	// SSM related change.
#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT  
    newAlarm.SetWakeup( ETrue );
#else
    newAlarm.ClientFlags().Set( KWakeupAlarmFlagIndex );
#endif
    
    TInt returnVal = iAlarmSrvSes.AlarmAdd( newAlarm );
    
    if( KErrNone == returnVal )
        {
        iAlarmObject = newAlarm;
        iAlarmId = newAlarm.Id();
        }
    
    return returnVal;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ClockAlarmInfo
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TInt CClkUiAlarmModel::ClockAlarmInfo( TAlarmId aAlarmId, SClkAlarmInfo& aAlarmInfo ) const
    {
    TASShdAlarm tempAlarm;
    
    if( !aAlarmId )
        {
        aAlarmInfo.iState = EAlarmStateInPreparation;
        aAlarmInfo.iStatus = EAlarmStatusDisabled;
        
        return KErrNone;
        }
    
    TInt returnVal = iAlarmSrvSes.GetAlarmDetails( aAlarmId, tempAlarm );
    
    if( KErrNone == returnVal )
        {
        aAlarmInfo.iAlarmTime = tempAlarm.NextDueTime();
        aAlarmInfo.iMessage = tempAlarm.Message();
        aAlarmInfo.iOrigExpiryTime = tempAlarm.OriginalExpiryTime();
        aAlarmInfo.iRepeat = tempAlarm.RepeatDefinition();
        aAlarmInfo.iSound = tempAlarm.SoundName();
        aAlarmInfo.iState = tempAlarm.State();
        aAlarmInfo.iStatus = tempAlarm.Status();
        iAlarmSrvSes.GetAlarmCategory( aAlarmId, aAlarmInfo.iCategory );
        }
    
    return returnVal;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ClockAlarmInfo
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C const TAlarmId& CClkUiAlarmModel::AlarmId()
    {
    return iAlarmId;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::SaveLatestAlarmId
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C void CClkUiAlarmModel::SaveLatestAlarmId( TAlarmId aAlarmId )
    {
    iAlarmId = aAlarmId;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ClockAlarmInfo
// rest of the details are commented in the header
// ---------------------------------------------------------
//
EXPORT_C TBool CClkUiAlarmModel::GetAlarmQueuedOrSnoozedId( TAlarmId& aAlarmId, TBool aUpdatedId )
    {
    TBool alarmQueued( EFalse );
    RArray< TAlarmId > alarmIds;

    TRAP_IGNORE( iAlarmSrvSes.GetAlarmIdListForCategoryL( KAlarmClockOne, alarmIds ) );

    TInt alarmCount( alarmIds.Count() );
    for( TInt alarmIndex( KZerothIndex ); alarmIndex < alarmCount; alarmIndex++ )
        {
        const TAlarmId alarmId = alarmIds[ alarmIndex ];
        TAlarmStatus alarmStatus;
        TASShdAlarm tempAlarm;

        // First get the alarm details.
        TInt errorVal = iAlarmSrvSes.GetAlarmDetails( alarmId, tempAlarm );
        // Then the status.
        errorVal = iAlarmSrvSes.GetAlarmStatus( alarmId, alarmStatus );

        // If the alarm status is enabled and the alarm is in either queued or snoozed state.
        // The alarm ids we have received will be sorted based on the expiry time.
        if( ( KErrNone == errorVal ) &&
            ( EAlarmStatusEnabled == tempAlarm.Status() ) &&
            ( EAlarmStateQueued == tempAlarm.State() || 
              EAlarmStateSnoozed == tempAlarm.State() ) )
            {
            // The queued alarm is found.
            aAlarmId = alarmId;
            alarmQueued = ETrue;

            if( aUpdatedId )
                {
                iAlarmId = alarmId;
                }
            break;
            }
        }

    alarmIds.Close();

    if( aUpdatedId && !alarmQueued )
        {
        iAlarmId = KZerothIndex;
        }

    return alarmQueued;
    }

// ---------------------------------------------------------
// CClkUiAlarmModel::ConstructL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClkUiAlarmModel::ConstructL( MClkModelObserver* aObserver,
                                   TInt aListenerPriority )
    {
    // First Set the observer.
    SetModelObserver( aObserver );
    
    // Connect to the alarm server.
    User::LeaveIfError( iAlarmSrvSes.Connect() );
    
    // Construct the listener and make it active.
    CClkUiMdlAlarmListener* alarmListener = new( ELeave ) CClkUiMdlAlarmListener( iAlarmSrvSes,
                                                                                  *this,
                                                                                  aListenerPriority );
    SetListenerActive( alarmListener );
    
    // Get the latest alarm and store it.
    TAlarmId latestAlarm;
    GetAlarmQueuedOrSnoozedId( latestAlarm, ETrue );    
    }

// End of file