1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalComponent

    19 */

    20 

    21 #include "hciserver.h"

    22 #include "corehciutil.h"

    23 #include "hciserverrequestmgr.h"

    24 #include "hcisession.h"

    25 #include "hciserversecuritypolicy.h"

    26 #include "HciCorePluginImpl.h"

    27 

    28 #include <bluetooth/hci/hciipc.h>

    29 #include <bluetooth/logger.h>

    30 

    31 #ifdef __FLOG_ACTIVE

    32 _LIT8(KLogComponent, LOG_COMPONENT_HCISERVER);

    33 #endif

    34 

    35 CHCIServer* CHCIServer::NewL(CCoreHCIPluginImpl& aParent)

    36 	{

    37 	LOG_STATIC_FUNC

    38 	

    39 	CHCIServer* self = new(ELeave) CHCIServer(aParent);

    40 	CleanupStack::PushL(self);

    41 	// StartL is where the kernel checks that there isn't already an instance 

    42 	// of the same server running, so do it before ConstructL.

    43 	self->StartL(KHCIServerName);

    44 	self->ConstructL();

    45 	CleanupStack::Pop(self);

    46 	return self;

    47 	}

    48 

    49 CHCIServer::~CHCIServer()

    50 	{

    51 	LOG_FUNC

    52 	

    53 	delete iBTPowerControlManager;

    54 	delete iHCIDirectAccessManager;

    55 	}

    56 

    57 CHCIServer::CHCIServer(CCoreHCIPluginImpl& aParent)

    58  :	CPolicyServer(CActive::EPriorityStandard, KHCIServerPolicy),

    59 	iParent(aParent)

    60 	{

    61 	LOG_FUNC

    62 	}

    63 

    64 void CHCIServer::ConstructL()

    65 	{

    66 	LOG_FUNC

    67 	

    68 	iBTPowerControlManager = CBTPowerControlManager::NewL(iParent);

    69 	iHCIDirectAccessManager = CHCIDirectAccessManager::NewL(iParent);

    70 	iBluetoothDutModeManager = CBluetoothDutModeManager::NewL(iParent);

    71 	iA2dpOptimiserManager = CA2dpOptimiserManager::NewL(iParent);

    72 	}

    73 

    74 CHCIDirectAccessManager &CHCIServer::DirectAccessManager()

    75 	{

    76 	LOG_FUNC

    77 	

    78 	return *iHCIDirectAccessManager;

    79 	}

    80 

    81 CBTPowerControlManager& CHCIServer::PowerControlManager()

    82 	{

    83 	LOG_FUNC

    84 	

    85 	return *iBTPowerControlManager;	

    86 	}

    87 

    88 CBluetoothDutModeManager& CHCIServer::DutModeManager()

    89 	{

    90 	LOG_FUNC

    91 	

    92 	return *iBluetoothDutModeManager; 

    93 	}

    94 

    95 CA2dpOptimiserManager& CHCIServer::A2dpOptimiserManager()

    96 	{

    97 	LOG_FUNC

    98 	

    99 	return *iA2dpOptimiserManager; 

   100 	}

   101 

   102 CHCIServerRequestManager* CHCIServer::ConnectToServiceL(TInt aInterfaceUid)

   103 	{

   104 	LOG_FUNC

   105 	TInt err = KErrInUse;

   106 	CHCIServerRequestManager* requestManager = NULL;

   107 

   108 	switch(aInterfaceUid)

   109 		{

   110 	case KHCIPowerControlManagerUid:

   111 		if(!(iRequestManagerLocks & EBTPowerControlService))

   112 			{

   113 			iRequestManagerLocks |= EBTPowerControlService;

   114 			requestManager = iBTPowerControlManager;

   115 			err = KErrNone;

   116 			}

   117 		break;

   118 

   119 	case KHCIDirectAccessManagerUid:

   120 		if(!(iRequestManagerLocks & EHCIDirectAccessService))

   121 			{

   122 			iRequestManagerLocks |= EHCIDirectAccessService;

   123 			requestManager = iHCIDirectAccessManager;

   124 			err = KErrNone;

   125 			}

   126 		break;

   127 

   128 	case KHCIBluetoothDutModeManagerUid:

   129 		if(!(iRequestManagerLocks & EBluetoothDutModeService))

   130 			{

   131 			iRequestManagerLocks |= EBluetoothDutModeService;

   132 			requestManager = iBluetoothDutModeManager;

   133 			err = KErrNone;

   134 			}

   135 		break;

   136 

   137 	case KHCIA2dpOptimserManagerUid:

   138 		if(!(iRequestManagerLocks & EA2dpOptimiserService))

   139 			{

   140 			iRequestManagerLocks |= EA2dpOptimiserService;

   141 			requestManager = iA2dpOptimiserManager;

   142 			err = KErrNone;

   143 			}

   144 		break;

   145 

   146 	default:

   147 		err = KErrArgument;

   148 		break;

   149 		}

   150 

   151 	LEAVEIFERRORL(err); // only return a request manager on success

   152 	__ASSERT_DEBUG(requestManager, PANIC(KHciServerPanicCat, ENoRequestManagerToProvide));

   153 	return requestManager;

   154 	}

   155 

   156 void CHCIServer::ReleaseService(CHCIServerRequestManager* aServiceToRelease)

   157 	{

   158 	if(aServiceToRelease == iBTPowerControlManager)

   159 		{

   160 		__ASSERT_DEBUG(iRequestManagerLocks & EBTPowerControlService, PANIC(KHciServerPanicCat, EPwrCtrlReleasedWhenNotLocked));

   161 		iRequestManagerLocks &= ~EBTPowerControlService;

   162 		}

   163 	else if(aServiceToRelease == iHCIDirectAccessManager)

   164 		{

   165 		__ASSERT_DEBUG(iRequestManagerLocks & EHCIDirectAccessService, PANIC(KHciServerPanicCat, EHciDaReleasedWhenNotLocked));

   166 		iRequestManagerLocks &= ~EHCIDirectAccessService;

   167 		}

   168 	else if(aServiceToRelease == iBluetoothDutModeManager)

   169 		{

   170 		__ASSERT_DEBUG(iRequestManagerLocks & EBluetoothDutModeService, PANIC(KHciServerPanicCat, EDutModeReleasedWhenNotLocked));

   171 		iRequestManagerLocks &= ~EBluetoothDutModeService;

   172 		}

   173 	else if(aServiceToRelease == iA2dpOptimiserManager)

   174 		{

   175 		__ASSERT_DEBUG(iRequestManagerLocks & EA2dpOptimiserService, PANIC(KHciServerPanicCat, EA2dpOptimiserReleasedWhenNotLocked));

   176 		iRequestManagerLocks &= ~EA2dpOptimiserService;

   177 		}

   178 	else

   179 		{

   180 		__ASSERT_DEBUG(EFalse, PANIC(KHciServerPanicCat, EUnknownServiceReleased));

   181 		}

   182 	}

   183 

   184 CSession2* CHCIServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

   185 	{

   186 	LOG_FUNC

   187 	LOG3(_L8("\taVersion = (%d,%d,%d)"), aVersion.iMajor, aVersion.iMinor, aVersion.iBuild);

   188 		

   189 	// Version number check...

   190 	TVersion v(KHCISrvVersion2MajorVersionNumber,

   191 			   KHCISrvVersion2MinorVersionNumber,

   192 			   KHCISrvVersion2BuildNumber);

   193 	

   194 	if ( !User::QueryVersionSupported(v, aVersion) )

   195 		{

   196 		LEAVEIFERRORL(KErrNotSupported);

   197 		}

   198 

   199 	CHCIServer* ncThis = const_cast<CHCIServer*>(this);

   200 

   201 	CHCISession* sess = CHCISession::NewL(*ncThis);

   202 	LOG1(_L8("\tsess = 0x%08x"), sess);

   203 	return sess;

   204 	}

   205 

   206 void CHCIServer::OpenClientReference()

   207 	{

   208 	iParent.OpenClientReference();

   209 	}

   210 

   211 void CHCIServer::CloseClientReference()

   212 	{

   213 	iParent.CloseClientReference();

   214 	}