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

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cptpserverTraces.h"

#endif

_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()

    {

    OstTraceFunctionEntry0( CPTPSERVER_CONSTRUCTL_ENTRY );

    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);

    OstTraceFunctionExit0( CPTPSERVER_CONSTRUCTL_EXIT );

    }

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

// 

// C++ destructor.

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

//

CPtpServer::~CPtpServer()

    {

    OstTraceFunctionEntry0( CPTPSERVER_CPTPSERVER_DES_ENTRY );

    delete iPrinterP;

    iPrinterP = NULL;

    delete iFileMan;

    iFileMan = NULL;    

    OstTraceFunctionExit0( CPTPSERVER_CPTPSERVER_DES_EXIT );

    }

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

// 

// from CServer2, creates a new session.

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

//

CSession2* CPtpServer::NewSessionL(const TVersion& aVersion, 

                                   const RMessage2& /*aMessage*/) const

    {

    OstTraceFunctionEntry0( CPTPSERVER_NEWSESSIONL_ENTRY );

    TVersion v(KPtpServerVersionMajor, KPtpServerVersionMinor, 0);

    if (!User::QueryVersionSupported(v,aVersion))

        {

        OstTrace0( TRACE_ERROR, CPTPSERVER_NEWSESSIONL, "!!!!Error: version not support!" );

        User::Leave(KErrNotSupported);

        }

    if (iNumSession>0)

        {

        OstTrace0( TRACE_ERROR, DUP1_CPTPSERVER_NEWSESSIONL, "!!!!Error: session is in use!" );

        User::Leave(KErrInUse);            

        }

    CPtpSession* session = CPtpSession::NewL(const_cast<CPtpServer*>(this)); 

    OstTraceFunctionExit0( CPTPSERVER_NEWSESSIONL_EXIT );

    return session; 

    }

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

// CPtpServer::GetObjectHandleByNameL()

// Returns object handle

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

//

void CPtpServer::GetObjectHandleByNameL(const TDesC& aNameAndPath, TUint32& aHandle)

    {

    OstTraceFunctionEntry0( CPTPSERVER_GETOBJECTHANDLEBYNAMEL_ENTRY );

    OstTraceExt1( TRACE_NORMAL, CPTPSERVER_GETOBJECTHANDLEBYNAMEL, "Name %S", aNameAndPath );

    aHandle=Framework().ObjectMgr().HandleL(aNameAndPath);

    OstTraceExt2( TRACE_NORMAL, DUP1_CPTPSERVER_GETOBJECTHANDLEBYNAMEL, 

            "Name %S == Handle 0x%x", aNameAndPath, aHandle );

    OstTraceFunctionExit0( CPTPSERVER_GETOBJECTHANDLEBYNAMEL_EXIT );

    }

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

// CPtpServer::GetObjectNameByHandleL()

// Returns object name and path

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

//

void CPtpServer::GetObjectNameByHandleL(TDes& aNameAndPath, 

                                       const TUint32 aHandle)

    {

    OstTraceFunctionEntry0( CPTPSERVER_GETOBJECTNAMEBYHANDLEL_ENTRY );

    TMTPTypeUint32 handle(aHandle);

    CMTPObjectMetaData* objectP=CMTPObjectMetaData::NewL();

    CleanupStack::PushL(objectP);

    TBool err = Framework().ObjectMgr().ObjectL(handle, *objectP);

    if(EFalse == err)

        {

        OstTrace0( TRACE_ERROR, CPTPSERVER_GETOBJECTNAMEBYHANDLEL, "!!!!Error: ObjectL failed!" );

        User::Leave(KErrBadHandle);

        }

    aNameAndPath=objectP->DesC(CMTPObjectMetaData::ESuid);    

    CleanupStack::PopAndDestroy(objectP);

    OstTraceFunctionExit0( CPTPSERVER_GETOBJECTNAMEBYHANDLEL_EXIT );

    }

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

// CPtpServer::SendEvent

// Requests Object send

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

//

void CPtpServer::SendEventL(TMTPTypeEvent& ptpEvent)

    {

    OstTraceFunctionEntry0( CPTPSERVER_SENDEVENTL_ENTRY ); 

    if(iPrinterP->Status()!=CMTPPictBridgePrinter::EConnected)

        {

        OstTrace0( TRACE_ERROR, CPTPSERVER_SENDEVENTL, " no printer connection" );

        User::Leave(KErrNotReady);

        }

    Framework().SendEventL(ptpEvent, *(iPrinterP->ConnectionP()));

    OstTraceFunctionExit0( CPTPSERVER_SENDEVENTL_EXIT );

    }

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

// 

// 

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

//  

MMTPDataProviderFramework& CPtpServer::Framework() const

    {

    return iFramework;

    }

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

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

// 

const TDesC& CPtpServer::PtpFolder()

    {

    return iPtpFolder; 

    }

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

// 

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

//

void CPtpServer::AddTemporaryObjectL(const TDesC& aPathAndFileName, TUint32& aHandle)

    {

    OstTraceFunctionEntry0( CPTPSERVER_ADDTEMPORARYOBJECTL_ENTRY );

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

        OstTrace1( TRACE_ERROR, CPTPSERVER_ADDTEMPORARYOBJECTL, " leaving %d", err);

        User::Leave(err);

        }

    OstTraceFunctionExit0( CPTPSERVER_ADDTEMPORARYOBJECTL_EXIT );

    }

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

// 

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

//

void CPtpServer::RemoveTemporaryObjects()

    {

    OstTraceFunctionEntry0( CPTPSERVER_REMOVETEMPORARYOBJECTS_ENTRY );

    OstTrace1( TRACE_NORMAL, CPTPSERVER_REMOVETEMPORARYOBJECTS, "plan to remove %d temporary objects", iTemporaryObjects.Count());

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

        {

        TInt err(KErrNone);

        TRAP(err,RemoveObjectL(iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid)));

        OstTraceExt2( TRACE_NORMAL, DUP1_CPTPSERVER_REMOVETEMPORARYOBJECTS, 

                "removed object from db %S err=%d", iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid), err);

        err=Framework().Fs().Delete(iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid));

        OstTraceExt2( TRACE_NORMAL, DUP2_CPTPSERVER_REMOVETEMPORARYOBJECTS, 

                "removed object from fs %S err=%d", iTemporaryObjects[i]->DesC(CMTPObjectMetaData::ESuid), err);        

        }

    iTemporaryObjects.ResetAndDestroy();

    OstTrace1( TRACE_NORMAL, DUP3CPTPSERVER_REMOVETEMPORARYOBJECTS, "%d temporary objects remain", iTemporaryObjects.Count());        

    OstTraceFunctionExit0( CPTPSERVER_REMOVETEMPORARYOBJECTS_EXIT );

    }

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

// 

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

//

void CPtpServer::RemoveObjectL(const TDesC& aSuid)

    {    

    OstTraceFunctionEntry0( CPTPSERVER_REMOVEOBJECTL_ENTRY );

    OstTraceExt1( TRACE_NORMAL, CPTPSERVER_REMOVEOBJECTL, "remove %S", aSuid );

    Framework().ObjectMgr().RemoveObjectL(aSuid);

    OstTraceFunctionExit0( CPTPSERVER_REMOVEOBJECTL_EXIT );

    }

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

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

//     

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; 

    }