diff -r 000000000000 -r 2f259fa3e83a commonuisupport/uikon/test/teiksrv/tnotdial/TNOTDIAL.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonuisupport/uikon/test/teiksrv/tnotdial/TNOTDIAL.CPP Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,2244 @@ +// 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: +// 1. What is the test code testing? +// TNotdial has been designed to exercise the API of the extended notifier +// framework. The extended notifier framework has +// support for priorities, channels, and plugin-in implementation modules --- see the +// tplugin.* files. +// When the notifier framework is started for the first time Connect is called on +// a RNotifier object. The manager is created and Register is called and the plug-in +// dll implementing the MEikSrvNotifierbase2 classes: +// CMyPhoneNotifierSubject +// CMyLEDPhoneNotifierSubject +// CMyLEDLowBatteryNotifierSubject +// CMyLowBatteryNotifierSubject +// CMyAgendaNotifierSubject +// CMyLEDAgendaNotifierSubject +// is created and registered in the list of notifiers owned by the manager class. +// The basic tests performed are starting notifiers, updating notifiers and cancelling +// notifiers. Notifiers for phone, agenda and low battery can be requested. Each notifier +// has two channels visually displayed as a busy message and dialog in the middle of the +// screen. Updates are displayed along the bottom of the screen as info messages. +// Messages when starting agenda notifier asynchronously are displayed as info messages +// along the top of the screen. The notifiers have been assigned priorities with Low +// Battery having the highest and Agenda the lowest. When a notifier is already displayed, +// and another request is called on a notifier with a higher notifier priority on the same +// channel, the high priority notifier has focus, and the low priority notifier remains +// in the background where it can be updated. When a notifier is alreday displayed, and +// another request is called on a notifier with a lower priority on the same channel, +// nothing happens until the high priority notifier is in an idle state. +// 2. The APIs: +// ------ class RNotifier +// TInt Connect() +// Creates a session to the extended notifier server, if the server isn't started already, +// it will be started, and the plug-in dll(s) will be loaded. Returns an error code. +// Tint StartNotifier(TUid aNotifierUid, const TDesC8& aBuffer,TDes8& aResponse) +// When started the two channels for a notifier appear as a busy message and dialog, +// horizontally, in the middle of the display. The busy message on the left displays +// the contents of aBuffer. +// TInt CancelNotifier(TUid aNotifierUid) +// This removes the two channels from the screen +// TInt UpdateNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse) +// When a notifier is already displayed and another request is called on a notifier with a higher priority +// on the same channel, the high priority notifier has focus and the low priority notifier +// remains in updated in the background. Updates are displayed as info messages along the +// bottom of the screen --- an info message on the left displays the content of aBuffer +// and an info message on the right displays the content of aResponse. If an update is not +// possible because the notifier has not been started, then a suitable info message is +// displayed in the bottom right hand corner. +// void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid, +// const TDesC8& aBuffer,TDes8& aResponse) +// This function is only implemented for Agenda. Calling results in Agenda channels +// displayed in the middle of screen as expected and an info message at the top left +// hand corner of the screen. If the call completes and returns, an info message displays +// aResponse at the top right hand corner of the screen. +// ------ class MEikSrvNotifierBase +// This is a mixin class and the following pure virtual functions from (eiknotapi.h) are +// implemented in the plug-in, (see tplugin.* files), for the notifiers +// virtual void Release() +// Called when all resources allocated by notifiers should be freed. +// TNotifierInfo RegisterL() +// Called when a notifier is first loaded to allow any initial construction +// that is required. +// TNotifierInfo Info() const +// Packages the notifier info, contains public members: +// TUid iUid - The notifier's own uid (e.g KPhoneNotifierUid) +// TUid iChannel - a Uid specifying which channel the notifier uses +// TNotifierPriority iPriority - the priority channel +// TPtrC8 StartL(const TDesC8& aBuffer) +// Will be called by the manager to start the notifier, the contents of the +// buffer are passed unchanged from RNotifier call (and in the test code displayed +// in the busy message representing the LED channel). +// void StartL(const TDesC8& aBuffer, const TAny* aReturnVal, RMessage aMessage) +// Same as above but asynchronous version. Response is returned to +// void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid, +// const TDesC8& aBuffer,TDes8& aResponse) +// by calling +// aMessage.WriteL(aReturnVal,descriptor). +// The test code calls +// StartL(const TDesC8& aBuffer), and then aMessage.WriteL(aReturnVal,descriptor), +// successful completion is noted by calling +// aMessage.Complete(EEikNotExtRequestCompleted); +// void Cancel() +// Will be called by the manager to stop the notifier. Nothing hapens when a call to +// cancel is made on a notifier that hasn't started. Calling cancel in the test code +// cancels the busy message and dialog channels. +// TPtrC8 UpdateL(const TDesC8& aBuffer) +// Will be called by the manager to update an already started notifier, the contents +// of aBuffer are passed unchanged from the RNotifier call and can be used by the notifier +// implementation. In the test code aBuffer is displayed as an info message at the +// bottom left hand corner of the screen. A response is returned to: +// TInt UpdateNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse) +// 3. The test code does not check the error codes returned by StartNotifier, UpdateNotifier +// and CancelNotifier. Also code and checks for the responses from +// StartL(const TDesC8& aBuffer) are not implemented. Only three of the 5 priority levels +// a notifier can have are implemented. +// +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + + + +#include +#include + +#include "tnotdial.h" + +#include "tpluginV2.h" +#include "tnotify2v2.h" +#include +#include +#include "w32std.h" +#include + + +// globals +_LIT(KTNOTDIALResourceFilePath, "z:\\system\\test\\tnotdial\\tnotdial.rsc"); + + +// +// Models +// + +/** + This method creates an empty control which provides the background for + the test step. + */ +void CEmptyControl::ConstructL(const TRect& aRect) + { + CreateWindowL(); + SetRect(aRect); + SetBlank(); + ActivateL(); + } + +// +// class CTNotdialAppUi +// + +CTNotdialAppUi::CTNotdialAppUi(CTmsTestStep* aTestStep) : + CTestAppUi(aTestStep, KTNOTDIALResourceFilePath, R_TNOT_HOTKEYS, R_TDLG_MENUBAR, R_TDLG_TOOLBAR) + { + } + +/** + This method copies notifiers along with its resource file from ROM to RAM + and connects to the extended notifier server. The method also creates an + empty control and a periodic timer. Once all the construction is completed + it prepares to execute the test step. + */ +void CTNotdialAppUi::ConstructL() + { + INFO_PRINTF1(_L("CTNotdialAppUi::ConstructL")); + + CTestAppUi::ConstructL(); + + iEmptyControl=new(ELeave) CEmptyControl; + iEmptyControl->ConstructL(ClientRect()); + + INFO_PRINTF1(_L("iNotifier Connect")); + User::LeaveIfError(iNotifier.Connect()); + iColor[0]=KRgbBlack; + iColor[1]=KRgbBlack; + iBattTimer = CPeriodic::NewL(CActive::EPriorityIdle); + + INFO_PRINTF1(_L("Start Auto Test")); + + iMyPhoneNotifierUid = KMyNewPhoneNotifierUid ; + iMySmsNotifierUid = KMyNewSmsNotifierUid ; + iMyEmailNotifierUid = KMyNewEmailNotifierUid; + iMyLowBatteryNotifierUid =KMyNewLowBatteryNotifierUid ; + iMyAgendaAlarmUid =KMyNewAgendaAlarmUid ; + + AutoTestManager().StartAutoTest(); + } + +CTNotdialAppUi::~CTNotdialAppUi() + { + delete iEmptyControl; + iNotifier.Close(); + if(iBattTimer->IsActive()) + { + iBattTimer->Cancel(); + } + delete iBattTimer; + } + +/** + The method is an override from CTestAppUi. The method initiates tests on + public APIs of RNotifier and MEikSrvNotifierBase. + */ +void CTNotdialAppUi::RunTestStepL(TInt aNextStep) + { + switch(aNextStep) + { + case 1: + SetTestStepID(_L("UIF-TNotdialStep-TestStep01L")); + TestStep01L(); + RecordTestResultL(); + break; + case 2: + SetTestStepID(_L("UIF-TNotdialStep-TestStep02L")); + TestStep02L(); + RecordTestResultL(); + break; + case 3: + SetTestStepID(_L("UIF-TNotdialStep-TestStep03L")); + TestStep03L(); + RecordTestResultL(); + break; + case 4: + SetTestStepID(_L("UIF-TNotdialStep-TestStep04L")); + TestStep04L(); + RecordTestResultL(); + break; + case 5: + SetTestStepID(_L("UIF-TNotdialStep-TestStep05L")); + TestStep05L(); + RecordTestResultL(); + break; + case 6: + SetTestStepID(_L("UIF-TNotdialStep-TestStep06L")); + TestStep06L(); + RecordTestResultL(); + break; + case 7: + SetTestStepID(_L("UIF-TNotdialStep-TestStep07L")); + TestStep07L(); + RecordTestResultL(); + break; + case 8: + SetTestStepID(_L("UIF-TNotdialStep-TestStep08L")); + TestStep08L(); + RecordTestResultL(); + break; + case 9: + SetTestStepID(_L("UIF-TNotdialStep-TestStep09L")); + TestStep09L(); + RecordTestResultL(); + break; + case 10: + SetTestStepID(_L("UIF-TNotdialStep-TestStep10L")); + TestStep10L(); + RecordTestResultL(); + break; + case 11: + SetTestStepID(_L("UIF-TNotdialStep-TestStep11L")); + TestStep11L(); + RecordTestResultL(); + break; + case 12: + SetTestStepID(_L("UIF-TNotdialStep-TestStep12L")); + TestStep12L(); + RecordTestResultL(); + break; + case 13: + SetTestStepID(_L("UIF-TNotdialStep-TestStep13L")); + TestStep13L(); + RecordTestResultL(); + break; + case 14: + SetTestStepID(_L("UIF-TNotdialStep-TestStep14L")); + TestStep14L(); + RecordTestResultL(); + break; + case 15: + SetTestStepID(_L("UIF-TNotdialStep-TestStep15L")); + TestStep15L(); + RecordTestResultL(); + break; + case 16: + SetTestStepID(_L("UIF-TNotdialStep-TestStep16L")); + TestStep16L(); + RecordTestResultL(); + break; + case 17: + SetTestStepID(_L("UIF-TNotdialStep-TestStep17L")); + TestStep17L(); + RecordTestResultL(); + break; + case 18: + SetTestStepID(_L("UIF-TNotdialStep-TestStep18L")); + TestStep18L(); + RecordTestResultL(); + break; + case 19: + SetTestStepID(_L("UIF-TNotdialStep-TestStep19L")); + TestStep19L(); + RecordTestResultL(); + break; + case 20: + SetTestStepID(_L("UIF-TNotdialStep-TestStep20L")); + TestStep20L(); + RecordTestResultL(); + break; + case 21: + SetTestStepID(_L("UIF-TNotdialStep-TestStep21L")); + TestStep21L(); + RecordTestResultL(); + break; + case 22: + TestStep22L(); + break; + case 23: + SetTestStepID(_L("UIF-TNotdialStep-TestStep23L")); + TestStep23L(); + RecordTestResultL(); + break; + case 24: + SetTestStepID(_L("UIF-TNotdialStep-TestStep24L")); + TestStep24L(); + RecordTestResultL(); + break; + case 25: + SetTestStepID(_L("UIF-TNotdialStep-TestStep25L")); + TestStep25L(); + RecordTestResultL(); + break; + case 26: + SetTestStepID(_L("UIF-TNotdialStep-TestStep26L")); + TestStep26L(); + RecordTestResultL(); + break; + case 27: + SetTestStepID(_L("UIF-TNotdialStep-TestStep27L")); + TestStep27L(); + RecordTestResultL(); + break; + case 28: + SetTestStepID(_L("UIF-TNotdialStep-TestStep28L")); + TestStep28L(); + RecordTestResultL(); + break; + case 29: + SetTestStepID(_L("UIF-NotdialStep-TestStep29L")); + TestStep29L(); + RecordTestResultL(); + break; + case 30: + SetTestStepID(_L("UIF-NotdialStep-TestStep30L")); + TestStep30L(); + RecordTestResultL(); + break; + case 31: + SetTestStepID(_L("UIF-NotdialStep-TestStep31L")); + TestStep31L(); + RecordTestResultL(); + break; + case 32: + SetTestStepID(_L("UIF-NotdialStep-TestStep32L")); + TestStep32L(); + RecordTestResultL(); + CloseTMSGraphicsStep(); + break; + case 33: + { + INFO_PRINTF1(_L("Last test case reached -> finishing!")); + CTestAppUi::AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass); + } + default: + break; + } + + INFO_PRINTF1(_L("Test case completed\n")); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep01L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() & RNotifier::CancelNotifier() + APIs. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTNotdialAppUi::HandleCommandL() to test + StartNotifier() & CancelNotifier() APIs for the following plug-in notifiers: + (a) Phone Ring Notifier. + (b) Low Battery Notifier. + (c) Agenda Alarm Notifier. + + @SYMTestExpectedResults The test verifies whether StartNotifier() & + CancelNotifier() method returns KErrNone on successful completion of + function call. + + */ +void CTNotdialAppUi::TestStep01L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 1:")); + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep02L + + @SYMPREQ + + @SYMTestCaseDesc Test cancelling the plug-in notifiers via dialog. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test method starts the plug-in notifier by calling + CTNotdialAppUi::HandleCommandL(). The test then connects to Windows Server + and simulates an ENTER key event on the notifier dialog to cancel. This test + is carried out for the following plug-in notifiers: + (a) Phone Ring Notifier. + (b) Low Battery Notifier. + (c) Agenda Alarm Notifier. + + @SYMTestExpectedResults The tests should be able to simulate the ENTER Key + for the notifier dialog and cancel the notifier. + + */ +void CTNotdialAppUi::TestStep02L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 2:")); + RWsSession ws; + TKeyEvent event; + + //Set up key event "enter" to simulate key enter to replace clicking "ok" on dialog. + event.iCode=event.iScanCode=EKeyEnter; + event.iModifiers=event.iRepeats=0; + + //Connect to Window Server Session + TEST(ws.Connect()==KErrNone); + + //Start Notifier + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + //Cancel Notifier using dialog + INFO_PRINTF1(_L("Cancel Phone Ring Notifier via dialog")); + + // Simulate key entry and flush the buffer to send event to windows server session. + ws.SimulateKeyEvent(event); + ws.Flush(); + + //Low battery notifier + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + INFO_PRINTF1(_L("Cancel Low Battery Notifier via dialog")); + + ws.SimulateKeyEvent(event); + ws.Flush(); + + //Agenda alarm notifier + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier via dialog")); + + ws.SimulateKeyEvent(event); + ws.Flush(); + ws.Close(); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep03L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::UpdateNotifier() API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test method starts the plug-in notifier by calling + RNotifier::StartNotifier(). It then calls CTNotdialAppUi::AppUpdate() + method which calls RNotifier::UpdateNotifier() to update the plug-in + notifier identified by the specified UID. The test then cancels the + notifier. The test is carried out for the following plug-in notifiers: + (a) Phone Ring Notifier. + (b) Low Battery Notifier. + (c) Agenda Alarm Notifier. + + @SYMTestExpectedResults The response received from RNotifier::UpdateNotifier() + is verified and displayed. + + */ +void CTNotdialAppUi::TestStep03L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 3:")); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Start Low Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Update Phone Ring Notifier.")); + HandleCommandL(EAppUpdateRingPhone); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Update Agenda Alarm Notifier")); + HandleCommandL(EAppUpdateAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep04L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::UpdateNotifier() API without starting the + plug-in notifier. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls CTNotdialAppUi::AddUpdate() which invokes + RNotifier::UpdateNotifier() to update the Low Battery Notifier without + starting the plug-in notifier. + + @SYMTestExpectedResults The response received from RNotifier::UpdateNotifier() + is verified and displayed. + + */ +void CTNotdialAppUi::TestStep04L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 4:")); + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep05L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() & RNotifier::CancelNotifier() + API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start + (i) Low Battery (ii) Ringing Phone & (iii) Agenda Alarm Notifiers one after + the other without cancelling any plug-in notifier. The test then cancels + them one after the other in the same order. + + @SYMTestExpectedResults RNotifier::Cancel() should return KErrNone & only + cancel the plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep05L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 5:")); + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep06L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() & RNotifier::CancelNotifier() + API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start notifiers + in the order (i) Low Battery (ii) Agenda Alarm & (iii) Ringing Phone + Notifier one after the other without cancelling any plug-in notifier. The + test then cancels them so that Low Battery notifier is first cancelled + followed by Ringing Phone and Agenda Alarm notifier. + + @SYMTestExpectedResults RNotifier::Cancel() should return KErrNone & only + cancel the plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep06L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 6:")); + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep07L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() & RNotifier::CancelNotifier() + API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start notifiers + in the order (i) Ringing Phone (ii) Low Battery & (iii) Alarm Agenda Notifier + one after the other without cancelling any plug-in notifier. The test then + cancels them so that Low Battery notifier is first cancelled followed by + Ringing Phone and Agenda Alarm notifier. + + @SYMTestExpectedResults RNotifier::Cancel() should return KErrNone & only + cancel the plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep07L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 7:")); + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep08L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() & RNotifier::CancelNotifier() + API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start notifiers + in the order (i) Ringing Phone (ii) Alarm Agenda & (iii) Low Battery + Notifiers one after the other without cancelling any plug-in notifier. The + test then cancels them so that Low Battery notifier is first cancelled + followed by Ringing Phone and Agenda Alarm notifier. + + @SYMTestExpectedResults RNotifier::Cancel() should return KErrNone & only + cancel the plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep08L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 8:")); + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep09L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() & RNotifier::CancelNotifier() + API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start notifiers + in the order (i) Alarm Agenda (ii) Ringing Phone & (iii) Low Battery + Notifier one after the other without cancelling any plug-in notifier. The + test then cancels them so that Low Battery notifier is first cancelled + followed by Ringing Phone and Agenda Alarm notifier. + + @SYMTestExpectedResults RNotifier::Cancel() should return KErrNone & only + cancel the plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep09L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 9:")); + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep10L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() & RNotifier::CancelNotifier() + API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start notifiers + in the order (i) Alarm Agenda (ii) Low Battery & (iii) Ringing Phone + Notifiers one after the other without cancelling any plug-in notifier. The + test then cancels them so that Low Battery notifier is first cancelled + followed by Ringing Phone and Agenda Alarm notifier. + + @SYMTestExpectedResults RNotifier::Cancel() should return KErrNone & only + cancel the plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep10L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 10:")); + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep11L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() ,RNotifier::CancelNotifier() + & RNotifier::UpdateNotifier() APIs. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start Low + Battery notifier followed by Phone Ringing Notifier without cancelling any + plug-in notifier. The test then calls UpdateNotifier() to update them so + that Low Battery notifier is first updated followed by Ringing Phone + updation.In the same order these notifiers are cancelled. + + @SYMTestExpectedResults The message from RNotifier::UpdateNotifer() is verified + and recorded. RNotifier::Cancel() should return KErrNone & only cancel the + plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep11L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 11:")); + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + INFO_PRINTF1(_L("Update Phone Ring Notifier.")); + HandleCommandL(EAppUpdateRingPhone); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep12L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() ,RNotifier::CancelNotifier() + & RNotifier::UpdateNotifier() APIs. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start Phone + Ringing notifier followed by Low Battery notifier without cancelling any + plug-in notifier. The test then calls UpdateNotifier() to update them so + that Low Battery notifier is first updated followed by Phone Ringing + updation.Now the Low Battery notifier is cancelled followed by Phone + Ringing notifier cancellation. + + @SYMTestExpectedResults The message from RNotifier::UpdateNotifer() is verified + and recorded. RNotifier::Cancel() should return KErrNone & only cancel the + plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep12L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 12:")); + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + INFO_PRINTF1(_L("Update Phone Ring Notifier.")); + HandleCommandL(EAppUpdateRingPhone); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep13L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() ,RNotifier::CancelNotifier() + & RNotifier::UpdateNotifier() APIs. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start Alarm + Agenda notifier followed by Low Battery notifier which is followed by + Phone Ringing notifier without cancelling any plug-in notifier. The test + then calls UpdateNotifier() to update them so that Phone Ringing notifier + is first updated followed by Low Battery notifier updation which is followed + by Alarm Agenda notifier updation.The Low Battery notifier is cancelled first, + followed by Phone Ringing notifier and Alarm Agenda notifier cancellation. + + @SYMTestExpectedResults The message from RNotifier::UpdateNotifer() is verified + and recorded. RNotifier::Cancel() should return KErrNone & only cancel the + plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep13L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 13:")); + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + INFO_PRINTF1(_L("Update Phone Ring Notifier.")); + HandleCommandL(EAppUpdateRingPhone); + + INFO_PRINTF1(_L("Update Agenda Alarm Notifier")); + HandleCommandL(EAppUpdateAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep14L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() ,RNotifier::CancelNotifier() + & RNotifier::UpdateNotifier() APIs. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start Phone + Ringing notifier followed by Alarm Agenda notifier and Low Battery + notifier started without cancelling any plug-in notifier. The test then + calls UpdateNotifier() to update them so that Low Battery notifier is first + updated followed by Phone Ringing notifier and Alarm Agenda notifier + updation. Then the Low Battery notifier is cancelled first followed by Phone + Ringing notifier and Alarm Agenda notifier cancellation. + + @SYMTestExpectedResults The message from RNotifier::UpdateNotifer() is verified + and recorded. RNotifier::Cancel() should return KErrNone & only cancel the + plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep14L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 14:")); + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + INFO_PRINTF1(_L("Update Phone Ring Notifier.")); + HandleCommandL(EAppUpdateRingPhone); + + INFO_PRINTF1(_L("Update Agenda Alarm Notifier")); + HandleCommandL(EAppUpdateAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep15L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() ,RNotifier::CancelNotifier() + & RNotifier::UpdateNotifier() APIs. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifier() to start Low Battery + notifier followed by Phone Ringing notifier and Alarm Agenda notifier + without cancelling any plug-in notifier. The test then calls + UpdateNotifier() to update them so that Low Battery notifier is first + updated followed by Phone Ringing notifier and Alarm Agenda notifier + updation.Then the Low Battery notifier is cancelled first followed by Phone + Ringing notifier and Alarm Agenda notifier cancellation. + + @SYMTestExpectedResults The message from RNotifier::UpdateNotifer() is verified + and recorded. RNotifier::Cancel() should return KErrNone & only cancel the + plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep15L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 15:")); + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + INFO_PRINTF1(_L("Update Phone Ring Notifier.")); + HandleCommandL(EAppUpdateRingPhone); + + INFO_PRINTF1(_L("Update Agenda Alarm Notifier")); + HandleCommandL(EAppUpdateAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep16L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifierAndGetResponse() & + RNotifier:: CancelNotifier() API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method connects to the extended notifier server and makes + an asynchronous requests to start the Alarm Agenda plug-in notifier by + calling RNotifier::StartNotifierAndGetResponse(). While the request is + outstanding the test attempts to cancel the Low Battery plug-in notifier + by calling RNotifier::CanelNotifier(). The response from CancelNotifier() + & response message on completion of asynchronous request + StartNotifierAndGetResponse() is observed. + + @SYMTestExpectedResults Test verifies that CancelNotifier returns KErrNone + even though the notifier is not started. It also verifies and displays the + response message on completion of asynchronous request + StartNotifierAndGetResponse() + + */ +void CTNotdialAppUi::TestStep16L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 16:")); + INFO_PRINTF1(_L("Start Agenda Alarm Notifier Status")); + HandleCommandL(EAppStartAgendaAlarmStatus); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep17L + + @SYMPREQ + + @SYMTestCaseDesc Test cancelling plug-in notifier started by + RNotifier::StartNotifierAndGetResponse() request. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method connects to the extended notifier server and makes + an asynchronous requests to start the Alarm Agenda plug-in notifier by + calling RNotifier::StartNotifierAndGetResponse(). Now the Low Battery + plug-in notifier is started by calling RNotifier::StartNotifier(). The test + now cancels the Alarm Agenda notifier followed by Low Battery notifier by + calling RNotifier::CancelNotifier(). + + @SYMTestExpectedResults Test verifies that RNotifier::CancelNotifier returns + KErrNone and cancels the notifier started by asynchronous method + RNotifier::StartNotifierAndGetResponse(). + + */ +void CTNotdialAppUi::TestStep17L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 17:")); + INFO_PRINTF1(_L("Start Agenda Alarm Notifier Status")); + HandleCommandL(EAppStartAgendaAlarmStatus); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep18L + + @SYMPREQ + + @SYMTestCaseDesc Test StartNotifier(), CancelNotifier() & + StartNotifierAndGetResponse() APIs. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method initially Starts & Cancels Low Battery plug-in + notifier. Now it starts Alarm Agenda notifer by calling + RNotifier::StartNotifierAndGetResponse(). Now Phone Ringing notifier is + started by calling RNotifier::StartNotifier(). Then the Alarm Agenda + notifier is cancelled followed by cancellation of Phone Ringing notifier. + + @SYMTestExpectedResults Test verifies that RNotifier::CancelNotifier returns + KErrNone and cancels the notifier started by asynchronous method + RNotifier::StartNotifierAndGetResponse(). + + */ +void CTNotdialAppUi::TestStep18L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 18:")); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Start Agenda Alarm Notifier Status")); + HandleCommandL(EAppStartAgendaAlarmStatus); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep19L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifierAndGetResponse(), RNotifier::StartNotifier() + & RNotifier::CancelNotifier() API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::StartNotifierAndGetResponse() to + start the Alarm Agenda notifier asynchronously. This is followed by calls + to RNotifier::StartNotifier() to start Low Battery & Phone Ringing Notifiers + one after the other without cancelling any plug-in notifier. The test then + cancels them one after the other in the same order by calling + RNotifier::CancelNotifier(). + + @SYMTestExpectedResults RNotifier::Cancel() should return KErrNone & only + cancel the plug-in notifier specifed by the UID. + + */ +void CTNotdialAppUi::TestStep19L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 19:")); + INFO_PRINTF1(_L("Start Agenda Alarm Notifier Status")); + HandleCommandL(EAppStartAgendaAlarmStatus); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Start Phone Ring Notifier")); + HandleCommandL(EAppRingPhone); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + + INFO_PRINTF1(_L("Cancel Phone Ring Notifier")); + HandleCommandL(EAppCancelRingPhone); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep20L + + @SYMPREQ + + @SYMTestCaseDesc Test Starting & Cancelling the SMS plug-in notifier. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test invokes RNotifier::StartNotifier() by specifying the + UID for SMS plug-in notifier to start the notifier. Then the test cancels + SMS notifier by invoking RNotifier::CancelNotifier(). + + @SYMTestExpectedResults The test verifies that StartNotifier() & + CancelNotifier() returns KErrNone on successful completion. + + */ +void CTNotdialAppUi::TestStep20L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 20:")); + INFO_PRINTF1(_L("Start SMS Notifier")); + HandleCommandL(EAppNewSms); + + INFO_PRINTF1(_L("Cancel SMS Notifier")); + HandleCommandL(EAppCancelSms); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep21L + + @SYMPREQ + + @SYMTestCaseDesc Test cancelling the SMS plug-in notifier via dialog. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test method starts the SMS plug-in notifier by calling + RNotifier::StartNotifier. The test then connects to Windows Server + and simulates an ENTER key event on the notifier dialog to cancel the SMS + plug-in notifier. + + @SYMTestExpectedResults The simulated ENTER Key on the notifier dialog should + cancel the SMS notifier. + + */ +void CTNotdialAppUi::TestStep21L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 21:")); + RWsSession ws; + TKeyEvent event; + + INFO_PRINTF1(_L("Start SMS Notifier")); + HandleCommandL(EAppNewSms); + + //Set up key event "enter" to simulate key enter to replace clicking "ok" on dialog. + event.iCode=event.iScanCode=EKeyEnter; + event.iModifiers=event.iRepeats=0; + + //Connect to Window Server Session + TEST(ws.Connect()==KErrNone); + + // Simulate key entry and flush the buffer to send event to windows server session. + ws.SimulateKeyEvent(event); + ws.Flush(); + INFO_PRINTF1(_L("Cancel SMS Notifier via dialog")); + ws.Close(); + } + + +void CTNotdialAppUi::TestStep22L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 22:")); + INFO_PRINTF1(_L("Start Email Notifier")); + HandleCommandL(EAppNewEmail); + + INFO_PRINTF1(_L("Cancel Email Notifier")); + HandleCommandL(EAppCancelEmail); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep23L + + @SYMPREQ + + @SYMTestCaseDesc Test cancelling the Email plug-in notifier via dialog. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test method starts the Email plug-in notifier by calling + RNotifier::StartNotifier. The test then connects to Windows Server + and simulates an ENTER key event on the notifier dialog to cancel the Email + plug-in notifier. + + @SYMTestExpectedResults The simulated ENTER Key on the notifier dialog should + cancel the Email notifier. + + */ +void CTNotdialAppUi::TestStep23L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 23:")); + RWsSession ws; + TKeyEvent event; + + INFO_PRINTF1(_L("Start Email Notifier")); + HandleCommandL(EAppNewEmail); + + //Set up key event "enter" to simulate key enter to replace clicking "ok" on dialog. + event.iCode=event.iScanCode=EKeyEnter; + event.iModifiers=event.iRepeats=0; + + //Connect to Window Server Session + TEST(ws.Connect()==KErrNone); + + // Simulate key entry and flush the buffer to send event to windows server session. + ws.SimulateKeyEvent(event); + ws.Flush(); + INFO_PRINTF1(_L("Cancel Email Notifier via dialog")); + ws.Close(); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep24L + + @SYMPREQ + + @SYMTestCaseDesc Test updating the SMS notifier. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test method starts the SMS plug-in notifier by invoking + RNotifier::StartNotifier() specifying the UID for SMS plug-in notifier. + It then calls CTNotdialAppUi::AppUpdate() method which calls + RNotifier::UpdateNotifier() to update the SMS plug-in notifier identified + by its UID. The test then cancels the notifier. + + @SYMTestExpectedResults The response received from RNotifier::UpdateNotifier() + is verified and displayed. + + */ +void CTNotdialAppUi::TestStep24L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 24:")); + INFO_PRINTF1(_L("Start SMS Notifier")); + HandleCommandL(EAppNewSms); + + INFO_PRINTF1(_L("Update SMS Notifier.")); + HandleCommandL(EAppUpdateSms); + + INFO_PRINTF1(_L("Cancel SMS Notifier")); + HandleCommandL(EAppCancelSms); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep25L + + @SYMPREQ + + @SYMTestCaseDesc Test updating the Email notifier. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test method starts the Email plug-in notifier by invoking + RNotifier::StartNotifier() specifying the UID for Email plug-in notifier. + It then calls CTNotdialAppUi::AppUpdate() method which calls + RNotifier::UpdateNotifier() to update the Email plug-in notifier identified + by its UID. The test then cancels the notifier. + + @SYMTestExpectedResults The response received from RNotifier::UpdateNotifier() + is verified and displayed. + + */ +void CTNotdialAppUi::TestStep25L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 25:")); + INFO_PRINTF1(_L("Start Email Notifier")); + HandleCommandL(EAppNewEmail); + + INFO_PRINTF1(_L("Update Email Notifier.")); + HandleCommandL(EAppUpdateEmail); + + INFO_PRINTF1(_L("Cancel Email Notifier")); + HandleCommandL(EAppCancelEmail); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep26L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::StartNotifier() to start a plug-in notifier + which is invalid. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test calls RNotifier::StartNotifier() by specifying an + invalid uid for the notifier. + + @SYMTestExpectedResults RNotifier::StartNotifier() should return KErrNotFound + if the UID of notifier is invalid. + + */ +void CTNotdialAppUi::TestStep26L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 26.")); + INFO_PRINTF1(_L("Test Checking Error Code")); + HandleCommandL(EAppCheckErrorCode); + } + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep27L + + @SYMPREQ + + @SYMTestCaseDesc Test to start a Low Battery Notifier using a CPeriodic Timer. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test starts a CPeriodic Timer which invokes callback + method KickOffBatteryNotifierL(). This callback method starts Low Battery + notifier by calling RNotifier::StartNotifier(). + + @SYMTestExpectedResults The response message from StartNotifier() is verified + & displayed. + + */ + void CTNotdialAppUi::TestStep27L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 27.")); + INFO_PRINTF1(_L("Test Checking Battery On Timer Notifier ")); + HandleCommandL(EAppBatteryNotifiyOnTimer); + } + + +/** + @SYMTestCaseID UIF-TNotdialStep-TestStep28L + + @SYMPREQ + + @SYMTestCaseDesc Test RNotifier::Notify() API. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The method calls RNotifier::Notify() to asynchronously + display a dialog. Then it connects to the Windows server and + simulates an ENTER key event for the dialog to cancel it. + + @SYMTestExpectedResults RNotifier::Notify() should display a dialog and the + simulated key event should cancel the dialog. + + */ +void CTNotdialAppUi::TestStep28L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 28:")); + RNotifier n; + n.Connect(); + _LIT(KLine1,"Line1 - Select Button2"); + _LIT(KLine2,"Line2 - or press enter"); + _LIT(KButton1,"Button1"); + _LIT(KButton2,"Button2"); + TInt button=-1; + TRequestStatus stat; + INFO_PRINTF1(_L("Testing RNotifier::Notify:")); + n.Notify(KLine1,KLine2,KButton1,KButton2,button,stat); + // Wait for a time to allow the Notifier server to process this + // request and display a dialog before we simulate sending an enter key press + User::After(100000); + + RWsSession ws; + TKeyEvent event; + //Set up key event "enter" to simulate key enter to replace clicking "ok" on dialog. + event.iCode=event.iScanCode=EKeyEnter; + event.iModifiers=event.iRepeats=0; + TEST(ws.Connect()==KErrNone); + + // Simulate key entry and flush the buffer to send + // event to windows server session. + ws.SimulateKeyEvent(event); + ws.Flush(); + INFO_PRINTF1(_L("Cancel Notifier dialog by simulating pressing the enter key")); + ws.Close(); + + // Don't test the button until we know the server has completed the request + User::WaitForRequest(stat); + INFO_PRINTF1(_L("Testing the enter key was pressed:")); + TEST(button==1); + n.Close(); + } + +/** + @SYMTestCaseID UIF-NotdialStep-TestStep29L + + @SYMPREQ + + @SYMTestCaseDesc Tests RNotifer::Notify and notification messages of different threads. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + To create five threads,with a time gap of 5 seconds between creation of the next thread and + to test whether the notification messages of all the five threads are displayed + API Calls: + RNotifer::Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aBut1, + const TDesC& aBut2,TInt& aButtonVal,TRequestStatus& aStatus) + RThread::TInt Create(const TDesC& aName,TThreadFunction aFunction, + TInt aStackSize,RHeap* aHeap,TAny* aPtr,TOwnerType aType=EOwnerProcess) + RThread::Resume() const + RThread::Heap() + RThread::Close() + User::After(TTimeIntervalMicroSeconds32 anInterval) + + @SYMTestExpectedResults The notification messages of all the five threads to be displayed. + + */ +void CTNotdialAppUi::TestStep29L() + { + iNotifierCounter=0; + iMessageCounter=0; + INFO_PRINTF1(_L(" ------------------------- Test Case 29:")); + INFO_PRINTF1(_L("Testing Display of Queued Error Notes")); + _LIT(KMessage1, "Note 1"); + _LIT(KMessage2, "Note 2"); + _LIT(KMessage3, "Note 3"); + _LIT(KMessage4, "Note 4"); + _LIT(KMessage5, "Note 5"); + + iNotifierMessage[0].Set(KMessage1); + iNotifierMessage[1].Set(KMessage2); + iNotifierMessage[2].Set(KMessage3); + iNotifierMessage[3].Set(KMessage4); + iNotifierMessage[4].Set(KMessage5); + + // Launch a thread to pop up an error note + RThread one; + one.Create(KMessage1,NotifyFunc, 4096, NULL, (void*) this); + one.Resume(); + one.Close(); + // Wait for a bit (5 secs) + User::After(1000000); + // Launch another thread to pop up an error note + RThread two; + two.Create(KMessage2,NotifyFunc, 4096, NULL, (void*) this); + two.Resume(); + two.Close(); + // Wait for a bit more (5 secs) + User::After(1000000); + // Launch another thread to pop up an error note + RThread three; + three.Create(KMessage3,NotifyFunc, 4096, NULL, (void*) this); + three.Resume(); + three.Close(); + // Wait for a bit more (5 secs) + User::After(1000000); + // Launch another thread to pop up an error note + RThread four; + four.Create(KMessage4, NotifyFunc, 4096, NULL, (void*) this); + four.Resume(); + four.Close(); + // Wait for a bit more (5 secs) + User::After(1000000); + // Launch another thread to pop up an error note + RThread five; + five.Create(KMessage5, NotifyFunc, 4096, NULL, (void*) this); + five.Resume(); + five.Close(); + // Wait for a bit more (5 secs) + User::After(1000000); + while(iNotifierCounter<5) + { + User::After(2000000); + } + } + +/** + @SYMTestCaseID UIF-NotdialStep-TestStep30L + + @SYMPREQ INC079968 + + @SYMTestCaseDesc Tests activation and cancellation of Agenda Alarm, Low Battery notifier. + + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Activate the agenda alarm and low battery notifiers. + Update then cancel the agenda alarm and low battery notifiers.. + + + @SYMTestExpectedResults Both notifiers are activated and cancelled susccessfully. + + */ + +void CTNotdialAppUi::TestStep30L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 30:")); + INFO_PRINTF1(_L("Start Agenda Alarm Notifier")); + HandleCommandL(EAppAgendaAlarm); + + INFO_PRINTF1(_L("Start Low Battery Notifier")); + HandleCommandL(EAppLowBattery); + + INFO_PRINTF1(_L("Update Agenda Alarm Notifier Status")); + HandleCommandL(EAppUpdateAgendaAlarmStatus); + + INFO_PRINTF1(_L("Cancel Agenda Alarm Notifier")); + HandleCommandL(EAppCancelAgendaAlarm); + + INFO_PRINTF1(_L("Cancel Low Battery Notifier")); + HandleCommandL(EAppCancelLowBattery); + } + + + /** + @SYMTestCaseID UIF-NotdialStep-TestStep31L + + @SYMDEF INC079968 + + @SYMTestCaseDesc Verifies that messages are completed if the corresponding notifier is inactive. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Attempt to send a message to the inactive agenda alarm notifier. + Observe that the message completes i.e. the test step continues. + + @SYMTestExpectedResults Messages sent to inactive notifiers complete. + */ +void CTNotdialAppUi::TestStep31L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 31:")); + INFO_PRINTF1(_L("Update Agenda Alarm Notifier Status after it was cancelled")); + HandleCommandL(EAppUpdateAgendaAlarmStatus); + + } + + /** + @SYMTestCaseID UIF-NotdialStep-TestStep32L + + @SYMDEF DEF113741 + + @SYMTestCaseDesc Verifies that attempting to cancel a notifier that doesn't exist returns the required error code + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Call RNotifier::CancelNotifier() with the UID of a notifier that hasn't been started. + + + @SYMTestExpectedResults RNotifier::CancelNotifier() returns KErrNotFound. + */ +void CTNotdialAppUi::TestStep32L() + { + INFO_PRINTF1(_L(" ------------------------- Test Case 32:")); + INFO_PRINTF1(_L("Cancelling a notifier that hasn't been started.\n")); + const TUid KNotifierNotExistUid = {0x1fffffff}; + TInt err = iNotifier.CancelNotifier(KNotifierNotExistUid); + INFO_PRINTF4(_L("RNotifier::Cancel(%x) returned '%D', expected '%D'"), KNotifierNotExistUid.iUid, err, KErrNotFound); + TEST(KErrNotFound == err); + } + +/** + The method creates a session with Notifier server for each of the five threads. + The notification message for each thread is displayed after a simulated lapse + of 10 seconds + */ +TInt CTNotdialAppUi::NotifyFunc(TAny *aPtr) + { + CTNotdialAppUi* notdialAppUi=(CTNotdialAppUi*)aPtr; + _LIT(KLine2,"Line2 - or press enter"); + _LIT(KButton1,"Button1"); + _LIT(KButton2,"Button2"); + TRequestStatus status; + TInt response; + RNotifier session; + session.Connect(); + session.Notify(notdialAppUi->iNotifierMessage[notdialAppUi->iMessageCounter++], KLine2, KButton1, KButton2, response, status); + //wait for 10 seconds and then dismiss the first queued message to check whether + //the other queued message in the notifier server are popped up. + User::After(10000000); + RWsSession ws; + TKeyEvent event; + //Set up key event "enter" to simulate key enter to replace clicking "ok" on dialog. + event.iCode=event.iScanCode=EKeyEnter; + event.iModifiers = event.iRepeats = 0; + + TInt err = ws.Connect(); + if(err==KErrNone) + { + // Simulate key entry and flush the buffer to send event to windows server session. + ws.SimulateKeyEvent(event); + ws.Flush(); + ws.Close(); + } + User::WaitForRequest(status); + notdialAppUi->iNotifierCounter++; + session.Close(); + return err; + } + +/** + This method is an oveerride from CCoeAppUi. It is used to handle key events. + */ +TKeyResponse CTNotdialAppUi::HandleKeyEventL(const TKeyEvent& /*aKeyEvent*/,TEventCode /*aType*/) + { + return EKeyWasNotConsumed; + } + +/** + This is an override from CEikAppUi. It is used to handle user commands. + */ +void CTNotdialAppUi::HandleCommandL(TInt aCommand) + { + TInt ret=KErrNotFound; + TBuf8<256> response; + response.SetMax(); + + User::After(TTimeIntervalMicroSeconds32(100000)); + + CEikonEnv* eikEnv=CEikonEnv::Static(); + + if (iNotifier.Handle()==KNullHandle) + { + User::LeaveIfError(iNotifier.Connect()); + } + + _LIT8(KMessagePhone, "Phone Ringing"); + _LIT8(KMessageBattery, "Low Battery"); + _LIT8(KMessageAgenda, "Agenda Alarm"); + _LIT8(KMessageSms, "New Sms"); + _LIT8(KMessageEmail, "New Email"); + + const TUid KRubbishUid={0x11111234}; + + switch (aCommand) + { + case EAppRingPhone: + ret=iNotifier.StartNotifier(iMyPhoneNotifierUid,KMessagePhone); + INFO_PRINTF3(_L("Start Phone Notifier returned :%d MyPhoneNotifierUid[%x]"), ret, iMyPhoneNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppNewSms: + ret=iNotifier.StartNotifier(iMySmsNotifierUid,KMessageSms,response); + INFO_PRINTF3(_L("Start SMS Notifier returned: %d MySmsNotifierUid[%x]"), ret, iMySmsNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppNewEmail: + ret=iNotifier.StartNotifier(iMyEmailNotifierUid,KMessageEmail,response); + INFO_PRINTF3(_L("Start Email Notifier returned: %d MyEmailNotifierUid[%x]"), ret, iMyEmailNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppLowBattery: + ret=iNotifier.StartNotifier(iMyLowBatteryNotifierUid,KMessageBattery,response); + INFO_PRINTF3(_L("Start Low Battery Notifier returned: %d MyLowBatteryNotifierUid[%x]"), ret,iMyLowBatteryNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppAgendaAlarm: + ret=iNotifier.StartNotifier(iMyAgendaAlarmUid,KMessageAgenda,response); + INFO_PRINTF3(_L("Start Agenda Alarm Notifier returned: %d MyAgendaAlarmUid[%x]"), ret,iMyAgendaAlarmUid.iUid); + TEST (ret==KErrNone); + break; + case EAppCancelRingPhone: + ret=iNotifier.CancelNotifier(iMyPhoneNotifierUid); + INFO_PRINTF3(_L("Cancel Phone Notifier returned: %d MyPhoneNotifierUid[%x]"), ret,iMyPhoneNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppCancelSms: + ret=iNotifier.CancelNotifier(iMySmsNotifierUid); + INFO_PRINTF3(_L("Cancel SMS Notifier returned: %d MySmsNotifierUid[%x]"), ret,iMySmsNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppCancelEmail: + ret=iNotifier.CancelNotifier(iMyEmailNotifierUid); + INFO_PRINTF3(_L("Cancel Email Notifier returned: %d MyEmailNotifierUid[%x]"), ret,iMyEmailNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppCancelLowBattery: + ret=iNotifier.CancelNotifier(iMyLowBatteryNotifierUid); + INFO_PRINTF3(_L("Cancel Low Battery Notifier returned: %d MyLowBatteryNotifierUid[%x]"), ret,iMyLowBatteryNotifierUid.iUid); + TEST (ret==KErrNone); + break; + case EAppCancelAgendaAlarm: + ret=iNotifier.CancelNotifier(iMyAgendaAlarmUid); + INFO_PRINTF3(_L("Cancel Agenda Notifier returned: %d MyAgendaAlarmUid[%x]"), ret,iMyAgendaAlarmUid.iUid); + TEST (ret==KErrNone); + break; + case EAppUpdateRingPhone: + { + INFO_PRINTF2(_L("Calling Phone Update MyPhoneNotifierUid[%x]"),iMyPhoneNotifierUid.iUid); + _LIT8(KMessage, "Calling Sms Update"); + AppUpdate(iMyPhoneNotifierUid,KMessage(),eikEnv,response); + } + break; + case EAppUpdateSms: + { + INFO_PRINTF2(_L("Calling Sms Update MySmsNotifierUid[%x]"),iMySmsNotifierUid.iUid); + _LIT8(KMessage, "Calling Sms Update"); + AppUpdate(iMySmsNotifierUid,KMessage(),eikEnv,response); + } + break; + case EAppUpdateEmail: + { + INFO_PRINTF2(_L("Calling Email Update MyEmailNotifierUid[%x]"),iMyEmailNotifierUid.iUid); + _LIT8(KMessage, "Calling Email Update"); + AppUpdate(iMyEmailNotifierUid,KMessage(),eikEnv,response); + } + break; + case EAppUpdateLowBattery: + { + INFO_PRINTF2(_L("Calling Low Battery Update MyLowBatteryNotifierUid[%x]"),iMyLowBatteryNotifierUid.iUid); + _LIT8(KMessage, "Calling Low Battery Update"); + AppUpdate(iMyLowBatteryNotifierUid,KMessage(),eikEnv,response); + } + break; + case EAppUpdateAgendaAlarm: + { + INFO_PRINTF2(_L("Calling Agenda Update MyAgendaAlarmUid[%x]"),iMyAgendaAlarmUid.iUid); + _LIT8(KMessage, "Calling Agenda Update"); + AppUpdate(iMyAgendaAlarmUid,KMessage(),eikEnv,response); + + } + break; + case EAppStartAgendaAlarmStatus: + { + if (iNotifier.Handle()==KNullHandle) + { + User::LeaveIfError(iNotifier.Connect()); + } + _LIT(KMessage,"Agenda:Status Request"); + _LIT(KRequestQMsg,"Agenda Alarm:Request Queued"); + _LIT(KNotifExists,"Agenda Alarm Already Exists"); + _LIT(KNotifNotFound,"Agenda Alarm notifier not found"); + + TRequestStatus status=KRequestPending; + INFO_PRINTF2(_L("StartNotifierAndGetResponse for MyAgendaAlarmUid [%x]"),iMyAgendaAlarmUid.iUid ); + + iNotifier.StartNotifierAndGetResponse(status,iMyAgendaAlarmUid,KMessageAgenda,response); + + INFO_PRINTF2(_L(">>call cancel low battery notifier MyLowBatteryNotifierUid[%x]"),iMyLowBatteryNotifierUid.iUid); + + //issue new call while request pending + TInt error=iNotifier.CancelNotifier(iMyLowBatteryNotifierUid); + TGulAlignment messageAlignment=EHLeftVTop; + eikEnv->InfoMsgWithAlignment(messageAlignment,KMessage); + INFO_PRINTF3(_L("cancel low battery notifier MyLowBatteryNotifierUid[%x] returned[%d]"),iMyLowBatteryNotifierUid.iUid,error); + User::WaitForRequest(status); + messageAlignment=EHRightVTop; + if (status.Int() == (TInt)EEikNotExtRequestQueued) + { + INFO_PRINTF1(_L(">>request queued")); + eikEnv->InfoMsgWithAlignment(messageAlignment,KRequestQMsg); + } + else if (status.Int() == (TInt)KErrAlreadyExists) + { + INFO_PRINTF1(_L(">>notifier exists")); + eikEnv->InfoMsgWithAlignment(messageAlignment,KNotifExists); + } + else if(status.Int() == (TInt)KErrNone) + { + INFO_PRINTF1(_L(">>request completed successfully")); + TBuf<256> buffer; + buffer.Copy(response); + INFO_PRINTF1(buffer); + eikEnv->InfoMsgWithAlignment(messageAlignment,buffer); + } + else if(status.Int() == (TInt)KErrNotFound) + { + INFO_PRINTF1(KNotifNotFound); + } + else + { + INFO_PRINTF2(_L("************ request completed with an error: %d"), status.Int()); + } + } + break; + case EAppUpdateAgendaAlarmStatus: + { + _LIT(KNotifNotFound,"Agenda Alarm notifier not found"); + _LIT(KRequestQMsg,"Agenda Alarm:Request Queued"); + _LIT(KMessage,"Agenda:Status Request"); + _LIT(KNotifNotReady,"Agenda Alarm notifier not ready"); + + TRequestStatus status=KRequestPending; + INFO_PRINTF2(_L("UpdateNotifierAndGetResponse for MyAgendaAlarmUid [%x]"),iMyAgendaAlarmUid.iUid); + iNotifier.UpdateNotifierAndGetResponse(status,iMyAgendaAlarmUid,KMessageAgenda,response); + TGulAlignment messageAlignment=EHLeftVTop; + eikEnv->InfoMsgWithAlignment(messageAlignment, KMessage); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + User::WaitForRequest(status); + if(status.Int() == (TInt)EEikNotExtRequestQueued) + { + INFO_PRINTF1(_L(">>request queued")); + eikEnv->InfoMsgWithAlignment(messageAlignment, KRequestQMsg); + } + else if (status.Int() == (TInt) KErrNone) + { + INFO_PRINTF1(_L(">>request completed successfully")); + TBuf<256> buffer; + buffer.Copy(response); + INFO_PRINTF1(buffer); + eikEnv->InfoMsgWithAlignment(messageAlignment, buffer); + } + else if (status.Int() == (TInt) KErrNotFound) + { + INFO_PRINTF1(KNotifNotFound); + } + else if(status.Int() == (TInt)KErrNotReady) + { + INFO_PRINTF1(KNotifNotReady); + } + else + { + INFO_PRINTF2(_L("************ request completed with an error: %d"), status.Int()); + } + } + break; + case EAppStartEmailStatus: + { + if (iNotifier.Handle()==KNullHandle) + { + User::LeaveIfError(iNotifier.Connect()); + } + _LIT(KEmailMessage,"Email:Status Request"); + _LIT(KEmailRequestQMsg,"Email :Request Queued"); + _LIT(KEmailNotifExists,"Email Already Exists"); + _LIT(KEmailNotFound,"Email Notifier not found"); + + TRequestStatus status=KRequestPending; + + INFO_PRINTF2(_L("StartNotifierAndGetResponse for MyEmailNotifierUid [%x]"),iMyEmailNotifierUid.iUid ); + iNotifier.StartNotifierAndGetResponse(status,iMyEmailNotifierUid,KMessageEmail,response); + + INFO_PRINTF2(_L(">>call cancel low battery notifier MyLowBatteryNotifierUid[%x]"),iMyLowBatteryNotifierUid.iUid); + + //issue new call while request pending + TInt error = iNotifier.CancelNotifier(iMyLowBatteryNotifierUid); + TGulAlignment messageAlignment=EHLeftVTop; + eikEnv->InfoMsgWithAlignment(messageAlignment,KEmailMessage); + INFO_PRINTF3(_L(">>call cancel low battery notifier MyLowBatteryNotifierUid[%x]"),iMyLowBatteryNotifierUid.iUid,error); + + RWsSession ws; + TKeyEvent event; + + //Set up key event "enter" to simulate key enter to replace + //clicking "ok" on dialog. + event.iCode=event.iScanCode=EKeyEnter; + event.iModifiers=event.iRepeats=0; + + //Connect to Window Server Session + TEST(ws.Connect()==KErrNone); + + // Simulate key entry and flush the buffer to send event to windows server session. + ws.SimulateKeyEvent(event); + ws.Flush(); + INFO_PRINTF1(_L("Cancelled Email Status Notifier via dialog")); + ws.Close(); + + messageAlignment=EHRightVTop; + TInt statusValue=status.Int(); + if (statusValue == (TInt)EEikNotExtRequestQueued) + { + INFO_PRINTF1(_L(">>request queued")); + eikEnv->InfoMsgWithAlignment(messageAlignment,KEmailRequestQMsg); + } + else if (statusValue == (TInt)KErrAlreadyExists) + { + INFO_PRINTF1(_L(">>notifier exits")); + eikEnv->InfoMsgWithAlignment(messageAlignment,KEmailNotifExists); + } + else if(statusValue == (TInt)KErrNone) + { + INFO_PRINTF1(_L(">>request completed successfully")); + TBuf<256> buffer; + buffer.Copy(response); + INFO_PRINTF1(buffer); + eikEnv->InfoMsgWithAlignment(messageAlignment,buffer); + } + else if(statusValue == (TInt)KErrNotFound) + { + INFO_PRINTF1(KEmailNotFound); + } + else + { + INFO_PRINTF2(_L("************ request completed with an error: %d"),statusValue); + } + + } + + break; + case EAppUpdateEmailStatus: + { + _LIT(KNotifNotFound,"Email notifier not found"); + _LIT(KRequestQMsg,"Email:Request Queued"); + _LIT(KMessage,"Email:Status Request"); + + TRequestStatus status=KRequestPending; + INFO_PRINTF2(_L("UpdateNotifierAndGetResponse for MyEmailUid [%x]"),iMyEmailNotifierUid.iUid); + iNotifier.UpdateNotifierAndGetResponse(status,iMyEmailNotifierUid,KMessageEmail,response); + TGulAlignment messageAlignment=EHLeftVTop; + eikEnv->InfoMsgWithAlignment(messageAlignment, KMessage); + + INFO_PRINTF1(_L("Update Low Battery Notifier")); + HandleCommandL(EAppUpdateLowBattery); + + User::WaitForRequest(status); + if(status.Int() == (TInt)EEikNotExtRequestQueued) + { + INFO_PRINTF1(_L(">>request queued")); + eikEnv->InfoMsgWithAlignment(messageAlignment, KRequestQMsg); + } + else if (status.Int() == (TInt) KErrNone) + { + INFO_PRINTF1(_L(">>request completed successfully")); + TBuf<256> buffer; + buffer.Copy(response); + INFO_PRINTF1(buffer); + eikEnv->InfoMsgWithAlignment(messageAlignment, buffer); + } + else if (status.Int() == (TInt) KErrNotFound) + { + INFO_PRINTF1(KNotifNotFound); + } + else + { + INFO_PRINTF2(_L("************ request completed with an error: %d"), status.Int()); + } + } + break; + case EAppBatteryNotifiyOnTimer: + { + TTimeIntervalMicroSeconds32 delay(3000000); + TTimeIntervalMicroSeconds32 repeat(0); + if (!iBattTimer->IsActive()) + iBattTimer->Start(delay,repeat,(TCallBack(&KickOffBatteryNotifierL,this))); + } + break; + case EAppCheckErrorCode: + { + // Specific test for DEF022326 - RNotifier can start a notifier that doesn't exist + if (iNotifier.StartNotifier(KRubbishUid,KMessagePhone,response)==KErrNotFound) + { + INFO_PRINTF1(_L("Rubbish Notifer Not Found")); + } + } + break; + } + } + +/** + This is a callback method for CPeriodic Timer, iBattTimer. The method + invokes RNotifier::StartNotifier() to start Low Battery plug-in notifier. + */ +TInt CTNotdialAppUi::KickOffBatteryNotifierL(TAny* aSimpleAppUi) + { + CTNotdialAppUi* appUi=STATIC_CAST(CTNotdialAppUi*,aSimpleAppUi); + TBuf8<256> response; + response.SetMax(); + _LIT8(KMessageBattery, "Low Battery on Timer"); + if (appUi->iNotifier.Handle()==KNullHandle) + { + User::LeaveIfError(appUi->iNotifier.Connect()); + } + appUi->iNotifier.StartNotifier(appUi->iMyLowBatteryNotifierUid,KMessageBattery,response); + appUi->iBattTimer->Cancel(); + return 0; + } + + +/** + The method updates a plug-in notifier specified by UID aNotifierUid with + message aMessage by calling RNotifier::UpdateNotifier(). The method then + verifies the response aResponse and displays it. + */ +void CTNotdialAppUi::AppUpdate(TUid aNotifierUid, const TDesC8& aMessage, CEikonEnv* aEikEnv, TDes8& aResponse) + { + _LIT8(KPluginResponse, "Response:"); + _LIT(KNoPluginUpdate,"No Update from Plugin"); + + iNotifier.UpdateNotifier(aNotifierUid,aMessage,aResponse); + if (aResponse.Find(KPluginResponse)!=0) + { + aEikEnv->InfoMsgWithAlignment(EHRightVBottom, KNoPluginUpdate); + } + else + { + TBuf<256> buffer; + buffer.Copy(aResponse); + INFO_PRINTF1(buffer); + aEikEnv->InfoMsgWithAlignment(EHRightVBottom, buffer); + } + } + +/** + The method creates & sets the application's user interface object. + */ +void CTNotdialStep::ConstructAppL(CEikonEnv* aEikEnv) + { // runs inside a TRAP harness + INFO_PRINTF1(_L("CTNotdialStep::ConstructAppL")); + aEikEnv->ConstructL(); + CTNotdialAppUi* appUi=new(ELeave) CTNotdialAppUi(this); + INFO_PRINTF1(_L("SetAppUi")); + aEikEnv->SetAppUi(appUi); + appUi->ConstructL(); + } + +CTNotdialStep::CTNotdialStep() + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KTNotdialStep); + } + +CTNotdialStep::~CTNotdialStep() + { + } + +TVerdict CTNotdialStep::doTestStepPreambleL() + { + SetTestStepResult(EPass); + return TestStepResult(); + } + +TVerdict CTNotdialStep::doTestStepPostambleL() + { + return TestStepResult(); + } + +TVerdict CTNotdialStep::doTestStepL() + { + PreallocateHALBuffer(); + + __UHEAP_MARK; + INFO_PRINTF1(_L("Start TNotdial test cases (TESTING V2 NOTIFIERS)....")); + CEikonEnv* eikEnv=new(ELeave) CEikonEnv; + TRAPD(err,ConstructAppL(eikEnv)); + if (!err) + { + eikEnv->ExecuteD(); + } + else + { + SetTestStepResult(EFail); + User::Leave(err); + } + + REComSession::FinalClose(); + __UHEAP_MARKEND; + + INFO_PRINTF1(_L("...TNotdial test completed!")); + return TestStepResult(); + }