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 // -----------------------------------------------------------------------------

    61 // CCseSchedulerServerEngine::CCseSchedulerServerEngine

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

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

    64 //

    65 CCseSchedulerServerEngine::CCseSchedulerServerEngine( CCseSchedulerServer& aServer ) :

    66     iServer( aServer )

    67     {

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

    69         

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

    71     }

    72 

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

    74 // CCseSchedulerServerEngine::NewL

    75 // Two-phased constructor.

    76 // -----------------------------------------------------------------------------

    77 //

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

    79     {

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

    81     

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

    83     CleanupStack::PushL( self );

    84     self->ConstructL();

    85     CleanupStack::Pop( self );

    86     

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

    88     return self;

    89     }

    90 

    91 // -----------------------------------------------------------------------------

    92 // CCseSchedulerServerEngine::ConstructL

    93 // Symbian 2nd phase constructor can leave.

    94 // -----------------------------------------------------------------------------

    95 //

    96 void CCseSchedulerServerEngine::ConstructL()

    97     {

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

    99         

   100     iDb = CCseScheduleDB::NewL();

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

   102     

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

   104     }

   105 

   106 // -----------------------------------------------------------------------------

   107 // CCseSchedulerServerEngine::~CCseSchedulerServerEngine

   108 // Destructor.

   109 // -----------------------------------------------------------------------------

   110 //

   111 CCseSchedulerServerEngine::~CCseSchedulerServerEngine()

   112     {

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

   114     

   115     delete iDb;

   116     	

   117 	iPluginControllerArray.ResetAndDestroy();

   118 	iPluginControllerArray.Close();

   119     delete iCompletitionBreaker;    

   120 		

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

   122     }

   123 

   124 

   125 // -----------------------------------------------------------------------------

   126 // CCseSchedulerServerEngine::GeneralServiceL

   127 //

   128 // Schedule operations

   129 // -----------------------------------------------------------------------------

   130 //

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

   132 	{

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

   134 	

   135 	switch( aMessage.Function() )

   136 		{

   137 		case ECseAddSchedule:

   138 			{

   139 			AddScheduleL( aMessage );

   140 			break; 		

   141 			}

   142 		case ECseRemoveSchedule:

   143 			{

   144 			RemoveScheduleL( aMessage );

   145 			break;

   146 			}

   147 		case ECseGetSchedules:

   148 			{

   149 			GetSchedulesL( aMessage );	

   150 			break;

   151 			}

   152 		case ECseGetSchedule:

   153 			{

   154 			GetScheduleL( aMessage );

   155 			break;

   156 			}

   157 		case ECseGetScheduleLength:

   158 			{

   159 			GetScheduleLengthL( aMessage );

   160 			break;

   161 			}

   162 		case ECseGetSchedulesByAppUid:

   163 			{

   164 			GetSchedulesByAppUidL( aMessage );

   165 			break;

   166 			}

   167 		case ECseGetScheduleArrayLengthByAppUid:

   168 			{

   169 			GetScheduleArrayLengthByAppUidL( aMessage );

   170 			break;

   171 			}

   172 		case ECseGetOverlappingSchedulesLength:

   173 			{

   174 			GetOverlappingSchedulesLengthL( aMessage );

   175 			break;

   176 			}

   177 		case ECseGetOverlappingSchedules:

   178 			{

   179 			GetOverlappingSchedulesL( aMessage );

   180 			break;

   181 			}			

   182 		case ECseGetScheduleArrayLengthByPluginUid:

   183 			{

   184 			GetScheduleArrayLengthByPluginUidL( aMessage );

   185 			break;

   186 			}

   187 		case ECseGetSchedulesByPluginUid:

   188 			{

   189 			GetSchedulesByPluginUidL( aMessage );

   190 			break;

   191 			}

   192 		case ECseGetScheduleArrayLengthByType:

   193 			{

   194 			GetScheduleArrayLengthByTypeL( aMessage );

   195 			break;

   196 			}

   197 		case ECseGetSchedulesByType:

   198 			{

   199 			GetSchedulesByTypeL( aMessage );

   200 			break;

   201 			}

   202 		case ECseGetScheduleArrayLengthByTimeframe:		     

   203 			{

   204 			GetScheduleArrayLengthByTimeframeL( aMessage );

   205 			break;

   206 			}

   207 		case ECseGetSchedulesByTimeframe:

   208 			{

   209 			GetSchedulesByTimeframeL( aMessage );

   210 			break;

   211 			}

   212 			

   213 		default:

   214 			{

   215 			aMessage.Complete( KErrNotSupported ); 

   216 		    break; 

   217 			}

   218 		}

   219 	

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

   221 	}

   222 

   223 	

   224 // -----------------------------------------------------------------------------

   225 // CCseSchedulerServerEngine::PanicClient

   226 //

   227 // -----------------------------------------------------------------------------

   228 //

   229 void CCseSchedulerServerEngine::PanicClient( TCseSchedulerServPanic aPanic,

   230 											 const RMessage2& aMessage ) const

   231     {    

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

   233     

   234     // Panic the client on server side

   235     _LIT( KTxtClientFault, "CseSchedulerServer" );

   236     aMessage.Panic( KTxtClientFault, aPanic );

   237     

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

   239     }

   240 

   241 // -----------------------------------------------------------------------------

   242 // CCseSchedulerServerEngine::AddScheduleL

   243 //

   244 // -----------------------------------------------------------------------------

   245 //

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

   247 	{

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

   249 	TInt ret( KErrNone );

   250 	TBuf8<4> id;

   251 	

   252 	// Initialize buffers...

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

   254 	CleanupStack::PushL( schedule );

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

   256 	CleanupStack::PushL( msg );

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

   258 	

   259 	// Read schedule as a stream format to buffer

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

   261 			

   262 	RDesReadStream readStream;

   263 	CleanupClosePushL( readStream );

   264 	readStream.Open( ptr );

   265 	

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

   267 	schedule->InternalizeL( readStream );

   268 	

   269 	CleanupStack::PopAndDestroy( &readStream );

   270 	

   271 	// Add it to DB	

   272 	iDb->AddScheduleL( *schedule );

   273 	

   274 	// Make the completition value

   275 	id.FillZ();

   276 	RDesWriteStream writeStream;

   277 	CleanupClosePushL( writeStream );

   278 	writeStream.Open( id );

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

   280 	writeStream.CommitL();

   281 	CleanupStack::PopAndDestroy( &writeStream );

   282 	

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

   284 

   285     RescheduleByPluginL( schedule->PluginUid() );

   286 

   287 	CleanupStack::PopAndDestroy( msg );

   288 	CleanupStack::PopAndDestroy( schedule );

   289 

   290     aMessage.Complete( ret );    

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

   292 	}

   293 

   294 // -----------------------------------------------------------------------------

   295 // CCseSchedulerServerEngine::RemoveScheduleL

   296 //

   297 // -----------------------------------------------------------------------------

   298 //

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

   300 	{

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

   302 	

   303 	TUint32 dbIdentifier( 0 );

   304 	TBuf8<4> idBuff;

   305 	TInt32 pluginUid( 0 );

   306 	

   307 	idBuff.FillZ();

   308 	

   309 	// Read db identifier from aMessager

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

   311 	

   312 	RDesReadStream readStream;

   313 	CleanupClosePushL( readStream );

   314 	readStream.Open( idBuff );

   315 	dbIdentifier = readStream.ReadUint32L();

   316 	CleanupStack::PopAndDestroy( &readStream );

   317 	

   318 	// Remove schedule

   319 	// First check the plugin UID of removed schedule

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

   321 	CleanupStack::PushL( prog );

   322 	iDb->GetScheduleByDbIdentifierL( dbIdentifier, prog );

   323 	pluginUid = prog->PluginUid( );

   324 	// Now remove it from DB

   325 	iDb->RemoveScheduleL( dbIdentifier );	

   326 	RescheduleByPluginL( pluginUid );

   327 	

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

   329 	if( !iCompletitionBreaker->IsActive() )

   330         {            

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

   332         }

   333     else

   334         {

   335         CSELOGSTRING_HIGH_LEVEL(

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

   337         }	

   338 	

   339 	CleanupStack::PopAndDestroy( prog );

   340 	aMessage.Complete( KErrNone );	

   341 	

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

   343 	}

   344 

   345 // -----------------------------------------------------------------------------

   346 // CCseSchedulerServerEngine::GetScheduleL

   347 //

   348 // -----------------------------------------------------------------------------

   349 //

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

   351 	{

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

   353 	TUint32 dbIdentifier( 0 );

   354 	TBuf8<4> idBuff;

   355 	

   356 	idBuff.FillZ();

   357 	

   358 	// Read db identifier from aMessage

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

   360 		

   361 	if ( err == KErrNone )

   362 		{

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

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

   365 		CleanupStack::PushL( prog );

   366 

   367 		RDesReadStream readStream;

   368 		CleanupClosePushL( readStream );

   369 		readStream.Open( idBuff );

   370 		dbIdentifier = readStream.ReadUint32L();

   371 		CleanupStack::PopAndDestroy( &readStream );

   372 		

   373 		// Get schedule

   374 		iDb->GetScheduleByDbIdentifierL( dbIdentifier, prog );

   375 		

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

   377 		

   378 		// Externalize schedule to stream format

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

   380 		CleanupStack::PushL( retBuff );

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

   382 		RDesWriteStream writeStream;

   383 		CleanupClosePushL( writeStream );

   384 		writeStream.Open( retPtr );

   385 		prog->ExternalizeL( writeStream );

   386 		writeStream.CommitL();

   387 		CleanupStack::PopAndDestroy( &writeStream );

   388 		

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

   390 		CleanupStack::PopAndDestroy( retBuff );

   391 		CleanupStack::PopAndDestroy( prog );

   392 		}

   393 	

   394 	aMessage.Complete( err );

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

   396 	}

   397 	

   398 // -----------------------------------------------------------------------------

   399 // CCseSchedulerServerEngine::GetScheduleLengthL

   400 //

   401 // -----------------------------------------------------------------------------

   402 //

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

   404 	{

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

   406 	TUint32 dbIdentifier( 0 );

   407 	TBuf8<4> idBuff;

   408 	TBuf8<4> lenBuff;

   409 	TInt length( 0 );

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

   411 	CleanupStack::PushL( schedule );

   412 	idBuff.FillZ();

   413 	

   414 	// Read db identifier from aMessage

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

   416 	

   417 	RDesReadStream readStream;

   418 	CleanupClosePushL( readStream );

   419 	readStream.Open( idBuff );

   420 	dbIdentifier = readStream.ReadUint32L();

   421 	CleanupStack::PopAndDestroy( &readStream );

   422 	

   423 	// Get schedule

   424 	iDb->GetScheduleByDbIdentifierL( dbIdentifier, schedule );

   425 	

   426 	// Get schedule length

   427 	length = schedule->ExternalizeLength();

   428 	

   429 	lenBuff.FillZ();

   430 	

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

   432 	RDesWriteStream writeStream;

   433 	CleanupClosePushL( writeStream );

   434 	writeStream.Open( lenBuff );

   435     writeStream.WriteInt32L( length );

   436 	writeStream.CommitL();

   437     CleanupStack::PopAndDestroy( &writeStream );

   438     

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

   440     

   441     CleanupStack::PopAndDestroy( schedule );

   442 	

   443 	aMessage.Complete( KErrNone );

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

   445 	}

   446 	

   447 // -----------------------------------------------------------------------------

   448 // CCseSchedulerServerEngine::GetScheduleLengthL

   449 //

   450 // -----------------------------------------------------------------------------

   451 //

   452 void CCseSchedulerServerEngine::GetScheduleArrayLengthByAppUidL( 

   453 											const RMessage2& aMessage )

   454 	{

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

   456 	TInt32 appUid( 0 );

   457 	TBuf8<4> idBuff;

   458 	TBuf8<4> lenBuff;

   459 	TInt length( 0 );

   460 	idBuff.FillZ();

   461 	

   462 	// Read application uid from aMessage

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

   464 	

   465 	RDesReadStream readStream;

   466 	CleanupClosePushL( readStream );

   467 	readStream.Open( idBuff );

   468 	appUid = readStream.ReadInt32L();

   469 	CleanupStack::PopAndDestroy( &readStream );

   470 

   471     // Get schedules from database

   472 	RPointerArray<CCseScheduledProgram> progArray;

   473 	CleanupResetAndDestroyPushL( progArray );

   474 	iDb->GetApplicationSchedulesL( appUid, progArray );

   475 	

   476 	// Calculate total length

   477 	// Number of items in array

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

   479 	// Data from array

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

   481 		{

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

   483 		}

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

   485 	

   486 	lenBuff.FillZ();

   487 	

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

   489 	RDesWriteStream writeStream;

   490 	CleanupClosePushL( writeStream );

   491 	writeStream.Open( lenBuff );

   492     writeStream.WriteInt32L( length );

   493     CleanupStack::PopAndDestroy( &writeStream );

   494     

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

   496     

   497   	aMessage.Complete( KErrNone );	

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

   499 	}

   500 

   501 // -----------------------------------------------------------------------------

   502 // CCseSchedulerServerEngine::GetSchedulesByAppUidL

   503 //

   504 // -----------------------------------------------------------------------------

   505 //

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

   507 	{

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

   509 	TInt32 appUid( 0 );

   510 	TBuf8<4> idBuff;

   511 	idBuff.FillZ();

   512 	TInt32 numberOfElems( 0 );

   513 	TInt length( 0 );

   514 	

   515 	// Read application UID from aMessage

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

   517 		

   518 	if ( err == KErrNone )

   519 		{

   520 		RPointerArray<CCseScheduledProgram> progArray;

   521 		CleanupResetAndDestroyPushL( progArray );

   522 		RDesReadStream readStream;

   523 		CleanupClosePushL( readStream );

   524 		readStream.Open( idBuff );

   525 		appUid = readStream.ReadInt32L();

   526 		CleanupStack::PopAndDestroy( &readStream );

   527 		

   528 		// Get schedules from database

   529 		iDb->GetApplicationSchedulesL( appUid, progArray );

   530 		

   531 		// Calculate total length

   532 		// Number of items in array

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

   534 		// Data from array

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

   536 			{		

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

   538 			}

   539 		

   540 		// Allocate write stream

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

   542 		CleanupStack::PushL( retBuff );

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

   544 		RDesWriteStream writeStream;

   545 		CleanupClosePushL( writeStream );

   546 		writeStream.Open( retPtr );

   547 		

   548 		// Fill stream

   549 		// Write number elems

   550 		numberOfElems = progArray.Count();

   551 		writeStream.WriteInt32L( numberOfElems );		

   552 		// Add elems one by one

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

   554 			{

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

   556 			}

   557 		writeStream.CommitL();

   558 		

   559 		CleanupStack::PopAndDestroy( &writeStream );

   560 		

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

   562 		

   563 		CleanupStack::PopAndDestroy( retBuff );

   564 		CleanupStack::PopAndDestroy( &progArray );

   565 		}

   566 

   567 	aMessage.Complete( err );

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

   569 	}

   570 

   571 // -----------------------------------------------------------------------------

   572 // CCseSchedulerServerEngine::GetSchedulesL

   573 //

   574 // -----------------------------------------------------------------------------

   575 //

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

   577 	{

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

   579 	aMessage.Complete( KErrNotSupported );

   580 	}

   581     

   582 // -----------------------------------------------------------------------------

   583 // CCseSchedulerServerEngine::GetOverlappingSchedulesLengthL

   584 //

   585 // -----------------------------------------------------------------------------

   586 //

   587 void CCseSchedulerServerEngine::GetOverlappingSchedulesLengthL( 

   588 											const RMessage2& aMessage )

   589 	{

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

   591 	TInt32 scheduleType( 0 );

   592 	TBuf8<20> idBuff;

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

   594 	

   595 	TUint32 length( 0 );

   596 	

   597 	idBuff.FillZ();

   598 	

   599 	// Read schedule type from aMessage

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

   601 	

   602 	RDesReadStream readStream;

   603 	CleanupClosePushL( readStream );

   604 	readStream.Open( idBuff );

   605 	scheduleType = readStream.ReadInt32L();

   606 

   607 	TUint32 lower( 0 );

   608 	TUint32 upper( 0 );

   609 	

   610 	// Read start time from the aMessage

   611     lower = readStream.ReadUint32L();

   612     upper = readStream.ReadUint32L();

   613     TInt64 time( 0 );

   614     time = (TInt64) lower;    

   615     TInt64 longUpper = (TInt64) upper;

   616     longUpper = longUpper << 32;

   617     longUpper &= (0xFFFFFFFF00000000ULL);    

   618     time |= longUpper;

   619     TInt64 startTime = time;  

   620         

   621 	// Read end time from the aMessage

   622 	lower = readStream.ReadUint32L();

   623     upper = readStream.ReadUint32L();

   624     time = (TInt64) lower;    

   625     longUpper = (TInt64) upper;

   626     longUpper = longUpper << 32;

   627     longUpper &= (0xFFFFFFFF00000000ULL);    

   628     time |= longUpper;

   629     TInt64 endTime = time;  

   630 

   631 	CleanupStack::PopAndDestroy( &readStream );

   632 

   633 	RPointerArray<CCseScheduledProgram> schedules;

   634 	CleanupResetAndDestroyPushL( schedules );

   635 	

   636 	// Get overlapping schedules

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

   638 	

   639 	// Count length one by one

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

   641 		{

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

   643 		}

   644 	

   645 	CleanupStack::PopAndDestroy( &schedules );	

   646 

   647 	retBuf.FillZ();

   648 	

   649 	

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

   651 	RDesWriteStream writeStream;

   652 	CleanupClosePushL( writeStream );

   653 	writeStream.Open( retBuf );

   654     writeStream.WriteInt32L( length );

   655 	writeStream.CommitL();

   656     CleanupStack::PopAndDestroy( &writeStream );

   657     

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

   659 

   660 	aMessage.Complete( KErrNone );

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

   662 	}

   663 

   664 

   665 // -----------------------------------------------------------------------------

   666 // CCseSchedulerServerEngine::GetOverlappingSchedulesL

   667 //

   668 // -----------------------------------------------------------------------------

   669 //

   670 void CCseSchedulerServerEngine::GetOverlappingSchedulesL( 

   671 											const RMessage2& aMessage )

   672 	{

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

   674 	TInt32 scheduleType( 0 );

   675 	TBuf8<20> idBuff;

   676 	

   677 	idBuff.FillZ();

   678 	

   679 	// Read schedule type from aMessage

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

   681 	

   682 	RDesReadStream readStream;

   683 	CleanupClosePushL( readStream );

   684 	readStream.Open( idBuff );

   685 	scheduleType = readStream.ReadInt32L();

   686 

   687 	TUint32 lower( 0 );

   688 	TUint32 upper( 0 );

   689 	

   690 	// Read start time from aMessage

   691     lower = readStream.ReadUint32L();

   692     upper = readStream.ReadUint32L();

   693     TInt64 time( 0 );

   694     time = (TInt64) lower;    

   695     TInt64 longUpper = (TInt64) upper;

   696     longUpper = longUpper << 32;

   697     longUpper &= (0xFFFFFFFF00000000ULL);    

   698     time |= longUpper;

   699     TInt64 startTime = time;  

   700         

   701 	//Read end time from aMessage

   702 	lower = readStream.ReadUint32L();

   703     upper = readStream.ReadUint32L();

   704     time = (TInt64) lower;    

   705     longUpper = (TInt64) upper;

   706     longUpper = longUpper << 32;

   707     longUpper &= (0xFFFFFFFF00000000ULL);    

   708     time |= longUpper;

   709     TInt64 endTime = time;  

   710 

   711 	CleanupStack::PopAndDestroy( &readStream );

   712 

   713 	RPointerArray<CCseScheduledProgram> schedules;

   714 	CleanupResetAndDestroyPushL( schedules );

   715 	

   716 	// Get overlapping schedules from database

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

   718 	

   719 	TUint32 length( 0 );

   720 

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

   722 	

   723 	// Length of the schedules needed for transfer stream

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

   725 		{

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

   727 		}

   728 	

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

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

   731 

   732 	RDesWriteStream writeStream;

   733 	CleanupClosePushL( writeStream );

   734 	writeStream.Open( retBufPtr );

   735 	// write item count to buffer

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

   737 	

   738 	// write all items to buffer

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

   740 		{

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

   742 		}

   743 	writeStream.CommitL();

   744     CleanupStack::PopAndDestroy( &writeStream );

   745 

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

   747 

   748     CleanupStack::PopAndDestroy( retBuf );

   749 	CleanupStack::PopAndDestroy( &schedules );	

   750 

   751 	aMessage.Complete( KErrNone );

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

   753 	}

   754 

   755 

   756 

   757 // -----------------------------------------------------------------------------

   758 // CCseSchedulerServerEngine::RescheduleL

   759 //

   760 // -----------------------------------------------------------------------------

   761 //

   762 void CCseSchedulerServerEngine::RescheduleL()

   763 	{

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

   765 			

   766 	RArray<TInt32> uidArray;

   767 	

   768 	iDb->GetPluginsL( uidArray );

   769 	

   770 	if( uidArray.Count() > 0 )

   771 	    {

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

   773 	        {

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

   775 	        

   776 	        // Search for existing plugin controller for this schedule

   777 	        RPointerArray<CCseScheduledProgram> schedules;

   778 	        CleanupResetAndDestroyPushL( schedules ); 	        

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

   780 	        

   781 	        if( schedules.Count() > 0 )

   782 	            {	        

   783     	        TBool controllerFound( EFalse );

   784     	        

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

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

   787     	            {

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

   789     	                {

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

   791     	                controllerFound = ETrue;

   792     	                break;	                

   793     	                }	                

   794     	            }

   795     	        

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

   797     	        if( controllerFound == EFalse )

   798     	            {                            

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

   800                         {

   801                         CSELOGSTRING_HIGH_LEVEL(

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

   803                         // Create new PluginController

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

   805                         // Add schedules to just created controller

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

   807                         }

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

   809                         {

   810                         CSELOGSTRING_HIGH_LEVEL(

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

   812                         // Create new PluginController

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

   814                         // Add schedules to just created controller

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

   816                         }

   817                     else

   818                         {

   819                         // WTF?!?!

   820                         CSELOGSTRING_HIGH_LEVEL(

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

   822                         }

   823     	            }

   824 	            }

   825 	        // Delete schedule array.

   826 	        CleanupStack::PopAndDestroy( &schedules );

   827 	        }

   828 	    }

   829 	    

   830 	uidArray.Reset();

   831 	uidArray.Close();

   832 	

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

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

   835 	iServer.StopServer();

   836 	

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

   838 	}

   839 

   840 // -----------------------------------------------------------------------------

   841 // CCseSchedulerServerEngine::IsSchedulerActive()

   842 //

   843 // -----------------------------------------------------------------------------

   844 //

   845 TBool CCseSchedulerServerEngine::IsSchedulerActive() const

   846     {

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

   848 	

   849 	TBool ret(EFalse);

   850 	

   851 	if( iPluginControllerArray.Count() > 0 )

   852         {

   853         ret = ETrue;

   854         }

   855 	

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

   857 	return ret;

   858 	}

   859 	

   860 // -----------------------------------------------------------------------------

   861 // CCseSchedulerServerEngine::Close()

   862 //

   863 // -----------------------------------------------------------------------------

   864 //

   865 void CCseSchedulerServerEngine::Close()

   866 	{

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

   868 	

   869     while( AccessCount() >= 1 )

   870         {

   871         Dec();

   872         }

   873 	

   874 	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServerEngine::IsSchedulerActive");

   875 	}

   876 

   877 	

   878 // -----------------------------------------------------------------------------

   879 // CCseSchedulerServerEngine::GetScheduleArrayLengthByPluginUidL

   880 //

   881 // -----------------------------------------------------------------------------

   882 //

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

   884     {

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

   886 	TInt32 pluginUid( 0 );

   887 	TBuf8<4> idBuff;

   888 	TBuf8<4> lenBuff;

   889 	TInt length( 0 );

   890 	idBuff.FillZ();

   891 	

   892 	// Read application uid from aMessage

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

   894 	

   895 	RDesReadStream readStream;

   896 	CleanupClosePushL( readStream );

   897 	readStream.Open( idBuff );

   898 	pluginUid = readStream.ReadInt32L();

   899 	CleanupStack::PopAndDestroy( &readStream );

   900 

   901     // Get schedules from database

   902 	RPointerArray<CCseScheduledProgram> progArray;

   903 	CleanupResetAndDestroyPushL( progArray );	

   904 	iDb->GetSchedulesByPluginL( pluginUid, progArray);

   905 	

   906 	// Calculate total length

   907 	// Number of items in array

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

   909 	// Data from array

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

   911 		{

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

   913 		}

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

   915 	

   916 	lenBuff.FillZ();

   917 	

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

   919 	RDesWriteStream writeStream;

   920 	CleanupClosePushL( writeStream );

   921 	writeStream.Open( lenBuff );

   922     writeStream.WriteInt32L( length );

   923     CleanupStack::PopAndDestroy( &writeStream );

   924     

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

   926     

   927   	aMessage.Complete( KErrNone );	

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

   929     }

   930     

   931 // -----------------------------------------------------------------------------

   932 // CCseSchedulerServerEngine::GetSchedulesByPluginUidL

   933 //

   934 // -----------------------------------------------------------------------------

   935 //

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

   937     {

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

   939 	TInt32 pluginUid( 0 );

   940 	TBuf8<4> idBuff;

   941 	idBuff.FillZ();

   942 	TInt32 numberOfElems( 0 );

   943 	TInt length( 0 );

   944 	

   945 	// Read application UID from aMessage

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

   947 		

   948 	if ( err == KErrNone )

   949 		{

   950 		RPointerArray<CCseScheduledProgram> progArray;

   951 		CleanupResetAndDestroyPushL( progArray );

   952 		RDesReadStream readStream;

   953 		CleanupClosePushL( readStream );

   954 		readStream.Open( idBuff );

   955 		pluginUid = readStream.ReadInt32L();

   956 		CleanupStack::PopAndDestroy( &readStream );

   957 		

   958 		// Get schedules from database

   959 		iDb->GetSchedulesByPluginL( pluginUid, progArray );

   960 		

   961 		// Calculate total length

   962 		// Number of items in array

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

   964 		// Data from array

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

   966 			{		

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

   968 			}

   969 		

   970 		// Allocate write stream

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

   972 		CleanupStack::PushL( retBuff );

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

   974 		RDesWriteStream writeStream;

   975 		CleanupClosePushL( writeStream );

   976 		writeStream.Open( retPtr );

   977 		

   978 		// Fill stream

   979 		// Write number elems

   980 		numberOfElems = progArray.Count();

   981 		writeStream.WriteInt32L( numberOfElems );		

   982 		// Add elems one by one

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

   984 			{

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

   986 			}

   987 		writeStream.CommitL();

   988 		

   989 		CleanupStack::PopAndDestroy( &writeStream );

   990 		

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

   992 		

   993 		CleanupStack::PopAndDestroy( retBuff );

   994 		CleanupStack::PopAndDestroy( &progArray );

   995 		}

   996 

   997 	aMessage.Complete( err );

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

   999     }

  1000     

  1001 // -----------------------------------------------------------------------------

  1002 // CCseSchedulerServerEngine::GetScheduleArrayLengthByTypeL

  1003 //

  1004 // -----------------------------------------------------------------------------

  1005 //

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

  1007     {

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

  1009 	TInt32 type( 0 );

  1010 	TBuf8<4> idBuff;

  1011 	TBuf8<4> lenBuff;

  1012 	TInt length( 0 );

  1013 	idBuff.FillZ();

  1014 	

  1015 	// Read application uid from aMessage

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

  1017 	

  1018 	RDesReadStream readStream;

  1019 	CleanupClosePushL( readStream );

  1020 	readStream.Open( idBuff );

  1021 	type = readStream.ReadInt32L();

  1022 	CleanupStack::PopAndDestroy( &readStream );

  1023 

  1024     // Get schedules from database

  1025 	RPointerArray<CCseScheduledProgram> progArray;

  1026 	CleanupResetAndDestroyPushL( progArray );	

  1027 	iDb->GetSchedulesByTypeL( type, progArray);

  1028 	

  1029 	// Calculate total length

  1030 	// Number of items in array

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

  1032 	// Data from array

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

  1034 		{

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

  1036 		}

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

  1038 	

  1039 	lenBuff.FillZ();

  1040 	

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

  1042 	RDesWriteStream writeStream;

  1043 	CleanupClosePushL( writeStream );

  1044 	writeStream.Open( lenBuff );

  1045     writeStream.WriteInt32L( length );

  1046     CleanupStack::PopAndDestroy( &writeStream );

  1047     

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

  1049     

  1050   	aMessage.Complete( KErrNone );	

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

  1052     }

  1053 

  1054 // -----------------------------------------------------------------------------

  1055 // CCseSchedulerServerEngine::GetSchedulesByTypeL

  1056 //

  1057 // -----------------------------------------------------------------------------

  1058 //

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

  1060     {

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

  1062 	TInt32 type( 0 );

  1063 	TBuf8<4> idBuff;

  1064 	idBuff.FillZ();

  1065 	TInt32 numberOfElems( 0 );

  1066 	TInt length( 0 );

  1067 	

  1068 	// Read application UID from aMessage

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

  1070 		

  1071 	if ( err == KErrNone )

  1072 		{

  1073 		RPointerArray<CCseScheduledProgram> progArray;

  1074 		CleanupResetAndDestroyPushL( progArray );

  1075 		RDesReadStream readStream;

  1076 		CleanupClosePushL( readStream );

  1077 		readStream.Open( idBuff );

  1078 		type = readStream.ReadInt32L();

  1079 		CleanupStack::PopAndDestroy( &readStream );

  1080 		

  1081 		// Get schedules from database

  1082 		iDb->GetSchedulesByTypeL( type, progArray );

  1083 		

  1084 		// Calculate total length

  1085 		// Number of items in array

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

  1087 		// Data from array

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

  1089 			{		

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

  1091 			}

  1092 		

  1093 		// Allocate write stream

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

  1095 		CleanupStack::PushL( retBuff );

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

  1097 		RDesWriteStream writeStream;

  1098 		CleanupClosePushL( writeStream );

  1099 		writeStream.Open( retPtr );

  1100 		

  1101 		// Fill stream

  1102 		// Write number elems

  1103 		numberOfElems = progArray.Count();

  1104 		writeStream.WriteInt32L( numberOfElems );		

  1105 		// Add elems one by one

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

  1107 			{

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

  1109 			}

  1110 		writeStream.CommitL();

  1111 		

  1112 		CleanupStack::PopAndDestroy( &writeStream );

  1113 		

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

  1115 		

  1116 		CleanupStack::PopAndDestroy( retBuff );

  1117 		CleanupStack::PopAndDestroy( &progArray );

  1118 		}

  1119 

  1120 	aMessage.Complete( err );

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

  1122     }

  1123 

  1124 // -----------------------------------------------------------------------------

  1125 // CCseSchedulerServerEngine::GetScheduleArrayLengthByTimeframeL

  1126 //

  1127 // -----------------------------------------------------------------------------

  1128 //

  1129 void CCseSchedulerServerEngine::GetScheduleArrayLengthByTimeframeL( const RMessage2& aMessage )

  1130     {

  1131     CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServerEngine::GetScheduleArrayLengthByTimeframeL");	

  1132 	TBuf8<20> idBuff;

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

  1134