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:  Processor object for running queued tasks

    15  *

    16 */

    17 

    18 

    19 #include <e32base.h>

    20 #include <fbs.h>

    21 #include "thumbnailtaskprocessor.h"

    22 #include "thumbnailtask.h"

    23 #include "thumbnailprovider.h"

    24 #include "thumbnailmanageruids.hrh"

    25 #include "thumbnailmanagerconstants.h"

    26 #include "thumbnailgeneratetask.h"

    27 #include "thumbnailpanic.h"

    28 

    29 

    30 // ======== MEMBER FUNCTIONS ========

    31 

    32 // ---------------------------------------------------------------------------

    33 // CThumbnailTaskProcessor::NewL()

    34 // Two-phased constructor.

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

    36 //

    37 CThumbnailTaskProcessor* CThumbnailTaskProcessor::NewL()

    38     {

    39     CThumbnailTaskProcessor* self = new( ELeave )CThumbnailTaskProcessor();

    40     CleanupStack::PushL( self );

    41     self->ConstructL();

    42     CleanupStack::Pop( self );

    43     return self;

    44     }

    45 

    46 

    47 // ---------------------------------------------------------------------------

    48 // CThumbnailTaskProcessor::CThumbnailTaskProcessor()

    49 // C++ default constructor can NOT contain any code, that might leave.

    50 // ---------------------------------------------------------------------------

    51 //

    52 CThumbnailTaskProcessor::CThumbnailTaskProcessor(): CActive( CActive

    53     ::EPriorityStandard )

    54     {

    55     CActiveScheduler::Add( this );

    56     }

    57 

    58 

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

    60 // CThumbnailTaskProcessor::ConstructL()

    61 // Symbian 2nd phase constructor can leave.

    62 // ---------------------------------------------------------------------------

    63 //

    64 void CThumbnailTaskProcessor::ConstructL()

    65     {

    66     // define PS property

    67     TInt ret = RProperty::Delete(KServerIdle, KIdle);

    68     TN_DEBUG2( "CThumbnailTaskProcessor::CThumbnailTaskProcessor() Delete KServerIdle %d", ret);

    69     

    70     ret=RProperty::Define(KServerIdle, KIdle, RProperty::EInt);

    71     TN_DEBUG2( "CThumbnailTaskProcessor::ConstructL() Define KServerIdle %d", ret);

    72     

    73     // attach to the property    

    74 	ret = iProperty.Attach(KServerIdle, KIdle, EOwnerThread);

    75     TN_DEBUG2( "CThumbnailTaskProcessor::ConstructL()Attach %d", ret);

    76     

    77 	// set initial PS value

    78     ret = iProperty.Set( ETrue );

    79     TN_DEBUG2( "CThumbnailTaskProcessor::ConstructL() Set IDLE ETrue %d", ret );

    80     iIdle = ETrue;

    81     

    82     iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle);

    83     

    84     iTimerActive = EFalse;

    85      

    86     iIsDaemonAsProcess = EFalse;

    87     }

    88 

    89 

    90 // ---------------------------------------------------------------------------

    91 // CThumbnailTaskProcessor::~CThumbnailTaskProcessor()

    92 // Destructor.

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

    94 //

    95 CThumbnailTaskProcessor::~CThumbnailTaskProcessor()

    96     {

    97     Cancel();

    98     iTasks.ResetAndDestroy();

    99     iProperty.Close();

   100     TInt ret = RProperty::Delete(KServerIdle, KIdle);

   101     TN_DEBUG2( "CThumbnailTaskProcessor::CThumbnailTaskProcessor() Delete KServerIdle %d", ret);

   102     

   103     if(iPeriodicTimer)

   104        {

   105        iPeriodicTimer->Cancel();

   106        }

   107     delete iPeriodicTimer;

   108     

   109     }

   110 

   111 

   112 // ---------------------------------------------------------------------------

   113 // CThumbnailTaskProcessor::AddTaskL()

   114 // Adds new task to the task queue.

   115 // ---------------------------------------------------------------------------

   116 //

   117 void CThumbnailTaskProcessor::AddTaskL( CThumbnailTask* aTask )

   118     {

   119     TN_DEBUG1( "CThumbnailTaskProcessor::AddTaskL()");

   120     __ASSERT_DEBUG(( aTask ), ThumbnailPanic( EThumbnailNullPointer ));

   121     const TInt taskCount = iTasks.Count();

   122     iTasks.AppendL( aTask );

   123     

   124     if ( !IsActive() && !taskCount )

   125         {

   126         // this is the first task in queue, go active now

   127         iActiveTask = aTask;

   128         

   129         SetActive();

   130         TRequestStatus* statusPtr = &iStatus;

   131         User::RequestComplete( statusPtr, KErrNone );

   132         }

   133     }

   134 

   135 

   136 // ---------------------------------------------------------------------------

   137 // CThumbnailTaskProcessor::RemoveTask()

   138 // Removes specific tasks from the queue.

   139 // ---------------------------------------------------------------------------

   140 //

   141 TInt CThumbnailTaskProcessor::RemoveTask( const TThumbnailServerRequestId&

   142     aRequestId )

   143     {

   144     TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - request ID: %d", aRequestId.iRequestId);

   145     

   146     TBool cancel = EFalse;

   147     TInt res = KErrNotFound;

   148     

   149     for ( TInt i = iTasks.Count(); --i >= 0; )

   150         {

   151         CThumbnailTask* task = iTasks[i];

   152         if ( task->RequestId() == aRequestId )

   153             {

   154             if ( task->State() != CThumbnailTask::ERunning )

   155                 {

   156                 // Remove task from queue

   157                 delete task;

   158                 iTasks.Remove( i );

   159                 

   160                 TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - removed request ID: %d", aRequestId.iRequestId);

   161                 }

   162             else

   163                 {

   164                 // Task is already running, canceled first

   165                 task->Cancel();

   166                 delete task;

   167                 iTasks.Remove( i );

   168                 cancel = ETrue;

   169                 

   170                 TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - canceled & removed request ID: %d", aRequestId.iRequestId);

   171                 }

   172             

   173             res = KErrNone;

   174             

   175             // don't break, because there could be many tasks related to the same request ID

   176             }

   177         }

   178     

   179     // no tasks active anymore

   180     if ( cancel ) 

   181         {

   182         Cancel();

   183         TaskComplete(NULL);

   184         }

   185     

   186     TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - remaining task count: %d", iTasks.Count());

   187     

   188     return res;

   189     }

   190 

   191 // ---------------------------------------------------------------------------

   192 // CThumbnailTaskProcessor::RemoveTasks()

   193 // Removes specific task from the queue.

   194 // ---------------------------------------------------------------------------

   195 //

   196 void CThumbnailTaskProcessor::RemoveTasks( CThumbnailServerSession* aSession )

   197     {

   198     TN_DEBUG1( "CThumbnailTaskProcessor::RemoveTasks()");

   199     

   200     TBool cancel = EFalse;

   201     

   202     for ( TInt i = iTasks.Count(); --i >= 0; )

   203         {

   204         CThumbnailTask* task = iTasks[i];

   205         if ( task->RequestId().iSession == aSession)

   206             {

   207             if ( task->State() != CThumbnailTask::ERunning )

   208                 {

   209                 TThumbnailRequestId id = task->RequestId().iRequestId;

   210                 

   211                 // Remove task from queue

   212                 delete task;

   213                 iTasks.Remove( i );

   214                 

   215                 TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - removed request ID: %d", id);

   216                 }

   217             else

   218                 {

   219                 TN_DEBUG1( "CThumbnailTaskProcessor::RemoveTasks() - task still running");

   220                 

   221                 TThumbnailRequestId id = task->RequestId().iRequestId;

   222                 

   223                 // Task is already running, canceled first

   224                 task->ResetMessageData();

   225                 task->Cancel();

   226                 delete task;

   227                 iTasks.Remove( i );

   228                 cancel = ETrue;

   229                 

   230                 TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - canceled & removed request ID: %d", id);

   231                 }

   232             }

   233         }

   234     

   235     // no tasks active anymore

   236     if ( cancel ) 

   237         {

   238         Cancel();

   239         TaskComplete(NULL);

   240         }

   241     

   242     TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - remaining task count: %d", iTasks.Count());

   243     }

   244 

   245 // ---------------------------------------------------------------------------

   246 // CThumbnailTaskProcessor::RemoveAllTasks()

   247 // Removes specific task from the queue.

   248 // ---------------------------------------------------------------------------

   249 //

   250 void CThumbnailTaskProcessor::RemoveAllTasks()

   251     {

   252     TN_DEBUG1( "CThumbnailTaskProcessor::RemoveAllTasks()");

   253     

   254     TBool cancel = EFalse;

   255     

   256     for ( TInt i = iTasks.Count(); --i >= 0; )

   257         {

   258         CThumbnailTask* task = iTasks[i];

   259         if ( task->State() != CThumbnailTask::ERunning )

   260             {

   261             TThumbnailRequestId id = task->RequestId().iRequestId;

   262             

   263             // Remove task from queue

   264             delete task;

   265             iTasks.Remove( i );

   266             

   267             TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - removed request ID: %d", id);

   268             }

   269         else

   270             {

   271             TN_DEBUG1( "CThumbnailTaskProcessor::RemoveTasks() - task still running");

   272             

   273             TThumbnailRequestId id = task->RequestId().iRequestId;

   274             

   275             // Task is already running, canceled first

   276             task->ResetMessageData();

   277             task->Cancel();

   278             delete task;

   279             iTasks.Remove( i );

   280             cancel = ETrue;

   281             

   282             TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - canceled & removed request ID: %d", id);

   283             }

   284         }

   285     

   286     // no tasks active anymore

   287     if ( cancel ) 

   288         {

   289         Cancel();

   290         TaskComplete(NULL);

   291         }

   292     

   293     TN_DEBUG1( "CThumbnailTaskProcessor::RemoveAllTasks() - Task removed because of starting format" );

   294     }

   295 

   296 // ---------------------------------------------------------------------------

   297 // CThumbnailTaskProcessor::ChangeTaskPriority()

   298 // Changes priority of a task.

   299 // ---------------------------------------------------------------------------

   300 //

   301 TInt CThumbnailTaskProcessor::ChangeTaskPriority( const

   302     TThumbnailServerRequestId& aRequestId, const TInt aNewPriority )

   303     {

   304     TInt err = KErrNotFound;

   305     const TInt count = iTasks.Count();

   306     for ( TInt i( 0 ); i < count; i++ )

   307         {

   308         if ( iTasks[i]->RequestId() == aRequestId )

   309             {

   310             iTasks[i]->ChangeTaskPriority( aNewPriority );

   311             err = KErrNone;

   312             break;

   313             }

   314         }

   315     return err;

   316     }

   317 

   318 

   319 // ---------------------------------------------------------------------------

   320 // CThumbnailTaskProcessor::RunL()

   321 // ---------------------------------------------------------------------------

   322 //

   323 void CThumbnailTaskProcessor::RunL()

   324     {

   325     iActiveTask = NULL;

   326     TInt priority( KMinTInt );

   327     TInt taskPriority;

   328     

   329 #ifdef _DEBUG

   330     TN_DEBUG2( "CThumbnailTaskProcessor::TASKPROCESSOR-COUNTER---------- in, Tasks = %d", iTasks.Count() );

   331 #endif

   332     

   333     /* 

   334     // remove completed tasks and run priorised task

   335     for ( TInt i = 0; i < iTasks.Count(); i++ )

   336         {

   337         CThumbnailTask* task = iTasks[i];

   338         if ( task->State() == CThumbnailTask::EComplete )

   339             {

   340             // delete completed task

   341             delete task;

   342             iTasks.Remove( i );

   343             

   344             // correct the index so that no tasks are skipped

   345             i--;

   346             if(i <= -1)

   347                 {

   348                 i = -1;

   349                 }

   350             }*/

   351     

   352     // remove completed tasks and run priorised task

   353     for ( TInt i = iTasks.Count(); --i >= 0; )

   354         {

   355         CThumbnailTask* task = iTasks[i];

   356         if ( task->State() == CThumbnailTask::EComplete )

   357             {

   358             // Delete completed task

   359             delete task;

   360             iTasks.Remove( i );

   361             }

   362         else

   363             {

   364             if( task->State() == CThumbnailTask::EIdle )

   365                 {

   366                 taskPriority = task->Priority();

   367                 if ( taskPriority > priority )

   368                     {

   369                     priority = taskPriority;

   370                     iActiveTask = task;

   371                     }

   372                 }

   373             }

   374         }

   375 

   376     if ( iActiveTask )

   377         {

   378         iActiveTask->StartL();

   379         }

   380     

   381 #ifdef _DEBUG

   382     TN_DEBUG2( "CThumbnailTaskProcessor::TASKPROCESSOR-COUNTER---------- out, Tasks = %d", iTasks.Count() );

   383 #endif

   384 

   385 	//update PS value for Daemon

   386     if( iTasks.Count() > 0 && iIdle)

   387         {

   388         //set not idle

   389         if(iTimerActive)

   390            {

   391            iPeriodicTimer->Cancel();

   392            iTimerActive = EFalse;

   393            }

   394         TInt ret = iProperty.Set( EFalse );

   395         TN_DEBUG2( "CThumbnailTaskProcessor::RunL() iProperty Set EFalse %d", ret );

   396         iIdle = EFalse;

   397         }

   398     else

   399         {

   400         if(!iIdle)

   401             {

   402             //set idle    

   403             if(iIsDaemonAsProcess)

   404                {

   405                if(iTimerActive)

   406                  {

   407                  iPeriodicTimer->Cancel();

   408                  iTimerActive = EFalse;

   409                  } 

   410                TN_DEBUG1( "CThumbnailTaskProcessor::RunL() - daemon is the process");

   411                TInt ret = iProperty.Set( ETrue );

   412                TN_DEBUG2( "CThumbnailTaskProcessor::RunL() iProperty Set ETrue %d", ret );

   413                iIdle = ETrue;

   414                }

   415             else

   416                {

   417                TN_DEBUG1( "CThumbnailTaskProcessor::RunL() - daemon is not the process - start timer");

   418                if(iTimerActive)

   419                   {

   420                   iPeriodicTimer->Cancel();

   421                   iTimerActive = EFalse;

   422                   }  

   423                iPeriodicTimer->Start( KHarvestingCompleteTimeout, KHarvestingCompleteTimeout, 

   424                                    TCallBack(PeriodicTimerCallBack, this));

   425                iTimerActive = ETrue;

   426                }

   427             }

   428         }

   429     }

   430 

   431 // ---------------------------------------------------------------------------

   432 // Handle any error from RunL

   433 // ---------------------------------------------------------------------------

   434 //

   435 TInt CThumbnailTaskProcessor::RunError( TInt aError )

   436     {

   437     TN_DEBUG1( "CThumbnailTaskProcessor::RunError()");

   438     if ( iActiveTask )

   439         {

   440         // This will complete the task and continue processing from the

   441         // next task

   442         iActiveTask->StartError( aError );

   443         }

   444     return KErrNone;

   445     }

   446 

   447 // ---------------------------------------------------------------------------

   448 // CThumbnailTaskProcessor::DoCancel()

   449 // ---------------------------------------------------------------------------

   450 //

   451 void CThumbnailTaskProcessor::DoCancel()

   452     {

   453     // No implementation required

   454     }

   455 

   456 

   457 // ---------------------------------------------------------------------------

   458 // CThumbnailTaskProcessor::TaskComplete()

   459 // Marks task to completed

   460 // ---------------------------------------------------------------------------

   461 //

   462 void CThumbnailTaskProcessor::TaskComplete( CThumbnailTask*  /*aTask*/ )

   463     {

   464     TN_DEBUG1( "CThumbnailTaskProcessor::TaskComplete()");

   465  

   466     if ( iTasks.Count() && !IsActive())

   467         {

   468         // More tasks yet to be run

   469         SetActive();

   470         TRequestStatus* statusPtr = &iStatus;

   471         User::RequestComplete( statusPtr, KErrNone );

   472         }

   473     else if( iTasks.Count() == 0 && !iIdle)

   474         {

   475         if(iIsDaemonAsProcess)

   476             {

   477             if(iTimerActive)

   478               {

   479               iPeriodicTimer->Cancel();

   480               iTimerActive = EFalse;

   481               } 

   482             TN_DEBUG1( "CThumbnailTaskProcessor::TaskComplete() - daemon is the process");

   483             TInt ret = iProperty.Set( ETrue );

   484             TN_DEBUG2( "CThumbnailTaskProcessor::TaskComplete() iProperty Set ETrue %d", ret );

   485             iIdle = ETrue;

   486             }

   487         else

   488             {

   489             if(iTimerActive)

   490               {

   491               iPeriodicTimer->Cancel();

   492               iTimerActive = EFalse;

   493               }  

   494             iPeriodicTimer->Start( KPSKeyTimeout, KPSKeyTimeout, 

   495                              TCallBack(PeriodicTimerCallBack, this));

   496             iTimerActive = ETrue;

   497             }

   498         }

   499     }

   500 

   501 // ---------------------------------------------------------------------------

   502 // CThumbnailTaskProcessor::PeriodicTimerCallBack()

   503 // ---------------------------------------------------------------------------

   504 //

   505 TInt CThumbnailTaskProcessor::PeriodicTimerCallBack(TAny* aAny)

   506     {

   507     TN_DEBUG1( "CThumbnailTaskProcessor::PeriodicTimerCallBack()");

   508     

   509     CThumbnailTaskProcessor* self = static_cast<CThumbnailTaskProcessor*>( aAny );

   510     

   511     self->iTimerActive = EFalse;

   512     self->iPeriodicTimer->Cancel();

   513     TInt ret = self->iProperty.Set( ETrue );

   514     TN_DEBUG2( "CThumbnailTaskProcessor::PeriodicTimerCallBack() iProperty Set ETrue %d", ret );

   515     self->iIdle = ETrue;

   516 

   517     return KErrNone; // Return value ignored by CPeriodic

   518     }

   519 

   520 void CThumbnailTaskProcessor::SetDaemonAsProcess(TBool aValue)

   521     {

   522     TN_DEBUG2( "CThumbnailTaskProcessor::SetDaemonAsProcess() Daemon set %d", aValue );

   523     iIsDaemonAsProcess = aValue;

   524     }

   525 

   526 

   527 // End of file