FCL/sf/mw/mds: comparison locationmanager/locationtrail/src/clocationrecord.cpp

equal deleted inserted replaced

-:aa5a574040a4
+:a3cc46f37772
 #include <lbserrors.h>
 #include <lbssatellite.h>
 #include <ecom.h>
 #include <centralrepository.h>
 #include <hwrmpowerstatesdkpskeys.h>
+#ifdef LOC_GEOTAGGING_CELLID
+#include <lbslocationinfo.h>
+#endif //LOC_GEOTAGGING_CELLID
 #include "rlocationtrail.h"
 #include "clocationrecord.h"
 #include "cnetworkinfo.h"
 #include "locationmanagerdebug.h"
 #include "locationtraildefs.h"
 #include "locationtrailpskeys.h"
 #include "mdeconstants.h"
-#ifdef LOC_REVERSEGEOCODE
-#include "reversegeocoderplugin.h"
-const TUid KReverseGeoCodeUid = {0x2002DD12};
-#endif
 using namespace MdeConstants;
 const TUint KNetQueryBit = 1; // 1 bit
 #ifdef LOC_REVERSEGEOCODE
 ,iConnectionOption(ESilent)
 	,iImageQuery(NULL)
 	,iTagQuery(NULL)
 ,iTagCreator( NULL )
+,iLastReverseGeocodeFails(EFalse)
 	,iRevGeocoderPlugin( NULL )
 #endif
 {
 iMaxTrailSize = KMaxTrailLength / KUpdateInterval;
 }
 iNetworkInfoTimer = CPeriodic::NewL( CActive::EPriorityStandard );
 #ifdef LOC_REVERSEGEOCODE
 iTagCreator = CTagCreator::NewL();
+	  TInt pluginerr = KErrNone;
-if (!iRevGeocoderPlugin)
+TRAP(pluginerr,iRevGeocoderPlugin = CReverseGeoCoderPlugin::NewL());
-{
-iRevGeocoderPlugin = reinterpret_cast<CReverseGeoCoderPlugin*>(
+if(pluginerr == KErrNone)
-REComSession::CreateImplementationL(KReverseGeoCodeUid,iDtorKey));
+	{
-if(iRevGeocoderPlugin)
+		iRevGeocoderPlugin->AddObserverL(*this);
-{
+	 	}
-iRevGeocoderPlugin->AddObserverL(*this);
-}
-}
 #endif
 TInt interval( 0 );
 TRAP(err, ReadCenRepValueL(KIntervalKey, interval));
 #ifdef LOC_REVERSEGEOCODE
 iLocationItems.ResetAndDestroy();
 iLocationItems.Close();
 #endif
 delete iNetworkInfoChangeListener;
+iNetworkInfoChangeListener = NULL;
 delete iPositionInfo;
+iPositionInfo = NULL;
 delete iNetworkInfoTimer;
+iNetworkInfoTimer = NULL;
 #ifdef LOC_GEOTAGGING_CELLID
 if(iGeoConverter)
 {
 delete iGeoConverter;
 iGeoConverter = NULL;
 #endif
 if (iRemapper)
 		{
 		iRemapper->StopRemapping();
 		delete iRemapper;
+		iRemapper = NULL;
 		}
 if(iLocationQuery)
 		{
 		iLocationQuery->RemoveObserver(*this);
 		iLocationQuery->Cancel();
 		}
 	delete iTagCreator;
 	// set the pointer to NULL, ECOM will destroy object.
 delete iRevGeocoderPlugin;
 iRevGeocoderPlugin = NULL;
-REComSession::DestroyedImplementation(iDtorKey);
 #endif
 LOG( "CLocationRecord::~CLocationRecord(), end" );
 }
 // --------------------------------------------------------------------------
 _LIT( KDateTimeFormat, "%Y/%M/%D %H:%T:%S" );
 const TInt DateTimeStrMaxLength = 20;
 LOG1( "CLocationRecord::GetLocationByTimeL - aTime: %Ld", aTime.Int64() );
 TBuf<DateTimeStrMaxLength> str1;
 aTime.FormatL( str1, KDateTimeFormat );
