mmserv/sts/tsrc/ststester/src/ststester.cpp
changeset 16 43d09473c595
parent 14 80975da52420
child 20 b67dd1fc57c5
equal deleted inserted replaced
14:80975da52420 16:43d09473c595
    25 
    25 
    26 const TInt KFontSize = 15;
    26 const TInt KFontSize = 15;
    27 
    27 
    28 const TOperationsPage KKeyMap[KKeyMapPageCount] =
    28 const TOperationsPage KKeyMap[KKeyMapPageCount] =
    29     {
    29     {
    30         {STR("Standard controls"), 5, // default softkey index
    30         {
    31            {
    31         STR("Standard controls"), 5, // default softkey index
    32                // Enter
    32                     {
    33                {STR(""),                   KOperation_ExecuteOption},
    33                     // Enter
    34                // Up / Down / Left / Right
    34                                 {
    35                {STR(""),                   KOperation_PreviousOption},
    35                                 STR(""), KOperation_ExecuteOption
    36                {STR(""),                   KOperation_NextOption},
    36                                 },
    37                {STR(""),                   KOperation_PreviousOptionPage},
    37                             // Up / Down / Left / Right
    38                {STR(""),                   KOperation_NextOptionPage},
    38                                 {
    39                // 0 - 9
    39                                 STR(""), KOperation_PreviousOption
    40                {STR("Play Default Beep"),  EOperation_PlayDefaultBeep},
    40                                 },
    41                {STR("Play Clock Alarm"),   EOperation_PlayClockAlarm},
    41                                 {
    42                {STR("Stop Clock Alarm"),   EOperation_StopClockAlarm},
    42                                 STR(""), KOperation_NextOption
    43                {STR(""),                   KOperation_None},
    43                                 },
    44                {STR(""),                   KOperation_None},
    44                                 {
    45                {STR(""),                   KOperation_None},
    45                                 STR(""), KOperation_PreviousOptionPage
    46                {STR(""),                   KOperation_None},
    46                                 },
    47                {STR(""),                   KOperation_None},
    47                                 {
    48                {STR(""),                   KOperation_None},
    48                                 STR(""), KOperation_NextOptionPage
    49                {STR("Exit"),               KOperation_Exit}
    49                                 },
    50            }
    50                             // 0 - 9
       
    51                                 {
       
    52                                         STR("Play Default Beep"),
       
    53                                         EOperation_PlayDefaultBeep
       
    54                                 },
       
    55                                 {
       
    56                                         STR("Play Clock Alarm"),
       
    57                                         EOperation_PlayClockAlarm
       
    58                                 },
       
    59                                 {
       
    60                                         STR("Stop Clock Alarm"),
       
    61                                         EOperation_StopClockAlarm
       
    62                                 },
       
    63                                 {
       
    64                                 STR(""), KOperation_None
       
    65                                 },
       
    66                                 {
       
    67                                 STR(""), KOperation_None
       
    68                                 },
       
    69                                 {
       
    70                                 STR(""), KOperation_None
       
    71                                 },
       
    72                                 {
       
    73                                 STR(""), KOperation_None
       
    74                                 },
       
    75                                 {
       
    76                                 STR(""), KOperation_None
       
    77                                 },
       
    78                                 {
       
    79                                 STR(""), KOperation_None
       
    80                                 },
       
    81                                 {
       
    82                                 STR("Exit"), KOperation_Exit
       
    83                                 }
       
    84                     }
    51         }
    85         }
    52     };
    86     };
    53 
    87 
    54 void CStsTester::ExecuteL()
    88 void CStsTester::ExecuteL()
    55     {
    89     {
    65     {
    99     {
    66     }
   100     }
    67 
   101 
    68 CStsTester::~CStsTester()
   102 CStsTester::~CStsTester()
    69     {
   103     {
    70     CSystemToneService::Delete( iSts);
   104     CSystemToneService::Delete(iSts);
    71     }
   105     }
    72 
   106 
    73 void CStsTester::InitL()
   107 void CStsTester::InitL()
    74     {
   108     {
    75     BaseConstructL(KKeyMap, KKeyMapPageCount);
   109     BaseConstructL(KKeyMap, KKeyMapPageCount);
    76     iSts = CSystemToneService::Create();
   110     iSts = CSystemToneService::Create();
    77     }
   111     }
    78 
   112 
    79 void CStsTester::Main()
   113 void CStsTester::Main()
    80     {
   114     {
    81     TRAP_IGNORE( MainL() );
   115     TRAP_IGNORE(MainL());
    82     }
   116     }
    83 
   117 
    84 void CStsTester::MainL()
   118 void CStsTester::MainL()
    85     {
   119     {
    86     _LIT( KPlayDefault, "Play Default Beep" );
   120     _LIT(KPlayDefault, "Play Default Beep");
    87     _LIT( KPlayClockAlarm, "Play Clock Alarm" );
   121     _LIT(KPlayClockAlarm, "Play Clock Alarm");
    88     _LIT( KStopClockAlarm, "Stop Clock Alarm" );
   122     _LIT(KStopClockAlarm, "Stop Clock Alarm");
    89     _LIT( KExit, "Exit");
   123     _LIT(KExit, "Exit");
    90 
   124 
    91     bool done = false;
   125     bool done = false;
    92 
   126 
    93     while (!done)
   127     while (!done)
    94         {
   128         {
    96         operations.Append(&KPlayDefault);
   130         operations.Append(&KPlayDefault);
    97         operations.Append(&KPlayClockAlarm);
   131         operations.Append(&KPlayClockAlarm);
    98         operations.Append(&KStopClockAlarm);
   132         operations.Append(&KStopClockAlarm);
    99         operations.Append(&KExit);
   133         operations.Append(&KExit);
   100 
   134 
   101         TInt index = SelectFromListL(TPoint(0, 0), iDisplaySize,
   135         TInt index = SelectFromListL(TPoint(0, 0), iDisplaySize, _L(
   102                 _L("Select STS operation to perform:"), operations);
   136                 "Select STS operation to perform:"), operations);
   103 
   137 
   104         operations.Reset();
   138         operations.Reset();
   105 
   139 
   106         TPtrC operationName(STR("Play Default Beep"));
   140         TPtrC operationName(STR("Play Default Beep"));
   107 
   141 
   142             {
   176             {
   143             // Only play if not already playing
   177             // Only play if not already playing
   144             if (iPlayState != EPlaying)
   178             if (iPlayState != EPlaying)
   145                 {
   179                 {
   146                 TAG_TIME_PROFILING_BEGIN;
   180                 TAG_TIME_PROFILING_BEGIN;
   147                 iSts->PlayTone(CSystemToneService::EClockAlarm,
   181                 iSts->PlayAlarm(CSystemToneService::EClockAlarm,
   148                         iCurrentContext);
   182                         iCurrentContext, *this);
   149                 TAG_TIME_PROFILING_END;
   183                 TAG_TIME_PROFILING_END;
   150                 PRINT_TO_CONSOLE_TIME_DIFF;
   184                 PRINT_TO_CONSOLE_TIME_DIFF;
   151                 iPlayState = EPlaying;
   185                 iPlayState = EPlaying;
   152                 }
   186                 }
   153             break;
   187             break;
   154             }
   188             }
   155         case EOperation_StopClockAlarm:
   189         case EOperation_StopClockAlarm:
   156             {
   190             {
   157             TAG_TIME_PROFILING_BEGIN;
   191             TAG_TIME_PROFILING_BEGIN;
   158             iSts->StopTone(iCurrentContext);
   192             iSts->StopAlarm(iCurrentContext);
   159             TAG_TIME_PROFILING_END;
   193             TAG_TIME_PROFILING_END;
   160             PRINT_TO_CONSOLE_TIME_DIFF;
   194             PRINT_TO_CONSOLE_TIME_DIFF;
   161             iPlayState = EStopped;
   195             iPlayState = EStopped;
   162             break;
   196             break;
   163             }
   197             }
   165             {
   199             {
   166             break;
   200             break;
   167             }
   201             }
   168         }
   202         }
   169     }
   203     }
       
   204 
       
   205 void CStsTester::PlayAlarmComplete(unsigned int aAlarmContext)
       
   206     {
       
   207     if (aAlarmContext == iCurrentContext)
       
   208         {
       
   209         iPlayState = EStopped;
       
   210         }
       
   211     }