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 = 100;

    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 = NULL;

    82         TRAPD( err, entry = CEntry::NewL( aUri, aError ) );

    83         if ( !err && entry )

    84             {

    85             err = iNotFetched.Find( entry );

    86             if ( err != KErrNotFound )

    87                 {

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

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

    90                     {

    91                     iNotFetched[ i ]->iError = aError;

    92                     }

    93                 }

    94             else 

    95                 {

    96                 if( iNotFetched.Count() < KMaxStoredEntries )

    97                     {

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

    99                     if ( err != KErrNone )

   100                         {

   101                         delete entry;

   102                         }

   103                     }

   104                 }

   105             }

   106         }

   107     }

   108 

   109 // -----------------------------------------------------------------------------

   110 // CThumbnailFetchedChecker::Reset()

   111 // -----------------------------------------------------------------------------

   112 //

   113 void CThumbnailFetchedChecker::Reset()

   114     {

   115     iNotFetched.ResetAndDestroy();

   116     }

   117 

   118 // -----------------------------------------------------------------------------

   119 // CThumbnailFetchedChecker::CEntry::New()

   120 // -----------------------------------------------------------------------------

   121 //

   122 CThumbnailFetchedChecker::CEntry* CThumbnailFetchedChecker::CEntry::NewL(

   123         const TDesC& aUri, TInt aError )

   124     {

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

   126     if ( self )

   127         {

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

   129         self->iError = aError;

   130         if ( !self->iUri )

   131             {

   132             delete self;

   133             self = NULL;

   134             }

   135         }

   136     return self;

   137     }

   138 

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

   140 // CThumbnailFetchedChecker::CEntry::FindCB()

   141 // -----------------------------------------------------------------------------

   142 //

   143 TInt CThumbnailFetchedChecker::CEntry::FindCB(

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

   145     {

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

   147     }

   148 

   149 // -----------------------------------------------------------------------------

   150 // CThumbnailFetchedChecker::CEntry::InsertCB()

   151 // -----------------------------------------------------------------------------

   152 //

   153 TInt CThumbnailFetchedChecker::CEntry::InsertCB(

   154         const CThumbnailFetchedChecker::CEntry& aEntry1,

   155         const CThumbnailFetchedChecker::CEntry& aEntry2 )

   156     {

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

   158     }

   159 

   160 // -----------------------------------------------------------------------------

   161 // CThumbnailFetchedChecker::CEntry::CEntry()

   162 // -----------------------------------------------------------------------------

   163 //

   164 CThumbnailFetchedChecker::CEntry::CEntry()

   165     {

   166     }

   167 

   168 // -----------------------------------------------------------------------------

   169 // CThumbnailFetchedChecker::CEntry::~CEntry()

   170 // -----------------------------------------------------------------------------

   171 //

   172 CThumbnailFetchedChecker::CEntry::~CEntry()

   173     {

   174     delete iUri;

   175     }