/*
* Copyright (c) 2002-2007 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:  Streams data from Java to controller
*
*/


//  INCLUDE FILES
#include <AudioPreference.h>
#include <jdebug.h>

#include "cmmastreamhandler.h"
#include "cmmadatasourcestream.h"
#include "cmmaeventsource.h"


CMMAStreamHandler* CMMAStreamHandler::NewL(
    MMMAStreamHandlerListener& aListener,
    MStreamControl& aMStreamControl,
    MDataBufferSource& aMDataBufferSource,
    CMultimediaFactory& aFactory,
    CMetaDataUtility& aMetaDataUtility)
{
    DEBUG("MMA::CMMAStreamHandler::NewL +");
    CMMAStreamHandler* self = new(ELeave) CMMAStreamHandler(aListener,
            aMStreamControl,
            aMDataBufferSource,
            aFactory,
            aMetaDataUtility);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    DEBUG("MMA::CMMAStreamHandler::NewL -");
    return self;
}

CMMAStreamHandler::~CMMAStreamHandler()
{
    DEBUG("MMA::CMMAStreamHandler::~CMMAStreamHandler() +");
    iMDataBufferSource.RemoveObserver(*this);
    if (iBuffer != NULL)
    {
        iFactory.DeleteDataBuffer(iBuffer);
        iBuffer = NULL;
    }
    iRequests.ResetAndDestroy();
    DEBUG("MMA::CMMAStreamHandler::~CMMAStreamHandler() -");
}

CMMAStreamHandler::CMMAStreamHandler(MMMAStreamHandlerListener& aListener,
                                     MStreamControl& aMStreamControl,
                                     MDataBufferSource& aMDataBufferSource,
                                     CMultimediaFactory& aFactory,
                                     CMetaDataUtility& aMetaDataUtility)
        :iMStreamControl(aMStreamControl),
        iMDataBufferSource(aMDataBufferSource),
        iFactory(aFactory),
        iListener(aListener),
        iMetaDataUtility(aMetaDataUtility),
        // to be removed once MDU supports all the reqd formats
        iMimeTypeSupportedByMDU(ETrue)
{
    // ignore read/write completed before stream is prepared
    iState = EMMAStreamPaused;
    iMetaDataReadyToBeParsed = EFalse;
}

void CMMAStreamHandler::ConstructL()
{
    DEBUG("MMA::CMMAStreamHandler::ConstructL +");
    //Register source control to control observer to get the event
    iMDataBufferSource.AddObserver(*this);
    iLastBufferWritten = EFalse;
    iBuffer = NULL; // initialize MDataBuffer type pointer
    // create requests
    for (TInt i = 0; i < KMMAStreamHandlerBufferCount; i++)
    {
        CMMAStreamRequest* requestToAppend = CMMAStreamRequest::NewLC(this);
        iRequests.AppendL(requestToAppend);
        CleanupStack::Pop(requestToAppend);
    }
    DEBUG("MMA::CMMAStreamHandler::ConstructL -");
}

void CMMAStreamHandler::Prepare(const TDesC8& aMimeType)
{
    DEBUG("MMA::CMMAStreamHandler::Prepare +");
    DEBUG_INT("MMA::CMMAStreamHandler::Prepare state %d", iState);
    iState = EMMAStreamPrepare;
    // initialize MetaDataUtility
    TInt error = iMetaDataUtility.InitChunkData(aMimeType, *this);
    DEBUG_INT("MMA::CMMAStreamHandler::Prepare, error = %d", error);
    if (error != KErrNone)
    {
        if (error == KErrArgument)
        {
            // MDU doesn't support aMimeType
            // can be removed once MDU supports all the reqd formats
            iMimeTypeSupportedByMDU = EFalse;
        }
        else
        {
            // MDU supports but some other error occured
            iListener.PrepareComplete(error);
            return;
        }
    }
    else
    {
        // to be removed once MDU supports all the reqd formats
        iMimeTypeSupportedByMDU = ETrue;
    }
    //reset request data for reading again from beginning
    iRequests[0]->DataPtr().SetLength(0);

    // when read completes iListerner.PrepareComplete will be called
    iSourceStream->Read(iRequests[ 0 ]);
    DEBUG("MMA::CMMAStreamHandler::Prepare -");
}

