/*
* Copyright (c) 2006-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: This class interfaces with Context Framework Client API.
*
*/
// SYSTEM INCLUDE
#include <coemain.h>
#include <f32file.h>
#include <pathinfo.h>
#include <cfclient.h>
#include <cfcontextobject.h>
#include <cfactionsubscription.h>
#include <cfcontextsubscription.h>
#include <cfcontextindication.h>
#include <cfactionindication.h>
// USER INCLUDE
#include "alarmcontextfwsupport.h"
#include "AlmAlarmControl.h"
#include "alarmutils.h"
#include "pim_trace.h"
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// Symbian constructor.
// ---------------------------------------------------------------------------
//
CAlarmContextFwSupport* CAlarmContextFwSupport::NewL(CAlmAlarmControl* aAlarmControl)
{
TRACE_ENTRY_POINT;
CAlarmContextFwSupport* self = new( ELeave )CAlarmContextFwSupport( aAlarmControl );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
TRACE_EXIT_POINT;
return self;
}
// ---------------------------------------------------------------------------
// destructor
// ---------------------------------------------------------------------------
//
CAlarmContextFwSupport::~CAlarmContextFwSupport()
{
TRACE_ENTRY_POINT;
CloseCFClient();
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Indicates a change in context for subscribed clients.
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::ContextIndicationL(const CCFContextIndication& aChangedContext)
{
TRACE_ENTRY_POINT;
const CCFContextObject& contextObject = aChangedContext.Context();
if( contextObject.Source() == KAlarmUISource() && contextObject.Type() == KAlarmUISourceCommand() )
{
if( contextObject.Value() == TPtrC( KAlarmUISourceCommandValues[ECommandAlarmStop] ) )
{
// stop alarm
iAlarmControl->SetStopFromContext(ETrue);
iAlarmControl->ExternalStopAlarm();
}
else if( contextObject.Value() == TPtrC( KAlarmUISourceCommandValues[ECommandAlarmSnooze] ) )
{
// snooze alarm
if(iAlarmControl->CanSnooze())
iAlarmControl->ExternalSnoozeAlarm();
}
else if( contextObject.Value() == TPtrC( KAlarmUISourceCommandValues[ECommandAlarmSilence] ) )
{
SilenceAlarm();
}
else
{
// value didn't match
}
}
else
{
//source didn't match!
}
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Indicates that specified action is needed to be executed.
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::ActionIndicationL(const CCFActionIndication& aActionToExecute)
{
TRACE_ENTRY_POINT;
if( aActionToExecute.Identifier() == TPtrC( KAlarmUIActions[EActionSnooze] ) )
{
// snooze the alarm
if(iAlarmControl->CanSnooze())
iAlarmControl->ExternalSnoozeAlarm();
}
else if( aActionToExecute.Identifier() == TPtrC( KAlarmUIActions[EActionSilence] ) )
{
SilenceAlarm();
}
else if( aActionToExecute.Identifier() == TPtrC( KAlarmUIActions[EActionStop] ) )
{
//Do not stop the alarm internally but force the user to stop the alarm manually.
//iAlarmControl->ExternalStopAlarm();
}
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Indicates that error has occured.
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::HandleContextFrameworkError( TCFError aError,
const TDesC& /*aSource*/,
const TDesC& /*aType*/ )
{
TRACE_ENTRY_POINT;
// no implementation
ASSERT( !aError );
TRACE_EXIT_POINT;
}
// Changes made for Context Framework API changes (SCB Id: MKAN-765D93)
// ---------------------------------------------------------------------------
// Returns an extension interface.
// The extension interface is mapped with the extension UID.
// ---------------------------------------------------------------------------
//
TAny* CAlarmContextFwSupport::Extension( const TUid& /*aExtensionUid */ ) const
{
TRACE_ENTRY_POINT;
// Just return a NULL as currently there are no extensions available
// and also since we do not support any of these APIs defined within
// the alarm UID.
TRACE_EXIT_POINT;
return NULL;
}
// ---------------------------------------------------------------------------
// c++ constructor
// ---------------------------------------------------------------------------
//
CAlarmContextFwSupport::CAlarmContextFwSupport(CAlmAlarmControl* aAlarmControl)
: iAlarmControl( aAlarmControl )
{
TRACE_ENTRY_POINT;
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor.
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::ConstructL()
{
TRACE_ENTRY_POINT;
// Context Framework client side API
OpenCFClientL();
// define context(s)
DefineContextL( KAlarmUISource, KAlarmUISourceState, KAlarmUISourceStateSec );
DefineContextL( KAlarmUISource, KAlarmUISourceCommand, KAlarmUISourceCommandSec );
DefineContextL( KAlarmUISource, KAlarmUISourceResult, KAlarmUISourceResultSec );
// define actions(s)
DefineActionL( EActionSnooze );
DefineActionL( EActionSilence );
//Stop action definition should not be defined as the alarm component should not automatically stop the alarm on observing context events
// but continue to expire the alarm and force the user to manually stop the alarm
//DefineActionL( EActionStop );
// no need to keep the session open
CloseCFClient();
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Defines a new context
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::DefineContextL( const TDesC& aContextSource,
const TDesC& aContextType,
const TSecurityPolicy& aSecurityPolicy )
{
TRACE_ENTRY_POINT;
const TInt err = iCFClient->DefineContext( aContextSource,
aContextType,
aSecurityPolicy );
// don't care if it already existed
User::LeaveIfError( err == KErrAlreadyExists ? KErrNone : err );
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Defines an action
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::DefineActionL(const TAlarmUIActionValues aAction)
{
TRACE_ENTRY_POINT;
const TInt err = iCFClient->DefineAction( TPtrC( KAlarmUIActions[ aAction ] ),
KAlarmUIActionSec );
// don't care if it already existed
User::LeaveIfError( err == KErrAlreadyExists ? KErrNone : err );
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Subscribe an action
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::SubscribeActionL(const TAlarmUIActionValues aAction)
{
TRACE_ENTRY_POINT;
CCFActionSubscription* as = CCFActionSubscription::NewLC();
as->SetActionIdentifierL( TPtrC( KAlarmUIActions[ aAction ] ) );
TInt err = iCFClient->SubscribeAction( *as );
if( !err )
{
// add to array if the subscription was successfull
err = iSubscribedActions.Append( as );
CleanupStack::Pop( as );
}
else
{
// delete the object if it didn't go to the array
CleanupStack::PopAndDestroy( as );
}
User::LeaveIfError( err );
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Unsubscribe all actions
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::UnsubscribeActions()
{
TRACE_ENTRY_POINT;
// unsubscribe all actions
while( iSubscribedActions.Count() )
{
CCFActionSubscription* as = iSubscribedActions[0];
iSubscribedActions.Remove( 0 );
PIM_ASSERT( iCFClient->UnsubscribeAction( *as ); )
delete as;
}
iSubscribedActions.Close();
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Publish a context
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::PublishContextL( const TDesC& aSource,
const TDesC& aType,
const TDesC& aValue )
{
TRACE_ENTRY_POINT;
CCFContextObject* co = CCFContextObject::NewLC( aSource, aType, aValue );
const TInt err = iCFClient->PublishContext( *co );
CleanupStack::PopAndDestroy( co );
User::LeaveIfError( err );
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Subscribe to actions/ context and publish the new alarm status.
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::StartL(const TAlarmSourceStateValues aEvent)
{
TRACE_ENTRY_POINT;
// open client session(closed in StopL)
OpenCFClientL(); // closed in StopL
// subscribe for action(s)
SubscribeActionL( EActionSnooze );
SubscribeActionL( EActionSilence );
//Subscription to stop action definition from the context events should not be defined as the alarm component should not automatically stop the alarm on observing context events
// but continue to expire the alarm and force the user to manually stop the alarm
//SubscribeActionL( EActionStop );
// subscribe for context with Source: 'AlarmUI' & Type: 'Command'
SubscribeContextL(KAlarmUISource, KAlarmUISourceCommand );
// publish new alarm event/status
PublishContextL( KAlarmUISource,
KAlarmUISourceState,
TPtrC( KAlarmUISourceStateValues[ aEvent ] ) );
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// publish 'alaram inactive' state and close the session
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::StopL()
{
TRACE_ENTRY_POINT;
if( iCFClient ) // created in StartL
{
// publish the 'alarm inactive' status
PublishContextL( KAlarmUISource,
KAlarmUISourceState,
TPtrC( KAlarmUISourceStateValues[ EStateAlarmInactive ] ) );
// no need to keep the session open anymore
CloseCFClient();
}
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Create a connection to Context Framework Server
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::OpenCFClientL()
{
TRACE_ENTRY_POINT;
if( !iCFClient )
{
iCFClient = CCFClient::NewL( *this );
}
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Unsusbscribe all actions and close the session.
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::CloseCFClient()
{
TRACE_ENTRY_POINT;
UnsubscribeActions();
// unsubscribe contexts
UnsubscribeContexts();
delete iCFClient;
iCFClient = NULL;
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// publish context alarm result Source: 'AlarmUI' Type: 'Result'
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::PublishAlarmResultL(const TAlarmSourceResultValues aResult)
{
TRACE_ENTRY_POINT;
TBool closeCFClient( EFalse );
// open a new CF client session if needed
if( !iCFClient )
{
OpenCFClientL();
closeCFClient = ETrue;
}
// publish the new alarm result
PublishContextL( KAlarmUISource,
KAlarmUISourceResult,
TPtrC( KAlarmUISourceResultValues[ aResult ] ) );
// close the CF client session if it was explicitly opened for this operation
if( closeCFClient )
{
CloseCFClient();
}
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Subscribe a context
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport::SubscribeContextL( const TDesC& aSource,
const TDesC& aType)
{
TRACE_ENTRY_POINT;
// define a context
CCFContextSubscription* subscription = CCFContextSubscription::NewLC();
subscription->SetContextSourceL( aSource );
subscription->SetContextTypeL( aType );
//subscribe to the context
TInt err = iCFClient->SubscribeContext( *subscription );
if( !err )
{
// add to array if the subscription was successfull
err = iSubscribedContexts.Append( subscription );
CleanupStack::Pop( subscription );
}
else
{
// delete the object if subscription fails
CleanupStack::PopAndDestroy( subscription );
}
User::LeaveIfError( err );
TRACE_EXIT_POINT;
}
// ---------------------------------------------------------------------------
// Unsubscribe all contexts
// ---------------------------------------------------------------------------
//
void CAlarmContextFwSupport :: UnsubscribeContexts()
{
TRACE_ENTRY_POINT;
// unsubscribe all subscriptions
while( iSubscribedContexts.Count() )
{
CCFContextSubscription* subscription = iSubscribedContexts[0];
iSubscribedContexts.Remove( 0 );
PIM_ASSERT( iCFClient->UnsubscribeContext( *subscription ) );
delete subscription;
}
iSubscribedContexts.Close();
TRACE_EXIT_POINT;
}
void CAlarmContextFwSupport::SilenceAlarm()
{
if( iAlarmControl->AlarmUtils() )
{
iAlarmControl->AlarmUtils()->DoSilence();
}
}
// End of File