/*static*/TInt RStsSession::CallBackThreadMain(TAny* aSession)

    {

    TInt err = KErrNoMemory;

    RThread myThread;

    myThread.SetPriority(EPriorityAbsoluteHigh);

    myThread.Close();

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if (cleanup)

        {

        // Run the server and request a thread rendezvous.

        TRAP( err, ((RStsSession*)aSession)->RunThreadL() );

        delete cleanup;

        }

    return err;

    }

void RStsSession::RunThreadL()

    {

    // Initialisation complete, now signal the client, if requested.

    RThread::Rendezvous(KErrNone);

    while (true)

        {

        TStsCallBack message;

        iMsgQueue.ReceiveBlocking(message);

        TStsCallBackType type = message.callBackType;

        if (type == EStsPlayAlarmComplete)

            {

            message.observer->PlayAlarmComplete(message.alarmContext);

            }

        else if (type == EStsShutdown)

            {

            break;

            }

        else

            {

            //TODO: Log error message

            }

        }

    }

TInt RStsSession::StartMsgQueue()

    {

    // Create a nameless global message queue, then pass the handle to the queue to the server.

    TInt err = iMsgQueue.CreateGlobal(KNullDesC, 30);

    if (err == KErrNone)

        {

        err = SendReceive(StsMsg_RegisterMsgQueue, TIpcArgs(iMsgQueue));

        }

    return err;

    }

        server.Resume();

        // wait for start or death

        User::WaitForRequest(rendezvousStatus);

        if (server.ExitType() == EExitPanic)

            {

            err = KErrGeneral;

            }

        else

            {

            err = rendezvousStatus.Int();

            }

    server.Close();

TInt RStsSession::StartThread()

    {

    TInt result = iThread.Create(KNullDesC,

            RStsSession::CallBackThreadMain, KDefaultStackSize,

            &User::Heap(), (TAny*) this);

    if (result == KErrNone)

        {

        TRequestStatus rendezvousStatus = KRequestPending;

        //  Register for rendezvous notification when thread is started.

        iThread.Rendezvous(rendezvousStatus);

        // Start the thread execution

        iThread.Resume();

        // Wait for thread to start.

        User::WaitForRequest(rendezvousStatus);

        result = rendezvousStatus.Int();

        if (result != KErrNone)

            {

            iThread.Kill(result);

            }

        }

    return result;

    }

    // Try to create a session with the server

    // If the server wasn't found, start the server and try creating a session again

                    KStsServerBuild), KNumSlots, EIpcSession_Sharable);

    // Create thread for receiving asynch callbacks from the server

        result = StartMsgQueue();

        if (result == KErrNone)

            result = StartThread();

    TRequestStatus logonStatus = KRequestPending;

    iThread.Logon(logonStatus);

    User::WaitForRequest(logonStatus);

    iThread.Close();

    iMsgQueue.Close();

    }

TInt RStsSession::SendPlayTone(CSystemToneService::TToneType aTone)

    {

    return SendReceive(StsMsg_PlayTone, TIpcArgs(aTone));

TInt RStsSession::SendPlayAlarm(CSystemToneService::TAlarmType aAlarm,

        unsigned int& aAlarmContext, MStsPlayAlarmObserver& aObserver)

    TPckg<unsigned int> alarmContextPckg(aAlarmContext);

    return SendReceive(StsMsg_PlayAlarm, TIpcArgs(aAlarm, &alarmContextPckg,

            &aObserver));

TInt RStsSession::SendStopAlarm(unsigned int aAlarmContext)

    return SendReceive(StsMsg_StopAlarm, TIpcArgs(aAlarmContext));