examples/Base/IPC/ClientServer/Complex/ComplexServerCCountSession.cpp

/*
Copyright (c) 2000-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: ComplexServer.cpp  
*/


#include "ComplexClientAndServer.h"
#include "ComplexServer.h"
#include <e32svr.h>
#include <e32uid.h>


//*******************************
//CCountSession - implementations
//*******************************

CCountSession::CCountSession()
        {
        }


void CCountSession::CreateL()
        {
          // Create new object index
        iCountersObjectIndex=CObjectIx::NewL();
        
          // Initialize the object container
          // using the object container index in the server.
        iContainer=((CCountServer*)Server())->NewContainerL();
        }


void CCountSession::CloseSession() 
        {
          // Deletes the object index.
        delete iCountersObjectIndex;
        iCountersObjectIndex = NULL;
        
          // Removes object container from the container list    
        ((CCountServer*)Server())->RemoveContainer(iContainer);
        iContainer = NULL;
        }


CCountSubSession* CCountSession::CounterFromHandle(const RMessage2& aMessage,TInt aHandle)
    {
        CCountSubSession* counter = (CCountSubSession*)iCountersObjectIndex->At(aHandle);
        if (counter == NULL)
            {
                PanicClient(aMessage, EBadSubsessionHandle); 
            }
        return counter;
    }



void CCountSession::ServiceL(const RMessage2& aMessage)
        {
        TRAPD(err,DispatchMessageL(aMessage));
        aMessage.Complete(err);
        }


void CCountSession::DispatchMessageL(const RMessage2& aMessage)
        {
          // First check for session-relative requests
        switch (aMessage.Function())
                {
        case ECountServCreateSubSession:
                NewCounterL(aMessage);
                return;
        case ECountServCloseSession:
                CloseSession();
                return;
        case ECountServResourceCount:
                NumResourcesL(aMessage);
                return; 
                }
                
          // All other function codes must be subsession relative.
          // We need to find the appropriate server side subsession
          // i.e. the CCountSubSession object. 
          // The handle value is passed as the 4th aregument.
    CCountSubSession* counter=CounterFromHandle(aMessage,aMessage.Int3());
        switch (aMessage.Function())
        {
        case ECountServInitSubSession:
                counter->SetFromStringL(aMessage);
                return; 
        case ECountServCloseSubSession:
             DeleteCounter(aMessage.Int3());
             return;
        case ECountServIncrease:
                counter->Increase();
                return;
        case ECountServIncreaseBy:
                counter->IncreaseBy(aMessage);
                return;
        case ECountServDecrease:
                counter->Decrease();
                return;
        case ECountServDecreaseBy:
                counter->DecreaseBy(aMessage);
                return;
        case ECountServReset:
                counter->Reset();
                return;
        case ECountServValue:
                counter->CounterValueL(aMessage);
                return;
        default:
                PanicClient(aMessage,EBadRequest);
                return;
        }
        }


void CCountSession::NewCounterL(const RMessage2& aMessage)
        {
          // make a new counter object
        CCountSubSession* counter= new (ELeave) CCountSubSession(this);
         
          // add the CCountSubSession object to 
          // this subsession's object container
          // to gererate a unique id
        iContainer->AddL(counter);
        
          // Add the object to object index; this returns
          // a unique handle so that we can find the object
          // again laterit later.
        TInt handle=iCountersObjectIndex->AddL(counter);

      // Write the handle value back to the client.
      // NB It's not obvious but the handle value must be passed
      // back as the 4th parameter (i.e. parameter number 3 on
      // a scale of 0 to 3). 
      // The arguments that are passed across are actually
      // set up by RSubSessionBase::DoCreateSubSession().
      // If you pass your own arguments into a call
      // to RSubSessionBase::CreateSubSession(), which calls DoCreateSubSession, 
      // then only the first three are picked up - the 4th is reserved for the
      // the subsession handle.
        TPckgBuf<TInt> handlePckg(handle);
        TRAPD(res,aMessage.WriteL(3,handlePckg));
        if (res!=KErrNone)
                {
                iCountersObjectIndex->Remove(handle);
                PanicClient(aMessage,EBadDescriptor);
                return;
                }
                
          // We now have another "resource"
        iResourceCount++;
        }




void CCountSession::DeleteCounter(TInt aHandle)
        {
        
          // This will delete the CCountSubSession object; the object is
          // reference counted, and removing the handle causes the object to be closed
          // [closing reduces the access count - the object is deleted if the access
          //  count reaches zero etc].
        iCountersObjectIndex->Remove(aHandle); 
          // decrement resource count
        iResourceCount--;
        }


// return the number of resources owned by the session
// required by CSession if derived class implements resource
// mark-start and mark-end protocol
TInt CCountSession::CountResources()
        {
        return iResourceCount;
        }


void CCountSession::NumResourcesL(const RMessage2& aMessage)
        {
        TPckgBuf<TInt> resourcesPckg(iResourceCount);
        aMessage.WriteL(0,resourcesPckg);
        }


void CCountSession::PanicClient(const RMessage2& aMessage,TInt aPanic) const
        {
        _LIT(KTxtServer,"CountServ server");
        aMessage.Panic(KTxtServer,aPanic);
        }

---