/*

* Copyright (c) 2007-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:   

*

*/

// INCLUDE FILES

#include "alarmutils.h"

#include "AlmAlertVariant.hrh"

#include "pim_trace.h"

#include "AlmAlarmPlayer.h"

#include "AlmAlarmControl.h"

#include "AlmAlarmInfo.h"

#include "AlarmService.h"

#include "alarmremconeventshandler.h"

#ifdef RD_ALMALERT__SENSOR_SUPPORT

#include "alarmcontextfwsupport.h"

#endif // RD_ALMALERT__SENSOR_SUPPORT

#include <almconst.h>

#include <eikenv.h>

#include <AknCapServer.h>

#include <e32property.h>

#include <centralrepository.h>

#include <MProfileEngine.h>

#include <MProfile.h>

#include <MProfileTones.h>

#include <ProfileEngineDomainConstants.h>

#include <sbdefs.h>

#include <coreapplicationuisdomainpskeys.h>

#include <clockdomaincrkeys.h>

#include <CalendarInternalCRKeys.h>

#include <wakeupalarm.h>

#include <calalarm.h> // KUidAgendaModelAlarmCategory - the alarm category id for calendar alarms

#include <AknUtils.h>

#ifndef SYMBIAN_CALENDAR_V2

#include <agmalarm.h> // deprecated, use CalAlarm.h when SYMBIAN_CALENDAR_V2 flag is enabled

#endif // SYMBIAN_CALENDAR_V2

#include <calsession.h>

#include <calentryview.h>

#include <calenlauncher.h>  // for launching calendar entry view

// CONSTANTS AND MACROS

const TInt KAlmAlertMinSnooze( 100 );

const TInt KAlmAlertMaxSnooze( 104 );

const TInt KDefaultSnoozeTime( 5 ); // 5 minutes

const TUint KAlarmAutoHide( 60000000 );  // 60 s

const TUint KAlarmAutoHideCalendar( 30000000 );  // 30 s

const TUint KKeyBlockTime( 500000 );  // 0.5 s

const TUint KShutdownTime( 1500000 ); // 1.5 s

const TUint KAlarmDelayTime( 1000000 ); // 1.0 s

const TUint KInactivityResetInterval( 1000000 ); // 1.0 s

const TInt KMaxProfileVolume( 10 );

const TInt KVolumeRampPeriod( 3000000 );  // 3 seconds

_LIT( KRngMimeType, "application/vnd.nokia.ringing-tone" );

// ==========================================================

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

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

// 

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

//

