private void SetZoneChangedCallback()
{
Log.Info(Globals.LogTag, "Inside SetZoneChangedCallback");
if (_zoneChangedCallback == null)
{
_zoneChangedCallback = (state, latitude, longitude, altitude, timestamp, userData) =>
{
Log.Info(Globals.LogTag, "Inside ZoneChangedCallback");
DateTime timeStamp = DateTime.Now;
if (timestamp != 0)
{
DateTime start = DateTime.SpecifyKind(new DateTime(1970, 1, 1).AddSeconds(timestamp), DateTimeKind.Utc);
timeStamp = start.ToLocalTime();
}
_zoneChanged?.Invoke(this, new ZoneChangedEventArgs(state, latitude, longitude, altitude, timeStamp));
};
}
int ret = Interop.LocatorEvent.SetZoneChangedCallback(_handle, _zoneChangedCallback, IntPtr.Zero);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Setting Zone Changed Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
/// <summary>
/// The constructor of the Polygon Boundary class.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="coordinates"> The coordinates which constitute the polgonal boundary.</param>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public PolygonBoundary(IList <Coordinate> coordinates)
{
Log.Info(Globals.LogTag, "Calling PolygonBoundary Constructor");
if (coordinates == null)
{
Log.Error(Globals.LogTag, "coordingtes list is null");
throw LocationErrorFactory.ThrowLocationException((int)LocationError.InvalidParameter);
}
BoundaryType = BoundaryType.Polygon;
IntPtr listPointer = Marshal.AllocHGlobal(Marshal.SizeOf(coordinates[0]) * coordinates.Count);
IntPtr boundsHandle;
for (int i = 0; i < coordinates.Count; i++)
{
Marshal.StructureToPtr(coordinates[i], listPointer + i * Marshal.SizeOf(coordinates[0]), false);
}
int ret = Interop.LocationBoundary.CreatePolygonBoundary(listPointer, coordinates.Count, out boundsHandle);
if ((LocationBoundError)ret != LocationBoundError.None)
{
Log.Error(Globals.LogTag, "Error Creating Polygon Boundary," + (LocationBoundError)ret);
throw LocationErrorFactory.ThrowLocationBoundaryException(ret);
}
handle = boundsHandle;
}
private void SetSatelliteStatusChangeCallback()
{
Log.Info(Globals.LogTag, "SetSatelliteStatusChangeCallback");
if (_satelliteStatuschangedCallback == null)
{
_satelliteStatuschangedCallback = (numActive, numInView, timestamp, userData) =>
{
Log.Info(Globals.LogTag, "Inside SatelliteStatusChangedCallback");
DateTime timeStamp = DateTime.Now;
if (timestamp != 0)
{
DateTime start = DateTime.SpecifyKind(new DateTime(1970, 1, 1).AddSeconds(timestamp), DateTimeKind.Utc);
timeStamp = start.ToLocalTime();
}
_satelliteStatusChanged?.Invoke(_handle, new SatelliteStatusChangedEventArgs(numActive, numInView, timeStamp));
};
}
GCHandle handle = GCHandle.Alloc(this);
int ret = Interop.GpsSatellite.SetSatelliteStatusChangedCallback(_handle, _satelliteStatuschangedCallback, _interval, GCHandle.ToIntPtr(handle));
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in setting satellite status changed callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void SetLocationBatchCallback()
{
Log.Info(Globals.LogTag, "Calling SetLocationBatchCallback");
int ret;
if (_locationBatchCallback == null)
{
_locationBatchCallback = (batch_size, userData) =>
{
Log.Info(Globals.LogTag, "LocationBatchCallback has been called, size : " + batch_size);
_locationBatchGetCallback = (latitude, longitude, altitude, speed, direction, horizontal, vertical, timestamp, batchUserData) =>
{
Log.Info(Globals.LogTag, "GetLocationBatch has been called");
Location location = new Location(latitude, longitude, altitude, speed, direction, horizontal, timestamp);
_location = location;
_locationChanged?.Invoke(this, new LocationChangedEventArgs(location));
};
ret = Interop.LocatorEvent.GetLocationBatch(_handle, _locationBatchGetCallback, IntPtr.Zero);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Setting location batch Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
};
}
ret = Interop.LocatorEvent.SetLocationBatchCallback(_handle, _locationBatchCallback, _batchInterval, _batchPeriod, IntPtr.Zero);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Setting location batch Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void DestroyHandle()
{
int ret = Interop.Locator.Destroy(_handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Destroy handle, " + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void SetEnableMock()
{
int ret = Interop.Locator.EnableMock(_isEnableMock);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error Set Enable Mock Status," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void UnSetSettingChangedCallback()
{
Log.Info(Globals.LogTag, "Calling UnSetSettingChangedCallback");
int ret = Interop.LocatorEvent.UnSetSettingChangedCallback((int)_locationType);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Unsetting Setting's Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void UnSetLocationBatchCallback()
{
Log.Info(Globals.LogTag, "Calling UnSetLocationBatchCallback");
int ret = Interop.LocatorEvent.UnSetLocationBatchCallback(_handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in UnSetting location batch Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
/// <summary>
/// Sets the specified geographical positioning type.
/// </summary>
/// <since_tizen> 4 </since_tizen>
/// <privilege>http://tizen.org/privilege/location.enable</privilege>
/// <privlevel>platform</privlevel>
/// <param name="locationType">The back-end positioning method to be used for LBS.</param>
/// <param name="status">The location setting value.</param>
/// <feature>http://tizen.org/feature/location.gps</feature>
/// <feature>http://tizen.org/feature/location.wps</feature>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public static void EnableType(LocationType locationType, bool status)
{
Log.Info(Globals.LogTag, "Sets the location setting status");
int ret = Interop.LocatorHelper.EnableType((int)locationType, status);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error Sets the Location type," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
/// <summary>
/// Deletes a bound for a given locator.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="locationBoundary"> The boundary object to be removed from the locator.</param>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public void RemoveBoundary(LocationBoundary locationBoundary)
{
Log.Info(Globals.LogTag, "RemoveBoundary called");
int ret = Interop.Locator.RemoveBoundary(_handle, locationBoundary.GetHandle());
if ((LocationBoundError)ret != LocationBoundError.None)
{
Log.Error(Globals.LogTag, "Error Removing Boundary," + (LocationBoundError)ret);
throw LocationErrorFactory.ThrowLocationBoundaryException(ret);
}
}
private void DestroyHandle()
{
Log.Info(Globals.LogTag, "DestroyBoundaryHandle");
int ret = Interop.LocationBoundary.DestroyBoundary(handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in DestroyBoundary handle" + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
/// <summary>
/// Clears a mock location for the given location method.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <privilege>http://tizen.org/privilege/location</privilege>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="UnauthorizedAccessException">Thrown when the application has no privilege to use the location.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public void ClearMock()
{
Log.Info(Globals.LogTag, "Clear mock location");
int ret = Interop.Locator.ClearMock(_handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in clear up location mocking," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
/// <summary>
/// Stops the Location Manager which has been activated using the specified method.
/// Does not destroy the manager.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public void Stop()
{
Log.Info(Globals.LogTag, "Stopping Location Manager");
int ret = Interop.Locator.Stop(_handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error stopping Location Manager," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void UnSetSatelliteStatusChangeCallback()
{
Log.Info(Globals.LogTag, "UnSetSatelliteStatusChangeCallback");
int ret = Interop.GpsSatellite.UnSetSatelliteStatusChangedCallback(_handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Getting Unsetting satellite status changed callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void UnSetDistanceBasedLocationChangedCallback()
{
Log.Info(Globals.LogTag, "UnSetDistanceBasedLocationChangedCallback");
int ret = Interop.LocatorEvent.UnSetDistanceBasedLocationChangedCallback(_handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in UnSetting Distance based location changed Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
_distanceBasedLocationChanged = null;
}
private bool GetEnableMock()
{
bool status = false;
int ret = Interop.Locator.IsEnabledMock(out status);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error Get Enable Mock Status," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
return(status);
}
private string GetNmea()
{
string value = null;
int ret = Interop.GpsSatellite.GetNMEAData(_handle, out value);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error getting the NMEAData," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
return(value);
}
private double GetRadius()
{
Coordinate center;
double radius = 0;
int ret = Interop.LocationBoundary.GetCircleCoordinates(handle, out center, out radius);
if ((LocationBoundError)ret != LocationBoundError.None)
{
Log.Error(Globals.LogTag, "Error Get Radius," + (LocationBoundError)ret);
throw LocationErrorFactory.ThrowLocationBoundaryException(ret);
}
return(radius);
}
/// <summary>
/// The constructor of the Locator class.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="locationType"> The back-end positioning method to be used for LBS.</param>
/// <feature>http://tizen.org/feature/location.gps</feature>
/// <feature>http://tizen.org/feature/location.wps</feature>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public Locator(LocationType locationType)
{
Log.Info(Globals.LogTag, "Locator Constructor");
int ret = Interop.Locator.Create((int)locationType, out _handle);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error creating Location Manager," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
_location = new Location();
_locationType = locationType;
}
/// <summary>
/// Checks if the specified geographical positioning type is enabled or not.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="locationType">The back-end positioning method to be used for LBS.</param>
/// <feature>http://tizen.org/feature/location.gps</feature>
/// <feature>http://tizen.org/feature/location.wps</feature>
/// <returns>Returns a boolean value indicating whether or not the specified method is supported.</returns>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public static bool IsEnabledType(LocationType locationType)
{
Log.Info(Globals.LogTag, "Checking if the Location Manager type is Enabled");
bool status;
int ret = Interop.LocatorHelper.IsEnabled((int)locationType, out status);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error Checking the Location Manager type is Enabled," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
return(status);
}
/// <summary>
/// The constructor of the Rectangle boundary class.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="topLeft"> The coordinate which constitutes the top-left handside of the rectangular boundary.</param>
/// <param name="bottomRight"> The coordinate which constitutes the bottom-right handside of the rectangular boundary.</param>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public RectangleBoundary(Coordinate topLeft, Coordinate bottomRight)
{
Log.Info(Globals.LogTag, "Calling RectangleBoundary constructor");
BoundaryType = BoundaryType.Rectangle;
IntPtr boundsHandle;
int ret = Interop.LocationBoundary.CreateRectangularBoundary(topLeft, bottomRight, out boundsHandle);
if ((LocationBoundError)ret != LocationBoundError.None)
{
Log.Error(Globals.LogTag, "Error Creating Rectangular Boundary," + (LocationBoundError)ret);
throw LocationErrorFactory.ThrowLocationBoundaryException(ret);
}
handle = boundsHandle;
}
private Coordinate GetCircleCenter()
{
Log.Info(Globals.LogTag, "Calling to get CoordinateItem Center");
Coordinate center;
double radius;
int ret = Interop.LocationBoundary.GetCircleCoordinates(handle, out center, out radius);
if ((LocationBoundError)ret != LocationBoundError.None)
{
Log.Error(Globals.LogTag, "Error Get Circle Center," + (LocationBoundError)ret);
throw LocationErrorFactory.ThrowLocationBoundaryException(ret);
}
return(center);
}
/// <summary>
/// Gets the distance between the current and the specified location.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="location"> The location object to which distance is to be calculated.</param>
/// <returns>Returns the distance to the specified location.</returns>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public double GetDistanceTo(Location location)
{
double result;
Log.Info(Globals.LogTag, "Calling GetDistanceTo");
int ret = Interop.Location.GetDistanceBetween(this.Latitude, this.Longitude, location.Latitude, location.Longitude, out result);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error getting distance information to the specifed location," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
return(result);
}
/// <summary>
/// Gets the distance between the two given coordinates.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="startLatitude">The latitude of the source location [-90.0 ~ 90.0] \(degrees).</param>
/// <param name="startLongitude">The longitude of the source location[-180.0 ~ 180.0] \(degrees).</param>
/// <param name="endLatitude">The latitude of the source location [-90.0 ~ 90.0] \(degrees).</param>
/// <param name="endLongitude">The longitude of the source location[-180.0 ~ 180.0] \(degrees).</param>
/// <returns>Returns the distance between the source and the destination.</returns>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public static double GetDistanceBetween(double startLatitude, double startLongitude, double endLatitude, double endLongitude)
{
double result;
Log.Info(Globals.LogTag, "Calling GetDistanceBetween");
int ret = Interop.Location.GetDistanceBetween(startLatitude, startLongitude, endLatitude, endLongitude, out result);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error getting single distance information ," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
return(result);
}
/// <summary>
/// The constructor of the Circular boundary class.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="coordinate"> The coordinates which constitute the center of the circular boundary.</param>
/// <param name="radius"> The radius value of the circular boundary.</param>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public CircleBoundary(Coordinate coordinate, double radius)
{
Log.Info(Globals.LogTag, "Calling CircleBoundary constructor");
BoundaryType = BoundaryType.Circle;
IntPtr boundsHandle;
int ret = Interop.LocationBoundary.CreateCircleBoundary(coordinate, radius, out boundsHandle);
if ((LocationBoundError)ret != LocationBoundError.None)
{
Log.Error(Globals.LogTag, "Error Creating Circular Boundary," + (LocationBoundError)ret);
throw LocationErrorFactory.ThrowLocationBoundaryException(ret);
}
handle = boundsHandle;
}
/// <summary>
/// Gets the details of the location.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <returns> Which contains the current location details.</returns>
/// <privilege>http://tizen.org/privilege/location</privilege>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="UnauthorizedAccessException">Thrown when the application has no privilege to use the location.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public Location GetLocation()
{
double latitude = 0;
double longitude = 0;
double altitude = 0;
double climb = 0;
double speed = 0;
double direction = 0;
int level = 0;
double accuracy = 0;
double vertical = 0;
int timestamp = 0;
Log.Info(Globals.LogTag, "Get current location information");
int ret = Interop.Locator.GetLocation(_handle, out altitude, out latitude, out longitude, out climb, out direction, out speed, out level, out accuracy, out vertical, out timestamp);
if (((LocationError)ret != LocationError.None))
{
if ((LocationError)ret == LocationError.ServiceNotAvailable)
{
Log.Info(Globals.LogTag, "Get last location information");
ret = Interop.Locator.GetLastLocation(_handle, out altitude, out latitude, out longitude, out climb, out direction, out speed, out level, out accuracy, out vertical, out timestamp);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in get last location information," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
else
{
if (latitude == 0.0 && longitude == 0.0)
{
Log.Error(Globals.LogTag, "Error fail to get last location information");
throw LocationErrorFactory.ThrowLocationException((int)LocationError.ServiceNotAvailable);
}
}
}
else
{
Log.Error(Globals.LogTag, "Error in get current location information," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
Location location = new Location(latitude, longitude, altitude, speed, direction, accuracy, timestamp);
_location = location;
return(location);
}
private uint GetInViewCount()
{
Log.Info(Globals.LogTag, "Getting the In view count of satellites");
uint numActive;
uint numInView = 0;
int timestamp;
int ret = Interop.GpsSatellite.GetSatelliteStatus(_handle, out numActive, out numInView, out timestamp);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error getting the satellite" + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
return(numInView);
}
/// <summary>
/// Sets a mock location for the given location method.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <param name="location"> The location object containing the mock location details.</param>
/// <privilege>http://tizen.org/privilege/location</privilege>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
/// <exception cref="UnauthorizedAccessException">Thrown when the application has no privilege to use the location.</exception>
/// <exception cref="NotSupportedException">Thrown when the location is not supported.</exception>
public void SetMockLocation(Location location)
{
Log.Info(Globals.LogTag, "Setting mock location");
int ret = Interop.Locator.SetMockLocation(_handle, location.Latitude, location.Longitude, location.Altitude, location.Speed, location.Direction, location.Accuracy);
if (((LocationError)ret == LocationError.None))
{
_location.Latitude = location.Latitude;
_location.Longitude = location.Longitude;
_location.Altitude = location.Altitude;
_location.Speed = location.Speed;
_location.Direction = location.Direction;
_location.Accuracy = location.Accuracy;
}
else
{
Log.Error(Globals.LogTag, "Error in setting up location mocking," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void SetSettingChangedCallback()
{
Log.Info(Globals.LogTag, "Calling SetSettingChangedCallback");
if (_settingChangedCallback == null)
{
_settingChangedCallback = (method, enable, userData) =>
{
Log.Info(Globals.LogTag, "Calling SettingChangedCallback");
_settingChanged?.Invoke(this, new SettingChangedEventArgs(method, enable));
};
}
int ret = Interop.LocatorEvent.SetSettingChangedCallback((int)_locationType, _settingChangedCallback, IntPtr.Zero);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Setting Changed Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
private void SetServiceStateChangedCallback()
{
Log.Info(Globals.LogTag, "Calling Interop.LocatorEvent.SetServiceStateChangedCallback");
if (_serviceStateChangedCallback == null)
{
_serviceStateChangedCallback = (state, userData) =>
{
Log.Info(Globals.LogTag, "Inside ServiceStateChangedCallback");
_serviceStateChanged?.Invoke(this, new ServiceStateChangedEventArgs(state));
};
}
int ret = Interop.LocatorEvent.SetServiceStateChangedCallback(_handle, _serviceStateChangedCallback, IntPtr.Zero);
if (((LocationError)ret != LocationError.None))
{
Log.Error(Globals.LogTag, "Error in Setting Service State Changed Callback," + (LocationError)ret);
throw LocationErrorFactory.ThrowLocationException(ret);
}
}
