// 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/mmtpdataproviderframework.h>
#include <f32file.h>
#include "cptpsession.h"
#include "cptpserver.h"
#include "cptpreceivedmsghandler.h"
#include "cmtppictbridgeprinter.h"
#include "cptptimer.h"
#include "mtppictbridgedpconst.h"
#include "ptpdef.h" 

// --------------------------------------------------------------------------
// 
// 2-phased constructor.
// --------------------------------------------------------------------------
//
CPtpSession* CPtpSession::NewL(CPtpServer* aServer)
    {
    CPtpSession* self= new (ELeave) CPtpSession(aServer);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// --------------------------------------------------------------------------
// 
// C++ constructor.
// --------------------------------------------------------------------------
//
CPtpSession::CPtpSession(CPtpServer* aServer) : iServerP(aServer) 
    {
    iServerP->Printer()->RegisterObserver(this); // since PTP register service 
                  // is deprecated we register the observer at session creation
    iServerP->IncrementSessionCount();                  
    }

// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
void CPtpSession::ConstructL()
    {
    __FLOG_OPEN(KMTPSubsystem, KPtpServerLog);
    iTimerP=CPtpTimer::NewL(*this);
    }
// --------------------------------------------------------------------------
// 
// C++ destructor.
// --------------------------------------------------------------------------
//
CPtpSession::~CPtpSession()
    {
    __FLOG(_L8(">>>CPtpSession::~"));
    delete iTimerP;
    CancelOutstandingRequest();
    TRAP_IGNORE(CleanupL()); // there is not much we can do at this phase if the removal fails, so just ignore
    if(iServerP->NumSession())
        {
        iServerP->DecrementSessionCount();
        }
    __FLOG(_L8("<<<CPtpSession::~"));
    __FLOG_CLOSE;
    }

// --------------------------------------------------------------------------
// 
// From CSession2, passes the request forward to DispatchMessageL.
// --------------------------------------------------------------------------
//
void CPtpSession::ServiceL( const RMessage2& aMessage )
    {
    __FLOG(_L8(">>>CPtpSession::ServiceL"));
    DispatchMessageL(aMessage);
    __FLOG(_L8("<<<CPtpSession::ServiceL"));
    }

// --------------------------------------------------------------------------
//  Cleans up the previously received DPS file, since the files are used only 
//  for communication
// --------------------------------------------------------------------------
//
void CPtpSession::CleanupL()
    {
    __FLOG(_L8(">>>CPtpSession::Cleanup"));
    if(iReceivedFile.Size())
        {
        __FLOG_VA((_L16("   deleting file %S"), &iReceivedFile));
        User::LeaveIfError(iServerP->Framework().Fs().Delete(iReceivedFile));
        __FLOG(_L8("   removing from DB"));
        iServerP->RemoveObjectL(iReceivedFile);
        iReceivedFile.Zero();
        }
    __FLOG(_L8("<<<CPtpSession::Cleanup"));
    }

// --------------------------------------------------------------------------
// Handles the request from client.
// --------------------------------------------------------------------------
//
void CPtpSession::DispatchMessageL( const RMessage2& aMessage )
    {
    __FLOG_VA((_L8(">>>CPtpSession::DispatchMessageL %d"), aMessage.Function()));
    TInt ret = KErrNone;
    TBool complete = ETrue;        
    CleanupL(); // calling this here assumes that the client never makes a new call 
                // before it has handled the received DPS message
    switch( aMessage.Function() )
        {        
        case EIsDpsPrinter:
            ret = IsDpsPrinter(aMessage, complete);
            break;

        case ECancelIsDpsPrinter:
            CancelIsDpsPrinter();
            break;

        case EGetObjectHandleByName:  
            GetObjectHandleByNameL(aMessage);
            break;

        case EGetNameByObjectHandle:
            GetNameByObjectHandleL(aMessage);
            break;

        case ESendObject:
            ret = SendObject(aMessage, complete);
            break;

        case ECancelSendObject:
            CancelSendObject();
            break;

        case EObjectReceivedNotify:
            ret = ObjectReceivedNotify(aMessage, complete);
            break;

        case ECancelObjectReceivedNotify:
            CancelObjectReceivedNotify();
            break;

        case EPtpFolder:
            ret = PtpFolder(aMessage);
            break;

        default:
            __FLOG(_L8("!!!Error: ---Wrong param from client!!!"));
            aMessage.Panic(KPTPClientPanicCategory, EBadRequest);
            break;
        }
        
    if (complete)
        {
        aMessage.Complete(ret);
        }
    __FLOG_VA((_L8("<<<PtpSession::DispatchMessageL ret=%d"), ret));
    }

// --------------------------------------------------------------------------
// CPtpSession::CancelIsDpsPrinter()
// Cancels Asynchronous request IsDpsPrinter
// --------------------------------------------------------------------------
//
void CPtpSession::CancelIsDpsPrinter()
    {
    __FLOG(_L8(">>>CPtpSession::CancelIsDpsPrinter"));
    if (iDpsPrinterMsg.Handle())
        {
        iDpsPrinterMsg.Complete(KErrCancel);
        iServerP->Printer()->DeRegisterDpsPrinterNotify(this);
        iTimerP->Cancel();
        iServerP->CancelNotifyOnMtpSessionOpen(this);
        } 
    __FLOG(_L8("<<<CPtpSession::CancelIsDpsPrinter"));
    }
    
// --------------------------------------------------------------------------
// CPtpSession::CancelSendObject()
// Cancel Asynchronous request send Object
// --------------------------------------------------------------------------
//
void CPtpSession::CancelSendObject()
    {
    __FLOG(_L8(">>>CancelSendObject"));
    if (iSendObjectMsg.Handle())
        {
        iServerP->Printer()->CancelSendDpsFile();
        iSendObjectMsg.Complete(KErrCancel);
        iTimerP->Cancel();
        }
    __FLOG(_L8("<<<CancelSendObject"));    
    }
    
// --------------------------------------------------------------------------
// CPtpSession::CancelObjectReceivedNotify()
// Deregisters for Object received notification
// --------------------------------------------------------------------------
//
void CPtpSession::CancelObjectReceivedNotify()
    {
    __FLOG(_L8(">>>CancelObjectReceivedNotify"));       
    if (iObjectReceivedNotifyMsg.Handle())
        {
        __FLOG_VA((_L8("the handle is 0x%x"), iObjectReceivedNotifyMsg.Handle()));
        iServerP->Printer()->MsgHandlerP()->DeRegisterReceiveObjectNotify();
        iObjectReceivedNotifyMsg.Complete(KErrCancel);                    
        }
    __FLOG(_L8("<<<CancelObjectReceivedNotifiy"));
    }
    
// --------------------------------------------------------------------------
// CPtpSession::IsDpsPrinter()
// --------------------------------------------------------------------------
//    
TInt CPtpSession::IsDpsPrinter(const RMessage2& aMessage, TBool& aComplete)
    {
    __FLOG(_L8(">>>IsDpsPrinter"));
    TInt ret=EPrinterNotAvailable;
    if (!iDpsPrinterMsg.Handle()) // not already pending
        {
        switch (iServerP->Printer()->Status())
            {   
            case CMTPPictBridgePrinter::ENotConnected:
                iDpsPrinterMsg = aMessage;    
                iServerP->Printer()->RegisterDpsPrinterNotify(this);
                aComplete = EFalse;
                if(iServerP->MtpSessionOpen())
                    {
                    if (!iTimerP->IsActive()) 
                        {
                        iTimerP->After(KDiscoveryTime);
                        }
                    }
                else
                    {
                    iServerP->NotifyOnMtpSessionOpen(this);
                    }                    
                // we do not set ret since the  value does not really matter, we will be waiting for the discovery to complete
                __FLOG(_L8(" waiting"));
                break;
                
            case CMTPPictBridgePrinter::EConnected:
                ret=EPrinterAvailable;
                aComplete = ETrue;
                __FLOG(_L8(" connected"));
                break;

            case CMTPPictBridgePrinter::ENotPrinter:
                ret=EPrinterNotAvailable;
                aComplete = ETrue;
                __FLOG(_L8(" not connected"));
                break;

            default:
                break;                
            }
        }
    else
        {
        __FLOG(_L8("!!!Error: client message error, duplicated IsDpsPrinter"));                        
        aMessage.Panic(KPTPClientPanicCategory, ERequestPending);
        aComplete = EFalse;
        }
    __FLOG(_L8("<<<IsDpsPrinter"));
    return ret;
    }

// --------------------------------------------------------------------------
// start the timer for printer detection, since we have now session open and 
// we are ready to communicate wioth the host
// --------------------------------------------------------------------------
void CPtpSession::MTPSessionOpened()
    {
    __FLOG(_L8(">>>CPtpSession::MTPSessionOpened"));
    if (!iTimerP->IsActive() && iDpsPrinterMsg.Handle()) 
        {
        __FLOG(_L8("   CPtpSession::MTPSessionOpened timer started"));
        iTimerP->After(KDiscoveryTime);
        }        
    __FLOG(_L8("<<<CPtpSession::MTPSessionOpened"));
    }
    
// --------------------------------------------------------------------------
// CPtpSession::GetObjectHandleByNameL()
// 
// --------------------------------------------------------------------------
//
void CPtpSession::GetObjectHandleByNameL(const RMessage2& aMessage)
    {
    __FLOG(_L8(">>>CPtpSession::GetObjectHandleByNameL"));
    TFileName file;
    User::LeaveIfError(aMessage.Read(0, file));
    __FLOG_VA((_L16("--the file is %S"), &file));
    TUint32 handle=0;
    TRAP_IGNORE(iServerP->GetObjectHandleByNameL(file, handle));
    TPckgBuf<TUint32> handlePckg(handle);
    aMessage.WriteL(1, handlePckg);     
    __FLOG_VA((_L16("<<<CPtpSession::GetObjectHandleByNameL handle=%d"), handle));
    }
    
// --------------------------------------------------------------------------
// CPtpSession::GetNameByObjectHandle()

// --------------------------------------------------------------------------
//
void CPtpSession::GetNameByObjectHandleL(const RMessage2& aMessage)
    {
    __FLOG(_L8(">>>CPtpSession::GetNameByObjectHandle"));               
    TUint32 handle = 0;
    TPckgBuf<TUint32> pckgHandle(handle);
    User::LeaveIfError(aMessage.Read(1, pckgHandle));
    TFileName file; 
    handle = pckgHandle();
    __FLOG_VA((_L8("---handle is %x"), handle));
    TRAP_IGNORE(iServerP->GetObjectNameByHandleL(file, handle));
    __FLOG_VA((_L16("the file is %S"), &file));
    aMessage.WriteL(0, file);
    
    __FLOG(_L8("<<<CPtpSession::GetNameByObjectHandle"));               
    }
              
// --------------------------------------------------------------------------
// CPtpSession::SendObject()
// Asynch. request send Object
// --------------------------------------------------------------------------
//
TInt CPtpSession::SendObject(const RMessage2& aMessage, TBool& aComplete)
    {
    __FLOG(_L8(">>>CPtpSession::SendObject"));                      
    TInt err(KErrNone);
    
    if (iSendObjectMsg.Handle())
        {
        __FLOG(_L8("!!!!Error: client message error, duplicated SendObject"));
        aMessage.Panic(KPTPClientPanicCategory, ERequestPending);
        aComplete = EFalse;
        return KErrNone;
        }
    else
        {
        // Parameter add is depracated. We do not send Object added and we do not keep ther DPS object permanently in
        // our system.
        //
        // Sending ObjectAdded Event is not mandatory ( See Appendix B page 78. DPS Usage of USB and PTP in CIPA DC-001-2003)

        TBool timeout = aMessage.Int2();    
        __FLOG_VA((_L8("---timeout is %d"), timeout));    
        TFileName file; 
        err = aMessage.Read(0, file);
        if (err == KErrNone)
            {
            __FLOG_VA((_L16("---the file is %S"), &file));
            TInt size = aMessage.Int3();
            __FLOG_VA((_L8("---the file size is %d"), size)); // size is deprecated and not used anymore
            TRAP(err, iServerP->Printer()->SendDpsFileL(file, timeout, size));
            if (err == KErrNone)
                {
                iSendObjectMsg = aMessage;
                aComplete = EFalse;    
                }
            }
        if ((EFalse != timeout) && !iTimerP->IsActive())
            {
            iTimerP->After(KSendTimeout);
            }
        __FLOG_VA((_L8("<<<CPtpSession::SendObject err=%d"), err));
        return err;    
        }    
    }             

// --------------------------------------------------------------------------
// CPtpSession::ObjectReceivedNotify()
// 
// --------------------------------------------------------------------------
//   
TInt CPtpSession::ObjectReceivedNotify(const RMessage2& aMessage, 
                                       TBool& aComplete)
    {
    __FLOG(_L8(">>>CPtpSession::ObjectReceivedNotify"));                        
    if (iObjectReceivedNotifyMsg.Handle())
        {
        __FLOG(_L8("!!!!Error: client message error, duplicated ObjectReceivedNotify"));
        aMessage.Panic(KPTPClientPanicCategory, ERequestPending);
        aComplete = EFalse;
        return KErrNone;
        }
    else
        {
        //TBool del = aMessage.Int2();
        //__FLOG_VA((_L8("---the del is %d"), del));    

        TBuf<KFileExtLength> ext; 
        TInt err = aMessage.Read(0, ext);
        if (err == KErrNone)
            {
            __FLOG_VA((_L16("the extension is %S"), &ext));
            
            iObjectReceivedNotifyMsg = aMessage; 
            aComplete = EFalse;
            iServerP->Printer()->MsgHandlerP()->RegisterReceiveObjectNotify(ext);
            }
        __FLOG(_L8("<<<CPtpSession::ObjectReceivedNotify"));                            
        return err;
        }
    }
    
// --------------------------------------------------------------------------
// CPtpSession::PtpFolder()
// Returns PtpFolder Name and Path
// --------------------------------------------------------------------------
//    
TInt CPtpSession::PtpFolder(const RMessage2& aMessage)
    {
    __FLOG(_L8(">>>CPtpSession::PtpFolder"));
    TInt err(KErrNotReady);
    TFileName folder = iServerP->PtpFolder();
    err = aMessage.Write(0,folder);
    __FLOG_VA((_L16("<<<CPtpSession::PtpFolder %S err(%d)"), &folder, err));
    return err;
    }
    
// --------------------------------------------------------------------------
// CPtpSession::SendObjectCompleted()
// 
// --------------------------------------------------------------------------
//    
void CPtpSession::SendObjectCompleted(TInt aStatus)
    {
    __FLOG_VA((_L16(">>>CPtpSession::SendObjectCompleted status(%d)"), aStatus));
    if (iSendObjectMsg.Handle())
        {
        iSendObjectMsg.Complete(aStatus);    
        iTimerP->Cancel();
        }
    else
        {
        __FLOG(_L8("!!!Warning: CPtpSession::SendObjectCompleted: UNEXPECTED CALL"));
        }
    __FLOG(_L8("<<<CPtpSession::SendObjectCompleted")); 
    }

// --------------------------------------------------------------------------
// CPtpSession::IsDpsPrinterCompleted()
// 
// --------------------------------------------------------------------------
//
void CPtpSession::IsDpsPrinterCompleted(TDpsPrinterState aState)
    {
    __FLOG(_L8(">>>CPtpSession::IsDpsPrinterCompleted"));    
    if (iDpsPrinterMsg.Handle())
        {
        iDpsPrinterMsg.Complete(aState);
        iTimerP->Cancel();
        iServerP->Printer()->DeRegisterDpsPrinterNotify(this);
        }
    else
        {
        __FLOG(_L8("!!!Warning: CPtpSession::IsDpsPrinterCompleted: UNEXPECTED CALL"));
        }
    __FLOG(_L8("<<<CPtpSession::IsDpsPrinterCompleted"));    
    }

// --------------------------------------------------------------------------
// CPtpSession::ReceivedObjectCompleted()
// 
// --------------------------------------------------------------------------
//
void CPtpSession::ReceivedObjectCompleted(TDes& aFile)
    {
    __FLOG(_L8(">>>CPtpSession::ReceivedObjectCompleted"));
    if (iObjectReceivedNotifyMsg.Handle())
        {
        TInt err = iObjectReceivedNotifyMsg.Write(1, aFile);
        iReceivedFile.Copy(aFile);
        __FLOG_VA((_L8("***CPtpSession::ReceivedObjectCompleted err=%d"), err));
        iObjectReceivedNotifyMsg.Complete(err);
        }
    else
        {
        __FLOG(_L8("!!!Warning: Strange Happened!!!"));    
        }
    __FLOG(_L8("<<<CPtpSession::ReceivedObjectCompleted"));
    }

// --------------------------------------------------------------------------
// 
// Cancels outstanding request
// --------------------------------------------------------------------------
//
void CPtpSession::CancelOutstandingRequest()
    {
    __FLOG(_L8(">>>CPtpSession::CancelOutstandingRequest"));
    if (iSendObjectMsg.Handle())
        {
        iSendObjectMsg.Complete(KErrCancel);
        }
    if (iObjectReceivedNotifyMsg.Handle())
        {
        iObjectReceivedNotifyMsg.Complete(KErrCancel);
        }
    if (iDpsPrinterMsg.Handle())
        {
        iDpsPrinterMsg.Complete(KErrCancel);
        }
    __FLOG(_L8("<<<CPtpSession::CancelOutstandingRequest"));    
    }
// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
CPtpServer* CPtpSession::ServerP() const
    {
    return iServerP;    
    }