uiacceltk/hitchcock/AlfDecoderServerClient/src/alfcompositionclient.cpp
changeset 19 f5bac0badc7e
parent 14 83d2d132aa58
child 21 6ce30188c5bf
equal deleted inserted replaced
14:83d2d132aa58 19:f5bac0badc7e
   723 
   723 
   724         void SetActive() {iStatus = KRequestPending;  CActive::SetActive();};
   724         void SetActive() {iStatus = KRequestPending;  CActive::SetActive();};
   725 
   725 
   726         void RunL() 
   726         void RunL() 
   727             {
   727             {
   728             if( iStatus == KErrNone )
   728             if( iStatus != KErrCancel )
   729                 {
   729                 {
   730                 SetActive();
   730                 SetActive();
   731                 if( !iPixelSource.DrawFrameL(iStatus, iBufferNumber) )
   731                 if( !iPixelSource.DrawFrameL(iStatus, iBufferNumber) )
   732                     {
   732                     {
   733                     __ALFLOGSTRING( "CSurfaceUpdateCallBack::RunL - DrawFrameL returned EFalse -> Pause");
   733                     __ALFLOGSTRING( "CSurfaceUpdateCallBack::RunL - DrawFrameL returned EFalse -> Pausing");
   734                     TRequestStatus* status = &iStatus;
   734                     TRequestStatus* status  = &iStatus;
   735                     User::RequestComplete(status, KErrNone);
   735                     User::RequestComplete(status, KErrCancel);
   736                     Cancel();
   736                     Cancel();
   737                    }
   737                     }
   738                 }
   738                 }
   739             else
       
   740                 {
       
   741                 __ALFLOGSTRING1("CSurfaceUpdateCallBack::RunL %d", iStatus.Int());
       
   742                 iPixelSource.Suspend();
       
   743                 }
       
   744 
       
   745             
       
   746             };
   739             };
   747         void DoCancel() {  };
   740         void DoCancel() 
   748         
   741             {
       
   742             };
       
   743 
   749     private: // Data
   744     private: // Data
   750         CAlfCompositionPixelSource& iPixelSource;
   745         CAlfCompositionPixelSource& iPixelSource;
   751         TInt iBufferNumber;
   746         TInt iBufferNumber;
   752     };
   747     };
   753 
   748 
   905         iData->iSourceStatus = CAlfCompositionPixelSourceData::EActive;
   900         iData->iSourceStatus = CAlfCompositionPixelSourceData::EActive;
   906         }
   901         }
   907    
   902    
   908     // do nothing if content was already active
   903     // do nothing if content was already active
   909     }
   904     }
   910     
   905 
       
   906 // ---------------------------------------------------------------------------
       
   907 // CAlfCompositionPixelSource::ActivateSyncL
       
   908 // ---------------------------------------------------------------------------
       
   909 //
       
   910 EXPORT_C void CAlfCompositionPixelSource::ActivateSyncL()
       
   911     {
       
   912     if( !iData->iWindow && iData->iSurfaceId.IsNull() )
       
   913         {
       
   914         User::Leave(KErrNotReady);
       
   915         }
       
   916     TBool pause = EFalse;
       
   917     if( iData->iSourceStatus == CAlfCompositionPixelSourceData::ESuspended )
       
   918         {
       
   919         MAlfBufferProvider::TBufferCreationAttributes& creationAttribs = iData->iProvider.BufferAttributes();
       
   920         
       
   921         iData->iSurfaceRect = TRect(TPoint(0,0), TSize(creationAttribs.iWidth, creationAttribs.iHeight));
       
   922 
       
   923         ConstructSurfaceL(creationAttribs);
       
   924 
       
   925         User::LeaveIfError( iData->iSurfaceUpdateSession.Connect() );     
       
   926         
       
   927         // update surface buffer before setting surface as background surface
       
   928         if( !iData->iSurfaceUpdateWaiter )
       
   929             {
       
   930             iData->iSurfaceUpdateWaiter = new (ELeave) CSurfaceUpdateCallback( *this, 0, iData->iWaiterAoPriority );
       
   931             }
       
   932 
       
   933         iData->iSurfaceUpdateWaiter->SetActive();
       
   934         pause = !DrawFrameL(iData->iSurfaceUpdateWaiter->iStatus ,0);
       
   935         if(pause && iData->iSurfaceUpdateWaiter->IsActive())
       
   936             {
       
   937             TRequestStatus* status  = &iData->iSurfaceUpdateWaiter->iStatus;
       
   938             User::RequestComplete(status, KErrCancel);
       
   939             iData->iSurfaceUpdateWaiter->Cancel();
       
   940             }
       
   941         
       
   942         iData->iWindow->SetBackgroundSurface(iData->iSurfaceId);
       
   943 
       
   944         TInt array[] = { 0, iData->iWindow->ClientHandle(), iData->iWindow->WindowGroupId() }; 
       
   945         TInt handle = SendEvent(KAlfCompOpCreateSource, array, sizeof(array));
       
   946         CAlfCompositionClientBase::SetHandleL( handle );
       
   947         }
       
   948   
       
   949     if( iData->iSourceStatus != CAlfCompositionPixelSourceData::EActive && !pause )
       
   950         {
       
   951 
       
   952         if( !iData->iSurfaceUpdateWaiter )
       
   953             {
       
   954             iData->iSurfaceUpdateWaiter = new (ELeave) CSurfaceUpdateCallback( *this, 0, iData->iWaiterAoPriority );
       
   955             }
       
   956 
       
   957         if(!iData->iSurfaceUpdateWaiter->IsActive())
       
   958             {
       
   959             iData->iSurfaceUpdateWaiter->SetActive();
       
   960             TRequestStatus* status = &iData->iSurfaceUpdateWaiter->iStatus;
       
   961             User::RequestComplete(status, KErrNone);
       
   962             }
       
   963         iData->iProvider.OnActivation();
       
   964         iData->iSourceStatus = CAlfCompositionPixelSourceData::EActive;
       
   965         }
       
   966    
       
   967     // do nothing if content was already active and running    
       
   968     }
       
   969 
   911 // --------------------------------------------------------------------------- 
   970 // --------------------------------------------------------------------------- 
   912 // CAlfCompositionPixelSource::Suspend
   971 // CAlfCompositionPixelSource::Suspend
   913 // ---------------------------------------------------------------------------
   972 // ---------------------------------------------------------------------------
   914 //
   973 //
   915 EXPORT_C void CAlfCompositionPixelSource::Suspend()
   974 EXPORT_C void CAlfCompositionPixelSource::Suspend()
  1170         }
  1229         }
  1171     // call base class
  1230     // call base class
  1172     CAlfCompositionSource::HandleEventL( aEventType, aEventData );
  1231     CAlfCompositionSource::HandleEventL( aEventType, aEventData );
  1173     }
  1232     }
  1174 
  1233 
       
  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 
  1175 //end of file    
  1334 //end of file