examples/AppServices/AlarmServer/AlarmServerExample.cpp

/*
Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description:  
*/


// System includes
#include <e32base.h>
#include <e32cons.h>
#include <asshdalarm.h>
#include <asclisession.h>

// Local includes
#include "AlarmServerExample.h"

// Global definition
static CConsoleBase* gConsole;
// Strings for display
_LIT(KConsoleStars,"\n*************************");

CExampleAlarmServer* CExampleAlarmServer::NewL()
        {
        CExampleAlarmServer* self = new (ELeave) CExampleAlarmServer();
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop(self);
        return self;
        }
        
void CExampleAlarmServer::ConstructL()
        {
        // connect to the alarm server
        User::LeaveIfError(iAlarmServerSession.Connect());
        }       
        
CExampleAlarmServer::~CExampleAlarmServer()     
        {
        iAlarmServerSession.Close();
        }

// Called each time the alarm server generates an event. Displays a description of the event.
void CExampleAlarmServer::DisplayNotificationType(TAlarmChangeEvent aAlarmChangeEvent, TAlarmId /*aAlarmId*/)
        {
        switch (aAlarmChangeEvent)
                {
                case EAlarmChangeEventUndefined:
                        _LIT(KConsoleMsg, "\nAn undefined alarm event has occurred.");
                        gConsole->Printf(KConsoleMsg);
                        break;
                case EAlarmChangeEventState:
                        _LIT(KConsoleMsg1, "\nAn alarm has changed state.");
                        gConsole->Printf(KConsoleMsg1);
                        break;
                case EAlarmChangeEventStatus:
                        _LIT(KConsoleMsg2, "\nAn alarm has changed status.");
                        gConsole->Printf(KConsoleMsg2);
                        break;
                case EAlarmChangeEventCharacteristics:
                        _LIT(KConsoleMsg3, "\nAn alarm has changed characteristics..");
                        gConsole->Printf(KConsoleMsg3);
                        break;
                case EAlarmChangeEventAlarmDeletion:
                        _LIT(KConsoleMsg4, "\nAn alarm has been deleted from the queue.");
                        gConsole->Printf(KConsoleMsg4);
                        break;
                case EAlarmChangeEventAlarmAddition:
                        _LIT(KConsoleMsg5, "\nAn alarm has been added to the queue.");
                        gConsole->Printf(KConsoleMsg5);
                        break;
                case EAlarmChangeEventTimerExpired:
                        _LIT(KConsoleMsg6, "\nAn alarm has expired.");
                        gConsole->Printf(KConsoleMsg6);
                        break;
                case EAlarmChangeEventSoundPlaying:
                        _LIT(KConsoleMsg7, "\nThe sound for an alarm has just started playing.");
                        gConsole->Printf(KConsoleMsg7);
                        break;
                case EAlarmChangeEventSoundStopped:
                        _LIT(KConsoleMsg8, "\nThe sound for an alarm has just stopped playing.");
                        gConsole->Printf(KConsoleMsg8);
                        break;
                case EAlarmChangeEventPlayIntervalsChanged:
                        _LIT(KConsoleMsg9, "\nThe sound intervals associated with sound timing have changed.");
                        gConsole->Printf(KConsoleMsg9);
                        break;
                case EAlarmChangeEventGlobalSoundStateChanged:
                        _LIT(KConsoleMsg10, "\nThe global sound state (on/off) has changed.");
                        gConsole->Printf(KConsoleMsg10);
                        break;
                case EAlarmChangeEventHeadQueueItemChanged:
                        _LIT(KConsoleMsg11, "\nThe next alarm at the head of the alarm queue has changed.");
                        gConsole->Printf(KConsoleMsg11);
                        break;
                case EAlarmChangeEventSystemDateTimeChanged:
                        _LIT(KConsoleMsg12, "\nThe system date or time has changed, or the days defined as workdays have changed.");
                        gConsole->Printf(KConsoleMsg12);
                        break;
                case EAlarmChangeEventAlarmUIVisible:
                        _LIT(KConsoleMsg13, "\nThe alarm alert server has been instructed to show the 'alarm expired' display.");
                        gConsole->Printf(KConsoleMsg13);
                        break;
                case EAlarmChangeEventAlarmUIInvisible:
                        _LIT(KConsoleMsg14, "\nThe alarm alert server has been instructed to hide the 'alarm expired' display.");
                        gConsole->Printf(KConsoleMsg14);
                        break;
                case EAlarmChangeEventSoundSilence:
                        _LIT(KConsoleMsg15, "\nAlarm sounds have been temporarily silenced, the current alarm has been paused or re-enabled.");
                        gConsole->Printf(KConsoleMsg15);
                        break;
                case EAlarmChangeEventAlarmData:
                        _LIT(KConsoleMsg16, "\nThe data associated with an alarm has changed.");
                        gConsole->Printf(KConsoleMsg16);
                        break;
                case EAlarmChangeEventRestoreStarted:
                        _LIT(KConsoleMsg17, "\nA restore from backup of the alarm server has started. Alarms cannot be added/deleted until this has finished.");
                        gConsole->Printf(KConsoleMsg17);
                        break;
                case EAlarmChangeEventRestoreFailed:
                        _LIT(KConsoleMsg18, "\nA restore from backup of the alarm server has failed. Alarms can be added/deleted again.");
                        gConsole->Printf(KConsoleMsg18);
                        break;
                case EAlarmChangeEventRestoreCompleted:
                        _LIT(KConsoleMsg19, "\nA restore from backup of the alarm server has completed. The alarm queue has changed.");
                        gConsole->Printf(KConsoleMsg19);
                        break;
                case EAlarmChangeEventLast:
                        _LIT(KConsoleMsg20, "\nLast change event (anchor). This is always at the end of the list.");
                        gConsole->Printf(KConsoleMsg20);
                        break;
                }
        }
        

