/*
* Copyright (c) 2005 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 <uricommon.h>
#include <uri8.h>
#include <uriutils.h>
#include<e32cmn.h>
#include<e32const.h>
#include <f32file.h>

#include "mcemsrpsink.h"
#include <mcertpsource.h>
#include <mcemsrpsource.h>
#include "mcecommsrpsink.h"
#include "mcesession.h"
#include "mcemediastream.h"
#include "mceclilogs.h"
#include "mcemanager.h"
#include "mcecommediastream.h"
#include <e32cmn.h>
#include <e32const.h>
#include <f32file.h>

#define _FLAT_DATA static_cast<CMceComMsrpSink*>( iFlatData )
#define FLAT_DATA( data ) (_FLAT_DATA->data)

#define _FLAT_ARRAY_DATA static_cast<CMceComMsrpSink*>(iFlatData)
#define FLAT_ARRAY_DATA(iArray,data) (_FLAT_ARRAY_DATA)->iArray.AppendL(data)

#define _FLAT_PTRARRAY_DATA static_cast<CMceComMsrpSink*>(iFlatData)
#define FLAT_PTRARRAY_DATA(iArray,data) (_FLAT_PTRARRAY_DATA)->iArray->AppendL(data)

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CMceMsrpSink::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceMsrpSink* CMceMsrpSink::NewL()
    {    
    CMceMsrpSink* self = CMceMsrpSink::NewLC();    
	CleanupStack::Pop(self);
    return self;   
    }
	
	
// -----------------------------------------------------------------------------
// CMceMsrpSink::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CMceMsrpSink* CMceMsrpSink::NewLC()
    {    
    CMceMsrpSink* self = new (ELeave) CMceMsrpSink(); 
	CleanupStack::PushL(self);
	self->ConstructL();
    return self;   
    }   

	
// -----------------------------------------------------------------------------
// CMceMsrpSinke::ConstructL
// -----------------------------------------------------------------------------
//
void CMceMsrpSink::ConstructL()
    { 
    CMceComMsrpSink *sink = CMceComMsrpSink::NewLC();
    CMceMediaSink::ConstructL(sink);		
	CleanupStack::Pop(sink);
    }
       

// -----------------------------------------------------------------------------
// CMceMsrpSinke::~CMceMsrpSinke
// -----------------------------------------------------------------------------
//
EXPORT_C CMceMsrpSink::~CMceMsrpSink()
    {
    }	


// -----------------------------------------------------------------------------
// CMceMsrpSink::CMceMsrpSink
// -----------------------------------------------------------------------------
//
CMceMsrpSink::CMceMsrpSink()
    :CMceMediaSink()
    {
    }
	
// -----------------------------------------------------------------------------
// CMceMicSource::EnableL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::EnableL()
    {
    MCECLI_DEBUG("CMceMsrpSink::EnableL, Entry");
    
    CMceMediaSink::DoEnableL(); 
    
    MCECLI_DEBUG("CMceMsrpSink::EnableL, Exit");
    
    }
    
// -----------------------------------------------------------------------------
// CMceMsrpSink::Disable
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::DisableL()
    {
    MCECLI_DEBUG("CMceMsrpSink::DisableL, Entry");

    CMceMediaSink::DoDisableL();
    
    MCECLI_DEBUG("CMceMsrpSink::DisableL, Exit");
    
    }

// -----------------------------------------------------------------------------
// CMceMsrpSinke::Path
// -----------------------------------------------------------------------------
//

EXPORT_C RPointerArray<TUriC8>& CMceMsrpSink::Path()
    {
    return FLAT_DATA(iPath);
    }

 

// -----------------------------------------------------------------------------
// CMceMsrpSinke::SetPath
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::SetPathL( const RPointerArray<TUriC8>& aMsrpPath )
    {
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    // destroy the existing MSRP path entries
    static_cast<CMceComMsrpSink*>(iFlatData)->iPath.ResetAndDestroy();
    for(int i=0;i<aMsrpPath.Count();i++)
        {        
        TUriParser8* parser = new (ELeave) TUriParser8;
        CleanupStack::PushL(parser);
        User::LeaveIfError( parser->Parse(aMsrpPath[i]->UriDes()));
        FLAT_ARRAY_DATA(iPath, parser);
        CleanupStack::Pop(parser);
        }
    }


// -----------------------------------------------------------------------------
// CMceMsrpSink::AcceptTypesL
// -----------------------------------------------------------------------------
//

void CMceMsrpSink::AcceptTypesL(CDesC8ArrayFlat& aAcceptTypes)
    {
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    
    for (TInt i=0; i< FLAT_DATA(iAcceptTypes).Count();i++)
        {
        aAcceptTypes.AppendL(FLAT_DATA(iAcceptTypes)[i]);
        }
    }
  
// -----------------------------------------------------------------------------
// CMceMsrpSink::SetAcceptTypesL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::SetAcceptTypesL( const MDesC8Array& aAcceptTypes )
    {
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    // reset the existing entries
    static_cast<CMceComMsrpSink*>(iFlatData)->iAcceptTypes.Reset();
    for(int i=0; i<aAcceptTypes.MdcaCount();i++)
        {       
        FLAT_ARRAY_DATA(iAcceptTypes, aAcceptTypes.MdcaPoint(i));        
        }
    }


// -----------------------------------------------------------------------------
// CMceMsrpSink::AcceptWrappedTypes
// -----------------------------------------------------------------------------
//

EXPORT_C TDes8& CMceMsrpSink::AcceptWrappedTypesL()
    {
    return FLAT_DATA(iAcceptWrappedTypes);
    }
    
// -----------------------------------------------------------------------------
// CMceMsrpSink::SetAcceptTypesL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::SetAcceptWrappedTypesL( const TDes8& aAcceptWrappedTypes )
    {
    MCECLI_DEBUG(" \n CMceMsrpSink::SetAcceptWrappedTypesL : Entry");
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    FLAT_DATA(iAcceptWrappedTypes) = aAcceptWrappedTypes;
    FLAT_DATA(iWrappedTypes) = ETrue;
    MCECLI_DEBUG(" \n CMceMsrpSink::SetAcceptWrappedTypesL : Entry");
    }


// -----------------------------------------------------------------------------
// CMceMsrpSink::SetFileSelector
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::SetFileSelectorL(const TDesC& aName, const TDesC8& aFileType, TUint aFileSize )
    {
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    FLAT_DATA(iFileShare) = ETrue;
    if (FLAT_DATA(iFileName) !=NULL )
        {
        delete FLAT_DATA(iFileName);
        FLAT_DATA(iFileName) = NULL;
        }
    FLAT_DATA(iFileName) = aName.Alloc();
    FLAT_DATA(iFileSize) = aFileSize;
    if (FLAT_DATA(iFileType) !=NULL )
        {
        delete FLAT_DATA(iFileType);
        FLAT_DATA(iFileType) = NULL;
        }
    FLAT_DATA(iFileType) = aFileType.Alloc();
    }

// -----------------------------------------------------------------------------
// CMceMsrpSink::SetFileDisposition
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::SetFileDispositionL (const TDes8& aDispositionValue)
    {
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    FLAT_DATA(iDispositionValue) = aDispositionValue;
    }


// -----------------------------------------------------------------------------
// CMceMsrpSink::SetFileTransferId
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::SetFileTransferIdL(TDes8& aId)
    {
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    //Set Current time as transferid (Which is unique)
    TTime transferId;
    transferId.HomeTime();
    aId.AppendNum(transferId.Int64());
    FLAT_DATA(iFileTransferid) = aId;
    }

// -----------------------------------------------------------------------------
// CMceMsrpSink::SetInformationAttr
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceMsrpSink::SetInformationAttrL(const TDes8& aInfo)
    {
    __ASSERT_ALWAYS(iFlatData!=NULL, User::Leave(KErrArgument));
    static_cast<CMceComMsrpSink*>(iFlatData)->iSessInfo = aInfo.AllocL();
    }

void CMceMsrpSink::InitializeL( CMceMediaStream& aParent )
    {
    MCECLI_DEBUG(" \n CMceMsrpSink::InitializeL : Entry");
    CMceMediaSink::InitializeL(aParent);
    
    RPointerArray<TUriC8>& msrpPath= Path();
    MCECLI_DEBUG_DVALUE("\n CMceMsrpSink::InitializeL: Msrp path count is: ", msrpPath.Count());
    if (msrpPath.Count() > 0 )
        {
        SetPortFromPathAttrL(* (msrpPath[msrpPath.Count()-1]) ,
                static_cast<CMceMessageStream&> (aParent) );
        }
    MCECLI_DEBUG("\n CMceMsrpSink::InitializeL : Exit");
    }


void CMceMsrpSink::SetPortFromPathAttrL(TUriC8& aMsrpUri, CMceMessageStream& aStream)
    {
    __ASSERT_ALWAYS(aStream.Type() == KMceMessage, User::Leave(KErrArgument));
    
    MCECLI_DEBUG("\n CMceMsrpSink::SetPortFromPathAttr : Entry");
    TUriParser8 parser;
    TInt parseValue = parser.Parse(aMsrpUri.UriDes()); 
    MCECLI_DEBUG_DVALUE("\n CMceMsrpSink::SetPortFromPathAttr: Parsed return value for MSRP URI: ",
            parseValue);
        
    TBuf8<50> host = parser.Extract(EUriHost);
    TBuf8<10> portBuf = parser.Extract(EUriPort);
    TInt Port;
        
    TBuf16<10> portBuf16;
    portBuf16.Copy(portBuf);
    TLex lex(portBuf16);
    lex.Val(Port);  // returns the port value 
    // Set media port
    aStream.SetLocalMediaPortL(Port);
	if (aStream.BoundStream())
		{
		aStream.BoundStreamL().SetLocalMediaPortL(Port);
		}
    MCECLI_DEBUG_DVALUE("\n CMceMsrpSink::SetPortFromPathAttr: Media port is : ", 
                Port);
    MCECLI_DEBUG("\n CMceMsrpSink::SetPortFromPathAttr : Exit");
    }


EXPORT_C void CMceMsrpSink::SetPathToSaveReceivedFile(const TDesC16& aFilePath)
    {
    if ( FLAT_DATA(iFilePath) != NULL)
        {
        delete FLAT_DATA(iFilePath);
        FLAT_DATA(iFilePath) = NULL;
        }
    FLAT_DATA(iFilePath) = aFilePath.Alloc();
    }

EXPORT_C void CMceMsrpSink::EnableFileTransferProgressNotifications(TBool enableFlag)
    {
    FLAT_DATA(iFTProgressNotification) = enableFlag;
    }