1234 class CAlfSignalObserver;

  1235 

  1236 class MAlfEffectObserverData

  1237     {

  1238     public:

  1239         virtual void Remove(CAlfSignalObserver* aObserver) = 0;

  1240     };

  1241 

  1242 NONSHARABLE_CLASS(CAlfEffectObserver::CAlfEffectObserverData): public CBase, public MAlfEffectObserverData

  1243     {

  1244     public:

  1245     void SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType = MAlfEffectObserver::EAlfEffectComplete );        

  1246     ~CAlfEffectObserverData();

  1247     void Remove(CAlfSignalObserver* aObserver);

  1248     

  1249     // data

  1250     RAlfBridgerClient iClient;

  1251     RPointerArray<CAlfSignalObserver> iObservers;

  1252     };

  1253 

  1254 

  1255 NONSHARABLE_CLASS(CAlfSignalObserver):public CActive

  1256     {

  1257     public:    

  1258     CAlfSignalObserver(CAlfEffectObserver::MAlfEffectObserver* aObserver, MAlfEffectObserverData* aOwner, TInt aHandle, TInt aType):CActive(EPriorityStandard),

  1259         iOwner(aOwner), iObserver(aObserver), iHandle(aHandle), iType(aType), iArgs(aHandle,aType)

  1260         {   

  1261         CActiveScheduler::Add(this);

  1262         SetActive(); 

  1263         }

  1264                 

  1265     void DoCancel(){} // do not...

  1266     

  1267     void RunL()

  1268         {    

  1269         iObserver->HandleEffectCallback(iType, iHandle, iStatus.Int());

  1270         iOwner->Remove(this);

  1271         }    

  1272     

  1273     MAlfEffectObserverData* iOwner;

  1274     CAlfEffectObserver::MAlfEffectObserver* iObserver;

  1275     TInt iHandle;        

  1276     TInt iType;

  1277     TIpcArgs iArgs;

  1278     };

  1279 

  1280 void CAlfEffectObserver::CAlfEffectObserverData::SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType)

  1281     {

  1282     CAlfSignalObserver* obs = new (ELeave) CAlfSignalObserver(aObserver, this, aHandle, aType);

  1283     CleanupStack::PushL(obs);

  1284     User::LeaveIfError(iObservers.Append(obs));

  1285     CleanupStack::Pop();

  1286     iClient.SendAsynchronous(EAlfRequestSignal, obs->iArgs, obs->iStatus);        

  1287     }

  1288         

  1289 CAlfEffectObserver::CAlfEffectObserverData::~CAlfEffectObserverData()

  1290     {    

  1291     iClient.Close(); // destroys signals

  1292     iObservers.ResetAndDestroy();

  1293     }

  1294         

  1295 void CAlfEffectObserver::CAlfEffectObserverData::Remove(CAlfSignalObserver* aObserver)

  1296     {

  1297     TInt index = iObservers.Find(aObserver);

  1298     iObservers.Remove(index);

  1299     delete aObserver;   

  1300     }    

  1301     

  1302 EXPORT_C CAlfEffectObserver* CAlfEffectObserver::NewL()

  1303     {

  1304     CAlfEffectObserver* me = new (ELeave) CAlfEffectObserver();

  1305     CleanupStack::PushL(me);

  1306     me->iData = new (ELeave) CAlfEffectObserverData();

  1307     User::LeaveIfError(me->iData->iClient.Connect());

  1308     CleanupStack::Pop();

  1309     return me;    

  1310     }

  1311 

  1312 EXPORT_C CAlfEffectObserver::~CAlfEffectObserver()

  1313     {

  1314     delete iData;        

  1315     }

  1316 

  1317 EXPORT_C TInt CAlfEffectObserver::ActiveEffectsCount()

  1318     {

  1319     return iData->iClient.EffectsCount();

  1320     }

  1321 

  1322 EXPORT_C void CAlfEffectObserver::SubscribeCallbackL(MAlfEffectObserver* aObserver, TInt aHandle, TInt aType)

  1323     {

  1324     iData->SubscribeCallbackL(aObserver, aHandle, aType ); 

  1325     }

  1326 

  1327 CAlfEffectObserver::CAlfEffectObserver()

  1328     {

  1329     }

  1330 

  1331  

  1332 

  1333