diff -r 000000000000 -r 2f259fa3e83a commonuisupport/uikon/srvsrc/EIKALSUP.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonuisupport/uikon/srvsrc/EIKALSUP.CPP Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,421 @@ +// Copyright (c) 1997-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: +// MultiAlrm version of supervisor +// +// + +/** + @file +*/ + +// System includes +#include +#include +#include + +// User includes +#include "EIKSRV.PAN" +#include "EIKALSUP.H" +#include + +// Constants +const TInt KAlarmMinuteInMicroSeconds = 60000000; + +// See eiksrv.cpp for initialization of +// EXPORT_C extern const TInt KEikAlarmDefaultSnoozeInMinutes + +CEikAlmControlSupervisor* CEikAlmControlSupervisor::NewLC(MEikServAlarmFactory& aAlarmControl, CEikServAlarmAlertSession* aSession) + { + CEikAlmControlSupervisor* supervisor = new (ELeave) CEikAlmControlSupervisor(); + CleanupStack::PushL(supervisor); + supervisor->ConstructL(aAlarmControl, aSession); + return supervisor; + } + +void CEikAlmControlSupervisor::ConstructL(MEikServAlarmFactory& aAlarmControlFactory, CEikServAlarmAlertSession* aSession) + { + iMinuteCountDown = CPeriodic::NewL(ESnoozeCountDownPriority); + iAlarmAlert = aAlarmControlFactory.NewAlarmL(*this); + iSession = aSession; + } + +CEikAlmControlSupervisor::CEikAlmControlSupervisor() + { + } + +CEikAlmControlSupervisor::~CEikAlmControlSupervisor() + { + delete iMinuteCountDown; + delete iAlarmData; + + if (iAlarmAlert) + iAlarmAlert->Release(); + } + +/** +Services requests to the server +@param aMessage Message from client. +@internalTechnology +*/ +void CEikAlmControlSupervisor::ServiceL(const RMessage2 &aMessage) + { + __ASSERT_DEBUG(iAlarmAlert, Panic(EEsPanicAlarmAlert)); + __ASSERT_DEBUG(!aMessage.IsNull(), Panic(EEsPanicAlarmAlert)); + + switch (aMessage.Function()) + { + case EASAltOpCodeVisible: + case EASAltOpCodeVisibleAll: + SetVisibility(aMessage.Int0()); + break; + case EASAltOpCodeSetState: + case EASAltOpCodeSetStateAll: + iAlarmAlert->UpdateForAlarmServerState(aMessage.Int0()); + break; + case EASAltOpCodeSetAlarm: + UpdateAlarmInfoL(aMessage); + break; + case EASAltOpCodeStartPlayingSound: + StartPlayAlarmL(aMessage); + break; + case EASAltOpCodeStopPlayingSound: + case EASAltOpCodeStopPlayingSoundAll: + StopPlayAlarm(); + break; + default: + break; + } + } + +/** +@internalTechnology +*/ +void CEikAlmControlSupervisor::CancelTimeCountDown() + { + iMinuteCountDown->Cancel(); + } + +void CEikAlmControlSupervisor::SetVisibility(TBool aVisible) + { + iVisible = aVisible; + + if (aVisible) + iAlarmAlert->ShowAlarm(); + else + iAlarmAlert->HideAlarm(); + } + +/** +Static callback function. Decrements snooze minutes +@param aAlarmControl Pointer to this. Gets cast to CEikAlarmControlSupervisor* +@internalComponent +*/ +TInt CEikAlmControlSupervisor::CallbackSnoozeDecrement(TAny *aAlarmControl) + { + __ASSERT_ALWAYS(aAlarmControl, Panic(EEsPanicAlarmAlert)); + static_cast(aAlarmControl)->DecrementSnoozeMinutes(); + return KErrNone; + } + +/** +@internalComponent +*/ +void CEikAlmControlSupervisor::DecrementSnoozeMinutes() + { + iPauseSoundMinutes--; + iAlarmAlert->UpdateSoundPauseTimeInterval(iPauseSoundMinutes); + if (iPauseSoundMinutes <= 0) + CancelTimeCountDown(); + } + +/** +@internalComponent +*/ +void CEikAlmControlSupervisor::StartTimeCountDown() + { + TCallBack callback(&CallbackSnoozeDecrement, this); + CancelTimeCountDown(); + iMinuteCountDown->Start(KAlarmMinuteInMicroSeconds, KAlarmMinuteInMicroSeconds, callback); + iAlarmAlert->UpdateSoundPauseTimeInterval(iPauseSoundMinutes); + } + +/** +@internalTechnology +*/ +void CEikAlmControlSupervisor::SynchronizeCountDownTimer() + { + CancelTimeCountDown(); + + TTime now; + now.UniversalTime(); + if (iPauseSoundDueTime > now) + { + // sychronise timer (needed when machine has been turned off during snooze) + TTimeIntervalSeconds seconds; + iPauseSoundDueTime.SecondsFrom(now, seconds); + iPauseSoundMinutes = (seconds.Int()/60)+1; // +1 because will be called back in less than a minute + + const TInt delay = ((seconds.Int())%60)*1000000; // pity there's no TTime::MicroSeconds32From :-( + const TCallBack callback(&CallbackSnoozeDecrement, this); + iMinuteCountDown->Start(delay, KAlarmMinuteInMicroSeconds, callback); + } + else + iPauseSoundMinutes = 0; + + TASAltClientServerStateFlags alarmState(iAlarmAlert->CurrentServerState()); + + if (!((alarmState[EASAltStateFlagsInQuietPeriod] || + alarmState[EASAltStateFlagsSilentRunning] || + alarmState[EASAltStateFlagsAlarmHasNoSoundFileName]) && + (iPauseSoundMinutes==0))) + { + iAlarmAlert->UpdateSoundPauseTimeInterval(iPauseSoundMinutes); + } + } + + +/** +Update the alerts information on the current alarm. Extracts owner and establishes whether alarm time is local +@param aMessage Message from client. EASAltOpCodeSetAlarm +@internalComponent +*/ +void CEikAlmControlSupervisor::UpdateAlarmInfoL(const RMessage2& aMessage) + { + const TInt KDataSlot = 2; + iPauseSoundMinutes = 0; + iMinuteCountDown->Cancel(); + iPauseSoundDueTime.UniversalTime(); + + TASShdAlarm alarm; + TPckg pAlarm(alarm); + aMessage.ReadL(0, pAlarm); + iAlarmId = alarm.Id(); + + TFullName owner; + aMessage.ReadL(1, owner); + + // Create new alarm data (use temporary newAlarmData and reassign iAlarmData on success) + HBufC8* newAlarmData = NULL; + if(alarm.HasAssociatedData()) + { + const TInt desLength = aMessage.GetDesLengthL(KDataSlot); + newAlarmData = HBufC8::NewLC(desLength); // Push in case ReadL() below leaves + TPtr8 readPtr(newAlarmData->Des()); + aMessage.ReadL(KDataSlot, readPtr); + } + else + { + newAlarmData = HBufC8::NewLC(0); + } + + delete iAlarmData; + iAlarmData = newAlarmData; + CleanupStack::Pop(newAlarmData); + newAlarmData = NULL; + + // These lines will make sure the alert server is given the alarm in local time, if the alarm is + // set in local time (a floating alarm) + //------------------------------------------- + if (alarm.IsFloating()) + { + TTimeIntervalSeconds offset = User::UTCOffset(); + if (alarm.NextDueTime() != Time::NullTTime()) + alarm.NextDueTime() += offset; + + if (alarm.OriginalExpiryTime() != Time::NullTTime()) + alarm.OriginalExpiryTime() += offset; + } + + iAlarmAlert->UpdateAlarmInfo(alarm, owner); + iAlarmAlert->UpdateForAlarmServerState(iAlarmAlert->CurrentServerState()); + } + +/** +This method will trigger a new alarm in aMinutesToSnooze minutes and start the +alarm timer. + +@internalTechnology */ +TTime CEikAlmControlSupervisor::ReturnTimeToSnooze(TInt aMinutesToSnooze) + { + if (iPauseSoundMinutes <= 0) + iPauseSoundMinutes = aMinutesToSnooze; + + iPauseSoundDueTime.UniversalTime(); + iPauseSoundDueTime += TTimeIntervalMinutes(iPauseSoundMinutes); + + const TTime time = iPauseSoundDueTime; + StartTimeCountDown(); + return time; + } + + + +void CEikAlmControlSupervisor::StartPlayAlarmL(const RMessage2& aMessage) + { + TBuf alarmSoundName; + aMessage.ReadL(0, alarmSoundName); + iAlarmAlert->StartPlayAlarmL(alarmSoundName); + } + + +void CEikAlmControlSupervisor::StopPlayAlarm() + { + iAlarmAlert->StopPlayAlarm(); + } + + +/** +Acknowledges a notifying alarm +(i.e. an alarm that is going off or has expired). + +When an alarm has expired, the alarm control is notified and can call +this function to acknowledge the alarm. +*/ +EXPORT_C void CEikAlmControlSupervisor::CmdAcknowledgeAlarm() + { + if (iSession) + { + TRAP_IGNORE(iSession->RespondEventL(EASAltAlertServerResponseClear, AlarmId())); + } + } + +/** +Acknowledges all notifying alarms +(i.e. all alarms that are going off or have expired). + +When an alarm has expired, the alarm control is notified and can call +this function to acknowledge all alarms that are currently notifying. +*/ +EXPORT_C void CEikAlmControlSupervisor::CmdAcknowledgeAllAlarms() + { + if (iSession) + { + TRAP_IGNORE(iSession->ClearAllAlarmsL()); + } + } + + + +/** +Increases the alarm's snooze period by the specified number of minutes. + +If the alarm has expired, it is snoozed by aNumMinutes. +MEikServAlarm::UpdateSoundPauseTimeInterval() is called, which might, for instance, +update the view to display the new snooze period. + +@param aNumMinutes The number of minutes to add to the snooze period. +*/ +EXPORT_C void CEikAlmControlSupervisor::CmdPauseAlarmSoundL(TInt aNumMinutes) + { + // If the argument is KUseDefaultAlarmSnoozeIncrement (minus one) then change it to KAlarmDefaultSnoozeInMinutes. + // The use of KUseDefaultAlarmSnoozeIncrement as default argument (rather than KAlarmDefaultSnoozeInMinutes) + // is needed to allow KAlarmDefaultSnoozeInMinutes being ROM patchable constant. + if(aNumMinutes == KEikUseDefaultAlarmSnoozeIncrement) + aNumMinutes = KEikAlarmDefaultSnoozeInMinutes; + + if(iPauseSoundMinutes + aNumMinutes <= 0) + return; + + iPauseSoundMinutes += aNumMinutes; + + // Update the client's TTime so that they don't need to + // call "ReturnTimeToSnoozeL" (synchronous) in response to + // an asynch completion here... + const TTime time = ReturnTimeToSnooze(KEikAlarmDefaultSnoozeInMinutes); + if (iSession) + iSession->RespondEventL(EASAltAlertServerResponsePauseSound, AlarmId(), time); + } + +/** +Silences the alarm sound that is playing, without changing the alarm's state. +*/ +EXPORT_C void CEikAlmControlSupervisor::CmdSilenceAlarmSound() + { + if (iSession) + { + TRAP_IGNORE(iSession->RespondEventL(EASAltAlertServerResponseSilence, AlarmId())); + } + } + + +/** +If an alarm has expired, this function snoozes it for the default +period (e.g. 5 minutes). + +This function shall be called in response to the user switching away from the +application when an alarm has expired. + +@return Always ETrue. +*/ +EXPORT_C TBool CEikAlmControlSupervisor::CmdTaskAwayFromAlarmL() + { + return CmdTaskAwayFromAlarmL(KEikAlarmDefaultSnoozeInMinutes); + } + +/** +If an alarm has expired, this function snoozes it for specified snooze period. + +This function shall be called in response to the user switching away from the +application when an alarm has expired. + +@param aMinutesToSnooze Minutes to be added to the snooze period. +@return Always ETrue. +*/ +EXPORT_C TBool CEikAlmControlSupervisor::CmdTaskAwayFromAlarmL(TInt aMinutesToSnooze) + { + // Update the client's TTime so that they don't need to + // call "ReturnTimeToSnoozeL" (synchronous) in response to + // an asynch completion here... + aMinutesToSnooze = Max(1, aMinutesToSnooze); //minimum snooze time is one minute, to avoid live lock between alarm server & eik server + const TTime time = ReturnTimeToSnooze(aMinutesToSnooze); + if (iSession) + { + iSession->RespondEventL(EASAltAlertServerResponseSnooze, AlarmId(), time); + } + return ETrue; + } + + +TBool CEikAlmControlSupervisor::IsVisible() const + { + return iVisible; + } + + +TAlarmId CEikAlmControlSupervisor::AlarmId() const + { + return iAlarmId; + } + +/** +Gets data associated with alarm. + +@param aData Application specific 8-bit data that was queued with the Alarm. +@return KErrNotFound if no data is associated with current alarm, KErrNone otherwise. +*/ +EXPORT_C TDesC8& CEikAlmControlSupervisor::AlarmData() const + { + return *iAlarmData; + } + + +EXPORT_C void CEikAlmControlSupervisor::CEikAlmControlSupervisor_Reserved1() + { + } + + +EXPORT_C void CEikAlmControlSupervisor::CEikAlmControlSupervisor_Reserved2() + { + } +