1 /*

     2 * Copyright (c) 2006-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:  Activity Manager 

    15 *

    16 */

    17 

    18 #include "tmactivitymanager.h"

    19 #include "thumbnaillog.h"

    20 

    21 // ---------------------------------------------------------------------------

    22 // CTMActivityManager::NewL()

    23 // ---------------------------------------------------------------------------

    24 //

    25 CTMActivityManager* CTMActivityManager::NewL(MTMActivityManagerObserver* aObserver, TInt aTimeout)

    26     {

    27     TN_DEBUG1( "CTMActivityManager::NewL()");

    28     CTMActivityManager* self = new (ELeave) CTMActivityManager(aObserver, aTimeout);

    29     CleanupStack::PushL(self);

    30     self->ConstructL();

    31     CleanupStack::Pop(self);

    32     return self;

    33     }

    34  

    35 // ---------------------------------------------------------------------------

    36 // CTMActivityManager::CTMActivityManager()

    37 // ---------------------------------------------------------------------------

    38 //

    39 CTMActivityManager::CTMActivityManager(MTMActivityManagerObserver* aObserver, TInt aTimeout)

    40 : CActive(CActive::EPriorityHigh), iObserver(aObserver), iTimeout(aTimeout), iPreviousStatus(KErrNotFound)

    41     {

    42     TN_DEBUG1( "CTMActivityManager::CTMActivityManager()");

    43     CActiveScheduler::Add(this);

    44     }

    45 

    46 // ---------------------------------------------------------------------------

    47 // CTMActivityManager::~CTMActivityManager()

    48 // ---------------------------------------------------------------------------

    49 //

    50 CTMActivityManager::~CTMActivityManager()

    51     {

    52     TN_DEBUG1( "CTMActivityManager::~CTMActivityManager()");

    53     delete iLight;

    54     iLight = NULL;

    55     Cancel();

    56     iTimer.Close();

    57     }

    58  

    59 // ---------------------------------------------------------------------------

    60 // CTMActivityManager::ConstructL()

    61 // ---------------------------------------------------------------------------

    62 //

    63 void CTMActivityManager::ConstructL()

    64     {

    65     TN_DEBUG1( "CTMActivityManager::ConstructL()");

    66     iTimer.CreateLocal();

    67     }

    68 

    69 // ---------------------------------------------------------------------------

    70 // CTMActivityManager::SetTimeout()

    71 // ---------------------------------------------------------------------------

    72 //

    73 void CTMActivityManager::SetTimeout(TInt aTimeout)

    74     {

    75     TN_DEBUG1( "CTMActivityManager::SetTimeout()");

    76     iTimeout = aTimeout;

    77     Reset();

    78     }

    79 

    80 // ---------------------------------------------------------------------------

    81 // CTMActivityManager::Reset()

    82 // ---------------------------------------------------------------------------

    83 //

    84 void CTMActivityManager::Reset()

    85     {

    86     TN_DEBUG1( "CTMActivityManager::Reset()");

    87     delete iLight;

    88     iLight = NULL;

    89     Cancel();

    90     Start();

    91     }

    92  

    93 // ---------------------------------------------------------------------------

    94 // CTMActivityManager::DoCancel()

    95 // ---------------------------------------------------------------------------

    96 void CTMActivityManager::DoCancel()

    97     {

    98     TN_DEBUG1( "CTMActivityManager::DoCancel()");

    99     iTimer.Cancel();

   100     iWatch = ENone;

   101     }

   102 

   103 // ---------------------------------------------------------------------------

   104 // CTMActivityManager::Start()

   105 // ---------------------------------------------------------------------------

   106 //

   107 void CTMActivityManager::Start()

   108     {

   109     TN_DEBUG1( "CTMActivityManager::Start()");

   110     

   111     iFirstRound = ETrue;

   112     

   113     if(!iLight)

   114         {

   115         TRAP_IGNORE(iLight = CHWRMLight::NewL(this));

   116         }

   117     

   118     if( !IsActive() )

   119         {

   120         SetActive();

   121         TRequestStatus* statusPtr = &iStatus;

   122         User::RequestComplete( statusPtr, KErrNone );

   123         }

   124     }

   125 

   126 // ---------------------------------------------------------------------------

   127 // CTMActivityManager::RunL()

   128 // ---------------------------------------------------------------------------

   129 //

   130 void CTMActivityManager::RunL()

   131     {

   132     TN_DEBUG4( "CTMActivityManager::RunL(0x%08x) %d, observer = 0x%08x", this, iStatus.Int(), iObserver);

   133     

   134     if(iFirstRound)

   135         {

   136         TN_DEBUG1( "CTMActivityManager::RunL() iFirstRound");

   137         iFirstRound = EFalse;

   138         if (!IsActive())

   139              {

   140              iWatch = EWaitingForInactivity;

   141              iTimer.Inactivity(iStatus, iTimeout);

   142              SetActive();

   143              }

   144         NotifyObserver();

   145         return;

   146         }

   147     

   148     if (iStatus == KErrNone)

   149         {

   150         if (iWatch == EWaitingForInactivity)

   151             {

   152             TInt inactivity = User::InactivityTime().Int();

   153             if (inactivity >= iTimeout)

   154                 {

   155                 TN_DEBUG1( "CTMActivityManager::RunL() inactive");

   156                 NotifyObserver();

   157 

   158             if (!IsActive()) //observer might have called a Reset()

   159                 {

   160                 iTimer.Inactivity(iStatus,0);

   161                 iWatch = EWaitingForActivity;

   162                 }

   163             }

   164             else

   165                 {

   166                 iTimer.Inactivity(iStatus,iTimeout);

   167                 }

   168             }

   169         else if (iWatch == EWaitingForActivity)

   170             {

   171                 TN_DEBUG1( "CTMActivityManager::RunL() active");

   172                 NotifyObserver();

   173              

   174             if (!IsActive()) //observer might have called a Reset()

   175                 {

   176                 iTimer.Inactivity(iStatus,iTimeout);

   177                 iWatch = EWaitingForInactivity;

   178                 }

   179             }

   180     

   181         if (!IsActive()) //observer might have called a Reset()

   182             {

   183             SetActive();

   184             }

   185         }

   186     else

   187         {

   188         iWatch = ENone;

   189         }

   190         TN_DEBUG1( "CTMActivityManager::RunL() end");

   191     }

   192 

   193 // ---------------------------------------------------------------------------

   194 // CTMActivityManager::RunError()

   195 // ---------------------------------------------------------------------------

   196 //

   197 TInt CTMActivityManager::RunError(TInt aError)

   198     {

   199     TN_DEBUG2( "CTMActivityManager::RunError() %d", aError);

   200     

   201     if (aError != KErrNone)

   202         {

   203         Reset();

   204         }

   205     

   206     // nothing to do

   207     return KErrNone;

   208     }

   209 

   210 // -----------------------------------------------------------------------------

   211 // IsInactive()

   212 // -----------------------------------------------------------------------------

   213 //

   214 TBool CTMActivityManager::IsInactive()

   215     {

   216 #ifdef _DEBUG

   217 TN_DEBUG3( "CTMActivityManager::IsInactive()= %d, iLights = %d", User::InactivityTime().Int(), iLights);

   218 #endif

   219 

   220     //if lights are off or inactivity timer is less that target the device is not idle

   221     if( User::InactivityTime() >= TTimeIntervalSeconds(iTimeout) || !iLights )

   222       {

   223       TN_DEBUG1( "CTMActivityManager::IsInactive() ETrue");

   224       return ETrue;

   225       }

   226     TN_DEBUG1( "CTMActivityManager::IsInactive() EFalse");

   227     return EFalse;

   228     }

   229 

   230 // -----------------------------------------------------------------------------

   231 // LightStatusChanged()

   232 // -----------------------------------------------------------------------------

   233 //

   234 void CTMActivityManager::LightStatusChanged(TInt /*aTarget*/, CHWRMLight::TLightStatus aStatus)

   235     {

   236     TN_DEBUG2( "CTMActivityManager::LightStatusChanged() aStatus == %d", aStatus);

   237     

   238      if( aStatus == CHWRMLight::ELightOff)

   239         {

   240         TN_DEBUG1( "CTMActivityManager::LightStatusChanged() -- OFF");

   241         iLights = EFalse;

   242         }

   243     else

   244         {

   245         TN_DEBUG1( "CTMActivityManager::LightStatusChanged() -- ON");

   246         iLights = ETrue;

   247         }

   248      

   249         NotifyObserver();

   250     }

   251 

   252 // -----------------------------------------------------------------------------

   253 // NotifyObserver()

   254 // -----------------------------------------------------------------------------

   255 //

   256 void CTMActivityManager::NotifyObserver()

   257     {

   258     TN_DEBUG1( "void CTMAActivityManager::NotifyObserver()");

   259     TBool status = IsInactive();

   260     

   261     if( iPreviousStatus != status )

   262         {

   263         iPreviousStatus = status; 

   264         if (iObserver)

   265             {

   266             iObserver->ActivityChanged(!status);

   267             }

   268         }

   269     }