--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/upnpsharing/upnpsharingalgorithm/src/upnpsharingalgorithmimpl.cpp Wed Nov 03 11:45:09 2010 +0200
@@ -0,0 +1,714 @@
+/*
+* Copyright (c) 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: Implementation of the class CUpnpSharingAlgorithmImpl.
+*
+*/
+
+// INCLUDE FILES, SYSTEM
+#include <upnpdlnaprofiler.h>
+#include <upnpitem.h>
+#include "upnpcommonutils.h"
+#include "upnpmetadatafetcher.h"
+#include "upnpfileutility.h"
+#include <escapeutils.h> // ConvertFromUnicodeToUtf8L
+#include <bautils.h> // File existence check
+#include "upnpconstantdefs.h"
+#include <mm/mmcleanup.h> // for array cleanup
+
+// INCLUDE FILES, USER
+#include "upnpcontainerresolver.h"
+#include "upnpsharingao.h"
+#include "upnpcdsreaderao.h"
+#include "upnpsharingalgorithmimpl.h"
+#include "upnpsharingalgorithmconstants.h"
+#include "upnplog.h"
+#include "upnpcdsliteobject.h"
+#include "upnpcdsliteobjectarray.h"
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithm::NewL
+// --------------------------------------------------------------------------
+//
+CUpnpSharingAlgorithmImpl* CUpnpSharingAlgorithmImpl::NewL()
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithmImpl::NewL" );
+
+ CUpnpSharingAlgorithmImpl* self = CUpnpSharingAlgorithmImpl::NewLC();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::NewLC
+// Two-phased constructor
+// --------------------------------------------------------------------------
+//
+CUpnpSharingAlgorithmImpl* CUpnpSharingAlgorithmImpl::NewLC()
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithmImpl::NewLC" );
+
+ CUpnpSharingAlgorithmImpl* self =
+ new ( ELeave ) CUpnpSharingAlgorithmImpl();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+
+ return self;
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::~CUpnpSharingAlgorithmImpl
+// --------------------------------------------------------------------------
+//
+CUpnpSharingAlgorithmImpl::~CUpnpSharingAlgorithmImpl()
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithmImpl::\
+~CUpnpSharingAlgorithmImpl" );
+
+ delete iContainerResolver;
+ delete iSharingAO;
+ delete iSharedContentArray;
+
+ iMediaServer.Close();
+ }
+
+// --------------------------------------------------------------------------
+// CCUpnpSharingAlgorithmImpl::ConstructL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::ConstructL()
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithmImpl::\
+ConstructL" );
+
+ // connect to server
+ User::LeaveIfError( iMediaServer.Connect() );
+ // Start server if not yet started
+ StartServer();
+
+ // An array to list all the shared files on the CDS
+ iSharedContentArray = CUpnpCdsLiteObjectArray::NewL();
+ // container structure resolver
+ // contentarray is always up-to-date
+ iContainerResolver =
+ CUpnpContainerResolver::NewL( *iSharedContentArray );
+
+ CUpnpCdsReaderAO* cdsReader =
+ CUpnpCdsReaderAO::NewL( *iSharedContentArray );
+ CleanupStack::PushL( cdsReader );
+ cdsReader->ReadCdsStructureL();
+ CleanupStack::PopAndDestroy( cdsReader );
+
+ // Active object for sharing and unsharing the items
+ iSharingAO = CUpnpSharingAO::NewL();
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::ShareFileL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::ShareFileL(
+ const TFileName & aFileName )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+ ShareFileL" );
+
+ // Check that file exists. Leaves with KErrArgument if not exist.
+ CheckFileExistenceL( aFileName );
+
+ // Check that file is not protected. Leaves with KAccessDenied if yes.
+ CheckFileProtectionL( aFileName );
+
+ if ( !IsFileSharedL( aFileName ) )
+ {
+ // Start server if not yet started
+ StartServer();
+
+ // create upnpitem...
+ CUpnpItem* upnpItem =
+ UPnPMetadataFetcher::CreateItemFromFileLC( aFileName );
+
+ // Resolve container structure
+ RPointerArray<CUpnpContainer> containerArray =
+ iContainerResolver->ResolveContainerStructureL( *upnpItem );
+ CleanupResetAndDestroyPushL( containerArray );
+
+ if ( containerArray.Count() )
+ {
+ // Share containers
+ ShareContainersL( containerArray );
+
+ // parent container id for item is the last shared container id
+ TPtrC8 itemParentContainerId =
+ containerArray[ containerArray.Count()-1 ]->Id();
+ // ... and share it
+ iSharingAO->ShareFileL( itemParentContainerId, upnpItem );
+
+ // Add the file to the shared content array
+ iSharedContentArray->AppendL( upnpItem );
+ }
+ else
+ {
+ // All containers exists already.
+ // Resolver put parentid to item
+ iSharingAO->ShareFileL( upnpItem->ParentId(), upnpItem );
+
+ // Add the file to the shared content array
+ iSharedContentArray->AppendL( upnpItem );
+ }
+
+ // SHARE reference containers and items
+ ShareReferenceObjectsL( upnpItem );
+
+ // Cleanup
+ CleanupStack::PopAndDestroy( &containerArray );
+ CleanupStack::PopAndDestroy( upnpItem );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::UnshareFileL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::UnshareFileL(
+ const TFileName& aFileName )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::UnshareFileL" );
+
+ // Convert the filename to 8bit
+ HBufC8* filename = EscapeUtils::ConvertFromUnicodeToUtf8L( aFileName );
+ CleanupStack::PushL( filename );
+
+ // Search the array for the item
+ TInt arrayindex = iSharedContentArray->FindByName( *filename );
+
+ // Continue only if the file was found
+ if ( arrayindex >= 0 )
+ {
+ // Start server if not yet started
+ StartServer();
+
+ // Get the object reference
+ CUpnpCdsLiteObject& object =
+ iSharedContentArray->ObjectAtL( arrayindex );
+
+ // unshare references first
+ UnshareReferenceObjectsL( object );
+
+ // Checks the container tree and unshares if needed
+ // First container id to be checked is item's parentid
+ TBool containerUnshared =
+ UnshareEmptyContainersL( object.ParentId() );
+
+ // if container is not unshared the item needs to be unshared
+ if ( !containerUnshared )
+ {
+ // Leave if ObjectId not found
+ if( object.ObjectId() == KNullDesC8 )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+ UnshareFileL, ObjectId not found!" );
+ User::Leave( KErrCorrupt );
+ }
+
+ TInt objectIdInt( KErrNotFound );
+ User::LeaveIfError(
+ objectIdInt = UPnPCommonUtils::DesC8ToInt( object.ObjectId() ));
+
+ // Unshare the item
+ iSharingAO->UnshareFileL( objectIdInt );
+
+ // index must be retrieved again because reference item removal
+ // changes indexes
+ arrayindex =
+ iSharedContentArray->FindByObjectId(object.ObjectId());
+ // Remove the file from the shared content array
+ iSharedContentArray->RemoveObjectAtL( arrayindex );
+ }
+ else
+ {
+ // index must be retrieved again because removal of containers
+ // change indexes
+ arrayindex = iSharedContentArray->FindByName( *filename );
+ // item was also unshared when container was unshared
+ // it's enough to remove item from contentarray
+ iSharedContentArray->RemoveObjectAtL( arrayindex );
+ }
+ }
+ // Cleanup
+ CleanupStack::PopAndDestroy( filename );
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::IsFileSharedL
+// --------------------------------------------------------------------------
+//
+TBool CUpnpSharingAlgorithmImpl::IsFileSharedL(
+ const TFileName& aFileName )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithmImpl::\
+ IsFileSharedL" );
+
+ TBool returnValue = EFalse;
+
+ // Convert the filename to 8bit
+ HBufC8* tempFilename =
+ EscapeUtils::ConvertFromUnicodeToUtf8L( aFileName );
+ CleanupStack::PushL( tempFilename );
+
+ // Search the file from the array
+ TInt index = iSharedContentArray->FindByName( *tempFilename );
+ if( index >= 0 )
+ {
+ returnValue = ETrue;
+ }
+
+ // Clean up
+ CleanupStack::PopAndDestroy( tempFilename );
+
+ return returnValue;
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::CheckFileExistenceL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::CheckFileExistenceL(
+ const TFileName& aFileName )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithmImpl::\
+CheckFileExistenceL" );
+
+ TBool fileExists( EFalse );
+
+ RFs fsSession;
+ User::LeaveIfError( fsSession.Connect() ); // connect session
+ CleanupClosePushL( fsSession );
+
+ // check that file exists
+ fileExists = BaflUtils::FileExists( fsSession, aFileName );
+
+ CleanupStack::PopAndDestroy( &fsSession );
+
+ if ( !fileExists )
+ {
+ User::Leave( KErrArgument );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::UnshareEmptyContainersL
+// --------------------------------------------------------------------------
+//
+TBool CUpnpSharingAlgorithmImpl::UnshareEmptyContainersL( TDesC8& aParentId )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithmImpl::\
+UnshareEmptyContainersL" );
+
+ TBool containerUnshared( EFalse );
+
+ // get top container id that does not contain item
+ // starting from container where item is.
+ RPointerArray<CUpnpCdsLiteObject> containerList =
+ iContainerResolver->ResolveEmptyContainersL( aParentId );
+ CleanupClosePushL( containerList );
+
+ TInt containerCount = containerList.Count();
+ if ( containerCount )
+ {
+ // Get top containerId which needs to be unshared.
+ TPtrC8 containerIdStr = containerList[containerCount-1]->ObjectId();
+ TInt objectIdInt( KErrNotFound );
+ User::LeaveIfError(
+ objectIdInt = UPnPCommonUtils::DesC8ToInt( containerIdStr ));
+ // unshares all objecs under this container with single call
+ TRAPD( error, iSharingAO->UnshareContainerL( objectIdInt ));
+ if ( !error )
+ {
+ for ( TInt i = 0; i < containerCount; i++ )
+ {
+ // get container's array index
+ TInt arrayIndex =
+ iSharedContentArray->FindByObjectId(
+ containerList[i]->ObjectId() );
+
+ // Remove the container from the shared content array
+ iSharedContentArray->RemoveObjectAtL( arrayIndex );
+ }
+ }
+ containerUnshared = ETrue;
+ }
+
+ CleanupStack::PopAndDestroy( &containerList );
+
+ return containerUnshared;
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::ShareContainersL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::ShareContainersL(
+ RPointerArray<CUpnpContainer>& aContainerArray )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+ShareContainersL" );
+
+ TPtrC8 previousContainerId( KNullDesC8 );
+
+ // Share containers
+ for ( TInt i = 0; i < aContainerArray.Count(); i++ )
+ {
+ CUpnpContainer* container = aContainerArray[i];
+
+ // first container ( index = 0 ) have parent id ready
+ if ( container->ParentId() == KNullDesC8 )
+ {
+ // parentid is previously shared container id
+ container->SetParentIdL( previousContainerId );
+ }
+
+ TInt error( KErrNone );
+ TRAP( error, iSharingAO->ShareContainerL( container ));
+ if ( error )
+ {
+ // remove shared objects from server because of error
+ RemoveSharedObjectsL( aContainerArray );
+ User::LeaveIfError( error );
+ }
+ // container got id on sharing - keep it safe for next container
+ // because it it used as parent container id
+ previousContainerId.Set( container->Id());
+
+ // no errors - append containers to cdsliteobjectarray
+ TRAP( error, iSharedContentArray->AppendL( container ));
+ if ( error )
+ {
+ // remove shared objects from array because of error
+ RemoveSharedObjectsL( aContainerArray );
+ User::LeaveIfError( error );
+ }
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::ShareReferenceObjectsL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::ShareReferenceObjectsL( CUpnpItem* aItem )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+ShareReferenceObjectsL" );
+
+ // Get cds object from array. Reference item ids will be
+ // added to this item
+ TInt index = iSharedContentArray->FindByObjectId( aItem->Id() );
+ CUpnpCdsLiteObject& object = iSharedContentArray->ObjectAtL( index );
+
+ // reset id because a new one will be given when reference is shared
+ aItem->SetIdL( KNullDesC8 );
+ // reset refid field because item is reference
+ aItem->SetRefIdL( KNullDesC8 );
+ // reset title
+ aItem->SetTitleL( KNullDesC8 );
+ // reset parentId
+ aItem->SetParentIdL( KNullDesC8 );
+
+ if ( aItem->ObjectClass() == KClassAudioMusicTrack )
+ {
+ // Resolve genre containers
+ RPointerArray<CUpnpContainer> refContainers =
+ iContainerResolver->ResolveReferenceContainersL( EGenreType,
+ *aItem );
+ CleanupResetAndDestroyPushL( refContainers );
+ if ( refContainers.Count() ||
+ aItem->ParentId() != KNullDesC8 )
+ {
+ // share container(s) and item
+ ShareReferenceObjectL( refContainers, object, *aItem );
+ }
+ CleanupStack::PopAndDestroy( &refContainers );
+
+ // reset parentId
+ aItem->SetParentIdL( KNullDesC8 );
+ // Resolve album containers
+ refContainers =
+ iContainerResolver->ResolveReferenceContainersL( EAlbumType,
+ *aItem );
+ CleanupResetAndDestroyPushL( refContainers );
+ if ( refContainers.Count() ||
+ aItem->ParentId() != KNullDesC8 )
+ {
+ // share container(s) and item
+ ShareReferenceObjectL( refContainers, object, *aItem );
+ }
+ CleanupStack::PopAndDestroy( &refContainers );
+
+ // reset parentId
+ aItem->SetParentIdL( KNullDesC8 );
+ // Resolve artist containers
+ refContainers =
+ iContainerResolver->ResolveReferenceContainersL( EArtistType,
+ *aItem );
+ CleanupResetAndDestroyPushL( refContainers );
+ if ( refContainers.Count() ||
+ aItem->ParentId() != KNullDesC8 )
+ {
+ // share container(s) and item
+ ShareReferenceObjectL( refContainers, object, *aItem );
+ }
+ CleanupStack::PopAndDestroy( &refContainers );
+
+ // reset parentId
+ aItem->SetParentIdL( KNullDesC8 );
+ // Resolve artist containers
+ refContainers =
+ iContainerResolver->ResolveReferenceContainersL( EMusicByDateType,
+ *aItem );
+ CleanupResetAndDestroyPushL( refContainers );
+ if ( refContainers.Count() ||
+ aItem->ParentId() != KNullDesC8 )
+ {
+ // share container(s) and item
+ ShareReferenceObjectL( refContainers, object, *aItem );
+ }
+ CleanupStack::PopAndDestroy( &refContainers );
+ }
+
+
+ else if ( aItem->ObjectClass() == KClassImage )
+ {
+ // reset parentId
+ aItem->SetParentIdL( KNullDesC8 );
+ // resolve date container
+ RPointerArray<CUpnpContainer> refContainers =
+ iContainerResolver->ResolveReferenceContainersL( EImageByDateType,
+ *aItem );
+ CleanupResetAndDestroyPushL( refContainers );
+ if ( refContainers.Count() ||
+ aItem->ParentId() != KNullDesC8 )
+ {
+ // share container(s) and item
+ ShareReferenceObjectL( refContainers, object, *aItem );
+ }
+ CleanupStack::PopAndDestroy( &refContainers );
+ }
+
+ else if ( aItem->ObjectClass() == KClassVideo )
+ {
+ // reset parentId
+ aItem->SetParentIdL( KNullDesC8 );
+ // resolve date container
+ RPointerArray<CUpnpContainer> refContainers =
+ iContainerResolver->ResolveReferenceContainersL( EVideoByDateType,
+ *aItem );
+ CleanupResetAndDestroyPushL( refContainers );
+ if ( refContainers.Count() )
+ {
+ // share container(s) and item
+ ShareReferenceObjectL( refContainers, object, *aItem );
+ }
+ CleanupStack::PopAndDestroy( &refContainers );
+ }
+ else
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+ ShareReferenceObjectsL object class not defined" );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::UnshareReferenceObjectsL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::UnshareReferenceObjectsL(
+ CUpnpCdsLiteObject& aOriginalObject )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+UnshareReferenceObjectsL" );
+
+ TInt refIndex( KErrNotFound );
+
+ do
+ {
+ // find reference items created from original item
+ refIndex = iSharedContentArray->FindRefItemIdByOriginalIdL(
+ aOriginalObject.ObjectId() );
+
+ if ( refIndex != KErrNotFound )
+ {
+ CUpnpCdsLiteObject& refObject =
+ iSharedContentArray->ObjectAtL( refIndex );
+
+ // Checks the container tree and unshares if needed
+ // First container id to be checked is item's parentid
+ TBool containerUnshared =
+ UnshareEmptyContainersL( refObject.ParentId() );
+
+ // if container is not unshared the item needs to be unshared
+ if ( !containerUnshared )
+ {
+ // Leave if ObjectId not found
+ if( refObject.ObjectId() == KNullDesC8 )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t \
+CUpnpSharingAlgorithm::UnshareFileL, ObjectId not found!" );
+ User::Leave( KErrCorrupt );
+ }
+
+ TInt objectIdInt( KErrNotFound );
+ User::LeaveIfError( objectIdInt =
+ UPnPCommonUtils::DesC8ToInt( refObject.ObjectId() ));
+
+ // Unshare the item
+ iSharingAO->UnshareFileL( objectIdInt );
+
+ // Remove the file from the shared content array
+ iSharedContentArray->RemoveObjectAtL( refIndex );
+ }
+ else
+ {
+ // index has changed because container(s) was unshared
+ refIndex = iSharedContentArray->FindByObjectId(
+ refObject.ObjectId() );
+ // item was also unshared when container was unshared
+ // it's enough to remove item from contentarray
+ iSharedContentArray->RemoveObjectAtL( refIndex );
+ }
+ }
+ } while ( refIndex != KErrNotFound );
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::ShareReferenceObjectL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::ShareReferenceObjectL(
+ RPointerArray<CUpnpContainer>& aContainerArray,
+ CUpnpCdsLiteObject& aOriginalObject,
+ CUpnpItem& aItem )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+ShareReferenceObjectL" );
+
+ TPtrC8 refParentId( KNullDesC8 );
+ TInt parentContainerId( KErrNotFound );
+
+ TInt count = aContainerArray.Count();
+
+ if ( count )
+ {
+ // reference container must be non-restricted
+ aContainerArray[count-1]->SetRestricted(EFalse);
+ // share containers
+ ShareContainersL( aContainerArray );
+
+ refParentId.Set( aContainerArray[count-1]->Id() );
+ User::LeaveIfError(
+ parentContainerId = UPnPCommonUtils::DesC8ToInt( refParentId ));
+ }
+ else // share just item
+ {
+ refParentId.Set( aItem.ParentId() );
+ User::LeaveIfError(
+ parentContainerId = UPnPCommonUtils::DesC8ToInt( refParentId ));
+ }
+
+ TInt originalItemId( KErrNotFound );
+ User::LeaveIfError( originalItemId = UPnPCommonUtils::DesC8ToInt(
+ aOriginalObject.ObjectId() ));
+
+ iSharingAO->ShareReferenceL( parentContainerId, originalItemId, &aItem );
+ // Add the file to the shared content array
+ iSharedContentArray->AppendL( &aItem );
+
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::RemoveSharedObjectsL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::RemoveSharedObjectsL(
+ RPointerArray<CUpnpContainer>& aContainerArray )
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+RemoveSharedObjectsL" );
+
+ // Unshare starting from first container
+ TPtrC8 containerIdStr = aContainerArray[0]->Id();
+ TInt objectIdInt( KErrNotFound );
+ User::LeaveIfError(
+ objectIdInt= UPnPCommonUtils::DesC8ToInt( containerIdStr ));
+ // unshares all objecs under this container with single call
+ iSharingAO->UnshareContainerL( objectIdInt );
+
+ for ( TInt i = 0; i < aContainerArray.Count(); i++)
+ {
+ // Remove object from the shared content array
+ iSharedContentArray->RemoveL( aContainerArray[i] );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::ReadSharedContent
+// --------------------------------------------------------------------------
+//
+CUpnpCdsLiteObjectArray& CUpnpSharingAlgorithmImpl::ReadSharedContent()
+ {
+ return *iSharedContentArray;
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::StartServer
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::StartServer()
+ {
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+StartServer" );
+
+ // start offline if not started
+ TInt status( RUpnpMediaServerClient::EStopped );
+ iMediaServer.Status( status );
+ if ( status == RUpnpMediaServerClient::EStopped )
+ {
+ iMediaServer.StartOffline();
+ __LOG( "[CUpnpSharingAlgorithm]\t CUpnpSharingAlgorithm::\
+StartServer started offline" );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::Close
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::Close()
+ {
+ delete this;
+ }
+
+// --------------------------------------------------------------------------
+// CUpnpSharingAlgorithmImpl::CheckFileProtectionL
+// --------------------------------------------------------------------------
+//
+void CUpnpSharingAlgorithmImpl::CheckFileProtectionL(
+ const TFileName& aFileName )
+ {
+ if ( UPnPFileUtility::IsFileProtectedL( aFileName ) )
+ {
+ User::Leave( KErrAccessDenied );
+ }
+ }
+
+// End of file