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 // DataMonitoringProvider.cpp

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @internalComponent 

    21 */

    22 

    23 #include <comms-infras/ss_nodemessages.h>

    24 #include "ss_datamonitoringprovider.h"

    25 

    26 #include <comms-infras/ss_log.h>

    27 

    28 using namespace ESock;

    29 using namespace Messages;

    30 using namespace MeshMachine;

    31 

    32 EXPORT_C ADataMonitoringProvider::ADataMonitoringProvider()

    33 	{

    34 	}

    35 

    36 EXPORT_C void ADataMonitoringProvider::ConstructL()

    37 	{

    38 	InsertWrapMarkerL(EReceived);

    39 	SetNextNotificationThreshold(EReceived);

    40 	InsertWrapMarkerL(ESent);

    41 	SetNextNotificationThreshold(ESent);

    42 	}

    43 

    44 EXPORT_C ADataMonitoringProvider::~ADataMonitoringProvider()

    45 	{

    46 	TUint requestIdx;

    47 	TUint requestCount;

    48 	TNotificationRequest* notificationRequest;

    49 

    50 	// Cancel any outstanding received notification requests

    51 	requestCount = iReceivedNotificationRequests.Count();

    52 	for(requestIdx=0;requestIdx<requestCount;requestIdx++)

    53 		{

    54 		notificationRequest = iReceivedNotificationRequests[requestIdx];		

    55 		if(!notificationRequest->Cancelled()) 

    56 			{

    57 			CDataMonitoringResponder::CancelRequest(notificationRequest->Responder());

    58 			}

    59 		}

    60 	iReceivedNotificationRequests.ResetAndDestroy();

    61 

    62 	// Cancel any outstanding sent notification requests

    63 	requestCount = iSentNotificationRequests.Count();

    64 	for(requestIdx=0;requestIdx<requestCount;requestIdx++)

    65 		{

    66 		notificationRequest = iSentNotificationRequests[requestIdx];

    67 		if(!notificationRequest->Cancelled())

    68 			{

    69 			CDataMonitoringResponder::CancelRequest(notificationRequest->Responder());

    70 			}

    71 		}

    72 	iSentNotificationRequests.ResetAndDestroy();

    73 	}

    74 

    75 /**

    76 	Responds to client request for immediate notification of the amount of data transferred.

    77 	@param aResponder The IPC responder for completing the client request

    78 	@param aClientId Not used

    79 */

    80 EXPORT_C void ADataMonitoringProvider::RequestDataTransferred(CDataMonitoringResponder*& aResponder, TSubSessionUniqueId /* aClientId */)

    81 	{

    82 	CDataMonitoringResponder::DataTransferred(aResponder, iDataVolumes.iReceivedBytes, iDataVolumes.iSentBytes);

    83 	}

    84 

    85 /**

    86 	Cancels an outstanding client request for immediate notification of the amount of data transferred.

    87 	@param aClientId Not used

    88 	@note Method has no implementation as completion of request is immediate.

    89 	@see ADataMonitoringProvider::RequestDataTransferred

    90 */

    91 EXPORT_C void ADataMonitoringProvider::CancelDataTransferredRequest(TSubSessionUniqueId /* aClientId */)

    92 	{

    93 	// Nothing to do

    94 	}

    95 

    96 /**

    97 	Responds to client request for notification of a particular volume of data having been

    98 	received.

    99 	@param aResponder The IPC responder for completing the client request

   100 	@param aDelta An offset from the current volume transferred at which to notify the client

   101 	@param aReceivedBytes An absolute data volume at which to notify the client

   102 	@param aClientId Id of the requesting client

   103 	@note Only one of the parameters aDelta and aReceivedBytes should be set for a given call

   104 		  to this method

   105 */

   106 EXPORT_C void ADataMonitoringProvider::RequestDataReceivedNotification(CDataMonitoringResponder*& aResponder, TUint32 aDelta, TUint32 aReceivedBytes, TSubSessionUniqueId aClientId)

   107 	{	

   108 	TNotificationRequest* notificationRequest = new TNotificationRequest(aResponder, aClientId);

   109 	if (!notificationRequest)

   110 		{

   111 		CDataMonitoringResponder::Error(aResponder, KErrNoMemory);

   112 		return;

   113 		}

   114 

   115 	// Ensure this client has not registered before or if it has, any outstanding requests are

   116 	// marked as cancelled.

   117 	TInt requestIdx = iReceivedNotificationRequests.Find(notificationRequest, TIdentityRelation<TNotificationRequest>(TNotificationRequest::CompareClientIds));

   118 	if(requestIdx != KErrNotFound && !iReceivedNotificationRequests[requestIdx]->Cancelled())

   119 		{

   120 		delete notificationRequest;

   121 		CDataMonitoringResponder::Error(aResponder, KErrInUse);

   122 		return;

   123 		}

   124 	

   125 	if(aDelta)

   126 		{ 	// If the delta was set then set the threshold from that and the current received data volume

   127 		notificationRequest->SetThresholdFromDelta(iDataVolumes.iReceivedBytes, aDelta);

   128 		}

   129 	else

   130 		{	// Otherwise, we were given an absolute value for the threshold

   131 		if(iDataVolumes.iReceivedBytes >= aReceivedBytes) 

   132 			{	// If the required threshold has already been reached then send immediate notification

   133 			delete notificationRequest;

   134 			CDataMonitoringResponder::DataReceivedNotification(aResponder, iDataVolumes.iReceivedBytes);

   135 			return;

   136 			}

   137 		else

   138 			{

   139 			notificationRequest->SetThreshold(aReceivedBytes);

   140 			}

   141 		}

   142 

   143 	TInt error = InsertNotificationRequest(notificationRequest, EReceived);

   144 	if (error!=KErrNone)

   145 		{

   146 		delete notificationRequest;	

   147 		CDataMonitoringResponder::Error(aResponder, error);

   148 		return;

   149 		}

   150 

   151 	SetNextNotificationThreshold(EReceived);

   152 	}

   153 

   154 /**

   155 	Cancels an outstanding request for data received notification.

   156 	

   157 	@param aClientId Id of the requesting client

   158 */

   159 EXPORT_C void ADataMonitoringProvider::CancelDataReceivedNotificationRequest(TSubSessionUniqueId aClientId)

   160 	{

   161 	// Set up an exemplar request using the specified client ID

   162 	TNotificationRequest exemplarRequest(NULL, aClientId);

   163 	

   164 	// Locate the request matching the specified client ID

   165 	TInt requestIdx = iReceivedNotificationRequests.Find(&exemplarRequest, TIdentityRelation<TNotificationRequest>(TNotificationRequest::CompareClientIds));	

   166 	if(requestIdx != KErrNotFound && !iReceivedNotificationRequests[requestIdx]->Cancelled())

   167 		{

   168 		TNotificationRequest* notificationRequest = iReceivedNotificationRequests[requestIdx];

   169 		

   170 		// Cancel it and complete the client

   171 		notificationRequest->SetCancelled();

   172 		CDataMonitoringResponder::CancelRequest(notificationRequest->Responder());

   173 		}

   174 	}

   175 

   176 /**

   177 

   178 */

   179 EXPORT_C void ADataMonitoringProvider::RequestDataSentNotification(CDataMonitoringResponder*& aResponder, TUint32 aDelta, TUint32 aSentBytes, TSubSessionUniqueId aClientId)

   180 	{	

   181 	TNotificationRequest* notificationRequest = new TNotificationRequest(aResponder, aClientId);

   182 	if (!notificationRequest)

   183 		{

   184 		CDataMonitoringResponder::Error(aResponder, KErrNoMemory);

   185 		return;

   186 		}

   187 	

   188 	// Ensure this client has not registered before or if it has, any outstanding requests are

   189 	// marked as cancelled.

   190 	TInt requestIdx = iSentNotificationRequests.Find(notificationRequest, TIdentityRelation<TNotificationRequest>(TNotificationRequest::CompareClientIds));

   191 	if(requestIdx != KErrNotFound && !iSentNotificationRequests[requestIdx]->Cancelled())

   192 		{

   193 		delete notificationRequest;

   194 		CDataMonitoringResponder::Error(aResponder, KErrInUse);

   195 		return;

   196 		}

   197 		

   198 	if(aDelta)

   199 		{ 	// If the delta was set then set the threshold from that and the current sent data volume

   200 		notificationRequest->SetThresholdFromDelta(iDataVolumes.iSentBytes, aDelta);

   201 		}

   202 	else

   203 		{	// Otherwise, we were given an absolute value for the threshold

   204 		if(iDataVolumes.iSentBytes >= aSentBytes)

   205 			{	// If the required threshold has already been reached then send immediate notification

   206 			delete notificationRequest;

   207 			CDataMonitoringResponder::DataSentNotification(aResponder, iDataVolumes.iSentBytes);

   208 			return;

   209 			}

   210 		else

   211 			{

   212 			notificationRequest->SetThreshold(aSentBytes);

   213 			}

   214 		}

   215 

   216 	TInt error = InsertNotificationRequest(notificationRequest, ESent);

   217 	if (error!=KErrNone)

   218 		{

   219 		delete notificationRequest;	

   220 		CDataMonitoringResponder::Error(aResponder, error);

   221 		return;

   222 		}

   223 

   224 	SetNextNotificationThreshold(ESent);

   225 	}

   226 

   227 /**

   228 	Cancels an outstanding request for data sent notification.

   229 	

   230 	@param aClientId Client id of the request to be cancelled

   231 */

   232 EXPORT_C void ADataMonitoringProvider::CancelDataSentNotificationRequest(TSubSessionUniqueId aClientId)

   233 	{

   234 	// Set up an exemplar request using the specified client id

   235 	TNotificationRequest exemplarRequest(NULL, aClientId);

   236 	

   237 	// Locate the request matching the specified client id

   238 	TInt requestIdx = iSentNotificationRequests.Find(&exemplarRequest, TIdentityRelation<TNotificationRequest>(TNotificationRequest::CompareClientIds));

   239 	if(requestIdx != KErrNotFound && !iSentNotificationRequests[requestIdx]->Cancelled())

   240 		{

   241 		TNotificationRequest* notificationRequest = iSentNotificationRequests[requestIdx];

   242 		

   243 		// Cancel it and complete the client

   244 		notificationRequest->SetCancelled();

   245 		CDataMonitoringResponder::CancelRequest(notificationRequest->Responder());

   246 		}

   247 	}

   248 

   249 /**

   250 	Call from data to control plane to indicate the received data volume notification

   251 	threshold has been reached.

   252 	

   253 	@param aNotificationValue The volume of data received

   254 */

   255 EXPORT_C void ADataMonitoringProvider::DataReceivedNotificationL(TUint32 aNotificationValue)

   256 	{

   257 	TNotificationRequest* request;

   258 	

   259 	// Complete the first request in the array immediately and loop for any

   260 	// additional same value thresholds in the list.

   261 	while((iReceivedNotificationRequests.Count() > 0) && 

   262 		  (aNotificationValue >= iReceivedNotificationRequests[0]->Threshold()))

   263 		{

   264 		request = iReceivedNotificationRequests[0];

   265 		if(!request->Cancelled())

   266 			{	// Only complete if the request wasn't cancelled

   267 			CDataMonitoringResponder::DataReceivedNotification(request->Responder(), aNotificationValue);

   268 			}

   269 		iReceivedNotificationRequests.Remove(0);

   270 		delete request;

   271 		}

   272 

   273 	// If we've completed a wrap marker, we need to do a little housekeeping

   274 	if(aNotificationValue == KMaxTUint32) 

   275 		{	

   276 		TInt requestCount = iReceivedNotificationRequests.Count();

   277 		if(requestCount > 0)

   278 			{

   279 			// The remaining requests had been marked wrapped.  Now we've

   280 			// completed the wrap marker they need to be 'unmarked' to allow

   281 			// new wrapped requests to be positioned correctly in the request array

   282 			for(TUint requestIdx=0;requestIdx<requestCount;requestIdx++)

   283 				{

   284 				iReceivedNotificationRequests[requestIdx]->SetWrapped(EFalse);

   285 				}

   286 			}

   287 			InsertWrapMarkerL(EReceived);

   288 		}

   289 	SetNextNotificationThreshold(EReceived);

   290 	}

   291 	

   292 /**

   293 	Call from data to control plane to indicate the sent data volume notification

   294 	threshold has been reached.

   295 	

   296 	@param aNotificationValue The volume of data received

   297 */

   298 EXPORT_C void ADataMonitoringProvider::DataSentNotificationL(TUint32 aNotificationValue)

   299 	{

   300 	TNotificationRequest* request;

   301 	

   302 	// Complete the first request in the array immediately and loop for any

   303 	// additional same value thresholds in the list.

   304 	while((iSentNotificationRequests.Count() > 0) && 

   305 		  (aNotificationValue >= iSentNotificationRequests[0]->Threshold()))

   306 		{

   307 		request = iSentNotificationRequests[0];

   308 		if(!request->Cancelled())

   309 			{	// Only complete if the request wasn't cancelled

   310 			CDataMonitoringResponder::DataSentNotification(request->Responder(), aNotificationValue);

   311 			}

   312 		iSentNotificationRequests.Remove(0);

   313 		delete request;

   314 		}

   315 

   316 	// If we've completed a wrap marker, we need to do a little housekeeping

   317 	if(aNotificationValue == KMaxTUint32) 

   318 		{	

   319 		TInt requestCount = iSentNotificationRequests.Count();

   320 		if(requestCount > 0)

   321 			{

   322 			// The remaining requests had been marked wrapped.  Now we've

   323 			// completed the wrap marker they need to be 'unmarked' to allow

   324 			// new wrapped requests to be positioned correctly in the request array

   325 			for(TUint requestIdx=0;requestIdx<requestCount;requestIdx++)

   326 				{

   327 				iSentNotificationRequests[requestIdx]->SetWrapped(EFalse);

   328 				}

   329 			}

   330 			InsertWrapMarkerL(ESent);

   331 		}

   332 	SetNextNotificationThreshold(ESent);

   333 	}

   334 

   335 

   336 EXPORT_C void ADataMonitoringProvider::CancelClientExtItfRequests(TSubSessionUniqueId aClientId)

   337 	{

   338 	CancelDataSentNotificationRequest(aClientId);

   339 	CancelDataReceivedNotificationRequest(aClientId);

   340 	}

   341 

   342 /**

   343     Call from a node activity upon receiving TCFMessage::TDataMonitoringInternal 

   344     message extension.

   345 */

   346 EXPORT_C void ADataMonitoringProvider::DataNotificationL(const ESock::TCFDataMonitoringNotification::TDataMonitoringNotification& aNotification)

   347     {

   348 	switch(aNotification.iValue1)

   349 		{

   350 		case EReceived:

   351 			DataReceivedNotificationL(aNotification.iValue2);

   352 			break;

   353 			

   354 		case ESent:

   355 			DataSentNotificationL(aNotification.iValue2);

   356 			break;

   357 			

   358 		default:

   359 			break;

   360 		}	

   361     }

   362     

   363 /**

   364 

   365 */

   366 void ADataMonitoringProvider::InsertWrapMarkerL(TDataMonitoringDirection aDirection)

   367 	{

   368 	TNotificationRequest* wrapMarkerRequest = new(ELeave) TNotificationRequest(NULL, 0);

   369 	

   370 	wrapMarkerRequest->SetThreshold(KMaxTUint32);

   371 	wrapMarkerRequest->SetCancelled();

   372 	

   373 	TInt ret = NotificationRequestArray(aDirection)->InsertInOrder(wrapMarkerRequest, TLinearOrder<TNotificationRequest>(TNotificationRequest::CompareThresholds));

   374 	

   375 	if(ret != KErrNone)

   376 		{	

   377 		// If the insert failed then the most likely reason is a KErrAlreadyExists.  In any

   378 		// case, we definitely want to delete the wrap marker.  Then we'll try and carry on

   379 		// as best we can.

   380 		delete wrapMarkerRequest;

   381 		}				

   382 	}

   383 

   384 

   385 /**

   386 

   387 */

   388 RNotificationRequestArray* ADataMonitoringProvider::NotificationRequestArray(TDataMonitoringDirection aDirection)

   389 	{

   390 	if(aDirection == EReceived)

   391 		{

   392 		return &iReceivedNotificationRequests;

   393 		}

   394 	else

   395 		{

   396 		return &iSentNotificationRequests;

   397 		}

   398 	}

   399 

   400 /**

   401 

   402 */

   403 TInt ADataMonitoringProvider::InsertNotificationRequest(TNotificationRequest* aRequest, TDataMonitoringDirection aDirection)

   404 	{

   405 	TInt err;

   406 	err = NotificationRequestArray(aDirection)->InsertInOrderAllowRepeats(aRequest, TLinearOrder<TNotificationRequest>(TNotificationRequest::CompareThresholds));

   407 

   408 	LOG(

   409 		switch(aDirection)

   410 			{

   411 		case ESent:

   412 			ESockLog::Printf(_L("ADataMonitoringProvider(%08x)::InsertNotificationRequest - Direction: Sending"), this);

   413 			break;			

   414 		case EReceived:

   415 			ESockLog::Printf(_L("ADataMonitoringProvider(%08x)::InsertNotificationRequest - Direction: Receiving"), this);

   416 			break;

   417 			}

   418 		

   419 		for(TInt idx=0;idx<NotificationRequestArray(aDirection)->Count();idx++)

   420 			{

   421 			TNotificationRequest* req = (*NotificationRequestArray(aDirection))[idx];

   422 			ESockLog::Printf(_L("\tRequest %d, Threshold %d, Wrapped %d, Client id. 0x%08x"), idx, req->Threshold(), req->Wrapped(), req->ClientId());

   423 			}

   424 		)

   425 	

   426 	return err;

   427 	}

   428 

   429 /**

   430 */

   431 void ADataMonitoringProvider::SetNextNotificationThreshold(TDataMonitoringDirection aDirection) 

   432 	{

   433 	if(NotificationRequestArray(aDirection)->Count())

   434 		{

   435 		switch(aDirection)

   436 			{

   437 		case EReceived:			

   438 			iThresholds.iReceivedThreshold = (*NotificationRequestArray(EReceived))[0]->Threshold();				

   439 			break;

   440 

   441 		case ESent:			

   442 			iThresholds.iSentThreshold = (*NotificationRequestArray(ESent))[0]->Threshold();			

   443 			break;

   444 			}

   445 		}

   446 	}

   447 

   448 

   449 /**

   450 

   451 */

   452 EXPORT_C TDataMonitoringConnProvisioningInfo::TDataMonitoringConnProvisioningInfo(TDataVolumes* aDataVolumesPtr, TNotificationThresholds* aThresholdsPtr) :

   453 	TDataMonitoringProvisioningInfoBase(aDataVolumesPtr, aThresholdsPtr)

   454 	{

   455 	}

   456 

   457 

   458 /**

   459 

   460 */

   461 EXPORT_C TDataMonitoringSubConnProvisioningInfo::TDataMonitoringSubConnProvisioningInfo(TDataVolumes* aDataVolumesPtr, TNotificationThresholds* aThresholdsPtr) :

   462 	TDataMonitoringProvisioningInfoBase(aDataVolumesPtr, aThresholdsPtr)

   463 	{

   464 	}

   465 

   466 

   467 /**

   468 	Sets the data volume notification threshold given the current transferred volume

   469 	and a delta from the current amount.

   470 	

   471 	@param aVolume Current data volume transferred

   472 	@param aDelta An offset from the current volume of data transferred

   473 */

   474 void TNotificationRequest::SetThresholdFromDelta(TUint32 aVolume, TUint32 aDelta)

   475 	{

   476 	TUint64 threshold = aVolume + aDelta;

   477 	

   478 	if(threshold > KMaxTUint32) 

   479 		{

   480 		iWrapped = ETrue;

   481 		iThreshold = threshold - KMaxTUint32;

   482 		}

   483 	else

   484 		{

   485 		iWrapped = EFalse;

   486 		iThreshold = threshold;

   487 		}	

   488 	}

   489 		

   490 /**

   491 	Compares two TNotificationRequest objects using their thresholds as the criteria.

   492 */

   493 TInt TNotificationRequest::CompareThresholds(const TNotificationRequest& aFirst, const TNotificationRequest& aSecond)

   494 	{

   495 	TUint64 effectiveFirstThreshold = aFirst.iThreshold;

   496 	TUint64 effectiveSecondThreshold = aSecond.iThreshold;

   497 	

   498 	if(aFirst.Wrapped()) effectiveFirstThreshold += KMaxTUint32;

   499 	if(aSecond.Wrapped()) effectiveSecondThreshold += KMaxTUint32;

   500 

   501 	if(effectiveFirstThreshold > effectiveSecondThreshold)

   502 		{

   503 		return 1;

   504 		}

   505 	else if(effectiveFirstThreshold < effectiveSecondThreshold) 

   506 		{

   507 		return -1;

   508 		}

   509 	else

   510 		{

   511 		return 0;

   512 		}

   513 	}

   514 

   515 /**

   516 	Compares two TNotificationRequest objects using their client ids as the criteria.

   517 */

   518 TBool TNotificationRequest::CompareClientIds(const TNotificationRequest& aFirst, const TNotificationRequest& aSecond)

   519 	{

   520 	if(aFirst.ClientId() == aSecond.ClientId())

   521 		{

   522 		return ETrue;

   523 		}

   524 	else

   525 		{

   526 		return EFalse;

   527 		}

   528 	}

   529 

   530 EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDataMonitoringProvisioningInfoBase, TDataMonitoringProvisioningInfoBase::iUid, TDataMonitoringProvisioningInfoBase::iId)

   531 	REGISTER_ATTRIBUTE(TDataMonitoringProvisioningInfoBase, iDataVolumesPtr, TMeta<TDataMonitoringProvisioningInfoBase*>)

   532 	REGISTER_ATTRIBUTE(TDataMonitoringProvisioningInfoBase, iThresholdsPtr, TMeta<TDataMonitoringProvisioningInfoBase*>)

   533 END_ATTRIBUTE_TABLE()

   534 

   535 EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDataMonitoringConnProvisioningInfo, TDataMonitoringProvisioningInfoBase::iUid, TDataMonitoringConnProvisioningInfo::iId)

   536 END_ATTRIBUTE_TABLE_BASE(TDataMonitoringProvisioningInfoBase, 0)

   537 

   538 EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDataMonitoringSubConnProvisioningInfo, TDataMonitoringProvisioningInfoBase::iUid, TDataMonitoringSubConnProvisioningInfo::iId)

   539 END_ATTRIBUTE_TABLE_BASE(TDataMonitoringProvisioningInfoBase, 0)

   540