// 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/tmtptyperequest.h>
#include <mtp/cmtpstoragemetadata.h>
#include <mtp/mmtpconnection.h>
#include <mtp/mmtpdataproviderframework.h>
#include <mtp/mtpdataproviderapitypes.h>
#include <mtp/mtpprotocolconstants.h>
#include "cmtppictbridgedp.h"
#include "cptpserver.h"
#include "mtppictbridgedpconst.h"
#include "mtppictbridgedppanic.h"
#include "mtppictbridgedpprocessor.h"
#include "cmtppictbridgeenumerator.h"
#include "ptpdef.h"

LOCAL_D const TInt KArrayGranularity = 3;

// --------------------------------------------------------------------------
// PictBridge data provider factory method.
// @return A pointer to a pictbridge data provider object. Ownership is transfered.
// @leave One of the system wide error codes, if a processing failure occurs.
// --------------------------------------------------------------------------
//
TAny* CMTPPictBridgeDataProvider::NewL(TAny* aParams)
    {
    CMTPPictBridgeDataProvider* self = new (ELeave) CMTPPictBridgeDataProvider(aParams);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }
// --------------------------------------------------------------------------
// Constructor
// --------------------------------------------------------------------------
//
CMTPPictBridgeDataProvider::CMTPPictBridgeDataProvider(TAny* aParams):
    CMTPDataProviderPlugin(aParams),
    iActiveProcessors(KArrayGranularity)
    {
    }

// --------------------------------------------------------------------------
// second phase constructor
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::ConstructL()
    {
    __FLOG_OPEN(KMTPSubsystem, KComponent);
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::ConstructL"));   
    iPictBridgeEnumeratorP = CMTPPictBridgeEnumerator::NewL(Framework(), *this);
    iServerP = CPtpServer::NewL(Framework(), *this);
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::ConstructL"));
    }
// --------------------------------------------------------------------------
// Destructor
// --------------------------------------------------------------------------
//
CMTPPictBridgeDataProvider::~CMTPPictBridgeDataProvider()
    {
    __FLOG(_L8(">> ~CMTPPictBridgeDataProvider"));

    TUint count(iActiveProcessors.Count());
    while (count--)
        {
        iActiveProcessors[count]->Release();
        }
    iActiveProcessors.Close();

    delete iPictBridgeEnumeratorP;
    delete iServerP;

    __FLOG(_L8("<< ~CMTPPictBridgeDataProvider"));
    __FLOG_CLOSE;
    }

// --------------------------------------------------------------------------
// Cancel
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::Cancel()
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::Cancel"));
    // nothing to cancel
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::Cancel"));
    }
// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::ProcessEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::ProcessEventL"));    

    TInt idx = LocateRequestProcessorL(aEvent, aConnection);

    if (idx != KErrNotFound)
        {
        iActiveProcessors[idx]->HandleEventL(aEvent);
        }

    __FLOG(_L8("<< CMTPPictBridgeDataProvider::ProcessEventL"));    
    }
// --------------------------------------------------------------------------
// Process notifications from the initiator
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::ProcessNotificationL(TMTPNotification aNotification, const TAny* aParams)
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::ProcessNotificationL"));    
    
    switch (aNotification)
        {
    case EMTPSessionClosed:
        SessionClosedL(*reinterpret_cast<const TMTPNotificationParamsSessionChange*>(aParams));
        break;
        
    case EMTPSessionOpened:
        SessionOpenedL(*reinterpret_cast<const TMTPNotificationParamsSessionChange*>(aParams));
        break;
        
    default:
        // Ignore all other notifications.
        break;
        }

    __FLOG(_L8("<< CMTPPictBridgeDataProvider::ProcessNotificationL"));    
    }
