diff -r f5050f1da672 -r 04becd199f91 javauis/mmapi_akn/audiostreaming/src.emc/cmmastreamhandler.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/mmapi_akn/audiostreaming/src.emc/cmmastreamhandler.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,416 @@
+/*
+* 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