/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  AHLE client interface API definition.

 *

*/

// INCLUDE FILES

#include <e32std.h>

#include "AHLEInterface.h"

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

CAHLEInterface* CAHLEInterface::NewL( TAHLENewType aNewType,

                                      const TDesC& aDatabase,

                                      TUint aPrimarySize,

                                      TUint aSecondarySize,

                                      TAHLEScore aAdaptationSpeed )

{

  CAHLEInterface* apiObject = new (ELeave) CAHLEInterface;

  CleanupStack::PushL( apiObject );

  apiObject->ConstructL( aNewType, aDatabase, aPrimarySize, aSecondarySize, aAdaptationSpeed );

  CleanupStack::Pop();

  return apiObject;

}

EXPORT_C CAHLEInterface* CAHLEInterface::NewL( const TDesC& aDatabase,

                                               TUint aPrimarySize,

                                               TUint aSecondarySize,

                                               TAHLEScore aAdaptationSpeed ){

  return NewL( EAHLENewAllArgs, aDatabase, aPrimarySize, aSecondarySize, aAdaptationSpeed );

}

EXPORT_C  CAHLEInterface* CAHLEInterface::NewL( const TDesC& aDatabase ){

  return NewL( EAHLENewDbOnlyArgs, aDatabase, 0, 0, 0);

}

EXPORT_C  CAHLEInterface* CAHLEInterface::NewL(){

  return NewL( EAHLENewNoArgs, KAHLEInterfaceDummyFile, 0, 0, 0);

}

EXPORT_C  CAHLEInterface* CAHLEInterface::NewL( TUint aPrimarySize ){

  return NewL( EAHLENewPrimarySizeOnlyArgs, KAHLEInterfaceDummyFile, aPrimarySize, 0, 0);

}

// -----------------------------------------------------------------------------

// CAHLEInterface::InitializeAHLE

// Creates the AHLE client if needed.

// Throws exception on failure. This is where the AHLE client finally gets created.

// We defer it as long as possible.

// -----------------------------------------------------------------------------

void CAHLEInterface::InitializeAHLEL()

{

  //If already done return quickly.

  if (iAHLE) return;

  TUint aPrimarySize = 0;

  TUint aSecondarySize = 0;

  TAHLEScore aAdaptationSpeed = 0;

  //Fire the correct contructor. It should map to the CAHLEInterface contructor.

  switch (iNewType)

    {

    case EAHLENewNoArgs:

      iAHLE = CAHLE::NewL();

      break;

    case EAHLENewAllArgs:

      iAHLE = CAHLE::NewL( *iDatabase, iPrimarySize, iSecondarySize, iAdaptationSpeed);

      break;

    case EAHLENewDbOnlyArgs:

      iAHLE = CAHLE::NewL( *iDatabase );

      break;

    case EAHLENewPrimarySizeOnlyArgs:

      //The actual value will be added by the initialization later. We

      //can't change the AHLE constructors.

      iDeferPrimarySize = iPrimarySize;

      iAHLE = CAHLE::NewL();

      break;

    default:

      iAHLE = CAHLE::NewL();

    }

  //Do the deferred reconfigure. It was not done earlier, the values

  //were cached for now. Note that the values could have been set in the

  //constructor as well as here. The trick is to keep track of which

  //ones to set here. If the deferred one was set use it. Otherwise use

  //the one just read in with GetConfiguration()

  iAHLE->GetConfigurationL( aPrimarySize, aSecondarySize, aAdaptationSpeed );

  iAHLE->ReconfigureL( iDeferPrimarySize     ? iDeferPrimarySize    : aPrimarySize,

                       iDeferSecondarySize   ? iDeferSecondarySize  : aSecondarySize,

                       iDeferAdaptationSpeed ? iDeferAdaptationSpeed: aAdaptationSpeed );

}

// -----------------------------------------------------------------------------

// Idle Callback Function

// Called when the thread is not busy. The code will be initialized

// now. If it was initialized explicitly bu other code than this call

// won't do very much. In any case this will always return false. It

// doesn't need to run a second time since it will run to completion.

// -----------------------------------------------------------------------------

TInt CAHLEInterface::AHLEInitializationCB(TAny* thisObj)

{

  ((CAHLEInterface*)thisObj)->InitializeAHLEL();

  return EFalse;

}

// -----------------------------------------------------------------------------

// CAHLEInterface::CAHLEInterface

// -----------------------------------------------------------------------------

