uiacceltk/hitchcock/goommonitor/src/goomcloseapp.cpp
branchRCL_3
changeset 41 cd0ae4656946
parent 11 46927d61fef3
child 49 c9d868f1e20c
equal deleted inserted replaced
34:3a60ebea00d0 41:cd0ae4656946
    16 */
    16 */
    17 
    17 
    18 
    18 
    19 #include <apgtask.h>
    19 #include <apgtask.h>
    20 
    20 
       
    21 #include "goommemorymonitor.h"
       
    22 #include "goomwindowgrouplist.h"
    21 #include "goomcloseapp.h"
    23 #include "goomcloseapp.h"
    22 #include "goomtraces.h"
    24 #include "goomtraces.h"
    23 #include "goomappclosetimer.h"
    25 #include "goomappclosetimer.h"
    24 #include "goomappclosewatcher.h"
    26 #include "goomappclosewatcher.h"
    25 #include "goomactionref.h"
    27 #include "goomactionref.h"
    40 // Call the CGOomAction::MemoryFreed when it is done
    42 // Call the CGOomAction::MemoryFreed when it is done
    41 void CGOomCloseApp::FreeMemory(TInt, TBool)
    43 void CGOomCloseApp::FreeMemory(TInt, TBool)
    42     {
    44     {
    43     FUNC_LOG;
    45     FUNC_LOG;
    44 
    46 
       
    47     if ( iAlreadyGaveUp )
       
    48         {
       
    49         if (iAppCloseTimer)
       
    50         	{
       
    51 			iAppCloseTimer->Cancel();
       
    52     		}
       
    53 			
       
    54     	if (iAppCloseWatcher)
       
    55         	{
       
    56 			iAppCloseWatcher->Cancel();
       
    57 			}
       
    58 			
       
    59 		RDebug::Printf("GOOM: I should not activate actions for app that already refused to exit !!!!");
       
    60         MemoryFreed(KErrNone);
       
    61         return;
       
    62         }    
       
    63 
    45     iAppCloserRunning = ETrue;
    64     iAppCloserRunning = ETrue;
    46     
    65     
    47     // Set the TApaTask to the app
    66     // Set the TApaTask to the app
    48     iCurrentTask.SetWgId(iWgId);
    67     iCurrentTask.SetWgId(iWgId);
    49     
    68 
    50     // Start a timer and the thread watcher 
    69     // start the chain
    51     iAppCloseTimer->SetState(CGOomAppCloseTimer::EGOomAppClosing);
    70     ConditionalClose();
    52     iAppCloseTimer->After(iCloseTimeout * 1000);
       
    53     iAppCloseWatcher->Start(iCurrentTask);
       
    54     // Tell the app to close
       
    55     TRACES2("CGOomCloseApp::FreeMemory: Closing app with window group id %d Timeout = %d",iWgId, iCloseTimeout);
       
    56     iCurrentTask.EndTask();
       
    57     }
    71     }
    58 
    72 
    59 CGOomCloseApp::~CGOomCloseApp()
    73 CGOomCloseApp::~CGOomCloseApp()
    60     {
    74     {
    61     FUNC_LOG;
    75     FUNC_LOG;
    75     {
    89     {
    76     FUNC_LOG;
    90     FUNC_LOG;
    77 
    91 
    78     // The application has closed (or we have a timeout)
    92     // The application has closed (or we have a timeout)
    79     iAppCloserRunning = EFalse;
    93     iAppCloserRunning = EFalse;
       
    94     iAlreadyGaveUp = ETrue;
    80     
    95     
    81     if (iAppCloseTimer)
    96     if (iAppCloseTimer)
    82         {
    97         {
    83             iAppCloseTimer->Cancel();
    98         iAppCloseTimer->Cancel();
    84             iAppCloseTimer->SetState(CGOomAppCloseTimer::EGOomAppKilled);
    99         iAppCloseTimer->SetState(CGOomAppCloseTimer::EGOomAppKilled);
    85             iAppCloseTimer->After(iWaitAfterClose * 1000);
   100         iAppCloseTimer->After(iWaitAfterClose * 1000);
    86         }
   101         }
    87     
   102     
    88     if (iAppCloseWatcher)
   103     if (iAppCloseWatcher)
       
   104         {
    89         iAppCloseWatcher->Cancel(); 
   105         iAppCloseWatcher->Cancel(); 
    90     
   106         }    
    91     
       
    92     //MemoryFreed(KErrNone);
       
    93     }
   107     }
    94 
   108 
    95 void CGOomCloseApp::Reconfigure(const TActionRef& aRef)
   109 void CGOomCloseApp::Reconfigure(const TActionRef& aRef)
    96     {
   110     {
    97     FUNC_LOG;
   111     FUNC_LOG;
    98 
   112 
    99     iWgId = aRef.WgId();    
   113     iWgId = aRef.WgId();    
   100     iCloseTimeout = aRef.CloseTimeout();
   114     iCloseTimeout = aRef.CloseTimeout();
   101     iWaitAfterClose = aRef.WaitAfterClose();
   115     iWaitAfterClose = aRef.WaitAfterClose();
       
   116 	iAlreadyGaveUp = EFalse;
   102     }
   117     }
   103 
   118 
   104 void CGOomCloseApp::ConstructL()
   119 void CGOomCloseApp::ConstructL()
   105     {
   120     {
   106     FUNC_LOG;
   121     FUNC_LOG;
   113                                 : CGOomAction(aStateChangeObserver), iCurrentTask(aWs)
   128                                 : CGOomAction(aStateChangeObserver), iCurrentTask(aWs)
   114     {
   129     {
   115     FUNC_LOG;
   130     FUNC_LOG;
   116     }
   131     }
   117 
   132 
       
   133 TBool IsConsumingMemory(TInt aWgId)
       
   134     {
       
   135     FUNC_LOG;
       
   136     // Something more efficient could be done here
       
   137     CMemoryMonitor* globalMemoryMonitor = static_cast<CMemoryMonitor*>(Dll::Tls());
       
   138     globalMemoryMonitor->GetWindowGroupList()->Refresh();
       
   139     return (globalMemoryMonitor->GetWindowGroupList()->GetIndexFromWgId(aWgId) != KErrNotFound);
       
   140     }    
       
   141     
       
   142 void CGOomCloseApp::ConditionalClose()
       
   143     {
       
   144     FUNC_LOG;
       
   145     // Start a timer and the thread watcher 
       
   146     iAppCloseTimer->SetState(CGOomAppCloseTimer::EGOomAppClosing);
       
   147     iAppCloseTimer->After(iCloseTimeout * 1000);
       
   148     // Tell the app to close
       
   149 	// We are not asking system applications to exit anyway, so we'll send legacy event only
       
   150 	// even we have powermgmt capability 
       
   151     TRACES2("CGOomCloseApp::FreeMemory: Closing app with window group id %d Timeout = %d",iWgId, iCloseTimeout);
       
   152 	TWsEvent event;
       
   153 	event.SetType(EEventUser);
       
   154 	TInt* eventData = (TInt*)(event.EventData());
       
   155 	*eventData = EApaSystemEventShutdown;
       
   156 	eventData++;
       
   157 	*eventData = KGoomMemoryLowEvent;
       
   158 	
       
   159 	// should proxy the session..
       
   160     CMemoryMonitor* globalMemoryMonitor = static_cast<CMemoryMonitor*>(Dll::Tls());
       
   161     globalMemoryMonitor->iWs.SendEventToWindowGroup(iWgId, event);
       
   162     }    
       
   163 
       
   164 
   118 // ----------------------------------------------
   165 // ----------------------------------------------
   119 // Callback from iAppCloseTimer
   166 // Callback from iAppCloseTimer
   120 // App refused to exit gracefully on given time
   167 // App refused to exit gracefully on given time
   121 // ----------------------------------------------
   168 // ----------------------------------------------
   122 //
   169 //
   125     FUNC_LOG;
   172     FUNC_LOG;
   126     if (iAppCloseWatcher)
   173     if (iAppCloseWatcher)
   127         {
   174         {
   128         iAppCloseWatcher->Cancel(); 
   175         iAppCloseWatcher->Cancel(); 
   129         }
   176         }
   130     
   177         
   131     iCurrentTask.KillTask();
   178     if(IsConsumingMemory(iWgId))    
   132     iAppCloserRunning = EFalse;
   179         {    
   133     
   180         iCurrentTask.KillTask();
   134     iAppCloseTimer->SetState(CGOomAppCloseTimer::EGOomAppKilled);
   181         iAppCloserRunning = EFalse; // not sure if intended (?)
   135     iAppCloseTimer->After(iWaitAfterClose * 1000);
   182         iAppCloseTimer->SetState(CGOomAppCloseTimer::EGOomAppKilled);
       
   183         iAppCloseTimer->After(iWaitAfterClose * 1000);
       
   184         }
       
   185     else
       
   186         { // application has released its graphics resources -> we are no more interested about it
       
   187         CloseAppEvent();
       
   188         }    
   136     //MemoryFreed(KErrNone);
   189     //MemoryFreed(KErrNone);
   137     }
   190     }
   138 
   191 
   139 void CGOomCloseApp::KillTaskWaitDone()
   192 void CGOomCloseApp::KillTaskWaitDone()
   140     {
   193     {