browserui/browser/BrowserAppSrc/AHLEInterface.cpp
changeset 0 84ad3b177aa3
equal deleted inserted replaced
-1:000000000000 0:84ad3b177aa3
       
     1 /*
       
     2 * Copyright (c) 2006 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 the License "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:  AHLE client interface API definition.
       
    15  *
       
    16 */
       
    17 
       
    18 
       
    19 // INCLUDE FILES
       
    20 #include <e32std.h>
       
    21 #include "AHLEInterface.h"
       
    22 
       
    23 
       
    24 
       
    25 // ================= MEMBER FUNCTIONS =======================
       
    26 
       
    27 CAHLEInterface* CAHLEInterface::NewL( TAHLENewType aNewType,
       
    28                                       const TDesC& aDatabase,
       
    29                                       TUint aPrimarySize,
       
    30                                       TUint aSecondarySize,
       
    31                                       TAHLEScore aAdaptationSpeed )
       
    32 {
       
    33   CAHLEInterface* apiObject = new (ELeave) CAHLEInterface;
       
    34   CleanupStack::PushL( apiObject );
       
    35   apiObject->ConstructL( aNewType, aDatabase, aPrimarySize, aSecondarySize, aAdaptationSpeed );
       
    36   CleanupStack::Pop();
       
    37   return apiObject;
       
    38 }
       
    39 
       
    40 EXPORT_C CAHLEInterface* CAHLEInterface::NewL( const TDesC& aDatabase,
       
    41                                                TUint aPrimarySize,
       
    42                                                TUint aSecondarySize,
       
    43                                                TAHLEScore aAdaptationSpeed ){
       
    44   return NewL( EAHLENewAllArgs, aDatabase, aPrimarySize, aSecondarySize, aAdaptationSpeed );
       
    45 }
       
    46 
       
    47 EXPORT_C  CAHLEInterface* CAHLEInterface::NewL( const TDesC& aDatabase ){
       
    48   return NewL( EAHLENewDbOnlyArgs, aDatabase, 0, 0, 0);
       
    49 }
       
    50 
       
    51 EXPORT_C  CAHLEInterface* CAHLEInterface::NewL(){
       
    52   return NewL( EAHLENewNoArgs, KAHLEInterfaceDummyFile, 0, 0, 0);
       
    53 }
       
    54 
       
    55 EXPORT_C  CAHLEInterface* CAHLEInterface::NewL( TUint aPrimarySize ){
       
    56   return NewL( EAHLENewPrimarySizeOnlyArgs, KAHLEInterfaceDummyFile, aPrimarySize, 0, 0);
       
    57 }
       
    58 
       
    59 
       
    60 // -----------------------------------------------------------------------------
       
    61 // CAHLEInterface::InitializeAHLE
       
    62 // Creates the AHLE client if needed.
       
    63 // Throws exception on failure. This is where the AHLE client finally gets created.
       
    64 // We defer it as long as possible.
       
    65 // -----------------------------------------------------------------------------
       
    66 void CAHLEInterface::InitializeAHLEL()
       
    67 {
       
    68   //If already done return quickly.
       
    69   if (iAHLE) return;
       
    70 
       
    71   TUint aPrimarySize = 0;
       
    72   TUint aSecondarySize = 0;
       
    73   TAHLEScore aAdaptationSpeed = 0;
       
    74 
       
    75   //Fire the correct contructor. It should map to the CAHLEInterface contructor.
       
    76   switch (iNewType)
       
    77     {
       
    78     case EAHLENewNoArgs:
       
    79       iAHLE = CAHLE::NewL();
       
    80       break;
       
    81 
       
    82     case EAHLENewAllArgs:
       
    83       iAHLE = CAHLE::NewL( *iDatabase, iPrimarySize, iSecondarySize, iAdaptationSpeed);
       
    84       break;
       
    85 
       
    86     case EAHLENewDbOnlyArgs:
       
    87       iAHLE = CAHLE::NewL( *iDatabase );
       
    88       break;
       
    89 
       
    90     case EAHLENewPrimarySizeOnlyArgs:
       
    91       //The actual value will be added by the initialization later. We
       
    92       //can't change the AHLE constructors.
       
    93       iDeferPrimarySize = iPrimarySize;
       
    94       iAHLE = CAHLE::NewL();
       
    95       break;
       
    96 
       
    97     default:
       
    98       iAHLE = CAHLE::NewL();
       
    99     }
       
   100 
       
   101   //Do the deferred reconfigure. It was not done earlier, the values
       
   102   //were cached for now. Note that the values could have been set in the
       
   103   //constructor as well as here. The trick is to keep track of which
       
   104   //ones to set here. If the deferred one was set use it. Otherwise use
       
   105   //the one just read in with GetConfiguration()
       
   106 
       
   107   iAHLE->GetConfigurationL( aPrimarySize, aSecondarySize, aAdaptationSpeed );
       
   108   iAHLE->ReconfigureL( iDeferPrimarySize     ? iDeferPrimarySize    : aPrimarySize,
       
   109                        iDeferSecondarySize   ? iDeferSecondarySize  : aSecondarySize,
       
   110                        iDeferAdaptationSpeed ? iDeferAdaptationSpeed: aAdaptationSpeed );
       
   111 }
       
   112 
       
   113 // -----------------------------------------------------------------------------
       
   114 // Idle Callback Function
       
   115 // Called when the thread is not busy. The code will be initialized
       
   116 // now. If it was initialized explicitly bu other code than this call
       
   117 // won't do very much. In any case this will always return false. It
       
   118 // doesn't need to run a second time since it will run to completion.
       
   119 // -----------------------------------------------------------------------------
       
   120 TInt CAHLEInterface::AHLEInitializationCB(TAny* thisObj)
       
   121 {
       
   122   ((CAHLEInterface*)thisObj)->InitializeAHLEL();
       
   123   return EFalse;
       
   124 }
       
   125 
       
   126 
       
   127 
       
   128 // -----------------------------------------------------------------------------
       
   129 // CAHLEInterface::CAHLEInterface
       
   130 // -----------------------------------------------------------------------------
       
   131 CAHLEInterface::CAHLEInterface()
       
   132 {
       
   133   iAHLE = NULL;
       
   134   iDatabase = NULL;
       
   135 
       
   136   iPrimarySize = 0;
       
   137   iSecondarySize = 0;
       
   138   iAdaptationSpeed = 0;
       
   139 
       
   140   iDeferPrimarySize = 0;
       
   141   iDeferSecondarySize = 0;
       
   142   iDeferAdaptationSpeed = 0;
       
   143 }
       
   144 
       
   145 
       
   146 // -----------------------------------------------------------------------------
       
   147 // CAHLEInterface::~CAHLEInterface
       
   148 // C++ destructor
       
   149 // -----------------------------------------------------------------------------
       
   150 CAHLEInterface::~CAHLEInterface()
       
   151 {
       
   152 if(iIdle != NULL)
       
   153 	{
       
   154 	iIdle->Cancel();
       
   155 	}
       
   156   delete iIdle;
       
   157   delete iAHLE;
       
   158   delete iDatabase;
       
   159 }
       
   160 
       
   161 
       
   162 // -----------------------------------------------------------------------------
       
   163 // CAHLEInterface::IsConnected
       
   164 // Check if the client has been connected to the server. Note that if the actual
       
   165 // AHLE client has not been created yet we ARE considered connected. Otherwise we
       
   166 // would need to connect almost immediately.
       
   167 // -----------------------------------------------------------------------------
       
   168 EXPORT_C TBool CAHLEInterface::IsConnected()
       
   169     {
       
   170       return (iAHLE ? iAHLE->IsConnected(): ETrue);
       
   171     }
       
   172 
       
   173 
       
   174 // ---------------------------------------------------------
       
   175 // CAHLEInterface::ConstructL
       
   176 // Light weight constructor. Real work is deferred until later.
       
   177 // An active idle object is created to do the construction when
       
   178 // things are not busy. If it is done by a task that explicitly
       
   179 // requires the AHLE client it will not need to run.
       
   180 // ---------------------------------------------------------
       
   181 void CAHLEInterface::ConstructL( TAHLENewType aNewType,
       
   182                                  const TDesC& aDatabase,
       
   183                                  TUint aPrimarySize,
       
   184                                  TUint aSecondarySize,
       
   185                                  TAHLEScore aAdaptationSpeed )
       
   186 {
       
   187   iAHLE = NULL;
       
   188   iPrimarySize = aPrimarySize;
       
   189   iSecondarySize = aSecondarySize;
       
   190   iAdaptationSpeed = aAdaptationSpeed;
       
   191   iDatabase = aDatabase.Alloc();
       
   192   iNewType = aNewType;
       
   193   iIdle = CIdle::NewL(CActive::EPriorityIdle);
       
   194   iIdle->Start(TCallBack(AHLEInitializationCB, this));
       
   195 }
       
   196 
       
   197 
       
   198 // -----------------------------------------------------------------------------
       
   199 // CAHLEInterface::SetObserverL
       
   200 // -----------------------------------------------------------------------------
       
   201 EXPORT_C void CAHLEInterface::SetObserverL( const MAHLEClientObserver* aClientObs )
       
   202 {
       
   203   InitializeAHLEL();
       
   204   iAHLE->SetObserverL(aClientObs);
       
   205 }
       
   206 
       
   207 
       
   208 // ---------------------------------------------------------
       
   209 // CAHLEInterface::Reconfigure
       
   210 // ---------------------------------------------------------
       
   211 EXPORT_C TInt CAHLEInterface::ReconfigureL( TUint aPrimarySize,
       
   212                                             TUint aSecondarySize,
       
   213                                             TAHLEScore aAdaptationSpeed )
       
   214 {
       
   215   InitializeAHLEL();
       
   216   return iAHLE->ReconfigureL(aPrimarySize, aSecondarySize, aAdaptationSpeed );
       
   217 }
       
   218 
       
   219 
       
   220 // ---------------------------------------------------------
       
   221 // CAHLEInterface::GetConfiguration
       
   222 // ---------------------------------------------------------
       
   223 EXPORT_C void CAHLEInterface::GetConfigurationL( TUint& aPrimarySize,
       
   224                                                  TUint& aSecondarySize,
       
   225                                                  TAHLEScore& aAdaptationSpeed )
       
   226 {
       
   227   InitializeAHLEL();
       
   228   iAHLE->GetConfigurationL(aPrimarySize, aSecondarySize, aAdaptationSpeed );
       
   229 }
       
   230 
       
   231 
       
   232 // ----------------------------------------------------------------
       
   233 // CAHLEInterface::GetParameters
       
   234 // ----------------------------------------------------------------
       
   235 EXPORT_C TInt CAHLEInterface::GetParameters( TAHLESortOrder& /* aOrder */ ) const
       
   236 {
       
   237   return KErrNotSupported;
       
   238 }
       
   239 
       
   240 
       
   241 // ----------------------------------------------------------------
       
   242 // CAHLEInterface::GetParameters
       
   243 // ----------------------------------------------------------------
       
   244 EXPORT_C TInt CAHLEInterface::GetParameters( TAHLESortOrder& /* aOrder */,
       
   245                                              TAny* /* aReserved */  ) const
       
   246 {
       
   247   return KErrNotSupported;
       
   248 }
       
   249 
       
   250 
       
   251 // ----------------------------------------------------------------
       
   252 // CAHLEInterface::SetParameters
       
   253 // ----------------------------------------------------------------
       
   254 EXPORT_C TInt CAHLEInterface::SetParameters( TAHLESortOrder /* aOrder */ )
       
   255 {
       
   256   return KErrNotSupported;
       
   257 }
       
   258 
       
   259 EXPORT_C TInt CAHLEInterface::SetParameters( TAHLESortOrder /* aOrder */,
       
   260                                              TAny* /* aReserved */ )
       
   261 {
       
   262   return KErrNotSupported;
       
   263 }
       
   264 
       
   265 
       
   266 // ---------------------------------------------------------
       
   267 // CAHLEInterface::NewAccessL
       
   268 // ---------------------------------------------------------
       
   269 EXPORT_C TInt CAHLEInterface::NewAccessL( const TDesC& aItem,
       
   270                                           const TDesC& aItemName )
       
   271 {
       
   272   InitializeAHLEL();
       
   273   return (iAHLE->NewAccessL(aItem, aItemName));
       
   274 }
       
   275 
       
   276 
       
   277 EXPORT_C void CAHLEInterface::NewAccessL( TRequestStatus& aStatus,
       
   278                                           const TDesC& aItem,
       
   279                                           const TDesC& aItemName )
       
   280 {
       
   281   InitializeAHLEL();
       
   282   iAHLE->NewAccessL(aStatus, aItem, aItemName);
       
   283 }
       
   284 
       
   285 
       
   286 // ----------------------------------------------------------------
       
   287 // CAHLEInterface::AdaptiveListL
       
   288 // ----------------------------------------------------------------
       
   289 EXPORT_C TInt CAHLEInterface::AdaptiveListL( CDesCArray&  aItems,
       
   290                                              CDesCArray&  aItemNames,
       
   291                                              const TInt  aSize,
       
   292                                              const TDesC& aMatch,
       
   293                                              const TAHLEState aState )
       
   294 {
       
   295   InitializeAHLEL();
       
   296   return (iAHLE->AdaptiveListL( aItems, aItemNames, aSize, aMatch, aState ));
       
   297 }
       
   298 
       
   299 
       
   300 // ---------------------------------------------------------
       
   301 // CAHLEInterface::OrderByScoreL
       
   302 // ---------------------------------------------------------
       
   303 //
       
   304 EXPORT_C TInt CAHLEInterface::OrderByScoreL( CDesCArray& aItems,
       
   305                                              CDesCArray& aItemsSorted )
       
   306 {
       
   307   InitializeAHLEL();
       
   308   return (iAHLE->OrderByScoreL( aItems, aItemsSorted ));
       
   309 }
       
   310 
       
   311 EXPORT_C TInt CAHLEInterface::OrderByScoreL( CDesCArray& /* aItems */,
       
   312                                              RArray<TInt>& /* aSortOrder */ )
       
   313 {
       
   314   return KErrNotSupported;
       
   315 }
       
   316 
       
   317 
       
   318 // ---------------------------------------------------------
       
   319 // CAHLEInterface::RemoveL
       
   320 // ---------------------------------------------------------
       
   321 EXPORT_C TInt CAHLEInterface::RemoveL( const TDesC& aItem )
       
   322 {
       
   323   InitializeAHLEL();
       
   324   return (iAHLE->RemoveL( aItem ));
       
   325 }
       
   326 
       
   327 EXPORT_C void CAHLEInterface::RemoveL( const TDesC& aItem,
       
   328                                        TRequestStatus& aStatus )
       
   329 {
       
   330   InitializeAHLEL();
       
   331   iAHLE->RemoveL( aItem, aStatus );
       
   332 }
       
   333 
       
   334 EXPORT_C void CAHLEInterface::RemoveL( const CDesCArray& aItems,
       
   335                                        TRequestStatus &aStatus)
       
   336 {
       
   337   InitializeAHLEL();
       
   338   iAHLE->RemoveL( aItems, aStatus );
       
   339 }
       
   340 
       
   341 EXPORT_C TInt CAHLEInterface::RemoveL(const CDesCArray& aItems )
       
   342 {
       
   343   InitializeAHLEL();
       
   344   return (iAHLE->RemoveL( aItems ));
       
   345 }
       
   346 
       
   347 
       
   348 // ---------------------------------------------------------
       
   349 // CAHLEInterface::RemoveMatching
       
   350 // ---------------------------------------------------------
       
   351 EXPORT_C TInt CAHLEInterface::RemoveMatchingL( const TDesC& aMatch )
       
   352 {
       
   353   InitializeAHLEL();
       
   354   return (iAHLE->RemoveMatchingL( aMatch ));
       
   355 }
       
   356 
       
   357 EXPORT_C void CAHLEInterface::RemoveMatchingL( const TDesC& aMatch,
       
   358                                                TRequestStatus& aStatus )
       
   359 {
       
   360   InitializeAHLEL();
       
   361   iAHLE->RemoveMatchingL( aMatch, aStatus);
       
   362 }
       
   363 
       
   364 
       
   365 // ---------------------------------------------------------
       
   366 // CAHLEInterface::Rename
       
   367 // ---------------------------------------------------------
       
   368 EXPORT_C TInt CAHLEInterface::RenameL( const TDesC& aItem,
       
   369                                        const TDesC& aNewName )
       
   370 {
       
   371   InitializeAHLEL();
       
   372   return (iAHLE->RenameL( aItem, aNewName ));
       
   373 }
       
   374 
       
   375 
       
   376 // ---------------------------------------------------------
       
   377 // CAHLEInterface::GetName
       
   378 // ---------------------------------------------------------
       
   379 //
       
   380 EXPORT_C TInt CAHLEInterface::GetNameL( const TDesC& /* aItem */,
       
   381                                         TDesC& /* aName */ )
       
   382 {
       
   383   return KErrNotSupported;
       
   384 }
       
   385 
       
   386 
       
   387 // ---------------------------------------------------------
       
   388 // CAHLEInterface::Clear
       
   389 // ---------------------------------------------------------
       
   390 EXPORT_C TInt CAHLEInterface::Clear()
       
   391 {
       
   392   //Exception may be thrown but is not expected. Return something
       
   393   //harmless in that case.
       
   394   TRAPD( error, InitializeAHLEL());
       
   395   return (error ? 0 : iAHLE->Clear());
       
   396 }
       
   397 
       
   398 
       
   399 // ---------------------------------------------------------
       
   400 // CAHLEInterface::Flush
       
   401 // ---------------------------------------------------------
       
   402 EXPORT_C TInt CAHLEInterface::Flush()
       
   403 {
       
   404   //Exception may be thrown but is not expected. Return something
       
   405   //harmless in that case.
       
   406   TRAPD( error, InitializeAHLEL());
       
   407   return (error ? 0 : iAHLE->Flush());
       
   408 }
       
   409