protected virtual async void RangingBeaconsInRegion(object sender, ICollection <AltBeaconOrg.BoundBeacon.Beacon> beacons) { MvxTrace.TaggedTrace(TAG, "RangingBeaconsInRegion"); if (beacons != null && beacons.Count > 0) { var foundBeacons = beacons.ToList(); foreach (var beacon in foundBeacons) { if (beacon.BeaconTypeCode == 0x10) //Eddystone URL { var url = UrlBeaconUrlCompressor.Uncompress(beacon.Id1.ToByteArray()); await BeaconsService.Instance.ActivateEddystoneUrl(url); } else if (beacon.BeaconTypeCode == 0x00) //Eddystone UID { var uid = beacon.Id1.ToString().Replace("0x", "") + beacon.Id2.ToString().Replace("0x", ""); await BeaconsService.Instance.ActivateEddystoneUrl(uid); } else if (beacon.BeaconTypeCode == 533) //iBeacon { await BeaconsService.Instance.ActivateiBeacon( beacon.Id1.ToString().Replace("-", ""), Int32.Parse(beacon.Id2.ToString()), Int32.Parse(beacon.Id3.ToString()) ); } } } }
protected override void OnHandleIntent(Intent intent) { if (intent == null) { return; } MvxTrace.TaggedTrace(TAG, "GeofenceTransitionsIntentService handle intent"); var geofencingEvent = GeofencingEvent.FromIntent(intent); if (geofencingEvent.HasError) { var errorMessage = GeofenceErrorMessages.GetErrorString(this, geofencingEvent.ErrorCode); MvxTrace.TaggedError(TAG, errorMessage); return; } int geofenceTransition = geofencingEvent.GeofenceTransition; if (geofenceTransition != Geofence.NeverExpire) { IList <IGeofence> triggeringGeofences = geofencingEvent.TriggeringGeofences; var geofencesIds = GetGeofenceTransitionDetails(this, geofenceTransition, triggeringGeofences); LoadOffersInGeofences(geofencesIds); } else { // Log the error. MvxTrace.TaggedError(TAG, GetString(Resource.String.geofence_transition_invalid_type, new[] { new Java.Lang.Integer(geofenceTransition) })); } }
public Task <bool> Start() { MvxTrace.TaggedTrace(MvxTraceLevel.Diagnostic, "Geofencing", "Start"); var tcs = new TaskCompletionSource <bool>(); bool result = false; UIKit.UIApplication.SharedApplication.InvokeOnMainThread(async() => { result = await GeofencingUtil.RequestPermissionAsync(); if (result) { GeofencingProvider.UpdateRegionLeft += OnUpdateRegionLeft; GeofencingProvider.RegionEntered += OnRegionEntered; GeofencingProvider.InitGeoFencing(); await SetupRegions(); } tcs.TrySetResult(result); }); return(tcs.Task); }
protected virtual void StartMvvmCross(MvxIosViewPresenter presenter, MvxAsyncIosSetup setup) { Task.Run(async() => { try { await setup.InitializeAsync(); var startup = Mvx.Resolve <IMvxAppStart>(); InvokeOnMainThread(() => { startup.Start(); RequestNotificationAuthorization(); Initialized = true; OnInitialized?.Invoke(); }); #if DEBUG MvxTrace.TaggedTrace(MvxTraceLevel.Diagnostic, this.GetType().FullName, $"Ellapsed milliseconds after MvvmCross setup {Base.Core.ServicesDebug.StartupTimerService.Instance.EllapsedMilliseconds()}"); Base.Core.ServicesDebug.StartupTimerService.Instance.StopTimer(); #endif } catch (Exception ex) { MvxTrace.TaggedTrace(MvxTraceLevel.Error, this.GetType().FullName, ex.BuildAllMessagesAndStackTrace()); } }); }
public override void OnCreate() { base.OnCreate(); BuildGoogleApiClient(); MvxTrace.TaggedTrace(TAG, "Created"); }
public void StartRagingBeacons() { MvxTrace.TaggedTrace(TAG, "StartRagingBeacons"); if (_rangeNotifier != null) { return; } BEACONS_REGION_HEADER = $"beacons_{Context.PackageName}"; _beaconManager = BeaconManager.GetInstanceForApplication(this); _regionBootstrap = new RegionBootstrap(this, new AltBeaconOrg.BoundBeacon.Region(BEACONS_REGION_HEADER, null, null, null)); _powerSaver = new BackgroundPowerSaver(this); RegisterActivityLifecycleCallbacks(this); _rangeNotifier = new RangeNotifier(); //iBeacon _beaconManager.BeaconParsers.Add(new BeaconParser().SetBeaconLayout("m:2-3=0215,i:4-19,i:20-21,i:22-23,p:24-24")); //Estimote _beaconManager.BeaconParsers.Add(new BeaconParser().SetBeaconLayout(BeaconParser.EddystoneUidLayout)); _beaconManager.BeaconParsers.Add(new BeaconParser().SetBeaconLayout(BeaconParser.EddystoneTlmLayout)); _beaconManager.BeaconParsers.Add(new BeaconParser().SetBeaconLayout(BeaconParser.EddystoneUrlLayout)); _beaconManager.Bind(this); }
private void PurgeMessagesOfType(Type type) { lock (this) { Dictionary <Guid, BaseSubscription> messageSubscriptions; if (!_subscriptions.TryGetValue(type, out messageSubscriptions)) { return; } var deadSubscriptionIds = new List <Guid>(); foreach (var subscription in messageSubscriptions) { if (!subscription.Value.IsAlive) { deadSubscriptionIds.Add(subscription.Key); } } MvxTrace.TaggedTrace(GetType().Name, "Purging {0} subscriptions", deadSubscriptionIds.Count); foreach (var id in deadSubscriptionIds) { messageSubscriptions.Remove(id); } PublishSubscriberChangeMessage(type, messageSubscriptions); } }
protected override void TriggerFirstNavigate() { #if DEBUG MvxTrace.TaggedTrace(MvxTraceLevel.Diagnostic, this.GetType().FullName, $"Ellapsed milliseconds after MvvmCross started {Base.Core.ServicesDebug.StartupTimerService.Instance.EllapsedMilliseconds()}"); Core.ServicesDebug.StartupTimerService.Instance.StopTimer(); #endif base.TriggerFirstNavigate(); }
public virtual void DidEnterRegion(AltBeaconOrg.BoundBeacon.Region region) { MvxTrace.TaggedTrace(TAG, "DidEnterRegion {1}. SinceBoot: {0}", _haveDetectedBeaconsSinceBoot, region.UniqueId); if (!_haveDetectedBeaconsSinceBoot) { _haveDetectedBeaconsSinceBoot = true; } }
// thats an OVERLOAD!, just in case somebody reads way to fast ;) public bool ShowViewModel(MvxViewModelRequest request, bool viewModelShouldHandleError = true) { Action action = () => { MvxTrace.TaggedTrace("DroidNavigation", "Navigate requested"); _presenter.Show(request); }; return(RequestMainThreadAction(action)); }
public static void Trace(MvxTraceLevel level, string message, params object[] args) { if (level < TraceBindingLevel) { return; } MvxTrace.TaggedTrace(level, Tag, message, args); }
public bool RequestNavigate(MvxShowViewModelRequest request) { Action action = () => { MvxTrace.TaggedTrace("MacNavigation", "Navigate requested"); _presenter.Show(request); }; return RequestMainThreadAction(action); }
public bool RequestClose(IMvxViewModel toClose) { Action action = () => { MvxTrace.TaggedTrace("MacNavigation", "Navigate back requested"); _presenter.Close(toClose); }; return RequestMainThreadAction(action); }
public bool ShowViewModel(MvxViewModelRequest request) { Action action = () => { MvxTrace.TaggedTrace("UnityNavigation", "Navigate requested"); _presenter.Show(request); }; return(RequestMainThreadAction(action)); }
protected bool RequestClose(IMvxViewModel toClose) { MvxTrace.TaggedTrace("Navigation", "Close requested"); if (ViewDispatcher != null) { return(ViewDispatcher.RequestClose(toClose)); } return(false); }
public bool ChangePresentation(MvxPresentationHint hint) { Action action = () => { MvxTrace.TaggedTrace("MacNavigation", "Change presentation requested"); this._presenter.ChangePresentation(hint); }; return(this.RequestMainThreadAction(action)); }
private string[] GetGeofenceTransitionDetails(Context context, int geofenceTransition, IList <IGeofence> triggeringGeofences) { string geofenceTransitionString = GetTransitionString(geofenceTransition); var triggeringGeofencesIdsList = triggeringGeofences.Select(x => x.RequestId).ToArray(); MvxTrace.TaggedTrace(TAG, geofenceTransitionString + ": " + string.Join(", ", triggeringGeofencesIdsList)); return(triggeringGeofencesIdsList); }
public void OnLocationChanged(global::Android.Locations.Location location) { if (_googleApiClient == null || !_googleApiClient.IsConnected) { return; } UpdateRegions(location); MvxTrace.TaggedTrace(TAG, string.Format("OnLocationChanged Lat {0} : Long {1} – Accuracy {2} : Speed {3}", location.Latitude, location.Longitude, location.Accuracy, location.Speed)); }
public bool ShowViewModel(MvxViewModelRequest request) { Action action = () => { MvxTrace.TaggedTrace("iOSNavigation", "Navigate requested"); //IT seems that here is a problem in the stack. this._presenter.Show(request); }; return(this.RequestMainThreadAction(action)); }
protected virtual async void OnRegionEntered(object sender, string id) { try { await AreaService.Instance.ActivateRegionBy(id); } catch (Exception ex) { MvxTrace.TaggedTrace(MvxTraceLevel.Error, "Geofencing", ex.BuildAllMessagesAndStackTrace()); } }
private void HandleResult(Statuses status, string message) { if (status.IsSuccess) { MvxTrace.TaggedTrace(TAG, message); } else { var errorMessage = GeofenceErrorMessages.GetErrorString(Application.Context, status.StatusCode); MvxTrace.TaggedError(TAG, errorMessage); } }
private void DestroyService() { if (_googleApiClient != null && _googleApiClient.IsConnected) { LocationServices.FusedLocationApi.RemoveLocationUpdates(_googleApiClient, this); _googleApiClient?.Disconnect(); } _geofenceList = new List <IGeofence>(); MvxTrace.TaggedTrace(TAG, "Service been destroyed"); }
public void Load() { Mvx.RegisterSingleton <IGeofencingService>(() => new GeofencingService()); try { Mvx.Resolve <IGeofencingService>().Start(); } catch (Exception ex) { MvxTrace.TaggedTrace("Geofencing", ex.BuildAllMessagesAndStackTrace()); } }
public void Load() { Mvx.RegisterSingleton <IBeaconsScanService>(() => new BeaconsScanService()); try { Mvx.Resolve <IBeaconsScanService>().Start(); } catch (Exception ex) { MvxTrace.TaggedTrace("Beacons", ex.BuildAllMessagesAndStackTrace()); } }
protected bool RequestNavigate(Type viewModelType, IDictionary <string, string> parameterValues, bool clearTop, MvxRequestedBy requestedBy) { MvxTrace.TaggedTrace("Navigation", "Navigate to " + viewModelType.Name + " with args"); if (ViewDispatcher != null) { return(ViewDispatcher.RequestNavigate(new MvxShowViewModelRequest( viewModelType, parameterValues, clearTop, requestedBy))); } return(false); }
public async Task Stop() { MvxTrace.TaggedTrace(MvxTraceLevel.Error, "Geofencing", "Stop"); var result = await GeofencingUtil.RequestPermissionAsync(); if (result) { GeofencingProvider.UpdateRegionLeft -= OnUpdateRegionLeft; GeofencingProvider.RegionEntered -= OnRegionEntered; GeofencingProvider.SetRegions(new System.Collections.Generic.List <CoreLocation.CLCircularRegion>()); } }
public Task <Coordinates> GetCurrentLocation() { var tcs = new TaskCompletionSource <Coordinates>(); //плагин геолокации работает только в главном потоке Mvx.Resolve <IMvxMainThreadDispatcher>().RequestMainThreadAction(async() => { Coordinates location = default(Coordinates); var hasPermission = await Mvx.Resolve <IPermissionsService>().CheckPermission(Permission.LocationWhenInUse); if (hasPermission) { Position position = null; try { var locator = CrossGeolocator.Current; locator.DesiredAccuracy = 100; position = await locator.GetLastKnownLocationAsync(); if (position == null && locator.IsGeolocationAvailable && locator.IsGeolocationEnabled) { position = await locator.GetPositionAsync(TimeSpan.FromSeconds(20), null, true); } } catch (Exception ex) { MvxTrace.TaggedTrace(MvxTraceLevel.Error, nameof(LocationService), () => ex.BuildAllMessagesAndStackTrace()); } if (position != null) { var output = string.Format("Time: {0} \nLat: {1} \nLong: {2} \nAltitude: {3} \nAltitude Accuracy: {4} \nAccuracy: {5} \nHeading: {6} \nSpeed: {7}", position.Timestamp, position.Latitude, position.Longitude, position.Altitude, position.AltitudeAccuracy, position.Accuracy, position.Heading, position.Speed); MvxTrace.TaggedTrace(MvxTraceLevel.Diagnostic, nameof(LocationService), () => output); location = (CurrentOrLastLocation = new Coordinates { Latitude = position.Latitude, Longitude = position.Longitude }); } } tcs.TrySetResult(location); }); return(tcs.Task); }
private static void LocationManager_RegionLeft(object sender, CLRegionEventArgs e) { MvxTrace.TaggedTrace("Geofencing", "Left region " + e.Region.Identifier); if (e.Region.Identifier == USER_REGION_HEADER) { UpdateRegionLeft?.Invoke(null, EventArgs.Empty); return; } if (!e.Region.Identifier.StartsWith(GEO_REGION_HEADER)) { return; //TODO On Region Lefted } }
public override void OnTaskRemoved(Intent rootIntent) { var restartServiceIntent = new Intent(Application.Context, this.Class); restartServiceIntent.SetPackage(Application.Context.PackageName); var restartServicePendingIntent = PendingIntent.GetService(Application.Context, 3, restartServiceIntent, PendingIntentFlags.OneShot); var alarmService = (AlarmManager)Application.Context.GetSystemService(Context.AlarmService); alarmService.Set( AlarmType.RtcWakeup, SystemClock.CurrentThreadTimeMillis() + 1000, restartServicePendingIntent); MvxTrace.TaggedTrace(TAG, "Start after removed"); }
public override void OnReceive(Context context, Intent intent) { var restartServiceIntent = new Intent(Application.Context, typeof(GeofencingIntentService)); restartServiceIntent.SetPackage(Application.Context.PackageName); PendingIntent restartServicePendingIntent = PendingIntent.GetService(Application.Context, 3, restartServiceIntent, PendingIntentFlags.OneShot); AlarmManager alarmService = (AlarmManager)Application.Context.GetSystemService(Context.AlarmService); alarmService.Set( AlarmType.RtcWakeup, SystemClock.CurrentThreadTimeMillis() + 1000, restartServicePendingIntent); MvxTrace.TaggedTrace(TAG, "Start after boot completed"); }