/** @file

* Copyright (c) 2005-2006 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:  Local interface

 *

*/

// INCLUDE FILES

#include "upnpcontainer.h"

#include "upnpitem.h"

#include "upnpelement.h"

#include "upnpattribute.h"

#include "upnpitemlist.h"

#include "upnpcontainerlist.h"

#include "upnpbrowsecriteria.h"

#include "upnplocalstorage.h"

#include "upnpobjectbean.h"

#include "upnpelementbean.h"

#include "upnpattributebean.h"

#include "upnpelementbean.h"

#include "upnpmetadatastorage.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpresourcesbean.h"

#include "upnpcdutils.h"

#include "upnpstatehandler.h"

#include "upnpstring.h"

#include "upnpcontentdirectory.h"

#include "upnpautodestroyobjectlist.h"

#include "upnpautodestroyobject.h"

#include <uriutils.h>

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

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

// CUpnpLocalStorage::CUpnpLocalStorage

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

// might leave.

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

//

CUpnpLocalStorage::CUpnpLocalStorage( CUpnpMetadataStorage* aMetadataStorage )

    {

    iMetadataStorage = aMetadataStorage; 

    }

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

// CUpnpLocalStorage::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpLocalStorage::ConstructL()

    {

    }

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

// CUpnpLocalStorage::NewL

// Two-phased constructor.

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

//

