// 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:
//


#include <mtp/tmtptypeevent.h>
#include <mtp/tmtptypeuint32.h>
#include <mtp/mmtpdataproviderframework.h>
#include <mtp/mmtpobjectmgr.h>
#include <mtp/mmtpstoragemgr.h>
#include <mtp/cmtpobjectmetadata.h>
#include <mtp/mmtpconnection.h>

#include "ptpdef.h"
#include "cptpserver.h"
#include "mtppictbridgedpconst.h"
#include "cmtppictbridgeprinter.h"

_LIT(KPtpFolder, "_Ptp\\");

// --------------------------------------------------------------------------
// 
// 2-phased constructor.
// --------------------------------------------------------------------------
//
CPtpServer* CPtpServer::NewL(MMTPDataProviderFramework& aFramework, CMTPPictBridgeDataProvider& aDataProvider)
    {
    CPtpServer* self = new (ELeave) CPtpServer(aFramework, aDataProvider);
    CleanupStack::PushL(self);
    self->ConstructL();
    self->StartL( KPTPServer );
    CleanupStack::Pop(self);  
    return self;
    }

// --------------------------------------------------------------------------
// 
// C++ constructor.
// --------------------------------------------------------------------------
//
CPtpServer::CPtpServer(MMTPDataProviderFramework& aFramework, CMTPPictBridgeDataProvider& aDataProvider) : CServer2(EPriorityStandard), 
                                                                iFramework(aFramework), 
                                                                iDataProvider(aDataProvider)
    {
    }

// --------------------------------------------------------------------------
// 
// 2nd phase constructor.
// --------------------------------------------------------------------------
//
void CPtpServer::ConstructL()
    {
    __FLOG_OPEN(KMTPSubsystem, KPtpServerLog);
    __FLOG(_L8(">>>CPtpServer::ConstructL"));
    iFileMan = CFileMan::NewL(iFramework.Fs());
    iPtpFolder = PathInfo::PhoneMemoryRootPath();
    iPtpFolder.Append( PathInfo::ImagesPath());   
    iPtpFolder.Append(KPtpFolder);
    iFileMan->RmDir(iPtpFolder);
    Framework().Fs().MkDirAll(iPtpFolder);

    iPrinterP = CMTPPictBridgePrinter::NewL(*this);
    __FLOG(_L8("<<<CPtpServer::ConstructL"));
    }
    

// --------------------------------------------------------------------------
// 
// C++ destructor.
// --------------------------------------------------------------------------
//
CPtpServer::~CPtpServer()
    {
    __FLOG(_L8(">>>CPtpServer::~"));
    delete iPrinterP;
    iPrinterP = NULL;
    delete iFileMan;
    iFileMan = NULL;    
    __FLOG(_L8("<<<CPtpServer::~"));
	__FLOG_CLOSE;
    }
        

// ----------------------------------------------------------------------------
// 
// from CServer2, creates a new session.
// ----------------------------------------------------------------------------
//
CSession2* CPtpServer::NewSessionL(const TVersion& aVersion, 
                                   const RMessage2& /*aMessage*/) const
    {
    __FLOG(_L8(">>>CPtpServer::NewSessionL"));
    TVersion v(KPtpServerVersionMajor, KPtpServerVersionMinor, 0);
    if (!User::QueryVersionSupported(v,aVersion))
        {
        __FLOG(_L8("!!!!Error: CPtpServer::NewSessionL version not support!"));
        User::Leave(KErrNotSupported);
        }
    if (iNumSession>0)
        {
        __FLOG(_L8("!!!!Error: CPtpServer::NewSessionL session is in use!"));
        User::Leave(KErrInUse);            
        }
    CPtpSession* session = CPtpSession::NewL(const_cast<CPtpServer*>(this)); 
    __FLOG(_L8("<<<CPtpServer::NewSessionL"));
    return session; 
    }

// --------------------------------------------------------------------------
// CPtpServer::GetObjectHandleByNameL()
// Returns object handle
// --------------------------------------------------------------------------
//
void CPtpServer::GetObjectHandleByNameL(const TDesC& aNameAndPath, TUint32& aHandle)
    {
    __FLOG_VA((_L16(">> CPtpServer::GetObjectHandleByNameL %S"), &aNameAndPath));
    aHandle=Framework().ObjectMgr().HandleL(aNameAndPath);
    __FLOG_VA((_L16("<< CPtpServer::GetObjectHandleByNameL %S == 0x%x"), &aNameAndPath, aHandle));
    }

