1 // Copyright (c) 1998-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 #include <s32std.h>

    17 

    18 #include "MSVAPI.H"

    19 #include "MSVCOP.H"

    20 #include "MSVPANIC.H"

    21 #include <tmsvsystemprogress.h>

    22 

    23 //**********************************

    24 // CMsvOperation

    25 //**********************************

    26 

    27 EXPORT_C CMsvOperation::CMsvOperation(CMsvSession& aMsvSession, TInt aPriority, TRequestStatus& aObserverRequestStatus)

    28 : CActive(aPriority), iObserverRequestStatus(aObserverRequestStatus), iMsvSession(aMsvSession)

    29 //

    30 //

    31 //

    32 /** Constructor. This is called by MTM implementers from the derived class constructor. 

    33 

    34 CMsvOperation-derived objects are not created by message client applications. The constructor uses the 

    35 CMsvSession object to obtain a ID for the operation. This ID can be accessed by clients through Id(). 

    36 

    37 aPriority is the priority used by the active object. Typically, this is EPriorityStandard.

    38 

    39 aObserverRequestStatus is the asynchronous status object of an active object provided by the caller. 

    40 The derived class is required to signal the caller through this when the operation completes. 

    41 It is stored by the constructor in the iObserverRequestStatus member.

    42 @param aMsvSession Session object 

    43 @param aPriority Active object priority 

    44 @param aObserverRequestStatus  Request status of operation observer

    45  */

    46 	{

    47 	__DECLARE_NAME(_S("CMsvOperation"));

    48 	iId = iMsvSession.OperationId();

    49 	}

    50 

    51 

    52 EXPORT_C CMsvOperation::~CMsvOperation()

    53 /** Destructor.

    54 

    55 This base class function takes no action. Derived classes should implement 

    56 a destructor to do the clean up tasks that they require. Minimally, they should 

    57 call Cancel() to cancel any outstanding request. */

    58 	{}

    59 

    60 EXPORT_C const TDesC8& CMsvOperation::FinalProgress()

    61 /** Gets information about a completed operation. 

    62 

    63 Unlike ProgressL(), this is guaranteed to provide status information reflecting 

    64 the outcome of a completed operation.

    65 

    66 Requirements:

    67 

    68 The default implementation of this function returns the result from ProgressL(). 

    69 If the operation is active or ProgressL() leaves, a panic occurs. 

    70 

    71 A derived class should implement the function to meet the requirement to provide 

    72 appropriate final status information. Typically, on active object completion, 

    73 it will store progress information in a private member, and return that stored 

    74 information from this function.

    75 

    76 @return Descriptor holding progress information

    77 @panic MSGS 285 Operation is active

    78 @panic MSGS 286 Could not get final progress information, as ProgressL() left.

    79 */

    80 	{	

    81 	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));

    82 	const TDesC8* progress = &KNullDesC8();

    83 	TRAPD(leave, progress = &ProgressL());

    84 	__ASSERT_ALWAYS(leave == KErrNone, PanicServer(EMsvFinalProgressFailed));

    85 	return *progress;

    86 	}

    87 

    88 EXPORT_C TUid CMsvOperation::Mtm() const

    89 /** Gets the UID of the MTM associated with the operation.

    90 

    91 This UID can be used to determine the appropriate method of getting information 

    92 from a progress descriptor. 

    93 

    94 The default implementation returns iMtm.

    95 

    96 @return The UID of the MTM associated with the operation 

    97 @see ProgressL() */

    98  	{

    99  	return iMtm;

   100  	} 

   101 

   102 /** This call leads to calling SystemProgress() in the server to populate the

   103 TMsvSystemProgress structure.

   104 @param aOutSysProg The TMsvSystemProgress structure to be populated by the server

   105 @return the error of the Extension_ method call

   106 */

   107 EXPORT_C TInt CMsvOperation::SystemProgress(TMsvSystemProgress& aOutSysProg)

   108 	{

   109 	TAny* ptrNull = NULL;

   110 	return Extension_(KUIDMsgMsvSystemProgress, ptrNull, &aOutSysProg);

   111 	}

   112 

   113 /** The extension method provides a polymorphic behaviour to call the correct

   114 SystemProgress function.

   115 @param aExtensionId The Uid passed in as KUIDMsgMsvSystemProgress to obtain the

   116 System Progress.

   117 @return KErrExtensionNotSupported retuned if no Extension_ function is overriddden

   118 by the derived class.

   119 */

   120 EXPORT_C TInt CMsvOperation::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)	

   121 	{

   122 	TInt ret = KErrNone;

   123 	switch(aExtensionId)

   124 		{

   125 		case KUIDMsgMsvSystemProgress:

   126 			{

   127 			ret = KErrExtensionNotSupported;

   128 			}

   129 			break;

   130 		default:

   131 			{

   132 		// Chain to base class

   133 			ret = CActive::Extension_(aExtensionId, a0, a1);

   134 			}

   135 			break;

   136 		}

   137 	return ret;

   138 	}

   139 

   140 //**********************************

   141 // CMsvEntryOperation

   142 //**********************************

   143 

   144 CMsvEntryOperation* CMsvEntryOperation::NewL(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)

   145 //

   146 //

   147 //

   148 	{

   149 	CMsvEntryOperation* self = CMsvEntryOperation::NewLC(aMsvSession, aObserverRequestStatus);

   150 	CleanupStack::Pop();

   151 	return self;

   152 	}

   153 

   154 CMsvEntryOperation* CMsvEntryOperation::NewLC(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)

   155 //

   156 //

   157 //

   158 	{

   159 	CMsvEntryOperation* self = new(ELeave) CMsvEntryOperation(aMsvSession, aObserverRequestStatus);

   160 	CleanupStack::PushL(self);

   161 	self->ConstructL();

   162 	return self;

   163 	}

   164 

   165 

   166 CMsvEntryOperation::CMsvEntryOperation(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)

   167 : CMsvOperation(aMsvSession, EPriorityStandard, aObserverRequestStatus)

   168 //

   169 //

   170 //

   171 	{

   172 	__DECLARE_NAME(_S("CMsvEntryOperation"));

   173 	}

   174 

   175 

   176 CMsvEntryOperation::~CMsvEntryOperation()

   177 //

   178 //

   179 //

   180 	{

   181 	Cancel();

   182 	delete iProgress;

   183 	}

   184 

   185 

   186 void CMsvEntryOperation::ConstructL()

   187 //

   188 //

   189 //

   190 	{

   191 	iProgress = HBufC8::NewL(KMsvProgressBufferLength);

   192 	CActiveScheduler::Add(this);

   193 	}

   194 

   195 

   196 

   197 void CMsvEntryOperation::DoCancel()

   198 //

   199 //

   200 //

   201 	{

   202 	TPtr8 des = iProgress->Des();

   203 	iMsvSession.Session().CancelOperation(Id(), des); // error ignored

   204 

   205 	// signal the observer that the operation has completed

   206 	TRequestStatus* status = &iObserverRequestStatus;

   207 	User::RequestComplete(status, KErrCancel);

   208 	}

   209 

   210 

   211 void CMsvEntryOperation::RunL()

   212 //

   213 //

   214 //

   215 	{

   216 	// get the final Msv system progress from the server

   217 	iErrorGetSystemProgress = iMsvSession.Session().OperationSystemProgress(Id(), iSystemProgress);

   218 	

   219 	// get the final progress from the server

   220 	TPtr8 des = iProgress->Des();

   221 	TInt length=des.Length();

   222 	TInt error = iMsvSession.Session().OperationCompletion(Id(), des); 

   223 	if (error)

   224 		des.SetLength(length);

   225 

   226 	// signal the observer that the operation has completed

   227 	TRequestStatus* status = &iObserverRequestStatus;

   228 

   229 	// If there is no operation then complete with our status

   230 	// Otherwise complete with the operation completion error

   231 

   232 	if (error == KErrNotFound && iStatus.Int())

   233 		User::RequestComplete(status, iStatus.Int());

   234 	else

   235 		User::RequestComplete(status, error ? error : iStatus.Int());

   236 	}

   237 

   238 const TDesC8& CMsvEntryOperation::ProgressL()

   239 //

   240 //

   241 //

   242 	{

   243 	if (IsActive())

   244 		{

   245 		TPtr8 des = iProgress->Des();

   246 		User::LeaveIfError(iMsvSession.Session().OperationProgress(Id(), des));

   247 		}

   248 	return *iProgress;

   249 	}

   250 

   251 /** The extension method provides a polymorphic behaviour to get the TMsvSystemProgress

   252 structure in one of the Operations.

   253 @param aExtensionId The Uid passed in as KUIDMsgMsvSystemProgress to obtain the

   254 System Progress.

   255 @return error from the call of DoGetSystemProgress() method.

   256 */

   257 EXPORT_C TInt CMsvEntryOperation::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)

   258 	{

   259 	if (aExtensionId == KUIDMsgMsvSystemProgress)

   260 		{

   261 		TMsvSystemProgress* systemProgress = reinterpret_cast<TMsvSystemProgress*>(a1);

   262 		return DoGetSystemProgress(*systemProgress);

   263 		}

   264 	

   265 	// Chain to base class

   266 	return CMsvOperation::Extension_(aExtensionId, a0, a1);

   267 	}

   268 

   269 /** This function calls the session which eventually goes to SystemProgress() in the server

   270 to populate the TMsvSystemProgress structure.

   271 @param aOutSysProg The TMsvSystemProgress structure to be populated by the server

   272 @return the error from the SystemProgress() call.

   273 */

   274 TInt CMsvEntryOperation::DoGetSystemProgress(TMsvSystemProgress& aOutSysProg)

   275 	{

   276 	TInt err = KErrNone;

   277 	// use RMsvSession

   278 	if (IsActive())

   279 		{

   280 		err = iMsvSession.Session().OperationSystemProgress(Id(), aOutSysProg);

   281 		}

   282 	else

   283 		{

   284 		aOutSysProg = iSystemProgress;

   285 		err = iErrorGetSystemProgress;

   286 		}

   287 	return err;

   288 	}

   289 

   290 const TDesC8& CMsvEntryOperation::FinalProgress()

   291 	{

   292 	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));

   293 	return *iProgress;

   294 	}

   295 

   296 

   297 void CMsvEntryOperation::Start()

   298 //

   299 //

   300 //

   301 	{

   302 	iObserverRequestStatus=KRequestPending;

   303 	SetActive();

   304 	}

   305 

   306 //**********************************

   307 // CMsvOperationWait

   308 //**********************************

   309 

   310 // static 

   311 /** Allocates and constructs a new CMsvOperationWait object.

   312 

   313 The new object is added to the active scheduler and left on

   314 the cleanup stack.

   315 

   316 @param aPriority Active object priority. It has a default value of 

   317 EPriorityStandard.

   318 @return New CMsvOperationWait object

   319 @leave KErrNoMemory

   320 */

   321 EXPORT_C CMsvOperationWait* CMsvOperationWait::NewLC(TInt aPriority)

   322 	{

   323 	CMsvOperationWait* self = new (ELeave) CMsvOperationWait(aPriority);

   324 	CleanupStack::PushL(self);

   325 	return self;

   326 	}

   327 

   328 /** Constructor.

   329 

   330 @param aPriority Active object priority

   331 */

   332 CMsvOperationWait::CMsvOperationWait(TInt aPriority)

   333 : CActive(aPriority)

   334 	{

   335 	CActiveScheduler::Add(this);

   336 	}

   337 

   338 /** Destructor.

   339 

   340 Any active request on the object is cancelled.

   341 */

   342 EXPORT_C CMsvOperationWait::~CMsvOperationWait()

   343 	{

   344 	Cancel();

   345 	}

   346 

   347 /** Sets the object to be active.

   348 

   349 */

   350 EXPORT_C void CMsvOperationWait::Start()

   351 	{

   352 	iStatus = KRequestPending;

   353 	SetActive();

   354 	}

   355 

   356 /** Handles a request completion event.

   357 

   358 The function stops the current active scheduler.

   359 

   360 @see CActive::RunL()

   361 */

   362 void CMsvOperationWait::RunL()

   363 	{

   364 	CActiveScheduler::Stop();

   365 	}

   366 

   367 /** Implements cancellation of an outstanding request.

   368 

   369 @see CActive::DoCancel()

   370 */

   371 void CMsvOperationWait::DoCancel()

   372 	{

   373 	TRequestStatus* s=&iStatus;

   374 	User::RequestComplete(s, KErrCancel);

   375 	}

   376 

   377 

   378 //**********************************

   379 // CMsvOperationActiveSchedulerWait

   380 //**********************************

   381 

   382 // static 

   383 /** Allocates and constructs a new CMsvOperationActiveSchedulerWait object.

   384 

   385 The new object is added to the active scheduler and left on

   386 the cleanup stack.

   387 

   388 @param aPriority Active object priority. It has a default value of 

   389 EPriorityStandard.

   390 @return New CMsvOperationActiveSchedulerWait object

   391 @leave KErrNoMemory

   392 */

   393 EXPORT_C CMsvOperationActiveSchedulerWait* CMsvOperationActiveSchedulerWait::NewLC(TInt aPriority)

   394 	{

   395 	CMsvOperationActiveSchedulerWait* self = new (ELeave) CMsvOperationActiveSchedulerWait(aPriority);

   396 	CleanupStack::PushL(self);

   397 	return self;

   398 	}

   399 

   400 /** Constructor.

   401 

   402 @param aPriority Active object priority

   403 */

   404 CMsvOperationActiveSchedulerWait::CMsvOperationActiveSchedulerWait(TInt aPriority)

   405 : CActive(aPriority)

   406 	{

   407 	CActiveScheduler::Add(this);

   408 	}

   409 

   410 /** Destructor.

   411 

   412 Any active request on the object is cancelled.

   413 */

   414 EXPORT_C CMsvOperationActiveSchedulerWait::~CMsvOperationActiveSchedulerWait()

   415 	{

   416 	Cancel();

   417 	}

   418 

   419 /** Sets the object to be active, and wait until the request is completed.

   420 */

   421 EXPORT_C void CMsvOperationActiveSchedulerWait::Start()

   422 	{

   423 	SetActive();

   424 	iActiveSchedulerWait.Start();	//Re-enter the active scheduler--execution halts here until RunL is called

   425 	}

   426 

   427 /** Handles a request completion event.

   428 

   429 The function stops the object waiting, and allows the program to resume execution after the Start() function call.

   430 

   431 @see CActive::RunL()

   432 */

   433 void CMsvOperationActiveSchedulerWait::RunL()

   434 	{

   435 	iActiveSchedulerWait.AsyncStop();	//Exit current scheduler loop, resuming execution of the Start() function

   436 	}

   437 

   438 /** Implements cancellation of an outstanding request.

   439 

   440 @see CActive::DoCancel()

   441 */

   442 void CMsvOperationActiveSchedulerWait::DoCancel()

   443 	{

   444 	TRequestStatus* s=&iStatus;

   445 	User::RequestComplete(s, KErrCancel);

   446 	}

   447 

   448 //**********************************

   449 // CMsvCompletedOperation

   450 //**********************************

   451 

   452 // static

   453 /** Allocates and constructs a new CMsvCompletedOperation object.

   454 

   455 The new object is added to the active scheduler and its asynchronous request 

   456 immediately set to complete.

   457 

   458 @param aSession Message Server session to use

   459 @param aMtm The UID of the MTM associated with the operation. 

   460 @param aProgress Operation progress information buffer. This is copied by the object.

   461 @param aService The ID of the service that is associated with this operation. 

   462 @param aObserverRequestStatus Request status of the operation observer. This 

   463 observer is signalled that the operation is complete. 

   464 @param aError Error code with which to complete the request. Use KErrNone to 

   465 indicate that the operation completed successfully. 

   466 

   467 @return New CMsvOperationActiveSchedulerWait object

   468 @leave KErrNoMemory

   469 */

   470 EXPORT_C CMsvCompletedOperation* CMsvCompletedOperation::NewL(CMsvSession& aSession, TUid aMtm, const TDesC8& aProgress, TMsvId aService, TRequestStatus& aObserverRequestStatus, TInt aError)

   471 	{

   472 	CMsvCompletedOperation* self = new (ELeave) CMsvCompletedOperation(aSession, aObserverRequestStatus);

   473 	CleanupStack::PushL(self);

   474 	self->ConstructL(aMtm, aError, aProgress, aService);

   475 	CleanupStack::Pop();

   476 	return self;

   477 	}

   478 

   479 CMsvCompletedOperation::CMsvCompletedOperation(CMsvSession& aSession, TRequestStatus& aObserverRequestStatus)

   480 : CMsvOperation(aSession, EPriorityStandard, aObserverRequestStatus) 

   481 	{

   482 	__DECLARE_NAME(_S("CMsvCompletedOperation"));

   483 	}

   484 

   485 /** Destructor.

   486 

   487 Any active request on the object is cancelled.

   488 */

   489 EXPORT_C CMsvCompletedOperation::~CMsvCompletedOperation()

   490 	{

   491 	Cancel();

   492 	delete iProgress;

   493 	}

   494 

   495 void CMsvCompletedOperation::ConstructL(TUid aMtm, TInt aError, const TDesC8& aProgress, TMsvId aService)

   496 	{

   497 	iProgress = HBufC8::NewL(aProgress.Length());

   498 	*iProgress = aProgress;

   499 	iMtm=aMtm;

   500 	iService=aService;

   501 	//

   502 	CActiveScheduler::Add(this);

   503 	iStatus = KRequestPending;

   504 	SetActive();

   505 	//

   506 	TRequestStatus* pstat=&iStatus;

   507 	User::RequestComplete(pstat, aError);

   508 	iObserverRequestStatus = KRequestPending;

   509 	}

   510 

   511 /** Gets information on the progress of the operation.

   512 

   513 For a CMsvCompletedOperation, the progress information returned by 

   514 ProgressL() and FinalProgress() is the same, and is the progress 

   515 information set in the NewL() function. 

   516  

   517 @return Descriptor holding progress information.

   518 @see CMsvOperation::ProgressL()

   519 */

   520 const TDesC8& CMsvCompletedOperation::ProgressL()

   521 	{

   522 	return *iProgress;

   523 	}

   524 

   525 /** Gets information about a completed operation. 

   526 @return Descriptor holding progress information.

   527 @see CMsvOperation::FinalProgress()

   528 */

   529 const TDesC8& CMsvCompletedOperation::FinalProgress()

   530 	{

   531 	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));

   532 	return *iProgress;

   533 	}

   534 

   535 void CMsvCompletedOperation::DoCancel()

   536 	{

   537 	TRequestStatus* pstat=&iObserverRequestStatus;

   538 	User::RequestComplete(pstat, iStatus.Int());

   539 	}

   540 

   541 void CMsvCompletedOperation::RunL()

   542 	{

   543 	TRequestStatus* pstat=&iObserverRequestStatus;

   544 	User::RequestComplete(pstat, iStatus.Int());

   545 	}

   546 

   547 

   548 //**********************************

   549 // CMsvSendOperation

   550 //**********************************

   551 

   552 /** Constructor.

   553 

   554 @param aSession Message Server session to use

   555 @param aObserverRequestStatus Request status of the operation observer. This 

   556 

   557 @return New CMsvSendOperation object

   558 @leave KErrNoMemory

   559 */

   560 EXPORT_C CMsvSendOperation::CMsvSendOperation(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus) :

   561 	CMsvOperation(aMsvSession, CActive::EPriorityStandard, aObserverRequestStatus)

   562 	{

   563 	iObserverRequestStatus = KRequestPending;

   564 	CActiveScheduler::Add(this);

   565 	}

   566 	

   567 /** 

   568 Takes ownership of a CMsvOperation object that is set to complete iStatus of this object.

   569 This implementation does not leave.

   570 

   571 @param anOperation CMsvOperation object

   572 */

   573 EXPORT_C void CMsvSendOperation::Start(CMsvOperation* aOperation)

   574 	{

   575 	iOperation = aOperation;

   576 	iMtm = iOperation->Mtm();

   577 	iService = iOperation->Service();

   578 	SetActive();

   579 	}

   580 	

   581 /** Destructor.

   582 

   583 Any active request on the object is cancelled.

   584 */

   585 EXPORT_C CMsvSendOperation::~CMsvSendOperation()

   586 	{

   587 	Cancel();

   588 	delete iOperation;

   589 	}

   590 

   591 /** Gets progress information about the current send operation

   592 

   593 Returns the translated progress for the current send operation. Calls the underlying

   594 ProgressL function to obtain the native progress then calls TranslateProgressL to 

   595 translate the native progress into standard send progress. 

   596 

   597 @return Descriptor holding progress information

   598 */

   599 EXPORT_C const TDesC8& CMsvSendOperation::ProgressL()

   600 	{ 

   601 	return TranslateProgress(iOperation->ProgressL()); 

   602 	}

   603 

   604 /** Gets information about a completed operation. 

   605 

   606 Returns the translated progress for the current send operation. Calls the sending 

   607 operation's FinalProgress function to obtain the native progress then calls 

   608 TranslateProgressL to translate the native progress into standard send progress. 

   609 

   610 @return Descriptor holding progress information

   611 */

   612 EXPORT_C const TDesC8& CMsvSendOperation::FinalProgress()

   613 	{ 

   614 	return TranslateProgress(iOperation->FinalProgress()); 

   615 	}

   616 

   617 /** 

   618 Called when this operation is cancelled and is active. It in turn cancels the

   619 sending operation and completes iObserverRequestStatus with KErrCancel. 

   620 */

   621 EXPORT_C void CMsvSendOperation::DoCancel()

   622 	{

   623 	iOperation->Cancel();

   624 	Complete(KErrCancel);

   625 	}

   626 

   627 /**

   628 Called on completion of sending operation. Completes iObserverRequestStatus

   629 with the sending operation's status. This RunL does not leave. 

   630 */

   631 EXPORT_C void CMsvSendOperation::RunL()

   632 	{

   633 	iProgress().iError = iStatus.Int();

   634 	Complete(iStatus.Int());

   635 	}

   636 

   637 void CMsvSendOperation::Complete(TInt anError)

   638 	{

   639 	TRequestStatus* stat = &iObserverRequestStatus;

   640 	User::RequestComplete(stat, anError);

   641 	}

   642