/*

* 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 "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 "alarmalertwrapper.h"

// #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 <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 <clockdomaincrkeys.h>

#include <calendardomaincrkeys.h>

const TInt KAlmAlertMinSnooze( 100 );

const TInt KAlmAlertMaxSnooze( 104 );

const TInt KMaxProfileVolume( 10 );

const TUid KAlarmClockOne = { 0x101F793A };

const TUid KCRUidProfileEngine = {0x101F8798};

//const TUint32 KProEngActiveReminderTone     = 0x7E00001C;

//const TUint32 KProEngActiveAlertVibra           = 0x7E00001E;

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

// ================= 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 );

    iAlarmAlert = new AlarmAlert(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( iAlarmAlert )

        {

        delete iAlarmAlert;

        iAlarmAlert = 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* profileRepository = NULL;

	CRepository* repository = NULL;

	if( IsClockAlarm() )

	{

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

		PIM_TRAPD_ASSERT( profileRepository = CRepository::NewL( 

														KCRUidProfileEngine ); )

		if( repository )

		{

			PIM_ASSERT( repository->Get( KClockAppDefaultSoundFile, 

											iAlarmData.iDefaultAlarmTone ); )

		}

		if( profileRepository )

		{

			// TODO: Need to use KProEngActiveClockAlarmTone once its released

			//PIM_ASSERT( profileRepository->Get( KProEngActiveClockAlarmTone , iAlarmData.iAlarmTone); )

			PIM_ASSERT( repository->Get( KClockAppDefaultSoundFile, 

													iAlarmData.iAlarmTone ); )

		}

	}

	else

	{

		PIM_TRAPD_ASSERT( repository =

				CRepository::NewL( TUid::Uid(KCRUidCalendar) ); )

		PIM_TRAPD_ASSERT( profileRepository =

				CRepository::NewL( KCRUidProfileEngine ); )

		if( repository )

		{

			PIM_ASSERT( repository->Get( KCalendarDefaultSoundFile, 

											iAlarmData.iDefaultAlarmTone ); )

		}

		if( profileRepository )

		{

		}

	}

	delete repository;

	delete profileRepository;

	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() )

    {

        CRepository* repository = NULL;

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

    	TInt ringType;

    	repository->Get( KProEngActiveRingingType , ringType);

    	iAlarmData.iRingType = static_cast< TProfileRingingType >( ringType );