// Copyright (c) 2010 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:
//

/**
 @file
 @internalComponent
*/

#include <mtp/mmtpconnection.h>
#include <mtp/mmtpdataproviderframework.h>
#include <mtp/mtpdataproviderapitypes.h>

#include "cmtpplaybackcontroldp.h"
#include "cmtprequestprocessor.h"
#include "mtpplaybackcontroldpprocessor.h"
#include "cmtpplaybackmap.h"
#include "cmtpplaybackproperty.h"
#include "mmtpplaybackinterface.h"
#include "cmtpplaybackevent.h"
#include "mtpplaybackcontrolpanic.h"


// Class constants.
__FLOG_STMT(_LIT8(KComponent,"PlaybackControlDataProvider");)
static const TInt KMTPPlaybackControlDpSessionGranularity(3);

/**
MTP playback control data provider plug-in factory method.
@return A pointer to an MTP playback control data provider plug-in. Ownership IS
transfered.
@leave One of the system wide error codes, if a processing failure occurs.
*/
TAny* CMTPPlaybackControlDataProvider::NewL(TAny* aParams)
    {
    CMTPPlaybackControlDataProvider* self = new (ELeave) CMTPPlaybackControlDataProvider(aParams);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

/**
Destructor
*/
CMTPPlaybackControlDataProvider::~CMTPPlaybackControlDataProvider()
    {
    __FLOG(_L8("~CMTPPlaybackControlDataProvider - Entry"));
    TInt count = iActiveProcessors.Count();
    while(count--)
        {
        iActiveProcessors[count]->Release();
        }
    iActiveProcessors.Close();
    delete iPlaybackMap;
    delete iPlaybackProperty;
    if(iPlaybackControl)
        {
        iPlaybackControl->Close();
        }
    __FLOG(_L8("~CMTPPlaybackControlDataProvider - Exit"));
    __FLOG_CLOSE;
    }

void CMTPPlaybackControlDataProvider::Cancel()
    {

    }

void CMTPPlaybackControlDataProvider::ProcessEventL(const TMTPTypeEvent& /*aEvent*/, MMTPConnection& /*aConnection*/)
    {
    __FLOG(_L8("ProcessEventL - Entry"));
    __FLOG(_L8("ProcessEventL - Exit"));
    }

void CMTPPlaybackControlDataProvider::ProcessNotificationL(TMTPNotification aNotification, const TAny* aParams)
    {
    __FLOG(_L8("ProcessNotificationL - Entry"));
    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("ProcessNotificationL - Exit"));
    }

