118 

   119     delete iRingTonePlayer;

   120     delete iDTMFTonePlayerDn;

   121     delete iDTMFTonePlayerUp;

   122     delete iInbandTonePlayer;

   200         ENTRY( "CreateDTMFTonePlayer", CTmsAudioServicesTestClass::CreateDTMFTonePlayer ),

   201         ENTRY( "DTMFTonePlay", CTmsAudioServicesTestClass::DTMFTonePlay ),

   202         ENTRY( "StopDTMFTonePlayer", CTmsAudioServicesTestClass::StopDTMFTonePlayer ),

   203         ENTRY( "ContinueDTMFStringSending", CTmsAudioServicesTestClass::ContinueDTMFStringSending ),

   204         ENTRY( "CloseDTMFPlayer", CTmsAudioServicesTestClass::CloseDTMFPlayer ),

   205         ENTRY( "CreateRingTonePlayer", CTmsAudioServicesTestClass::CreateRingTonePlayer ),

   206         ENTRY( "InitRingTonePlayer", CTmsAudioServicesTestClass::InitRingTonePlayer ),

   207         ENTRY( "PlayRingTone", CTmsAudioServicesTestClass::PlayRingTone ),

   208         ENTRY( "PlayRingToneNoEvent", CTmsAudioServicesTestClass::PlayRingToneNoEvent ),

   209         ENTRY( "PauseRingTone", CTmsAudioServicesTestClass::PauseRingTone ),

   210         ENTRY( "MuteRingTone", CTmsAudioServicesTestClass::MuteRingTone ),

   211         ENTRY( "StopRingTone", CTmsAudioServicesTestClass::StopRingTone ),

   212         ENTRY( "CloseRingTonePlayer", CTmsAudioServicesTestClass::CloseRingTonePlayer ),

   213         ENTRY( "CreateInbandTonePlayer", CTmsAudioServicesTestClass::CreateInbandTonePlayer ),

   214         ENTRY( "StartInbandTone", CTmsAudioServicesTestClass::StartInbandTone ),

   215         ENTRY( "StopInbandTone", CTmsAudioServicesTestClass::StopInbandTone ),

   216         ENTRY( "CloseInbandTonePlayer", CTmsAudioServicesTestClass::CloseInbandTonePlayer ),

   283         (TText*)L"ERTInitComplete",

   284         (TText*)L"ERTPlayComplete",

   285         (TText*)L"ERTDeinitComplete",

   286         (TText*)L"EInbToneStarted",

   287         (TText*)L"EInbToneStopped",

   288         (TText*)L"EDTMFToneStarted",

   289         (TText*)L"EDTMFToneStopped",

  2929     return error;

  2930     }

  2931 

  2932 TInt CTmsAudioServicesTestClass::CreateDTMFTonePlayer(CStifItemParser& aItem)

  2933     {

  2934     iLog->Log(_L("CTmsAudioServicesTestClass::CreateDTMFTonePlayer"));

  2935     TInt error = TMS_RESULT_SUCCESS;

  2936     TPtrC StreamType;

  2937     error = aItem.GetNextString(StreamType);

  2938 

  2939     if (error == TMS_RESULT_SUCCESS)

  2940         {

  2941         if (StreamType == KTagDnlink)

  2942             {

  2943             if (iFactory && !iDTMFTonePlayerDn)

  2944                 {

  2945                 error = iFactory->CreateDTMF(TMS_STREAM_DOWNLINK,

  2946                         iDTMFTonePlayerDn);

  2947                 error |= iDTMFTonePlayerDn->AddObserver(*this, NULL);

  2948                 }

  2949             FTRACE(FPrint(_L("CreateDTMF-DNL Error [%d]"), error));

  2950             }

  2951         else if (StreamType == KTagUplink)

  2952             {

  2953             if (iFactory && !iDTMFTonePlayerUp)

  2954                 {

  2955                 error = iFactory->CreateDTMF(TMS_STREAM_UPLINK,

  2956                         iDTMFTonePlayerUp);

  2957                 error |= iDTMFTonePlayerUp->AddObserver(*this, NULL);

  2958                 }

  2959             FTRACE(FPrint(_L("CreateDTMF-UPL Error [%d]"), error));

  2960             }

  2961         else

  2962             {

  2963             iLog->Log(KMsgBadTestParameters);

  2964             error = KErrBadTestParameter;

  2965             }

  2966         }

  2967     iLog->Log(_L("CTmsAudioServicesTestClass::CreateDTMFTonePlayer Error [%d]"), error);

  2968     return error;

  2969     }

  2970 

  2971 TInt CTmsAudioServicesTestClass::DTMFTonePlay(CStifItemParser& aItem)

  2972     {

  2973     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::DTMFTonePlay")));

  2974     iLog->Log(_L("CTmsAudioServicesTestClass::DTMFTonePlay"));

  2975     GString* dtmfstring;

  2976     TInt error = TMS_RESULT_SUCCESS;

  2977     TPtrC StreamType;

  2978     error = aItem.GetNextString(StreamType);

  2979 

  2980     if (error == TMS_RESULT_SUCCESS)

  2981         {

  2982         if (StreamType == KTagDnlink)

  2983             {

  2984             if (iDTMFTonePlayerDn)

  2985                 {

  2986                 // NOTE: UpLink Status must be READY or STREAMING

  2987                 dtmfstring = g_string_new("4723");

  2988                 dtmfstring = g_string_append_c(dtmfstring, '4');

  2989                 error = iDTMFTonePlayerDn->SetTone(dtmfstring);

  2990                 if (error == TMS_RESULT_SUCCESS)

  2991                     {

  2992                     error = iDTMFTonePlayerDn->Start();

  2993                     }

  2994                 g_string_free(dtmfstring, TRUE);

  2995                 }

  2996             }

  2997         else if (StreamType == KTagUplink)

  2998             {

  2999             if (iDTMFTonePlayerUp)

  3000                 {

  3001                 // NOTE: UpLink Status must be READY or STREAMING

  3002                 dtmfstring = g_string_new("987");

  3003                 dtmfstring = g_string_append_c(dtmfstring, '4');

  3004                 error = iDTMFTonePlayerUp->SetTone(dtmfstring);

  3005                 if (error == TMS_RESULT_SUCCESS)

  3006                     {

  3007                     error = iDTMFTonePlayerUp->Start();

  3008                     }

  3009                 g_string_free(dtmfstring, TRUE);

  3010                 }

  3011             }

  3012         else

  3013             {

  3014             iLog->Log(KMsgBadTestParameters);

  3015             error = KErrBadTestParameter;

  3016             }

  3017         }

  3018 

  3019     if (error == TMS_RESULT_SUCCESS)

  3020         {

  3021         AddExpectedEvent(EDTMFToneStopped, KMediumTimeout);

  3022         }

  3023 

  3024     iLog->Log(_L("CTmsAudioServicesTestClass::DTMFTonePlay Error [%d]"), error);

  3025     return error;

  3026     }

  3027 

  3028 TInt CTmsAudioServicesTestClass::StopDTMFTonePlayer(CStifItemParser& aItem)

  3029     {

  3030     FTRACE(FPrint(_L("CTmsAudioServicesTestClass::StopDTMFTonePlayer")));

  3031     iLog->Log(_L("CTmsAudioServicesTestClass::StopDTMFTonePlay"));

  3032     TInt error = TMS_RESULT_SUCCESS;

  3033     TPtrC StreamType;

  3034     error = aItem.GetNextString(StreamType);

  3035 

  3036     if (error == TMS_RESULT_SUCCESS)

  3037         {

  3038         if (StreamType == KTagDnlink)

  3039             {

  3040             if (iFactory && iDTMFTonePlayerDn)

  3041                 {

  3042                 iDTMFTonePlayerDn->Stop();

  3043                 RemoveExpectedEvent(EDTMFToneStopped);

  3044                 }

  3045             }

  3046         else if (StreamType == KTagUplink)

  3047             {

  3048             if (iFactory && iDTMFTonePlayerUp)

  3049                 {

  3050                 iDTMFTonePlayerUp->Stop();

  3051                 RemoveExpectedEvent(EDTMFToneStopped);

  3052                 }

  3053             }

  3054         else

  3055             {

  3056             iLog->Log(KMsgBadTestParameters);

  3057             error = KErrBadTestParameter;

  3058             }

  3059         }

  3060 

  3061     iLog->Log(_L("CTmsAudioServicesTestClass::StopDTMFTonePlayer Error [%d]"), error);

  3062     return error;

  3063     }

  3064 

  3065 TInt CTmsAudioServicesTestClass::ContinueDTMFStringSending(

  3066         CStifItemParser& aItem)

  3067     {

  3068     FTRACE(FPrint(_L("CTmsAudioServicesTestClass::ContinueDTMFStringSending")));

  3069     iLog->Log(_L("CTmsAudioServicesTestClass::ContinueDTMFStringSending"));

  3070     TInt error = TMS_RESULT_SUCCESS;

  3071     TPtrC StreamType;

  3072     error = aItem.GetNextString(StreamType);

  3073 

  3074     if (error == TMS_RESULT_SUCCESS)

  3075         {

  3076         if (StreamType == KTagDnlink)

  3077             {

  3078             if (iFactory && iDTMFTonePlayerDn)

  3079                 {

  3080                 //case not supported for DNL, should return valid error

  3081                 error = iDTMFTonePlayerDn->ContinueDTMFStringSending(TRUE);

  3082                 }

  3083             }

  3084         else if (StreamType == KTagUplink)

  3085             {

  3086             if (iFactory && iDTMFTonePlayerUp)

  3087                 {

  3088                 error = iDTMFTonePlayerUp->ContinueDTMFStringSending(TRUE);

  3089                 }

  3090             }

  3091         else

  3092             {

  3093             iLog->Log(KMsgBadTestParameters);

  3094             error = KErrBadTestParameter;

  3095             }

  3096         }

  3097     iLog->Log(_L("CTmsAudioServicesTestClass::ContinueDTMFStringSending Error [%d]"), error);

  3098     return error;

  3099     }

  3100 

  3101 TInt CTmsAudioServicesTestClass::CloseDTMFPlayer(CStifItemParser& aItem)

  3102     {

  3103     FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CloseDTMFPlayer")));

  3104     iLog->Log(_L("CTmsAudioServicesTestClass::CloseDTMFPlayer"));

  3105     TInt error = TMS_RESULT_SUCCESS;

  3106     TPtrC StreamType;

  3107     error = aItem.GetNextString(StreamType);

  3108 

  3109     if (error == TMS_RESULT_SUCCESS)

  3110         {

  3111         if (StreamType == KTagDnlink)

  3112             {

  3113             if (iFactory && iDTMFTonePlayerDn)

  3114                 {

  3115                 iDTMFTonePlayerDn->RemoveObserver(*this);

  3116                 iFactory->DeleteDTMF(iDTMFTonePlayerDn);

  3117                 }

  3118             }

  3119         else if (StreamType == KTagUplink)

  3120             {

  3121             if (iFactory && iDTMFTonePlayerUp)

  3122                 {

  3123                 iDTMFTonePlayerUp->RemoveObserver(*this);

  3124                 iFactory->DeleteDTMF(iDTMFTonePlayerUp);

  3125                 }

  3126             }

  3127         else

  3128             {

  3129             iLog->Log(KMsgBadTestParameters);

  3130             error = KErrBadTestParameter;

  3131             }

  3132         }

  3133     iLog->Log(_L("CTmsAudioServicesTestClass::StopDTMFTonePlayer Error [%d]"), error);

  3134     return error;

  3135     }

  3136 

  3137 TInt CTmsAudioServicesTestClass::CreateRingTonePlayer(

  3138         CStifItemParser& /*aItem */)

  3139     {

  3140     FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateRingTonePlayer")));

  3141     iLog->Log(_L("CTmsAudioServicesTestClass::CreateRingTonePlayer"));

  3142     TInt error = TMS_RESULT_SUCCESS;

  3143     if (iFactory)

  3144         {

  3145         error = iFactory->CreateRingTonePlayer(iRingTonePlayer);

  3146         if (error == TMS_RESULT_SUCCESS)

  3147             {

  3148             iRingTonePlayer->AddObserver(*this, NULL);

  3149             }

  3150         }

  3151     iLog->Log(_L("CTmsAudioServicesTestClass::CreateRingTonePlayer Error [%d]"), error);

  3152     return error;

  3153     }

  3154 

  3155 TInt CTmsAudioServicesTestClass::InitRingTonePlayer(CStifItemParser& aItem)

  3156     {

  3157     FTRACE(FPrint(_L("CTmsAudioServicesTestClass::InitRingTonePlayer")));

  3158     iLog->Log(_L("CTmsAudioServicesTestClass::InitRingTonePlayer"));

  3159 

  3160     TInt error = TMS_RESULT_SUCCESS;

  3161     TPtrC StreamType;

  3162     error = aItem.GetNextString(StreamType);

  3163 

  3164     if (error == TMS_RESULT_SUCCESS && iRingTonePlayer)

  3165         {

  3166         if (StreamType == KTagRTDefault)

  3167             {

  3168             error = iRingTonePlayer->Init(TMS_RINGTONE_DEFAULT);

  3169             }

  3170         else if (StreamType == KTagRTFile)

  3171             {

  3172             TBuf<sizeof(KTestFile3)> buf(KTestFile3);

  3173             iRTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length() * 2);

  3174             error = iRingTonePlayer->Init(TMS_RINGTONE_FILE, iRTStr);

  3175             g_string_free(iRTStr, TRUE);

  3176             iRTStr = NULL;

  3177             }

  3178         else if (StreamType == KTagRTBeepOnce)

  3179             {

  3180             error = iRingTonePlayer->Init(TMS_RINGTONE_BEEP_ONCE);

  3181             }

  3182         else if (StreamType == KTagRTSilent)

  3183             {

  3184             error = iRingTonePlayer->Init(TMS_RINGTONE_SILENT);

  3185             }

  3186         else if (StreamType == KTagRTUnsecureVoIP)

  3187             {

  3188             error = iRingTonePlayer->Init(TMS_RINGTONE_UNSECURE_VOIP);

  3189             }

  3190         else if (StreamType == KTagRTSequence)

  3191             {

  3192             TBuf8<sizeof(KRTBeepSequence)> buf(KRTBeepSequence);

  3193             iRTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length());

  3194             error = iRingTonePlayer->Init(TMS_RINGTONE_SEQUENCE, iRTStr);

  3195             g_string_free(iRTStr, TRUE);

  3196             }

  3197         else if (StreamType == KTagRTTts)

  3198             {

  3199             TBuf<sizeof(KTextToSpeak)> buf(KTextToSpeak);

  3200             iTTSStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length() * 2);

  3201             error = iRingTonePlayer->Init(TMS_RINGTONE_DEFAULT, NULL,

  3202                     iTTSStr);

  3203             g_string_free(iTTSStr, TRUE);

  3204             iTTSStr = NULL;

  3205             }

  3206         else

  3207             {

  3208             iLog->Log(KMsgBadTestParameters);

  3209             error = KErrBadTestParameter;

  3210             }

  3211 

  3212         if (error == TMS_RESULT_SUCCESS)

  3213             {

  3214             AddExpectedEvent(ERTInitComplete, KMediumTimeout);

  3215             }

  3216         }

  3217     iLog->Log(_L("CTmsAudioServicesTestClass::InitRingTonePlayer Error [%d]"), error);

  3218     return error;

  3219     }

  3220 

  3221 TInt CTmsAudioServicesTestClass::PlayRingTone(CStifItemParser& /*aItem*/)

  3222     {

  3223     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::PlayRingTone")));

  3224     iLog->Log(_L("CTmsAudioServicesTestClass::PlayRingTone"));

  3225     TInt error = KErrNone;

  3226 

  3227     if (iRingTonePlayer)

  3228         {

  3229         iRingTonePlayer->Play();

  3230         AddExpectedEvent(ERTPlayComplete, KMediumTimeout);

  3231         }

  3232     else

  3233         {

  3234         error = KErrNotFound;

  3235         }

  3236 

  3237     iLog->Log(_L("CTmsAudioServicesTestClass::PlayRingTone Error [%d]"), error);

  3238     return error;

  3239     }

  3240 

  3241 TInt CTmsAudioServicesTestClass::PlayRingToneNoEvent(CStifItemParser& /*aItem*/)

  3242     {

  3243     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::PlayRingToneNoEvent")));

  3244     iLog->Log(_L("CTmsAudioServicesTestClass::PlayRingToneNoEvent"));

  3245     TInt error = KErrNone;

  3246 

  3247     if (iRingTonePlayer)

  3248         {

  3249         iRingTonePlayer->Play();

  3250         // Not expecting any event - will allow to cancel

  3251         }

  3252     else

  3253         {

  3254         error = KErrNotFound;

  3255         }

  3256 

  3257     iLog->Log(_L("CTmsAudioServicesTestClass::PlayRingToneNoEvent Error [%d]"), error);

  3258     return error;

  3259     }

  3260 

  3261 TInt CTmsAudioServicesTestClass::PauseRingTone(CStifItemParser& /*aItem*/)

  3262     {

  3263     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::PauseRingTone")));

  3264     iLog->Log(_L("CTmsAudioServicesTestClass::PauseRingTone"));

  3265     TInt error = KErrNone;

  3266 

  3267     if (iRingTonePlayer)

  3268         {

  3269         iRingTonePlayer->Pause();

  3270         RemoveExpectedEvent(ERTPlayComplete);

  3271         }

  3272     else

  3273         {

  3274         error = KErrNotFound;

  3275         }

  3276 

  3277     iLog->Log(_L("CTmsAudioServicesTestClass::PauseRingTone Error [%d]"), error);

  3278     return error;

  3279     }

  3280 

  3281 TInt CTmsAudioServicesTestClass::StopRingTone(CStifItemParser& /*aItem*/)

  3282     {

  3283     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::StopRingTone")));

  3284     iLog->Log(_L("CTmsAudioServicesTestClass::StopRingTone"));

  3285     TInt error = KErrNotFound;

  3286     if (iRingTonePlayer)

  3287         {

  3288         error = iRingTonePlayer->Stop();

  3289         RemoveExpectedEvent(ERTPlayComplete);

  3290         }

  3291     iLog->Log(_L("CTmsAudioServicesTestClass::StopRingTone Error [%d]"), error);

  3292     return error;

  3293     }

  3294 

  3295 TInt CTmsAudioServicesTestClass::MuteRingTone(CStifItemParser& /*aItem*/)

  3296     {

  3297     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::MuteRingTone")));

  3298     iLog->Log(_L("CTmsAudioServicesTestClass::MuteRingTone"));

  3299     TInt error = KErrNotFound;

  3300     if (iRingTonePlayer)

  3301         {

  3302         error = iRingTonePlayer->Mute();

  3303         }

  3304     iLog->Log(_L("CTmsAudioServicesTestClass::MuteRingTone Error [%d]"), error);

  3305     return error;

  3306     }

  3307 

  3308 TInt CTmsAudioServicesTestClass::CloseRingTonePlayer(CStifItemParser& /*aItem*/)

  3309     {

  3310     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::CloseRingTonePlayer")));

  3311     iLog->Log(_L("CTmsAudioServicesTestClass::CloseRingTonePlayer"));

  3312     TInt error = KErrNotFound;

  3313     if (iFactory && iRingTonePlayer)

  3314         {

  3315         error = iRingTonePlayer->Deinit();

  3316         error |= iRingTonePlayer->RemoveObserver(*this);

  3317         error |= iFactory->DeleteRingTonePlayer(iRingTonePlayer);

  3318         }

  3319     iLog->Log(_L("CTmsAudioServicesTestClass::CloseRingTonePlayer Error [%d]"), error);

  3320     return error;

  3321     }

  3322 

  3323 TInt CTmsAudioServicesTestClass::CreateInbandTonePlayer(CStifItemParser& /*aItem*/)

  3324     {

  3325     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::CreateInbandTonePlayer")));

  3326     iLog->Log(_L("CTmsAudioServicesTestClass::CreateInbandTonePlayer"));

  3327     TInt error = KErrNotFound;

  3328 

  3329     if (iFactory && !iInbandTonePlayer)

  3330         {

  3331         error = iFactory->CreateInbandTonePlayer(iInbandTonePlayer);

  3332         if (iInbandTonePlayer)

  3333             {

  3334             iInbandTonePlayer->AddObserver(*this, NULL);

  3335             }

  3336         }

  3337     iLog->Log(_L("CTmsAudioServicesTestClass::CreateInbandTonePlayer Error [%d]"), error);

  3338     return error;

  3339     }

  3340 

  3341 TInt CTmsAudioServicesTestClass::StartInbandTone(CStifItemParser& aItem)

  3342     {

  3343     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::StartInbandTone")));

  3344     iLog->Log(_L("CTmsAudioServicesTestClass::StartInbandTone"));

  3345     TInt error = TMS_RESULT_SUCCESS;

  3346     TPtrC StreamType;

  3347     error = aItem.GetNextString(StreamType);

  3348 

  3349     if (error == TMS_RESULT_SUCCESS && iInbandTonePlayer)

  3350         {

  3351         if (StreamType == KTagUserBusy)

  3352             {

  3353             error = iInbandTonePlayer->Start(TMS_INBAND_USER_BUSY);

  3354             }

  3355         else if (StreamType == KTagRadioPathNotFound)

  3356             {

  3357             error = iInbandTonePlayer->Start(TMS_INBAND_RADIO_PATH_NOT_AVAIL);

  3358             }

  3359         else if (StreamType == KTagCongestion)

  3360             {

  3361             error = iInbandTonePlayer->Start(TMS_INBAND_CONGESTION);

  3362             }

  3363         else if (StreamType == KTagSpecialInfo)

  3364             {

  3365             error = iInbandTonePlayer->Start(TMS_INBAND_SPECIAL_INFO);

  3366             }

  3367         else if (StreamType == KTagReorder)

  3368             {

  3369             error = iInbandTonePlayer->Start(TMS_INBAND_REORDER);

  3370             }

  3371         else if (StreamType == KTagAlerting)

  3372             {

  3373             error = iInbandTonePlayer->Start(TMS_INBAND_REMOTE_ALEARTING);

  3374             }

  3375         else if (StreamType == KTagWaiting)

  3376             {

  3377             error = iInbandTonePlayer->Start(TMS_INBAND_CALL_WAITING);

  3378             }

  3379         else if (StreamType == KTagDataCall)

  3380             {

  3381             error = iInbandTonePlayer->Start(TMS_INBAND_DATA_CALL);

  3382             }

  3383         else if (StreamType == KTagNoSequence)

  3384             {

  3385             error = iInbandTonePlayer->Start(TMS_INBAND_NO_SEQUENCE);

  3386             }

  3387         else if (StreamType == KTagBeepSequence)

  3388             {

  3389             error = iInbandTonePlayer->Start(TMS_INBAND_BEEP_SEQUENCE);

  3390             }

  3391         else

  3392             {

  3393             iLog->Log(KMsgBadTestParameters);

  3394             error = KErrBadTestParameter;

  3395             }

  3396         }

  3397 

  3398     if (error == TMS_RESULT_SUCCESS)

  3399         {

  3400         AddExpectedEvent(EInbToneStarted, KShortTimeout);

  3401         }

  3402 

  3403     iLog->Log(_L("CTmsAudioServicesTestClass::StartInbandTone Error [%d]"), error);

  3404     return error;

  3405     }

  3406 

  3407 TInt CTmsAudioServicesTestClass::StopInbandTone(CStifItemParser& /*aItem*/)

  3408     {

  3409     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::StopInbandTone")));

  3410     iLog->Log(_L("CTmsAudioServicesTestClass::StopInbandTone"));

  3411     TInt error = KErrNotFound;

  3412     if (iFactory && iInbandTonePlayer)

  3413         {

  3414         error = iInbandTonePlayer->Stop();

  3415         RemoveExpectedEvent(EInbToneStarted);

  3416         }

  3417     iLog->Log(_L("CTmsAudioServicesTestClass::StopInbandTone Error [%d]"), error);

  3418     return error;

  3419     }

  3420 

  3421 TInt CTmsAudioServicesTestClass::CloseInbandTonePlayer(CStifItemParser& /*aItem*/)

  3422     {

  3423     FTRACE (FPrint(_L("CTmsAudioServicesTestClass::CloseInbandTonePlayer")));

  3424     iLog->Log(_L("CTmsAudioServicesTestClass::CloseInbandTonePlayer"));

  3425     TInt error = KErrNotFound;

  3426     if (iFactory && iInbandTonePlayer)

  3427         {

  3428         error = iInbandTonePlayer->RemoveObserver(*this);

  3429         error |= iFactory->DeleteInbandTonePlayer(iInbandTonePlayer);

  3430         }

  3431     iLog->Log(_L("CTmsAudioServicesTestClass::CloseInbandTonePlayer Error [%d]"), error);