// Waits for the alarm to be cleared by the user.
// In the meantime, prints out descriptions of all change events generated by server.
void CExampleAlarmServer::WaitForAlarmToBeCleared()
        {
        TAlarmChangeEvent alarmChangeEvent;
        do
                {
                TRequestStatus status;  
                TAlarmId alarmId;
                iAlarmServerSession.NotifyChange(status, alarmId);
                User::WaitForRequest(status);
                alarmChangeEvent = static_cast<TAlarmChangeEvent>(status.Int());
                DisplayNotificationType(alarmChangeEvent,alarmId);
                }
        // EAlarmChangeEventAlarmUIInvisible is generated when the alarm is cleared
        while (alarmChangeEvent != EAlarmChangeEventAlarmUIInvisible);
        }
        
// Sets a floating alarm and adds it to the alarmserver queue.
// This is an alarm that is set using local time, for example a morning wake up call.
void CExampleAlarmServer::SetFloatingAlarmL()
        {
        /*
        There are two types of alarms - floating and fixed.
        For a floating alarm, time is set in local time by using TASShdAlarm::NextDueTime().
        A floating alarm will be rescheduled when the UTC offset is changed.

        In case of fixed alarms, time is set in UTC by using TASShdAlarm::SetUtcNextDueTime().
        A fixed alarm will not be rescheduled when the UTC offset is changed.
        */
        _LIT(KConsoleMsg, "\nPress any key to add a floating alarm");
        gConsole->Printf(KConsoleMsg);
        _LIT(KConsoleMsg2,"\nWhen notification occurs, press Clear to continue");
        gConsole->Printf(KConsoleMsg2);
        gConsole->Getch();
        gConsole->Printf(KConsoleStars);

        TASShdAlarm alarm;
        alarm.Category() = KASCliCategoryClock;
        // Alarm occurs once, today. This is the default.
        alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
        _LIT(KAlarmMessage,"\nThis is a floating alarm.");
        alarm.Message() = KAlarmMessage;
        // Get the local time and set it as the alarm's due time
        alarm.NextDueTime().HomeTime();
        // Set alarm to expire in the past - should go off immediately.
        // Note that if the alarm was of type EAlarmRepeatDefintionRepeatNext24Hours
        // it would expire tomorrow.
        alarm.NextDueTime() -= TTimeIntervalSeconds(2); 
        
        // WriteUserData capability is required to add an alarm
        User::LeaveIfError(iAlarmServerSession.AlarmAdd(alarm));
        // Wait for the user to clear the alarm
        WaitForAlarmToBeCleared();
        }

// Displays the state of the alarm
void CExampleAlarmServer::DisplayAlarmState(TAlarmState aState)
        {
        switch (aState)
                {
                case EAlarmStateInPreparation:
                        _LIT(KConsoleMsg1, "\nThe alarm state is not currently known by the alarm server..");
                        gConsole->Printf(KConsoleMsg1);
                        break;
                case EAlarmStateQueued:
                        _LIT(KConsoleMsg2, "\nThe alarm is in the queue.");
                        gConsole->Printf(KConsoleMsg2);
                        break;
                case EAlarmStateSnoozed:
                        _LIT(KConsoleMsg3, "\nThe alarm is snoozed. When the snooze period is over, the alarm expires again.");
                        gConsole->Printf(KConsoleMsg3);
                        break;
                case EAlarmStateWaitingToNotify:
                        _LIT(KConsoleMsg4, "\nThe alarm is waiting to be notified.");
                        gConsole->Printf(KConsoleMsg4);
                        break;
                case EAlarmStateNotifying:
                        _LIT(KConsoleMsg5, "\nThe alarm is currently notifying"); 
                        gConsole->Printf(KConsoleMsg5);
                        break;
                case EAlarmStateNotified:
                        _LIT(KConsoleMsg6, "\nThe alarm has already notified and has been dismissed.");
                        gConsole->Printf(KConsoleMsg6);
                        break;
                }
        }
        