// --------------------------------------------------------------------------
// Process requests from the initiator
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::ProcessRequestPhaseL(TMTPTransactionPhase aPhase, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
    {    
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::ProcessRequestPhaseL"));    

    TInt idx = LocateRequestProcessorL(aRequest, aConnection);
    __ASSERT_DEBUG((idx != KErrNotFound), Panic(EMTPPictBridgeDpNoMatchingProcessor));
    MMTPRequestProcessor* processorP(iActiveProcessors[idx]);
    TBool result(processorP->HandleRequestL(aRequest, aPhase));
    if (result)    //destroy the processor
        {
        processorP->Release();
        iActiveProcessors.Remove(idx);
        }

    __FLOG_VA((_L8("<< CMTPPictBridgeDataProvider::ProcessRequestPhaseL result=%d"), result));    
    }

// --------------------------------------------------------------------------
// Starts the object enumeration
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::StartObjectEnumerationL(TUint32 aStorageId, TBool /*aPersistentFullEnumeration*/)
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::StartObjectEnumerationL"));
    
    iPictBridgeEnumeratorP->EnumerateObjectsL(aStorageId);

    __FLOG(_L8("<< CMTPPictBridgeDataProvider::StartObjectEnumerationL"));
    }

// --------------------------------------------------------------------------
// Storage enumeration is not needed, just declared complete
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::StartStorageEnumerationL()
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::StartStorageEnumerationL"));        
    iPictBridgeEnumeratorP->EnumerateStoragesL();
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::StartStorageEnumerationL"));
    }
// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::Supported(TMTPSupportCategory aCategory, RArray<TUint>& aArray) const
    {   
    __FLOG_VA((_L8(">> CMTPPictBridgeDataProvider::Supported %d"), aCategory));
    switch (aCategory) 
        {        
    case EEvents:
        aArray.Append(EMTPEventCodeRequestObjectTransfer);
        break;
    case EObjectPlaybackFormats:
    case EObjectCaptureFormats:
         break;
    case EObjectProperties:
        {
        TInt count(sizeof(KMTPPictBridgeDpSupportedProperties) / sizeof(KMTPPictBridgeDpSupportedProperties[0]));
        for (TInt i = 0; i < count; i++ )
            {
            aArray.Append( KMTPPictBridgeDpSupportedProperties[i] );
            }
        }
        break; 

    case EOperations:
        {
        TInt count(sizeof(KMTPPictBridgeDpSupportedOperations) / sizeof(KMTPPictBridgeDpSupportedOperations[0]));
        for (TInt i = 0; (i < count); i++)
            {
            aArray.Append(KMTPPictBridgeDpSupportedOperations[i]);
            }
        }
        break;  

    case EStorageSystemTypes:
        aArray.Append(CMTPStorageMetaData::ESystemTypeDefaultFileSystem);
        break; 

    default:
        // Unrecognised category, leave aArray unmodified.
        break;
        }
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::Supported"));
    }

void CMTPPictBridgeDataProvider::SupportedL(TMTPSupportCategory aCategory, CDesCArray& /*aStrings*/) const
    {
    switch (aCategory) 
        {
        case EFolderExclusionSets:
            break;
        case EFormatExtensionSets:
            break;
        default:
            break;
        }
    }


// --------------------------------------------------------------------------
// CMTPPictBridgeDataProvider::NotifyStorageEnumerationCompleteL()
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::NotifyStorageEnumerationCompleteL()
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::NotifyStorageEnumerationCompleteL"));    
    Framework().StorageEnumerationCompleteL();
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::NotifyStorageEnumerationCompleteL"));    
    }

// --------------------------------------------------------------------------
// 
// --------------------------------------------------------------------------
//
#ifdef __FLOG_ACTIVE
void CMTPPictBridgeDataProvider::NotifyEnumerationCompleteL(TUint32 aStorageId, TInt aErr )
#else
void CMTPPictBridgeDataProvider::NotifyEnumerationCompleteL(TUint32 aStorageId, TInt /* aErr*/ )
#endif
    {
    __FLOG_VA((_L8(">> CMTPPictBridgeDataProvider::NotifyEnumerationCompletedL storage 0x%08X status %d"), aStorageId, aErr ));
    Framework().ObjectEnumerationCompleteL(aStorageId);
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::NotifyEnumerationCompletedL"));
    }