-// LOG1( "CLocationRecord::GetLocationByTimeL - aTime: %S", &str1 );
+LOG1( "CLocationRecord::GetLocationByTimeL - aTime: %S", &str1 );
 #endif
 TTimeIntervalSeconds interval;
 TTimeIntervalSeconds nextInterval;
 for ( TInt i(iTrail.Count()-1) ; i >= 0 && !posFound ; i-- )
 #ifdef _DEBUG
 LOG1( "CLocationRecord::GetLocationByTimeL - Trail timestamp: %Ld", iTrail[i]->iTimeStamp.Int64() );
 TBuf<DateTimeStrMaxLength> str;
 iTrail[i]->iTimeStamp.FormatL( str, KDateTimeFormat );
-//LOG1( "CLocationRecord::GetLocationByTimeL - Trail timestamp: %S", &str );
+LOG1( "CLocationRecord::GetLocationByTimeL - Trail timestamp: %S", &str );
 LOG1( "CLocationRecord::GetLocationByTimeL - timeDiff: %d", timeDiff );
 #endif
 if ( err == KErrNone && timeDiff <= KMaximumIntervalSeconds )
 {
 iGpsDataAvailableFlag = EFalse;
 if ( !iTrailStarted || iState == RLocationTrail::ETrailStopped)
 {
-	LOG("trail not started/stopped");
+	LOG("CLocationRecord::Position(), trail not started/stopped");
 iPositionInfo->Stop();
 return;
 }
 // all cases store the location..
 StoreLocation( positionSatelliteInfo );
 {
 case KPositionPartialUpdate: // fall through
 case KPositionQualityLoss:
 {
 // Location is stored, even if it may not be valid.
-LOG("Partial update");
+LOG("CLocationRecord::Position(), Partial update");
 if ( iState != RLocationTrail::EWaitingGPSData &&
 	 iState != RLocationTrail::ETrailStopping )
 {
 SetCurrentState( RLocationTrail::EWaitingGPSData );
-	LOG("Trail waiting for gps");
+	LOG("CLocationRecord::Position(), Trail waiting for gps");
 }
 break;
 }
 case KErrNone:
 {
-LOG("Good GPS coordinates");
+LOG("CLocationRecord::Position(), Good GPS coordinates");
 iGpsDataAvailableFlag = ETrue;
 if ( iState != RLocationTrail::ETrailStarted )
 {
 if ( iRemapper )
 	{
-	LOG("Start remapping");
+	LOG("CLocationRecord::Position(), Start remapping");
 		iRemapper->StartRemappingObjects( iNewItem.iLocationData );
 if( iObserver->WaitForPositioningStopTimeout() && !RemappingNeeded() )
 		    {
 iObserver->RemapedCompleted();
 }
 break;
 }
 default:
 {
-LOG1("Searching GPS, aError %d", aError );
+LOG1("CLocationRecord::Position(), Searching GPS, aError %d", aError );
 if ( iState != RLocationTrail::ESearchingGPS &&
 	 iState != RLocationTrail::ETrailStopping )
 {
 SetCurrentState( RLocationTrail::ESearchingGPS );
 	LOG("Trail searching gps");
 }
 break;
 }
 }
 TBool fixState = CheckGPSFix( positionSatelliteInfo );
-LOG1( "fixState %d", fixState );
+LOG1( "CLocationRecord::Position(), fixState %d", fixState );
-LOG1( "iLastGPSFixState %d", iLastGPSFixState );
+LOG1( "CLocationRecord::Position(), iLastGPSFixState %d", iLastGPSFixState );
 if ( iObserver && iLastGPSFixState != fixState )
 	{
-	LOG("Quality changed");
+	LOG("CLocationRecord::Position(), Quality changed");
 	iObserver->GPSSignalQualityChanged( positionSatelliteInfo );
 	}
 	iLastGPSFixState = fixState;
 iNetwork = aNetworkInfo;
 if (iNetwork.iAccess == CTelephony::ENetworkAccessUtran)
 	{
 	iNetwork.iLocationAreaCode = 0;
 	}
+#ifdef LOC_GEOTAGGING_CELLID
 if ( iState == RLocationTrail::ETrailStarting && iTrailStarted )
 	{
 	SetCurrentState( RLocationTrail::ETrailStarted );
 	}
+#endif
 }
 else
 {
 LOG1("CLocationRecord::NetworkInfo - %d", aError );
 iNetwork = CTelephony::TNetworkInfoV1();
 LOG1( "CLocationRecord::SetCurrentState(), begin, state:%d", aState );
 iState = aState;
 if( iTrailStarted )
 {
 // Set the property only when trail is started to avoid icon flickering and wrong icon update in UI
-if( iGpsDataAvailableFlag  ||
+if( iGpsDataAvailableFlag
-iNetwork.iCellId > 0 &&
+#ifdef LOC_GEOTAGGING_CELLID
+|| ( iNetwork.iCellId > 0 &&
 ((iNetwork.iLocationAreaCode == 0 && iNetwork.iAccess == CTelephony::ENetworkAccessUtran) || // 3G
 (iNetwork.iLocationAreaCode > 0 && (iNetwork.iAccess == CTelephony::ENetworkAccessGsm ||  // 2G
 						iNetwork.iAccess == CTelephony::ENetworkAccessGsmCompact)))  &&
 iNetwork.iCountryCode.Length() > 0 &&
 iNetwork.iNetworkId.Length() > 0 )
+#endif // LOC_GEOTAGGING_CELLID
+)
 {
 // set the value 3 to have Geo tag available icon else not available.
 iProperty.Set( KPSUidLocationTrail, KLocationTrailState,
 (TInt) RLocationTrail::ETrailStarted );
 }
 net->iCountryCode.Length() == 0 &&
 net->iNetworkId.Length() == 0 )
 {
 // no n/w info... put it into remap.
 // remove the last appended element.
-LOG("No network info (offline mode + no GPS fix), keep for remapping");
+LOG("CLocationRecord::LocationSnapshotL(), No network info (offline mode + no GPS fix), keep for remapping");
 			TRemapItem remapItem;
 			remapItem.iObjectId = aObjectId;
 			remapItem.iTime = timestamp;
 			iRemapper->Append( remapItem );
 			TLocationSnapshotItem* firstPtr = iMediaItems[iMediaItems.Count() - 1];
 			iMediaItems.Remove(iMediaItems.Count() - 1);
 			iMediaItems.Compress();
-			delete firstPtr;
+if( firstPtr == newItem)
+{
+newItem = NULL;
+}
+delete firstPtr;
+firstPtr = NULL;
 }
 else
 {
 // n/w info available
 NetworkInfoSnapshotL();
 }
 		}
 	else if ( Math::IsNaN( locationData.iPosition.Latitude() ) &&
 			Math::IsNaN( locationData.iPosition.Longitude() ))
 		{
+LOG("CLocationRecord::LocationSnapshotL(), coordinates empty with or without cellular info")
 	    // coordinates empty, with or without cellular info
 		if ( net->iCellId == 0 &&
 				net->iLocationAreaCode == 0 &&
 				net->iCountryCode.Length() == 0 &&
 				net->iNetworkId.Length() == 0 )
 			{
-LOG("No network info (offline mode + no GPS fix), keep for remapping");
+LOG("CLocationRecord::LocationSnapshotL(), No network info (offline mode + no GPS fix), keep for remapping");
 			TRemapItem remapItem;
 			remapItem.iObjectId = aObjectId;
 			remapItem.iTime = timestamp;
 			iRemapper->Append( remapItem );
 			TLocationSnapshotItem* firstPtr = iMediaItems[iMediaItems.Count() - 1];
 			iMediaItems.Remove(iMediaItems.Count() - 1);
 			iMediaItems.Compress();
-			delete firstPtr;
+if( firstPtr == newItem)
+{
+newItem = NULL;
+}
+delete firstPtr;
+firstPtr = NULL;
 			}
 		// check match for last created locationobject
 #ifdef LOC_REVERSEGEOCODE
 		else if ( (iLastMediaItem.iFlag & KSnapMediaFile) > 0 &&
 iLastMediaItem.iCountryTagId > 0)
 #else
 else if ( (iLastMediaItem.iFlag & KSnapMediaFile) > 0)
 #endif //LOC_REVERSEGEOCODE
 			{
+LOG("CLocationRecord::LocationSnapshotL(), last created locationobject match" );
 			TLocationData lastLocationData = iLastMediaItem.iLocationData;
 			CTelephony::TNetworkInfoV1* lastnet = &lastLocationData.iNetworkInfo;
 			// networkinfo changed from last location
 			if ( lastnet->iCellId == net->iCellId &&
 #endif //LOC_REVERSEGEOCODE
 // remove the current item.
 				TLocationSnapshotItem* firstPtr = iMediaItems[iMediaItems.Count() - 1];
 				iMediaItems.Remove(iMediaItems.Count() - 1);
 				iMediaItems.Compress();
-				delete firstPtr;
+	            if( firstPtr == newItem)
+	                {
+	                newItem = NULL;
+	                }
+	            delete firstPtr;
+	            firstPtr = NULL;
 				}
 			}
-		if ( !previousMatch )
+if (  newItem && !previousMatch )
 		    {
 			// go for n/w based
 newItem->iFlag |= KNetQueryBit;
 		    }
 		}
 	// valid coordinates found
 	else if ( lastLocationId != 0 &&
 ((iLastMediaItem.iFlag & KSnapMediaFile) > 0))
 		{
+LOG("CLocationRecord::LocationSnapshotL(), valid coordinates found");
 TLocationData lastLocationData = iLastMediaItem.iLocationData;
 		CTelephony::TNetworkInfoV1* lastnet = &lastLocationData.iNetworkInfo;
 		// first check if networkinfo matches last created location
 		if ( lastnet->iCellId == net->iCellId &&
 				lastnet->iCountryCode == net->iCountryCode &&
 				lastnet->iNetworkId == net->iNetworkId )
 			{
 			// if both locations have valid coordinates, calculate distance between points
-			if ( !Math::IsNaN( lastLocationData.iPosition.Latitude() ) &&
+			if (
+#ifdef LOC_REVERSEGEOCODE
+!iLastReverseGeocodeFails &&
+#endif //LOC_REVERSEGEOCODE
+!Math::IsNaN( lastLocationData.iPosition.Latitude() ) &&
 					!Math::IsNaN( lastLocationData.iPosition.Longitude() ) &&
 					!Math::IsNaN( locationData.iPosition.Latitude() ) &&
 					!Math::IsNaN( locationData.iPosition.Longitude() ))
 				{
 				TReal32 distance;
 				TInt err = locationData.iPosition.Distance(lastLocationData.iPosition, distance);
 				if ( distance < iLocationDelta )
 					{
-					LOG("location close to the previous one");
+					LOG("CLocationRecord::LocationSnapshotL(), location close to the previous one");
 					previousMatch = ETrue;
 					CreateRelationL( aObjectId, lastLocationId );
 #ifdef LOC_REVERSEGEOCODE
 					// attach same tags associated to last location
 					    iTagCreator->AttachTagsL(
 					          aObjectId, iLastMediaItem.iCountryTagId, iLastMediaItem.iCityTagId );
 TLocationSnapshotItem* firstPtr = iMediaItems[iMediaItems.Count() - 1];
 iMediaItems.Remove(iMediaItems.Count() - 1);
 iMediaItems.Compress();
-delete firstPtr;
+if( firstPtr == newItem)
+{
+newItem = NULL;
+}
+delete firstPtr;
+firstPtr = NULL;
 					    }
-					else
+					//check newItem for validity
+					else if (newItem)
 					    {
 					    // country tag not found.. go for reverse geocoding..
 					    newItem->iLocationId = lastLocationId;
 					    iLocationItems.Append( newItem );
 						iMediaItems.Remove(iMediaItems.Count() - 1);
 #else
 // remove from the queue
 TLocationSnapshotItem* firstPtr = iMediaItems[iMediaItems.Count() - 1];
 iMediaItems.Remove(iMediaItems.Count() - 1);
 iMediaItems.Compress();
-delete firstPtr;
+if( firstPtr == newItem)
+{
+newItem = NULL;
+}
+delete firstPtr;
+firstPtr = NULL;
 #endif //LOC_REVERSEGEOCODE
 					}
 				}
 			}
 LOG( "CLocationRecord::FindLocationFromDBL(), begin" );
 if(((iMediaHandlingFlag & KLocationQueryInProgress)> 0)
 	     || (iMediaItems.Count() <= 0))
 {
 		// query is in progress or queue is empty
-		LOG1( "query is in progress or queue is empty. Count - %d", iMediaItems.Count() );
+		LOG1( "CLocationRecord::FindLocationFromDBL(), Count - %d", iMediaItems.Count() );
 return;
 }
 if ( (iMediaItems[0]->iFlag & KNetQueryBit) > 0 )
 {
 		 // n/w based.
 }
 const TReal64 KMeterInDegrees = 0.000009;
 const TReal64 KPi = 3.14159265358979;
 const TReal32 K180Degrees = 180.0;
-//TLocationData locationData = iMediaItems[0].iLocationData;
 TReal64 latitude = iMediaItems[0]->iLocationData.iPosition.Latitude();
 TReal64 longitude = iMediaItems[0]->iLocationData.iPosition.Longitude();
 // calculate distance in degrees
 TReal64 cosine;
 iLocationQuery = iMdeSession->NewObjectQueryL( *iNamespaceDef, *iLocationObjectDef, this );
 CMdELogicCondition& cond = iLocationQuery->Conditions();
 cond.SetOperator( ELogicConditionOperatorAnd );
-LOG1( "latitude: %f", latitude);
+LOG1( "CLocationRecord::FindLocationFromDBL(), latitude: %f", latitude);
-LOG1( "latdelta: %f", latDelta);
+LOG1( "CLocationRecord::FindLocationFromDBL(), latdelta: %f", latDelta);
-LOG1( "longitude: %f", longitude);
+LOG1( "CLocationRecord::FindLocationFromDBL(), longitude: %f", longitude);
-LOG1( "londelta: %f", lonDelta);
+LOG1( "CLocationRecord::FindLocationFromDBL(), londelta: %f", lonDelta);
 cond.AddPropertyConditionL( *iLatitudeDef,
 TMdERealBetween( latitude - latDelta, latitude + latDelta ));
 cond.AddPropertyConditionL( *iLongitudeDef,
 TMdERealBetween( longitude - lonDelta, longitude + lonDelta ));
 	locationObject->AddTimePropertyL( modifiedDef, timestamp );
 	locationObject->AddUint32PropertyL( sizeDef, 0 ); // always zero size for location objects
 	locationObject->AddTextPropertyL( itemTypeDef, Location::KLocationItemType );
 	locationObject->AddInt16PropertyL( offSetDef, timeOffset.Int() / 60 );
-	LOG1( "Location created with stamp: %Ld", timestamp.Int64() );
+	LOG1( "CLocationRecord::DoCreateLocationL(), Location created with stamp: %Ld", timestamp.Int64() );
 	// location related properties
 	if ( !Math::IsNaN( aLocationData.iPosition.Latitude() ) &&
 		 !Math::IsNaN( aLocationData.iPosition.Longitude() ))
 		{
+LOG1("CLocationRecord::DoCreateLocationL(), Lan - %f", aLocationData.iPosition.Latitude());
+LOG1("CLocationRecord::DoCreateLocationL(), Lon - %f", aLocationData.iPosition.Longitude());
 		locationObject->AddReal64PropertyL( *iLatitudeDef, aLocationData.iPosition.Latitude() );
 		locationObject->AddReal64PropertyL( *iLongitudeDef, aLocationData.iPosition.Longitude() );
 		}
 	if ( !Math::IsNaN( aLocationData.iPosition.Altitude() ) )
 		{
 		locationObject->AddReal32PropertyL( qualityDef, aLocationData.iQuality );
 		}
 	// network related properties
-	if ( aLocationData.iNetworkInfo.iAreaKnown )
+	if ( aLocationData.iNetworkInfo.iAccess != CTelephony::ENetworkAccessUnknown )
 		{
-		if ( aLocationData.iNetworkInfo.iAccess != CTelephony::ENetworkAccessUnknown )
+		LOG1("CLocationRecord::DoCreateLocationL(), Cell id - %d", aLocationData.iNetworkInfo.iCellId);
-			{
+		locationObject->AddUint32PropertyL( cellIdDef, aLocationData.iNetworkInfo.iCellId );
-			locationObject->AddUint32PropertyL( cellIdDef, aLocationData.iNetworkInfo.iCellId );
+		}
+	if ( aLocationData.iNetworkInfo.iAreaKnown &&
-			}
+aLocationData.iNetworkInfo.iLocationAreaCode != 0 &&
-		if ( aLocationData.iNetworkInfo.iLocationAreaCode != 0 &&
+		aLocationData.iNetworkInfo.iAccess != CTelephony::ENetworkAccessUnknown )
-			aLocationData.iNetworkInfo.iAccess != CTelephony::ENetworkAccessUnknown )
+		{
-			{
+		LOG1("CLocationRecord::DoCreateLocationL(), Areacode - %d", aLocationData.iNetworkInfo.iLocationAreaCode);
-			locationObject->AddUint32PropertyL( locationCodeDef,
+		locationObject->AddUint32PropertyL( locationCodeDef,
-					aLocationData.iNetworkInfo.iLocationAreaCode );
+				aLocationData.iNetworkInfo.iLocationAreaCode );
+		}
-			}
+#ifdef _DEBUG
-		if ( aLocationData.iNetworkInfo.iCountryCode.Length() > 0 )
-			{
+if ( aLocationData.iNetworkInfo.iCountryCode.Length() > 0 )
-			locationObject->AddTextPropertyL( countryCodeDef,
+{
-					aLocationData.iNetworkInfo.iCountryCode );
+TLex lexer( aLocationData.iNetworkInfo.iCountryCode );
+TUint countryCode = 0;
-			}
+TRAP_IGNORE(lexer.Val( countryCode, EDecimal));
-		if ( aLocationData.iNetworkInfo.iNetworkId.Length() > 0 )
+LOG1("CLocationRecord::DoCreateLocationL(), Country code - %d", countryCode);
-			{
+}
-			locationObject->AddTextPropertyL(networkCodeDef, aLocationData.iNetworkInfo.iNetworkId);
+else
+{
-			}
+LOG("CLocationRecord::DoCreateLocationL(), No Country code");
+}
+//Set mobile network code
+if ( aLocationData.iNetworkInfo.iNetworkId.Length() > 0 )
+{
+TLex lexer = aLocationData.iNetworkInfo.iNetworkId;
+TUint networkCode = 0;
+TRAP_IGNORE(lexer.Val( networkCode, EDecimal));
+LOG1("CLocationRecord::DoCreateLocationL(), Network id - %d", networkCode);
+}
+else
+{
+LOG("CLocationRecord::DoCreateLocationL(), No network code");
+}
+#endif
+	if ( aLocationData.iNetworkInfo.iCountryCode.Length() > 0 )
+		{
+		locationObject->AddTextPropertyL( countryCodeDef,
+				aLocationData.iNetworkInfo.iCountryCode );
+		}
+	if ( aLocationData.iNetworkInfo.iNetworkId.Length() > 0 )
+		{
+		locationObject->AddTextPropertyL(networkCodeDef, aLocationData.iNetworkInfo.iNetworkId);
 		}
 	// Add the location object to the database.
 	locationObjectId = iMdeSession->AddObjectL( *locationObject );
+LOG1("CLocationRecord::DoCreateLocationL(), Location id - %d", locationObjectId);
 	CleanupStack::PopAndDestroy( locationObject );
 LOG( "CLocationRecord::DoCreateLocationL(), end" );
 	return locationObjectId;
 	}
 void CLocationRecord::HandleFindLocationFromDB()
 {
 LOG( "CLocationRecord::HandleFindLocationFromDB(), begin" );
 	if ( iMediaItems.Count() > 0 )
 	   {
-		//TODO: by module owner
 		TInt trapErr = KErrNone;
 		TRAP(trapErr,FindLocationFromDBL());
 		// no memory, don't proceed further
 		// other error sceenario, we can move the node to the end and process the next
 		if(trapErr != KErrNoMemory && trapErr != KErrNone)
 {
 CMdEItem& item = aQuery.ResultItem(0);
 CMdEObject& locationObject = static_cast<CMdEObject&>(item);
 locationId = locationObject.Id();
+iMediaItems[0]->iLocationId = locationId;
 TRAP( error, CreateRelationL( iMediaItems[0]->iObjectId, locationId ) );
 #ifdef LOC_REVERSEGEOCODE
 //check if found location object has lat, long
 CMdEProperty* latProp = NULL;
 CMdEProperty* lonProp = NULL;
 iGeoConverter->ConvertL(iMediaItems[0]->iLocationData.iNetworkInfo);
 iMediaHandlingFlag |= KSnapGeoConvertInProgress;
 iMediaHandlingFlag &= ~KSnapGeoConvertInPendingState;
 }
 #else
+// cell id based geo tagging is not supported.. go for remapping.
 locationId = DoCreateLocationL( iMediaItems[0]->iLocationData );
 iMediaItems[0]->iLocationId = locationId;
-CreateRelationL( iMediaItems[0]->iObjectId, locationId );
+TItemId relationId = CreateRelationL( iMediaItems[0]->iObjectId, locationId );
 TLocationSnapshotItem* firstPtr = iMediaItems[0];
+// Go for remapping.. get locationdata from trail with object time
+TTime timestamp = GetMdeObjectTimeL( iMediaItems[0]->iObjectId );
+TRemapItem remapItem;
+remapItem.iObjectId = iMediaItems[0]->iObjectId;
+remapItem.iTime = timestamp;
+remapItem.iLocationId = locationId;
+remapItem.iRelationId = relationId;
+iRemapper->Append( remapItem );
 iMediaItems.Remove(0);
 delete firstPtr;
 iMediaItems.Compress();
 iMediaHandlingFlag &= ~KLocationQueryInProgress;
 if ( iMediaItems.Count() > 0 )
 iNewItem.iLocationData.iPosition.SetCoordinate
 ( aPosition.Latitude(), aPosition.Longitude(), aPosition.Altitude());
 iNewItem.iLocationData.iQuality = aPosition.HorizontalAccuracy();
 TItemId locationId = DoCreateLocationL( iNewItem.iLocationData );
 iRemapper->UpdateRelationsL( locationId );
-// TODO: remap.
 #ifdef LOC_REVERSEGEOCODE
 if(!(iMediaHandlingFlag & KReverseGeoCodingInProgress))
 {
 iRemapState = ERemapRevGeoCodeInProgress;
 //Find the address by coordinate, results a call to ReverseGeocodeComplete()
 ( aPosition.Latitude(), aPosition.Longitude(), aPosition.Altitude());
 iMediaItems[0]->iLocationData.iQuality = aPosition.HorizontalAccuracy();
 TLocationSnapshotItem* item = iMediaItems[0];
 TItemId locationId = DoCreateLocationL( iMediaItems[0]->iLocationData );
 iMediaItems[0]->iLocationId = locationId;
-CreateRelationL( iMediaItems[0]->iObjectId, locationId );
+TItemId relationId = CreateRelationL( iMediaItems[0]->iObjectId, locationId );
+// Go for remapping.. get locationdata from trail with object time
+TTime timestamp = GetMdeObjectTimeL( iMediaItems[0]->iObjectId );
+TRemapItem remapItem;
+remapItem.iObjectId = iMediaItems[0]->iObjectId;
+remapItem.iTime = timestamp;
+remapItem.iLocationId = locationId;
+remapItem.iRelationId = relationId;
+iRemapper->Append( remapItem );
 if((iMediaItems[0]->iFlag & KSnapMediaFile) > 0)
 {
 iLastMediaItem = *(iMediaItems[0]);
 }
 iMediaItems.Remove(0);
 iRemapState = ERemapProgressNone;
 }
 else if ( iMediaItems.Count() > 0 )
 {
 TLocationSnapshotItem* item = iMediaItems[0];
+// Fails may be becuase of n/w reason..create location + relation so that we can handle at 3:00 AM.
+TItemId locationId = DoCreateLocationL( iMediaItems[0]->iLocationData );
+iMediaItems[0]->iLocationId = locationId;
+TItemId relationId = CreateRelationL( iMediaItems[0]->iObjectId, locationId );
+// Go for remapping.. get locationdata from trail with object time
+TTime timestamp = GetMdeObjectTimeL( iMediaItems[0]->iObjectId );
+TRemapItem remapItem;
+remapItem.iObjectId = iMediaItems[0]->iObjectId;
+remapItem.iTime = timestamp;
+remapItem.iLocationId = locationId;
+remapItem.iRelationId = relationId;
+iRemapper->Append( remapItem );
 iMediaItems.Remove(0);
 iMediaItems.Compress();
 iMediaHandlingFlag &= ~KLocationQueryInProgress;
 delete item;
 }
 CMdEObject* object = NULL;
 CMdEProperty* property = NULL;
 object = iMdeSession->GetObjectL( aObjectId );
+if( !object )
+{
+User::Leave( KErrNotFound );
+}
 CleanupStack::PushL( object );
 object->Property( timeDef, property, 0 );
 if ( !property )
 {
 User::Leave( KErrNotFound );
 }
 const TTime timeValue( property->TimeValueL() );
 CleanupStack::PopAndDestroy( object );
+LOG( "CLocationRecord::GetMdeObjectTimeL(), end" );
 return timeValue;
 }
 // --------------------------------------------------------------------------
 cond.AddPropertyConditionL( networkCodeDef, ETextPropertyConditionCompareEquals,
 iMediaItems[0]->iLocationData.iNetworkInfo.iNetworkId );
 iNetLocationQuery->FindL(1, 1);
 iMediaHandlingFlag |= KLocationQueryInProgress;
-//    iMediaHandlingFlag |= KNetQueryInProgress;
 }
 else
 {
 TLocationSnapshotItem* firstPtr = iMediaItems[0];
 iMediaItems.Remove(0);
 TItemId countryTagId(0);
 TItemId cityTagId(0);
 iMediaHandlingFlag &= (~KReverseGeoCodingInProgress);
 	TLocationSnapshotItem* snapshotItem = NULL;
+LOG1("Error - %d", aErrorcode);
 if( aErrorcode == KErrNone )
 {
+iLastReverseGeocodeFails = EFalse;
 TPtrC countryPtr( aAddressInfo.GetCountryName() );
 TPtrC cityPtr( aAddressInfo.GetCity() );
 TRAP_IGNORE( iTagCreator->CreateLocationTagsL( countryPtr, countryTagId,
 cityPtr, cityTagId ) );
 if ( iRemapState == ERemapRevGeoCodeInProgress)
 iLocationItems[0]->iCityTagId = cityTagId;
 iLastLocationItem = (*iLocationItems[0]);
 TRAP_IGNORE( iTagCreator->AttachTagsL(
 iLocationItems[0]->iObjectId, countryTagId, cityTagId  ) );
+if ( (iLastMediaItem.iFlag & KSnapMediaFile) > 0
+&& iLastMediaItem.iLocationId == iLastLocationItem.iLocationId )
+{
+LOG("Updating country/city\n");
+iLastMediaItem.iCountryTagId = countryTagId;
+iLastMediaItem.iCityTagId = cityTagId;
+}
 }
 }
-if(iLastMediaItem.iFlag == 0)
-{
-LOG("Last media item is null\n");
-}
-if ( iLastMediaItem.iFlag > 0 && iLastMediaItem.iLocationId == iLastLocationItem.iLocationId )
-{
-LOG("Updating country/city\n");
-iLastMediaItem.iCountryTagId = countryTagId;
-iLastMediaItem.iCityTagId = cityTagId;
-}
 //check other items in the array has same location
 for ( TInt index = iLocationItems.Count() - 1; index > 0; index--)
 {
 if ( iLocationItems[index]->iLocationId == iLastLocationItem.iLocationId )
 {
 }
 }
 else
 {
 //handle error
+LOG("Reverse geo coding fails");
+iLastReverseGeocodeFails = ETrue;
 }
 //irrespective of error or not, remove current(first) item to proceed further
 if ( iLocationItems.Count() > 0 )
 {

changeset 54	a3cc46f37772
parent 36	aa5a574040a4