1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    Actual intelligence of scheduler server*

    15 */

    16 

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <s32mem.h>

    23 #include <e32def.h>

    24 #include <e32const.h>

    25 #include "CCseSchedulerServerEngine.h"      // Common methods for server

    26 #include <ipvideo/CseSchedulerClientServerCommon.h> // Common defines for client and server

    27 #include <ipvideo/CCseScheduledProgram.h>           // Represent one schedule in database

    28 #include "CseDebug.h"                       // Debug macros

    29 #include "CCseScheduleDB.h"                 // Schedule database

    30 #include "CCseSchedulerTimer.h"             // Schedule timer for determining schedule times

    31 #include <ipvideo/CCseSchedulerPluginIF.h>          // Scheduler plugin interface

    32 #include "CCseSchedulerUniPluginController.h"

    33 #include "CCseSchedulerMultiPluginController.h"

    34 #include "CCseSchedulerServer.h"

    35 

    36 

    37 // EXTERNAL DATA STRUCTURES

    38 // None.

    39 

    40 // EXTERNAL FUNCTION PROTOTYPES  

    41 // None.

    42 

    43 // CONSTANTS

    44 // None

    45 

    46 // MACROS

    47 // None.

    48 

    49 // LOCAL CONSTANTS AND MACROS

    50 // None.

    51 

    52 // MODULE DATA STRUCTURES

    53 // None.

    54 

    55 // LOCAL FUNCTION PROTOTYPES

    56 // None.

    57 

    58 // ============================ MEMBER FUNCTIONS ===============================

    59 // -----------------------------------------------------------------------------

    60 // CloseEngine

    61 // CB method used if ConstructL leaves. Just calls Close to initiate proper

    62 // shutdown sequence

    63 // -----------------------------------------------------------------------------

    64 //

    65 void CloseEngine( TAny* aPtr )

    66     {

    67     static_cast<CCseSchedulerServerEngine*>( aPtr )->Close();

    68     }

    69 

    70 // -----------------------------------------------------------------------------

    71 // CCseSchedulerServerEngine::CCseSchedulerServerEngine

    72 // C++ default constructor can NOT contain any code, that might leave.

    73 // -----------------------------------------------------------------------------

    74 //

    75 CCseSchedulerServerEngine::CCseSchedulerServerEngine( CCseSchedulerServer& aServer ) :

    76     iServer( aServer )

    77     {

    78     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::CCseSchedulerServerEngine");

    79         

    80     CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::CCseSchedulerServerEngine");

    81     }

    82 

    83 // -----------------------------------------------------------------------------

    84 // CCseSchedulerServerEngine::NewL

    85 // Two-phased constructor.

    86 // -----------------------------------------------------------------------------

    87 //

    88 CCseSchedulerServerEngine* CCseSchedulerServerEngine::NewL( CCseSchedulerServer& aServer ) 

    89     {

    90     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::NewL");

    91     

    92     CCseSchedulerServerEngine* self = new( ELeave ) CCseSchedulerServerEngine( aServer );    

    93     CleanupStack::PushL( TCleanupItem( CloseEngine, self ) );

    94     self->ConstructL();

    95     CleanupStack::Pop( ); // CleanupItem

    96     

    97     CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::NewL");

    98     return self;

    99     }

   100 

   101 // -----------------------------------------------------------------------------

   102 // CCseSchedulerServerEngine::ConstructL

   103 // Symbian 2nd phase constructor can leave.

   104 // -----------------------------------------------------------------------------

   105 //

   106 void CCseSchedulerServerEngine::ConstructL()

   107     {

   108     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::ConstructL");       

   109 

   110     iDb = CCseScheduleDB::NewL();

   111     iCompletitionBreaker = CIdle::NewL( CActive::EPriorityLow );

   112 

   113 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::ConstructL");

   114     }

   115 

   116 // -----------------------------------------------------------------------------

   117 // CCseSchedulerServerEngine::~CCseSchedulerServerEngine

   118 // Destructor.

   119 // -----------------------------------------------------------------------------

   120 //

   121 CCseSchedulerServerEngine::~CCseSchedulerServerEngine()

   122     {

   123     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::~CCseSchedulerServerEngine");

   124 

   125     delete iDb;

   126     	

   127 	iPluginControllerArray.ResetAndDestroy();

   128 	iPluginControllerArray.Close();

   129     delete iCompletitionBreaker;

   130     

   131     CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::~CCseSchedulerServerEngine");

   132     }

   133 

   134 // -----------------------------------------------------------------------------

   135 // CCseSchedulerServerEngine::GeneralServiceL

   136 //

   137 // Schedule operations

   138 // -----------------------------------------------------------------------------

   139 //

   140 void CCseSchedulerServerEngine::GeneralServiceL( const RMessage2& aMessage )

   141 	{

   142 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GeneralService");

   143 	

   144 	switch( aMessage.Function() )

   145 		{

   146 		case ECseAddSchedule:

   147 			{

   148 			AddScheduleL( aMessage );

   149 			break; 		

   150 			}

   151 		case ECseRemoveSchedule:

   152 			{

   153 			RemoveScheduleL( aMessage );

   154 			break;

   155 			}

   156 		case ECseGetSchedules:

   157 			{

   158 			GetSchedulesL( aMessage );	

   159 			break;

   160 			}

   161 		case ECseGetSchedule:

   162 			{

   163 			GetScheduleL( aMessage );

   164 			break;

   165 			}

   166 		case ECseGetScheduleLength:

   167 			{

   168 			GetScheduleLengthL( aMessage );

   169 			break;

   170 			}

   171 		case ECseGetSchedulesByAppUid:

   172 			{

   173 			GetSchedulesByAppUidL( aMessage );

   174 			break;

   175 			}

   176 		case ECseGetScheduleArrayLengthByAppUid:

   177 			{

   178 			GetScheduleArrayLengthByAppUidL( aMessage );

   179 			break;

   180 			}

   181 		case ECseGetOverlappingSchedulesLength:

   182 			{

   183 			GetOverlappingSchedulesLengthL( aMessage );

   184 			break;

   185 			}

   186 		case ECseGetOverlappingSchedules:

   187 			{

   188 			GetOverlappingSchedulesL( aMessage );

   189 			break;

   190 			}			

   191 		case ECseGetScheduleArrayLengthByPluginUid:

   192 			{

   193 			GetScheduleArrayLengthByPluginUidL( aMessage );

   194 			break;

   195 			}

   196 		case ECseGetSchedulesByPluginUid:

   197 			{

   198 			GetSchedulesByPluginUidL( aMessage );

   199 			break;

   200 			}

   201 		case ECseGetScheduleArrayLengthByType:

   202 			{

   203 			GetScheduleArrayLengthByTypeL( aMessage );

   204 			break;

   205 			}

   206 		case ECseGetSchedulesByType:

   207 			{

   208 			GetSchedulesByTypeL( aMessage );

   209 			break;

   210 			}

   211 		case ECseGetScheduleArrayLengthByTimeframe:		     

   212 			{

   213 			GetScheduleArrayLengthByTimeframeL( aMessage );

   214 			break;

   215 			}

   216 		case ECseGetSchedulesByTimeframe:

   217 			{

   218 			GetSchedulesByTimeframeL( aMessage );

   219 			break;

   220 			}

   221 			

   222 		default:

   223 			{

   224 			aMessage.Complete( KErrNotSupported ); 

   225 		    break; 

   226 			}

   227 		}

   228 	

   229 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GeneralService");

   230 	}

   231 

   232 	

   233 // -----------------------------------------------------------------------------

   234 // CCseSchedulerServerEngine::PanicClient

   235 //

   236 // -----------------------------------------------------------------------------

   237 //

   238 void CCseSchedulerServerEngine::PanicClient( TCseSchedulerServPanic aPanic,

   239 											 const RMessage2& aMessage ) const

   240     {    

   241     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::PanicClient");

   242     

   243     // Panic the client on server side

   244     _LIT( KTxtClientFault, "CseSchedulerServer" );

   245     aMessage.Panic( KTxtClientFault, aPanic );

   246     

   247     CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::PanicClient");

   248     }

   249 

   250 // -----------------------------------------------------------------------------

   251 // CCseSchedulerServerEngine::AddScheduleL

   252 //

   253 // -----------------------------------------------------------------------------

   254 //

   255 void CCseSchedulerServerEngine::AddScheduleL( const RMessage2& aMessage )

   256 	{

   257 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::AddScheduleL");

   258 	TInt ret( KErrNone );

   259 	TBuf8<4> id;

   260 	

   261 	// Initialize buffers...

   262 	CCseScheduledProgram* schedule = CCseScheduledProgram::NewL();

   263 	CleanupStack::PushL( schedule );

   264 	HBufC8* msg = HBufC8::NewL( aMessage.GetDesLengthL( 0 ) );

   265 	CleanupStack::PushL( msg );

   266 	TPtr8 ptr( msg->Des() );

   267 	

   268 	// Read schedule as a stream format to buffer

   269 	aMessage.ReadL( 0, ptr, 0 );

   270 			

   271 	RDesReadStream readStream;

   272 	CleanupClosePushL( readStream );

   273 	readStream.Open( ptr );

   274 	

   275 	// Change stream formatted schedule to "CseScheduledProgram"-format

   276 	schedule->InternalizeL( readStream );

   277 	

   278 	CleanupStack::PopAndDestroy( &readStream );

   279 	

   280 	// Add it to DB	

   281 	iDb->AddScheduleL( *schedule );

   282 	

   283 	// Make the completition value

   284 	id.FillZ();

   285 	RDesWriteStream writeStream;

   286 	CleanupClosePushL( writeStream );

   287 	writeStream.Open( id );

   288 	writeStream.WriteUint32L( schedule->DbIdentifier() );

   289 	writeStream.CommitL();

   290 	CleanupStack::PopAndDestroy( &writeStream );

   291 	

   292 	aMessage.WriteL( 1, id, 0 );

   293 

   294     RescheduleByPluginL( schedule->PluginUid() );

   295 

   296 	CleanupStack::PopAndDestroy( msg );

   297 	CleanupStack::PopAndDestroy( schedule );

   298 

   299     aMessage.Complete( ret );    

   300     CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::AddScheduleL, ret=%d", ret);

   301 	}

   302 

   303 // -----------------------------------------------------------------------------

   304 // CCseSchedulerServerEngine::RemoveScheduleL

   305 //

   306 // -----------------------------------------------------------------------------

   307 //

   308 void CCseSchedulerServerEngine::RemoveScheduleL( const RMessage2& aMessage )

   309 	{

   310 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::RemoveScheduleL");

   311 	

   312 	TUint32 dbIdentifier( 0 );

   313 	TBuf8<4> idBuff;

   314 	TInt32 pluginUid( 0 );

   315 	

   316 	idBuff.FillZ();

   317 	

   318 	// Read db identifier from aMessager

   319 	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

   320 	

   321 	RDesReadStream readStream;

   322 	CleanupClosePushL( readStream );

   323 	readStream.Open( idBuff );

   324 	dbIdentifier = readStream.ReadUint32L();

   325 	CleanupStack::PopAndDestroy( &readStream );

   326 	

   327 	// Remove schedule

   328 	// First check the plugin UID of removed schedule

   329 	CCseScheduledProgram* prog = CCseScheduledProgram::NewL();

   330 	CleanupStack::PushL( prog );

   331 	iDb->GetScheduleByDbIdentifierL( dbIdentifier, prog );

   332 	pluginUid = prog->PluginUid( );

   333 	// Now remove it from DB

   334 	iDb->RemoveScheduleL( dbIdentifier );	

   335 	RescheduleByPluginL( pluginUid );

   336 	

   337 	// Use completition callback to remove those controllers that aren't needed anymore

   338 	if( !iCompletitionBreaker->IsActive() )

   339         {            

   340         iCompletitionBreaker->Start(TCallBack( CompletitionCallback, this ));

   341         }

   342     else

   343         {

   344         CSELOGSTRING_HIGH_LEVEL(

   345             "CCseSchedulerServerEngine::ScheduleCompletedSuccesfully - Breaker already active");

   346         }	

   347 	

   348 	CleanupStack::PopAndDestroy( prog );

   349 	aMessage.Complete( KErrNone );	

   350 	

   351 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::RemoveScheduleL");

   352 	}

   353 

   354 // -----------------------------------------------------------------------------

   355 // CCseSchedulerServerEngine::GetScheduleL

   356 //

   357 // -----------------------------------------------------------------------------

   358 //

   359 void CCseSchedulerServerEngine::GetScheduleL( const RMessage2& aMessage )

   360 	{

   361 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleL");

   362 	TUint32 dbIdentifier( 0 );

   363 	TBuf8<4> idBuff;

   364 	

   365 	idBuff.FillZ();

   366 	

   367 	// Read db identifier from aMessage

   368 	TInt err( aMessage.Read( 0, idBuff ) );

   369 		

   370 	if ( err == KErrNone )

   371 		{

   372 		// Create new db identifier to be passed to client

   373 		CCseScheduledProgram* prog = CCseScheduledProgram::NewL();

   374 		CleanupStack::PushL( prog );

   375 

   376 		RDesReadStream readStream;

   377 		CleanupClosePushL( readStream );

   378 		readStream.Open( idBuff );

   379 		dbIdentifier = readStream.ReadUint32L();

   380 		CleanupStack::PopAndDestroy( &readStream );

   381 		

   382 		// Get schedule

   383 		iDb->GetScheduleByDbIdentifierL( dbIdentifier, prog );

   384 		

   385 		TInt length( prog->ExternalizeLength() );

   386 		

   387 		// Externalize schedule to stream format

   388 		HBufC8* retBuff = HBufC8::NewL( length );

   389 		CleanupStack::PushL( retBuff );

   390 		TPtr8 retPtr( retBuff->Des() );

   391 		RDesWriteStream writeStream;

   392 		CleanupClosePushL( writeStream );

   393 		writeStream.Open( retPtr );

   394 		prog->ExternalizeL( writeStream );

   395 		writeStream.CommitL();

   396 		CleanupStack::PopAndDestroy( &writeStream );

   397 		

   398 		User::LeaveIfError( aMessage.Write( 1, retPtr ) );

   399 		CleanupStack::PopAndDestroy( retBuff );

   400 		CleanupStack::PopAndDestroy( prog );

   401 		}

   402 	

   403 	aMessage.Complete( err );

   404 	CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::RemoveScheduleL, err=%d", err);

   405 	}

   406 	

   407 // -----------------------------------------------------------------------------

   408 // CCseSchedulerServerEngine::GetScheduleLengthL

   409 //

   410 // -----------------------------------------------------------------------------

   411 //

   412 void CCseSchedulerServerEngine::GetScheduleLengthL( const RMessage2& aMessage )

   413 	{

   414 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleLengthL");

   415 	TUint32 dbIdentifier( 0 );

   416 	TBuf8<4> idBuff;

   417 	TBuf8<4> lenBuff;

   418 	TInt length( 0 );

   419 	CCseScheduledProgram* schedule = CCseScheduledProgram::NewL();

   420 	CleanupStack::PushL( schedule );

   421 	idBuff.FillZ();

   422 	

   423 	// Read db identifier from aMessage

   424 	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

   425 	

   426 	RDesReadStream readStream;

   427 	CleanupClosePushL( readStream );

   428 	readStream.Open( idBuff );

   429 	dbIdentifier = readStream.ReadUint32L();

   430 	CleanupStack::PopAndDestroy( &readStream );

   431 	

   432 	// Get schedule

   433 	iDb->GetScheduleByDbIdentifierL( dbIdentifier, schedule );

   434 	

   435 	// Get schedule length

   436 	length = schedule->ExternalizeLength();

   437 	

   438 	lenBuff.FillZ();

   439 	

   440 	// Write length in stream so we can pass it to client

   441 	RDesWriteStream writeStream;

   442 	CleanupClosePushL( writeStream );

   443 	writeStream.Open( lenBuff );

   444     writeStream.WriteInt32L( length );

   445 	writeStream.CommitL();

   446     CleanupStack::PopAndDestroy( &writeStream );

   447     

   448     User::LeaveIfError( aMessage.Write( 1, lenBuff ) );

   449     

   450     CleanupStack::PopAndDestroy( schedule );

   451 	

   452 	aMessage.Complete( KErrNone );

   453 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetScheduleLengthL");

   454 	}

   455 	

   456 // -----------------------------------------------------------------------------

   457 // CCseSchedulerServerEngine::GetScheduleLengthL

   458 //

   459 // -----------------------------------------------------------------------------

   460 //

   461 void CCseSchedulerServerEngine::GetScheduleArrayLengthByAppUidL( 

   462 											const RMessage2& aMessage )

   463 	{

   464 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleArrayLengthByAppUidL");

   465 	TInt32 appUid( 0 );

   466 	TBuf8<4> idBuff;

   467 	TBuf8<4> lenBuff;

   468 	TInt length( 0 );

   469 	idBuff.FillZ();

   470 	

   471 	// Read application uid from aMessage

   472 	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

   473 	

   474 	RDesReadStream readStream;

   475 	CleanupClosePushL( readStream );

   476 	readStream.Open( idBuff );

   477 	appUid = readStream.ReadInt32L();

   478 	CleanupStack::PopAndDestroy( &readStream );

   479 

   480     // Get schedules from database

   481 	RPointerArray<CCseScheduledProgram> progArray;

   482 	CleanupResetAndDestroyPushL( progArray );

   483 	iDb->GetApplicationSchedulesL( appUid, progArray );

   484 	

   485 	// Calculate total length

   486 	// Number of items in array

   487 	length = length + 4; // Size of TInt32

   488 	// Data from array

   489 	for ( TInt i = 0 ; i < progArray.Count(); i++ )

   490 		{

   491 		length = length + progArray[i]->ExternalizeLength();

   492 		}

   493 	CleanupStack::PopAndDestroy( &progArray ); // closes progArray

   494 	

   495 	lenBuff.FillZ();

   496 	

   497 	// Change length value to stream so that we can send it back to client.

   498 	RDesWriteStream writeStream;

   499 	CleanupClosePushL( writeStream );

   500 	writeStream.Open( lenBuff );

   501     writeStream.WriteInt32L( length );

   502     CleanupStack::PopAndDestroy( &writeStream );

   503     

   504     User::LeaveIfError( aMessage.Write( 1, lenBuff ) );

   505     

   506   	aMessage.Complete( KErrNone );	

   507 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetScheduleArrayLengthByAppUidL");

   508 	}

   509 

   510 // -----------------------------------------------------------------------------

   511 // CCseSchedulerServerEngine::GetSchedulesByAppUidL

   512 //

   513 // -----------------------------------------------------------------------------

   514 //

   515 void CCseSchedulerServerEngine::GetSchedulesByAppUidL( const RMessage2& aMessage )

   516 	{

   517 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetSchedulesByAppUidL");

   518 	TInt32 appUid( 0 );

   519 	TBuf8<4> idBuff;

   520 	idBuff.FillZ();

   521 	TInt32 numberOfElems( 0 );

   522 	TInt length( 0 );

   523 	

   524 	// Read application UID from aMessage

   525 	TInt err( aMessage.Read( 0, idBuff ) );

   526 		

   527 	if ( err == KErrNone )

   528 		{

   529 		RPointerArray<CCseScheduledProgram> progArray;

   530 		CleanupResetAndDestroyPushL( progArray );

   531 		RDesReadStream readStream;

   532 		CleanupClosePushL( readStream );

   533 		readStream.Open( idBuff );

   534 		appUid = readStream.ReadInt32L();

   535 		CleanupStack::PopAndDestroy( &readStream );

   536 		

   537 		// Get schedules from database

   538 		iDb->GetApplicationSchedulesL( appUid, progArray );

   539 		

   540 		// Calculate total length

   541 		// Number of items in array

   542 		length = length + 4; // Size of TInt32

   543 		// Data from array

   544 		for ( TInt i = 0 ; i < progArray.Count(); i++ )

   545 			{		

   546 			length += progArray[i]->ExternalizeLength();

   547 			}

   548 		

   549 		// Allocate write stream

   550 		HBufC8* retBuff = HBufC8::NewL( length );

   551 		CleanupStack::PushL( retBuff );

   552 		TPtr8 retPtr( retBuff->Des() );

   553 		RDesWriteStream writeStream;

   554 		CleanupClosePushL( writeStream );

   555 		writeStream.Open( retPtr );

   556 		

   557 		// Fill stream

   558 		// Write number elems

   559 		numberOfElems = progArray.Count();

   560 		writeStream.WriteInt32L( numberOfElems );		

   561 		// Add elems one by one

   562 		for ( TInt i = 0; i < progArray.Count(); i++ )

   563 			{

   564 			progArray[i]->ExternalizeL( writeStream );

   565 			}

   566 		writeStream.CommitL();

   567 		

   568 		CleanupStack::PopAndDestroy( &writeStream );

   569 		

   570 		User::LeaveIfError( aMessage.Write( 1, retPtr ) );	

   571 		

   572 		CleanupStack::PopAndDestroy( retBuff );

   573 		CleanupStack::PopAndDestroy( &progArray );

   574 		}

   575 

   576 	aMessage.Complete( err );

   577 	CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetSchedulesByAppUidL", err);

   578 	}

   579 

   580 // -----------------------------------------------------------------------------

   581 // CCseSchedulerServerEngine::GetSchedulesL

   582 //

   583 // -----------------------------------------------------------------------------

   584 //

   585 void CCseSchedulerServerEngine::GetSchedulesL( const RMessage2& aMessage )

   586 	{

   587 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetSchedulesL");

   588 	aMessage.Complete( KErrNotSupported );

   589 	}

   590     

   591 // -----------------------------------------------------------------------------

   592 // CCseSchedulerServerEngine::GetOverlappingSchedulesLengthL

   593 //

   594 // -----------------------------------------------------------------------------

   595 //

   596 void CCseSchedulerServerEngine::GetOverlappingSchedulesLengthL( 

   597 											const RMessage2& aMessage )

   598 	{

   599 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetOverlappingSchedulesLengthL");

   600 	TInt32 scheduleType( 0 );

   601 	TBuf8<20> idBuff;

   602 	TBuf8<sizeof( TUint32 )> retBuf; // contains length

   603 	

   604 	TUint32 length( 0 );

   605 	

   606 	idBuff.FillZ();

   607 	

   608 	// Read schedule type from aMessage

   609 	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

   610 	

   611 	RDesReadStream readStream;

   612 	CleanupClosePushL( readStream );

   613 	readStream.Open( idBuff );

   614 	scheduleType = readStream.ReadInt32L();

   615 

   616 	TUint32 lower( 0 );

   617 	TUint32 upper( 0 );

   618 	

   619 	// Read start time from the aMessage

   620     lower = readStream.ReadUint32L();

   621     upper = readStream.ReadUint32L();

   622     TInt64 time( 0 );

   623     time = (TInt64) lower;    

   624     TInt64 longUpper = (TInt64) upper;

   625     longUpper = longUpper << 32;

   626     longUpper &= (0xFFFFFFFF00000000ULL);    

   627     time |= longUpper;

   628     TInt64 startTime = time;  

   629         

   630 	// Read end time from the aMessage

   631 	lower = readStream.ReadUint32L();

   632     upper = readStream.ReadUint32L();

   633     time = (TInt64) lower;    

   634     longUpper = (TInt64) upper;

   635     longUpper = longUpper << 32;

   636     longUpper &= (0xFFFFFFFF00000000ULL);    

   637     time |= longUpper;

   638     TInt64 endTime = time;  

   639 

   640 	CleanupStack::PopAndDestroy( &readStream );

   641 

   642 	RPointerArray<CCseScheduledProgram> schedules;

   643 	CleanupResetAndDestroyPushL( schedules );

   644 	

   645 	// Get overlapping schedules

   646 	iDb->GetOverlappingSchedulesL( scheduleType, startTime, endTime, schedules );

   647 	

   648 	// Count length one by one

   649 	for ( TInt i = 0; i < schedules.Count(); i++ )

   650 		{

   651 		length += schedules[i]->ExternalizeLength();

   652 		}

   653 	

   654 	CleanupStack::PopAndDestroy( &schedules );	

   655 

   656 	retBuf.FillZ();

   657 	

   658 	

   659 	// Write length to stream so we can pass it to client

   660 	RDesWriteStream writeStream;

   661 	CleanupClosePushL( writeStream );

   662 	writeStream.Open( retBuf );

   663     writeStream.WriteInt32L( length );

   664 	writeStream.CommitL();

   665     CleanupStack::PopAndDestroy( &writeStream );

   666     

   667     User::LeaveIfError( aMessage.Write( 1, retBuf ) );

   668 

   669 	aMessage.Complete( KErrNone );

   670 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetOverlappingSchedulesLengthL");

   671 	}

   672 

   673 

   674 // -----------------------------------------------------------------------------

   675 // CCseSchedulerServerEngine::GetOverlappingSchedulesL

   676 //

   677 // -----------------------------------------------------------------------------

   678 //

   679 void CCseSchedulerServerEngine::GetOverlappingSchedulesL( 

   680 											const RMessage2& aMessage )

   681 	{

   682 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetOverlappingSchedulesL");

   683 	TInt32 scheduleType( 0 );

   684 	TBuf8<20> idBuff;

   685 	

   686 	idBuff.FillZ();

   687 	

   688 	// Read schedule type from aMessage

   689 	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

   690 	

   691 	RDesReadStream readStream;

   692 	CleanupClosePushL( readStream );

   693 	readStream.Open( idBuff );

   694 	scheduleType = readStream.ReadInt32L();

   695 

   696 	TUint32 lower( 0 );

   697 	TUint32 upper( 0 );

   698 	

   699 	// Read start time from aMessage

   700     lower = readStream.ReadUint32L();

   701     upper = readStream.ReadUint32L();

   702     TInt64 time( 0 );

   703     time = (TInt64) lower;    

   704     TInt64 longUpper = (TInt64) upper;

   705     longUpper = longUpper << 32;

   706     longUpper &= (0xFFFFFFFF00000000ULL);    

   707     time |= longUpper;

   708     TInt64 startTime = time;  

   709         

   710 	//Read end time from aMessage

   711 	lower = readStream.ReadUint32L();

   712     upper = readStream.ReadUint32L();

   713     time = (TInt64) lower;    

   714     longUpper = (TInt64) upper;

   715     longUpper = longUpper << 32;

   716     longUpper &= (0xFFFFFFFF00000000ULL);    

   717     time |= longUpper;

   718     TInt64 endTime = time;  

   719 

   720 	CleanupStack::PopAndDestroy( &readStream );

   721 

   722 	RPointerArray<CCseScheduledProgram> schedules;

   723 	CleanupResetAndDestroyPushL( schedules );

   724 	

   725 	// Get overlapping schedules from database

   726 	iDb->GetOverlappingSchedulesL( scheduleType, startTime, endTime, schedules );

   727 	

   728 	TUint32 length( 0 );

   729 

   730 	length += sizeof( TInt32 ); // item count added to buffer first

   731 	

   732 	// Length of the schedules needed for transfer stream

   733 	for ( TInt i = 0; i < schedules.Count(); i++ )

   734 		{

   735 		length += schedules[i]->ExternalizeLength();

   736 		}

   737 	

   738 	HBufC8* retBuf = HBufC8::NewLC( length );

   739 	TPtr8 retBufPtr( retBuf->Des() );

   740 

   741 	RDesWriteStream writeStream;

   742 	CleanupClosePushL( writeStream );

   743 	writeStream.Open( retBufPtr );

   744 	// write item count to buffer

   745     writeStream.WriteInt32L( schedules.Count() );

   746 	

   747 	// write all items to buffer

   748 	for ( TInt j = 0; j < schedules.Count(); j++ )

   749 		{

   750 		schedules[j]->ExternalizeL( writeStream );

   751 		}

   752 	writeStream.CommitL();

   753     CleanupStack::PopAndDestroy( &writeStream );

   754 

   755 	User::LeaveIfError( aMessage.Write( 1, retBufPtr ) );

   756 

   757     CleanupStack::PopAndDestroy( retBuf );

   758 	CleanupStack::PopAndDestroy( &schedules );	

   759 

   760 	aMessage.Complete( KErrNone );

   761 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetOverlappingSchedulesL");

   762 	}

   763 

   764 

   765 

   766 // -----------------------------------------------------------------------------

   767 // CCseSchedulerServerEngine::RescheduleL

   768 //

   769 // -----------------------------------------------------------------------------

   770 //

   771 void CCseSchedulerServerEngine::RescheduleL()

   772 	{

   773 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::Reschedule");

   774 			

   775 	RArray<TInt32> uidArray;

   776 	

   777 	iDb->GetPluginsL( uidArray );

   778 	

   779 	if( uidArray.Count() > 0 )

   780 	    {

   781 	    for(TInt i = 0; i < uidArray.Count(); i++)

   782 	        {

   783 	        TTime runTime( iDb->GetNextScheduleTimeByPluginL( uidArray[i] ) );

   784 	        

   785 	        // Search for existing plugin controller for this schedule

   786 	        RPointerArray<CCseScheduledProgram> schedules;

   787 	        CleanupResetAndDestroyPushL( schedules ); 	        

   788 	        iDb->GetSchedulesByTimeAndPluginL( runTime, uidArray[i], schedules );

   789 	        

   790 	        if( schedules.Count() > 0 )

   791 	            {	        

   792     	        TBool controllerFound( EFalse );

   793     	        

   794     	        // Plugin controller might existCheck if the plugin controller already exists.

   795     	        for( TInt ii = 0; ii < iPluginControllerArray.Count(); ii++ )

   796     	            {

   797     	            if( schedules[0]->PluginUid() == iPluginControllerArray[ii]->PluginUid() )

   798     	                {

   799     	                iPluginControllerArray[ii]->SetSchedulesL( schedules );

   800     	                controllerFound = ETrue;

   801     	                break;	                

   802     	                }	                

   803     	            }

   804     	        

   805     	        // It didn't so we create new one

   806     	        if( controllerFound == EFalse )

   807     	            {                            

   808                     if( schedules[0]->PluginType() == CCseScheduledProgram::ECseUniPlugin )

   809                         {

   810                         CSELOGSTRING_HIGH_LEVEL(

   811                             "CCseSchedulerServerEngine::Reschedule: Create new uniplugin controller");

   812                         // Create new PluginController

   813                         iPluginControllerArray.AppendL( CCseSchedulerUniPluginController::NewL( *this, schedules[0]->PluginUid() ) );

   814                         // Add schedules to just created controller

   815                         iPluginControllerArray[iPluginControllerArray.Count()-1]->SetSchedulesL(schedules);

   816                         }

   817                     else if ( schedules[0]->PluginType() == CCseScheduledProgram::ECseMultiPlugin )

   818                         {

   819                         CSELOGSTRING_HIGH_LEVEL(

   820                         "CCseSchedulerServerEngine::Reschedule: Create new multiplugin controller");

   821                         // Create new PluginController

   822                         iPluginControllerArray.AppendL( CCseSchedulerMultiPluginController::NewL( *this, schedules[0]->PluginUid() ) );

   823                         // Add schedules to just created controller

   824                         iPluginControllerArray[iPluginControllerArray.Count()-1]->SetSchedulesL(schedules);

   825                         }

   826                     else

   827                         {

   828                         // WTF?!?!

   829                         CSELOGSTRING_HIGH_LEVEL(

   830                             "CCseSchedulerServerEngine::Reschedule: Plugin something completely different");

   831                         }

   832     	            }

   833 	            }

   834 	        // Delete schedule array.

   835 	        CleanupStack::PopAndDestroy( &schedules );

   836 	        }

   837 	    }

   838 	    

   839 	uidArray.Reset();

   840 	uidArray.Close();

   841 	

   842     // Stop server if we dont have any clients and there is no more

   843 	// reason for us to live (no schedules active).

   844 	iServer.StopServer();

   845 	

   846 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::Reschedule out");

   847 	}

   848 

   849 // -----------------------------------------------------------------------------

   850 // CCseSchedulerServerEngine::IsSchedulerActive()

   851 //

   852 // -----------------------------------------------------------------------------

   853 //

   854 TBool CCseSchedulerServerEngine::IsSchedulerActive() const

   855     {

   856 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::IsSchedulerActive");

   857 	

   858 	TBool ret(EFalse);

   859 	

   860 	if( iPluginControllerArray.Count() > 0 )

   861         {

   862         ret = ETrue;

   863         }

   864 	

   865     CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::IsSchedulerActive: %d", ret);

   866 	return ret;

   867 	}

   868 	

   869 // -----------------------------------------------------------------------------

   870 // CCseSchedulerServerEngine::Close()

   871 //

   872 // -----------------------------------------------------------------------------

   873 //

   874 void CCseSchedulerServerEngine::Close()

   875 	{

   876 	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::Close");

   877 	

   878     while( AccessCount() >= 1 )

   879         {

   880         Dec();

   881         }

   882 	

   883 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::Close");

   884 	}

   885 

   886 	

   887 // -----------------------------------------------------------------------------

   888 // CCseSchedulerServerEngine::GetScheduleArrayLengthByPluginUidL

   889 //

   890 // -----------------------------------------------------------------------------

   891 //

   892 void CCseSchedulerServerEngine::GetScheduleArrayLengthByPluginUidL( const RMessage2& aMessage )

   893     {

   894     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleArrayLengthByPluginUidL");

   895 	TInt32 pluginUid( 0 );

   896 	TBuf8<4> idBuff;

   897 	TBuf8<4> lenBuff;

   898 	TInt length( 0 );

   899 	idBuff.FillZ();

   900 	

   901 	// Read application uid from aMessage

   902 	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

   903 	

   904 	RDesReadStream readStream;

   905 	CleanupClosePushL( readStream );

   906 	readStream.Open( idBuff );

   907 	pluginUid = readStream.ReadInt32L();

   908 	CleanupStack::PopAndDestroy( &readStream );

   909 

   910     // Get schedules from database

   911 	RPointerArray<CCseScheduledProgram> progArray;

   912 	CleanupResetAndDestroyPushL( progArray );	

   913 	iDb->GetSchedulesByPluginL( pluginUid, progArray);

   914 	

   915 	// Calculate total length

   916 	// Number of items in array

   917 	length = length + 4; // Size of TInt32

   918 	// Data from array

   919 	for ( TInt i = 0 ; i < progArray.Count(); i++ )

   920 		{

   921 		length = length + progArray[i]->ExternalizeLength();

   922 		}

   923 	CleanupStack::PopAndDestroy( &progArray ); // closes progArray

   924 	

   925 	lenBuff.FillZ();

   926 	

   927 	// Change length value to stream so that we can send it back to client.

   928 	RDesWriteStream writeStream;

   929 	CleanupClosePushL( writeStream );

   930 	writeStream.Open( lenBuff );

   931     writeStream.WriteInt32L( length );

   932     CleanupStack::PopAndDestroy( &writeStream );

   933     

   934     User::LeaveIfError( aMessage.Write( 1, lenBuff ) );

   935     

   936   	aMessage.Complete( KErrNone );	

   937 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetScheduleArrayLengthByPluginUidL");

   938     }

   939     

   940 // -----------------------------------------------------------------------------

   941 // CCseSchedulerServerEngine::GetSchedulesByPluginUidL

   942 //

   943 // -----------------------------------------------------------------------------

   944 //

   945 void CCseSchedulerServerEngine::GetSchedulesByPluginUidL( const RMessage2& aMessage )

   946     {

   947     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetSchedulesByPluginUidL");

   948 	TInt32 pluginUid( 0 );

   949 	TBuf8<4> idBuff;

   950 	idBuff.FillZ();

   951 	TInt32 numberOfElems( 0 );

   952 	TInt length( 0 );

   953 	

   954 	// Read application UID from aMessage

   955 	TInt err( aMessage.Read( 0, idBuff ) );

   956 		

   957 	if ( err == KErrNone )

   958 		{

   959 		RPointerArray<CCseScheduledProgram> progArray;

   960 		CleanupResetAndDestroyPushL( progArray );

   961 		RDesReadStream readStream;

   962 		CleanupClosePushL( readStream );

   963 		readStream.Open( idBuff );

   964 		pluginUid = readStream.ReadInt32L();

   965 		CleanupStack::PopAndDestroy( &readStream );

   966 		

   967 		// Get schedules from database

   968 		iDb->GetSchedulesByPluginL( pluginUid, progArray );

   969 		

   970 		// Calculate total length

   971 		// Number of items in array

   972 		length = length + 4; // Size of TInt32

   973 		// Data from array

   974 		for ( TInt i = 0 ; i < progArray.Count(); i++ )

   975 			{		

   976 			length += progArray[i]->ExternalizeLength();

   977 			}

   978 		

   979 		// Allocate write stream

   980 		HBufC8* retBuff = HBufC8::NewL( length );

   981 		CleanupStack::PushL( retBuff );

   982 		TPtr8 retPtr( retBuff->Des() );

   983 		RDesWriteStream writeStream;

   984 		CleanupClosePushL( writeStream );

   985 		writeStream.Open( retPtr );

   986 		

   987 		// Fill stream

   988 		// Write number elems

   989 		numberOfElems = progArray.Count();

   990 		writeStream.WriteInt32L( numberOfElems );		

   991 		// Add elems one by one

   992 		for ( TInt i = 0; i < progArray.Count(); i++ )

   993 			{

   994 			progArray[i]->ExternalizeL( writeStream );

   995 			}

   996 		writeStream.CommitL();

   997 		

   998 		CleanupStack::PopAndDestroy( &writeStream );

   999 		

  1000 		User::LeaveIfError( aMessage.Write( 1, retPtr ) );	

  1001 		

  1002 		CleanupStack::PopAndDestroy( retBuff );

  1003 		CleanupStack::PopAndDestroy( &progArray );

  1004 		}

  1005 

  1006 	aMessage.Complete( err );

  1007 	CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetSchedulesByPluginUidL", err);

  1008     }

  1009     

  1010 // -----------------------------------------------------------------------------

  1011 // CCseSchedulerServerEngine::GetScheduleArrayLengthByTypeL

  1012 //

  1013 // -----------------------------------------------------------------------------

  1014 //

  1015 void CCseSchedulerServerEngine::GetScheduleArrayLengthByTypeL( const RMessage2& aMessage )

  1016     {

  1017     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleArrayLengthByTypeL");

  1018 	TInt32 type( 0 );

  1019 	TBuf8<4> idBuff;

  1020 	TBuf8<4> lenBuff;

  1021 	TInt length( 0 );

  1022 	idBuff.FillZ();

  1023 	

  1024 	// Read application uid from aMessage

  1025 	User::LeaveIfError( aMessage.Read( 0, idBuff ) );

  1026 	

  1027 	RDesReadStream readStream;

  1028 	CleanupClosePushL( readStream );

  1029 	readStream.Open( idBuff );

  1030 	type = readStream.ReadInt32L();

  1031 	CleanupStack::PopAndDestroy( &readStream );

  1032 

  1033     // Get schedules from database

  1034 	RPointerArray<CCseScheduledProgram> progArray;

  1035 	CleanupResetAndDestroyPushL( progArray );	

  1036 	iDb->GetSchedulesByTypeL( type, progArray);

  1037 	

  1038 	// Calculate total length

  1039 	// Number of items in array

  1040 	length = length + 4; // Size of TInt32

  1041 	// Data from array

  1042 	for ( TInt i = 0 ; i < progArray.Count(); i++ )

  1043 		{

  1044 		length = length + progArray[i]->ExternalizeLength();

  1045 		}

  1046 	CleanupStack::PopAndDestroy( &progArray ); // closes progArray

  1047 	

  1048 	lenBuff.FillZ();

  1049 	

  1050 	// Change length value to stream so that we can send it back to client.

  1051 	RDesWriteStream writeStream;

  1052 	CleanupClosePushL( writeStream );

  1053 	writeStream.Open( lenBuff );

  1054     writeStream.WriteInt32L( length );

  1055     CleanupStack::PopAndDestroy( &writeStream );

  1056     

  1057     User::LeaveIfError( aMessage.Write( 1, lenBuff ) );

  1058     

  1059   	aMessage.Complete( KErrNone );	

  1060 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetScheduleArrayLengthByTypeL");

  1061     }

  1062 

  1063 // -----------------------------------------------------------------------------

  1064 // CCseSchedulerServerEngine::GetSchedulesByTypeL

  1065 //

  1066 // -----------------------------------------------------------------------------

  1067 //

  1068 void CCseSchedulerServerEngine::GetSchedulesByTypeL( const RMessage2& aMessage )

  1069     {

  1070     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetSchedulesByTypeL");

  1071 	TInt32 type( 0 );

  1072 	TBuf8<4> idBuff;

  1073 	idBuff.FillZ();

  1074 	TInt32 numberOfElems( 0 );

  1075 	TInt length( 0 );

  1076 	

  1077 	// Read application UID from aMessage

  1078 	TInt err( aMessage.Read( 0, idBuff ) );

  1079 		

  1080 	if ( err == KErrNone )

  1081 		{

  1082 		RPointerArray<CCseScheduledProgram> progArray;

  1083 		CleanupResetAndDestroyPushL( progArray );

  1084 		RDesReadStream readStream;

  1085 		CleanupClosePushL( readStream );

  1086 		readStream.Open( idBuff );

  1087 		type = readStream.ReadInt32L();

  1088 		CleanupStack::PopAndDestroy( &readStream );

  1089 		

  1090 		// Get schedules from database

  1091 		iDb->GetSchedulesByTypeL( type, progArray );

  1092 		

  1093 		// Calculate total length

  1094 		// Number of items in array

  1095 		length = length + 4; // Size of TInt32

  1096 		// Data from array

  1097 		for ( TInt i = 0 ; i < progArray.Count(); i++ )

  1098 			{		

  1099 			length += progArray[i]->ExternalizeLength();

  1100 			}

  1101 		

  1102 		// Allocate write stream

  1103 		HBufC8* retBuff = HBufC8::NewL( length );

  1104 		CleanupStack::PushL( retBuff );

  1105 		TPtr8 retPtr( retBuff->Des() );

  1106 		RDesWriteStream writeStream;

  1107 		CleanupClosePushL( writeStream );

  1108 		writeStream.Open( retPtr );

  1109 		

  1110 		// Fill stream

  1111 		// Write number elems

  1112 		numberOfElems = progArray.Count();

  1113 		writeStream.WriteInt32L( numberOfElems );		

  1114 		// Add elems one by one

  1115 		for ( TInt i = 0; i < progArray.Count(); i++ )

  1116 			{

  1117 			progArray[i]->ExternalizeL( writeStream );

  1118 			}

  1119 		writeStream.CommitL();

  1120 		

  1121 		CleanupStack::PopAndDestroy( &writeStream );

  1122 		

  1123 		User::LeaveIfError( aMessage.Write( 1, retPtr ) );	

  1124 		

  1125 		CleanupStack::PopAndDestroy( retBuff );

  1126 		CleanupStack::PopAndDestroy( &progArray );

  1127 		}

  1128 

  1129 	aMessage.Complete( err );

  1130 	CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerServerEngine::GetSchedulesByTypeL", err);

  1131     }

  1132 

  1133 // -----------------------------------------------------------------------------

  1134 // CCseSchedulerServerEngine::GetScheduleArrayLengthByTimeframeL