satengine/SatServer/Engine/src/TSatEventMediator.cpp
changeset 46 2fa1fa551b0b
parent 42 35488577e233
child 48 78df25012fda
equal deleted inserted replaced
42:35488577e233 46:2fa1fa551b0b
     1 /*
       
     2 * Copyright (c) 2002-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:  Provides way to notify events and register observers
       
    15 *                for events
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 
       
    21 // INCLUDE FILES
       
    22 #include    "TSatEventMediator.h"
       
    23 #include    "TSatEventsObserver.h"
       
    24 //lint -e766 Used inside TRAP macro, lint misfunction.
       
    25 #include    "EnginePanic.h"
       
    26 #include    "MSatEventObserver.h"
       
    27 #include    "SatLog.h"
       
    28 
       
    29 // FORWARD DECLARE
       
    30 class MSatEventObserver;
       
    31 
       
    32 // ============================ MEMBER FUNCTIONS ===============================
       
    33 
       
    34 // -----------------------------------------------------------------------------
       
    35 // TSatEventMediator::TSatEventMediator
       
    36 // C++ default constructor can NOT contain any code, that
       
    37 // might leave.
       
    38 // -----------------------------------------------------------------------------
       
    39 //
       
    40 TSatEventMediator::TSatEventMediator() :
       
    41     iEventsObservers(),
       
    42     iIsNotifying( EFalse ),
       
    43     iDeletionsMarked( EFalse )
       
    44     {
       
    45     LOG( SIMPLE,
       
    46         "SATENGINE: TSatEventMediator::TSatEventMediator calling - exiting" )
       
    47     }
       
    48 
       
    49 // -----------------------------------------------------------------------------
       
    50 // TSatEventMediator::Reset
       
    51 // Replaces destructor since T classes cannot have one
       
    52 // -----------------------------------------------------------------------------
       
    53 //
       
    54 void TSatEventMediator::Reset()
       
    55     {
       
    56     LOG( SIMPLE, "SATENGINE: TSatEventMediator::Reset calling" )
       
    57 
       
    58     iEventsObservers.ResetAndDestroy();
       
    59 
       
    60     LOG( SIMPLE, "SATENGINE: TSatEventMediator::Reset exiting" )
       
    61     }
       
    62 
       
    63 // -----------------------------------------------------------------------------
       
    64 // TSatEventMediator::Notify
       
    65 // All observers, who are registered to get the notification of aEvent, are
       
    66 // notified
       
    67 // (other items were commented in a header).
       
    68 // -----------------------------------------------------------------------------
       
    69 //
       
    70 void TSatEventMediator::Notify(
       
    71     TInt aEvent ) // Event
       
    72     {
       
    73     LOG( DETAILED, "SATENGINE: TSatEventMediator::Notify calling" )
       
    74 
       
    75     // Go through the list of observers and call notify for observers who are
       
    76     // observing aEvent.
       
    77 
       
    78     // Set the flag on. No one can remove observers when this flag is on
       
    79     iIsNotifying = ETrue;
       
    80 
       
    81     TInt count( iEventsObservers.Count() );
       
    82     LOG2( DETAILED, "SATENGINE: TSatEventMediator::Notify observers \
       
    83           count: %d", count )
       
    84     for ( TInt i = 0; i < count; i++ )
       
    85         {
       
    86         TSatEventsObserver* eventsObserver =
       
    87             iEventsObservers[i];
       
    88         __ASSERT_ALWAYS( eventsObserver,
       
    89             PanicSatEngine( ESatEngineNullPointer ) );
       
    90 
       
    91         if ( eventsObserver->ObservingEvent( aEvent ) )
       
    92             {
       
    93             MSatEventObserver* observer =
       
    94                 eventsObserver->Observer();
       
    95 
       
    96             if ( observer )
       
    97                 {
       
    98                 LOG( DETAILED, "TSatEventMediator::Notify observer found" )
       
    99                 // Observer found, notify it
       
   100                 observer->Event( aEvent );
       
   101 
       
   102                 // Check is iEventObservers list changed. Some observers might
       
   103                 // remove themselves and notify a new event (new Notify loop)
       
   104                 // and marked observers are deleted there. When it comes back 
       
   105                 // here iEventsObserver has changed           
       
   106                 if ( count > iEventsObservers.Count() )
       
   107                     {
       
   108                     LOG( DETAILED, "TSatEventMediator::Notify \
       
   109                     count > iEventsObservers.Count()" )
       
   110                     TInt newCount( iEventsObservers.Count() );
       
   111                     i = i - ( count - newCount );
       
   112                     count = newCount;
       
   113                     }
       
   114                 }
       
   115             else
       
   116                 {
       
   117                 LOG( DETAILED, "TSatEventMediator::Notify observer not found" )
       
   118                 // Found NULL observer -> Mark fo deleted. This is deleted after
       
   119                 // this notification loop
       
   120                 eventsObserver->RemoveEvent( aEvent );
       
   121                 eventsObserver->MarkForDelete();
       
   122                 }
       
   123             }
       
   124         }
       
   125 
       
   126     // Set the flag off. Now observers can be removed
       
   127     iIsNotifying = EFalse;
       
   128 
       
   129     // Check was there any deletions during notify loop
       
   130     if ( iDeletionsMarked )
       
   131         {
       
   132         LOG( DETAILED, "TSatEventMediator::Notify iDeletionsMarked true" )
       
   133         // Delete marked observers
       
   134         DeleteMarkedObservers();
       
   135         iDeletionsMarked = EFalse;
       
   136         }
       
   137 
       
   138     LOG( DETAILED, "SATENGINE: TSatEventMediator::Notify exiting" )
       
   139     }
       
   140 
       
   141 // -----------------------------------------------------------------------------
       
   142 // TSatEventMediator::RegisterL
       
   143 // Registers observer for getting the event when event is notified using
       
   144 // Notify( TInt aEvent ).
       
   145 // (other items were commented in a header).
       
   146 // -----------------------------------------------------------------------------
       
   147 //
       
   148 void TSatEventMediator::RegisterL(
       
   149     MSatEventObserver* aObserver, // Observer of aEvent.
       
   150     TInt aEvent ) // Event, which will be trigger of notification.
       
   151     {
       
   152     LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL calling" )
       
   153 
       
   154     __ASSERT_ALWAYS( aObserver, PanicSatEngine( ESatEngineNullPointer ) );
       
   155     // Check if aObserver instance is already registered, so that we dont
       
   156     // create a new TSatEventsObserver entry in to the iEventsObserver list.
       
   157     TSatEventsObserver* eventsObserver = HasObserverInstance( aObserver );
       
   158 
       
   159     if ( NULL != eventsObserver )
       
   160         {
       
   161         LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL eventsObserver \
       
   162              not NULL" )
       
   163         // Add the event for the observer.
       
   164         eventsObserver->AddEventL( aEvent );
       
   165         }
       
   166     else
       
   167         {
       
   168         LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL eventsObserver \
       
   169              NULL" )
       
   170         // Observer is registering for the first time.
       
   171         eventsObserver = new( ELeave )TSatEventsObserver( aObserver );
       
   172         CleanupStack::PushL( eventsObserver );
       
   173         eventsObserver->AddEventL( aEvent );
       
   174         User::LeaveIfError( iEventsObservers.Append( eventsObserver ) );
       
   175         CleanupStack::Pop( eventsObserver );
       
   176         }
       
   177 
       
   178     LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL exiting" )
       
   179     }
       
   180 
       
   181 // -----------------------------------------------------------------------------
       
   182 // TSatEventMediator::Unregister
       
   183 // Removes aEvent from aObservers observable events.
       
   184 // (other items were commented in a header).
       
   185 // -----------------------------------------------------------------------------
       
   186 //
       
   187 void TSatEventMediator::Unregister(
       
   188     const MSatEventObserver* aObserver, // Observer of aEvent.
       
   189     TInt aEvent ) // Event, which the observer is observing.
       
   190     {
       
   191     LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister calling" )
       
   192 
       
   193     // Check if observer is registered.
       
   194     TSatEventsObserver* eventsObserver = HasObserverInstance( aObserver );
       
   195     if ( NULL != eventsObserver )
       
   196         {
       
   197         LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL eventsObserver \
       
   198              not NULL" )
       
   199         eventsObserver->RemoveEvent( aEvent );
       
   200 
       
   201         // Remove the eventsObserver from the list if the observer has
       
   202         // no longer any events to observe.
       
   203         if ( 0 == eventsObserver->EventCount() )
       
   204             {
       
   205             // Prevent delete if we are notifying observers
       
   206             if ( !iIsNotifying )
       
   207                 {
       
   208                 LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
       
   209                      iIsNotifying false" )
       
   210                 const TInt index = iEventsObservers.Find( eventsObserver );
       
   211                 // Does not destroy the object.
       
   212                 iEventsObservers.Remove( index ); 
       
   213                 iEventsObservers.GranularCompress();
       
   214                 delete eventsObserver;
       
   215                 }
       
   216             else
       
   217                 {
       
   218                 LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
       
   219                      iIsNotifying true" )
       
   220                 // If we are notifying, mark this observer as deleted
       
   221                 eventsObserver->MarkForDelete();
       
   222                 iDeletionsMarked = ETrue;
       
   223                 }
       
   224             }
       
   225         }
       
   226 
       
   227     LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister exiting" )
       
   228     }
       
   229 
       
   230 // -----------------------------------------------------------------------------
       
   231 // TSatEventMediator::Unregister
       
   232 // (other items were commented in a header).
       
   233 // -----------------------------------------------------------------------------
       
   234 //
       
   235 void TSatEventMediator::Unregister(
       
   236     const MSatEventObserver* aObserver ) // Observer of aEvent.
       
   237     {
       
   238     LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister calling" )
       
   239 
       
   240     // Check if observer is registered.
       
   241     TSatEventsObserver* eventsObserver = HasObserverInstance( aObserver );
       
   242     if ( NULL != eventsObserver )
       
   243         {
       
   244         // Prevent delete if we are notifying observers
       
   245         if ( !iIsNotifying )
       
   246             {
       
   247             LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
       
   248                  iIsNotifying false" )
       
   249             const TInt index = iEventsObservers.Find( eventsObserver );
       
   250             iEventsObservers.Remove( index ); // Does not destroy the object.
       
   251             iEventsObservers.GranularCompress();
       
   252             delete eventsObserver;
       
   253             }
       
   254         else
       
   255             {
       
   256             LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
       
   257                  iIsNotifying true" )
       
   258             // If we are notifying, mark this observer as deleted
       
   259             eventsObserver->MarkForDelete();
       
   260             iDeletionsMarked = ETrue;
       
   261             }
       
   262         }
       
   263 
       
   264     LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister exiting" )
       
   265     }
       
   266 
       
   267 // -----------------------------------------------------------------------------
       
   268 // TSatEventMediator::HasObserverInstance
       
   269 // Checks if aObserver is already registered to this mediator and returns the
       
   270 // result.
       
   271 // (other items were commented in a header).
       
   272 // -----------------------------------------------------------------------------
       
   273 //
       
   274 TSatEventsObserver* TSatEventMediator::HasObserverInstance(
       
   275     const MSatEventObserver* aObserver ) const // Observer looked from the list.
       
   276     {
       
   277     LOG( SIMPLE, "SATENGINE: TSatEventMediator::HasObserverInstance calling" )
       
   278 
       
   279     // Go through the list until same observer instance is found or
       
   280     // all entries have been checked.
       
   281     TSatEventsObserver* foundEventsObserver = NULL;
       
   282     const TInt count( iEventsObservers.Count() );
       
   283     LOG2( NORMAL, "SATENGINE: TSatEventMediator::HasObserverInstance \
       
   284           observer count: %d", count )
       
   285     for ( TInt i = 0; ( i < count ) && ( !foundEventsObserver ); i++ )
       
   286         {
       
   287         TSatEventsObserver* eventsObserver = iEventsObservers[i];
       
   288         __ASSERT_ALWAYS( eventsObserver,
       
   289             PanicSatEngine( ESatEngineNullPointer ) );
       
   290 
       
   291         if ( aObserver == eventsObserver->Observer() )
       
   292             {
       
   293             LOG( SIMPLE, "SATENGINE: TSatEventMediator::HasObserverInstance \
       
   294             aObserver == eventsObserver->Observer()" )
       
   295             foundEventsObserver = eventsObserver;
       
   296             }
       
   297         }
       
   298 
       
   299     LOG( SIMPLE, "SATENGINE: TSatEventMediator::HasObserverInstance exiting" )
       
   300     return foundEventsObserver;
       
   301     }
       
   302 
       
   303 // -----------------------------------------------------------------------------
       
   304 // TSatEventMediator::DeleteMarkedObservers
       
   305 // Deletes all observers marked as deleted during Notify loop
       
   306 // (other items were commented in a header).
       
   307 // -----------------------------------------------------------------------------
       
   308 //
       
   309 void TSatEventMediator::DeleteMarkedObservers()
       
   310     {
       
   311     LOG( SIMPLE, "SATENGINE: TSatEventMediator::DeleteMarkedObservers calling" )
       
   312 
       
   313     // Go through the list and delete all observers wich are
       
   314     // marked as deleted
       
   315     TInt count( iEventsObservers.Count() );
       
   316     LOG2( NORMAL, "SATENGINE: TSatEventMediator::DeleteMarkedObservers \
       
   317           observer count: %d", count )
       
   318     for ( TInt i = 0; i < count; i++ )
       
   319         {
       
   320         TSatEventsObserver* eventsObserver =
       
   321             iEventsObservers[i];
       
   322         if ( eventsObserver )
       
   323             {
       
   324             LOG( SIMPLE, "SATENGINE: TSatEventMediator::DeleteMarkedObservers\
       
   325             eventsObserver true" )
       
   326             // Check is obserer marked and it has no events
       
   327             if ( eventsObserver->IsMarkedForDelete() &&
       
   328                  ( 0 == eventsObserver->EventCount() ) )
       
   329                 {
       
   330                 LOG( SIMPLE, "SATENGINE: TSatEventMediator::\
       
   331                 DeleteMarkedObservers delete Observer" )
       
   332                 iEventsObservers.Remove( i ); // Does not destroy the object.
       
   333                 iEventsObservers.GranularCompress();
       
   334                 delete eventsObserver;
       
   335 
       
   336                 // Update count value. We just removed an object from list
       
   337                 count = iEventsObservers.Count();
       
   338                 i--;
       
   339                 }
       
   340             }
       
   341         }
       
   342 
       
   343     LOG( SIMPLE, "SATENGINE: TSatEventMediator::DeleteMarkedObservers exiting" )
       
   344     }
       
   345 
       
   346 //  End of File