uiacceltk/hitchcock/AlfDecoderServerClient/src/alfcompositionclient.cpp
branchRCL_3
changeset 22 7c5dd702d6d3
parent 17 3ac8bf5c5014
child 24 f93c875b566e
equal deleted inserted replaced
17:3ac8bf5c5014 22:7c5dd702d6d3
  1241 
  1241 
  1242 class MAlfEffectObserverData
  1242 class MAlfEffectObserverData
  1243     {
  1243     {
  1244     public:
  1244     public:
  1245         virtual void Remove(CAlfSignalObserver* aObserver) = 0;
  1245         virtual void Remove(CAlfSignalObserver* aObserver) = 0;
       
  1246         virtual RAlfBridgerClient& Client() = 0;
  1246     };
  1247     };
  1247 
  1248 
  1248 NONSHARABLE_CLASS(CAlfEffectObserver::CAlfEffectObserverData): public CBase, public MAlfEffectObserverData
  1249 NONSHARABLE_CLASS(CAlfEffectObserver::CAlfEffectObserverData): public CBase, public MAlfEffectObserverData
  1249     {
  1250     {
  1250     public:
  1251     public:
  1251     void SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType = MAlfEffectObserver::EAlfEffectComplete );        
  1252     void SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType = MAlfEffectObserver::EAlfEffectComplete );        
  1252     ~CAlfEffectObserverData();
  1253     ~CAlfEffectObserverData();
  1253     void Remove(CAlfSignalObserver* aObserver);
  1254     void Remove(CAlfSignalObserver* aObserver);
       
  1255     RAlfBridgerClient& Client();
  1254     
  1256     
  1255     // data
  1257     // data
  1256     RAlfBridgerClient iClient;
  1258     RAlfBridgerClient iClient;
  1257     RPointerArray<CAlfSignalObserver> iObservers;
  1259     RPointerArray<CAlfSignalObserver> iObservers;
  1258     };
  1260     };
  1265         iOwner(aOwner), iObserver(aObserver), iHandle(aHandle), iType(aType), iArgs(aHandle,aType)
  1267         iOwner(aOwner), iObserver(aObserver), iHandle(aHandle), iType(aType), iArgs(aHandle,aType)
  1266         {   
  1268         {   
  1267         CActiveScheduler::Add(this);
  1269         CActiveScheduler::Add(this);
  1268         SetActive(); 
  1270         SetActive(); 
  1269         }
  1271         }
  1270                 
  1272 		
  1271     void DoCancel(){} // do not...
  1273     ~CAlfSignalObserver()
  1272     
  1274         {
       
  1275         Cancel();
       
  1276         }
       
  1277 
       
  1278     private:
       
  1279     
       
  1280         void DoCancel()
       
  1281             {
       
  1282             if (iOwner)
       
  1283                 {
       
  1284                 iOwner->Client().SendSynch(EAlfCompleteSignal, TIpcArgs(iHandle, iType));
       
  1285                 }
       
  1286             }
       
  1287     
       
  1288 	    // just to prohibit cancel outside destructor
       
  1289         void Cancel()
       
  1290             {
       
  1291             CActive::Cancel();
       
  1292 			}	   
       
  1293 	
  1273     void RunL()
  1294     void RunL()
  1274         {    
  1295         {    
  1275         iObserver->HandleEffectCallback(iType, iHandle, iStatus.Int());
  1296         iObserver->HandleEffectCallback(iType, iHandle, iStatus.Int());
  1276         iOwner->Remove(this);
  1297         iOwner->Remove(this);
  1277         }    
  1298         }    
  1278     
  1299     
  1279     MAlfEffectObserverData* iOwner;
  1300 	public:
  1280     CAlfEffectObserver::MAlfEffectObserver* iObserver;
  1301         MAlfEffectObserverData* iOwner;
  1281     TInt iHandle;        
  1302         CAlfEffectObserver::MAlfEffectObserver* iObserver;
  1282     TInt iType;
  1303         TInt iHandle;        
  1283     TIpcArgs iArgs;
  1304         TInt iType;
       
  1305         TIpcArgs iArgs;
  1284     };
  1306     };
  1285 
  1307 
  1286 void CAlfEffectObserver::CAlfEffectObserverData::SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType)
  1308 void CAlfEffectObserver::CAlfEffectObserverData::SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType)
  1287     {
  1309     {
  1288     CAlfSignalObserver* obs = new (ELeave) CAlfSignalObserver(aObserver, this, aHandle, aType);
  1310     CAlfSignalObserver* obs = new (ELeave) CAlfSignalObserver(aObserver, this, aHandle, aType);
  1292     iClient.SendAsynchronous(EAlfRequestSignal, obs->iArgs, obs->iStatus);        
  1314     iClient.SendAsynchronous(EAlfRequestSignal, obs->iArgs, obs->iStatus);        
  1293     }
  1315     }
  1294         
  1316         
  1295 CAlfEffectObserver::CAlfEffectObserverData::~CAlfEffectObserverData()
  1317 CAlfEffectObserver::CAlfEffectObserverData::~CAlfEffectObserverData()
  1296     {    
  1318     {    
       
  1319     iObservers.ResetAndDestroy();
       
  1320     iObservers.Close();
  1297     iClient.Close(); // destroys signals
  1321     iClient.Close(); // destroys signals
  1298     iObservers.ResetAndDestroy();
  1322     }
  1299     }
  1323 
  1300         
  1324 RAlfBridgerClient& CAlfEffectObserver::CAlfEffectObserverData::Client()
       
  1325     {
       
  1326     return iClient;
       
  1327     }
       
  1328 
  1301 void CAlfEffectObserver::CAlfEffectObserverData::Remove(CAlfSignalObserver* aObserver)
  1329 void CAlfEffectObserver::CAlfEffectObserverData::Remove(CAlfSignalObserver* aObserver)
  1302     {
  1330     {
  1303     TInt index = iObservers.Find(aObserver);
  1331     TInt index = iObservers.Find(aObserver);
  1304     iObservers.Remove(index);
  1332     if (index != KErrNotFound)
  1305     delete aObserver;   
  1333         {
       
  1334         iObservers.Remove(index);
       
  1335         }
       
  1336     delete aObserver;
  1306     }    
  1337     }    
  1307     
  1338     
  1308 EXPORT_C CAlfEffectObserver* CAlfEffectObserver::NewL()
  1339 EXPORT_C CAlfEffectObserver* CAlfEffectObserver::NewL()
  1309     {
  1340     {
  1310     CAlfEffectObserver* me = new (ELeave) CAlfEffectObserver();
  1341     CAlfEffectObserver* me = new (ELeave) CAlfEffectObserver();
  1315     return me;    
  1346     return me;    
  1316     }
  1347     }
  1317 
  1348 
  1318 EXPORT_C CAlfEffectObserver::~CAlfEffectObserver()
  1349 EXPORT_C CAlfEffectObserver::~CAlfEffectObserver()
  1319     {
  1350     {
  1320     delete iData;        
  1351     delete iData; 
  1321     }
  1352     }
  1322 
  1353 
  1323 EXPORT_C TInt CAlfEffectObserver::ActiveEffectsCount()
  1354 EXPORT_C TInt CAlfEffectObserver::ActiveEffectsCount()
  1324     {
  1355     {
  1325     return iData->iClient.EffectsCount();
  1356     return iData->iClient.EffectsCount();
  1328 EXPORT_C void CAlfEffectObserver::SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType)
  1359 EXPORT_C void CAlfEffectObserver::SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType)
  1329     {
  1360     {
  1330     iData->SubscribeCallbackL(aObserver, aHandle, aType ); 
  1361     iData->SubscribeCallbackL(aObserver, aHandle, aType ); 
  1331     }
  1362     }
  1332 
  1363 
       
  1364 EXPORT_C void CAlfEffectObserver::SetDistractionWindow(const RWindowTreeNode& aWindow, TInt aState)
       
  1365     {
       
  1366     iData->iClient.SendSynch(EAlfSetDistractionWindow, TIpcArgs(aWindow.WindowGroupId(), aWindow.ClientHandle(), aState));
       
  1367     }
       
  1368 
  1333 CAlfEffectObserver::CAlfEffectObserver()
  1369 CAlfEffectObserver::CAlfEffectObserver()
  1334     {
  1370     {
  1335     }
  1371     }
  1336 
       
  1337  
  1372  
  1338 
  1373 //end of file
  1339 
  1374 
  1340 //end of file