CAHLEInterface::CAHLEInterface()

{

  iAHLE = NULL;

  iDatabase = NULL;

  iPrimarySize = 0;

  iSecondarySize = 0;

  iAdaptationSpeed = 0;

  iDeferPrimarySize = 0;

  iDeferSecondarySize = 0;

  iDeferAdaptationSpeed = 0;

}

// -----------------------------------------------------------------------------

// CAHLEInterface::~CAHLEInterface

// C++ destructor

// -----------------------------------------------------------------------------

CAHLEInterface::~CAHLEInterface()

{

if(iIdle != NULL)

	{

	iIdle->Cancel();

	}

  delete iIdle;

  delete iAHLE;

  delete iDatabase;

}

// -----------------------------------------------------------------------------

// CAHLEInterface::IsConnected

// Check if the client has been connected to the server. Note that if the actual

// AHLE client has not been created yet we ARE considered connected. Otherwise we

// would need to connect almost immediately.

// -----------------------------------------------------------------------------

EXPORT_C TBool CAHLEInterface::IsConnected()

    {

      return (iAHLE ? iAHLE->IsConnected(): ETrue);

    }

// ---------------------------------------------------------

// CAHLEInterface::ConstructL

// Light weight constructor. Real work is deferred until later.

// An active idle object is created to do the construction when

// things are not busy. If it is done by a task that explicitly

// requires the AHLE client it will not need to run.

// ---------------------------------------------------------

void CAHLEInterface::ConstructL( TAHLENewType aNewType,

                                 const TDesC& aDatabase,

                                 TUint aPrimarySize,

                                 TUint aSecondarySize,

                                 TAHLEScore aAdaptationSpeed )

{

  iAHLE = NULL;

  iPrimarySize = aPrimarySize;

  iSecondarySize = aSecondarySize;

  iAdaptationSpeed = aAdaptationSpeed;

  iDatabase = aDatabase.Alloc();

  iNewType = aNewType;

  iIdle = CIdle::NewL(CActive::EPriorityIdle);

  iIdle->Start(TCallBack(AHLEInitializationCB, this));

}

// -----------------------------------------------------------------------------

// CAHLEInterface::SetObserverL

// -----------------------------------------------------------------------------

EXPORT_C void CAHLEInterface::SetObserverL( const MAHLEClientObserver* aClientObs )

{

  InitializeAHLEL();

  iAHLE->SetObserverL(aClientObs);

}

// ---------------------------------------------------------

// CAHLEInterface::Reconfigure

// ---------------------------------------------------------

EXPORT_C TInt CAHLEInterface::ReconfigureL( TUint aPrimarySize,

                                            TUint aSecondarySize,

                                            TAHLEScore aAdaptationSpeed )

{

  InitializeAHLEL();

  return iAHLE->ReconfigureL(aPrimarySize, aSecondarySize, aAdaptationSpeed );

}

// ---------------------------------------------------------

// CAHLEInterface::GetConfiguration

// ---------------------------------------------------------

EXPORT_C void CAHLEInterface::GetConfigurationL( TUint& aPrimarySize,

                                                 TUint& aSecondarySize,

                                                 TAHLEScore& aAdaptationSpeed )

{

  InitializeAHLEL();

  iAHLE->GetConfigurationL(aPrimarySize, aSecondarySize, aAdaptationSpeed );

}

// ----------------------------------------------------------------

// CAHLEInterface::GetParameters

// ----------------------------------------------------------------

EXPORT_C TInt CAHLEInterface::GetParameters( TAHLESortOrder& /* aOrder */ ) const

{

  return KErrNotSupported;

}

// ----------------------------------------------------------------

// CAHLEInterface::GetParameters

// ----------------------------------------------------------------

EXPORT_C TInt CAHLEInterface::GetParameters( TAHLESortOrder& /* aOrder */,

                                             TAny* /* aReserved */  ) const

{

  return KErrNotSupported;

}

// ----------------------------------------------------------------

// CAHLEInterface::SetParameters

// ----------------------------------------------------------------

EXPORT_C TInt CAHLEInterface::SetParameters( TAHLESortOrder /* aOrder */ )

{

  return KErrNotSupported;

}

EXPORT_C TInt CAHLEInterface::SetParameters( TAHLESortOrder /* aOrder */,

                                             TAny* /* aReserved */ )

{

  return KErrNotSupported;

}

// ---------------------------------------------------------

// CAHLEInterface::NewAccessL

// ---------------------------------------------------------