void CMMAStreamHandler::Start()
{
    DEBUG("MMA::CMMAStreamHandler::Start +");
    DEBUG_INT("MMA::CMMAStreamHandler::Start state %d", iState);
    DEBUG_INT("MMA::CMMAStreamHandler::Start data source request=%d",(TInt)iSourceStream->Request());
    iState = EMMAStreamStart;
    if (iSourceStream->Request())
    { // when read request is completed it will be written to server
        iState = EMMAStreamStarted;
        iListener.StartComplete(KErrNone);
        return;
    }

    TInt count = iRequests.Count();
    TBool started = EFalse;
    for (TInt i = 0; i < count && !started; i++)
    {
        CMMAStreamRequest* r = iRequests[ i ];
        if (!r->IsActive() && r->DataPtr().Length() > 0)
        {
            DEBUG("MMA::CMMAStreamHandler::Start write request to server");
            DEBUG_INT("MMA::CMMAStreamHandler::Start request length=%d",
                      r->DataPtr().Length());
            DEBUG_INT("MMA::CMMAStreamHandler::Start last buffer %d",
                      r->RequestBuffer()());

            // data was not yet written to server
            WriteRequest(r);
            started = ETrue;
        }
        else if (r->IsActive())  // data is in server
        {
            DEBUG("MMA::CMMAStreamHandler::Start data is in server");
            // atleast one request is not processed
            started = ETrue;
        }
    }
    if (started)  // If allready started complete start
    {
        iListener.StartComplete(KErrNone);
        iState = EMMAStreamStarted;
    }
    else
    {
        // Need to read data before start
        iSourceStream->Read(iRequests[ 0 ]);
    }
    DEBUG("MMA::CMMAStreamHandler::Start -");
}

void CMMAStreamHandler::Pause()
{
    DEBUG("MMA::CMMAStreamHandler::Pause +");
    // ignore read/write completes
    iState = EMMAStreamPaused;
    DEBUG("MMA::CMMAStreamHandler::Pause -");
}

void CMMAStreamHandler::SetSourceStream(CMMADataSourceStream* aSourceStream)
{
    iSourceStream = aSourceStream;
}

void CMMAStreamHandler::WriteComplete(CMMAStreamRequest* aRequest)
{
    DEBUG("MMA::CMMAStreamHandler::WriteComplete +");
    DEBUG_INT("MMA::CMMAStreamHandler::WriteComplete state=%d", iState);
    DEBUG_INT("MMA::CMMAStreamHandler::WriteComplete request length=%d",
              aRequest->DataPtr().Length());
    DEBUG_INT("MMA::CMMAStreamHandler::WriteComplete last buffer %d",
              aRequest->RequestBuffer()());
    if (iState == EMMAStreamStarted)
    {
        if (aRequest->RequestBuffer()() == 1)
        {
            iState = EMMAStreamEof;
        }
        else
        {
            iSourceStream->Read(aRequest);
        }
    }
    // else, all other states ignore write complete
    DEBUG("MMA::CMMAStreamHandler::WriteComplete -");
}

void CMMAStreamHandler::ReadComplete(CMMAStreamRequest* aRequest)
{

    DEBUG("MMA::CMMAStreamHandler::ReadComplete +");

    if (iState == EMMAStreamPrepare)
    {

        WriteRequest(aRequest);
        iListener.PrepareComplete(KErrNone);
        iState = EMMAStreamPaused;
    }
    else if (iState == EMMAStreamStart)
    {
        iState = EMMAStreamStarted;
        // write first request to server
        WriteRequest(aRequest);
        iListener.StartComplete(KErrNone);
    }
    else if (iState == EMMAStreamStarted)
    {
        WriteRequest(aRequest);
    }
    DEBUG("MMA::CMMAStreamHandler::ReadComplete -");
    // else, all other states ignore read complete
}

void CMMAStreamHandler::HandleError(CMMAStreamRequest* /*aRequest*/,
                                    TInt aError)
{
    DEBUG("MMA::CMMAStreamHandler::HandleError +");
    DEBUG_INT("MMA::CMMAStreamHandler::HandleError state=%d", iState);
    if (iState == EMMAStreamPrepare)
    {
        iListener.PrepareComplete(aError);
        iState = EMMAStreamPaused;
    }
    else if (iState == EMMAStreamStart)
    {
        iListener.StartComplete(aError);
        iState = EMMAStreamStarted;
    }
    else
    {
        iListener.HandleError(aError);
    }
    DEBUG("MMA::CMMAStreamHandler::HandleError -");
}