// --------------------------------------------------------------------------
// Find or create a request processor that can process the specified request.
// @param aRequest    The request to be processed
// @param aConnection The connection from which the request comes
// @return the idx of the found/created request processor
// --------------------------------------------------------------------------
//
TInt CMTPPictBridgeDataProvider::LocateRequestProcessorL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::LocateRequestProcessorL"));        
    
    TInt idx(KErrNotFound);
    TInt count(iActiveProcessors.Count());
    for (TInt i = 0; (i < count); i++)
        {
        if (iActiveProcessors[i]->Match(aRequest, aConnection))
            {
            idx = i;
            break;
            }
        }
        
    if (idx == KErrNotFound)
        {
        MMTPRequestProcessor* processorP = MTPPictBridgeDpProcessor::CreateL(Framework(), aRequest, aConnection, *this);
        CleanupReleasePushL(*processorP);
        iActiveProcessors.AppendL(processorP);
        CleanupStack::Pop();
        idx = count;
        }
        
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::LocateRequestProcessorL")); 
    return idx;
    }

// --------------------------------------------------------------------------
// Find or create a request processor that can process the specified event.
// @param aEvent    The event to be processed
// @param aConnection The connection from which the request comes
// @return the idx of the found request processor, KErrNotFound if not found
// --------------------------------------------------------------------------
//
TInt CMTPPictBridgeDataProvider::LocateRequestProcessorL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)
    {
    __FLOG(_L8(">> CMTPPictBridgeDataProvider::LocateRequestProcessorL (event)"));
        
    TInt idx(KErrNotFound);
    TInt count(iActiveProcessors.Count());
    for (TInt i = 0; (i < count); i++)
        {
        if (iActiveProcessors[i]->Match(aEvent, aConnection))
            {
            idx = i;
            break;
            }
        }    
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::LocateRequestProcessorL (event)"));
    return idx;
    }

// --------------------------------------------------------------------------
// Cleans up outstanding request processors when a session is closed.
// @param aSession notification parameter block
// --------------------------------------------------------------------------
//
void CMTPPictBridgeDataProvider::SessionClosedL(const TMTPNotificationParamsSessionChange& aSession)
    {
    __FLOG_VA((_L8(">> CMTPPictBridgeDataProvider::SessionClosedL SessionID = %d"), aSession.iMTPId));
    
    TInt count = iActiveProcessors.Count();
    while(count--)
        {
        MMTPRequestProcessor* processorP = iActiveProcessors[count];
        TUint32 sessionId = processorP->SessionId();
        if((sessionId == aSession.iMTPId) && (processorP->Connection().ConnectionId() == aSession.iConnection.ConnectionId()))
            {
            processorP->Release();
            iActiveProcessors.Remove(count);
            }
        }

    iServerP->MtpSessionClosed();
    __FLOG(_L8("<< CMTPPictBridgeDataProvider::SessionClosedL"));
    }

// --------------------------------------------------------------------------
// Prepares for a newly-opened session.
// @param aSession notification parameter block
// --------------------------------------------------------------------------
//
#ifdef __FLOG_ACTIVE
void CMTPPictBridgeDataProvider::SessionOpenedL(const TMTPNotificationParamsSessionChange& aSession )
#else
void CMTPPictBridgeDataProvider::SessionOpenedL(const TMTPNotificationParamsSessionChange& /*aSession*/ )
#endif
    {
    __FLOG_VA((_L8(" CMTPPictBridgeDataProvider::SessionOpenedL SessionID = %d"), aSession.iMTPId));
    iServerP->MtpSessionOpened();
    }

TUint32 CMTPPictBridgeDataProvider::DeviceDiscoveryHandle() const
    {    
    return iPictBridgeEnumeratorP->DeviceDiscoveryHandle();
    }