// --------------------------------------------------------------------------
// CPtpServer::GetObjectNameByHandleL()
// Returns object name and path
// --------------------------------------------------------------------------
//
void CPtpServer::GetObjectNameByHandleL(TDes& aNameAndPath, 
                                       const TUint32 aHandle)
    {
    __FLOG(_L8(">> CPtpServer::GetObjectNameByHandleL"));
    TMTPTypeUint32 handle(aHandle);
    CMTPObjectMetaData* objectP=CMTPObjectMetaData::NewL();
    CleanupStack::PushL(objectP);
    TBool err = Framework().ObjectMgr().ObjectL(handle, *objectP);
    if(EFalse == err)
        {
        __FLOG(_L8("!!!!Error: CPtpServer::GetObjectNameByHandleL ObjectL failed!"));
        User::Leave(KErrBadHandle);
        }
    
    aNameAndPath=objectP->DesC(CMTPObjectMetaData::ESuid);    
    CleanupStack::PopAndDestroy(objectP);
    __FLOG(_L8("<< CPtpServer::GetObjectNameByHandleL"));
    }


// --------------------------------------------------------------------------
// CPtpServer::SendEvent
// Requests Object send
// --------------------------------------------------------------------------
//
void CPtpServer::SendEventL(TMTPTypeEvent& ptpEvent)
    {
    __FLOG(_L8(">> CPtpServer::SendEventL"));    

    if(iPrinterP->Status()!=CMTPPictBridgePrinter::EConnected)
        {
        __FLOG(_L8("   CPtpServer::SendEventL, no printer connection"));
        User::Leave(KErrNotReady);
        }
    Framework().SendEventL(ptpEvent, *(iPrinterP->ConnectionP()));

    __FLOG(_L8("<< CPtpServer::SendEventL"));    
    }

    
// --------------------------------------------------------------------------
// 
// 
// --------------------------------------------------------------------------
//  
MMTPDataProviderFramework& CPtpServer::Framework() const
    {
    return iFramework;
    }
    

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
// 
const TDesC& CPtpServer::PtpFolder()
    {
    return iPtpFolder; 
    }


// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
void CPtpServer::AddTemporaryObjectL(const TDesC& aPathAndFileName, TUint32& aHandle)
    {
    __FLOG_VA((_L8(">> CPtpServer::AddTemporaryObjectL")));

    // always using the default storage for this

    CMTPObjectMetaData* objectP(CMTPObjectMetaData::NewLC(Framework().DataProviderId(), 
                                     EMTPFormatCodeScript, // we only support sending DPS scripts
                                     Framework().StorageMgr().DefaultStorageId(), 
                                     aPathAndFileName));

    // since this object is temporary, we will not add any other details for it

    Framework().ObjectMgr().InsertObjectL(*objectP);
    aHandle=objectP->Uint(CMTPObjectMetaData::EHandle);
    CleanupStack::Pop(objectP);
    TInt err=iTemporaryObjects.Append(objectP); 
    if(err)
        {
        Framework().Fs().Delete(objectP->DesC(CMTPObjectMetaData::ESuid)); // not checking the return value since there is not much we can do with it
        RemoveObjectL(objectP->DesC(CMTPObjectMetaData::ESuid));
        delete objectP;
        __FLOG_VA((_L8("  CPtpServer::AddTemporaryObjectL, leaving %d"), err));
        User::Leave(err);
        }
    
    
    __FLOG_VA((_L8("<< CPtpServer::AddTemporaryObjectL")));
    }

// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
void CPtpServer::RemoveTemporaryObjects()
    {
    __FLOG_VA((_L8(">> CPtpServer::RemoveTemporaryObjects %d"), iTemporaryObjects.Count()));

    for (TInt i=0; i<iTemporaryObjects.Count();i++)
        {
        TInt err(KErrNone);
        TRAP(err,RemoveObjectL(iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid)));
        __FLOG_VA((_L16("removed object from db %S err=%d"), &(iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid)), err));
        err=Framework().Fs().Delete(iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid));
        __FLOG_VA((_L16("removed object from fs  %S err=%d"), &(iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid)), err));
        
        }
    iTemporaryObjects.ResetAndDestroy();
    __FLOG_VA((_L8("<< CPtpServer::RemoveTemporaryObjects %d"), iTemporaryObjects.Count()));
    }

// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
void CPtpServer::RemoveObjectL(const TDesC& aSuid)
    {    
    __FLOG_VA((_L16(">> CPtpServer::RemoveObjectL %S"), &aSuid));
    Framework().ObjectMgr().RemoveObjectL(aSuid);
    __FLOG_VA((_L8("<< CPtpServer::RemoveObjectL")));
    }

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
//     
void CPtpServer::MtpSessionClosed()
    {
    iMtpSessionOpen = EFalse;
    RemoveTemporaryObjects();
    iTemporaryObjects.Close();
    }

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
//     
void CPtpServer::MtpSessionOpened()
    {
    iMtpSessionOpen=ETrue;
    if(iSessionOpenNotifyClientP)
        {
        iSessionOpenNotifyClientP->MTPSessionOpened();
        iSessionOpenNotifyClientP=NULL;
        }
    }

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
//     
void CPtpServer::CancelNotifyOnMtpSessionOpen(CPtpSession* /*aSessionP*/)
    {
    iSessionOpenNotifyClientP=NULL;    
    }

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
//     
void CPtpServer::NotifyOnMtpSessionOpen(CPtpSession* aSession)
    {
    iSessionOpenNotifyClientP=aSession; 
    }