diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmservertest/TestMultipleAlarmsSuite/src/DummyAlarmControl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonappservices/alarmservertest/TestMultipleAlarmsSuite/src/DummyAlarmControl.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,362 @@ +// Copyright (c) 2005-2009 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: +// Contains implementation of CDummyAlarmControl class +// +// + +/** + @file + @internalTechnology +*/ + +// User Includes +#include "DummyAlarmControl.h" + +/*@{*/ +// < and > escape encoded as < and > as TestExecuteLogEngine +// does not do it for us. +_LIT(KNotKnown, "<message not known yet>"); +/*@}*/ + +/** +Constructor +@param aSupervisor Pointer to the supervisor corresponding to this alarm +control +@param aAlarmControlsManager Pointer to the alarm controls manager +@internalTechnology +@test +*/ +CDummyAlarmControl::CDummyAlarmControl(CEikAlmControlSupervisor* aSupervisor, CAlarmControlsManager* aAlarmControlsManager) +: iSupervisor(aSupervisor), iMyManager(aAlarmControlsManager), iAlarmMessage(KNotKnown) + { + } + +/** +Destructor +@internalTechnology +@test +*/ +CDummyAlarmControl::~CDummyAlarmControl() + { + delete iAlarmSoundName; + } + +// +// MEikServAlarm callbacks Impelementations start +// + +/** +MEikServAlarm implementation. Prints that it was called. +Asks its manager to remove it from his list. Deletes itself +@internalTechnology +@test +*/ +void CDummyAlarmControl::Release() + { + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::ERelease)); + + iMyManager->RemoveFromList(this); + delete this; + } + +/** +MEikServAlarm implementation. Prints that it was called. +Asks its manager to increment the number of currently notifying alarms if +it had not already been showing +@internalTechnology +@test +*/ +void CDummyAlarmControl::ShowAlarm() + { + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::EShowAlarm)); + + // KNullAlarmId check is done to be safe in case of Single Alarm mode, + // where some call backs occur before we have the alarm info. In such a + // case, no alarm is considered to be notifying + if(iAlarm.Id() != KNullAlarmId && !iIsShowing) + { + iMyManager->IncrementNoOfCurrentlyNotifyingAlarms(); + } + + iIsShowing = ETrue; + } + +/** +MEikServAlarm implementation. Prints that it was called. +Asks its manager to decrement the number of currently notifying alarms if +it has been showing. Marks itself as not showing +@internalTechnology +@test +*/ +void CDummyAlarmControl::HideAlarm() + { + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::EHideAlarm)); + if(iAlarm.Id() != KNullAlarmId && iIsShowing) + { + iMyManager->DecrementNoOfCurrentlyNotifyingAlarms(); + } + iIsShowing = EFalse; + + // If the alarm has been StopPlayAlarm-ed and HideAlarm is now being + // called, it means, this alarm is being hidden as a result of a + // snooze or a clear. Hence it must not be consiedered the + // CurrentlyPlayingAlarm. We check for iIsPlaying just to make sure + // that if HideAlarm has been erroneously called before StopPlayAlarm + // it will get trapped by the TestAlarmControlState step somewhere + + // We dont do this in StopPlayAlarm itself, because, if the alarm is + // left unattended it will stop and start playing periodically, and + // we must not consider that this alarm is not the currently notifying one + // in that case + if(!iIsPlaying) + { + iMyManager->UpdateCurrentlyPlayingAlarmId(KNullAlarmId); + } + + // If in single alarm mode, then we remove the record of the alarm message + // when the alarm is snoozed or cleared + if(iMyManager->CurrentMaxAlarms() == 1) + { + iAlarmMessage.Set(KNotKnown); + } + } + +/** +MEikServAlarm implementation. Prints that it was called. +Returns the current state of the alarm control object. +@return The current state of the alarm control object. +@internalTechnology +@test +*/ +TInt CDummyAlarmControl::CurrentServerState() const + { + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::ECurrentServerState)); + return iCurrentAlarmServerState; + } + +/** +MEikServAlarm implementation. Prints that it was called. +Marks itself as Snoozing +@param aMinutes Is not used +@internalTechnology +@test +*/ +void CDummyAlarmControl::UpdateSoundPauseTimeInterval(TInt aMinutes) + { + _LIT(KPrintMinsToSnooze, "Mins to snooze = "); + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::EUpdateSoundPauseTimeInterval)); + TBuf<20> message(KPrintMinsToSnooze); + message.AppendNum(aMinutes); + iMyManager->PrintLog(message); + iMinsToSnooze = aMinutes; + iIsSnoozed = ETrue; + } + +/** +MEikServAlarm implementation. Prints that it was called. +Updates its current alarm server state flag +@param aNewAlarmServerState The new alarm server state. +@internalTechnology +@test +*/ +void CDummyAlarmControl::UpdateForAlarmServerState(TInt aNewAlarmServerState) + { + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::EUpdateForAlarmServerState)); + iCurrentAlarmServerState = aNewAlarmServerState; + } + +/** +MEikServAlarm implementation. +Updates its alarm message flag, which will later identify this alarm control +object. Prints that it was called in the end, as then there is an advantage of +knowing the alarm message +@param aAlarm The Alarm object that carries the alarm's details +@param aOwner The owner of the alarm. Not used +@internalTechnology +@test +*/ +void CDummyAlarmControl::UpdateAlarmInfo(const TASShdAlarm& aAlarm,const TFullName& /* aOwner */) + { + // I got notified now + iMyNotificationTime.UniversalTime(); + + iAlarm = aAlarm; + + // I should have been notified at: + iOrigExpTime = iAlarm.OriginalExpiryTime(); + + iAlarmMessage.Set(iAlarm.Message()); + // In this function we print in the end, as we know iAlarmMessage henceforth + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::EUpdateAlarmInfo)); + } + +/** +MEikServAlarm implementation. Prints that it was called. +Asks its manager to upadte the flag identifying the id of the currently playing +alarm and marks itself as Playing. +@param aAlarmSoundName The alarm sound name to play +@internalTechnology +@test +*/ +void CDummyAlarmControl::StartPlayAlarmL(const TDesC& aAlarmSoundName) + { + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::EStartPlayAlarm)); + iMyManager->UpdateCurrentlyPlayingAlarmId(iAlarm.Id()); + iIsSnoozed = EFalse; + iIsPlaying = ETrue; + + if(iAlarmSoundName) + { + delete iAlarmSoundName; + iAlarmSoundName = NULL; + } + iAlarmSoundName = aAlarmSoundName.AllocL(); + } + +/** +MEikServAlarm implementation. Prints that it was called. +Marks itself as Not-Playing. +@internalTechnology +@test +*/ +void CDummyAlarmControl::StopPlayAlarm() + { + TRAP_IGNORE(PrintWhoWasCalledL(TestMultipleAlarms::EStopPlayAlarm)); + iIsPlaying = EFalse; + } + +// +// MEikServAlarm callbacks Impelementations end +// + + +/** +Returns the alarm-message of the alarm associated with this object +@return The alarm-message of the alarm associated with this object +@internalTechnology +@test +*/ +const TDesC& CDummyAlarmControl::AlarmMessage() + { + return iAlarmMessage; + } + +/** +Returns the alarm-sound name of the alarm associated with this object +@return The alarm-sound name of the alarm associated with this object +@internalTechnology +@test +*/ +const TDesC& CDummyAlarmControl::AlarmSoundName() + { + return *iAlarmSoundName; + } + +/** +Returns a pointer to the supervisor associated with this alarm control object +@return A pointer to the supervisor associated with this alarm control object +@internalTechnology +@test +*/ +CEikAlmControlSupervisor* CDummyAlarmControl::Supervisor() + { + return iSupervisor; + } + +/** +Returns the alarm object associated with this alarm control object +@return The alarm object associated with this alarm control object +@internalTechnology +@test +*/ +const TASShdAlarm& CDummyAlarmControl::AlarmObject() + { + return iAlarm; + } + +/** +Returns the IsSnoozed flag of this object +@return The IsSnoozed flag of this object +@internalTechnology +@test +*/ +TBool CDummyAlarmControl::IsSnoozed() + { + return iIsSnoozed; + } + +/** +Returns the IsShowing flag of this object +@return The IsShowing flag of this object +@internalTechnology +@test +*/ +TBool CDummyAlarmControl::IsShowing() + { + return iIsShowing; + } + +/** +Returns the actual time the alarm corresponding to this object got notified +@return The actual time the alarm corresponding to this object got notified +@internalTechnology +@test +*/ +TTime CDummyAlarmControl::ActualNotificationTime() + { + return iMyNotificationTime; + } + +/** +Returns the original expiry time of the alarm corresponding to this object +@return The original expiry time of the alarm corresponding to this object +@internalTechnology +@test +*/ +TTime CDummyAlarmControl::OriginalExpiryTime() + { + return iOrigExpTime; + } + +/** +Returns the minutes to snooze value +@return The minutes to snooze value +@internalTechnology +@test +*/ +TInt CDummyAlarmControl::MinsToSnooze() + { + return iMinsToSnooze; + } + + +/** +Prints which call-back was called by the alert server +@param aAlarmControlState The enumeration identifying the call-back +@internalTechnology +@test +*/ +void CDummyAlarmControl::PrintWhoWasCalledL(TestMultipleAlarms::TAlarmControlState aAlarmControlState) const + { + _LIT(KLineFeed, "\n"); + _LIT(KWasCalledOn, "*** DUMMY ALARM CONTROL *** :- %S was called on %S"); + TPtrC callBackName = iMyManager->GetFunctionName(aAlarmControlState); + HBufC* message = HBufC::NewL(KWasCalledOn().Length() + callBackName.Length() + iAlarmMessage.Length()); + message->Des().Format(KWasCalledOn(), &callBackName, &iAlarmMessage); + message->Des().Insert(0, KLineFeed); + message->Des().Append(KLineFeed); + iMyManager->PrintLog(message->Des()); + delete message; + } +