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:

    15  *

    16 */

    17 

    18 #include "thumbnailfetchedchecker.h"

    19 

    20 const int KMaxStoredEntries = 50;

    21 

    22 // -----------------------------------------------------------------------------

    23 // CThumbnailFetchedChecker::CThumbnailFetchedChecker()

    24 // -----------------------------------------------------------------------------

    25 //

    26 CThumbnailFetchedChecker* CThumbnailFetchedChecker::NewL()

    27     {

    28     return new (ELeave) CThumbnailFetchedChecker();

    29     }

    30 

    31 // -----------------------------------------------------------------------------

    32 // CThumbnailFetchedChecker::CThumbnailFetchedChecker()

    33 // -----------------------------------------------------------------------------

    34 //

    35 CThumbnailFetchedChecker::CThumbnailFetchedChecker()

    36     {

    37     }

    38 

    39 // -----------------------------------------------------------------------------

    40 // CThumbnailFetchedChecker::~CThumbnailFetchedChecker()

    41 // -----------------------------------------------------------------------------

    42 //

    43 CThumbnailFetchedChecker::~CThumbnailFetchedChecker()

    44     {

    45     iNotFetched.ResetAndDestroy();

    46     }

    47 

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

    49 // CThumbnailFetchedChecker::LastFetchResult()

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

    51 //

    52 TInt CThumbnailFetchedChecker::LastFetchResult( const TDesC& aUri )

    53     {

    54     TInt i = iNotFetched.FindInOrder( aUri, CEntry::FindCB );

    55     if ( i >= 0 && i < iNotFetched.Count() )

    56         {

    57         return iNotFetched[ i ]->iError;

    58         }

    59     return KErrNone;

    60     }

    61 

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

    63 // CThumbnailFetchedChecker::SetFetchResult()

    64 // -----------------------------------------------------------------------------

    65 //

    66 void CThumbnailFetchedChecker::SetFetchResult( const TDesC& aUri, TInt aError )

    67     {

    68     if ( aError == KErrNone )

    69         {

    70         // Do not store successful results

    71         TInt i = iNotFetched.FindInOrder( aUri, CEntry::FindCB );

    72         if ( i >= 0 && i < iNotFetched.Count() )

    73             {

    74             delete iNotFetched[ i ];

    75             iNotFetched.Remove( i );

    76             }

    77         }

    78     else

    79         {

    80         // Add or update

    81         CEntry* entry = CEntry::New( aUri, aError );

    82         if ( entry )

    83             {

    84             TInt err = iNotFetched.Find( entry );

    85             if ( err != KErrNotFound )

    86                 {

    87                 TInt i = iNotFetched.FindInOrder( aUri, CEntry::FindCB );

    88                 if ( i >= 0 && i < iNotFetched.Count() )

    89                     {

    90                     iNotFetched[ i ]->iError = aError;

    91                     }

    92                 }

    93             else 

    94                 {

    95                 if( iNotFetched.Count() < KMaxStoredEntries )

    96                     {

    97                     TInt err = iNotFetched.InsertInOrder( entry, CEntry::InsertCB );

    98                     if ( err != KErrNone )

    99                         {

   100                         delete entry;

   101                         }

   102                     }

   103                 }

   104             }

   105         }

   106     }

   107 

   108 // -----------------------------------------------------------------------------

   109 // CThumbnailFetchedChecker::Reset()

   110 // -----------------------------------------------------------------------------

   111 //

   112 void CThumbnailFetchedChecker::Reset()

   113     {

   114     iNotFetched.ResetAndDestroy();

   115     }

   116 

   117 // -----------------------------------------------------------------------------

   118 // CThumbnailFetchedChecker::CEntry::New()

   119 // -----------------------------------------------------------------------------

   120 //

   121 CThumbnailFetchedChecker::CEntry* CThumbnailFetchedChecker::CEntry::New(

   122         const TDesC& aUri, TInt aError )

   123     {

   124     CEntry* self = new (ELeave) CEntry();

   125     if ( self )

   126         {

   127         self->iUri = aUri.Alloc();

   128         self->iError = aError;

   129         if ( !self->iUri )

   130             {

   131             delete self;

   132             self = NULL;

   133             }

   134         }

   135     return self;

   136     }

   137 

   138 // -----------------------------------------------------------------------------

   139 // CThumbnailFetchedChecker::CEntry::FindCB()

   140 // -----------------------------------------------------------------------------

   141 //

   142 TInt CThumbnailFetchedChecker::CEntry::FindCB(

   143     const TDesC* aUri, const CThumbnailFetchedChecker::CEntry& aEntry )

   144     {

   145     return aUri->CompareF( *( aEntry.iUri ) );

   146     }

   147 

   148 // -----------------------------------------------------------------------------

   149 // CThumbnailFetchedChecker::CEntry::InsertCB()

   150 // -----------------------------------------------------------------------------

   151 //

   152 TInt CThumbnailFetchedChecker::CEntry::InsertCB(

   153         const CThumbnailFetchedChecker::CEntry& aEntry1,

   154         const CThumbnailFetchedChecker::CEntry& aEntry2 )

   155     {

   156     return aEntry1.iUri->CompareF( *( aEntry2.iUri ) );

   157     }

   158 

   159 // -----------------------------------------------------------------------------

   160 // CThumbnailFetchedChecker::CEntry::CEntry()

   161 // -----------------------------------------------------------------------------

   162 //

   163 CThumbnailFetchedChecker::CEntry::CEntry()

   164     {

   165     }

   166 

   167 // -----------------------------------------------------------------------------

   168 // CThumbnailFetchedChecker::CEntry::~CEntry()

   169 // -----------------------------------------------------------------------------

   170 //

   171 CThumbnailFetchedChecker::CEntry::~CEntry()

   172     {

   173     delete iUri;

   174     }