MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/devsoundextensions/mmextfw/custominterfaceutility/CustomInterfaceBuilder/src/CustomInterfaceBuilder.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /*

     2 * Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   CustomInterface Builder

    15 *

    16 */

    17 

    18 

    19 #include <CustomInterfaceBuilder.h>

    20 #include <sounddevice.h>

    21 #include <MessageHandlerFactory.h>

    22 #include "AdaptationCustomInterfaceBuilder.h"

    23 #include "CustomInterfaceBuilderTypes.h"

    24 

    25 #include "RestrictedAudioOutputMessageHandler.h"

    26 #include "AudioOutputMessageTypes.h"

    27 

    28 const TUid KUidCustomInterfaceBuilderImpl = {0x10207A8E};

    29 

    30 EXPORT_C CCustomInterfaceBuilder* CCustomInterfaceBuilder::NewL(CMMFObjectContainer& aObjectContainer,

    31                                                                 CMMFDevSound&        aDevSound)

    32 	{

    33 	CCustomInterfaceBuilder* self = new(ELeave) CCustomInterfaceBuilder(aObjectContainer,

    34 	                                                                    aDevSound);

    35 	CleanupStack::PushL(self);

    36 	self->ConstructL();

    37 	CleanupStack::Pop(self);

    38 	return self;

    39 	}

    40 

    41 EXPORT_C CCustomInterfaceBuilder* CCustomInterfaceBuilder::NewL(CMMFObjectContainer& aObjectContainer,

    42                                                                 MCustomInterface& aCustomInterface)

    43 	{

    44 	CCustomInterfaceBuilder* self = new(ELeave) CCustomInterfaceBuilder(aObjectContainer,

    45 	                                                                    aCustomInterface);

    46 	CleanupStack::PushL(self);

    47 	self->ConstructL();

    48 	CleanupStack::Pop(self);

    49 	return self;

    50 	}

    51 

    52 CCustomInterfaceBuilder::CCustomInterfaceBuilder(CMMFObjectContainer& aObjectContainer,

    53                                                  CMMFDevSound&        aDevSound) :

    54     CMMFObject(KUidCustomInterfaceBuilderImpl),

    55     iDevSound(&aDevSound),

    56 	iObjectContainer(aObjectContainer),

    57 	iSecureCustomInterfaces(EFalse)

    58 	{

    59 	}

    60 

    61 CCustomInterfaceBuilder::CCustomInterfaceBuilder(CMMFObjectContainer& aObjectContainer,

    62                                                  MCustomInterface& aCustomInterface) :

    63     CMMFObject(KUidCustomInterfaceBuilderImpl),

    64 	iCustomInterface(&aCustomInterface),

    65 	iObjectContainer(aObjectContainer),

    66 	iSecureCustomInterfaces(EFalse)

    67 	{

    68 	}

    69 

    70 void CCustomInterfaceBuilder::ConstructL()

    71 	{

    72 	}

    73 

    74 CCustomInterfaceBuilder::~CCustomInterfaceBuilder()

    75 	{

    76 	}

    77 

    78 void CCustomInterfaceBuilder::HandleRequest(TMMFMessage& aMessage)

    79 	{

    80 	ASSERT(aMessage.Destination().InterfaceId() == KUidCustomInterfaceBuilderImpl);

    81 	TRAPD(error,DoHandleRequestL(aMessage));

    82 	if(error)

    83 		{

    84 		aMessage.Complete(error);

    85 		}

    86 	}

    87 

    88 void CCustomInterfaceBuilder::DoHandleRequestL(TMMFMessage& aMessage)

    89 	{

    90 	switch( aMessage.Function() )

    91 		{

    92 		case ECibBuild:

    93 			DoBuildL(aMessage);

    94 			break;

    95 		case ECibRemove:

    96 			DoRemoveL(aMessage);

    97 			break;

    98 

    99 		default:

   100 			User::Leave(KErrNotSupported);

   101 

   102 		}

   103 

   104 	}

   105 

   106 void CCustomInterfaceBuilder::DoBuildL(TMMFMessage& aMessage)

   107 	{

   108 	TPckgBuf<TUid> uidPckg;

   109 	aMessage.ReadData1FromClientL(uidPckg);

   110 	TUid interfaceId = uidPckg();

   111 	//only KUidRestrictedAudioOutput is blocked here. 

   112     //KUidAudioOutput will be blocked in messageHandler for specific commands.

   113 	if( iSecureCustomInterfaces && interfaceId==KUidRestrictedAudioOutput )

   114 	    {

   115 	    User::Leave( KErrNotSupported );

   116 	    }

   117 

   118 	TMMFMessageDestination handle;

   119 	

   120 	TAny* customInterface = GetCustomInterfaceL(interfaceId);

   121 	if(customInterface)

   122 		{

   123 		CMMFObject* messageHandler = CMessageHandlerFactory::Create(interfaceId, customInterface,iObjectContainer);

   124 		if(messageHandler)

   125 			{

   126 			iObjectContainer.AddMMFObject(*messageHandler);

   127 			handle = messageHandler->Handle();

   128 			}

   129 		}

   130 	TMMFMessageDestinationPckg handlePckg(handle);

   131 	aMessage.WriteDataToClient(handlePckg);

   132 	aMessage.Complete(KErrNone);

   133 	}

   134 	

   135 void CCustomInterfaceBuilder::DoRemoveL(TMMFMessage& aMessage)

   136 	{

   137 	TMMFMessageDestinationPckg handlePckg;

   138 	aMessage.ReadData1FromClientL(handlePckg);

   139 

   140 	CMMFObject* messageHandler = NULL;

   141 

   142 	if ( iObjectContainer.FindMMFObject(handlePckg(), messageHandler) == KErrNone )

   143 		{

   144 		iObjectContainer.RemoveAndDestroyMMFObject(*messageHandler);

   145 		}

   146 	aMessage.Complete(KErrNone);

   147 		

   148 

   149 	}

   150 

   151 TAny* CCustomInterfaceBuilder::GetCustomInterfaceL(TUid aInterfaceId)

   152 	{

   153 	TAny* customInterface = NULL;

   154     if (iDevSound)

   155         {

   156         customInterface = iDevSound->CustomInterface(aInterfaceId);

   157         }

   158     else if (iCustomInterface)

   159         {

   160         customInterface = iCustomInterface->CustomInterface(aInterfaceId);

   161         }

   162 	return customInterface;

   163 	}

   164 

   165 EXPORT_C void CCustomInterfaceBuilder::SetSecureCustomInterfaces( const TBool aSecure )

   166     {

   167     iSecureCustomInterfaces = aSecure;

   168     }
Symaptic