diff -r 000000000000 -r 71ca22bcf22a mmfenh/enhancedmediaclient/Client/src/Components/EffectBase/EffectControlBaseImpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmfenh/enhancedmediaclient/Client/src/Components/EffectBase/EffectControlBaseImpl.cpp Tue Feb 02 01:08:46 2010 +0200 @@ -0,0 +1,418 @@ +/* +* Copyright (c) 2006 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: Implementation of EffectControlBaseImpl class. +* +*/ + +#include +#include +#include +#include +#include + +#include "CustomInterfaceBuilderTypes.h" +#include "EffectControlBaseImpl.h" +#include "EffectControlBase.h" + +const TUid KUidCIFBuilderParser = {0x10207B29}; + +using namespace multimedia; + +CEffectControlBaseImpl::CEffectControlBaseImpl( CEffectControlBase& aParent, TUid aCIUid ) +: CActive(CActive::EPriorityStandard), + iParent(aParent), + iCIUid(aCIUid), + iStreamControl(NULL), + iCustomCommand(NULL), + iEffect(NULL) + { + CActiveScheduler::Add(this); + } + +CEffectControlBaseImpl::~CEffectControlBaseImpl() + { + Cancel(); + // Signal MStreamControl if this effect class is deleted before + // removing from it + if ( iStreamControl ) + { + iStreamControl->RemoveEffect( *iEffect ); + }; + } + +CEffectControlBaseImpl* CEffectControlBaseImpl::NewL( CEffectControlBase& aParent, TUid aCIUid ) + { + CEffectControlBaseImpl* self = new (ELeave) CEffectControlBaseImpl( aParent, aCIUid ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +void CEffectControlBaseImpl::ConstructL() + { + // No impl yet + } + +TInt CEffectControlBaseImpl::AddedToStreamControl( MStreamControl& aStreamControl, + MCustomCommand& aCustomCommand, + MEffectControl& aEffect ) + { + TInt status(KErrAlreadyExists); + if ( !iStreamControl ) + { + iStreamControl = &aStreamControl; + iCustomCommand = &aCustomCommand; + iEffect = &aEffect; + status = KErrNone; + } + + // This is done here to get the MessageHandler if the Controller + // is already loaded, otherwise we dont return an Error from Connect + if(iMsgHndlrHandlePckg().InterfaceId() == KNullUid) + { + status = Connect(); + if(status == KErrNone) + { +/* + // This results in subclasses getting notification asynchronously. + // In the mean time clients may already start setting attributes on + // effect objects which will be lost if proxy is not created + // In order to eliminate this possibility, notify synchronously + CActive::Cancel(); + CActive::SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, EControllerLoaded ); +*/ + iParent.Event( CEffectControlBase::ECIBuilderCreated ); + } + else + { + // This Error is Overwritten because the Connect failed. + // Its ok here since we are just checking if the controller + // is loaded and the msghandler created. + status = KErrNone; + } + } + + return status; + } + +TInt CEffectControlBaseImpl::RemovedFromStreamControl( MStreamControl& /*aStreamControl*/ ) + { + Disconnect(); + iStreamControl = NULL; + iCustomCommand = NULL; + iEffect = NULL; + return KErrNone; + } + +void CEffectControlBaseImpl::StreamControlDeleted( MStreamControl& /*aStreamControl*/ ) + { + iStreamControl = NULL; + iCustomCommand = NULL; + iMsgHndlrHandlePckg().InterfaceId() = KNullUid; + } + +TBool CEffectControlBaseImpl::IsConnected() + { + if ( iMsgHndlrHandlePckg().InterfaceId() != KNullUid ) + { + return ETrue; + } + else + { + return EFalse; + } + } + +TInt CEffectControlBaseImpl::Connect() + { + TInt status(KErrNone); + + // Since the Volume Effect does not have Proxy + // and message handler we return here only + if(iEffect->Type() == KVolumeEffectControl) + { + return KErrNone; + } + + if(!iCustomCommand) + { + return KErrNotReady; + } + + TMMFMessageDestination destination(KUidCustomInterfaceBuilder); + TMMFMessageDestinationPckg destinationPckg(destination); + + if ( iMsgHndlrHandlePckg().InterfaceId() == KNullUid ) + { + + status = iCustomCommand->CustomCommandSync(destinationPckg, ECibGetBuilder, KNullDesC8, KNullDesC8, iBuilderHandle); + + if(iBuilderHandle().InterfaceId() == KNullUid || status != KErrNone) + { + return status; + } + + // Get handle to message handler from CI Bldr parser + status = BuilderParserMessage(ECIFCreateMessageHandler); + if( iMsgHndlrHandlePckg().InterfaceId() == KNullUid ) + { + status = KErrNotSupported; + } + } + + return status; + } + +TInt CEffectControlBaseImpl::Disconnect() + { + TInt status(KErrNotReady); + if ( ( iMsgHndlrHandlePckg().InterfaceId() != KNullUid ) && (iCustomCommand) ) + { + // Get handle to message handler from CI Bldr parser + status = BuilderParserMessage(ECIFRemoveMessageHandler); + // This is done here since the Interface ID is not set to NULL when + // we set it using KNullUid. + TMMFMessageDestination temp; + iMsgHndlrHandlePckg() = temp; + } + return status; + } + +TInt CEffectControlBaseImpl::CustomCommandSync(TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TDes8& aDataFrom) + { + return CustomCommandSync( iMsgHndlrHandlePckg, + aFunction, + aDataTo1, + aDataTo2, + aDataFrom ); + } + +TInt CEffectControlBaseImpl::CustomCommandSync(TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2) + { + return CustomCommandSync( iMsgHndlrHandlePckg, + aFunction, + aDataTo1, + aDataTo2 ); + } + +void CEffectControlBaseImpl::CustomCommandAsync(TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TDes8& aDataFrom, + TRequestStatus& aStatus) + { + CustomCommandAsync( iMsgHndlrHandlePckg, + aFunction, + aDataTo1, + aDataTo2, + aDataFrom, + aStatus ); + } + +void CEffectControlBaseImpl::CustomCommandAsync(TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TRequestStatus& aStatus) + { + CustomCommandAsync( iMsgHndlrHandlePckg, + aFunction, + aDataTo1, + aDataTo2, + aStatus ); + } + +TInt CEffectControlBaseImpl::CustomCommandSync( const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TDes8& aDataFrom ) + { + TInt status(KErrNotReady); + if ( ( iCustomCommand ) && ( aDestination().InterfaceId() != KNullUid ) ) + { + status = iCustomCommand->CustomCommandSync( aDestination, + aFunction, + aDataTo1, + aDataTo2, + aDataFrom ); + } + return status; + } + +TInt CEffectControlBaseImpl::CustomCommandSync( const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2 ) + { + TInt status(KErrNotReady); + if ( ( iCustomCommand ) && ( aDestination().InterfaceId() != KNullUid ) ) + { + status = iCustomCommand->CustomCommandSync( aDestination, + aFunction, + aDataTo1, + aDataTo2 ); + } + return status; + } + +void CEffectControlBaseImpl::CustomCommandAsync( const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TDes8& aDataFrom, + TRequestStatus& aStatus ) + { + if ( ( iCustomCommand ) && ( aDestination().InterfaceId() != KNullUid ) ) + { + iCustomCommand->CustomCommandAsync( aDestination, + aFunction, + aDataTo1, + aDataTo2, + aDataFrom, + aStatus ); + } + else + { + TRequestStatus* status = &aStatus; + User::RequestComplete(status, KErrNotReady); + } + } + +void CEffectControlBaseImpl::CustomCommandAsync( const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TRequestStatus& aStatus ) + + { + if ( ( iCustomCommand ) && ( aDestination().InterfaceId() != KNullUid ) ) + { + iCustomCommand->CustomCommandAsync( aDestination, + aFunction, + aDataTo1, + aDataTo2, + aStatus ); + } + else + { + TRequestStatus* status = &aStatus; + User::RequestComplete(status, KErrNotReady); + } + } + +TInt CEffectControlBaseImpl::GetMessageHandle(TMMFMessageDestinationPckg &aPckg) + { + TInt status(KErrNone); + aPckg = iMsgHndlrHandlePckg; + return status; + } + +MCustomCommand* CEffectControlBaseImpl::GetCustomCommand() + { + return iCustomCommand; + } + +void CEffectControlBaseImpl::RunL() + { + TInt status(KErrNone); + if ( iStatus.Int() == EControllerLoaded ) + { + status = Connect(); + if(status == KErrNone) + { + iParent.Event( CEffectControlBase::ECIBuilderCreated ); + } + } + else if ( iStatus.Int() == EControllerUnloaded ) + { + status = Disconnect(); + if(status == KErrNone) + { + iParent.Event( CEffectControlBase::EMessageHandlerDeleted ); + } + } + } + +void CEffectControlBaseImpl::DoCancel() + { + // Do Nothing + } + +TInt CEffectControlBaseImpl::RunError( TInt /*aError*/ ) + { + // RunL should never leave, if it did that means + // the code left during event handling + return KErrNone; + } + +void CEffectControlBaseImpl::Event( MControl* /*aControl*/, TUint aEventType, TAny* /*aEventObject*/ ) + { + if ( aEventType == EControllerLoaded ) + { + CActive::Cancel(); + CActive::SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, EControllerLoaded ); + } + else if ( aEventType == EControllerUnloaded ) + { + CActive::Cancel(); + CActive::SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, EControllerUnloaded ); + } + } + +TInt CEffectControlBaseImpl::BuilderParserMessage(CIFBuilderParserFunctions aCommand) + { + TInt status(KErrNotReady); + if ( iCustomCommand ) + { + TMMFMessageDestination ciBldr(KUidCIFBuilderParser); + TMMFMessageDestinationPckg ciBldrPckg(ciBldr); + TPckgBuf uidPckg; + uidPckg() = iCIUid; + switch (aCommand) + { + case ECIFCreateMessageHandler: + status = iCustomCommand->CustomCommandSync( iBuilderHandle, + ECibBuild, + uidPckg, + KNullDesC8, + iMsgHndlrHandlePckg); + break; + case ECIFRemoveMessageHandler: + status = iCustomCommand->CustomCommandSync( iBuilderHandle, + ECibRemove, + iMsgHndlrHandlePckg, + KNullDesC8); + break; + default: + status = KErrUnknown; + break; + }; + } + return status; + } + + +// End of file