bthci/hci2implementations/CommandsEvents/symbian/src/Event.cpp
changeset 0 29b1cd4cb562
child 51 20ac952a623c
equal deleted inserted replaced
-1:000000000000 0:29b1cd4cb562
       
     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 
       
    22 #include <bluetooth/hci/event.h>
       
    23 #include <bluetooth/hci/vendordebugevent.h>
       
    24 #include <bluetooth/hci/vendordebugcompleteevent.h>
       
    25 #include <bluetooth/hci/commandcompleteevent.h>
       
    26 
       
    27 #include <bluetooth/hci/hciopcodes.h>
       
    28 #include <bluetooth/hcicommandeventobserver.h>
       
    29 #include <bluetooth/hci/hcidataeventobserver.h>
       
    30 #include <bluetooth/hci/hciconsts.h>
       
    31 
       
    32 // Complete Event Class Headers
       
    33 #include <bluetooth/hci/nopcompleteevent.h>
       
    34 #include <bluetooth/hci/inquirycancelcompleteevent.h>
       
    35 #include <bluetooth/hci/periodicinquirymodecompleteevent.h>
       
    36 #include <bluetooth/hci/exitperiodicinquirymodecompleteevent.h>
       
    37 #include <bluetooth/hci/createconnectioncancelcompleteevent.h>
       
    38 #include <bluetooth/hci/linkkeyrequestreplycompleteevent.h>
       
    39 #include <bluetooth/hci/linkkeyrequestreplynegativecompleteevent.h>
       
    40 #include <bluetooth/hci/pincoderequestreplycompleteevent.h>
       
    41 #include <bluetooth/hci/pincoderequestreplynegativecompleteevent.h>
       
    42 #include <bluetooth/hci/remotenamerequestcancelcompleteevent.h>
       
    43 #include <bluetooth/hci/readlmphandlecompleteevent.h>
       
    44 #include <bluetooth/hci/qossetupcompleteevent.h>
       
    45 #include <bluetooth/hci/rolediscoverycompleteevent.h>
       
    46 #include <bluetooth/hci/readlinkpolicysettingscompleteevent.h>
       
    47 #include <bluetooth/hci/writelinkpolicysettingscompleteevent.h>
       
    48 #include <bluetooth/hci/readdefaultlinkpolicysettingscompleteevent.h>
       
    49 #include <bluetooth/hci/writedefaultlinkpolicysettingscompleteevent.h>
       
    50 #include <bluetooth/hci/sniffsubratingcompleteevent.h>
       
    51 #include <bluetooth/hci/flowspecificationcompleteevent.h>
       
    52 #include <bluetooth/hci/seteventmaskcompleteevent.h>
       
    53 #include <bluetooth/hci/resetcompleteevent.h>
       
    54 #include <bluetooth/hci/seteventfiltercompleteevent.h>
       
    55 #include <bluetooth/hci/flushcompleteevent.h>
       
    56 #include <bluetooth/hci/readpintypecompleteevent.h>
       
    57 #include <bluetooth/hci/writepintypecompleteevent.h>
       
    58 #include <bluetooth/hci/createnewunitkeycompleteevent.h>
       
    59 #include <bluetooth/hci/readstoredlinkkeycompleteevent.h>
       
    60 #include <bluetooth/hci/writestoredlinkkeycompleteevent.h>
       
    61 #include <bluetooth/hci/deletestoredlinkkeycompleteevent.h>
       
    62 #include <bluetooth/hci/writelocalnamecompleteevent.h>
       
    63 #include <bluetooth/hci/readlocalnamecompleteevent.h>
       
    64 #include <bluetooth/hci/readconnectionaccepttimeoutcompleteevent.h>
       
    65 #include <bluetooth/hci/writeconnectionaccepttimeoutcompleteevent.h>
       
    66 #include <bluetooth/hci/readpagetimeoutcompleteevent.h>
       
    67 #include <bluetooth/hci/writepagetimeoutcompleteevent.h>
       
    68 #include <bluetooth/hci/readscanenablecompleteevent.h>
       
    69 #include <bluetooth/hci/writescanenablecompleteevent.h>
       
    70 #include <bluetooth/hci/readpagescanactivitycompleteevent.h>
       
    71 #include <bluetooth/hci/writepagescanactivitycompleteevent.h>
       
    72 #include <bluetooth/hci/readinquiryscanactivitycompleteevent.h>
       
    73 #include <bluetooth/hci/writeinquiryscanactivitycompleteevent.h>
       
    74 #include <bluetooth/hci/readauthenticationenablecompleteevent.h>
       
    75 #include <bluetooth/hci/writeauthenticationenablecompleteevent.h>
       
    76 #include <bluetooth/hci/readencryptionmodecompleteevent.h>
       
    77 #include <bluetooth/hci/writeencryptionmodecompleteevent.h>
       
    78 #include <bluetooth/hci/readclassofdevicecompleteevent.h>
       
    79 #include <bluetooth/hci/writeclassofdevicecompleteevent.h>
       
    80 #include <bluetooth/hci/readvoicesettingcompleteevent.h>
       
    81 #include <bluetooth/hci/writevoicesettingcompleteevent.h>
       
    82 #include <bluetooth/hci/readautomaticflushtimeoutcompleteevent.h>
       
    83 #include <bluetooth/hci/writeautomaticflushtimeoutcompleteevent.h>
       
    84 #include <bluetooth/hci/readnumbroadcastretransmissionscompleteevent.h>
       
    85 #include <bluetooth/hci/writenumbroadcastretransmissionscompleteevent.h>
       
    86 #include <bluetooth/hci/readholdmodeactivitycompleteevent.h>
       
    87 #include <bluetooth/hci/writeholdmodeactivitycompleteevent.h>
       
    88 #include <bluetooth/hci/readtransmitpowerlevelcompleteevent.h>
       
    89 #include <bluetooth/hci/readsynchronousflowcontrolenablecompleteevent.h>
       
    90 #include <bluetooth/hci/writesynchronousflowcontrolenablecompleteevent.h>
       
    91 #include <bluetooth/hci/setcontrollertohostflowcontrolcompleteevent.h>
       
    92 #include <bluetooth/hci/hostbuffersizecompleteevent.h>
       
    93 #include <bluetooth/hci/hostnumberofcompletedpacketscompleteevent.h>
       
    94 #include <bluetooth/hci/readlinksupervisiontimeoutcompleteevent.h>
       
    95 #include <bluetooth/hci/writelinksupervisiontimeoutcompleteevent.h>
       
    96 #include <bluetooth/hci/readnumberofsupportediaccompleteevent.h>
       
    97 #include <bluetooth/hci/readcurrentiaclapcompleteevent.h>
       
    98 #include <bluetooth/hci/writecurrentiaclapcompleteevent.h>
       
    99 #include <bluetooth/hci/readpagescanperiodcompleteevent.h>
       
   100 #include <bluetooth/hci/writepagescanperiodcompleteevent.h>
       
   101 #include <bluetooth/hci/setafhhostchannelclassificationcompleteevent.h>
       
   102 #include <bluetooth/hci/readinquiryscantypecompleteevent.h>
       
   103 #include <bluetooth/hci/writeinquiryscantypecompleteevent.h>
       
   104 #include <bluetooth/hci/readinquirymodecompleteevent.h>
       
   105 #include <bluetooth/hci/writeinquirymodecompleteevent.h>
       
   106 #include <bluetooth/hci/readpagescantypecompleteevent.h>
       
   107 #include <bluetooth/hci/writepagescantypecompleteevent.h>
       
   108 #include <bluetooth/hci/readafhchannelassessmentmodecompleteevent.h>
       
   109 #include <bluetooth/hci/writeafhchannelassessmentmodecompleteevent.h>
       
   110 #include <bluetooth/hci/readdefaulterroneousdatareportingcompleteevent.h>
       
   111 #include <bluetooth/hci/writedefaulterroneousdatareportingcompleteevent.h>
       
   112 #include <bluetooth/hci/readlocalversioninfocompleteevent.h>
       
   113 #include <bluetooth/hci/readlocalsupportedcommandscompleteevent.h>
       
   114 #include <bluetooth/hci/readlocalsupportedfeaturescompleteevent.h>
       
   115 #include <bluetooth/hci/readlocalextendedfeaturescompleteevent.h>
       
   116 #include <bluetooth/hci/readbuffersizecompleteevent.h>
       
   117 #include <bluetooth/hci/readbdaddrcompleteevent.h>
       
   118 #include <bluetooth/hci/readfailedcontactcountercompleteevent.h>
       
   119 #include <bluetooth/hci/resetfailedcontactcountercompleteevent.h>
       
   120 #include <bluetooth/hci/readlinkqualitycompleteevent.h>
       
   121 #include <bluetooth/hci/readrssicompleteevent.h>
       
   122 #include <bluetooth/hci/readafhchannelmapcompleteevent.h>
       
   123 #include <bluetooth/hci/readclockcompleteevent.h>
       
   124 #include <bluetooth/hci/readloopbackmodecompleteevent.h>
       
   125 #include <bluetooth/hci/writeloopbackmodecompleteevent.h>
       
   126 #include <bluetooth/hci/enabledeviceundertestmodecompleteevent.h>
       
   127 #include <bluetooth/hci/readextendedinquiryresponsecompleteevent.h>
       
   128 #include <bluetooth/hci/writeextendedinquiryresponsecompleteevent.h>
       
   129 #include <bluetooth/hci/readinquiryresponsetransmitpowerlevelcompleteevent.h>
       
   130 #include <bluetooth/hci/writeinquiryresponsetransmitpowerlevelcompleteevent.h>
       
   131 #include <bluetooth/hci/iocapabilityrequestreplycompleteevent.h>
       
   132 #include <bluetooth/hci/userconfirmationrequestreplycompleteevent.h>
       
   133 #include <bluetooth/hci/userconfirmationrequestnegativereplycompleteevent.h>
       
   134 #include <bluetooth/hci/userpasskeyrequestreplycompleteevent.h>
       
   135 #include <bluetooth/hci/userpasskeyrequestnegativereplycompleteevent.h>
       
   136 #include <bluetooth/hci/remoteoobdatarequestreplycompleteevent.h>
       
   137 #include <bluetooth/hci/remoteoobdatarequestnegativereplycompleteevent.h>
       
   138 #include <bluetooth/hci/iocapabilityrequestnegativereplycompleteevent.h>
       
   139 #include <bluetooth/hci/readsimplepairingmodecompleteevent.h>
       
   140 #include <bluetooth/hci/writesimplepairingmodecompleteevent.h>
       
   141 #include <bluetooth/hci/readlocaloobdatacompleteevent.h>
       
   142 #include <bluetooth/hci/sendkeypressnotificationcompleteevent.h>
       
   143 #include <bluetooth/hci/writesimplepairingdebugmodecompleteevent.h>
       
   144 
       
   145 
       
   146 // Event Class Headers
       
   147 #include <bluetooth/hci/inquirycompleteevent.h>
       
   148 #include <bluetooth/hci/inquiryresultevent.h>
       
   149 #include <bluetooth/hci/connectioncompleteevent.h>
       
   150 #include <bluetooth/hci/connectionrequestevent.h>
       
   151 #include <bluetooth/hci/disconnectioncompleteevent.h>
       
   152 #include <bluetooth/hci/commandstatusevent.h>
       
   153 #include <bluetooth/hci/linkkeyrequestevent.h>
       
   154 #include <bluetooth/hci/pincoderequestevent.h>
       
   155 #include <bluetooth/hci/remotenamereqcompleteevent.h>
       
   156 #include <bluetooth/hci/authenticationcompleteevent.h>
       
   157 #include <bluetooth/hci/encryptionchangeevent.h>
       
   158 #include <bluetooth/hci/changelinkkeyevent.h>
       
   159 #include <bluetooth/hci/masterlinkkeyevent.h>
       
   160 #include <bluetooth/hci/readremsuppfeatcompleteevent.h>
       
   161 #include <bluetooth/hci/readremverinfocompleteevent.h>
       
   162 #include <bluetooth/hci/hardwareerrorevent.h>
       
   163 #include <bluetooth/hci/flushoccurredevent.h>
       
   164 #include <bluetooth/hci/rolechangeevent.h>
       
   165 #include <bluetooth/hci/numberofcompletedpacketsevent.h>
       
   166 #include <bluetooth/hci/modechangeevent.h>
       
   167 #include <bluetooth/hci/returnlinkkeysevent.h>
       
   168 #include <bluetooth/hci/linkkeynotificationevent.h>
       
   169 #include <bluetooth/hci/loopbackcommandevent.h>
       
   170 #include <bluetooth/hci/databufferoverflowevent.h>
       
   171 #include <bluetooth/hci/maxslotschangeevent.h>
       
   172 #include <bluetooth/hci/readclockoffsetevent.h>
       
   173 #include <bluetooth/hci/connectionpackettypechangedevent.h>
       
   174 #include <bluetooth/hci/qosviolationevent.h>
       
   175 #include <bluetooth/hci/pagescanrepetitionmodechangeevent.h>
       
   176 #include <bluetooth/hci/inquiryresultwithrssievent.h>
       
   177 #include <bluetooth/hci/readremoteextendedfeaturescompleteevent.h>
       
   178 #include <bluetooth/hci/synchronousconnectioncompleteevent.h>
       
   179 #include <bluetooth/hci/synchronousconnectionchangedevent.h>
       
   180 #include <bluetooth/hci/sniffsubratingevent.h>
       
   181 #include <bluetooth/hci/extendedinquiryresultevent.h>
       
   182 #include <bluetooth/hci/encryptionkeyrefreshcompleteevent.h>
       
   183 #include <bluetooth/hci/iocapabilityrequestevent.h>
       
   184 #include <bluetooth/hci/iocapabilityresponseevent.h>
       
   185 #include <bluetooth/hci/userconfirmationrequestevent.h>
       
   186 #include <bluetooth/hci/userpasskeyrequestevent.h>
       
   187 #include <bluetooth/hci/remoteoobdatarequestevent.h>
       
   188 #include <bluetooth/hci/simplepairingcompleteevent.h>
       
   189 #include <bluetooth/hci/linksupervisiontimeoutchangedevent.h>
       
   190 #include <bluetooth/hci/enhancedflushcompleteevent.h>
       
   191 #include <bluetooth/hci/userpasskeynotificationevent.h>
       
   192 #include <bluetooth/hci/keypressnotificationevent.h>
       
   193 #include <bluetooth/hci/remotehostsupportedfeaturesnotificationevent.h>
       
   194 #include <bluetooth/hci/pagescanmodechangeevent.h>
       
   195 
       
   196 #include "symbiancommandseventsutils.h"
       
   197 
       
   198 
       
   199 
       
   200 #ifdef __FLOG_ACTIVE
       
   201 _LIT8(KLogComponent, LOG_COMPONENT_COMMANDSEVENTS_SYMBIAN);
       
   202 #endif
       
   203 
       
   204 THCIEventBase::THCIEventBase(THCIEventCode aEventCode, TUint8 aParameterTotalLength,
       
   205 			TDes8& aEventData)
       
   206 	: 
       
   207 	iErrorCode(EOK)
       
   208 	{
       
   209 	PutEventCode(aEventCode, aEventData);			// Event code
       
   210 	PutTUint8(aParameterTotalLength, aEventData);	// Parameter_Total_Length (in octets)
       
   211 	
       
   212 	// It is the responsibility of the most derived class to set iEventData
       
   213 	// from aEventData after event-specific data has been added in.	
       
   214 	}
       
   215 
       
   216 EXPORT_C THCIEventBase::THCIEventBase(const TDesC8& aEventData)
       
   217 	: 
       
   218 	iErrorCode(EOK),
       
   219 	iEventData(aEventData)
       
   220 	{
       
   221 	}
       
   222 
       
   223 EXPORT_C THCIEventCode THCIEventBase::EventCode() const
       
   224 	{
       
   225 	return(static_cast<THCIEventCode>(iEventData[0]));	
       
   226 	}
       
   227 	
       
   228 EXPORT_C THCIErrorCode THCIEventBase::ErrorCode() const
       
   229 	{
       
   230 	return(iErrorCode);	
       
   231 	}
       
   232 
       
   233 TInt THCIEventBase::CreateAndSendCommandCompleteEvent(const TDesC8& aEventData,
       
   234 													  MHCICommandEventObserver& aEventObserver)
       
   235 	{
       
   236 	// Switch on Op Code.
       
   237 	__ASSERT_ALWAYS(aEventData.Length() >= KEventCommonFieldsLength + THCICommandCompleteEvent::KCommandCompleteCommonFieldsLength,
       
   238 				PANIC(KSymbianCommandsEventsPanicCat, EInvalidReceivedEventLength));
       
   239 	THCIOpcode opcode((aEventData[4] << 8) | aEventData[3]);
       
   240 
       
   241 	if ((opcode & KVendorDebugOGF) == KVendorDebugOGF)
       
   242 		{
       
   243 		// We don't know anything else about the opcode other than it
       
   244 		// corresponds to a vendor command
       
   245 		TVendorDebugCompleteEvent event(aEventData);
       
   246 		aEventObserver.MhceoEventNotification(event);
       
   247 		return KErrNone;
       
   248 		}
       
   249 
       
   250 	switch(opcode)
       
   251 		{
       
   252 	// Nop
       
   253 
       
   254 	case KNopOpcode:
       
   255 		{
       
   256 		TNopCompleteEvent event(aEventData);
       
   257 		aEventObserver.MhceoEventNotification(event);
       
   258 		}
       
   259 		break;
       
   260 
       
   261 
       
   262 	case KInquiryCancelOpcode:
       
   263 		{
       
   264 		TInquiryCancelCompleteEvent event(aEventData);
       
   265 		aEventObserver.MhceoEventNotification(event);
       
   266 		}
       
   267 		break;
       
   268 		
       
   269 	case KPeriodicInquiryModeOpcode:
       
   270 		{
       
   271 		TPeriodicInquiryModeCompleteEvent event(aEventData);
       
   272 		aEventObserver.MhceoEventNotification(event);
       
   273 		}
       
   274 		break;
       
   275 
       
   276 	case KExitPeriodicInquiryModeOpcode:
       
   277 		{
       
   278 		TExitPeriodicInquiryModeCompleteEvent event(aEventData);
       
   279 		aEventObserver.MhceoEventNotification(event);
       
   280 		}
       
   281 		break;
       
   282 
       
   283 	case KCreateConnectionCancelOpcode:
       
   284 		{
       
   285 		TCreateConnectionCancelCompleteEvent event(aEventData);
       
   286 		aEventObserver.MhceoEventNotification(event);
       
   287 		}
       
   288 		break;
       
   289 
       
   290 	case KLinkKeyRequestReplyOpcode:
       
   291 		{
       
   292 		TLinkKeyRequestReplyCompleteEvent event(aEventData);
       
   293 		aEventObserver.MhceoEventNotification(event);
       
   294 		}
       
   295 		break;
       
   296 
       
   297 	case KLinkKeyRequestReplyNegativeOpcode:
       
   298 		{
       
   299 		TLinkKeyRequestReplyNegativeCompleteEvent event(aEventData);
       
   300 		aEventObserver.MhceoEventNotification(event);
       
   301 		}
       
   302 		break;
       
   303 
       
   304 	case KPINCodeRequestReplyOpcode:
       
   305 		{
       
   306 		TPINCodeRequestReplyCompleteEvent event(aEventData);
       
   307 		aEventObserver.MhceoEventNotification(event);
       
   308 		}
       
   309 		break;
       
   310 
       
   311 	case KPINCodeRequestReplyNegativeOpcode:
       
   312 		{
       
   313 		TPINCodeRequestReplyNegativeCompleteEvent event(aEventData);
       
   314 		aEventObserver.MhceoEventNotification(event);
       
   315 		}
       
   316 		break;
       
   317 
       
   318 	case KRemoteNameRequestCancelOpcode:
       
   319 		{
       
   320 		TRemoteNameRequestCancelCompleteEvent event(aEventData);
       
   321 		aEventObserver.MhceoEventNotification(event);
       
   322 		}
       
   323 		break;
       
   324 
       
   325 	case KReadLMPHandleOpcode:
       
   326 		{
       
   327 		TReadLMPHandleCompleteEvent event(aEventData);
       
   328 		aEventObserver.MhceoEventNotification(event);
       
   329 		}
       
   330 		break;
       
   331 
       
   332 	case KIOCapabilityRequestReplyOpcode:
       
   333 		{
       
   334 		TIOCapabilityRequestReplyCompleteEvent event(aEventData);
       
   335 		aEventObserver.MhceoEventNotification(event);
       
   336 		}
       
   337 		break;
       
   338 
       
   339 	case KUserConfirmationRequestReplyOpcode:
       
   340 		{
       
   341 		TUserConfirmationRequestReplyCompleteEvent event(aEventData);
       
   342 		aEventObserver.MhceoEventNotification(event);
       
   343 		}
       
   344 		break;
       
   345 
       
   346 	case KUserConfirmationRequestNegativeReplyOpcode:
       
   347 		{
       
   348 		TUserConfirmationRequestNegativeReplyCompleteEvent event(aEventData);
       
   349 		aEventObserver.MhceoEventNotification(event);
       
   350 		}
       
   351 		break;
       
   352 
       
   353 	case KUserPasskeyRequestReplyOpcode:
       
   354 		{
       
   355 		TUserPasskeyRequestReplyCompleteEvent event(aEventData);
       
   356 		aEventObserver.MhceoEventNotification(event);
       
   357 		}
       
   358 		break;
       
   359 
       
   360 	case KUserPasskeyRequestNegativeReplyOpcode:
       
   361 		{
       
   362 		TUserPasskeyRequestNegativeReplyCompleteEvent event(aEventData);
       
   363 		aEventObserver.MhceoEventNotification(event);
       
   364 		}
       
   365 		break;
       
   366 
       
   367 	case KRemoteOOBDataRequestReplyOpcode:
       
   368 		{
       
   369 		TRemoteOOBDataRequestReplyCompleteEvent event(aEventData);
       
   370 		aEventObserver.MhceoEventNotification(event);
       
   371 		}
       
   372 		break;
       
   373 
       
   374 	case KRemoteOOBDataRequestNegativeReplyOpcode:
       
   375 		{
       
   376 		TRemoteOOBDataRequestNegativeReplyCompleteEvent event(aEventData);
       
   377 		aEventObserver.MhceoEventNotification(event);
       
   378 		}
       
   379 		break;
       
   380 
       
   381 	case KIOCapabilityRequestNegativeReplyOpcode:
       
   382 		{
       
   383 		TIOCapabilityRequestNegativeReplyCompleteEvent event(aEventData);
       
   384 		aEventObserver.MhceoEventNotification(event);
       
   385 		}
       
   386 		break;
       
   387 
       
   388 
       
   389 	// Link Policy
       
   390 
       
   391 	case KRoleDiscoveryOpcode:
       
   392 		{
       
   393 		TRoleDiscoveryCompleteEvent event(aEventData);
       
   394 		aEventObserver.MhceoEventNotification(event);
       
   395 		}
       
   396 		break;
       
   397 
       
   398 	case KReadLinkPolicySettingsOpcode:
       
   399 		{
       
   400 		TReadLinkPolicySettingsCompleteEvent event(aEventData);
       
   401 		aEventObserver.MhceoEventNotification(event);
       
   402 		}
       
   403 		break;
       
   404 
       
   405 	case KWriteLinkPolicySettingsOpcode:
       
   406 		{
       
   407 		TWriteLinkPolicySettingsCompleteEvent event(aEventData);
       
   408 		aEventObserver.MhceoEventNotification(event);
       
   409 		}
       
   410 		break;
       
   411 
       
   412 	case KReadDefaultLinkPolicySettingsOpcode:
       
   413 		{
       
   414 		TReadDefaultLinkPolicySettingsCompleteEvent event(aEventData);
       
   415 		aEventObserver.MhceoEventNotification(event);
       
   416 		}
       
   417 		break;
       
   418 
       
   419 	case KWriteDefaultLinkPolicySettingsOpcode:
       
   420 		{
       
   421 		TWriteDefaultLinkPolicySettingsCompleteEvent event(aEventData);
       
   422 		aEventObserver.MhceoEventNotification(event);
       
   423 		}
       
   424 		break;
       
   425 		
       
   426 	case KSniffSubratingOpcode:
       
   427 		{
       
   428 		TSniffSubratingCompleteEvent event(aEventData);
       
   429 		aEventObserver.MhceoEventNotification(event);
       
   430 		}
       
   431 		break;
       
   432 
       
   433 
       
   434 	// Controller and Baseband
       
   435 
       
   436 	case KSetEventMaskOpcode:
       
   437 		{
       
   438 		TSetEventMaskCompleteEvent event(aEventData);
       
   439 		aEventObserver.MhceoEventNotification(event);
       
   440 		}
       
   441 		break;
       
   442 
       
   443 	case KResetOpcode:
       
   444 		{
       
   445 		TResetCompleteEvent event(aEventData);
       
   446 		aEventObserver.MhceoEventNotification(event);
       
   447 		}
       
   448 		break;
       
   449 
       
   450 	case KSetEventFilterOpcode:
       
   451 		{
       
   452 		TSetEventFilterCompleteEvent event(aEventData);
       
   453 		aEventObserver.MhceoEventNotification(event);
       
   454 		}
       
   455 		break;
       
   456 
       
   457 	case KFlushOpcode:
       
   458 		{
       
   459 		TFlushCompleteEvent event(aEventData);
       
   460 		aEventObserver.MhceoEventNotification(event);
       
   461 		}
       
   462 		break;
       
   463 
       
   464 	case KReadPINTypeOpcode:
       
   465 		{
       
   466 		TReadPINTypeCompleteEvent event(aEventData);
       
   467 		aEventObserver.MhceoEventNotification(event);
       
   468 		}
       
   469 		break;
       
   470 
       
   471 	case KWritePINTypeOpcode:
       
   472 		{
       
   473 		TWritePINTypeCompleteEvent event(aEventData);
       
   474 		aEventObserver.MhceoEventNotification(event);
       
   475 		}
       
   476 		break;
       
   477 
       
   478 	case KCreateNewUnitKeyOpcode:
       
   479 		{
       
   480 		TCreateNewUnitKeyCompleteEvent event(aEventData);
       
   481 		aEventObserver.MhceoEventNotification(event);
       
   482 		}
       
   483 		break;
       
   484 
       
   485 	case KReadStoredLinkKeyOpcode:
       
   486 		{
       
   487 		TReadStoredLinkKeyCompleteEvent event(aEventData);
       
   488 		aEventObserver.MhceoEventNotification(event);
       
   489 		}
       
   490 		break;
       
   491 
       
   492 	case KWriteStoredLinkKeyOpcode:
       
   493 		{
       
   494 		TWriteStoredLinkKeyCompleteEvent event(aEventData);
       
   495 		aEventObserver.MhceoEventNotification(event);
       
   496 		}
       
   497 		break;
       
   498 
       
   499 	case KDeleteStoredLinkKeyOpcode:
       
   500 		{
       
   501 		TDeleteStoredLinkKeyCompleteEvent event(aEventData);
       
   502 		aEventObserver.MhceoEventNotification(event);
       
   503 		}
       
   504 		break;
       
   505 
       
   506 	case KWriteLocalNameOpcode:
       
   507 		{
       
   508 		TWriteLocalNameCompleteEvent event(aEventData);
       
   509 		aEventObserver.MhceoEventNotification(event);
       
   510 		}
       
   511 		break;
       
   512 
       
   513 	case KReadLocalNameOpcode:
       
   514 		{
       
   515 		TReadLocalNameCompleteEvent event(aEventData);
       
   516 		aEventObserver.MhceoEventNotification(event);
       
   517 		}
       
   518 		break;
       
   519 
       
   520 	case KReadConnectionAcceptTimeoutOpcode:
       
   521 		{
       
   522 		TReadConnectionAcceptTimeoutCompleteEvent event(aEventData);
       
   523 		aEventObserver.MhceoEventNotification(event);
       
   524 		}
       
   525 		break;
       
   526 
       
   527 	case KWriteConnectionAcceptTimeoutOpcode:
       
   528 		{
       
   529 		TWriteConnectionAcceptTimeoutCompleteEvent event(aEventData);
       
   530 		aEventObserver.MhceoEventNotification(event);
       
   531 		}
       
   532 		break;
       
   533 
       
   534 	case KReadPageTimeoutOpcode:
       
   535 		{
       
   536 		TReadPageTimeoutCompleteEvent event(aEventData);
       
   537 		aEventObserver.MhceoEventNotification(event);
       
   538 		}
       
   539 		break;
       
   540 
       
   541 	case KWritePageTimeoutOpcode:
       
   542 		{
       
   543 		TWritePageTimeoutCompleteEvent event(aEventData);
       
   544 		aEventObserver.MhceoEventNotification(event);
       
   545 		}
       
   546 		break;
       
   547 
       
   548 	case KReadScanEnableOpcode:
       
   549 		{
       
   550 		TReadScanEnableCompleteEvent event(aEventData);
       
   551 		aEventObserver.MhceoEventNotification(event);
       
   552 		}
       
   553 		break;
       
   554 
       
   555 	case KWriteScanEnableOpcode:
       
   556 		{
       
   557 		TWriteScanEnableCompleteEvent event(aEventData);
       
   558 		aEventObserver.MhceoEventNotification(event);
       
   559 		}
       
   560 		break;
       
   561 
       
   562 	case KReadPageScanActivityOpcode:
       
   563 		{
       
   564 		TReadPageScanActivityCompleteEvent event(aEventData);
       
   565 		aEventObserver.MhceoEventNotification(event);
       
   566 		}
       
   567 		break;
       
   568 
       
   569 	case KWritePageScanActivityOpcode:
       
   570 		{
       
   571 		TWritePageScanActivityCompleteEvent event(aEventData);
       
   572 		aEventObserver.MhceoEventNotification(event);
       
   573 		}
       
   574 		break;
       
   575 
       
   576 	case KReadInquiryScanActivityOpcode:
       
   577 		{
       
   578 		TReadInquiryScanActivityCompleteEvent event(aEventData);
       
   579 		aEventObserver.MhceoEventNotification(event);
       
   580 		}
       
   581 		break;
       
   582 
       
   583 	case KWriteInquiryScanActivityOpcode:
       
   584 		{
       
   585 		TWriteInquiryScanActivityCompleteEvent event(aEventData);
       
   586 		aEventObserver.MhceoEventNotification(event);
       
   587 		}
       
   588 		break;
       
   589 
       
   590 	case KReadAuthenticationEnableOpcode:
       
   591 		{
       
   592 		TReadAuthenticationEnableCompleteEvent event(aEventData);
       
   593 		aEventObserver.MhceoEventNotification(event);
       
   594 		}
       
   595 		break;
       
   596 
       
   597 	case KWriteAuthenticationEnableOpcode:
       
   598 		{
       
   599 		TWriteAuthenticationEnableCompleteEvent event(aEventData);
       
   600 		aEventObserver.MhceoEventNotification(event);
       
   601 		}
       
   602 		break;
       
   603 
       
   604 	case KReadClassOfDeviceOpcode:
       
   605 		{
       
   606 		TReadClassOfDeviceCompleteEvent event(aEventData);
       
   607 		aEventObserver.MhceoEventNotification(event);
       
   608 		}
       
   609 		break;
       
   610 
       
   611 	case KWriteClassOfDeviceOpcode:
       
   612 		{
       
   613 		TWriteClassOfDeviceCompleteEvent event(aEventData);
       
   614 		aEventObserver.MhceoEventNotification(event);
       
   615 		}
       
   616 		break;
       
   617 
       
   618 	case KReadVoiceSettingOpcode:
       
   619 		{
       
   620 		TReadVoiceSettingCompleteEvent event(aEventData);
       
   621 		aEventObserver.MhceoEventNotification(event);
       
   622 		}
       
   623 		break;
       
   624 
       
   625 	case KWriteVoiceSettingOpcode:
       
   626 		{
       
   627 		TWriteVoiceSettingCompleteEvent event(aEventData);
       
   628 		aEventObserver.MhceoEventNotification(event);
       
   629 		}
       
   630 		break;
       
   631 
       
   632 	case KReadAutomaticFlushTimeoutOpcode:
       
   633 		{
       
   634 		TReadAutomaticFlushTimeoutCompleteEvent event(aEventData);
       
   635 		aEventObserver.MhceoEventNotification(event);
       
   636 		}
       
   637 		break;
       
   638 
       
   639 	case KWriteAutomaticFlushTimeoutOpcode:
       
   640 		{
       
   641 		TWriteAutomaticFlushTimeoutCompleteEvent event(aEventData);
       
   642 		aEventObserver.MhceoEventNotification(event);
       
   643 		}
       
   644 		break;
       
   645 
       
   646 	case KReadNumBroadcastRetransmissionsOpcode:
       
   647 		{
       
   648 		TReadNumBroadcastRetransmissionsCompleteEvent event(aEventData);
       
   649 		aEventObserver.MhceoEventNotification(event);
       
   650 		}
       
   651 		break;
       
   652 
       
   653 	case KWriteNumBroadcastRetransmissionsOpcode:
       
   654 		{
       
   655 		TWriteNumBroadcastRetransmissionsCompleteEvent event(aEventData);
       
   656 		aEventObserver.MhceoEventNotification(event);
       
   657 		}
       
   658 		break;
       
   659 
       
   660 	case KReadHoldModeActivityOpcode:
       
   661 		{
       
   662 		TReadHoldModeActivityCompleteEvent event(aEventData);
       
   663 		aEventObserver.MhceoEventNotification(event);
       
   664 		}
       
   665 		break;
       
   666 
       
   667 	case KWriteHoldModeActivityOpcode:
       
   668 		{
       
   669 		TWriteHoldModeActivityCompleteEvent event(aEventData);
       
   670 		aEventObserver.MhceoEventNotification(event);
       
   671 		}
       
   672 		break;
       
   673 
       
   674 	case KReadTransmitPowerLevelOpcode:
       
   675 		{
       
   676 		TReadTransmitPowerLevelCompleteEvent event(aEventData);
       
   677 		aEventObserver.MhceoEventNotification(event);
       
   678 		}
       
   679 		break;
       
   680 
       
   681 	case KReadSynchronousFlowControlEnableOpcode:
       
   682 		{
       
   683 		TReadSynchronousFlowControlEnableCompleteEvent event(aEventData);
       
   684 		aEventObserver.MhceoEventNotification(event);
       
   685 		}
       
   686 		break;
       
   687 
       
   688 	case KWriteSynchronousFlowControlEnableOpcode:
       
   689 		{
       
   690 		TWriteSynchronousFlowControlEnableCompleteEvent event(aEventData);
       
   691 		aEventObserver.MhceoEventNotification(event);
       
   692 		}
       
   693 		break;
       
   694 
       
   695 	case KSetControllerToHostFlowControlOpcode:
       
   696 		{
       
   697 		TSetControllerToHostFlowControlCompleteEvent event(aEventData);
       
   698 		aEventObserver.MhceoEventNotification(event);
       
   699 		}
       
   700 		break;
       
   701 
       
   702 	case KHostBufferSizeOpcode:
       
   703 		{
       
   704 		THostBufferSizeCompleteEvent event(aEventData);
       
   705 		aEventObserver.MhceoEventNotification(event);
       
   706 		}
       
   707 		break;
       
   708 
       
   709 	case KHostNumberOfCompletedPacketsOpcode:
       
   710 		{
       
   711 		THostNumberOfCompletedPacketsCompleteEvent event(aEventData);
       
   712 		aEventObserver.MhceoEventNotification(event);
       
   713 		}
       
   714 		break;
       
   715 
       
   716 	case KReadLinkSupervisionTimeoutOpcode:
       
   717 		{
       
   718 		TReadLinkSupervisionTimeoutCompleteEvent event(aEventData);
       
   719 		aEventObserver.MhceoEventNotification(event);
       
   720 		}
       
   721 		break;
       
   722 
       
   723 	case KWriteLinkSupervisionTimeoutOpcode:
       
   724 		{
       
   725 		TWriteLinkSupervisionTimeoutCompleteEvent event(aEventData);
       
   726 		aEventObserver.MhceoEventNotification(event);
       
   727 		}
       
   728 		break;
       
   729 
       
   730 	case KReadNumberOfSupportedIACOpcode:
       
   731 		{
       
   732 		TReadNumberOfSupportedIACCompleteEvent event(aEventData);
       
   733 		aEventObserver.MhceoEventNotification(event);
       
   734 		}
       
   735 		break;
       
   736 
       
   737 	case KReadCurrentIACLAPOpcode:
       
   738 		{
       
   739 		TReadCurrentIACLAPCompleteEvent event(aEventData);
       
   740 		aEventObserver.MhceoEventNotification(event);
       
   741 		}
       
   742 		break;
       
   743 
       
   744 	case KWriteCurrentIACLAPOpcode:
       
   745 		{
       
   746 		TWriteCurrentIACLAPCompleteEvent event(aEventData);
       
   747 		aEventObserver.MhceoEventNotification(event);
       
   748 		}
       
   749 		break;
       
   750 
       
   751 	case KSetAFHHostChannelClassificationOpcode:
       
   752 		{
       
   753 		TSetAFHHostChannelClassificationCompleteEvent event(aEventData);
       
   754 		aEventObserver.MhceoEventNotification(event);
       
   755 		}
       
   756 		break;
       
   757 
       
   758 	case KReadInquiryScanTypeOpcode:
       
   759 		{
       
   760 		TReadInquiryScanTypeCompleteEvent event(aEventData);
       
   761 		aEventObserver.MhceoEventNotification(event);
       
   762 		}
       
   763 		break;
       
   764 
       
   765 	case KWriteInquiryScanTypeOpcode:
       
   766 		{
       
   767 		TWriteInquiryScanTypeCompleteEvent event(aEventData);
       
   768 		aEventObserver.MhceoEventNotification(event);
       
   769 		}
       
   770 		break;
       
   771 
       
   772 	case KReadInquiryModeOpcode:
       
   773 		{
       
   774 		TReadInquiryModeCompleteEvent event(aEventData);
       
   775 		aEventObserver.MhceoEventNotification(event);
       
   776 		}
       
   777 		break;
       
   778 
       
   779 	case KWriteInquiryModeOpcode:
       
   780 		{
       
   781 		TWriteInquiryModeCompleteEvent event(aEventData);
       
   782 		aEventObserver.MhceoEventNotification(event);
       
   783 		}
       
   784 		break;
       
   785 
       
   786 	case KReadPageScanTypeOpcode:
       
   787 		{
       
   788 		TReadPageScanTypeCompleteEvent event(aEventData);
       
   789 		aEventObserver.MhceoEventNotification(event);
       
   790 		}
       
   791 		break;
       
   792 
       
   793 	case KWritePageScanTypeOpcode:
       
   794 		{
       
   795 		TWritePageScanTypeCompleteEvent event(aEventData);
       
   796 		aEventObserver.MhceoEventNotification(event);
       
   797 		}
       
   798 		break;
       
   799 
       
   800 	case KReadAFHChannelAssessmentModeOpcode:
       
   801 		{
       
   802 		TReadAFHChannelAssessmentModeCompleteEvent event(aEventData);
       
   803 		aEventObserver.MhceoEventNotification(event);
       
   804 		}
       
   805 		break;
       
   806 
       
   807 	case KWriteAFHChannelAssessmentModeOpcode:
       
   808 		{
       
   809 		TWriteAFHChannelAssessmentModeCompleteEvent event(aEventData);
       
   810 		aEventObserver.MhceoEventNotification(event);
       
   811 		}
       
   812 		break;
       
   813 
       
   814 	case KReadExtendedInquiryResponseOpcode:
       
   815 		{
       
   816 		TReadExtendedInquiryResponseCompleteEvent event(aEventData);
       
   817 		aEventObserver.MhceoEventNotification(event);
       
   818 		}
       
   819 		break;
       
   820 
       
   821 	case KWriteExtendedInquiryResponseOpcode:
       
   822 		{
       
   823 		TWriteExtendedInquiryResponseCompleteEvent event(aEventData);
       
   824 		aEventObserver.MhceoEventNotification(event);
       
   825 		}
       
   826 		break;
       
   827 
       
   828 	case KReadSimplePairingModeOpcode:
       
   829 		{
       
   830 		TReadSimplePairingModeCompleteEvent event(aEventData);
       
   831 		aEventObserver.MhceoEventNotification(event);
       
   832 		}
       
   833 		break;
       
   834 
       
   835 	case KWriteSimplePairingModeOpcode:
       
   836 		{
       
   837 		TWriteSimplePairingModeCompleteEvent event(aEventData);
       
   838 		aEventObserver.MhceoEventNotification(event);
       
   839 		}
       
   840 		break;
       
   841 
       
   842 	case KReadLocalOOBDataOpcode:
       
   843 		{
       
   844 		TReadLocalOOBDataCompleteEvent event(aEventData);
       
   845 		aEventObserver.MhceoEventNotification(event);
       
   846 		}
       
   847 		break;
       
   848 
       
   849 	case KReadInquiryResponseTransmitPowerLevelOpcode:
       
   850 		{
       
   851 		TReadInquiryResponseTransmitPowerLevelCompleteEvent event(aEventData);
       
   852 		aEventObserver.MhceoEventNotification(event);
       
   853 		}
       
   854 		break;
       
   855 
       
   856 	case KWriteInquiryResponseTransmitPowerLevelOpcode:
       
   857 		{
       
   858 		TWriteInquiryResponseTransmitPowerLevelCompleteEvent event(aEventData);
       
   859 		aEventObserver.MhceoEventNotification(event);
       
   860 		}
       
   861 		break;
       
   862 
       
   863 	case KSendKeypressNotificationOpcode:
       
   864 		{
       
   865 		TSendKeypressNotificationCompleteEvent event(aEventData);
       
   866 		aEventObserver.MhceoEventNotification(event);
       
   867 		}
       
   868 		break;
       
   869 		
       
   870 	case KReadDefaultErroneousDataReportingOpcode:
       
   871 		{
       
   872 		TReadDefaultErroneousDataReportingCompleteEvent event(aEventData);
       
   873 		aEventObserver.MhceoEventNotification(event);
       
   874 		}
       
   875 		break;
       
   876 		
       
   877 	case KWriteDefaultErroneousDataReportingOpcode:
       
   878 		{
       
   879 		TWriteDefaultErroneousDataReportingCompleteEvent event(aEventData);
       
   880 		aEventObserver.MhceoEventNotification(event);
       
   881 		}
       
   882 		break;
       
   883 
       
   884 
       
   885 	// Informational Parameters
       
   886 
       
   887 	case KReadLocalVersionInfoOpcode:
       
   888 		{
       
   889 		TReadLocalVersionInfoCompleteEvent event(aEventData);
       
   890 		aEventObserver.MhceoEventNotification(event);
       
   891 		}
       
   892 		break;
       
   893 
       
   894 	case KReadLocalSupportedCommandsOpcode:
       
   895 		{
       
   896 		TReadLocalSupportedCommandsCompleteEvent event(aEventData);
       
   897 		aEventObserver.MhceoEventNotification(event);
       
   898 		}
       
   899 		break;
       
   900 
       
   901 	case KReadLocalSupportedFeaturesOpcode:
       
   902 		{
       
   903 		TReadLocalSupportedFeaturesCompleteEvent event(aEventData);
       
   904 		aEventObserver.MhceoEventNotification(event);
       
   905 		}
       
   906 		break;
       
   907 
       
   908 	case KReadLocalExtendedFeaturesOpcode:
       
   909 		{
       
   910 		TReadLocalExtendedFeaturesCompleteEvent event(aEventData);
       
   911 		aEventObserver.MhceoEventNotification(event);
       
   912 		}
       
   913 		break;
       
   914 
       
   915 	case KReadBufferSizeOpcode:
       
   916 		{
       
   917 		TReadBufferSizeCompleteEvent event(aEventData);
       
   918 		aEventObserver.MhceoEventNotification(event);
       
   919 		}
       
   920 		break;
       
   921 
       
   922 	case KReadBdaddrOpcode:
       
   923 		{
       
   924 		TReadBdaddrCompleteEvent event(aEventData);
       
   925 		aEventObserver.MhceoEventNotification(event);
       
   926 		}
       
   927 		break;
       
   928 		
       
   929 	
       
   930 	// Status Parameters
       
   931 
       
   932 	case KReadFailedContactCounterOpcode:
       
   933 		{
       
   934 		TReadFailedContactCounterCompleteEvent event(aEventData);
       
   935 		aEventObserver.MhceoEventNotification(event);
       
   936 		}
       
   937 		break;
       
   938 
       
   939 	case KResetFailedContactCounterOpcode:
       
   940 		{
       
   941 		TResetFailedContactCounterCompleteEvent event(aEventData);
       
   942 		aEventObserver.MhceoEventNotification(event);
       
   943 		}
       
   944 		break;
       
   945 
       
   946 	case KReadLinkQualityOpcode:
       
   947 		{
       
   948 		TReadLinkQualityCompleteEvent event(aEventData);
       
   949 		aEventObserver.MhceoEventNotification(event);
       
   950 		}
       
   951 		break;
       
   952 
       
   953 	case KReadRSSIOpcode:
       
   954 		{
       
   955 		TReadRSSICompleteEvent event(aEventData);
       
   956 		aEventObserver.MhceoEventNotification(event);
       
   957 		}
       
   958 		break;
       
   959 
       
   960 	case KReadAFHChannelMapOpcode:
       
   961 		{
       
   962 		TReadAFHChannelMapCompleteEvent event(aEventData);
       
   963 		aEventObserver.MhceoEventNotification(event);
       
   964 		}
       
   965 		break;
       
   966 
       
   967 	case KReadClockOpcode:
       
   968 		{
       
   969 		TReadClockCompleteEvent event(aEventData);
       
   970 		aEventObserver.MhceoEventNotification(event);
       
   971 		}
       
   972 		break;
       
   973 	
       
   974 
       
   975 	// Testing Commmands
       
   976 
       
   977 	case KReadLoopbackModeOpcode:
       
   978 		{
       
   979 		TReadLoopbackModeCompleteEvent event(aEventData);
       
   980 		aEventObserver.MhceoEventNotification(event);
       
   981 		}
       
   982 		break;
       
   983 
       
   984 	case KWriteLoopbackModeOpcode:
       
   985 		{
       
   986 		TWriteLoopbackModeCompleteEvent event(aEventData);
       
   987 		aEventObserver.MhceoEventNotification(event);
       
   988 		}
       
   989 		break;
       
   990 
       
   991 	case KEnableDeviceUnderTestModeOpcode:
       
   992 		{
       
   993 		TEnableDeviceUnderTestModeCompleteEvent event(aEventData);
       
   994 		aEventObserver.MhceoEventNotification(event);
       
   995 		}
       
   996 		break;
       
   997 
       
   998 	case KWriteSimplePairingDebugModeOpcode:
       
   999 		{
       
  1000 		TWriteSimplePairingDebugModeCompleteEvent event(aEventData);
       
  1001 		aEventObserver.MhceoEventNotification(event);
       
  1002 		}
       
  1003 		break;
       
  1004 		
       
  1005 	// Deprecated (in the Bluetooth specification)
       
  1006 
       
  1007     case KReadPageScanPeriodOpcode:
       
  1008 		{
       
  1009 		TReadPageScanPeriodCompleteEvent event(aEventData);
       
  1010 		aEventObserver.MhceoEventNotification(event);
       
  1011 		}
       
  1012 		break;
       
  1013 
       
  1014 	case KWritePageScanPeriodOpcode:
       
  1015 		{
       
  1016 		TWritePageScanPeriodCompleteEvent event(aEventData);
       
  1017 		aEventObserver.MhceoEventNotification(event);
       
  1018 		}
       
  1019 		break;
       
  1020 
       
  1021 	case KReadEncryptionModeOpcode:
       
  1022 		{
       
  1023 		TReadEncryptionModeCompleteEvent event(aEventData);
       
  1024 		aEventObserver.MhceoEventNotification(event);
       
  1025 		}
       
  1026 		break;
       
  1027 
       
  1028 	case KWriteEncryptionModeOpcode:
       
  1029 		{
       
  1030 		TWriteEncryptionModeCompleteEvent event(aEventData);
       
  1031 		aEventObserver.MhceoEventNotification(event);
       
  1032 		}
       
  1033 		break;
       
  1034 
       
  1035 	// Unknown command complete event.
       
  1036 	default:
       
  1037 		return KErrNotFound;
       
  1038 		};
       
  1039 
       
  1040 	return KErrNone;
       
  1041 	}
       
  1042 
       
  1043 EXPORT_C /*static*/ TInt THCIEventBase::CreateAndSendEvent(const TDesC8& aEventData,
       
  1044 														   MHCICommandEventObserver& aEventObserver,
       
  1045 														   MHCIDataEventObserver& aDataEventObserver,
       
  1046 														   TAny* /*aObserver*/)
       
  1047 	{
       
  1048 	TInt rerr = KErrNone;
       
  1049 
       
  1050 	if(aEventData.Length() >= KEventCommonFieldsLength 
       
  1051 	&& aEventData.Length() >= KEventCommonFieldsLength + aEventData[KTotalParameterLengthOffset])
       
  1052 		{
       
  1053 		// Switch on the event code.
       
  1054 		switch(aEventData[KEventCodeOffset])
       
  1055 			{
       
  1056 			case EInquiryCompleteEvent:
       
  1057 				{
       
  1058 				TInquiryCompleteEvent event(aEventData);
       
  1059 				aEventObserver.MhceoEventNotification(event);
       
  1060 				}
       
  1061 				break;
       
  1062 							
       
  1063 			case EInquiryResultEvent:
       
  1064 				{
       
  1065 				TInquiryResultEvent event(aEventData);
       
  1066 				aEventObserver.MhceoEventNotification(event);
       
  1067 				}
       
  1068 				break;
       
  1069 				
       
  1070 			case EConnectionCompleteEvent:
       
  1071 				{
       
  1072 				TConnectionCompleteEvent event(aEventData);
       
  1073 				aEventObserver.MhceoEventNotification(event);
       
  1074 				}
       
  1075 				break;
       
  1076 							
       
  1077 			case EConnectionRequestEvent:				
       
  1078 				{
       
  1079 				TConnectionRequestEvent event(aEventData);
       
  1080 				aEventObserver.MhceoEventNotification(event);
       
  1081 				}
       
  1082 				break;
       
  1083 
       
  1084 			case EDisconnectionCompleteEvent:
       
  1085 				{
       
  1086 				TDisconnectionCompleteEvent event(aEventData);
       
  1087 				aEventObserver.MhceoEventNotification(event);
       
  1088 				}
       
  1089 				break;
       
  1090 
       
  1091 			case EAuthenticationCompleteEvent:
       
  1092 				{
       
  1093 				TAuthenticationCompleteEvent event(aEventData);
       
  1094 				aEventObserver.MhceoEventNotification(event);				
       
  1095 				}
       
  1096 				break;
       
  1097 					
       
  1098 			case ERemoteNameReqCompleteEvent:
       
  1099 				{
       
  1100 				TRemoteNameReqCompleteEvent event(aEventData);
       
  1101 				aEventObserver.MhceoEventNotification(event);				
       
  1102 				}
       
  1103 				break;
       
  1104 							
       
  1105 			case EEncryptionChangeEvent:
       
  1106 				{
       
  1107 				TEncryptionChangeEvent event(aEventData);
       
  1108 				aEventObserver.MhceoEventNotification(event);				
       
  1109 				}
       
  1110 				break;
       
  1111 							
       
  1112 			case EChangeLinkKeyEvent:					
       
  1113 				{
       
  1114 				TChangeLinkKeyEvent event(aEventData);
       
  1115 				aEventObserver.MhceoEventNotification(event);				
       
  1116 				}
       
  1117 				break;
       
  1118 
       
  1119 			case EMasterLinkKeyEvent:					
       
  1120 				{
       
  1121 				TMasterLinkKeyEvent event(aEventData);
       
  1122 				aEventObserver.MhceoEventNotification(event);				
       
  1123 				}
       
  1124 				break;
       
  1125 
       
  1126 			case EReadRemSuppFeatCompleteEvent:		
       
  1127 				{
       
  1128 				TReadRemSuppFeatCompleteEvent event(aEventData);
       
  1129 				aEventObserver.MhceoEventNotification(event);				
       
  1130 				}
       
  1131 				break;
       
  1132 
       
  1133 			case EReadRemVerInfoCompleteEvent:		
       
  1134 				{
       
  1135 				TReadRemVerInfoCompleteEvent event(aEventData);
       
  1136 				aEventObserver.MhceoEventNotification(event);				
       
  1137 				}
       
  1138 				break;
       
  1139 
       
  1140 			case EQOSSetupCompleteEvent:
       
  1141 				{								
       
  1142 				TQOSSetupCompleteEvent event(aEventData);
       
  1143 				aEventObserver.MhceoEventNotification(event);
       
  1144 				}
       
  1145 				break;
       
  1146 				
       
  1147 			case ECommandCompleteEvent:				
       
  1148 				{
       
  1149 				rerr = CreateAndSendCommandCompleteEvent(aEventData,
       
  1150 														 aEventObserver);
       
  1151 				}
       
  1152 				break;
       
  1153 				
       
  1154 			case ECommandStatusEvent:
       
  1155 				{
       
  1156 				TCommandStatusEvent event(aEventData);
       
  1157 				aEventObserver.MhceoEventNotification(event);
       
  1158 				}
       
  1159 				break;
       
  1160 									
       
  1161 			case EHardwareErrorEvent:					
       
  1162 				{
       
  1163 				THardwareErrorEvent event(aEventData);
       
  1164 				aEventObserver.MhceoEventNotification(event);				
       
  1165 				}
       
  1166 				break;
       
  1167 
       
  1168 			case EFlushOccurredEvent:					
       
  1169 				{
       
  1170 				TFlushOccurredEvent event(aEventData);
       
  1171 				aDataEventObserver.MhdeoEventNotification(event);				
       
  1172 				}
       
  1173 				break;
       
  1174 
       
  1175 			case ERoleChangeEvent:					
       
  1176 				{
       
  1177 				TRoleChangeEvent event(aEventData);
       
  1178 				aEventObserver.MhceoEventNotification(event);				
       
  1179 				}
       
  1180 				break;
       
  1181 
       
  1182 			case ENumberOfCompletedPacketsEvent:		
       
  1183 				{
       
  1184 				TNumberOfCompletedPacketsEvent event(aEventData);
       
  1185 				aDataEventObserver.MhdeoEventNotification(event);				
       
  1186 				}
       
  1187 				break;
       
  1188 
       
  1189 			case EModeChangeEvent:					
       
  1190 				{
       
  1191 				TModeChangeEvent event(aEventData);
       
  1192 				aEventObserver.MhceoEventNotification(event);				
       
  1193 				}
       
  1194 				break;
       
  1195 
       
  1196 			case EReturnLinkKeysEvent:				
       
  1197 				{
       
  1198 				TReturnLinkKeysEvent event(aEventData);
       
  1199 				aEventObserver.MhceoEventNotification(event);				
       
  1200 				}
       
  1201 				break;
       
  1202 
       
  1203 			case EPINCodeRequestEvent:
       
  1204 				{
       
  1205 				TPINCodeRequestEvent event(aEventData);
       
  1206 				aEventObserver.MhceoEventNotification(event);
       
  1207 				}
       
  1208 				break;
       
  1209 				
       
  1210 			case ELinkKeyRequestEvent:
       
  1211 				{
       
  1212 				TLinkKeyRequestEvent event(aEventData);
       
  1213 				aEventObserver.MhceoEventNotification(event);
       
  1214 				}
       
  1215 				break;
       
  1216 				
       
  1217 			case ELinkKeyNotificationEvent:			
       
  1218 				{
       
  1219 				TLinkKeyNotificationEvent event(aEventData);
       
  1220 				aEventObserver.MhceoEventNotification(event);				
       
  1221 				}
       
  1222 				break;
       
  1223 
       
  1224 			case ELoopbackCommandEvent:				
       
  1225 				{
       
  1226 				TLoopbackCommandEvent event(aEventData);
       
  1227 				aEventObserver.MhceoEventNotification(event);				
       
  1228 				}
       
  1229 				break;
       
  1230 
       
  1231 			case EDataBufferOverflowEvent:			
       
  1232 				{
       
  1233 				TDataBufferOverflowEvent event(aEventData);
       
  1234 				aDataEventObserver.MhdeoEventNotification(event);				
       
  1235 				}
       
  1236 				break;
       
  1237 
       
  1238 			case EMaxSlotsChangeEvent:				
       
  1239 				{
       
  1240 				TMaxSlotsChangeEvent event(aEventData);
       
  1241 				aEventObserver.MhceoEventNotification(event);				
       
  1242 				}
       
  1243 				break;
       
  1244 
       
  1245 			case EReadClockOffsetEvent:				
       
  1246 				{
       
  1247 				TReadClockOffsetEvent event(aEventData);
       
  1248 				aEventObserver.MhceoEventNotification(event);				
       
  1249 				}
       
  1250 				break;
       
  1251 
       
  1252 			case EConnectionPacketTypeChangedEvent:	
       
  1253 				{
       
  1254 				TConnectionPacketTypeChangedEvent event(aEventData);
       
  1255 				aEventObserver.MhceoEventNotification(event);				
       
  1256 				}
       
  1257 				break;
       
  1258 
       
  1259 			case EQOSViolationEvent:					
       
  1260 				{
       
  1261 				TQOSViolationEvent event(aEventData);
       
  1262 				aDataEventObserver.MhdeoEventNotification(event);				
       
  1263 				}
       
  1264 				break;
       
  1265 
       
  1266 			case EPageScanRepetitionModeChangeEvent:	
       
  1267 				{
       
  1268 				TPageScanRepetitionModeChangeEvent event(aEventData);
       
  1269 				aEventObserver.MhceoEventNotification(event);				
       
  1270 				}
       
  1271 				break;
       
  1272 
       
  1273 			case EFlowSpecificationCompleteEvent:
       
  1274 				{
       
  1275 				TFlowSpecificationCompleteEvent event(aEventData);
       
  1276 				aEventObserver.MhceoEventNotification(event);				
       
  1277 				}
       
  1278 				break;
       
  1279 
       
  1280 			case EInquiryResultwithRSSIEvent:
       
  1281 				{
       
  1282 				TInquiryResultwithRSSIEvent event(aEventData);
       
  1283 				aEventObserver.MhceoEventNotification(event);				
       
  1284 				}
       
  1285 				break;
       
  1286 
       
  1287 			case EReadRemoteExtendedFeaturesCompleteEvent: 
       
  1288 				{
       
  1289 				TReadRemoteExtendedFeaturesCompleteEvent event(aEventData);
       
  1290 				aEventObserver.MhceoEventNotification(event);				
       
  1291 				}
       
  1292 				break;
       
  1293 
       
  1294 			case ESynchronousConnectionCompleteEvent:	
       
  1295 				{
       
  1296 				TSynchronousConnectionCompleteEvent event(aEventData);
       
  1297 				aEventObserver.MhceoEventNotification(event);				
       
  1298 				}
       
  1299 				break;
       
  1300 
       
  1301 			case ESynchronousConnectionChangedEvent:
       
  1302 				{
       
  1303 				TSynchronousConnectionChangedEvent event(aEventData);
       
  1304 				aEventObserver.MhceoEventNotification(event);				
       
  1305 				}
       
  1306 				break;
       
  1307 				
       
  1308 			case ESniffSubratingEvent:
       
  1309 				{
       
  1310 				TSniffSubratingEvent event(aEventData);
       
  1311 				aEventObserver.MhceoEventNotification(event);
       
  1312 				}
       
  1313 				break;
       
  1314 
       
  1315 			case EExtendedInquiryResultEvent:	
       
  1316 				{
       
  1317 				TExtendedInquiryResultEvent event(aEventData);
       
  1318 				aEventObserver.MhceoEventNotification(event);				
       
  1319 				}
       
  1320 				break;
       
  1321 
       
  1322 			case EEncryptionKeyRefreshCompleteEvent:
       
  1323 				{
       
  1324 				TEncryptionKeyRefreshCompleteEvent event(aEventData);
       
  1325 				aEventObserver.MhceoEventNotification(event);
       
  1326 				}
       
  1327 				break;
       
  1328 
       
  1329 			case EIOCapabilityRequestEvent:
       
  1330 				{
       
  1331 				TIOCapabilityRequestEvent event(aEventData);
       
  1332 				aEventObserver.MhceoEventNotification(event);				
       
  1333 				}
       
  1334 				break;
       
  1335 
       
  1336 			case EIOCapabilityResponseEvent:
       
  1337 				{
       
  1338 				TIOCapabilityResponseEvent event(aEventData);
       
  1339 				aEventObserver.MhceoEventNotification(event);				
       
  1340 				}
       
  1341 				break;
       
  1342 
       
  1343 			case EUserConfirmationRequestEvent:	
       
  1344 				{
       
  1345 				TUserConfirmationRequestEvent event(aEventData);
       
  1346 				aEventObserver.MhceoEventNotification(event);				
       
  1347 				}
       
  1348 				break;
       
  1349 
       
  1350 			case EUserPasskeyRequestEvent:	
       
  1351 				{
       
  1352 				TUserPasskeyRequestEvent event(aEventData);
       
  1353 				aEventObserver.MhceoEventNotification(event);				
       
  1354 				}
       
  1355 				break;
       
  1356 
       
  1357 			case ERemoteOOBDataRequestEvent:	
       
  1358 				{
       
  1359 				TRemoteOOBDataRequestEvent event(aEventData);
       
  1360 				aEventObserver.MhceoEventNotification(event);				
       
  1361 				}
       
  1362 				break;
       
  1363 
       
  1364 			case ESimplePairingCompleteEvent:	
       
  1365 				{
       
  1366 				TSimplePairingCompleteEvent event(aEventData);
       
  1367 				aEventObserver.MhceoEventNotification(event);				
       
  1368 				}
       
  1369 				break;
       
  1370 				
       
  1371 			case ELinkSupervisionTimeoutChangedEvent:
       
  1372 				{
       
  1373 				TLinkSupervisionTimeoutChangedEvent event(aEventData);
       
  1374 				aEventObserver.MhceoEventNotification(event);
       
  1375 				}
       
  1376 				break;
       
  1377 
       
  1378 			case EEnhancedFlushCompleteEvent:
       
  1379 				{
       
  1380 				TEnhancedFlushCompleteEvent event(aEventData);
       
  1381 				aEventObserver.MhceoEventNotification(event);
       
  1382 				}
       
  1383 				break;
       
  1384 
       
  1385 			case EUserPasskeyNotificationEvent:	
       
  1386 				{
       
  1387 				TUserPasskeyNotificationEvent event(aEventData);
       
  1388 				aEventObserver.MhceoEventNotification(event);				
       
  1389 				}
       
  1390 				break;
       
  1391 
       
  1392 			case EKeypressNotificationEvent:	
       
  1393 				{
       
  1394 				TKeypressNotificationEvent event(aEventData);
       
  1395 				aEventObserver.MhceoEventNotification(event);				
       
  1396 				}
       
  1397 				break;
       
  1398 
       
  1399 			case ERemoteHostSupportedFeaturesNotificationEvent:	
       
  1400 				{
       
  1401 				TRemoteHostSupportedFeaturesNotificationEvent event(aEventData);
       
  1402 				aEventObserver.MhceoEventNotification(event);				
       
  1403 				}
       
  1404 				break;
       
  1405 
       
  1406 		// Deprecated (in the Bluetooth specification) events
       
  1407 			case EPageScanModeChangeEvent:
       
  1408 				{
       
  1409 				TPageScanModeChangeEvent event(aEventData);
       
  1410 				aEventObserver.MhceoEventNotification(event);
       
  1411 				}
       
  1412 				break;
       
  1413 
       
  1414 		// Special case events
       
  1415 			case EVendorDebugEvent:
       
  1416 				{
       
  1417 				TVendorDebugEvent event(aEventData);
       
  1418 				aEventObserver.MhceoEventNotification(event);
       
  1419 				}
       
  1420 				break;
       
  1421 
       
  1422 			case EBTLogoTestingEvent:
       
  1423 				break;
       
  1424 
       
  1425 		// Unknown event
       
  1426 			default:
       
  1427 				rerr = KErrUnknown;
       
  1428 				break;			
       
  1429 			};
       
  1430 		}
       
  1431 	else
       
  1432 		{
       
  1433 		rerr = KErrCorrupt;
       
  1434 		}
       
  1435 	return rerr;		
       
  1436 	}
       
  1437 
       
  1438 EXPORT_C TUint8 THCIEventBase::AsTUint8(TInt aOffset) const
       
  1439 	{
       
  1440 	return iEventData[aOffset];
       
  1441 	}
       
  1442 	
       
  1443 EXPORT_C TUint8 THCIEventBase::AsTUint8(TInt aOffset, TInt aArrayBlockSize, TInt aIndex) const
       
  1444 	{
       
  1445 	return AsTUint8(aOffset + (aIndex * aArrayBlockSize));	
       
  1446 	}
       
  1447 
       
  1448 EXPORT_C TUint16 THCIEventBase::AsTUint16(TInt aOffset) const
       
  1449 	{
       
  1450 	return TUint16((iEventData[aOffset + 1] << 8) + iEventData[aOffset]);
       
  1451 	}
       
  1452 	
       
  1453 EXPORT_C TUint16 THCIEventBase::AsTUint16(TInt aOffset, TInt aArrayBlockSize, TInt aIndex) const
       
  1454 	{
       
  1455 	return AsTUint16(aOffset + (aIndex * aArrayBlockSize));	
       
  1456 	}
       
  1457 
       
  1458 EXPORT_C TUint32 THCIEventBase::AsTUint32(TInt aOffset, TUint8 aSize) const
       
  1459 	{
       
  1460 	TUint32 value = 0;
       
  1461 
       
  1462 	switch (aSize)
       
  1463 		{
       
  1464 	case 4:
       
  1465 		value = iEventData[aOffset + 3] << 24; // Fallthrough
       
  1466 	case 3:
       
  1467 		value += iEventData[aOffset + 2] << 16; 
       
  1468 		value += iEventData[aOffset + 1] << 8;
       
  1469 		value += iEventData[aOffset];
       
  1470 		break;
       
  1471 	default:
       
  1472 		PANIC(KSymbianCommandsEventsPanicCat, EParameterOutOfBounds);
       
  1473 		break;
       
  1474 		}
       
  1475 
       
  1476 	return value;
       
  1477 	}
       
  1478 
       
  1479 EXPORT_C TUint32 THCIEventBase::AsTUint32(TInt aOffset, TInt aArrayBlockSize, TInt aIndex, TUint8 aSize) const
       
  1480 	{
       
  1481 	return AsTUint32(aOffset + (aIndex * aArrayBlockSize), aSize);	
       
  1482 	}
       
  1483 
       
  1484 EXPORT_C TUint64 THCIEventBase::AsTUint64(TInt aOffset) const
       
  1485 	{
       
  1486 	TUint tmp = 0;
       
  1487 	tmp = AsTUint32(aOffset, 4);
       
  1488 	TUint64 value = tmp;
       
  1489 	tmp = AsTUint32(aOffset + 4, 4);
       
  1490 	value |= static_cast<TUint64>(tmp) << 32;
       
  1491 	return value;
       
  1492 	}
       
  1493 
       
  1494 EXPORT_C TUint64 THCIEventBase::AsTUint64(TInt aOffset, TInt aArrayBlockSize, TInt aIndex) const
       
  1495 	{
       
  1496 	return AsTUint64(aOffset + (aIndex * aArrayBlockSize));	
       
  1497 	}
       
  1498 
       
  1499 EXPORT_C TPtrC8 THCIEventBase::AsString(TInt aOffset) const
       
  1500 	{
       
  1501 	return TPtrC8(iEventData.Right(iEventData.Length() - aOffset));
       
  1502 	}
       
  1503 	
       
  1504 EXPORT_C TPtrC8 THCIEventBase::AsNullTerminatedString(TInt aOffset) const
       
  1505 	{
       
  1506 	TPtrC8 fullPtr(iEventData.Right(iEventData.Length() - aOffset));
       
  1507 	TPtrC8 retPtr(fullPtr.Ptr());
       
  1508 	__ASSERT_ALWAYS(retPtr.Length() <= fullPtr.Length(), PANIC(KSymbianCommandsEventsPanicCat, ENullTerminatedStringWasNotNullTerminated));
       
  1509 	return retPtr;
       
  1510 	}
       
  1511 
       
  1512 EXPORT_C TPtrC8 THCIEventBase::AsBluetoothDeviceName(TInt aOffset) const
       
  1513 	{
       
  1514 	TPtrC8 fullPtr(iEventData.Right(iEventData.Length() - aOffset));
       
  1515 	TInt len = 0;
       
  1516 	const TUint8* pS = fullPtr.Ptr();
       
  1517 	while(*pS && len < KHCILocalDeviceNameMaxLength)
       
  1518 		{
       
  1519 		pS++;
       
  1520 		len++;
       
  1521 		}
       
  1522 	TPtrC8 retPtr(fullPtr.Left(len));
       
  1523 	__ASSERT_ALWAYS(retPtr.Length() <= fullPtr.Length(), PANIC(KSymbianCommandsEventsPanicCat, ENullTerminatedStringWasNotNullTerminated));
       
  1524 	return retPtr;
       
  1525 	}
       
  1526 
       
  1527 EXPORT_C TBTDevAddr THCIEventBase::AsDevAddr(TInt aOffset) const
       
  1528 	{
       
  1529 	TBTDevAddr addr;
       
  1530 	for (TInt i=0;i<KBTMaxDevAddrSize;i++)
       
  1531 		{
       
  1532 		addr[KBTMaxDevAddrSize-1-i] = iEventData[aOffset + i];	// reading bdaddr from iEventBufPtr
       
  1533 		}
       
  1534 
       
  1535 	return addr;
       
  1536 	}
       
  1537 	
       
  1538 EXPORT_C TBTDevAddr THCIEventBase::AsDevAddr(TInt aOffset, TInt aArrayBlockSize, TInt aIndex) const
       
  1539 	{
       
  1540 	return AsDevAddr(aOffset + (aIndex * aArrayBlockSize));	
       
  1541 	}
       
  1542 
       
  1543 EXPORT_C TBluetoothSimplePairingHash THCIEventBase::AsSimplePairingHash(TInt aOffset) const
       
  1544 	{
       
  1545 	TBluetoothSimplePairingHash retHash;
       
  1546 	retHash.SetMax();
       
  1547 	for (TInt i=0;i<KBluetoothSimplePairingHashSize;i++)
       
  1548 		{
       
  1549 		retHash[KBluetoothSimplePairingHashSize-1-i] = iEventData[aOffset + i];
       
  1550 		}
       
  1551 
       
  1552 	return retHash;
       
  1553 	}
       
  1554 
       
  1555 EXPORT_C TBluetoothSimplePairingRandomizer THCIEventBase::AsSimplePairingRandomizer(TInt aOffset) const
       
  1556 	{
       
  1557 	TBluetoothSimplePairingRandomizer retRandomizer;
       
  1558 	retRandomizer.SetMax();
       
  1559 	for (TInt i=0;i<KBluetoothSimplePairingRandomizerSize;i++)
       
  1560 		{
       
  1561 		retRandomizer[KBluetoothSimplePairingRandomizerSize-1-i] = iEventData[aOffset + i];
       
  1562 		}
       
  1563 
       
  1564 	return retRandomizer;
       
  1565 	}
       
  1566 
       
  1567 EXPORT_C TBTLinkKey THCIEventBase::AsLinkKey(TInt aOffset) const
       
  1568 	{
       
  1569 	TBTLinkKey retKey;
       
  1570 	TPtr8 key(retKey().iLinkKey, KHCILinkKeySize, KHCILinkKeySize);
       
  1571 	for (TUint i=0;i<KHCILinkKeySize;i++)
       
  1572 		{
       
  1573 		key[KHCILinkKeySize-1-i] = iEventData[aOffset + i];
       
  1574 		}
       
  1575 		
       
  1576 	return retKey;
       
  1577 	}
       
  1578 	
       
  1579 EXPORT_C TBTLinkKey THCIEventBase::AsLinkKey(TInt aOffset, TInt aArrayBlockSize, TInt aIndex) const
       
  1580 	{
       
  1581 	return AsLinkKey(aOffset + (aIndex * aArrayBlockSize));	
       
  1582 	}
       
  1583 
       
  1584 EXPORT_C THCIConnectionHandle THCIEventBase::AsConnectionHandle(TInt aOffset) const
       
  1585 	{
       
  1586 	return THCIConnectionHandle(static_cast<THCIConnHandle>(AsTUint16(aOffset)));
       
  1587 	}
       
  1588 
       
  1589 EXPORT_C THCIConnectionHandle THCIEventBase::AsConnectionHandle(TInt aOffset, TInt aArrayBlockSize, TInt aIndex) const
       
  1590 	{
       
  1591 	return AsConnectionHandle(aOffset + (aIndex * aArrayBlockSize));
       
  1592 	}
       
  1593 
       
  1594 EXPORT_C TInt8 THCIEventBase::AsTInt8(TInt aOffset) const
       
  1595 	{
       
  1596 	return iEventData[aOffset];
       
  1597 	}
       
  1598 	
       
  1599 EXPORT_C TInt8 THCIEventBase::AsTInt8(TInt aOffset, TInt aArrayBlockSize, TInt aIndex) const
       
  1600 	{
       
  1601 	return AsTInt8(aOffset + (aIndex * aArrayBlockSize));	
       
  1602 	}
       
  1603 	
       
  1604 void THCIEventBase::PutEventCode(const THCIEventCode aValue, TDes8& aEventData)
       
  1605 	{
       
  1606 	TUint8 eventCode = TUint8(aValue); // the event code is a one octet quantity.
       
  1607 	aEventData.Append(&eventCode, 1);
       
  1608 	}
       
  1609 
       
  1610 void THCIEventBase::PutTUint8(TUint8 aValue, TDes8& aEventData)
       
  1611 	{
       
  1612 	aEventData.Append(&aValue, 1);
       
  1613 	}
       
  1614 
       
  1615 void THCIEventBase::PutTInt8(TInt8 aValue, TDes8& aEventData)
       
  1616 	{
       
  1617 	aEventData.Append(*reinterpret_cast<TUint8*>(&aValue));
       
  1618 	}
       
  1619 
       
  1620 void THCIEventBase::PutTUint16(TUint16 aValue, TDes8& aEventData)
       
  1621 	{
       
  1622 	TUint8 val[2] = {aValue & 0xff, aValue >> 8};
       
  1623 	aEventData.Append(val, 2);
       
  1624 	}
       
  1625 
       
  1626 void THCIEventBase::PutTUint32(TUint32 aValue, TUint8 aSize, TDes8& aEventData)
       
  1627 	{
       
  1628 	TUint8 val[4];
       
  1629 	switch (aSize)
       
  1630 		{
       
  1631 		// deliberate fallthroughs...
       
  1632 	case 4:
       
  1633 		val[3] = TUint8(aValue>>24);
       
  1634 	case 3:
       
  1635 		val[2] = TUint8(aValue>>16 & 0xff);
       
  1636 	case 2:
       
  1637 		val[1] = TUint8(aValue>>8 & 0xff);
       
  1638 	case 1:
       
  1639 		val[0] = TUint8(aValue & 0xff);
       
  1640 		break;
       
  1641 	default:
       
  1642 		PANIC(KSymbianCommandsEventsPanicCat, EParameterOutOfBounds);
       
  1643 		}
       
  1644 	aEventData.Append(val, aSize);
       
  1645 	}
       
  1646 	
       
  1647 void THCIEventBase::PutTUint64(TUint64 aValue, TDes8& aEventData)
       
  1648 	{
       
  1649 	const TUint32 K32BitMask = 0xFFFFFFFF;
       
  1650 	PutTUint32(aValue & K32BitMask, 4, aEventData);
       
  1651 	PutTUint32((aValue >> 32) & K32BitMask, 4, aEventData);
       
  1652 	}
       
  1653 	
       
  1654 void THCIEventBase::PutString(const TDesC8& aString, TDes8& aEventData)
       
  1655 	{
       
  1656 	aEventData.Append(aString);
       
  1657 	}
       
  1658 
       
  1659 void THCIEventBase::PutPaddedString(const TDesC8& aString, TInt aRequiredLength, TDes8& aEventData)
       
  1660 	{
       
  1661 	__ASSERT_DEBUG(aRequiredLength >= aString.Length(), PANIC(KSymbianCommandsEventsPanicCat, EMoreEventDataThanRequired));
       
  1662 	PutString(aString, aEventData);
       
  1663 	const TChar padByte = '\0';
       
  1664 	aEventData.AppendFill(padByte, aRequiredLength - aString.Length());
       
  1665 	}
       
  1666 	
       
  1667 void THCIEventBase::PutDevAddr(const TBTDevAddr& aBdaddr, TDes8& aEventData)
       
  1668 	{
       
  1669 	for (TUint i=0;i<KBTMaxDevAddrSize;i++)
       
  1670 		{
       
  1671 		TUint8 val(aBdaddr[KBTMaxDevAddrSize-1-i]);
       
  1672 		aEventData.Append(&val,1);
       
  1673 		}
       
  1674 	}
       
  1675 
       
  1676 void THCIEventBase::PutSimplePairingHash(const TBluetoothSimplePairingHash& aHash, TDes8& aEventData)
       
  1677 	{
       
  1678 	for (TUint i=0;i<KBluetoothSimplePairingHashSize;i++)
       
  1679 		{
       
  1680 		TUint8 val(aHash[KBluetoothSimplePairingHashSize-1-i]);
       
  1681 		aEventData.Append(&val,1);
       
  1682 		}
       
  1683 	}
       
  1684 
       
  1685 void THCIEventBase::PutSimplePairingRandomizer(const TBluetoothSimplePairingRandomizer& aRandomizer, TDes8& aEventData)
       
  1686 	{
       
  1687 	for (TUint i=0;i<KBluetoothSimplePairingRandomizerSize;i++)
       
  1688 		{
       
  1689 		TUint8 val(aRandomizer[KBluetoothSimplePairingRandomizerSize-1-i]);
       
  1690 		aEventData.Append(&val,1);
       
  1691 		}
       
  1692 	}
       
  1693 
       
  1694 void THCIEventBase::PutLinkKey(const TBTLinkKey aValue, TDes8& aEventData)
       
  1695 	{
       
  1696 	aEventData.Append(aValue().iLinkKey, KHCILinkKeySize);
       
  1697 	}
       
  1698 
       
  1699 void THCIEventBase::PutConnectionHandle(THCIConnectionHandle aConnectionHandle, TDes8& aEventData)
       
  1700 	{
       
  1701 	PutTUint16(aConnectionHandle.ConnHandle(), aEventData);
       
  1702 	}
       
  1703