1 /*

     2 * Copyright (c) 2007 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 "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: Implementation of customization components

    15 *

    16 */

    17  

    18 

    19 #include <mmf/common/mmfcontrollerpluginresolver.h>

    20 #include "ScreenSaverSession.h"

    21 #include "ScreenSaverClientServer.h"

    22 #include <badesca.h>

    23 #include "debug.h"

    24 #include <ecom/implementationinformation.h>

    25 #include <e32cmn.h>

    26 #include <f32file.h>

    27 

    28 CScreenSaverSession::CScreenSaverSession()

    29 	{

    30 	RDEBUG("CScreenSaverSession::CScreenSaverSession");

    31 	}

    32 

    33 

    34 CScreenSaverSession::~CScreenSaverSession()

    35 	{

    36 	RDEBUG("CScreenSaverSession::~CScreenSaverSession");

    37 	Server().DropSession();

    38 	}

    39 

    40 CScreenSaverServer& CScreenSaverSession::Server()

    41 	{

    42 	return *static_cast<CScreenSaverServer*>(const_cast<CServer2*>(CSession2::Server()));

    43 	}

    44 

    45 // ----------------------------------------------------------------------------------------

    46 // CScreenSaverSession::CreateL

    47 // 2nd phase construct for sessions - called by the CServer framework

    48 // ----------------------------------------------------------------------------------------

    49 void CScreenSaverSession::CreateL()

    50 	{

    51 	RDEBUG("CScreenSaverSession::CreateL");

    52 	Server().AddSession();

    53 	

    54 	}

    55 

    56 

    57 void CScreenSaverSession::ServiceL(const RMessage2& aMessage)

    58 	{

    59 	TRAPD(err,DispatchMessageL(aMessage));

    60 	aMessage.Complete(err);

    61 	}

    62 

    63 void CScreenSaverSession::ServiceError(const RMessage2& aMessage,TInt aError)

    64 	{

    65 	RDEBUG_2("CScreenSaverSession::ServiceError %d",aError);

    66 	CSession2::ServiceError(aMessage,aError);

    67 	}

    68 	

    69 

    70 void CScreenSaverSession::DispatchMessageL(const RMessage2& aMessage)

    71 	{

    72 	

    73 	switch(aMessage.Function())

    74 		{

    75 		case EGetAvailableScreenSavers:

    76 			{

    77 			RDEBUG("	DispatchMessageL case: EGetAvailableScreenSavers");

    78 			

    79 			

    80 			RImplInfoPtrArray screenSaverList;

    81 			CleanupResetAndDestroyPushL( screenSaverList ); 

    82 			Server().GetAvailableScreenSaversL(screenSaverList);

    83 			

    84 			TInt ssCount(0);

    85 			ssCount = screenSaverList.Count();

    86 			RDEBUG_2("	DispatchMessageL case: EGetAvailableScreenSavers : SSCount : %d",ssCount);

    87 			HBufC8* buffer = HBufC8::NewLC((sizeof(TUid)*ssCount)+sizeof(TInt8));

    88    			TPtr8 bufPtr = buffer->Des();

    89    			

    90    			RDesWriteStream stream;

    91 			stream.Open( bufPtr );

    92 			

    93 			CleanupClosePushL(stream);

    94 			

    95 			const TInt count = screenSaverList.Count();

    96 			

    97 			stream.WriteUint8L(TUint(count));

    98 			for ( TInt i = 0 ; i < count ; i++ )

    99 				{

   100 				CImplementationInformation* implInfo = screenSaverList[i];

   101 				stream.WriteInt32L( implInfo->ImplementationUid().iUid);

   102 				}

   103 			stream.CommitL();

   104 		    aMessage.WriteL( 0, bufPtr, 0 );

   105 

   106 		    CleanupStack::PopAndDestroy(&stream);

   107 		    	

   108 		    CleanupStack::PopAndDestroy(buffer);

   109 		    	

   110 		    CleanupStack::PopAndDestroy( &screenSaverList ); // screenSaverList

   111 		    

   112 			}

   113 			break;

   114 		

   115 		case EGetscreensaverInfo:

   116 			{

   117 			RDEBUG("	DispatchMessageL case: EGetscreensaverInfo");

   118 			

   119 			RImplInfoPtrArray screenSaverList;

   120 			CleanupResetAndDestroyPushL( screenSaverList ); 

   121 			

   122 			Server().GetAvailableScreenSaversL(screenSaverList);

   123 			

   124 			TInt ssCount(0);

   125 			ssCount = screenSaverList.Count();

   126 			RDEBUG_2("	DispatchMessageL case: EGetscreensaverInfo : SSCount : %d",ssCount);

   127 			

   128 			HBufC8* buffer = HBufC8::NewLC(KSSInfoBufferLength*ssCount);

   129    			TPtr8 bufPtr = buffer->Des();

   130    			

   131    			RDesWriteStream stream;

   132 			stream.Open( bufPtr );

   133 			CleanupClosePushL(stream);

   134 			

   135 			const TInt count = screenSaverList.Count();

   136 			

   137 			stream.WriteUint8L(TUint(count));

   138 			

   139 			for ( TInt i = 0 ; i < count ; i++ )

   140 				{

   141 					CImplementationInformation* implInfo = screenSaverList[i];

   142 					

   143 					stream.WriteInt32L( implInfo->ImplementationUid().iUid);	//Uid

   144 					stream.WriteInt32L( implInfo->Version());					//Version

   145 					

   146 					stream.WriteInt32L( implInfo->DisplayName().Length());	//Dispaly  Name		

   147 					stream << implInfo->DisplayName();

   148 					

   149 					stream.WriteInt32L( implInfo->OpaqueData().Length());   //Opaque Data

   150 					stream << implInfo->OpaqueData();

   151 					

   152 				}

   153 			stream.CommitL();

   154 		    aMessage.WriteL( 0, bufPtr, 0 );

   155 

   156 		    CleanupStack::PopAndDestroy(&stream);

   157 		    CleanupStack::PopAndDestroy(buffer);

   158 		    CleanupStack::PopAndDestroy( &screenSaverList );

   159 		    

   160 			}

   161 			break;

   162 		

   163 		case EScreenSaversCount:

   164 			{

   165 			RDEBUG("	DispatchMessageL case: EScreenSaversCount");

   166 				

   167 			RImplInfoPtrArray screenSaverCount;

   168 			CleanupResetAndDestroyPushL( screenSaverCount ); 

   169 			TInt count(0);

   170 			

   171 			Server().GetAvailableScreenSaversL(screenSaverCount);

   172 			

   173 			count = screenSaverCount.Count();

   174 			TPckgBuf<TInt>ssCount(count);

   175 

   176 			aMessage.WriteL(0,ssCount);

   177 			CleanupStack::Pop(&screenSaverCount)	;

   178 		    screenSaverCount.ResetAndDestroy();

   179 			

   180 			}

   181 			break;

   182 		default:

   183 			break;

   184 		}

   185 	}

   186