CAlarmUtils* CAlarmUtils::NewL( CAlmAlarmControl* aAlarmControl,

                                CAknAlarmService* aSupervisor )

    {

    TRACE_ENTRY_POINT;

    CAlarmUtils* self = new( ELeave )CAlarmUtils( aAlarmControl, aSupervisor );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// 

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

//

void CAlarmUtils::ConstructL()

    {

    TRACE_ENTRY_POINT;

    User::LeaveIfError( iApaSession.Connect() );

    iAlarmInfo = new( ELeave )CAlmAlarmInfo( this );

    // we can still work without profile engine

    PIM_TRAPD_ASSERT( iProfileEng = CreateProfileEngineL(); )

    iNotifierDialogController = ((CAknCapServer*)CEikonEnv::Static()->AppServer())->GlobalNoteControllerL();

    iNotifierDialogController->SetNoteObserver( iAlarmControl );

    // create timers

    iShutdownTimer   = CPeriodic::NewL( CActive::EPriorityStandard );

    iAutoSnoozeTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iKeyBlockTimer   = CPeriodic::NewL( CActive::EPriorityStandard );

    iAlarmDelayTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iInactivityResetTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    // set async callback priority so that it finishes before any of the timers

    iAsyncCallBack = new( ELeave )CAsyncCallBack( CActive::EPriorityStandard +1 );

    //RD_ALMALERT__ACCESSORY_STOP removed as a fix for ABAA-74R757

    // accessory observer

    iRemConHandler = CAlarmRemConEventsHandler::NewL( *iAlarmControl );

    iCalendarAlarmViewer = EFalse;

    TRACE_EXIT_POINT;

    }

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

// C++ default constructor

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

//

CAlarmUtils::CAlarmUtils( CAlmAlarmControl* aAlarmControl, 

                          CAknAlarmService* aSupervisor )

    : iAlarmControl( aAlarmControl ),

      iSupervisor( aSupervisor ),

      iLightsBlinking( EFalse ),

      iKeyGuardActivated( ETrue )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// Destructor

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

//

CAlarmUtils::~CAlarmUtils()

    {

    TRACE_ENTRY_POINT;

    if( iNotifierDialogController )

        {

        iNotifierDialogController->SetNoteObserver( NULL );

        }

    if( iShutdownTimer )

        {

        iShutdownTimer->Cancel();

        delete iShutdownTimer;

        iShutdownTimer = NULL;

        }

    if( iAutoSnoozeTimer )

        {

        iAutoSnoozeTimer->Cancel();

        delete iAutoSnoozeTimer;

        iAutoSnoozeTimer = NULL;

        }

    if( iKeyBlockTimer )

        {

        iKeyBlockTimer->Cancel();

        delete iKeyBlockTimer;

        iKeyBlockTimer = NULL;

        }

    if( iAlarmDelayTimer )

        {

        iAlarmDelayTimer->Cancel();

        delete iAlarmDelayTimer;

        iAlarmDelayTimer = NULL;

        }

    if( iInactivityResetTimer )

        {

        iInactivityResetTimer->Cancel();

        delete iInactivityResetTimer;

        iInactivityResetTimer = NULL;

        }

    if( iAsyncCallBack )

        {

        iAsyncCallBack->Cancel();

        delete iAsyncCallBack;

        iAsyncCallBack = NULL;

        }

    delete iAlarmPlayer;

    iAlarmPlayer = NULL;

    delete iAlarmInfo;

    iAlarmInfo = NULL;

    delete iRemConHandler;

    iRemConHandler = NULL;

    #ifdef RD_ALMALERT__SENSOR_SUPPORT

    delete iCFSupport;

    iCFSupport = NULL;

    #endif // RD_ALMALERT__SENSOR_SUPPORT

    if( iProfileEng )

        {

        iProfileEng->Release();

        iProfileEng = NULL;

        }

    iApaSession.Close();

	if(iQueueManagerAsw)

		{

		delete iQueueManagerAsw;

		}

	if(iEntryAsyncWait)

		{

		delete iEntryAsyncWait;

		}

	if(iCalSession)

		{

		delete iCalSession;

		}

	if(iCalEntryView)

		{

		delete iCalEntryView;

		}

    TRACE_EXIT_POINT;

    }

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

// Start the alarm player.

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

//

void CAlarmUtils::PlayAlarmSound()

    {

    TRACE_ENTRY_POINT;

    StopAlarmSound();

    PIM_TRAPD_ASSERT( iAlarmPlayer = CAlmAlarmPlayer::NewL( this ); )

    SetBackLight( ETrue );

    TRACE_EXIT_POINT;

    }

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

// Stop the alarm player.

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

//

void CAlarmUtils::StopAlarmSound()

    {

    TRACE_ENTRY_POINT;

    #if defined( RD_ALMALERT__SENSOR_SUPPORT )

    // notify the result through the context framework

    // only set the context if the player was really active

    if( iAlarmPlayer && iCFSupport )

        {

        PIM_TRAPD_ASSERT( iCFSupport->PublishAlarmResultL( EResultAlarmSilenced ); )

        }

    #endif // RD_ALMALERT__SENSOR_SUPPORT

    delete iAlarmPlayer;

    iAlarmPlayer = NULL;

    SetBackLight( EFalse );

    TRACE_EXIT_POINT;

    }

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

// Backlight on/off

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

//

void CAlarmUtils::SetBackLight(TBool aActive)

    {

    TRACE_ENTRY_POINT;

	TInt status;

	// reading the value before setting. This also ensures if the P&S key is defined or not. 

	TInt ret = RProperty::Get( KPSUidCoreApplicationUIs, 

									KLightsAlarmLightActive, 

									status); 

	if(ret == KErrNotFound )

		{	

		return ;

		}

    if( iLightsBlinking != aActive )

        {

        iLightsBlinking = aActive;

        PIM_ASSERT( RProperty::Set( KPSUidCoreApplicationUIs, 

                                    KLightsAlarmLightActive, 

                                    aActive ? ELightsBlinking : ELightsNotBlinking ); )

        }

    TRACE_EXIT_POINT;

    }

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

// Key guard on/off

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

//

void CAlarmUtils::SetKeyGuard(TBool aActive)

    {

    TRACE_ENTRY_POINT;

    if( iKeyGuardActivated != aActive )

        {

        iKeyGuardActivated = aActive;

        PIM_ASSERT( RProperty::Set( KPSUidCoreApplicationUIs, 

                                    KCoreAppUIsDisableKeyguard, 

                                    aActive ? ECoreAppUIsEnableKeyguard : ECoreAppUIsDisableKeyguard ); )

        }

    TRACE_EXIT_POINT;

    }

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

// 

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

//

TBool CAlarmUtils::IsClockAlarm() const

    {

    TRACE_ENTRY_POINT;

    const TBool retVal( iAlarmData.iAlarm.Category() == KAlarmClockOne );

    TRACE_EXIT_POINT;

    return retVal;

    }

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

// 

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

//

TBool CAlarmUtils::IsCalendarAlarm() const

    {

    TRACE_ENTRY_POINT;

    const TBool retVal( iAlarmData.iAlarm.Category() == KUidAgendaModelAlarmCategory );

    TRACE_EXIT_POINT;

    return retVal;

    }

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

// Check the active profile ringing type.

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

//

TBool CAlarmUtils::IsRingingTypeSilent() const

    {

    TRACE_ENTRY_POINT;

    TBool isSilent( EFalse );

    if( iProfileEng )

        {

        MProfile* profile = NULL;

        PIM_TRAPD_ASSERT( profile = iProfileEng->ActiveProfileL(); )

        if( profile )

            {

            if( profile->ProfileTones().ToneSettings().iRingingType == EProfileRingingTypeSilent ||

                profile->ProfileTones().ToneSettings().iRingingType == EProfileRingingTypeBeepOnce )

                {

                isSilent = ETrue;  // Ringing Type = Silent or BeepOnce

                }

            profile->Release();

            }

        }

    TRACE_EXIT_POINT;

    return isSilent;

    }

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

// Check if the used alarm tone is an "off" tone.

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

//

TBool CAlarmUtils::IsOffTone() const

    {

    TRACE_ENTRY_POINT;

    TBool isOffTone( EFalse );

    if( iAlarmData.iAlarmTone == KNullDesC )

        {

        isOffTone = ETrue;

        }

    else

        {

        // alarm tone file path w/o drive name

        TPtrC alarmToneFilePath = 

            iAlarmData.iAlarmTone.Mid( 

                TParsePtrC( iAlarmData.iAlarmTone ).Drive().Length() );

        if( alarmToneFilePath == KProfileNoSoundPath )

            {

            isOffTone = ETrue;

            }

        }

    TRACE_EXIT_POINT;

    return isOffTone;

    }

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

// Read alarm sound filenames from central repository.

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

//

void CAlarmUtils::GetAlarmSoundFilenames()

    {

    TRACE_ENTRY_POINT;

    CRepository* repository = NULL;

    if( IsClockAlarm() )

        {

        PIM_TRAPD_ASSERT( repository = CRepository::NewL( KCRUidClockApp ); )

        if( repository )

            {

            PIM_ASSERT( repository->Get( KClockAppSoundFile, iAlarmData.iAlarmTone ); )

            PIM_ASSERT( repository->Get( KClockAppDefaultSoundFile, iAlarmData.iDefaultAlarmTone ); )

            }

        }

    else

        {

        PIM_TRAPD_ASSERT( repository = CRepository::NewL( KCRUidCalendar ); )

        if( repository )

            {

            PIM_ASSERT( repository->Get( KCalendarSoundFile, iAlarmData.iAlarmTone ); )

            PIM_ASSERT( repository->Get( KCalendarDefaultSoundFile, iAlarmData.iDefaultAlarmTone ); )

            }

        }

    delete repository;

    TRACE_EXIT_POINT;

    }

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

// Check if the alarm sound file is a KRngMimeType file.

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

//

TBool CAlarmUtils::IsRngTone()

    {

    TRACE_ENTRY_POINT;

    TBool isRngTone( EFalse );

    RFs& session = iAlarmControl->ControlEnv()->FsSession();

    // Check that the file exist.  If not, use the default file.

    TUint attributes;

    TInt error = session.Att( iAlarmData.iAlarmTone, attributes );

    if( error )

        {

        iAlarmData.iAlarmTone = iAlarmData.iDefaultAlarmTone;

        }

    TUid dummyUid( KNullUid );

    TDataType dataType;

    error = iApaSession.AppForDocument( iAlarmData.iAlarmTone, dummyUid, dataType );

    ASSERT( !error );

    if( !error && dataType.Des().CompareF( KRngMimeType ) == 0 )

        {

        isRngTone = ETrue;

        }

    TRACE_EXIT_POINT;

    return isRngTone;

    }

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

// Read active profile settings from the profile engine.

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

//

void CAlarmUtils::GetProfileSettings()

    {

    TRACE_ENTRY_POINT;

    // set default/fallback values

    iAlarmData.iRingType = EProfileRingingTypeRinging; // not used with clock alarm

    iAlarmData.iRepeatValue = KMdaAudioToneRepeatForever; // KMdaRepeatForever

    iAlarmData.iVolume = KMaxProfileVolume; // clock alarms always ramp to maximum volume

    iAlarmData.iVolumeRampTime = iAlarmData.iVolume * KVolumeRampPeriod; // volume ramp only for clock alarms

    if( !IsClockAlarm() )

        {

        if( iProfileEng )

            {

            MProfile* profile = NULL;

            PIM_TRAPD_ASSERT( profile = iProfileEng->ActiveProfileL(); )

            if( profile )

                {

                const TProfileToneSettings& setting = profile->ProfileTones().ToneSettings();

                iAlarmData.iRingType = setting.iRingingType;

                // calendar alarms: if profile is "silent" -> set volume to zero

                iAlarmData.iVolume = (iAlarmData.iRingType == EProfileRingingTypeSilent ? 0 : setting.iRingingVolume);

                profile->Release();

                }

            }

        if( iAlarmData.iRingType == EProfileRingingTypeRingingOnce )

            {

            iAlarmData.iRepeatValue = 1;

            }

        iAlarmData.iVolumeRampTime = 0;

        }

    TRACE_EXIT_POINT;

    }

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

// 

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

//

TInt CAlarmUtils::MaxProfileVolume() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return KMaxProfileVolume;

    }

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

// Access to iAlarmData structure.

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