/** @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:  Implements remote access plugin API - loopback to File Server
 *
*/


// INCLUDE FILES
#include "upnpaccess.h"
#include "upnpmdebug.h"

#include <e32std.h>
#include <ecom/implementationproxy.h>

// ============================= LOCAL FUNCTIONS ===============================

// Map the interface UIDs to implementation factory functions
const TImplementationProxy ImplementationTable[] = 
    {
        {{0x101F9779}, (TProxyNewLPtr)CUpnpAccess::NewL}
    };

// ----------------------------------------------------------------------------
// ImplementationGroupProxy
// Exported proxy for instantiation method resolution
// ----------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy*
ImplementationGroupProxy(TInt& aTableCount)
    {
    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
    
    return ImplementationTable;
    }

// ============================ MEMBER FUNCTIONS ==============================
// ----------------------------------------------------------------------------
// CUpnpAccess::ConstructL
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CUpnpAccess::ConstructL()
    {
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::NewL
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CUpnpAccess* CUpnpAccess::NewL()
    {
    CUpnpAccess* self = new (ELeave) CUpnpAccess;
    DEBUGSTRING(("in NewL 0x%x", self));
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// Destructor
CUpnpAccess::~CUpnpAccess()
    {
    DEBUGSTRING(("in destructor 0x%x", this));
    delete iUUID;
    iAVCPEngineClient.Close();
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::SetupL
// ----------------------------------------------------------------------------
//
    void CUpnpAccess::SetupL(MRsfwRemoteAccessObserver*)
    {    
    DEBUGSTRING(("in SetupL"));
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::OpenL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::OpenL(const TUriC& aUri,
	                    const TDesC& /* aFriendlyName */,
						const TDesC& /* aUserName */,
                        const TDesC& /* aPassword */,                     
                        const TDesC& /* aAuxData */,
                        MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
   
    TPtrC host(aUri.Extract(EUriHost));
    DEBUGSTRING16(("open plugin for '%S'", &host));
        
    iUUID = HBufC8::NewL(host.Length());
    iUUID->Des().Copy(host);
    
    User::LeaveIfError(iAVCPEngineClient.Connect());
    
    aResponseHandler->HandleRemoteAccessResponse(0, KErrNone);
    return 0;
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::GetDirectoryL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::GetDirectoryL(const TDesC& aPathName,
                                RPointerArray<CRsfwDirEnt>& aDirEnts,
                                MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("get directory '%S'", &aPathName));

    TInt err = iAVCPEngineClient.GetDirectoryL(*iUUID, aPathName, aDirEnts);
    
    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;
    
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::GetDirectoryAttributesL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::GetDirectoryAttributesL(const TDesC& aPathName,
                                          CRsfwDirEntAttr*& aAttr,
                                          MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    // This function reads attributes of a directory
    // (not attributes of the files in the directory)
    DEBUGSTRING16(("Get directory attributes of '%S'", &aPathName));
    
    TInt err = iAVCPEngineClient.GetDirectoryAttributeL(*iUUID, aPathName, aAttr);

    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;
    
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::GetFileAttributesL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::GetFileAttributesL(const TDesC& aPathName,
                               CRsfwDirEntAttr*& aAttr,
                               MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("Get file attributes of '%S'", &aPathName));
    
    TInt err = iAVCPEngineClient.GetFileAttributeL(*iUUID, aPathName, aAttr);
        
    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;  
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::SetAttributesL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::SetAttributesL(const TDesC& aPathName,
                           CRsfwDirEntAttr& /*aAttr*/,
                           MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("Set attributes of '%S'",
                  &aPathName));

    aResponseHandler->HandleRemoteAccessResponse(0, KErrNotSupported);
    return 0;  
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::GetFileL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::GetFileL(const TDesC& aRemotePathName,
                           	const TDesC& aLocalPathName,
                           	TInt aOffset,
                           	TInt* aLength,
                   			TUint aFlags,                           
                           	MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
       
    DEBUGSTRING16(("get file '%S'", &aRemotePathName));
    DEBUGSTRING16(("     into file '%S'", &aLocalPathName));
    
    TInt length = 0;
    if (aLength) 
    {
        length = *aLength;
    }
    DEBUGSTRING(("offset=%d, length=%d", aOffset, length));        
    	
    TInt read;
    TInt err = iAVCPEngineClient.GetFileL(*iUUID, 
    		aRemotePathName, aLocalPathName, aOffset, length, aFlags, read);
    		
    if (aLength) {
    	*aLength = read;    	
    }
             
    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0; 

    }

// ----------------------------------------------------------------------------
// CUpnpAccess::MakeDirectoryL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::MakeDirectoryL(const TDesC& aPathName,
                           MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("Make directory '%S'", &aPathName));
    
    TInt err = iAVCPEngineClient.MakeDirectoryL(*iUUID, aPathName);    

    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;  
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::CreateFileL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::CreateFileL(const TDesC& aPathName, TBool aOverWriting,
                              MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("Create file '%S'", &aPathName));
    
    TInt err(0);
    if (aOverWriting) 
    	{
    	DEBUGSTRING16(("delete file '%S'", &aPathName));    
    	err = iAVCPEngineClient.DeleteFileL(*iUUID, aPathName);       	
    	}
    
    if (err == KErrNone) 
    	err = iAVCPEngineClient.CreateFileL(*iUUID, aPathName);    

    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;  
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::PutFileL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::PutFileL(const TDesC& aLocalPathName,
                        	const TDesC& aRemotePathName,
                   			const TDesC8& /*aMimeType*/,                             
                           	MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("put file '%S'", &aLocalPathName));
    DEBUGSTRING16(("     to remote file '%S'", &aRemotePathName));
        
    TInt err = iAVCPEngineClient.PutFileL(*iUUID, aLocalPathName, aRemotePathName);    

    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;   
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::PutFileL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::PutFileL(const TDesC& aLocalPathName,
                           	const TDesC& aRemotePathName,
							const TDesC8& /*aMimeType*/,                                                        	
                           	TInt /* aOffset */,
                           	TInt /* aLength */,
                           	TInt /* aTotalLength */,                   			
                           	MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("put file '%S'", &aLocalPathName));
    DEBUGSTRING16(("     to remote file '%S'", &aRemotePathName));

    aResponseHandler->HandleRemoteAccessResponse(0, KErrNotSupported);
    return 0; 
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::DeleteDirectoryL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::DeleteDirectoryL(const TDesC& aPathName,
                             MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("delete directory '%S'", &aPathName));
    
    TInt err = iAVCPEngineClient.DeleteDirectoryL(*iUUID, aPathName);    

    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;  
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::DeleteFileL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::DeleteFileL(const TDesC& aPathName,
                              MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("delete file '%S'", &aPathName));
    
    TInt err = iAVCPEngineClient.DeleteFileL(*iUUID, aPathName);    

    aResponseHandler->HandleRemoteAccessResponse(0, err);
    return 0;     
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::RenameL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::RenameL(const TDesC& aSrcPathName,
                          const TDesC& aDstPathName,
                          TBool /*aOverwrite*/,
                          MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    
    DEBUGSTRING16(("Rename '%S' to '%S'", &aSrcPathName, &aDstPathName));
    aResponseHandler->HandleRemoteAccessResponse(0, KErrNotSupported);
    return 0;
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::ObtainLockL
// ----------------------------------------------------------------------------
//

TUint CUpnpAccess::ObtainLockL(const TDesC&  aPathName ,
                        TUint /* aLockFlags */,
                        TUint& /*aTimeOut*/,
                        TDesC8*& /* aLockToken */,
                        MRsfwRemoteAccessResponseHandler*  aResponseHandler )
    {
    DEBUGSTRING16(("obtain lock '%S'", &aPathName));    

    aResponseHandler->HandleRemoteAccessResponse(0, KErrNotSupported);    
    return 0;
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::ReleaseLockL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::ReleaseLockL(const TDesC&  aPathName,
                         MRsfwRemoteAccessResponseHandler*  aResponseHandler)
    {
    DEBUGSTRING16(("release lock '%S'", &aPathName));

    aResponseHandler->HandleRemoteAccessResponse(0, KErrNotSupported);
    return 0;
    }

// ----------------------------------------------------------------------------
// CUpnpAccess::RefreshLockL
// ----------------------------------------------------------------------------
//
TUint CUpnpAccess::RefreshLockL(const TDesC&  aPathName, TUint& /*aTimeOut*/,
                         MRsfwRemoteAccessResponseHandler* aResponseHandler)
    {
    DEBUGSTRING16(("refresh lock '%S'", &aPathName));
    
    aResponseHandler->HandleRemoteAccessResponse(0, KErrNotSupported);    
    return 0;
    }
    
// ----------------------------------------------------------------------------
// CUpnpAccess::SetLockToken
// ----------------------------------------------------------------------------
//
TInt CUpnpAccess::SetLockToken(const TDesC& /* aPathName */,
                              const TDesC8& /* aLockToken */)
    {
    return KErrNotSupported;
    }
    
// ----------------------------------------------------------------------------
// CUpnpAccess::CancelL
// ----------------------------------------------------------------------------
//
void CUpnpAccess::Cancel(TDesC& /* aTargetPath */)
    {
    // Nothing to cancel
    }
// ----------------------------------------------------------------------------
// CUpnpAccess::CancelL
// ----------------------------------------------------------------------------
//
void CUpnpAccess::Cancel(TUint /* aId */)
    {
    // Nothing to cancel
    }


//  End of File