/*

* 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 <badesca.h>

#include <pathinfo.h>

#include "mcecssessionimplementation.h"

#include "mcecssession.h"

#include "mcecssessionreceiver.h"

#include "mcecomaudiocodec.h"

#include "mcecomvideocodec.h"

#include "mcecssubsession.h"

#include "mcesipmanager.h"

#include "mcemediamanager.h"

#include "mcesipdefaults.h"

#include "mcesrvlogs.h"

#include "mceserial.h"

#include "mcecommediasink.h"

#include "mcefilesource.h"

#include "mcecomcamerasource.h"

#define MCE_WRITE( aType, aData )\

    aType writeBuf( aData );\

    aInfo.Copy( writeBuf );

#define MCE_READ( aCastType, aType, aData )\

    aCastType readBuf;\

    readBuf.Copy( aInfo );\

    aType aData = readBuf();

_LIT(KMceApplPrivatePath, "%3Sprivate\\%x\\");

_LIT(KMceRootPath, "%3S");

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::NewL

// -----------------------------------------------------------------------------

//

CMceCsSessionImplementation* CMceCsSessionImplementation::NewL(

                                                CMceSipManager& aManager,

                                                CMceCsSession* aITCProvider )

	{

    CMceCsSessionImplementation* self = 

       CMceCsSessionImplementation::NewLC( aManager, aITCProvider );

    CleanupStack::Pop(self);

    return self;

	}

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::NewLC

// -----------------------------------------------------------------------------

//

CMceCsSessionImplementation* CMceCsSessionImplementation::NewLC(

                                               CMceSipManager& aManager,

                                               CMceCsSession* aITCProvider )

	{

    CMceCsSessionImplementation* self = 

            new (ELeave) CMceCsSessionImplementation( aManager, *aITCProvider );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

	}

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::CMceCsSessionImplementation

// -----------------------------------------------------------------------------

//

CMceCsSessionImplementation::CMceCsSessionImplementation(

                                                CMceSipManager& aManager,

                                                CMceCsSession& aITCProvider )

: iManager( aManager ),

  iITCProvider( &aITCProvider )

	{

	}

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::ConstructL

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::ConstructL ()

	{

    MCESRV_DEBUG("CMceCsSessionImplementation::ConstructL, Entry");

    iDefaults = CMceSipDefaults::NewL();

    MCESRV_DEBUG("CMceCsSessionImplementation::ConstructL, Exit");

	}

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::~CMceCsSessionImplementation

// -----------------------------------------------------------------------------

//

CMceCsSessionImplementation::~CMceCsSessionImplementation()

	{

	delete iDefaults;

    iSubSessions.ResetAndDestroy();

    iSubSessions.Close();

	}

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::ServerCore

// -----------------------------------------------------------------------------

//

RPointerArray<CMceCsSubSession>& CMceCsSessionImplementation::SubSessions()

    {

    return iSubSessions;

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::SupportedAudioCodecsL

// -----------------------------------------------------------------------------

//

HBufC8* CMceCsSessionImplementation::SupportedAudioCodecsL()

	{

    MCESRV_DEBUG("CMceCsSessionImplementation::SupportedAudioCodecsL, Entry");

    CDesC8ArrayFlat* codecs = NULL;

    HBufC8* codecsAsString = NULL;

	RPointerArray<CMceComAudioCodec> supportedCodecs;

	CleanupStack::PushL( TCleanupItem( ArrayCleanup, &supportedCodecs ) );

	iManager.MediaManager().GetCapabilitiesL( supportedCodecs );

    codecs = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    CleanupStack::PushL( codecs );

	for ( int i=0;i<supportedCodecs.Count();i++ )

		{

		CMceComAudioCodec* codec = supportedCodecs[i];

		CMceMsgObject<CMceComAudioCodec>* codecMsg = 

                    new (ELeave) CMceMsgObject<CMceComAudioCodec>

                    ( *codec, EMceItcMsgTypeCodec );

		CleanupStack::PushL( codecMsg );

		codecMsg->EncodeL();

		codecs->AppendL( codecMsg->EncodeBuffer().Ptr(0) );

		CleanupStack::PopAndDestroy( codecMsg );

		}

    CMceMsgTextArray* msgCodecs = new (ELeave) CMceMsgTextArray( *codecs );

    CleanupStack::PushL( msgCodecs );

    msgCodecs->EncodeL();

    codecsAsString = msgCodecs->EncodeBufferCloneL();

    CleanupStack::PopAndDestroy( msgCodecs );

    CleanupStack::PopAndDestroy( codecs );

	CleanupStack::PopAndDestroy( &supportedCodecs ); //TCleanupItem

    MCESRV_DEBUG("CMceCsSessionImplementation::SupportedAudioCodecsL, Exit");

	return codecsAsString;

	}

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::SupportedVideoCodecsL

// -----------------------------------------------------------------------------

//

HBufC8* CMceCsSessionImplementation::SupportedVideoCodecsL()

	{

    MCESRV_DEBUG("CMceCsSessionImplementation::SupportedVideoCodecsL, Entry");

    CDesC8ArrayFlat* codecs = NULL;

    HBufC8* codecsAsString = NULL;

	RPointerArray<CMceComVideoCodec> supportedCodecs;

	CleanupStack::PushL( TCleanupItem( ArrayCleanup, &supportedCodecs ) );

	iManager.MediaManager().GetCapabilitiesL( supportedCodecs );

    codecs = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    CleanupStack::PushL( codecs );

	for ( int i=0;i<supportedCodecs.Count();i++ )

		{

		CMceComVideoCodec* codec = supportedCodecs[i];

		CMceMsgObject<CMceComVideoCodec>* codecMsg = 

                    new (ELeave) CMceMsgObject<CMceComVideoCodec>

                    ( *codec, EMceItcMsgTypeCodec );

		CleanupStack::PushL( codecMsg );

		codecMsg->EncodeL();

		codecs->AppendL( codecMsg->EncodeBuffer().Ptr(0) );

		CleanupStack::PopAndDestroy( codecMsg );

		}

    CMceMsgTextArray* msgCodecs = new (ELeave) CMceMsgTextArray( *codecs );

    CleanupStack::PushL( msgCodecs );

    msgCodecs->EncodeL();

    codecsAsString = msgCodecs->EncodeBufferCloneL();

    CleanupStack::PopAndDestroy( msgCodecs );

    CleanupStack::PopAndDestroy( codecs );

	CleanupStack::PopAndDestroy( &supportedCodecs ); //TCleanupItem

    MCESRV_DEBUG("CMceCsSessionImplementation::SupportedVideoCodecsL, Exit");

	return codecsAsString;

	}

// -----------------------------------------------------------------------------

// CMceCsSession::DoServiceL

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::DoServiceL( TMceIds& aIds, TInt aFunction, TPtr8& aInfo )

    {

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL( read ), Entry");

    switch( aFunction )

        {

        case EMceItcCameraInfo:

            {

    		MCESRV_DEBUG("getting camera info");

            MCE_READ( TMceItcArgTCameraInfo, TMceCameraInfo, cameraInfo );

            iManager.MediaManager().GetCameraInfoL( cameraInfo.iIndex,

                                                    cameraInfo.iInfo );

            MCE_WRITE( TMceItcArgTCameraInfo, cameraInfo ); 

            break;

            }

        case EMceItcCamerasAvailable:

            {

            TInt camerasAvailable = KErrNotFound;

            iManager.MediaManager().GetCamerasAvailableL( camerasAvailable );

    		MCESRV_DEBUG_DVALUE("getting available cameras. #", camerasAvailable );

            MCE_WRITE( TMceItcArgTInt, camerasAvailable ); 

            break;

            }

        case EMceItcDisplaysAvailable:

            {

            TInt displaysAvailable = KErrNotFound;

            iManager.MediaManager().GetDisplaysAvailableL( displaysAvailable );

    		MCESRV_DEBUG_DVALUE("getting displays available. value", displaysAvailable );

            MCE_WRITE( TMceItcArgTInt, displaysAvailable ); 

            break;

            }

        case EMceItcFileInfo:

            {

    		MCESRV_DEBUG("getting file info");

            TMceItcArgTFileInfo readBuf;

            readBuf.Copy( aInfo );

            TMceFileInfo& fileInfo = readBuf();

            GetFileInfoL( aIds, fileInfo );

            MCE_WRITE( TMceItcArgTFileInfo, fileInfo ); 

            break;

            }

        case EMceItcMaxVolume:

            {

            TInt maxVolume = KErrNotFound;

            iManager.MediaManager().GetMaxVolumeL( maxVolume );

    		MCESRV_DEBUG_DVALUE("getting max volume. value", maxVolume );

            MCE_WRITE( TMceItcArgTInt, maxVolume );  

            break;

            }

        case EMceItcMaxGain:

            {

            TInt maxGain = KErrNotFound;

            iManager.MediaManager().GetMaxGainL( maxGain );

    		MCESRV_DEBUG_DVALUE("getting max volume. value", maxGain );

            MCE_WRITE( TMceItcArgTInt, maxGain );  

            break;

            }

        default:

            {

        	#ifndef ALLOW_NOT_SUPPORTED_ITC

        	User::Leave(KErrNotSupported);

        	#endif

            }

        }

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL( read ), Exit");

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::DoServiceL

// -----------------------------------------------------------------------------

//

HBufC8* CMceCsSessionImplementation::DoServiceL( TMceIds& /*aIds*/, TInt /*aFunction*/ )

    {

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL(no data), Entry");

    HBufC8* returnMessage = NULL;

    #ifndef ALLOW_NOT_SUPPORTED_ITC

    User::Leave(KErrNotSupported);

    #endif

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL(no data), Exit");

    return returnMessage;

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::DoServiceL

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::DoServiceL( TMceIds& /*aIds*/, TInt aFunction, const TDesC8& aInfo )

    {

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL( write ), Entry");

    switch( aFunction )

        {

        case EMceItcCancelTranscode:

            {

    		MCESRV_DEBUG("cancelling transcode");

            MCE_READ( TMceItcArgTUint32, TUint32, sessionId );

            iManager.MediaManager().CancelTranscodeFileL( sessionId );

            break;

            }

        default:

            {

        	#ifndef ALLOW_NOT_SUPPORTED_ITC

        	User::Leave(KErrNotSupported);

        	#endif

            }

        }

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL( write ), Exit");

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::DoServiceL

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::DoServiceL( TMceIds& aIds, TInt aFunction, 

                                              CMceMsgBase& aMessage )

    {

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL( message ), Entry");

    switch( aFunction )

        {

        case EMceItcTranscode:

            {

    		MCESRV_DEBUG("transcoding");

            CMceMsgObject<CMceComFileSource>* msg = 

                static_cast<CMceMsgObject<CMceComFileSource>*>( &aMessage );

            CMceComFileSource* file = msg->Object();

            CleanupStack::PushL( file );

            file->iClient = this;

            TUint32 sessionId = iManager.MediaManager().TranscodeFileL( file );

            aIds.Set( KMceIdsIndexTCId, sessionId );

            CleanupStack::Pop( file );

            break;

            }

        case EMceItcTranscodeWithSession:

            {

           	MCESRV_DEBUG("transcoding with session");

           	// Session structure is needed temporarily by mediamanager

           	// in order to find out output codec types. 

           	//

            CMceMsgObject<CMceComSession>* msg = 

                static_cast<CMceMsgObject<CMceComSession>*>( &aMessage );

            CMceComSession* session = msg->Object();

            CleanupStack::PushL( session );

            CMceComFileSource* file = NULL;

            for( TInt i = 0; session && ( i < session->Streams().Count() ) && !file; i++ )

                {

                if ( session->Streams()[ i ]->Source() &&

                     session->Streams()[ i ]->Source()->Type() == KMceFileSource )

                    {

                    file = static_cast<CMceComFileSource*>( 

                            session->Streams()[ i ]->Source() );

                    file->iClient = this;

                    }

                }

            __ASSERT_ALWAYS( file, User::Leave( KErrArgument ) );

            TUint32 sessionId = iManager.MediaManager().TranscodeFileL( file );

            aIds.Set( KMceIdsIndexTCId, sessionId );

            // Filesource was taken in use from session by mediamanager

            // (took ownership) and rest can be discarded. File is not deleted

            // while deleting session because of ref count increase.

            //

            file->ReferenceCount()++;

            CleanupStack::PopAndDestroy( session );

            break;

            }

        default:

            {

        	#ifndef ALLOW_NOT_SUPPORTED_ITC

        	User::Leave(KErrNotSupported);

        	#endif

            }

        }

    MCESRV_DEBUG("CMceCsSessionImplementation::DoServiceL( message ), Exit");

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::GetFileInfoL

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::GetFileInfoL( TMceIds& aIds, 

                                                TMceFileInfo& aFileInfo )

    {

    MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Entry");

    // Save some stack

    {

    const RMessage2* itcContext = MCE_IDS_ITC_CONTEXT( aIds );

    const TDesC& fileName = aFileInfo.iFileName;

	const TDesC& rootPath = PathInfo::PhoneMemoryRootPath(); 

    TFileName privatePath;

    TFileName realRootPath;

    __ASSERT_ALWAYS( MCE_NOT_NULL_PTR( itcContext ) , User::Leave( KErrArgument ) );

    TUid clientUId = itcContext->SecureId();

	privatePath.Format(KMceApplPrivatePath, &rootPath, clientUId.iUid );

	realRootPath.Format(KMceRootPath, &rootPath );

    MCESRV_DEBUG_SVALUE16("CMceCsSessionImplementation::GetFileInfoL, file", fileName );

    MCESRV_DEBUG_SVALUE16("CMceCsSessionImplementation::GetFileInfoL, root", rootPath );    

    MCESRV_DEBUG_SVALUE16("CMceCsSessionImplementation::GetFileInfoL, private", privatePath );

	if( itcContext->HasCapability( ECapabilityAllFiles ) )

		{

    	MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Client has AllFiles capability");

	    aFileInfo.iAccessRights = TMceFileInfo::EReadWrite;		

		}

	else if( fileName.FindF( rootPath ) == 0 )

		{

    	MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Client accessing phone root(data)");

	    aFileInfo.iAccessRights = TMceFileInfo::EReadWrite;		

		}

	else if( fileName.FindF( privatePath ) == 0 )

		{

    	MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Client accessing private path");

	    aFileInfo.iAccessRights = TMceFileInfo::EReadWrite;		

		}

	else if( fileName.FindF( privatePath ) == 0 )

		{

    	MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Client accessing private path");

	    aFileInfo.iAccessRights = TMceFileInfo::EReadWrite;		

		}

	else if( fileName.FindF( realRootPath ) == KErrNotFound )

		{

    	MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Client accessing another drive");

	    aFileInfo.iAccessRights = TMceFileInfo::EReadWrite;		

		}

	else

		{

    	MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Permission denied");

	    aFileInfo.iAccessRights = TMceFileInfo::EZero;				

		}	

    }

    if ( aFileInfo.iDirection >= TMceFileInfo::ERead && 

    	 aFileInfo.iAccessRights > TMceFileInfo::EZero )

        {

    	MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Getting file info");

        iManager.MediaManager().GetFileInfoL( aFileInfo );

        }			

    MCESRV_DEBUG("CMceCsSessionImplementation::GetFileInfoL, Exit");

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::StoreClientContent

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::StoreClientContent( HBufC8* aClientContent )

    {

    delete aClientContent;

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::EventReceived

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::EventReceived( TMceMccComEvent& aEvent )

    {

    MCESRV_DEBUG("CMceCsSessionImplementation::EventReceived, Entry");

    TMceIds ids;

    ids.iManagerType = KMceCSSIPSession;

    ids.iCallbackID = aEvent.iItcEvent;

	ids.iMediaID = aEvent.iStream ? aEvent.iStream->Id() : KMceMediaIdNotAssigned;

	ids.iSinkID = aEvent.iSink ? aEvent.iSink->Id() : KMceMediaIdNotAssigned;

	ids.iSourceID = aEvent.iSource ? aEvent.iSource->Id() : KMceMediaIdNotAssigned;

	ids.iState = aEvent.iItcData;

	ids.iStatus = aEvent.iError;

    TRAP_IGNORE( SendToClientL( ids, NULL, NULL ) );

    MCESRV_DEBUG("CMceCsSessionImplementation::EventReceived, Exit");

    }

// -----------------------------------------------------------------------------

// CMceCsSessionImplementation::ArrayCleanup

// -----------------------------------------------------------------------------

//

void CMceCsSessionImplementation::ArrayCleanup(TAny* aArray)

	{