/*

* 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 class interfaces with Context Framework Client API  

*

*/

#include <coemain.h>

#include <f32file.h>

#include <pathinfo.h>

#include <cfclient.h>

#include <cfcontextobject.h> 

#include <cfactionsubscription.h>

#include <cfactionindication.h> 

#include <cfcontextindication.h> 

#include <cfcontextobject.h>

#include <cfcontextsubscription.h>

#include <cfcontextobject.h>

#include "CleanupResetAndDestroy.h"

#include "calenalarmmanager.h"

#include "calencontextfwlistener.h"

#include <alarmsourcecontextdef.h>

#include "calendarui_debug.h"

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

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

// CCalenContextFWListener::NewL

// Symbian constructor.

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

//

CCalenContextFWListener* CCalenContextFWListener::NewL(CCalenAlarmManager& aAlarmManager)

    {

    TRACE_ENTRY_POINT;

    CCalenContextFWListener* self = new( ELeave )CCalenContextFWListener(aAlarmManager);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenContextFWListener::~CCalenContextFWListener

// destructor

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

//

CCalenContextFWListener::~CCalenContextFWListener()

    {

    TRACE_ENTRY_POINT;

    CloseCFClient();

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::ContextIndicationL

// Indicates a change in context for subscribed clients.

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

//

void CCalenContextFWListener::ContextIndicationL(const CCFContextIndication& aChangedContext)

    {

    TRACE_ENTRY_POINT;

    const CCFContextObject& co = aChangedContext.Context();

#ifdef _DEBUG

    RDebug::Print( _L("----- CalendarUI - context indication:") );

    RDebug::RawPrint( co.Source() );

    RDebug::RawPrint( co.Type() );

    RDebug::RawPrint( co.Value() );

#endif

    // exit alarm mode as soon as alarm is snoozed or stopped

    if( co.Source() == KAlarmUISource() && co.Type() == KAlarmUISourceResult() )

        {

#ifdef _DEBUG

        RDebug::Print( _L("### source OK!") );

#endif

        if( co.Value() == TPtrC( KAlarmUISourceResultValues[EResultAlarmStopped] ) )

            {

#ifdef _DEBUG

            RDebug::Print( _L("### EResultAlarmStopped") );

#endif

            // should close the Event view open

            iAlarmManager.StopAlarmContextListener();

            }

        else if( co.Value() == TPtrC( KAlarmUISourceResultValues[EResultAlarmSnoozed] ) )

            {

#ifdef _DEBUG

            RDebug::Print( _L("### EResultAlarmSnoozed") );

#endif

            // should leave the Event view

             iAlarmManager.StopAlarmContextListener(ETrue);             

            }

            //should close the event view in case of power on/off and missed alarm.

        else if( co.Value() == TPtrC( KAlarmUISourceResultValues[EResultAlarmStoppedAndExit] ) )

            {

#ifdef _DEBUG

            RDebug::Print( _L("### EResultAlarmMissed") );

#endif

            // should leave the Event view

             //iAlarmManager.StopAlarmContextListener(ETrue);    

            iAlarmManager.StopContextListenerForAutoSnooze(); 

            }    

        else

            {

#ifdef _DEBUG

            RDebug::Print( _L("### value didn't match!") );

#endif

            }

        }

    else

        {

#ifdef _DEBUG

        RDebug::Print( _L("### source didn't match!") );

#endif

        }

    UnsubscribeContexts();    

    CloseCFClient();

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::ActionIndicationL

// Indicates that specified action is needed to be executed.

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

//

void CCalenContextFWListener::ActionIndicationL(const CCFActionIndication& aActionToExecute)

    {

    TRACE_ENTRY_POINT;

#ifdef _DEBUG

    RDebug::Print( _L("----- CalendarUI - action:") );

    RDebug::RawPrint( aActionToExecute.Identifier() );

#endif

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::HandleContextFrameworkError

// Indicates that error has occured.

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

//

void CCalenContextFWListener::HandleContextFrameworkError( TCFError aError, 

                                                          const TDesC& aSource, 

                                                          const TDesC& aType )

    {

    TRACE_ENTRY_POINT;

    // no implementation

#ifdef _DEBUG

    RDebug::Print( _L("----- CalendarUI - CF error:") );

    RDebug::Print( _L("aError: %d"), aError );

    RDebug::RawPrint( aSource );

    RDebug::RawPrint( aType );

    RDebug::Print( _L("-----------------------------") );

#endif

    ASSERT( !aError );

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::CCalenContextFWListener

// c++ constructor

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

//

CCalenContextFWListener::CCalenContextFWListener(CCalenAlarmManager& aAlarmManager)

	:iAlarmManager(aAlarmManager)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::ConstructL

// Symbian 2nd phase constructor.

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

//

void CCalenContextFWListener::ConstructL()

    {

    TRACE_ENTRY_POINT;

    // Context Framework client side API

    OpenCFClientL();

    if( !IsCalendarAlarmActiveL() )

        {

        // alarm not active anymore >> cancel the alarm mode

        User::Leave( KErrCancel );

        }

    // subscribe to alarm 'Result' context

    CCFContextSubscription* cs = CCFContextSubscription::NewLC();

    cs->SetContextSourceL( KAlarmUISource );

    cs->SetContextTypeL( KAlarmUISourceResult );

    User::LeaveIfError( iCFClient->SubscribeContext( *cs ) );

    User::LeaveIfError( iSubscribedContexts.Append( cs ) );

    CleanupStack::Pop( cs );

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::PublishContextL

// publish a context for the alarm 

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

//

void CCalenContextFWListener::PublishContextL( const TDesC& aSource,

                                       const TDesC& aType,

                                       const TDesC& aValue )

    {

    TRACE_ENTRY_POINT;

    CCFContextObject* co = CCFContextObject::NewLC( aSource, aType, aValue );

    if(iCFClient)

      {

        const TInt err = iCFClient->PublishContext( *co );

#ifdef _DEBUG

    RDebug::Print( _L("### PublishContext - err: %d"), err );

#endif

    User::LeaveIfError( err );

      }

    CleanupStack::PopAndDestroy( co );

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::AlarmStopL

// Publish a context to stop alarm

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

//

void CCalenContextFWListener::AlarmStopL()

    {

    TRACE_ENTRY_POINT;

    // no need for the subscription(s) anymore...

    // ...we'll exit the alarm mode anyway

    // publish a new context for the alarm stop command

    PublishContextL( KAlarmUISource, 

                     KAlarmUISourceCommand, 

                     TPtrC( KAlarmUISourceCommandValues[ ECommandAlarmStop] ) );

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::AlarmSnoozeL

// Publish a context to snooze alarm 

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

//

void CCalenContextFWListener::AlarmSnoozeL()

    {

    TRACE_ENTRY_POINT;

    // no need for the subscription(s) anymore...

    // ...we'll exit the alarm mode anyway

    // publish a new context for the alarm snooze command

    PublishContextL( KAlarmUISource, 

                     KAlarmUISourceCommand, 

                     TPtrC( KAlarmUISourceCommandValues[ ECommandAlarmSnooze] ) );

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::OpenCFClientL

// Open the CCFClient session

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

//

void CCalenContextFWListener::OpenCFClientL()

    {

    TRACE_ENTRY_POINT;

    if( !iCFClient )

        {

        iCFClient = CCFClient::NewL( *this );

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::CloseCFClient

// Unsusbscribe all actions and close the session.

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

//

void CCalenContextFWListener::CloseCFClient()

    {

    TRACE_ENTRY_POINT;

    UnsubscribeContexts();

    delete iCFClient;

    iCFClient = NULL;

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::UnsubscribeContexts

// Unsusbscribe all actions 

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

//

void CCalenContextFWListener::UnsubscribeContexts()

    {

    TRACE_ENTRY_POINT;

    // unsubscribe all subscriptions

    while( iSubscribedContexts.Count() )

        {

        CCFContextSubscription* cs = iSubscribedContexts[0];

        iSubscribedContexts.Remove( 0 );

        PIM_ASSERT( iCFClient->UnsubscribeContext( *cs ) );

        delete cs;

        }

    iSubscribedContexts.Close();

    TRACE_EXIT_POINT;

    }

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

// CCalenContextFWListener::IsCalendarAlarmActiveL

// check if a calendar alarm is still active

// (alarm might have been dismissed before the viewer was fully constructed)

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

//

TBool CCalenContextFWListener::IsCalendarAlarmActiveL()

    {

    TRACE_ENTRY_POINT;

    TBool retVal( EFalse );

    RContextObjectArray arr;

    CleanupResetAndDestroyPushL( arr );

    CCFContextQuery* query = CCFContextQuery::NewLC( KAlarmUISource, KAlarmUISourceState );

    const TInt err = iCFClient->RequestContext( *query, arr );

    CleanupStack::PopAndDestroy( query );

    if( !err )

        {

        for( TInt i(0); i < arr.Count(); i++ )

            {

            CCFContextObject* obj = arr[i];

#ifdef _DEBUG

            RDebug::Print( _L("### found alarm context: %S"), &(obj->Value()) );

#endif

            if( obj->Value() == TPtrC( KAlarmUISourceStateValues[EStateCalendarAlarm] ) )

                {

                retVal = ETrue;

                break;

                }

            }

        }

    CleanupStack::PopAndDestroy( &arr );

    TRACE_EXIT_POINT;

    return retVal;

    }

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

// CCalenContextFWListener::Extension

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

//    

TAny* CCalenContextFWListener::Extension( const TUid&/* aExtensionUid */)const

	{

	TRACE_ENTRY_POINT;		

	TRACE_EXIT_POINT;

	return NULL;

	}

// End of File