/// <summary> /// The string to long. /// </summary> /// <param name="value"> /// The value. /// </param> /// <param name="conversionMethod"> /// The conversion type. /// </param> /// <returns> /// The <see cref="long"/>. /// </returns> public static long StringToLong(string value, ConversionMethods conversionMethod) { if (string.IsNullOrEmpty(value)) { throw new ArgumentNullException("value"); } switch (conversionMethod) { case ConversionMethods.IndividualIntegers: { return(IndividualIntegers(value)); } case ConversionMethods.Rounded: { return(Rounded(value)); } default: { throw new NotImplementedException( string.Format("{0} Conversion Method is Not Supported.", conversionMethod)); } } }
public void toGramTest() { ConversionMethods conversionTest = new ConversionMethods(); double result = conversionTest.toGrams(15); Assert.AreEqual(425.2428, result, 0.001); }
public void ToEmail_Internal_CheckFormatExceptions() { // Arrange var inputMail = new ecn.communicator.mvc.Models.Email(); inputMail.Birthdate = SampleDummy; inputMail.UserEvent1Date = SampleDummy; inputMail.UserEvent2Date = SampleDummy; var inputUser = new KMPlatform.Entity.User(); ShimEmail.GetByEmailIDInt32User = (p1, p2) => new Email(); // Act try { var internalEmail = ConversionMethods.ToEmail_Internal(inputMail, inputUser); // Assert internalEmail.ShouldBeNull(); } catch (ECNException ex) { ex.ErrorList.ShouldNotBeNull(); ex.ErrorList.Count.ShouldBe(4); ex.ErrorList[0].ErrorMessage.ShouldBe(ExceptionMessageFormatBirthdate); ex.ErrorList[1].ErrorMessage.ShouldBe(ExceptionMessageFormatUserEvent1Date); ex.ErrorList[2].ErrorMessage.ShouldBe(ExceptionMessageFormatUserEvent2Date); ex.ErrorList[3].ErrorMessage.ShouldBe(ExceptionMessageEmailRequired); } }
private void InitialiseWindow() { try { ThemeManager.PropagateThemeSelector(kcbTheme); knumDarkValue.Value = ConversionMethods.ConvertFloatToDecimal(_colourIntensitySettingsManager.GetDarkestColourIntensity()); knumMediumValue.Value = ConversionMethods.ConvertFloatToDecimal(_colourIntensitySettingsManager.GetMediumColourIntensity()); knumLightValue.Value = ConversionMethods.ConvertFloatToDecimal(_colourIntensitySettingsManager.GetLightColourIntensity()); knumLightestValue.Value = ConversionMethods.ConvertFloatToDecimal(_colourIntensitySettingsManager.GetLightestColourIntensity()); klblDarkColourFloatValue.Text = ColourHelpers.ReturnFloatAsString(_colourIntensitySettingsManager.GetDarkestColourIntensity()); klblMediumColourFloatValue.Text = ColourHelpers.ReturnFloatAsString(_colourIntensitySettingsManager.GetMediumColourIntensity()); klblLightColourFloatValue.Text = ColourHelpers.ReturnFloatAsString(_colourIntensitySettingsManager.GetLightColourIntensity()); klblLightestColourFloatValue.Text = ColourHelpers.ReturnFloatAsString(_colourIntensitySettingsManager.GetLightestColourIntensity()); } catch (Exception exc) { ExceptionHandler.CaptureException(exc, icon: MessageBoxIcon.Error, methodSignature: Helpers.GetCurrentMethod()); } }
public void toOunceTest() { ConversionMethods conversionTest = new ConversionMethods(); double result = conversionTest.toOunces(15); Assert.AreEqual(0.52910942924, result, 0.001); }
private static async Task UpdateElements(IElement element) { Ensure.ArgumentNotNull(nameof(element), element); var orderedPropertiesArray = await GetOrderedFilteredPropertyInfos(element); var models = await ConversionMethods.ConvertPropertyInfosToValidationModels(element, orderedPropertiesArray); await ProcessModels(element, models); }
private void EmitConversionCode(Type fromType, Type toType) { MethodInfo parseMethod = null; MethodInfo conversionMethod = null; // si los tipos son iguales no hay que emitir ningún código if (fromType == toType) { return; } if (fromType.IsEnum) { fromType = fromType.GetField("value__").FieldType; } if (toType.IsEnum) { toType = toType.GetField("value__").FieldType; } if (fromType.IsPrimitive && toType.IsPrimitive) { OpCode opCode; if (!nativeConversionOpcodes.TryGetValue(toType, out opCode)) { throw new InvalidCastException(string.Format(CultureInfo.InvariantCulture, "Cannot convert from {0} to {1}", fromType.FullName, toType.FullName)); } cil.Emit(opCode); } else if (fromType == typeof(string) && (parseMethod = toType.GetMethod("Parse", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string) }, null)) != null) { cil.Emit(OpCodes.Call, parseMethod); } else if (toType == typeof(string)) { MethodInfo toStringMethod = fromType.GetMethod("ToString", Type.EmptyTypes); if (toStringMethod == null) { throw new InvalidCastException(string.Format(CultureInfo.InvariantCulture, "Cannot convert from {0} to {1}", fromType.FullName, toType.FullName)); } if (fromType.IsValueType) { LocalBuilder localVar = cil.DeclareLocal(fromType); cil.Emit(OpCodes.Stloc, localVar); cil.Emit(OpCodes.Ldloca, localVar.LocalIndex); } cil.Emit(OpCodes.Call, toStringMethod); } else if ((conversionMethod = ConversionMethods.GetConversionMethod(fromType, toType)) != null) { cil.Emit(OpCodes.Call, conversionMethod); } else { throw new InvalidCastException(string.Format(CultureInfo.InvariantCulture, "Cannot convert from {0} to {1}", fromType.FullName, toType.FullName)); } }
private static void UpdateRepeatedItemList(IList list, Type subtype, IGenericRootItem genericRootItem) { var constructedType = ConversionMethods.GetConcreteClassFromInterface(subtype); var element = constructedType as IElement; if (element == null) { return; } UpdateReferences(element, genericRootItem); list.Add(element); }
private void kbtnConvert_Click(object sender, EventArgs e) { try { int[] rgb = ConversionMethods.ConvertHexadecimalToRGBTest(ktxtHexColourValue.Text); pnlPreview.BackColor = Color.FromArgb(rgb[0], rgb[1], rgb[2]); } catch (Exception) { } //UpdateUI(); }
public void ToEmail_Internal_CheckOneToOne_NoException() { // Arrange var inputMail = CreateSampleEmail(); var inputUser = new KMPlatform.Entity.User(); ShimEmail.GetByEmailIDInt32User = (p1, p2) => new Email(); // Act var internalEmail = ConversionMethods.ToEmail_Internal(inputMail, inputUser); // Assert internalEmail.ShouldNotBeNull(); CheckInternalEmail(internalEmail); }
public void ToEmail_Internal_CheckEmptyMail_NoException() { // Arrange var inputMail = new ecn.communicator.mvc.Models.Email(); inputMail.EmailAddress = SampleEmailAddress; inputMail.EmailID = SampleEmailId; var inputUser = new KMPlatform.Entity.User(); ShimEmail.GetByEmailIDInt32User = (p1, p2) => new Email(); // Act var internalEmail = ConversionMethods.ToEmail_Internal(inputMail, inputUser); // Assert internalEmail.ShouldNotBeNull(); }
private static void UpdateInterfacePropertyValue(object instance, IPropertyValidation propertyValidationModel) { if (!propertyValidationModel.PropertyInfo.PropertyType.IsInterface) { return; } var anyClassImplementingInterface = ConversionMethods.GetConcreteClassFromInterface(propertyValidationModel.PropertyInfo); var anyClassAsElement = anyClassImplementingInterface as BaseElement; if (anyClassAsElement == null) { return; } UpdateReferences(anyClassAsElement, propertyValidationModel.GenericReferenceElement); propertyValidationModel.PropertyInfo.SetValue(instance, anyClassImplementingInterface); }
private static void DoIt(TcpClient clientConnection) { NetworkStream stream = clientConnection.GetStream(); StreamReader reader = new StreamReader(stream); StreamWriter writer = new StreamWriter(stream); while (true) { string request = reader.ReadLine(); if (string.IsNullOrEmpty(request)) { break; } Console.WriteLine("Request: " + request); string response = request; var splitRequest = request.Split(); double conversionNumber = double.Parse(splitRequest[1]); Console.WriteLine($"Converting {conversionNumber} to ounces:"); switch (splitRequest[0]) { case ("toounces"): ConversionMethods toOuncesObject = new ConversionMethods(); double OunceResult = toOuncesObject.toOunces(conversionNumber); Console.WriteLine($"Result: {OunceResult} oz"); break; case ("tograms"): ConversionMethods toGramsObject = new ConversionMethods(); double GramResult = toGramsObject.toGrams(conversionNumber); Console.WriteLine($"Result: {GramResult} g"); break; } writer.WriteLine(response); writer.Flush(); } clientConnection.Close(); Console.WriteLine("Socket closed"); }
private async Task <bool> UpdateLocation() { bool locationChanged = false; if (Settings.FollowGPS) { Geoposition newGeoPos = null; Geolocator geolocal = new Geolocator() { DesiredAccuracyInMeters = 5000, ReportInterval = 900000, MovementThreshold = 1600 }; try { cts.Token.ThrowIfCancellationRequested(); newGeoPos = await geolocal.GetGeopositionAsync(TimeSpan.FromMinutes(15), TimeSpan.FromSeconds(10)).AsTask(cts.Token); } catch (OperationCanceledException) { return(locationChanged); } catch (Exception) { var geoStatus = GeolocationAccessStatus.Unspecified; try { cts.Token.ThrowIfCancellationRequested(); geoStatus = await Geolocator.RequestAccessAsync().AsTask(cts.Token); } catch (OperationCanceledException) { return(locationChanged); } catch (Exception ex) { Logger.WriteLine(LoggerLevel.Error, ex, "{0}: error requesting location permission", taskName); } finally { if (!cts.IsCancellationRequested && geoStatus == GeolocationAccessStatus.Allowed) { try { newGeoPos = await geolocal.GetGeopositionAsync(TimeSpan.FromMinutes(15), TimeSpan.FromSeconds(10)).AsTask(cts.Token); } catch (Exception ex) { Logger.WriteLine(LoggerLevel.Error, ex, "{0}: GetWeather error", taskName); } } } } // Access to location granted if (newGeoPos != null) { var lastGPSLocData = await Settings.GetLastGPSLocData(); if (cts.IsCancellationRequested) { return(locationChanged); } // Check previous location difference if (lastGPSLocData.query != null && Math.Abs(ConversionMethods.CalculateHaversine(lastGPSLocData.latitude, lastGPSLocData.longitude, newGeoPos.Coordinate.Point.Position.Latitude, newGeoPos.Coordinate.Point.Position.Longitude)) < geolocal.MovementThreshold) { return(false); } LocationQueryViewModel view = null; await Task.Run(async() => { view = await wm.GetLocation(newGeoPos); if (String.IsNullOrEmpty(view.LocationQuery)) { view = new LocationQueryViewModel(); } }, cts.Token); if (String.IsNullOrWhiteSpace(view.LocationQuery)) { // Stop since there is no valid query return(false); } if (cts.IsCancellationRequested) { return(locationChanged); } // Save oldkey string oldkey = lastGPSLocData.query; // Save location as last known lastGPSLocData.SetData(view, newGeoPos); Settings.SaveLastGPSLocData(lastGPSLocData); // Update tile id for location if (oldkey != null && SecondaryTileUtils.Exists(oldkey)) { await SecondaryTileUtils.UpdateTileId(oldkey, lastGPSLocData.query); } locationChanged = true; } } return(locationChanged); }
private async Task <bool> UpdateLocation() { bool locationChanged = false; if (Settings.DataSync == WearableDataSync.Off && Settings.FollowGPS && (location == null || location.locationType == LocationType.GPS)) { if (Activity != null && ContextCompat.CheckSelfPermission(Activity, Manifest.Permission.AccessFineLocation) != Permission.Granted) { RequestPermissions(new String[] { Manifest.Permission.AccessFineLocation }, PERMISSION_LOCATION_REQUEST_CODE); return(false); } Android.Locations.Location location = null; if (WearableHelper.IsGooglePlayServicesInstalled && !WearableHelper.HasGPS) { location = await mFusedLocationClient.GetLastLocationAsync(); if (location == null) { var mLocationRequest = new LocationRequest(); mLocationRequest.SetInterval(10000); mLocationRequest.SetFastestInterval(1000); mLocationRequest.SetPriority(LocationRequest.PriorityHighAccuracy); await mFusedLocationClient.RequestLocationUpdatesAsync(mLocationRequest, mLocCallback, null); await mFusedLocationClient.FlushLocationsAsync(); } } else { LocationManager locMan = Activity?.GetSystemService(Context.LocationService) as LocationManager; bool isGPSEnabled = (bool)locMan?.IsProviderEnabled(LocationManager.GpsProvider); bool isNetEnabled = (bool)locMan?.IsProviderEnabled(LocationManager.NetworkProvider); if (isGPSEnabled || isNetEnabled) { Criteria locCriteria = new Criteria() { Accuracy = Accuracy.Coarse, CostAllowed = false, PowerRequirement = Power.Low }; string provider = locMan.GetBestProvider(locCriteria, true); location = locMan.GetLastKnownLocation(provider); if (location == null) { locMan.RequestSingleUpdate(provider, mLocListnr, null); } } else { Toast.MakeText(Activity, Resource.String.error_retrieve_location, ToastLength.Short).Show(); } } if (location != null) { LocationData lastGPSLocData = await Settings.GetLastGPSLocData(); // Check previous location difference if (lastGPSLocData.query != null && mLocation != null && ConversionMethods.CalculateGeopositionDistance(mLocation, location) < 1600) { return(false); } if (lastGPSLocData.query != null && Math.Abs(ConversionMethods.CalculateHaversine(lastGPSLocData.latitude, lastGPSLocData.longitude, location.Latitude, location.Longitude)) < 1600) { return(false); } LocationQueryViewModel view = null; await Task.Run(async() => { view = await wm.GetLocation(location); if (String.IsNullOrEmpty(view.LocationQuery)) { view = new LocationQueryViewModel(); } }); if (String.IsNullOrWhiteSpace(view.LocationQuery)) { // Stop since there is no valid query return(false); } // Save location as last known lastGPSLocData.SetData(view, location); Settings.SaveHomeData(lastGPSLocData); this.location = lastGPSLocData; mLocation = location; locationChanged = true; } } return(locationChanged); }
internal void UpdateExtraParams() { lock (m_ExtraParamsLock) { int i = 0; int limitedi = 0; uint totalBytesLength = 1; uint extraParamsNum = 0; uint limitedTotalBytesLength = 1; uint limitedExtraParamsNum = 0; var flexi = m_Part.Flexible; var light = m_Part.PointLight; var proj = Projection; var shape = m_Part.Shape; var emesh = m_Part.ExtendedMesh; bool isFlexible = flexi.IsFlexible; bool isSculpt = shape.Type == PrimitiveShapeType.Sculpt; ObjectGroup objectGroup = m_Part.ObjectGroup; bool isFullLight = light.IsLight; AttachmentPoint attachPoint = objectGroup?.AttachPoint ?? AttachmentPoint.NotAttached; bool isLimitedLight = isFullLight && (!m_Part.IsAttachmentLightsDisabled || !IsPrivateAttachmentOrNone(attachPoint)) && (!m_Part.IsFacelightDisabled || (attachPoint != AttachmentPoint.LeftHand && attachPoint != AttachmentPoint.RightHand)) && (!m_Part.IsUnattachedLightsDisabled || attachPoint != AttachmentPoint.NotAttached); bool isProjecting = proj.IsProjecting; ExtendedMeshParams.MeshFlags emeshFlags = emesh.Flags; if (isFlexible) { ++extraParamsNum; totalBytesLength += 16; totalBytesLength += 2 + 4; } if (isSculpt) { ++extraParamsNum; totalBytesLength += 17; totalBytesLength += 2 + 4; } if (isProjecting) { ++extraParamsNum; totalBytesLength += 28; totalBytesLength += 2 + 4; } if (emeshFlags != ExtendedMeshParams.MeshFlags.None) { ++extraParamsNum; totalBytesLength += 4; totalBytesLength += 2 + 4; } limitedExtraParamsNum = extraParamsNum; limitedTotalBytesLength = totalBytesLength; if (isLimitedLight) { ++limitedExtraParamsNum; limitedTotalBytesLength += 16; limitedTotalBytesLength += 2 + 4; } if (isFullLight) { ++extraParamsNum; totalBytesLength += 16; totalBytesLength += 2 + 4; } var updatebytes = new byte[totalBytesLength]; var updatebyteslimited = new byte[limitedTotalBytesLength]; updatebyteslimited[limitedi++] = (byte)limitedExtraParamsNum; updatebytes[i++] = (byte)extraParamsNum; if (isFlexible) { updatebytes[i++] = FlexiEP % 256; updatebytes[i++] = FlexiEP / 256; updatebytes[i++] = 16; updatebytes[i++] = 0; updatebytes[i++] = 0; updatebytes[i++] = 0; updatebytes[i++] = (byte)((byte)((byte)(flexi.Tension * 10.01f) & 0x7F) | (byte)((flexi.Softness & 2) << 6)); updatebytes[i++] = (byte)((byte)((byte)(flexi.Friction * 10.01f) & 0x7F) | (byte)((flexi.Softness & 1) << 7)); updatebytes[i++] = (byte)((flexi.Gravity + 10.0f) * 10.01f); updatebytes[i++] = (byte)(flexi.Wind * 10.01f); flexi.Force.ToBytes(updatebytes, i); i += 12; } if (isSculpt) { updatebytes[i++] = SculptEP % 256; updatebytes[i++] = SculptEP / 256; updatebytes[i++] = 17; updatebytes[i++] = 0; updatebytes[i++] = 0; updatebytes[i++] = 0; shape.SculptMap.ToBytes(updatebytes, i); i += 16; updatebytes[i++] = (byte)shape.SculptType; } Buffer.BlockCopy(updatebytes, 1, updatebyteslimited, 1, i - 1); limitedi = i; if (isFullLight) { updatebytes[i++] = LightEP % 256; updatebytes[i++] = LightEP / 256; updatebytes[i++] = 16; updatebytes[i++] = 0; updatebytes[i++] = 0; updatebytes[i++] = 0; Buffer.BlockCopy(light.LightColor.AsByte, 0, updatebytes, i, 3); updatebytes[i + 3] = (byte)(light.Intensity * 255f); i += 4; ConversionMethods.Float2LEBytes((float)light.Radius, updatebytes, i); i += 4; ConversionMethods.Float2LEBytes((float)light.Cutoff, updatebytes, i); i += 4; ConversionMethods.Float2LEBytes((float)light.Falloff, updatebytes, i); i += 4; } if (isLimitedLight) { updatebyteslimited[limitedi++] = LightEP % 256; updatebyteslimited[limitedi++] = LightEP / 256; updatebyteslimited[limitedi++] = 16; updatebyteslimited[limitedi++] = 0; updatebyteslimited[limitedi++] = 0; updatebyteslimited[limitedi++] = 0; Buffer.BlockCopy(light.LightColor.AsByte, 0, updatebyteslimited, limitedi, 3); double intensity = light.Intensity; double radius = light.Radius; if (attachPoint == AttachmentPoint.NotAttached) { intensity = Math.Min(m_Part.UnattachedLightLimitIntensity, intensity); radius = Math.Min(m_Part.UnattachedLightLimitRadius, radius); } else if (IsPrivateAttachmentOrNone(attachPoint)) { /* skip these as they are anyways hidden from anyone else */ } else { if (attachPoint != AttachmentPoint.LeftHand && attachPoint != AttachmentPoint.RightHand) { intensity = Math.Min(m_Part.FacelightLimitIntensity, intensity); radius = Math.Min(m_Part.FacelightLimitRadius, radius); } intensity = Math.Min(m_Part.AttachmentLightLimitIntensity, intensity); radius = Math.Min(m_Part.AttachmentLightLimitRadius, radius); } updatebyteslimited[limitedi + 3] = (byte)(intensity * 255f); limitedi += 4; ConversionMethods.Float2LEBytes((float)light.Radius, updatebyteslimited, limitedi); limitedi += 4; ConversionMethods.Float2LEBytes((float)light.Cutoff, updatebyteslimited, limitedi); limitedi += 4; ConversionMethods.Float2LEBytes((float)light.Falloff, updatebyteslimited, limitedi); limitedi += 4; } if (isProjecting) { /* full block */ updatebytes[i++] = (ProjectionEP % 256); updatebytes[i++] = (ProjectionEP / 256); updatebytes[i++] = 28; updatebytes[i++] = 0; updatebytes[i++] = 0; updatebytes[i++] = 0; proj.ProjectionTextureID.ToBytes(updatebytes, i); i += 16; ConversionMethods.Float2LEBytes((float)proj.ProjectionFOV, updatebytes, i); i += 4; ConversionMethods.Float2LEBytes((float)proj.ProjectionFocus, updatebytes, i); i += 4; ConversionMethods.Float2LEBytes((float)proj.ProjectionAmbience, updatebytes, i); /* limited block */ updatebyteslimited[limitedi++] = (ProjectionEP % 256); updatebyteslimited[limitedi++] = (ProjectionEP / 256); updatebyteslimited[limitedi++] = 28; updatebyteslimited[limitedi++] = 0; updatebyteslimited[limitedi++] = 0; updatebyteslimited[limitedi++] = 0; proj.ProjectionTextureID.ToBytes(updatebyteslimited, limitedi); limitedi += 16; ConversionMethods.Float2LEBytes((float)proj.ProjectionFOV, updatebytes, limitedi); limitedi += 4; ConversionMethods.Float2LEBytes((float)proj.ProjectionFocus, updatebytes, limitedi); limitedi += 4; ConversionMethods.Float2LEBytes((float)proj.ProjectionAmbience, updatebytes, limitedi); } if (emeshFlags != ExtendedMeshParams.MeshFlags.None) { /* full block */ updatebytes[i++] = (ExtendedMeshEP % 256); updatebytes[i++] = (ExtendedMeshEP / 256); updatebytes[i++] = 4; updatebytes[i++] = 0; updatebytes[i++] = 0; updatebytes[i++] = 0; updatebytes[i++] = (byte)(((uint)emeshFlags) & 0xFF); updatebytes[i++] = (byte)((((uint)emeshFlags) >> 8) & 0xFF); updatebytes[i++] = (byte)((((uint)emeshFlags) >> 16) & 0xFF); updatebytes[i++] = (byte)((((uint)emeshFlags) >> 24) & 0xFF); /* limited block */ updatebyteslimited[limitedi++] = (ExtendedMeshEP % 256); updatebyteslimited[limitedi++] = (ExtendedMeshEP / 256); updatebyteslimited[limitedi++] = 4; updatebyteslimited[limitedi++] = 0; updatebyteslimited[limitedi++] = 0; updatebyteslimited[limitedi++] = 0; updatebyteslimited[limitedi++] = (byte)(((uint)emeshFlags) & 0xFF); updatebyteslimited[limitedi++] = (byte)((((uint)emeshFlags) >> 8) & 0xFF); updatebyteslimited[limitedi++] = (byte)((((uint)emeshFlags) >> 16) & 0xFF); updatebyteslimited[limitedi++] = (byte)((((uint)emeshFlags) >> 24) & 0xFF); } m_ExtraParamsBytes = updatebytes; m_ExtraParamsBytesLimitedLight = updatebyteslimited; } }
private async Task <bool> UpdateLocation() { bool locationChanged = false; if (Settings.FollowGPS && (location == null || location.locationType == LocationType.GPS)) { Geoposition newGeoPos = null; try { newGeoPos = await geolocal.GetGeopositionAsync(TimeSpan.FromMinutes(15), TimeSpan.FromSeconds(10)); } catch (Exception) { var geoStatus = GeolocationAccessStatus.Unspecified; try { geoStatus = await Geolocator.RequestAccessAsync(); } catch (Exception ex) { Logger.WriteLine(LoggerLevel.Error, ex, "WeatherNow: GetWeather error"); } finally { if (geoStatus == GeolocationAccessStatus.Allowed) { try { newGeoPos = await geolocal.GetGeopositionAsync(TimeSpan.FromMinutes(15), TimeSpan.FromSeconds(10)); } catch (Exception ex) { Logger.WriteLine(LoggerLevel.Error, ex, "WeatherNow: GetWeather error"); } } else if (geoStatus == GeolocationAccessStatus.Denied) { // Disable gps feature Settings.FollowGPS = false; } } if (!Settings.FollowGPS) { return(false); } } // Access to location granted if (newGeoPos != null) { LocationData lastGPSLocData = await Settings.GetLastGPSLocData(); // Check previous location difference if (lastGPSLocData.query != null && geoPos != null && ConversionMethods.CalculateGeopositionDistance(geoPos, newGeoPos) < geolocal.MovementThreshold) { return(false); } if (lastGPSLocData.query != null && Math.Abs(ConversionMethods.CalculateHaversine(lastGPSLocData.latitude, lastGPSLocData.longitude, newGeoPos.Coordinate.Point.Position.Latitude, newGeoPos.Coordinate.Point.Position.Longitude)) < geolocal.MovementThreshold) { return(false); } LocationQueryViewModel view = null; await Task.Run(async() => { view = await wm.GetLocation(newGeoPos); if (String.IsNullOrEmpty(view.LocationQuery)) { view = new LocationQueryViewModel(); } }); if (String.IsNullOrWhiteSpace(view.LocationQuery)) { // Stop since there is no valid query return(false); } // Save oldkey string oldkey = lastGPSLocData.query; // Save location as last known lastGPSLocData.SetData(view, newGeoPos); Settings.SaveLastGPSLocData(lastGPSLocData); // Update tile id for location if (oldkey != null && SecondaryTileUtils.Exists(oldkey)) { await SecondaryTileUtils.UpdateTileId(oldkey, lastGPSLocData.query); } location = lastGPSLocData; geoPos = newGeoPos; locationChanged = true; } } return(locationChanged); }
private async Task <bool> UpdateLocation() { bool locationChanged = false; if (Settings.FollowGPS) { if (ContextCompat.CheckSelfPermission(this, Manifest.Permission.AccessFineLocation) != Permission.Granted) { return(false); } Android.Locations.Location location = null; if (WearableHelper.IsGooglePlayServicesInstalled && !WearableHelper.HasGPS) { var mFusedLocationClient = new FusedLocationProviderClient(this); location = await mFusedLocationClient.GetLastLocationAsync(); } else { LocationManager locMan = GetSystemService(Context.LocationService) as LocationManager; bool isGPSEnabled = (bool)locMan?.IsProviderEnabled(LocationManager.GpsProvider); bool isNetEnabled = (bool)locMan?.IsProviderEnabled(LocationManager.NetworkProvider); if (isGPSEnabled || isNetEnabled) { Criteria locCriteria = new Criteria() { Accuracy = Accuracy.Coarse, CostAllowed = false, PowerRequirement = Power.Low }; string provider = locMan.GetBestProvider(locCriteria, true); location = locMan.GetLastKnownLocation(provider); } else { Toast.MakeText(this, Resource.String.error_retrieve_location, ToastLength.Short).Show(); } } if (location != null) { LocationData lastGPSLocData = await Settings.GetLastGPSLocData(); // Check previous location difference if (lastGPSLocData.query != null && Math.Abs(ConversionMethods.CalculateHaversine(lastGPSLocData.latitude, lastGPSLocData.longitude, location.Latitude, location.Longitude)) < 1600) { return(false); } LocationQueryViewModel view = null; await Task.Run(async() => { view = await wm.GetLocation(location); if (String.IsNullOrEmpty(view.LocationQuery)) { view = new LocationQueryViewModel(); } }); if (String.IsNullOrWhiteSpace(view.LocationQuery)) { // Stop since there is no valid query return(false); } // Save location as last known lastGPSLocData.SetData(view, location); Settings.SaveHomeData(lastGPSLocData); locationChanged = true; } } return(locationChanged); }
private async Task <bool> UpdateLocation() { bool locationChanged = false; if (Settings.FollowGPS && (location == null || location.locationType == LocationType.GPS)) { if (AppCompatActivity != null && ContextCompat.CheckSelfPermission(AppCompatActivity, Manifest.Permission.AccessFineLocation) != Permission.Granted && ContextCompat.CheckSelfPermission(AppCompatActivity, Manifest.Permission.AccessCoarseLocation) != Permission.Granted) { ActivityCompat.RequestPermissions(AppCompatActivity, new String[] { Manifest.Permission.AccessCoarseLocation, Manifest.Permission.AccessFineLocation }, PERMISSION_LOCATION_REQUEST_CODE); return(false); } LocationManager locMan = AppCompatActivity?.GetSystemService(Context.LocationService) as LocationManager; bool isGPSEnabled = (bool)locMan?.IsProviderEnabled(LocationManager.GpsProvider); bool isNetEnabled = (bool)locMan?.IsProviderEnabled(LocationManager.NetworkProvider); Android.Locations.Location location = null; if (isGPSEnabled || isNetEnabled) { Criteria locCriteria = new Criteria() { Accuracy = Accuracy.Coarse, CostAllowed = false, PowerRequirement = Power.Low }; string provider = locMan.GetBestProvider(locCriteria, true); location = locMan.GetLastKnownLocation(provider); if (location == null) { locMan.RequestSingleUpdate(provider, mLocListnr, null); } else { LocationData lastGPSLocData = await Settings.GetLastGPSLocData(); // Check previous location difference if (lastGPSLocData.query != null && mLocation != null && ConversionMethods.CalculateGeopositionDistance(mLocation, location) < 1600) { return(false); } if (lastGPSLocData.query != null && Math.Abs(ConversionMethods.CalculateHaversine(lastGPSLocData.latitude, lastGPSLocData.longitude, location.Latitude, location.Longitude)) < 1600) { return(false); } LocationQueryViewModel view = null; await Task.Run(async() => { view = await wm.GetLocation(location); if (String.IsNullOrEmpty(view.LocationQuery)) { view = new LocationQueryViewModel(); } }); if (String.IsNullOrWhiteSpace(view.LocationQuery)) { // Stop since there is no valid query return(false); } // Save oldkey string oldkey = lastGPSLocData.query; // Save location as last known lastGPSLocData.SetData(view, location); Settings.SaveLastGPSLocData(lastGPSLocData); App.Context.StartService( new Intent(App.Context, typeof(WearableDataListenerService)) .SetAction(WearableDataListenerService.ACTION_SENDLOCATIONUPDATE)); this.location = lastGPSLocData; mLocation = location; // Update widget ids for location if (oldkey != null && WidgetUtils.Exists(oldkey)) { WidgetUtils.UpdateWidgetIds(oldkey, lastGPSLocData); } locationChanged = true; } } else { AppCompatActivity?.RunOnUiThread(() => { Toast.MakeText(AppCompatActivity, Resource.String.error_retrieve_location, ToastLength.Short).Show(); }); } } return(locationChanged); }
//Not Implemented - MSH.19 -> MSH.21 public override string ToString() { return ($"{Prefix}{FieldSeparator}{ConversionMethods.BuildOrderedCollection(this).Result.ToFieldSeparatorString()}"); }
private void kbtnConvertToRGB_Click(object sender, EventArgs e) { ConversionMethods conversionMethods = new ConversionMethods(); cpbColourPreview.BackColor = conversionMethods.ConvertHexadecimalToRGB($"#{ ktxtHexValue.Text }"); }
public override string ToString() { return ($"{Prefix}{Configuration.Configuration.ConfigurationData.Instance.ParsingData.FieldSeparator}{ConversionMethods.BuildOrderedCollection(this).Result.ToFieldSeparatorString()}"); }