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