/*
* 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