void CMTPPlaybackControlDataProvider::ProcessRequestPhaseL(TMTPTransactionPhase aPhase, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
    {
    __FLOG(_L8("ProcessRequestPhaseL - Entry"));
    TInt index = LocateRequestProcessorL(aRequest, aConnection);
    __ASSERT_DEBUG(index != KErrNotFound, Panic(EMTPPBArgumentErr));
    MMTPRequestProcessor* processor = iActiveProcessors[index];
    iActiveProcessor = index;
    iActiveProcessorRemoved = EFalse;
    TBool result = processor->HandleRequestL(aRequest, aPhase);
    if (iActiveProcessorRemoved)
	    {
	    processor->Release(); // destroy the processor
	    }
    else if (result)
	    {
	    processor->Release();    	
	    iActiveProcessors.Remove(index);
	    }
    iActiveProcessor = -1;
    __FLOG(_L8("ProcessRequestPhaseL - Exit"));
    }

void CMTPPlaybackControlDataProvider::Supported(TMTPSupportCategory aCategory, RArray<TUint>& aArray) const
    {
    __FLOG(_L8("Supported - Entry"));
    
    switch (aCategory)
        {
    case EDeviceProperties:
        {
        TInt count = sizeof(KMTPPlaybackControlDpSupportedProperties) / sizeof(KMTPPlaybackControlDpSupportedProperties[0]);
        for(TInt i = 0; i < count; i++)
            {
            aArray.Append(KMTPPlaybackControlDpSupportedProperties[i]);
            }
        }
        break;

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

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

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

/**
Constructor.
*/
CMTPPlaybackControlDataProvider::CMTPPlaybackControlDataProvider(TAny* aParams) :
    CMTPDataProviderPlugin(aParams),
    iActiveProcessors(KMTPPlaybackControlDpSessionGranularity),
    iActiveProcessor(-1),
    iRequestToResetPbCtrl(EFalse)
    {

    }

/**
Second phase constructor.
*/
void CMTPPlaybackControlDataProvider::ConstructL()
    {
    __FLOG_OPEN(KMTPSubsystem, KComponent);
    __FLOG(_L8("ConstructL - Entry"));
    iPlaybackProperty = CMTPPlaybackProperty::NewL();
    iPlaybackMap = CMTPPlaybackMap::NewL(Framework(),*iPlaybackProperty);
    __FLOG(_L8("ConstructL - Exit"));
    }

void CMTPPlaybackControlDataProvider::SendEventL(TMTPDevicePropertyCode aPropCode)
	{
    __FLOG(_L8("SendEventL - Entry"));
	iEvent.Reset();
	iEvent.SetUint16(TMTPTypeEvent::EEventCode, EMTPEventCodeDevicePropChanged );
	iEvent.SetUint32(TMTPTypeEvent::EEventSessionID, KMTPSessionAll);
	iEvent.SetUint32(TMTPTypeEvent::EEventTransactionID, KMTPTransactionIdNone);
	iEvent.SetUint32(TMTPTypeEvent::EEventParameter1, aPropCode);
	Framework().SendEventL(iEvent);
    __FLOG(_L8("SendEventL - Exit"));
	}

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

/**
Cleans up outstanding request processors when a session is closed.
@param aSession notification parameter block
*/
void CMTPPlaybackControlDataProvider::SessionClosedL(const TMTPNotificationParamsSessionChange& aSession)
    {
    __FLOG(_L8("SessionClosedL - Entry"));
    TInt count = iActiveProcessors.Count();
    while (count--)
        {
        MMTPRequestProcessor* processor = iActiveProcessors[count];
        TUint32 sessionId(processor->SessionId());
        if ((sessionId == aSession.iMTPId) && (processor->Connection().ConnectionId() == aSession.iConnection.ConnectionId()))
            {
            iActiveProcessors.Remove(count);
            if (count == iActiveProcessor)
                {
                iActiveProcessorRemoved = ETrue;
                }
            else
                {
                processor->Release();
                }
            }
        }

    if(iPlaybackControl)
        {
        iPlaybackControl->Close();
        iPlaybackControl = NULL;
        }

    __FLOG(_L8("SessionClosedL - Exit"));
    }

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

void CMTPPlaybackControlDataProvider::StartObjectEnumerationL(TUint32 aStorageId, TBool /*aPersistentFullEnumeration*/)
    {
    __FLOG(_L8("StartObjectEnumerationL - Entry"));
    //This DP doesn't manage data.
    Framework().ObjectEnumerationCompleteL(aStorageId);
    __FLOG(_L8("StartObjectEnumerationL - Exit"));
    }

void CMTPPlaybackControlDataProvider::StartStorageEnumerationL()
    {
    __FLOG(_L8("StartStorageEnumerationL - Entry"));
    //This DP doesn't manage data.
    Framework().StorageEnumerationCompleteL();
    __FLOG(_L8("StartStorageEnumerationL - Exit"));
    }

void CMTPPlaybackControlDataProvider::HandlePlaybackEventL(CMTPPlaybackEvent* aEvent, TInt aErr)
    {
    __FLOG(_L8("HandlePlaybackEventL - Entry"));

    if(aErr != KPlaybackErrNone)
        {
        if(aErr == KPlaybackErrDeviceUnavailable )
            {
            iRequestToResetPbCtrl = ETrue;
            //Report error to initiator, .
            SendEventL(EMTPDevicePropCodePlaybackObject);
            SendEventL(EMTPDevicePropCodePlaybackRate);
            SendEventL(EMTPDevicePropCodePlaybackContainerIndex);
            SendEventL(EMTPDevicePropCodePlaybackPosition);
            }
        return;
        }

    __ASSERT_DEBUG((aEvent != NULL), Panic(EMTPPBDataNullErr));
    __ASSERT_ALWAYS((aEvent != NULL), User::Leave(KErrArgument));
    __FLOG_1(_L8("aEvent %d"), aEvent->PlaybackEvent());

    switch(aEvent->PlaybackEvent())
        {
        case EPlaybackEventVolumeUpdate:
            {
            SendEventL(EMTPDevicePropCodeVolume);
            }
            break;
        case EPlaybackEventStateUpdate:
            {
            SendEventL(EMTPDevicePropCodePlaybackRate);
            }
            break;           
        case EPlaybackEventObjectUpdate:
            {
            SendEventL(EMTPDevicePropCodePlaybackObject);
            }
            break;
        case EPlaybackEventObjectIndexUpdate:
            {
            SendEventL(EMTPDevicePropCodePlaybackContainerIndex);
            }
            break;

        default:
            User::Leave(KErrArgument);
            break;
        }
    
    __FLOG(_L8("HandlePlaybackEventL - Exit"));
    }

CMTPPlaybackMap& CMTPPlaybackControlDataProvider::GetPlaybackMap() const 
    {
    __ASSERT_DEBUG((iPlaybackMap != NULL), Panic(EMTPPBDataNullErr));
    return *iPlaybackMap;
    }

CMTPPlaybackProperty& CMTPPlaybackControlDataProvider::GetPlaybackProperty() const 
    {
    __ASSERT_DEBUG((iPlaybackProperty != NULL), Panic(EMTPPBDataNullErr));
    return *iPlaybackProperty;
    }

MMTPPlaybackControl& CMTPPlaybackControlDataProvider::GetPlaybackControlL() 
    {
    __FLOG(_L8("GetPlaybackControlL - Entry"));
    if(iPlaybackControl == NULL)
        {
        iPlaybackControl = MMTPPlaybackControl::NewL(*this);
        }
    else if(iRequestToResetPbCtrl)
        {
        iRequestToResetPbCtrl = EFalse;
        iPlaybackControl->Close();
        iPlaybackControl = NULL;
        iPlaybackControl = MMTPPlaybackControl::NewL(*this);
        }
    __FLOG(_L8("GetPlaybackControlL - Exit"));
    return *iPlaybackControl;
    }

void CMTPPlaybackControlDataProvider::RequestToResetPbCtrl()
    {
    iRequestToResetPbCtrl = ETrue;
    }