// 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 <f32file.h>

#include "rptp.h"

#include "ptpdef.h"

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

// RPtp::RPtp()

// C++ Constructor

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

//

EXPORT_C RPtp::RPtp()

    {

    iConnected=EFalse;

    }

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

// RPtp::Connect()

// Creates session with PtpServer

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

//

EXPORT_C TInt RPtp::Connect()

    {

    // We do not attempt to start the server since it is started up only when 

    // MTP is loaded (at USB cable connection). To be compatible with previous 

    // version of PTP server we keep track of the connection and try to create it

    // if it does not yet exist.

    if(DoConnect() != KErrNone) // we claim that the connection succeeded.

    	{

    	//Do nothing.Still return KErrNone to lanuch ImagePrint to prompt users to plug-in USB cable.

    	}

    return KErrNone;

    }

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

// RPtp::DoConnect()

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

//

TInt RPtp::DoConnect()

    {

    TInt ret=KErrNone;

    if(EFalse==iConnected)

        {

        TVersion version(KPtpServerVersionMajor, KPtpServerVersionMinor, 0);

        ret=KErrNotReady;

        ret = CreateSession( KPTPServer, version );

        if (KErrNone==ret)

            {

            iConnected=ETrue;

            }

        }

    return ret; 

    }

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

// RPtp::CreatePtpStack()

// Creates session with PTP Server, creates PTP stack and loads transposrt plugin

// Called by PTP Class controller

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

//

EXPORT_C TInt RPtp::CreatePtpStack(const TUid /* aTransport */)

    {

    Connect();

    return KErrNone;

    }

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

// RPtp::IsDpsPrinter()

// Asynchronously request request DPS printer status

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

//

EXPORT_C void RPtp::IsDpsPrinter(TRequestStatus& aStatus)

    {

    if(DoConnect()==KErrNone)

        {

        SendReceive(EIsDpsPrinter, aStatus);

        }

    else

        {

        TRequestStatus* statusP=&aStatus;

        User::RequestComplete(statusP, EPrinterNotAvailable);

        }

    }

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

// RPtp::CancelIsDpsPrinter()

// Cancel DPS printer status request

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

//

EXPORT_C void RPtp::CancelIsDpsPrinter()

    {

    if(DoConnect()==KErrNone)

        {

        if(SendReceive(ECancelIsDpsPrinter)==KErrServerTerminated)

            {

            iConnected=EFalse;

            }

        }

    }

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

// RPtp::SendObject()

// Request send object to Pictbridge Printer host 

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

//

EXPORT_C void RPtp::SendObject(const TDesC& aNameAndPath, 

                               TRequestStatus& aStatus, TBool aTimeout, 

                               TInt aSize, TBool aAdd)

    {   

    if(DoConnect()==KErrNone)

        {

        iFile.Copy(aNameAndPath);

        const TIpcArgs args(&iFile, aAdd, aTimeout, aSize); 

        SendReceive(ESendObject, args, aStatus);

        }

    else

        {

        TRequestStatus* statusP=&aStatus;

        User::RequestComplete(statusP, KErrNotReady);

        }

    }

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

// RPtp::CancelSendObject()

// Cancel send object request 

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

//

EXPORT_C void RPtp::CancelSendObject()

    {

    if(DoConnect()==KErrNone)

        {

        if(SendReceive(ECancelSendObject)==KErrServerTerminated)

            {

            iConnected=EFalse;    

            }

        }

    }

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

// RPtp::GetObjectHandleByName()

// Get Object handle by name

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

//

EXPORT_C TInt RPtp::GetObjectHandleByName(const TDesC& aNameAndPath, 

                                          TUint32& aHandle, 

                                          TBool /*aAdd*/)

    {

    TInt ret=KErrNone;

    if((ret=DoConnect())==KErrNone)

        {

        TPckgBuf<TUint32> pckgHandle(aHandle);

        const TIpcArgs args(&aNameAndPath, &pckgHandle, EFalse/*aAdd*/);

        ret = SendReceive(EGetObjectHandleByName, args);

        if (ret == KErrNone)

            {

            aHandle = (TUint32)pckgHandle();

            if(0 == aHandle)

                {

                ret = KErrNotFound;

                }

            }

        else if (ret == KErrServerTerminated)

            {

            iConnected=EFalse;    

            }

        }

    return ret;     

    }

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

// GetNameByObjectHandle()

// Get object name and path by object handle 

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

//

EXPORT_C TInt RPtp::GetNameByObjectHandle(TDes& aNameAndPath, 

                                          const TUint32 aHandle)

    {

    TInt ret=KErrNone;

    if((ret=DoConnect())==KErrNone)

        {   

        TPckgBuf<TUint32> pckgHandle(aHandle);

        const TIpcArgs args(&aNameAndPath, &pckgHandle);

        ret = SendReceive(EGetNameByObjectHandle, args);

        if (ret==KErrServerTerminated)

            {

            iConnected=EFalse;    

            }

        }

    return ret;

    }

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

// RPtp::ObjectReceivedNotify()

// Register for object received notification

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

//

EXPORT_C void RPtp::ObjectReceivedNotify( const TDesC& aExt,

                                          TDes& aNameAndPath,

                                          TRequestStatus& aStatus,

                                          TBool aDelete )

    {

    if(DoConnect()==KErrNone)

        {

        iExt.Copy(aExt);

        const TIpcArgs args(&iExt, &aNameAndPath, aDelete);

        SendReceive(EObjectReceivedNotify, args, aStatus);

        }

    else

        {

        TRequestStatus* statusP=&aStatus;

        User::RequestComplete(statusP, KErrNotReady);

        }

    }

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

// RPtp::CancelObjectReceivedNotify()

// Cancel for object received notification

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

//

EXPORT_C void RPtp::CancelObjectReceivedNotify()

    {

    if(DoConnect()==KErrNone)

        {

        if(SendReceive(ECancelObjectReceivedNotify)==KErrServerTerminated)

            {

            iConnected=EFalse;    

            }

        }

    }

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

// RPtp::DestroyPtpStatck()

// Destroy PTP stack @deprecated, only calls close, use Close() instead

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

//

EXPORT_C void RPtp::DestroyPtpStatck()

    {

    Close();

    }

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

// RPtp::Close()

// Override RSessionBase::Close();

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

//

EXPORT_C void RPtp::Close()

    {

    RSessionBase::Close();

    iConnected=EFalse;

    }

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

// RPtp::PtpFolder()

// returns name and Path of PtpFolder

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

//      

EXPORT_C const TDesC& RPtp::PtpFolder()

    {

    if(DoConnect()==KErrNone)

        {

        const TIpcArgs args(&iFile); 

        if(SendReceive(EPtpFolder, args)==KErrServerTerminated)

            {

            iConnected=EFalse;    

            }

        }

    return iFile;

    }