examples/Base/IPC/AdvancedClientServerExample/ThreadServer/src/threadserversession.cpp

// Copyright (c) 2007-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:
//

#include "threadserversession.h"


/*****************CThreadServerSession**********************/
CThreadServerSession* CThreadServerSession::NewL(CThreadServer& aServer)
        {
        CThreadServerSession* s = new(ELeave) CThreadServerSession(aServer);
        CleanupStack::PushL(s);
        s->ConstructL();
        CleanupStack::Pop();
        return s;       
        }
CThreadServerSession::CThreadServerSession(CThreadServer& aServer)
:iServer(aServer)
        {
        }
void CThreadServerSession::ConstructL()
        {
        }
CThreadServerSession::~CThreadServerSession()
        {
        delete iAsyncRequestHandler;            
        iServer.CloseLogicalChannel();
        iServer.DecrementRefCount();
        }
void CThreadServerSession::CreateL()
//
// 2nd phase construct for sessions - called by the CServer framework
//
        {
        iServer.IncrementRefCount();            
        //load dummy ldd
        User::LeaveIfError(iServer.LoadDevice());
        iAsyncRequestHandler = CAsyncHandler::NewL(iServer);    
        }
void CThreadServerSession::ServiceL(const RMessage2& aMessage)
        {
        TInt r = KErrNone;
        switch(aMessage.Function())
                {                               
                case EThreadServerLoadDeviceDriver:
                        aMessage.Complete(iServer.LoadDevice());
                        break;
                
                case EThreadServerOpenDriver:
                        aMessage.Complete(iServer.OpenLogicalChannel());
                        break;
                        
                case EThreadServerSendData: //async
                        r = iAsyncRequestHandler->ProcessRequest(aMessage);
                        if (r!=KErrNone)
                                aMessage.Complete(r);
                        break;
                        
                case EThreadServerSendDataCancel: //cancel async
                        iAsyncRequestHandler->Cancel(); 
                        aMessage.Complete(KErrNone); 
                        break;
                        
                case EThreadServerUnloadDeviceDriver:
                        aMessage.Complete(iServer.UnloadDevice());
                        break;
                        
                default:
                        User::Leave(KErrNotSupported);
                        break;
                }

        }
/*****************CAsyncHandler**********************/
CThreadServerSession::CAsyncHandler* CThreadServerSession::CAsyncHandler::NewL(CThreadServer& aServer)
        {
        CAsyncHandler* self = new(ELeave) CAsyncHandler(aServer);
        CleanupStack::PushL(self);
        self ->ConstructL();
        CleanupStack::Pop();
        return self;
        }
CThreadServerSession::CAsyncHandler::~CAsyncHandler()
        {
        Cancel();
        iMessageArray.Close();
        }
void CThreadServerSession::CAsyncHandler::RunL()
        {
        // complete the request
        Complete(iStatus.Int());
        
        //continue to execute next request if there is any
        ExecuteFirstRequestInArray();
        }
void CThreadServerSession::CAsyncHandler::DoCancel()
        {
        iServer.CancelSendData();
        // complete the request
        Complete(iStatus.Int());
        }
CThreadServerSession::CAsyncHandler::CAsyncHandler(CThreadServer& aServer)
        :CActive(EPriorityStandard), iServer(aServer)
        {
        CActiveScheduler::Add(this);
        }

void CThreadServerSession::CAsyncHandler::ConstructL()
        {
        }
TInt CThreadServerSession::CAsyncHandler::ProcessRequest(const RMessage2& aMessage)
        {
        TInt ret;
        //store message
        TMessage newMessage;
        newMessage.Message() = aMessage;
        ret= iMessageArray.Append(newMessage);
        if (ret != KErrNone)
                return ret;
        
        // only kick off the first request in the array when there is only one in the array
        if (iMessageArray.Count() == 1) 
                ret = ExecuteFirstRequestInArray();

        return ret;
        }
TInt CThreadServerSession::CAsyncHandler::ExecuteFirstRequestInArray()
        {
        TInt r = KErrNone;
        if (iMessageArray.Count() != 0)
                {
                const RMessage2& message = iMessageArray[0].Message();
                switch (message.Function())
                        {
                        case EThreadServerSendData:
                                {
                                TBuf8<KThreadServerMaxMessageLen> sendObject;
                                r= message.Read(0, sendObject);
                                if (r == KErrNone)
                                        {
                                        r = iServer.SendDataToDevice(iStatus, sendObject);
                                        if (r==KErrNone)
                                                SetActive();
                                        }
                                }
                                break;
                                
                        default:
                                break;
                        }
                }
        return r; 
        }
void CThreadServerSession::CAsyncHandler::Complete(TInt aResult)
        {
        iMessageArray[0].Message().Complete(aResult);
        iMessageArray.Remove(0);
        iServer.UpdateDriverState(CThreadServer::ELogicalChannelOpened);
        }

/***************TMessage****************/
const RMessage2& CThreadServerSession::CAsyncHandler::TMessage::Message() const
        {
        return iMessage;
        }
RMessage2& CThreadServerSession::CAsyncHandler::TMessage::Message()
        {
        return iMessage; 
        }

//EOF

---