// Sets a fixed alarm and adds it to the alarmserver's queue.
// This is an alarm that is set using UTC, so will not change if 
// for instance the system time zone changes.
// This function fetches and prints alarm details.
void CExampleAlarmServer::AddFetchDeleteFixedAlarmL()
        {
        gConsole->Printf(KConsoleStars);
        _LIT(KConsoleMsg, "\nPress any key to add a fixed alarm");
        gConsole->Printf(KConsoleMsg);
        gConsole->Getch();

        TASShdAlarm alarm;
        TAlarmCategory alarmCategory = KASCliCategoryClock;
        alarm.Category()=alarmCategory;
        _LIT(KAlarmMessage, "This is a fixed alarm");
        alarm.Message() = KAlarmMessage;
        _LIT(KAlarmSound, "Chimes");
        alarm.SoundName() = KAlarmSound;
    // Alarm occurs once. 
    alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
    
        TTime time;
        // Time is set in UTC for a fixed alarm 
        time.UniversalTime();
        // Set alarm to expire in 2 seconds. 
        time += TTimeIntervalSeconds(2);
        alarm.SetUtcNextDueTime(time);
        
        // WriteUserData capability is required to add an alarm
        User::LeaveIfError(iAlarmServerSession.AlarmAdd(alarm));
  
        // Fetch some details about the alarm from the server and print them
        const TAlarmId id = alarm.Id();
        TAlarmCategory category;
        User::LeaveIfError(iAlarmServerSession.GetAlarmCategory(id, category));
        User::LeaveIfError(iAlarmServerSession.GetAlarmDetails(id, alarm));

        TAlarmState state = alarm.State();
        DisplayAlarmState(state);
        
        TAlarmMessage message = alarm.Message();
        TBuf<256> messageBuf;
        messageBuf.Copy(message);
        _LIT(KConsoleMessage,"\nThe alarm's message is....:");
        gConsole->Printf(KConsoleMessage);
        gConsole->Printf(messageBuf);
        
        TAlarmSoundName soundName = alarm.SoundName();
        messageBuf.Copy(soundName);
        _LIT(KConsoleSoundName,"\nThe alarm's sound name is ....:");
        gConsole->Printf(KConsoleSoundName);
        gConsole->Printf(messageBuf);
                
        _LIT(KDeleteMsg, "\n\nPress any key to finish");
        gConsole->Printf(KDeleteMsg);
        gConsole->Getch();

        User::LeaveIfError(iAlarmServerSession.AlarmDelete(id));
        }
        

void CExampleAlarmServer::EgAlarmServerL()
        {
        SetFloatingAlarmL();
        AddFetchDeleteFixedAlarmL();
        }

static void DoExampleL()
        {
        // Create the console to print the messages to.
        _LIT(KConsoleMessageDisplay, "Alarm Server Example");
        gConsole = Console::NewL(KConsoleMessageDisplay,TSize(KConsFullScreen,KConsFullScreen));
        CleanupStack::PushL(gConsole);
        gConsole->Printf(KConsoleMessageDisplay);
        gConsole->Printf(KConsoleStars);

        CExampleAlarmServer* egAlarmServer= CExampleAlarmServer::NewL();
        TRAPD(err, egAlarmServer->EgAlarmServerL());
        if (err)
                {
                _LIT(KFailed,"\n\nExample failed: leave code=%d");
                gConsole->Printf(KFailed, err);
                gConsole->Getch();
                }
        delete egAlarmServer;   
        CleanupStack::PopAndDestroy(gConsole);
        }

// Standard entry point function
TInt E32Main()
        {
        __UHEAP_MARK;
        // Active scheduler required as this is a console app
        CActiveScheduler* scheduler=new CActiveScheduler;
        // If active scheduler has been created, install it.
        if (scheduler)
                {
                CActiveScheduler::Install(scheduler);
                // Cleanup stack needed
                CTrapCleanup* cleanup=CTrapCleanup::New();
                if (cleanup)
                        {
                        TRAP_IGNORE(DoExampleL());
                        delete cleanup;
                        }
                delete scheduler;
                } 
        __UHEAP_MARKEND;
        return KErrNone;
        }

---