EXPORT_C TInt CAHLEInterface::NewAccessL( const TDesC& aItem,

                                          const TDesC& aItemName )

{

  InitializeAHLEL();

  return (iAHLE->NewAccessL(aItem, aItemName));

}

EXPORT_C void CAHLEInterface::NewAccessL( TRequestStatus& aStatus,

                                          const TDesC& aItem,

                                          const TDesC& aItemName )

{

  InitializeAHLEL();

  iAHLE->NewAccessL(aStatus, aItem, aItemName);

}

// ----------------------------------------------------------------

// CAHLEInterface::AdaptiveListL

// ----------------------------------------------------------------

EXPORT_C TInt CAHLEInterface::AdaptiveListL( CDesCArray&  aItems,

                                             CDesCArray&  aItemNames,

                                             const TInt  aSize,

                                             const TDesC& aMatch,

                                             const TAHLEState aState )

{

  InitializeAHLEL();

  return (iAHLE->AdaptiveListL( aItems, aItemNames, aSize, aMatch, aState ));

}

// ---------------------------------------------------------

// CAHLEInterface::OrderByScoreL

// ---------------------------------------------------------

//

EXPORT_C TInt CAHLEInterface::OrderByScoreL( CDesCArray& aItems,

                                             CDesCArray& aItemsSorted )

{

  InitializeAHLEL();

  return (iAHLE->OrderByScoreL( aItems, aItemsSorted ));

}

EXPORT_C TInt CAHLEInterface::OrderByScoreL( CDesCArray& /* aItems */,

                                             RArray<TInt>& /* aSortOrder */ )

{

  return KErrNotSupported;

}

// ---------------------------------------------------------

// CAHLEInterface::RemoveL

// ---------------------------------------------------------

EXPORT_C TInt CAHLEInterface::RemoveL( const TDesC& aItem )

{

  InitializeAHLEL();

  return (iAHLE->RemoveL( aItem ));

}

EXPORT_C void CAHLEInterface::RemoveL( const TDesC& aItem,

                                       TRequestStatus& aStatus )

{

  InitializeAHLEL();

  iAHLE->RemoveL( aItem, aStatus );

}

EXPORT_C void CAHLEInterface::RemoveL( const CDesCArray& aItems,

                                       TRequestStatus &aStatus)

{

  InitializeAHLEL();

  iAHLE->RemoveL( aItems, aStatus );

}

EXPORT_C TInt CAHLEInterface::RemoveL(const CDesCArray& aItems )

{

  InitializeAHLEL();

  return (iAHLE->RemoveL( aItems ));

}

// ---------------------------------------------------------

// CAHLEInterface::RemoveMatching

// ---------------------------------------------------------

EXPORT_C TInt CAHLEInterface::RemoveMatchingL( const TDesC& aMatch )

{

  InitializeAHLEL();

  return (iAHLE->RemoveMatchingL( aMatch ));

}

EXPORT_C void CAHLEInterface::RemoveMatchingL( const TDesC& aMatch,

                                               TRequestStatus& aStatus )

{

  InitializeAHLEL();

  iAHLE->RemoveMatchingL( aMatch, aStatus);

}

// ---------------------------------------------------------

// CAHLEInterface::Rename

// ---------------------------------------------------------

EXPORT_C TInt CAHLEInterface::RenameL( const TDesC& aItem,

                                       const TDesC& aNewName )

{

  InitializeAHLEL();

  return (iAHLE->RenameL( aItem, aNewName ));

}

// ---------------------------------------------------------

// CAHLEInterface::GetName

// ---------------------------------------------------------

//

EXPORT_C TInt CAHLEInterface::GetNameL( const TDesC& /* aItem */,

                                        TDesC& /* aName */ )

{

  return KErrNotSupported;

}

// ---------------------------------------------------------

// CAHLEInterface::Clear

// ---------------------------------------------------------

EXPORT_C TInt CAHLEInterface::Clear()

{

  //Exception may be thrown but is not expected. Return something

  //harmless in that case.

  TRAPD( error, InitializeAHLEL());

  return (error ? 0 : iAHLE->Clear());

}

// ---------------------------------------------------------

// CAHLEInterface::Flush

// ---------------------------------------------------------

EXPORT_C TInt CAHLEInterface::Flush()

{

  //Exception may be thrown but is not expected. Return something

  //harmless in that case.

  TRAPD( error, InitializeAHLEL());

  return (error ? 0 : iAHLE->Flush());

}