/*

* Copyright (c) 2002 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:  Sub-session class of the Storage Server

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include	"CPEngStorageSubSession.h"

#include	"PEngStorageServerCommon.h"

#include	"CPEngStorageFolder.h"

#include	"MPEngStorageServer.h"

#include	"RPEngMessage.h"

// ============================ MEMBER FUNCTIONS ===============================

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

// CPEngStorageSubSession::CPEngStorageSubSession

// C++ default constructor can NOT contain any code, that might leave.

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

//

CPEngStorageSubSession::CPEngStorageSubSession( TInt32 aSessionId )

        : iBufferedNotif( 10 ), // 10 as value to grow array

        iSessionId( aSessionId )

    {

    }

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

// CPEngStorageSubSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEngStorageSubSession::ConstructL(

    MPEngStorageServer& aServer,

    const RPEngMessage& aMessage )

    {

    iStorageFolder = aServer.StorageFolderL( aMessage );

    }

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

// CPEngStorageSubSession::NewL

// Two-phased constructor.

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

//

CPEngStorageSubSession* CPEngStorageSubSession::NewL(

    MPEngStorageServer& aServer,

    const RPEngMessage& aMessage,

    TInt32 aSessionId )

    {

    CPEngStorageSubSession* self = NewLC( aServer, aMessage, aSessionId );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CPEngStorageSubSession::NewLC

// Two-phased constructor.

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

//

CPEngStorageSubSession* CPEngStorageSubSession::NewLC(

    MPEngStorageServer& aServer,

    const RPEngMessage& aMessage,

    TInt32 aSessionId )

    {

    CPEngStorageSubSession* self = new( ELeave ) CPEngStorageSubSession( aSessionId );

    CleanupClosePushL( *self );

    self->ConstructL( aServer, aMessage );

    return self;

    }

// Destructor

CPEngStorageSubSession::~CPEngStorageSubSession()

    {

    iBufferedNotif.Reset();

    // decrease count of the storage Folder

    if ( iStorageFolder )

        {

        iStorageFolder->CancelSubSessionRequests( iSessionId, iHandle );

        iStorageFolder->Close();

        }

    }

// =============================================================================

// =============== Functions from base class ===================================

// =============================================================================

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

// CPEngStorageSubSession::DisplayName()

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

//

TBool CPEngStorageSubSession::DispatchMessageL(

    const RPEngMessage& aMessage,

    TInt aRequest )

    {

    TBool completeMessage( ETrue );

    switch ( aRequest )

        {

            /*********************************************************************/

            /*  Asynchronous Requests Management                                 */

            /*********************************************************************/

            // Cancel Asynchronous request Request

        case EFolderSubSessCancelRequest:

            {

            iStorageFolder->CancelRequest( aMessage,

                                           iSessionId,

                                           iHandle );

            break;

            }

        // Reload Asynchronous Scout on the Server side

        case EFolderSubSessReloadAsynchronousScout:

            {

            iStorageFolder->ReloadAsyncScoutL( aMessage,

                                               iSessionId,

                                               iHandle );

            completeMessage = EFalse;

            break;

            }

        /*********************************************************************/

        /*  Store Entry management                                           */

        /*********************************************************************/

        // Write store entry

        case EFolderSubSessWriteEntry:

            {

            const CPEngDataEntry* entry = iStorageFolder->WriteStoreEntryL(

                                              aMessage,

                                              !iBufferingActiveCounter,

                                              iSessionId,

                                              iHandle );

            if ( entry )

                {

                TInt err( iBufferedNotif.InsertInAddressOrder( entry ) );

                err = err == KErrAlreadyExists ? KErrNone : err;

                User::LeaveIfError( err );

                }

            break;

            }

        // Read store Entry

        case EFolderSubSessReadEntry:

            {

            iStorageFolder->ReadStoreEntryL( aMessage );

            break;

            }

        // Get Entry size

        case EFolderSubSessGetEntryLength:

            {

            iStorageFolder->GetStoreEntryLengthL( aMessage );

            break;

            }

        // Remove Store entry from the storage

        case EFolderSubSessRemoveEntry:

            {

            iStorageFolder->RemoveStoreEntryL( aMessage );

            break;

            }

        // Lock Store Entry

        case EFolderSubSessLockEntry:

            {

            iStorageFolder->LockStoreEntryL( aMessage,

                                             iSessionId,

                                             iHandle );

            completeMessage = EFalse;

            break;

            }

        // Unlock the Store entry

        case EFolderSubSessUnlockEntry:

            {

            // check if it is needed to buffer notification

            const CPEngDataEntry* entry =

                iStorageFolder->UnlockStoreEntryL(

                    aMessage,

                    !iBufferingActiveCounter,

                    iSessionId,

                    iHandle );

            if ( entry )

                {

                TInt err( iBufferedNotif.InsertInAddressOrder( entry ) );

                err = err == KErrAlreadyExists ? KErrNone : err;

                User::LeaveIfError( err );

                }

            completeMessage = EFalse;

            break;

            }

        // Is Store entry locked

        case EFolderSubSessIsEntryLocked:

            {

            iStorageFolder->IsStoreEntryLockedL( aMessage );

            completeMessage = EFalse;

            break;

            }

        // Suspend notification to the client

        case EFolderSubSessSuspendNotification:

            {

            iBufferingActiveCounter += aMessage.Int0();

            aMessage.Complete( iBufferingActiveCounter );

            completeMessage = EFalse;

            break;

            }

        // Resume notification to the client

        case EFolderSubSessResumeNotification:

            {

            ResumeSIDsNotification( aMessage.Int0() );

            aMessage.Complete( iBufferingActiveCounter );

            completeMessage = EFalse;

            break;

            }

        /*********************************************************************/

        /*   Storage ID changes notify management                            */

        /*********************************************************************/

        // Synchronous Request to register for notification

        case EFolderSubSessListenSIDsChanges:

            {

            iStorageFolder->ListenSIDsChangesL( aMessage,

                                                iSessionId,

                                                iHandle );

            break;

            }

        // Synchronous Request to update set of SIDs client

        case EFolderSubSessUpdateListenSIDsScout:

            {

            iStorageFolder->UpdateListenSIDsScoutL( aMessage,

                                                    iSessionId,

                                                    iHandle );

            break;

            }

        // Fetch indexes of changed SIds

        case EFolderSubSessFetchChangedSIDsIndexes:

            {

            iStorageFolder->FetchChangedIdsIndexesL( aMessage,

                                                     iSessionId,

                                                     iHandle );

            break;

            }

        // Synchronous Request to force notify Store Entry change

        case EFolderSubSessNotifyChangedSIDs:

            {

            // check if it is needed to buffer notification

            const CPEngDataEntry* entry =

                iStorageFolder->NotifyChangedStorageIdL(

                    aMessage,

                    !iBufferingActiveCounter );

            if ( entry )

                {

                TInt err( iBufferedNotif.InsertInAddressOrder( entry ) );

                err = err == KErrAlreadyExists ? KErrNone : err;

                User::LeaveIfError( err );

                }

            break;

            }

        default:

            {

            PanicClient( aMessage, ESSBadRequest );

            break;

            }

        }

    // check if message can be completed

    completeMessage &= aMessage.MessageValid();

    return completeMessage;

    }

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

// CPEngStorageSubSession::SetSubSesionHandle()

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

//

void CPEngStorageSubSession::SetSubSesionHandle(

    TInt aHandle )

    {

    iHandle = aHandle;

    }

// =============================================================================

// =============== Private Functions from base class ===========================

// =============================================================================

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

// CPEngStorageSubSession::PanicClient()

// Panic client

// (other items were commented in a header).

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

//

void CPEngStorageSubSession::PanicClient(

    const RPEngMessage& aMessage,

    const TInt aPanic ) const

    {

    aMessage.Panic( KStorageSessionName, aPanic );

    }

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

// CPEngStorageSubSession::ResumeSIDsNotificationL()

// Resume Notification of the SIDs

// (other items were commented in a header).

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

//

void CPEngStorageSubSession::ResumeSIDsNotification(

    TInt aCount )

    {

    iBufferingActiveCounter -= aCount;

    if ( iBufferingActiveCounter <= KErrNone )

        {

        // notify buffered SIDs

        iBufferingActiveCounter = KErrNone;

        iStorageFolder->NotifySIDChanges( iBufferedNotif );

        iBufferedNotif.Reset();

        }

    }

//  End of File