/*
* 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: Provides OwnPosView's details.
*
*/
// INCLUDE FILES
#include <StringLoader.h>
#include <AknUtils.h>
#include <blid.rsg>
#include <aknlocationed.h>
#include "CBlidOwnPosLBModel.h"
#include "CBlidBaseContainer.h"
#include "MBlidLocation.h"
#include "MBlidSettings.h"
#include "bliduiconsts.h"
#include "Blid.hrh"
#include "Blidutils.h"
#include "lbscommon.h"
//CONSTANTS
// ================= MEMBER FUNCTIONS =======================
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::NewLC
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CBlidOwnPosLBModel* CBlidOwnPosLBModel::NewLC( MBlidLocation* aLocationModel,
MBlidSettings* aSettings )
{
CBlidOwnPosLBModel* ptr =
new (ELeave) CBlidOwnPosLBModel( aLocationModel, aSettings );
CleanupStack::PushL(ptr);
ptr->ConstructL();
return ptr;
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::CBlidOwnPosLBModel
// C++ default constructor can NOT contain any code, that
// might leave.
// ----------------------------------------------------------------------------
//
CBlidOwnPosLBModel::CBlidOwnPosLBModel(MBlidLocation* aLocationModel,
MBlidSettings* aSettings ):
iLocationModel( aLocationModel ), iSettingsModel( aSettings )
{
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::ConstructL
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CBlidOwnPosLBModel::ConstructL()
{
CEikonEnv* env = CEikonEnv::Static();
iBuffer = HBufC::NewL( KBlidLBLineMaxLen );
iLocale = new(ELeave)TLocale();
/// titles
iBlidLatitude = StringLoader::LoadL( R_BLID_POSITION_LATITUDE, env);
iBlidLongitude = StringLoader::LoadL( R_BLID_POSITION_LONGITUDE, env);
iBlidAccuracy = StringLoader::LoadL( R_BLID_POSITION_ACCURACY, env);
iBlidAltAccuracy = StringLoader::LoadL( R_BLID_POSITION_ALTITUDE_ACCURACY, env);
//iBlidSpeed = StringLoader::LoadL( R_BLID_POSITION_SPEED, env);
iBlidAltitude = StringLoader::LoadL( R_BLID_POSITION_ALTITUDE, env);
iAccuraryFormatM = env->AllocReadResourceL( R_BLID_METRIC_METER );
iAccuraryFormatFt = env->AllocReadResourceL( R_BLID_IMPERIAL_FOOT);
iSpeedFormatKmph = env->AllocReadResourceL( R_BLID_METRIC_SPEED );
iSpeedFormatMph = env->AllocReadResourceL( R_BLID_IMPERIAL_SPEED );
iAltitudeFormatM = env->AllocReadResourceL( R_BLID_METRIC_METER );
iAltitudeFormatFt = env->AllocReadResourceL( R_BLID_IMPERIAL_FOOT );
iDataBeingCalculated = StringLoader::LoadL( R_BLID_CALCULATING_LIST, env);
iConnectGPS = StringLoader::LoadL( R_BLID_CONNECT_GPS_LIST, env);
iNotAvailable = env->AllocReadResourceL( R_BLID_NOT_AVAILABLE );
iDataBlank = StringLoader::LoadL( R_BLID_BLANK, env);
iWaitingGpsData = StringLoader::LoadL( R_BLID_WAITING_GPS_LIST, env);
}
// ---------------------------------------------------------
// CBlidOwnPosLBModel::~CBlidOwnPosLBModel
// ---------------------------------------------------------
//
CBlidOwnPosLBModel::~CBlidOwnPosLBModel()
{
delete iLocale;
delete iBlidLatitude;
delete iBlidLongitude;
delete iBlidAltitude;
delete iBlidAltAccuracy;
//delete iBlidSpeed;
delete iBlidAccuracy;
delete iBuffer;
delete iAccuraryFormatM;
delete iAccuraryFormatFt;
delete iSpeedFormatKmph;
delete iSpeedFormatMph;
delete iAltitudeFormatM;
delete iAltitudeFormatFt;
delete iDataBeingCalculated;
delete iConnectGPS;
delete iNotAvailable;
delete iDataBlank;
delete iWaitingGpsData;
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::MdcaCount
// ----------------------------------------------------------------------------
//
TInt CBlidOwnPosLBModel::MdcaCount() const
{
return 5;
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::MdcaPoint
// ----------------------------------------------------------------------------
//
TPtrC16 CBlidOwnPosLBModel::MdcaPoint(TInt aIndex) const
{
TPtr ptr( iBuffer->Des() );
ptr.Zero();
const TPosition position = iLocationModel->GetCurrentPosition();
const TCourse course = iLocationModel->GetCourse();
switch ( aIndex )
{
case ELocLatitudeItemId:
{
TBuf<KBlidLBItemMaxLen> latitudeString;
LatitudeFormat( latitudeString, position );
ptr.Append( *iBlidLatitude );
ptr.Append( EKeyTab );
ptr.Append( latitudeString );
break;
}
case ELocLongitudeItemId:
{
TBuf<KBlidLBItemMaxLen> longitudeString;
LongitudeFormat( longitudeString, position );
ptr.Append( *iBlidLongitude );
ptr.Append( EKeyTab );
ptr.Append( longitudeString );
break;
}
case ELocAccuracyItemId:
{
TBuf<KBlidLBItemMaxLen> accuracyString;
AccuracyFormat( accuracyString, position );
ptr.Append( *iBlidAccuracy );
ptr.Append( EKeyTab );
ptr.Append( accuracyString );
break;
}
case ELocAltAccuracyItemId:
{
TBuf<KBlidLBItemMaxLen> altAccuracyString;
altAccuracyFormat( altAccuracyString );
ptr.Append( *iBlidAltAccuracy );
ptr.Append( EKeyTab );
ptr.Append( altAccuracyString );
break;
}
case ELocAltitudeItemId:
{
TBuf<KBlidLBItemMaxLen> altitudeString;
AltitudeFormat( altitudeString, position );
ptr.Append( *iBlidAltitude );
ptr.Append( EKeyTab );
ptr.Append( altitudeString );
break;
}
default:
{
break;
}
} //switch
AknTextUtils::LanguageSpecificNumberConversion( ptr );
return iBuffer->Des();
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::LatitudeFormat
// ----------------------------------------------------------------------------
//
void CBlidOwnPosLBModel::LatitudeFormat( TDes& aLatitudeString,
TPosition aPosition ) const
{
TReal latitude = aPosition.Latitude();
if(!CBlidBaseContainer::IsGPSAvailable() ||
!iLocationModel->IsGPSDataAvailable() )
{
if(iLocationModel->WaitingGPSData())
{
aLatitudeString = *iWaitingGpsData;
}
else
{
aLatitudeString = *iConnectGPS;
}
}
else if ( !Math::IsNaN(latitude) )
{
HBufC* formatter = NULL;
TRAP_IGNORE(formatter =
CAknLocationEditor::DisplayableLocationL(aPosition,CAknLocationEditor::ELatitudeOnly));
if(formatter)
{
aLatitudeString.Copy(formatter->Des());
delete formatter;
}
formatter = NULL;
}
else
{
aLatitudeString = *iDataBeingCalculated;
}
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::LongitudeFormat
// ----------------------------------------------------------------------------
//
void CBlidOwnPosLBModel::LongitudeFormat( TDes& aLongitudeString,
TPosition aPosition ) const
{
TReal longitude = aPosition.Longitude();
if(!CBlidBaseContainer::IsGPSAvailable() ||
!iLocationModel->IsGPSDataAvailable() )
{
aLongitudeString = *iDataBlank;
}
else if ( !Math::IsNaN(longitude) )
{
HBufC* formatter = NULL;
TRAP_IGNORE(formatter =
CAknLocationEditor::DisplayableLocationL(aPosition,CAknLocationEditor::ELongitudeOnly));
if(formatter)
{
aLongitudeString.Copy(formatter->Des());
delete formatter;
}
formatter = NULL;
}
else
{
aLongitudeString = *iDataBeingCalculated;
}
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::AccuracyFormat
// ----------------------------------------------------------------------------
//
void CBlidOwnPosLBModel::AccuracyFormat( TDes& aAccuracyString,
TPosition aPosition ) const
{
TReal accuracy = aPosition.HorizontalAccuracy();
TInt result(0);
if(!CBlidBaseContainer::IsGPSAvailable() ||
!iLocationModel->IsGPSDataAvailable() )
{
aAccuracyString = *iDataBlank;
}
else if ( !Math::IsNaN(accuracy) &&
BlidUtils::TRealToTInt( accuracy, result) == KErrNone )
{
if ( iSettingsModel->UnitOfMeasurement() == EUnitsMetric )
{
StringLoader::Format( aAccuracyString, *iAccuraryFormatM,
0, result );
}
else
{
if ( BlidUtils::TRealToTInt((accuracy*KMetreToFoot),
result) != KErrNone )
{
aAccuracyString = *iDataBlank;
}
else
{
StringLoader::Format( aAccuracyString, *iAccuraryFormatFt,
0, result );
}
}
}
else
{
aAccuracyString = *iDataBeingCalculated;
}
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::altAccuracyFormat
// ----------------------------------------------------------------------------
//
void CBlidOwnPosLBModel::altAccuracyFormat( TDes& aAltAccuracyString ) const
{
const TPosition position = iLocationModel->GetCurrentPosition();
const TReal32 altAccuracy = position.VerticalAccuracy();
TInt result(0);
TBuf<KBlidLBItemMaxLen> altitudeAccString;
AltitudeFormat(altitudeAccString, iLocationModel->GetCurrentPosition());
if(!CBlidBaseContainer::IsGPSAvailable() ||
!iLocationModel->IsGPSDataAvailable() ||
altitudeAccString == *iDataBlank)
{
aAltAccuracyString = *iDataBlank;
}
else if ( !Math::IsNaN(altAccuracy) &&
BlidUtils::TRealToTInt( altAccuracy, result) == KErrNone )
{
if ( iSettingsModel->UnitOfMeasurement() == EUnitsMetric )
{
StringLoader::Format( aAltAccuracyString, *iAccuraryFormatM,
0, result );
}
else
{
if ( BlidUtils::TRealToTInt((altAccuracy*KMetreToFoot),
result) != KErrNone )
{
aAltAccuracyString = *iDataBlank;
}
else
{
StringLoader::Format( aAltAccuracyString, *iAccuraryFormatFt,
0, result );
}
}
}
else
{
aAltAccuracyString = *iDataBeingCalculated;
}
}
// ----------------------------------------------------------------------------
// CBlidOwnPosLBModel::AltitudeFormat
// ----------------------------------------------------------------------------
//
void CBlidOwnPosLBModel::AltitudeFormat( TDes& aAltitudeString,
TPosition aPosition ) const
{
TReal altitude = aPosition.Altitude();
TInt result(0);
if(!CBlidBaseContainer::IsGPSAvailable() ||
!iLocationModel->IsGPSDataAvailable() )
{
aAltitudeString = *iDataBlank;
}
else if ( !Math::IsNaN(altitude) &&
BlidUtils::TRealToTInt((altitude - iSettingsModel->AltCalibration()),
result) == KErrNone )
{
if ( iSettingsModel->UnitOfMeasurement() == EUnitsMetric )
{
StringLoader::Format( aAltitudeString, *iAltitudeFormatM,
0, result );
}
else
{
TInt imperialAlt(0);
if ( BlidUtils::TRealToTInt((result*KMetreToFoot),
imperialAlt) != KErrNone )
{
aAltitudeString = *iDataBlank;
}
else
{
StringLoader::Format( aAltitudeString, *iAltitudeFormatFt,
0, imperialAlt );
}
}
}
else
{
aAltitudeString = *iDataBlank;
}
}
// End of File