/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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:
* Implements interface for Blid event
*
*/
// INCLUDE FILES
#include <sysutil.h>
#include <f32file.h>
#include <EPos_CPosLandmark.h>
#include <driveinfo.h>
#include "CBlidEng.h"
#include "BlidModelFactory.h"
#include "DllMain.h" // panic codes
#include "MBlidSettings.h" // MBlidSettings
#include "MBlidLocation.h" //MBlidLocation
#include "MBlidRouter.h" //MBlidRouter
#include "lbsposition.h"
#include "TNamedCoordinate.h"
#include "blidengconsts.h"
// ============================ MEMBER FUNCTIONS ==============================
// ----------------------------------------------------------------------------
// CBlidEng::NewL
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
EXPORT_C CBlidEng* CBlidEng::NewL()
{
CBlidEng* self = new( ELeave ) CBlidEng;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop(self); // self
return self;
}
// ---------------------------------------------------------
// CBlidEng::ConstructL
// ---------------------------------------------------------
//
void CBlidEng::ConstructL()
{
User::LeaveIfError(iServer.Connect());
CreateModelL( EBlidSettings );
CreateModelL( EBlidRouter );
iAppMode = EAppForeground;
iHWRMLight = CHWRMLight::NewL();
}
// ----------------------------------------------------------------------------
// CBlidEng::CBlidEng
// C++ default constructor can NOT contain any code, that
// might leave.
// ----------------------------------------------------------------------------
//
CBlidEng::CBlidEng()
{
}
// ---------------------------------------------------------
// CBlidEng::~CBlidEng
// ---------------------------------------------------------
//
CBlidEng::~CBlidEng()
{
delete iSettings;
delete iLocation;
delete iRouter;
delete iHWRMLight;
iServer.Close();
}
// ---------------------------------------------------------
// CBlidEng::StoreL
// ---------------------------------------------------------
//
EXPORT_C TStreamId CBlidEng::StoreL( CStreamStore& aStore,
CStreamStore& aRestore )
{
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL( fs );
if ( SysUtil::DiskSpaceBelowCriticalLevelL( &fs, 0, DriveInfo::EDefaultPhoneMemory ) )
{
const_cast<CBlidEng*>(this)->RestoreL( aRestore, iStreamId );
User::Leave( KErrDiskFull );
}
CleanupStack::PopAndDestroy(); // fs
RStoreWriteStream stream;
iStreamId = stream.CreateLC( aStore );
ExternalizeL( stream );
stream.CommitL();
CleanupStack::PopAndDestroy(); //stream
return iStreamId;
}
// ---------------------------------------------------------
// CBlidEng::RestoreL
// ---------------------------------------------------------
//
EXPORT_C void CBlidEng::RestoreL( const CStreamStore& aStore,
TStreamId aStreamId )
{
iStreamId = aStreamId;
RStoreReadStream stream;
stream.OpenLC(aStore,iStreamId);
InternalizeL(stream);
CleanupStack::PopAndDestroy(); //stream
}
// ----------------------------------------------------------------------------
// CBlidEng::SettingsModel()
// Settings model getter.
// ----------------------------------------------------------------------------
//
EXPORT_C MBlidSettings* CBlidEng::SettingsModel() const
{
return iSettings;
}
// ----------------------------------------------------------------------------
// CBlidEng::LocationModel()
// Location model getter.
// ----------------------------------------------------------------------------
//
EXPORT_C MBlidLocation* CBlidEng::LocationModel() const
{
return iLocation;
}
// ----------------------------------------------------------------------------
// CBlidEng::RouterModel()
// Router model getter.
// ----------------------------------------------------------------------------
//
EXPORT_C MBlidRouter* CBlidEng::RouterModel() const
{
return iRouter;
}
// ----------------------------------------------------------------------------
// CBlidEng::CreateModelL()
// Creates a given model type.
// ----------------------------------------------------------------------------
//
EXPORT_C void CBlidEng::CreateModelL( TBlidModelType aModel )
{
switch( aModel )
{
case EBlidSettings:
{
if ( !iSettings )
{
iSettings = BlidModelFactory::SettingsL();
}
break;
}
case EBlidLocation:
{
if ( !iLocation )
{
iLocation = BlidModelFactory::LocationL(iServer, *this);
}
break;
}
case EBlidRouter:
{
if ( !iRouter )
{
iRouter = BlidModelFactory::RouterL();
}
break;
}
default:
{
// Not supported model type
__ASSERT_DEBUG(EFalse, BlidEngPanic(ELCEModelTypeNotSupported));
break;
}
}
}
// ---------------------------------------------------------
// CBlidEng::GetDistanceToDestination
// ---------------------------------------------------------
//
EXPORT_C TInt CBlidEng::GetDistanceToDestination(TReal32& aDistance)
{
if(iRouter->IsAnyPointSet())
{
TInt retVal;
TPosition& currentPosition = iLocation->GetCurrentPosition();
if(iRouter->IsWaypointSet())
{
TNamedCoordinate* destination = iRouter->Waypoint();
retVal = destination->Distance(currentPosition, aDistance);
}
else
{
CPosLandmark* landmark = iRouter->Landmark();
TPosition destination;
landmark->GetPosition(destination);
retVal = currentPosition.Distance(destination, aDistance);
}
return retVal;
}
else
{
return KErrNotFound;
}
}
// ---------------------------------------------------------
// CBlidEng::HasArrivedToDestination
// ---------------------------------------------------------
//
EXPORT_C TBool CBlidEng::HasArrivedToDestination()
{
if(iRouter->IsAnyPointSet())
{
TPosition& currentPosition = iLocation->GetCurrentPosition();
TReal32 distanceToDestination(0);
if(iRouter->IsWaypointSet())
{
TNamedCoordinate* destination = iRouter->Waypoint();
if(destination->Distance(currentPosition, distanceToDestination) != KErrNone)
{
return EFalse;
}
}
else
{
TPosition destination;
CPosLandmark* landmark = iRouter->Landmark();
landmark->GetPosition(destination);
if(currentPosition.Distance(destination, distanceToDestination) != KErrNone)
{
return EFalse;
}
}
if(distanceToDestination <= KMinArrivalDist)
{
iSettings->SetArrivedDistance( KMinArrivalDist );
return ETrue;
}
TReal tempHorizontalAccuracy = currentPosition.HorizontalAccuracy();
if(tempHorizontalAccuracy > KMaxHorAccLimit)
{
tempHorizontalAccuracy = KMaxHorAccLimit;
}
if(distanceToDestination <= tempHorizontalAccuracy)
{
iSettings->SetArrivedDistance( tempHorizontalAccuracy );
return ETrue;
}
}
return EFalse;
}
// ----------------------------------------------------------------------------
// CBlidEng::SetAppMode
// ----------------------------------------------------------------------------
//
EXPORT_C void CBlidEng::SetAppMode(TAppMode aMode)
{
iAppMode = aMode;
}
// ----------------------------------------------------------------------------
// CBlidEng::SetBackLightStateL
// It's allocate the Backlight resource for the client and deallocate also depends
// Upon the choise of backlight option from the settings view
// ----------------------------------------------------------------------------
//
EXPORT_C void CBlidEng::SetBackLightStateL(TBacklightState aState)
{
if(aState == EBlidBacklightAlwaysOn)
{
TRAPD( error, iHWRMLight->ReserveLightL(CHWRMLight::EPrimaryDisplay, EFalse, EFalse);
iHWRMLight->LightOnL(CHWRMLight::EPrimaryDisplay); );
if( error != KErrNone )
{
// do something if necessary.
}
}
else
{
iHWRMLight->ReleaseLight(CHWRMLight::EPrimaryDisplay);
}
}
// ---------------------------------------------------------
// CBlidEng::ExternalizeL
// ---------------------------------------------------------
//
void CBlidEng::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteInt32L( KBlidDocVersion1 );
iRouter->ExternalizeL( aStream );
}
// ---------------------------------------------------------
// CBlidEng::InternalizeL
// ---------------------------------------------------------
//
void CBlidEng::InternalizeL( RReadStream& aStream )
{
switch( aStream.ReadInt32L() )
{
case KBlidDocVersion1:
{
InternalizeV1L( aStream );
break;
}
default:
{
User::Leave( KErrNotSupported );
break;
}
}
}
// ---------------------------------------------------------
// CBlidEng::InternalizeLV1
// ---------------------------------------------------------
//
void CBlidEng::InternalizeV1L( RReadStream& aStream )
{
if ( iRouter->Count() )
{
iRouter->ResetAndDestroy();
}
iRouter->InternalizeV1L( aStream );
}
// ----------------------------------------------------------------------------
// CBlidEng::AppMode
// ----------------------------------------------------------------------------
//
EXPORT_C CBlidEng::TAppMode CBlidEng::AppMode()
{
return iAppMode;
}
// End of File