void CMMAStreamHandler::WriteRequest(CMMAStreamRequest* aRequest)
{

    DEBUG("MMA::CMMAStreamHandler::WriteRequest +");
    iCurrentRequest = aRequest; //initialize the current StreamRequest for use in callback function
    iProcessedState = EMMANoneProcessed;

    TInt state = iMStreamControl.GetState();
    if (!aRequest->IsActive())
    {
        aRequest->SetActive(ETrue);
    }

    //Create MDataBuffer and then pass it as a parameter of WriteData
    if (iBuffer != NULL)
    {
        iFactory.DeleteDataBuffer(iBuffer);
        iBuffer= NULL;
    }
    iFactory.CreateDataBuffer(KDataBufferSourceControl, KMMAStreamRequestBufferSize, iBuffer);
    iBuffer->GetBufferPtr().Set(aRequest->DataPtr());
    DEBUG_INT("MMA::CMMAStreamHandler::WriteRequest: Size of the Data to be written is %d ",aRequest->DataPtr().Length());
    if (aRequest->RequestBuffer()() == 1)  //set that it is the last buffer
    {
        iState = EMMAStreamEof;
        iBuffer->SetLastBuffer(ETrue);
        iLastBufferWritten = ETrue;
        DEBUG("MMA::CMMAStreamHandler::WriteRequest: LastBuffer");
    }
    else
    {
        iBuffer->SetLastBuffer(EFalse);
        iLastBufferWritten = EFalse;
    }

    // When the buffer is processed by framework KBufferProcessedEvent
    // will be delivered to registered observers
    TInt err = iMDataBufferSource.WriteData(*iBuffer);
    // to be removed once MDU supports all the reqd formats
    if (iMimeTypeSupportedByMDU && !iMetaDataReadyToBeParsed)
    {
        err = iMetaDataUtility.ProcessChunkData(aRequest->DataPtr(), iLastBufferWritten);
    }
    DEBUG_INT("MMA::CMMAStreamHandler::WriteRequest, err = %d", err);
    DEBUG("MMA::CMMAStreamHandler::WriteRequest -");
}

void CMMAStreamHandler::Event(MControl* /*aControl*/, TUint aEventType, TAny* aEventObject)
{
    DEBUG("MMA::CMMAStreamHandler::Event ");
    switch (aEventType)
    {

    case MSourceControlObserver::KBufferProcessedEvent:
    {
        DEBUG("MMA::CMMAStreamHandler::Event:KBufferProcessedEvent");
        MBufferProcessedEvent* evt = (MBufferProcessedEvent*)aEventObject;
        DEBUG_INT("MMA::CMMAStreamHandler::Event:KBufferProcessedEvent:ErrorCode = %d ",evt->GetErrorCode());
        // can be removed once MDU supports all the reqd formats
        if (!iMimeTypeSupportedByMDU ||
                (iProcessedState == EMMAMetaDataProcessed || iMetaDataReadyToBeParsed))
        {
            iCurrentRequest->WriteRequestComplete(evt->GetErrorCode());
            iCurrentRequest->SetActive(EFalse);
            iProcessedState = EMMABothProcessed;
        }
        else
        {
            iProcessedState = EMMABufferProcessed;
        }
    }
    break;

    case MSourceControlObserver::KBitRateChangedEvent:
    {
    }
    break;

    case MStreamControlObserver::KDurationChangedEvent:
    {
    }
    break;

    default:
        break;

    };
}

void CMMAStreamHandler::HandleChunkDataProcessed(TInt aError)
{
    DEBUG("MMA::CMMAStreamHandler::HandleChunkDataProcessed + ");
    DEBUG_INT("MMA::CMMAStreamHandler::HandleChunkDataProcessed, aError = %d", aError);
    if (iProcessedState == EMMABufferProcessed)
    {
        iCurrentRequest->WriteRequestComplete(aError);
        iCurrentRequest->SetActive(EFalse);
        iProcessedState = EMMABothProcessed;
    }
    else
    {
        iProcessedState = EMMAMetaDataProcessed;
    }
    DEBUG("MMA::CMMAStreamHandler::HandleChunkDataProcessed - ");
}

void CMMAStreamHandler::HandleChunkDataReadyToBeParsed()
{
    DEBUG("MMA::CMMAStreamHandler::HandleChunkDataReadyToBeParsed + ");
    iMetaDataReadyToBeParsed = ETrue;
    TInt error = iMetaDataUtility.ParseChunkData();
    DEBUG_INT("MMA::CMMAStreamHandler::HandleChunkDataReadyToBeParsed, error = %d ", error);
    DEBUG("MMA::CMMAStreamHandler::HandleChunkDataReadyToBeParsed - ");
}

void CMMAStreamHandler::HandleChunkDataComplete(TInt aError)
{
    DEBUG("MMA::CMMAStreamHandler::HandleChunkDataComplete");
    if (KErrNone != aError)
    {
        DEBUG_INT("MMA::CMMAStreamHandler::HandleChunkDataComplete, aError = %d ", aError);
        iListener.HandleError(aError);
    }

}

TBool CMMAStreamHandler::LastBufferWritten()
{
    return iLastBufferWritten;
}

void CMMAStreamHandler::Stop()
{
    DEBUG("MMA::CMMAStreamHandler::Stop + ");
    // forcefully complete all requests
    // and release already read data.
    Pause();
    iMetaDataUtility.CloseChunkData();
    TInt count = iRequests.Count();
    for (TInt i = 0; i < count; i++)
    {
        CMMAStreamRequest* r = iRequests[ i ];
        r->WriteRequestComplete(KErrNone);
        r->SetActive(EFalse);
    }
    DEBUG("MMA::CMMAStreamHandler::Stop - ");
}


//  END OF FILE