const gint KPhoneInbandVolumeMax = 10;

const gint KPhoneInbandVolumeMin = 0;

_LIT(KSystemDefaultbeepRscDrive, "Z:");

_LIT(KSystemDefaultbeepRscFile, "DEFAULTBEEP.rSC");

    TMSAudioInbandTonePlayer* self = new (ELeave) TMSAudioInbandTonePlayer();

    self->ConstructL();

    iResourceFile.Close();

    iTones.ResetAndDestroy();

    iTones.Close();

    if (iPlayer)

        {

        iPlayer->CancelPlay();

        }

    delete iPlayer;

TMSAudioInbandTonePlayer::TMSAudioInbandTonePlayer() :

    iPlayer(NULL)

    iPlayer = TMSAudioToneUtilityImpl::NewL(*this);

    iTones.Reset();

    CreateToneSequencesL();

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// TMSAudioInbandTonePlayer::CreateSequencesL

// Create inband tone sequences from resources.

// -----------------------------------------------------------------------------

//

void TMSAudioInbandTonePlayer::CreateToneSequencesL()

    {

    TRACE_PRN_FN_ENT;

    iFileName = KSystemDefaultbeepRscDrive;

    iFileName.Append(KDC_RESOURCE_FILES_DIR);

    iFileName.Append(KSystemDefaultbeepRscFile);

    iFsSession.Connect();

    iResourceFile.OpenL(iFsSession, iFileName);

    // DO NOT change order of sequence allocation!

    AllocSeqFromResourceL(R_NET_BUSY);                 //iTones[0]

    AllocSeqFromResourceL(R_NET_RADIO_NOT_AVAILABLE);  //iTones[1]

    AllocSeqFromResourceL(R_NET_CONGESTION);           //iTones[2]

    AllocSeqFromResourceL(R_NET_SPECIAL_INFORMATION);  //iTones[3]

    AllocSeqFromResourceL(R_NET_REORDER);              //iTones[4]

    AllocSeqFromResourceL(R_NET_RING_GOING);           //iTones[5]

    AllocSeqFromResourceL(R_NET_CALL_WAITING);         //iTones[6]

    AllocSeqFromResourceL(R_DATA_CALL_TONE);           //iTones[7]

    AllocSeqFromResourceL(R_NO_SOUND_SEQUENCE);        //iTones[8]

    AllocSeqFromResourceL(R_BEEP_SEQUENCE);            //iTones[9]

    iResourceFile.Close();

    iFsSession.Close();

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// TMSAudioInbandTonePlayer::AllocSeqFromResourceL

//

// -----------------------------------------------------------------------------

//

void TMSAudioInbandTonePlayer::AllocSeqFromResourceL(const gint resource)

    {

    HBufC8* res = iResourceFile.AllocReadLC(resource);

    iReader.SetBuffer(res);

    gint length = iReader.ReadInt16();

    HBufC8* buf = HBufC8::NewL(length);

    TPtr8 ptr(buf->Des());

    for (gint i = 0; i < length; i++)

        ptr.Append(iReader.ReadUint16());

    User::LeaveIfError(iTones.Append(buf));

    CleanupStack::PopAndDestroy(res);

void TMSAudioInbandTonePlayer::PlayInbandTone(TMSInbandToneType tone)

    // First stop any ongoing playback

    Cancel();

    UpdateTonePlayerVolume();

    iToneName = tone;

    if (iPlayer && (tone >= 0 && tone < iTones.Count()))

        iPlayer->PrepareToPlayDesSequence(iTones[tone]->Des());

    if (iPlayer)

        if (iPlayer->State() == EMdaAudioToneUtilityNotReady)

            iPlayer->CancelPrepare();

            iPlayer->CancelPlay();

    if (iPlayer)

        if (iPlayer->State() == EMdaAudioToneUtilityPrepared)

                case TMS_INBAND_USER_BUSY:

                    SetToneAttributes(KAudioPrefBusy);

                case TMS_INBAND_RADIO_PATH_NOT_AVAIL:

                    SetToneAttributes(KAudioPrefRadioNotAvailable);

                    break;

                case TMS_INBAND_CONGESTION:

                    SetToneAttributes(KAudioPrefCongestion);

                case TMS_INBAND_SPECIAL_INFO:

                    SetToneAttributes(KAudioPrefSpecialInformation);

                case TMS_INBAND_REORDER:

                    SetToneAttributes(KAudioPrefReorder);

                case TMS_INBAND_REMOTE_ALEARTING:

                    SetToneAttributes(KAudioPrefRingGoing);

                case TMS_INBAND_CALL_WAITING:

                    SetToneAttributes(KAudioPrefCallWaiting,

                            KAudioPriorityNetMsg, 0);

                case TMS_INBAND_DATA_CALL:

                    SetToneAttributes(KAudioPrefIncomingDataCall,

                            KAudioPriorityPhoneCall);

            //      if ( iRingingType == EProfileRingingTypeAscending )

            //           {

            //           iPlayer->SetVolumeRamp(

            //               TTimeIntervalMicroSeconds( KPERingingToneRampDuration ) );

            //           }

            //       else

            //          {

            //          EProfileRingingTypeRinging, EProfileRingingTypeRingingOnce

                    iPlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(

            //           }

            //      if ( iRingingType == EProfileRingingTypeRingingOnce )

            //          {

            //        iPlayer->SetRepeats(0, TTimeIntervalMicroSeconds(

            //                KPhoneInbandToneZero));

                case TMS_INBAND_NO_SEQUENCE:

                case TMS_INBAND_BEEP_SEQUENCE:

                    SetToneAttributes(KAudioPrefIncomingCall,

                            KAudioPriorityPhoneCall);

                    //iPlayer->SetRepeats(0, TTimeIntervalMicroSeconds(

                    //        KPhoneInbandToneZero));

                    iPlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(

#ifndef __WINS__

            iPlayer->Play();

            }

        }

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// TMSAudioInbandTonePlayer::SetToneAttributes

//

// -----------------------------------------------------------------------------

//

void TMSAudioInbandTonePlayer::SetToneAttributes(const guint pref,

        const guint priority, const gint repeatTimes, const gint trailSilence)

    {

    iPlayer->SetRepeats(repeatTimes, TTimeIntervalMicroSeconds(trailSilence));

    iPlayer->SetPriority(priority, static_cast<TMdaPriorityPreference> (pref));

void TMSAudioInbandTonePlayer::SetVolume(gint volume)

    gint safeVolume = Max(Min(volume, KPhoneInbandVolumeMax),

    if (iPlayer)

        gint mediaServerVolume = CalculateMediaServerVolume(safeVolume);

        if (EMdaAudioToneUtilityNotReady != iPlayer->State())

            {

            iPlayer->SetVolume(mediaServerVolume);

            }

void TMSAudioInbandTonePlayer::MatoPlayComplete(TInt /*aError*/)

    // TODO: process error?

gint TMSAudioInbandTonePlayer::CalculateMediaServerVolume(gint volume) const

    return (iPlayer->MaxVolume() * volume) /

    gint volume( /*KPhoneInbandVolumeMin*/KPhoneInbandVolumeMax);