CUpnpLocalStorage* CUpnpLocalStorage::NewLC(

        CUpnpMetadataStorage* aMetadataStorage )

    {

    CUpnpLocalStorage* self = new ( ELeave ) CUpnpLocalStorage( aMetadataStorage );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CUpnpLocalStorage* CUpnpLocalStorage::NewL(

        CUpnpMetadataStorage* aMetadataStorage )

    {

    CUpnpLocalStorage* self = CUpnpLocalStorage::NewLC( aMetadataStorage );

    CleanupStack::Pop();

    return self;

    }

void CUpnpLocalStorage::SetStateHandler( CUpnpStateHandler* aStateHandler )

    {

    iStateHandler = aStateHandler;

    }

// Destructor

CUpnpLocalStorage::~CUpnpLocalStorage()

    {

    }

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

// CUpnpLocalStorage::ShareObjectL

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

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

//

void CUpnpLocalStorage::ShareObjectL( CUpnpObject* aObj )

    {

    TLex8 lexer( aObj->ParentId() );

    TPtrC8 parentId = aObj->ParentId();

    TInt containerId;

    User::LeaveIfError( lexer.Val( containerId ) );

    // check parent

    ValidateContainerL( containerId );

    // start transaction

    iMetadataStorage->BeginTransactionL();

    TRAPD(err, DoShareObjectL( containerId, aObj ) );

    if ( err )

        { // rollback if error

        iMetadataStorage->RollbackTransactionL();    

        User::Leave( err );

        }

    iMetadataStorage->CommitTransactionL();

    // eventing

    if (iStateHandler)

        {

        iStateHandler->IncreaseSystemUpdateIdL();     

        iStateHandler->IncreaseContainerUpdateIdL( parentId );   

        }

    }

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

// CUpnpLocalStorage::ShareReferenceL

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

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

//

void CUpnpLocalStorage::ShareReferenceL( CUpnpItem* aItem )

    {	    

	// check whether container exists and is not restricted

    TLex8 lexer( aItem->ParentId() );

    TPtrC8 parentId = aItem->ParentId();

    TInt containerId;

    User::LeaveIfError( lexer.Val( containerId ) );

    ValidateContainerL( containerId );    

    // if everything is OK -> start transaction

    iMetadataStorage->BeginTransactionL();

    TRAPD(err, DoShareReferenceL( containerId, aItem ) );

    if ( err )

        { // rollback if error

        iMetadataStorage->RollbackTransactionL();    

        User::Leave( err );

        }

    iMetadataStorage->CommitTransactionL();

    // eventing

    if (iStateHandler)

        {

        iStateHandler->IncreaseSystemUpdateIdL();                

        iStateHandler->IncreaseContainerUpdateIdL( parentId );   

        }               

    }

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

// CUpnpLocalStorage::ShareReferenceListL

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

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

//

void CUpnpLocalStorage::ShareReferenceListL( CUpnpItemList* aItemList, 

											TInt* aExecutionStatus )

	{

	//----- firstly - validate all containers upon which references are to be created.

	for ( TInt i = 0; i < aItemList->ObjectCount(); i++ )

	    {	    

	    TLex8 lex((*aItemList)[i]->ParentId());

	    TInt containerId;

	    User::LeaveIfError( lex.Val(containerId) );

	    ValidateContainerL(containerId);	    

	    }

	//----- if containers are OK, do the following ...

	// varaible used to do the rest of eventing

	TInt itemCommited=0; 

    // start transaction

    iMetadataStorage->BeginTransactionL();

    // reset status

    *aExecutionStatus = 0;

    // for each item in the list ...

    for ( TInt i = 0; i < aItemList->ObjectCount(); i++ )

        {               

        // get parentId field value [upon which 'reference item' will be created]

        TLex8 lexer((*aItemList)[i]->ParentId());

        TInt parentId = -1;

        User::LeaveIfError( lexer.Val(parentId) );            

        // commit every KCommitEveryNum inserts 

        if ( !(i%KCommitEveryNum) ) 

            {

            // ignore if i == 0;

            if ( i )

                {

                itemCommited=0;

                // commit last transaction

                iMetadataStorage->CommitTransactionL();

                // success - update status

                *aExecutionStatus = i;

                if ( iStateHandler )

                    {                                          

                    for ( TInt j = 0; j < KCommitEveryNum; j++ )

                        {

                        iStateHandler->IncreaseSystemUpdateIdL();    

                        iStateHandler->IncreaseContainerUpdateIdL( ( (*aItemList)[j]->ParentId() ) );    

                        }                       

                    }

                   // begin new transaction

                   iMetadataStorage->BeginTransactionL();                   

                }

            }

        // insert object

        CUpnpObject* object = ( *aItemList )[i];

        CUpnpItem* item = dynamic_cast<CUpnpItem*>( object );

        TRAPD( err, DoShareReferenceL( parentId, item ) );

        if ( err )

            { // rollback if error

            iMetadataStorage->RollbackTransactionL();    

            User::Leave(err);

            }

        itemCommited++;

        }

        // commit

        iMetadataStorage->CommitTransactionL();

        // success - update status

        *aExecutionStatus = aItemList->ObjectCount();

        //eventing

        if ( iStateHandler )

            {

            // do the rest of eventing if number of items were greater than KCommitEveryNum

            for ( TInt j = 0; j < itemCommited; j++ ) 

                {

                iStateHandler->IncreaseSystemUpdateIdL();     

                iStateHandler->IncreaseContainerUpdateIdL( ( ( *aItemList )[j]->ParentId() ) );    

                }            

            }			

	}

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

// CUpnpLocalStorage::UnshareItemL

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

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

//

void CUpnpLocalStorage::UnshareItemL( TInt aId )

    {

    // check id

    ValidateItemL( aId );

    HBufC8* containerId = HBufC8::NewLC( KMaxIntegerLen );

    TInt containerIdInt = iMetadataStorage->GetParentIdL( aId );

    if ( containerIdInt == KErrGeneral )

        {

        User::Leave( KErrNotFound );

        }

    containerId->Des().Num( containerIdInt );

    if (aId <= KDownloadContId)

        {

        User::Leave( KErrArgument );

        }

    RArray<TInt> refList;

    CleanupClosePushL(refList);

    if ( iMetadataStorage->DeleteObjectL( aId, refList, ETrue, ETrue ) == ENoSuchObject )

        {

        User::Leave( KErrNotFound );

        }

    // eventing

    if ( iStateHandler )

        {

        TBuf8<KMaxIntegerLen> parentRefID;

        iStateHandler->IncreaseSystemUpdateIdL();     

        iStateHandler->IncreaseContainerUpdateIdL( *containerId );

        for (TInt i(0);i<refList.Count();i++)

            {

            iStateHandler->IncreaseSystemUpdateIdL();                

            parentRefID.Num( refList[i] );     

            iStateHandler->IncreaseContainerUpdateIdL( parentRefID );

            }

        }

    // clean up

    CleanupStack::PopAndDestroy( &refList );

    CleanupStack::PopAndDestroy( containerId );

    }

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

// CUpnpLocalStorage::UnshareContainerL

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

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

//

void CUpnpLocalStorage::UnshareContainerL( TInt aId )

    {

    // check id

    ValidateContainerL( aId );

    HBufC8* containerId = HBufC8::NewLC( KMaxIntegerLen );

    containerId->Des().Num(iMetadataStorage->GetParentIdL( aId ) );

    if ( aId <= KDownloadContId )

        {

        User::Leave( KErrArgument );

        }

    RArray<TInt> refList;

    CleanupClosePushL(refList);    

    if ( iMetadataStorage->DeleteObjectL( aId,refList, ETrue, ETrue ) == ENoSuchObject )

        {

        User::Leave( KErrNotFound );

        }

    // eventing

    if ( iStateHandler )

        {            

        iStateHandler->IncreaseSystemUpdateIdL();     

        iStateHandler->IncreaseContainerUpdateIdL( *containerId );

        TBuf8<KMaxIntegerLen> parentRefID;    

        for (TInt i(0);i<refList.Count();i++)

            {

            parentRefID.Num( refList[i] );                 

            if ( containerId->Compare( parentRefID ) )

                {

                iStateHandler->IncreaseSystemUpdateIdL();                           

                iStateHandler->IncreaseContainerUpdateIdL( parentRefID );   

                }            

            }

        refList.Reset();

        }

    CleanupStack::PopAndDestroy( &refList );

    CleanupStack::PopAndDestroy( containerId );

    }

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

// CUpnpLocalStorage::GetSharedItemL

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

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

//

CUpnpItem* CUpnpLocalStorage::GetSharedItemL( TInt aItemId )

    {

    // new item

    CUpnpItem* item = CUpnpItem::NewL();

    CleanupStack::PushL( item );

    // get object

    GetObjectL( aItemId, item );

    // clean up

    CleanupStack::Pop( item );

    return item;

    }

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

// CUpnpLocalStorage::ShareItemListL

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

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

//

void CUpnpLocalStorage::ShareItemListL(CUpnpItemList* aItemList,

        TInt* aExecutionStatus )

    {

    TInt itemCommited=0;

    // check parent    

    TLex8 lexer((*aItemList)[0]->ParentId());

    TInt parentId;

    User::LeaveIfError( lexer.Val(parentId) );

    ValidateContainerL(parentId);

      // start transaction

       iMetadataStorage->BeginTransactionL();

       // reset status

       *aExecutionStatus = 0;

    // for each item

    for ( TInt i = 0; i < aItemList->ObjectCount(); i++ )

        {

        // commit every KCommitEveryNum inserts

        if ( !(i%KCommitEveryNum) ) 

            {

            // ignore if i == 0;

            if ( i )

                {

                itemCommited=0;

                // commit last transaction

                iMetadataStorage->CommitTransactionL();

                // success - update status

                *aExecutionStatus = i;

                if ( iStateHandler )

                    {                                          

                    for ( TInt j =0; j<KCommitEveryNum; j++ )

                        {

                        iStateHandler->IncreaseSystemUpdateIdL();    

                        iStateHandler->IncreaseContainerUpdateIdL( ( (*aItemList)[0]->ParentId() ) );    

                        }                       

                    }

                   // begin new transaction

                   iMetadataStorage->BeginTransactionL();                   

                }

            }

        // insert object

        TRAPD( err, DoShareObjectL( parentId, ( *aItemList )[i]) );

        if ( err )

            { // rollback if error

            iMetadataStorage->RollbackTransactionL();    

            User::Leave(err);

            }

        itemCommited++;

        }

        // commit

        iMetadataStorage->CommitTransactionL();

        // success - update status

        *aExecutionStatus = aItemList->ObjectCount();

        //eventing

        if ( iStateHandler )

            {

            for ( TInt j =0; j<itemCommited; j++ )

                {

                iStateHandler->IncreaseSystemUpdateIdL();     

                iStateHandler->IncreaseContainerUpdateIdL( ( ( *aItemList )[0]->ParentId() ) );    

                }            

            }                       

    }

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

// CUpnpLocalStorage::ValidateContainerL

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

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

//

void CUpnpLocalStorage::ValidateContainerL( TInt aContainerId )

    {

    if ( !iMetadataStorage->IsContainerL( aContainerId ) )

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CUpnpLocalStorage::ValidateItemL

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

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

//

void CUpnpLocalStorage::ValidateItemL( TInt aItemId )

    {

    if ( iMetadataStorage->IsContainerL( aItemId ) )

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CUpnpLocalStorage::UnshareItemListL

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

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

//

void CUpnpLocalStorage::UnshareItemListL( RArray<TInt>& aObjList, 

                                          TInt* aExecutionStatus )

    {

    // list of resources

    RArray<TInt> refList;

    RArray<TInt> resList;

    RArray<TInt> objCommitedList;

    CleanupClosePushL(objCommitedList);

    CleanupClosePushL(resList);

    CleanupClosePushL(refList);

    TInt parentId(0);

    // start transaction

    iMetadataStorage->BeginTransactionL();

    // reset status

    *aExecutionStatus = 0;

    // for each item

    for (TInt i = 0; i < aObjList.Count(); i++ )

        {

        parentId = iMetadataStorage->GetParentIdL( aObjList[i] );

        if ( parentId>=0 )

            {

            objCommitedList.Append(parentId);

            // commit every KCommitEveryNum inserts

            if( !( i%KCommitEveryNum ) ) 

                {

                // ignore if i == 0;

                if ( i )

                    {                

                    // commit last transaction

                    iMetadataStorage->CommitTransactionL();

                    // everything went OK, delete files

                    iMetadataStorage->DeleteResourcesL(resList);

                    resList.Reset();

                    // success - update status

                    *aExecutionStatus = i;

                    // eventing

                    if (iStateHandler)

                        {                   

                        for (TInt j =0;j<objCommitedList.Count();j++)

                            {

                            iStateHandler->IncreaseSystemUpdateIdL();

                             TBuf8<KMaxIntegerLen> containerId;                       

                            containerId.Num( objCommitedList[j] );

                            iStateHandler->IncreaseContainerUpdateIdL( containerId );                    

                            }

                        objCommitedList.Reset();

                        TBuf8<KMaxIntegerLen> parentRefID;    

                           for ( TInt i(0); i<refList.Count(); i++ )

                            {