大数据安全>> BaiduMaps>> 返回
项目作者： dorisoy

项目描述 ：
Xamarin Android binding library for Baidumap sdk（5.3.2/6.4/7.0/7.1）
高级语言： C#
项目地址: git://github.com/dorisoy/BaiduMaps.git
创建时间： 2020-02-05T07:46:34Z
项目社区：https://github.com/dorisoy/BaiduMaps
开源协议：
下载


Xamarin.Forms.BaiduMaps

BaiduMap 地图和定位在Xamarin.Android/Xamarin.Forms 中的应用（5.3.2/6.4/7.0/7.1）

SDK 5.3.2/6.4/7.0/7.1 通用匹配绑定规则：

  1. <metadata>
  2.     <attr path="/api/package[@name='com.baidu.mapapi']/class[@name='VersionInfo']/field[@name='VERSION_INFO']"
  3.           name="name">VersionInformation</attr>
  5.     <attr path="/api/package[@name='com.baidu.location']/class[@name='Address']/field[@name='address']"
  6.           name="name">Addresses</attr>
  8.     <attr path="/api/package[@name='com.baidu.mapapi.map']/interface[@name='BaiduMap.OnMapStatusChangeListener']/method[@name='onMapStatusChangeStart' and count(parameter)=2 and parameter[1][@type='com.baidu.mapapi.map.MapStatus'] and parameter[2][@type='int']]"
  9.           name="managedName">OnMapStatusChangeStart2</attr>
  11.     <attr path="/api/package[@name='com.baidu.mapapi.search.poi']/interface[@name='OnGetPoiSearchResultListener']/method[@name='onGetPoiDetailResult' and parameter[1][@type='com.baidu.mapapi.search.poi.PoiDetailSearchResult']]"
  12.           name="managedName">OnGetPoiDetailResult2</attr>
  14.     <attr path="/api/package[@name='com.baidu.platform.comapi.map']/interface[@name='MapViewListener']/method[@name='onClickedItem' and count(parameter)=4 and parameter[1][@type='int'] and parameter[2][@type='int'] and parameter[3][@type='com.baidu.platform.comapi.basestruct.GeoPoint'] and parameter[4][@type='long']]"
  15.           name="managedName">OnClickedItem2</attr>
  17.     <attr path="/api/package[@name='com.baidu.platform.comapi.map']/interface[@name='NaviMapViewListener']/method[@name='onMapRenderModeChange' and count(parameter)=1 and parameter[1][@type='int']]"
  18.           name="managedName">OnMapRenderModeChange2</attr>
  20.     <attr path="/api/package[@name='com.baidu.platform.comapi.map']/interface[@name='NaviMapViewListener']/method[@name='onMapAnimationFinish' and count(parameter)=0]"
  21.           name="managedName">OnMapAnimationFinish2</attr>
  23.     <attr path="/api/package[@name='com.baidu.platform.comapi.map']/class[@name='ItemizedOverlay']/method[@name='compare' and count(parameter)=2 and parameter[1][@type='java.lang.Integer'] and parameter[2][@type='java.lang.Integer']]"
  24.           name="managedType">Java.Lang.Integer</attr>
  26.     <add-node path="/api/package/class[implements[@name='java.lang.Comparable']]">
  27.         <method name="compareTo"
  28.                 return="int"
  29.                 abstract="false"
  30.                 native="false"
  31.                 synchronized="false"
  32.                 static="false"
  33.                 final="false"
  34.                 deprecated="not deprecated"
  35.                 visibility="public">
  36.             <parameter name="o"
  37.                        type="java.lang.Object" />
  38.         </method>
  39.     </add-node>
  41.     <add-node path="/api/package/class[implements[@name='java.util.Comparator']]">
  42.         <method name="compare"
  43.                 return="int"
  44.                 abstract="false"
  45.                 native="false"
  46.                 synchronized="false"
  47.                 static="false"
  48.                 final="false"
  49.                 deprecated="not deprecated"
  50.                 visibility="public">
  51.             <parameter name="o1"
  52.                        type="java.lang.Object" />
  53.             <parameter name="o2"
  54.                        type="java.lang.Object" />
  55.         </method>
  56.     </add-node>
  58. </metadata>

如果你使用单独的定位服务，可以使用如下方式：
将定位SDK的SERVICE设置成为前台服务,使用Notification， 提高定位进程存活率

  1.    [Activity(Label = "App Name",
  2.         Icon = "@mipmap/ic_launcher",
  3.         Theme = "@style/MainTheme",
  4.         LaunchMode = LaunchMode.SingleTop,
  5.         ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
  6.     public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
  7.     {
  8.         private static LocationClient mLocationClient = null;
  9.         private MyLocationListener myLocationListener = new MyLocationListener();
  10.         private Notification mNotification;
  12.         protected override void OnCreate(Bundle bundle)
  13.         {
  15.             base.OnCreate(bundle);
  17.             TabLayoutResource = Resource.Layout.Tabbar;
  18.             ToolbarResource = Resource.Layout.Toolbar;
  20.             //动态请求用户允许使用定位权限
  21.             if (ContextCompat.CheckSelfPermission(this, Manifest.Permission.AccessFineLocation) != Permission.Granted)
  22.             {
  23.                 RequestPermissions(new string[] {
  24.                     Manifest.Permission.AccessNetworkState,
  25.                     Manifest.Permission.Internet,
  26.                     Manifest.Permission.WriteExternalStorage,
  27.                     Manifest.Permission.ReadExternalStorage,
  28.                     Manifest.Permission.AccessCoarseLocation,
  29.                     Manifest.Permission.AccessFineLocation,
  30.                     Manifest.Permission.AccessWifiState,
  31.                     Manifest.Permission.WriteSettings }, 1);
  32.             }
  33.             else
  34.             {
  35.                 InitLocation();
  36.                 InitNotification();
  37.             }
  39.             Xamarin.Forms.Forms.Init(this, bundle);
  40.             LoadApplication(new App(new AndroidInitializer()));
  41.         }
  43.         #region BaiduSDK
  46.         /// <summary>
  47.         /// 初始化配置
  48.         /// </summary>
  49.         private void InitLocation()
  50.         {
  51.             // 创建定位客户端
  52.             mLocationClient = new LocationClient(this);
  53.             myLocationListener = new MyLocationListener();
  54.             // 注册定位监听
  55.             mLocationClient.RegisterLocationListener(myLocationListener);
  56.             LocationClientOption mOption = new LocationClientOption();
  57.             //高精度
  58.             mOption.SetLocationMode(LocationClientOption.LocationMode.HightAccuracy);
  59.             //附近地址
  60.             mOption.SetIsNeedAddress(true);
  61.             // 可选，默认0，即仅定位一次，设置发起连续定位请求的间隔需要大于等于1000ms才是有效的
  62.             mOption.ScanSpan = 1000;
  63.             // 可选，默认gcj02，设置返回的定位结果坐标系，如果配合百度地图使用，建议设置为bd09ll;
  64.             mOption.CoorType = "bd09ll";
  65.             // 可选，默认false，设置是否开启Gps定位
  66.             mOption.OpenGps = true;
  67.             // 设置定位参数
  68.             mLocationClient.LocOption = mOption;
  69.         }
  70.         /// <summary>
  71.         /// 初始化前台服务
  72.         /// </summary>
  73.         private void InitNotification()
  74.         {
  75.             //设置后台定位
  76.             //android8.0及以上使用NotificationUtils
  77.             if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
  78.             {
  79.                 var notificationUtils = new NotificationUtils(this);
  80.                 var builder = notificationUtils.GetAndroidChannelNotification("MyAPP", "正在后台定位");
  81.                 mNotification = builder.Build();
  82.             }
  83.             else
  84.             {
  85.                 //获取一个Notification构造器
  86.                 Notification.Builder builder = new Notification.Builder(ApplicationContext, NotificationUtils.ANDROID_CHANNEL_ID);
  87.                 Intent nfIntent = new Intent(this, typeof(MainActivity));
  89.                 var currenttimemillis = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
  91.                 builder.SetContentIntent(PendingIntent.GetActivity(this, 0, nfIntent, 0))
  92.                     .SetContentTitle("定位服务")
  93.                     .SetSmallIcon(Android.Resource.Mipmap.SymDefAppIcon)
  94.                     .SetContentText("正在后台定位")
  95.                     .SetWhen(currenttimemillis);
  97.                 //获取构建好的Notification
  98.                 mNotification = builder.Build();
  99.             }
  100.         }
  101.         /// <summary>
  102.         /// 定义位置侦听
  103.         /// </summary>
  104.         private class MyLocationListener : BDAbstractLocationListener
  105.         {
  106.             public async override void OnReceiveLocation(BDLocation lct)
  107.             {
  108.                 if (lct == null)
  109.                     return;
  110.                 try
  111.                 {
  112.                     // 此处设置开发者获取到的方向信息，顺时针0-360
  113.                     var locData = new MyLocationData.Builder()
  114.                         .Accuracy(lct.Radius)
  115.                         .Direction(lct.Direction).Latitude(lct.Latitude)
  116.                         .Longitude(lct.Longitude)
  117.                         .Build();
  119.                     var msg = $"OnReceiveLocation:{lct.Latitude} Latitude:{lct.Longitude} Address:{lct.Country}{lct.Province}{lct.City}{lct.Address?.Street}";
  120.                     Log.Info("获取位置：", msg);
  122.                     //在这里可以实现你的本地存储
  123.                     //TODO...
  125.                 }
  126.                 catch (Java.Lang.Exception ex)
  127.                 {
  128.                     Android.Util.Log.Error("Exception", ex.Message);
  129.                 }
  130.             }
  131.         }
  133.         #endregion
  136.         protected override void OnStart()
  137.         {
  138.             base.OnStart();
  139.             //app 从后台唤醒，进入前台
  140.             activityActive++;
  141.             isBackground = false;
  142.             Android.Util.Log.Info("ACTIVITY", "程序从后台唤醒");
  143.             // 将定位SDK的SERVICE设置成为前台服务, 提高定位进程存活率
  144.             mLocationClient?.EnableLocInForeground(1, mNotification);
  145.             mLocationClient?.Start();
  146.         }
  148.         protected override void OnStop()
  149.         {
  150.             activityActive--;
  151.             if (activityActive == 0)
  152.             {
  153.                 //app 进入后台
  154.                 isBackground = true;
  155.                 //程序进入后台
  156.                 Android.Util.Log.Info("ACTIVITY", "程序进入后台");
  157.                 //关闭后台定位（true：通知栏消失；false：通知栏可手动划除）
  158.                 mLocationClient?.DisableLocInForeground(true);
  159.                 mLocationClient?.Stop();
  160.             }
  161.             base.OnStop();
  162.         }
  164.         protected override void OnDestroy()
  165.         {
  166.             base.OnDestroy();
  168.             // 关闭前台定位服务
  169.             mLocationClient?.DisableLocInForeground(true);
  171.             //取消之前注册的 BDAbstractLocationListener 定位监听函数
  172.             if (myLocationListener != null)
  173.                 mLocationClient?.UnRegisterLocationListener(myLocationListener);
  175.             //停止Baidu定位服务
  176.             mLocationClient?.Stop();
  177.         }
  179.         protected override void OnResume()
  180.         {
  181.             base.OnResume();
  182.         }
  184.         protected override void OnNewIntent(Intent intent)
  185.         {
  186.             base.OnNewIntent(intent);
  187.         }
  189.         protected override void OnActivityResult(int requestCode, Result resultCode, Intent intent)
  190.         {
  191.             base.OnActivityResult(requestCode, resultCode, intent);
  192.         }
  194.         public override void OnWindowFocusChanged(bool hasFocus)
  195.         {
  196.             base.OnWindowFocusChanged(hasFocus);
  197.             base.Window.SetBackgroundDrawable(null);
  198.         }
  200.         public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Permission[] grantResults)
  201.         {
  202.             base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
  203.             Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
  204.         }
  205.     }

在Xamarin.Forms 中，如果你使用基本地图视图模式，并且在加载地图时开始定位服务，你可以自定义一个MapView，定义一个IBaiduLocationService 接口用来创建位置服务，如下：

  1. public class Map : View
  2.     {
  3.         public Map()
  4.         {
  5.             VerticalOptions = HorizontalOptions = LayoutOptions.FillAndExpand;
  6.         }
  8.         /// <summary>
  9.         /// 地图坐标类型
  10.         /// </summary>
  11.         public static readonly BindableProperty MapTypeProperty = BindableProperty.Create(
  12.             propertyName: nameof(MapType),
  13.             returnType: typeof(MapType),
  14.             declaringType: typeof(Map),
  15.             defaultValue: MapType.Standard
  16.         );
  17.         public MapType MapType
  18.         {
  19.             get { return (MapType)GetValue(MapTypeProperty); }
  20.             set { SetValue(MapTypeProperty, value); }
  21.         }
  23.         /// <summary>
  24.         /// 使用跟踪模式
  25.         /// </summary>
  26.         public static readonly BindableProperty UserTrackingModeProperty = BindableProperty.Create(
  27.             propertyName: nameof(UserTrackingMode),
  28.             returnType: typeof(UserTrackingMode),
  29.             declaringType: typeof(Map),
  30.             defaultValue: UserTrackingMode.None
  31.         );
  32.         public UserTrackingMode UserTrackingMode
  33.         {
  34.             get { return (UserTrackingMode)GetValue(UserTrackingModeProperty); }
  35.             set { SetValue(UserTrackingModeProperty, value); }
  36.         }
  38.         /// <summary>
  39.         /// 显示用户位置
  40.         /// </summary>
  41.         public static readonly BindableProperty ShowUserLocationProperty = BindableProperty.Create(
  42.             propertyName: nameof(ShowUserLocation),
  43.             returnType: typeof(bool),
  44.             declaringType: typeof(Map),
  45.             defaultValue: true
  46.         );
  47.         public bool ShowUserLocation
  48.         {
  49.             get { return (bool)GetValue(ShowUserLocationProperty); }
  50.             set { SetValue(ShowUserLocationProperty, value); }
  51.         }
  53.         /// <summary>
  54.         /// 显示指南针
  55.         /// </summary>
  56.         public static readonly BindableProperty ShowCompassProperty = BindableProperty.Create(
  57.             propertyName: nameof(ShowCompass),
  58.             returnType: typeof(bool),
  59.             declaringType: typeof(Map),
  60.             defaultValue: true
  61.         );
  62.         public bool ShowCompass
  63.         {
  64.             get { return (bool)GetValue(ShowCompassProperty); }
  65.             set { SetValue(ShowCompassProperty, value); }
  66.         }
  68.         /// <summary>
  69.         /// 指南针位置
  70.         /// </summary>
  71.         public static readonly BindableProperty CompassPositionProperty = BindableProperty.Create(
  72.             propertyName: nameof(CompassPosition),
  73.             returnType: typeof(Point),
  74.             declaringType: typeof(Map),
  75.             defaultValue: new Point(40, 40)
  76.         );
  77.         public Point CompassPosition
  78.         {
  79.             get { return (Point)GetValue(CompassPositionProperty); }
  80.             set { SetValue(CompassPositionProperty, value); }
  81.         }
  83.        /// <summary>
  84.        /// 缩放比例
  85.        /// </summary>
  86.         public static readonly BindableProperty ZoomLevelProperty = BindableProperty.Create(
  87.             propertyName: nameof(ZoomLevel),
  88.             returnType: typeof(float),
  89.             declaringType: typeof(Map),
  90.             defaultValue: 11f
  91.         );
  92.         public float ZoomLevel
  93.         {
  94.             get { return (float)GetValue(ZoomLevelProperty); }
  95.             set { SetValue(ZoomLevelProperty, value); }
  96.         }
  98.         /// <summary>
  99.         /// 最小缩放比例
  100.         /// </summary>
  101.         public static readonly BindableProperty MinZoomLevelProperty = BindableProperty.Create(
  102.             propertyName: nameof(MinZoomLevel),
  103.             returnType: typeof(float),
  104.             declaringType: typeof(Map),
  105.             defaultValue: 3f
  106.         );
  107.         public float MinZoomLevel
  108.         {
  109.             get { return (float)GetValue(MinZoomLevelProperty); }
  110.             set { SetValue(MinZoomLevelProperty, value); }
  111.         }
  113.         /// <summary>
  114.         /// 最大缩放比例
  115.         /// </summary>
  116.         public static readonly BindableProperty MaxZoomLevelProperty = BindableProperty.Create(
  117.             propertyName: nameof(MaxZoomLevel),
  118.             returnType: typeof(float),
  119.             declaringType: typeof(Map),
  120.             defaultValue: 22f
  121.         );
  122.         public float MaxZoomLevel
  123.         {
  124.             get { return (float)GetValue(MaxZoomLevelProperty); }
  125.             set { SetValue(MaxZoomLevelProperty, value); }
  126.         }
  128.         /// <summary>
  129.         /// 中心位置
  130.         /// </summary>
  131.         public static readonly BindableProperty CenterProperty = BindableProperty.Create(
  132.             propertyName: nameof(Center),
  133.             returnType: typeof(Coordinate),
  134.             declaringType: typeof(Map),
  135.             defaultValue: new Coordinate(28.693, 115.958)
  136.         );
  137.         public Coordinate Center
  138.         {
  139.             get { return (Coordinate)GetValue(CenterProperty); }
  140.             set { SetValue(CenterProperty, value); }
  141.         }
  143.         /// <summary>
  144.         /// 显示缩放工具条
  145.         /// </summary>
  146.         public static readonly BindableProperty ShowScaleBarProperty = BindableProperty.Create(
  147.             propertyName: nameof(ShowScaleBar),
  148.             returnType: typeof(bool),
  149.             declaringType: typeof(Map),
  150.             defaultValue: true
  151.         );
  152.         public bool ShowScaleBar
  153.         {
  154.             get { return (bool)GetValue(ShowScaleBarProperty); }
  155.             set { SetValue(ShowScaleBarProperty, value); }
  156.         }
  158.         /// <summary>
  159.         /// 清除覆盖物
  160.         /// </summary>
  161.         public static readonly BindableProperty ClearOverlayProperty = BindableProperty.Create(
  162.            propertyName: nameof(ClearOverlay),
  163.            returnType: typeof(bool),
  164.            declaringType: typeof(Map),
  165.            defaultValue: false
  166.        );
  167.         public bool ClearOverlay
  168.         {
  169.             get { return (bool)GetValue(ClearOverlayProperty); }
  170.             set { SetValue(ClearOverlayProperty, value); }
  171.         }
  174.         /// <summary>
  175.         /// 显示缩放工具栏
  176.         /// </summary>
  177.         public static readonly BindableProperty ShowZoomControlProperty = BindableProperty.Create(
  178.             propertyName: nameof(ShowZoomControl),
  179.             returnType: typeof(bool),
  180.             declaringType: typeof(Map),
  181.             defaultValue: true
  182.         );
  183.         public bool ShowZoomControl
  184.         {
  185.             get { return (bool)GetValue(ShowZoomControlProperty); }
  186.             set { SetValue(ShowZoomControlProperty, value); }
  187.         }
  190.         public IBaiduLocationService LocationService { get; set; }
  191.         public IProjection Projection { get; set; }
  193.         public IList<Pin> Pins => pins;
  194.         private readonly ObservableCollection<Pin> pins = new ObservableCollection<Pin>();
  196.         public IList<Polyline> Polylines => polylines;
  197.         private readonly ObservableCollection<Polyline> polylines = new ObservableCollection<Polyline>();
  199.         public IList<Polygon> Polygons => polygons;
  200.         private readonly ObservableCollection<Polygon> polygons = new ObservableCollection<Polygon>();
  202.         public IList<Circle> Circles => circles;
  203.         private readonly ObservableCollection<Circle> circles = new ObservableCollection<Circle>();
  205.         public event EventHandler<MapBlankClickedEventArgs> BlankClicked;
  206.         public void SendBlankClicked(Coordinate pos)
  207.         {
  208.             BlankClicked?.Invoke(this, new MapBlankClickedEventArgs(pos));
  209.         }
  211.         public event EventHandler<MapPoiClickedEventArgs> PoiClicked;
  212.         public void SendPoiClicked(Poi poi)
  213.         {
  214.             PoiClicked?.Invoke(this, new MapPoiClickedEventArgs(poi));
  215.         }
  217.         public event EventHandler<MapDoubleClickedEventArgs> DoubleClicked;
  218.         public void SendDoubleClicked(Coordinate pos)
  219.         {
  220.             DoubleClicked?.Invoke(this, new MapDoubleClickedEventArgs(pos));
  221.         }
  223.         public event EventHandler<MapLongClickedEventArgs> LongClicked;
  224.         public void SendLongClicked(Coordinate pos)
  225.         {
  226.             LongClicked?.Invoke(this, new MapLongClickedEventArgs(pos));
  227.         }
  229.         public event EventHandler<EventArgs> Loaded;
  230.         public void SendLoaded()
  231.         {
  232.             Loaded?.Invoke(this, EventArgs.Empty);
  233.         }
  235.         public event EventHandler<EventArgs> StatusChanged;
  236.         public void SendStatusChanged()
  237.         {
  238.             StatusChanged?.Invoke(this, EventArgs.Empty);
  239.         }
  241.     }

在你的Android项目中 定义一个MapRenderer，继承自 ViewRenderer
在 OnElementChanged(ElementChangedEventArgs e) 中实现你的的接口 IBaiduLocationService

例如：

  1. protected override void OnElementChanged(ElementChangedEventArgs<Map> e)
  2. {
  3.     base.OnElementChanged(e);
  5.     if (null == Control)
  6.     {
  7.         SetNativeControl(new MapView(Context));
  8.     }
  10.     if (null != e.OldElement)
  11.     {
  12.         var oldMap = e.OldElement;
  13.         ((BaiduLocationServiceImpl)oldMap.LocationService).Unregister();
  14.         MapView oldMapView = Control;
  15.         oldMapView.OnDestroy();
  16.     }
  18.     if (null != e.NewElement)
  19.     {
  20.         Map.LocationService = new BaiduLocationServiceImpl(NativeMap, Context);
  21.     }
  22. }

在你的Xaml视图中启动或者停止服务：

  1. protected override void OnAppearing()
  2. {
  3.     try
  4.     {
  5.         base.OnAppearing();
  6.         //启动服务
  7.         map.LocationService?.Start();
  8.     }
  9.     catch (Exception ex)
  10.     {
  11.         Log.Write(ex);
  12.     }
  13. }
  14. protected override void OnDisappearing()
  15. {
  16.     try
  17.     {
  18.         base.OnDisappearing();
  19.         //停止服务
  20.         map.LocationService?.Stop();
  21.     }
  22.     catch (Exception ex)
  23.     {
  24.         Log.Write(ex);
  25.     }
  26. }

你也可以把SDK进程捆绑在主进程中，去掉 android:process=”:remote”，
然后把 LocationClientOption 的 ScanSpan 设置为0，默认0，即仅定位一次，然后自定义一个Service
在服务里定义频率执行间隔定位，当然，你可以使用WorkManager，使用PeriodicWorkRequest 定义一个Worker间隔定位， 例如：

  1. <service android:name="com.baidu.location.f"
  2.                  android:enabled="true"
  3.                  android:foregroundServiceType="location" ></service>
  1. [Service]
  2. public class LocationService : Service
  3. {
  4.         CancellationTokenSource _cts;
  5.         public override IBinder OnBind(Intent intent)
  6.         {
  7.             return null;
  8.         }
  10.         public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
  11.         {
  12.             _cts = new CancellationTokenSource();
  14.             Task.Run(async () => 
  15.             {
  16.                 Location locShared = null;
  17.                 try
  18.                 {
  19.                     locShared = new Location();
  20.                     await locShared.Run(_cts.Token);
  21.                 }
  22.                 catch (Android.OS.OperationCanceledException)
  23.                 {
  24.                 }
  25.                 finally
  26.                 {
  27.                     if (_cts.IsCancellationRequested)
  28.                     {
  29.                         var message = new StopServiceMessage();
  30.                         Device.BeginInvokeOnMainThread(() => MessagingCenter.Send(message, "ServiceStopped")
  31.                         );
  32.                     }
  33.                 }
  34.             }, _cts.Token);
  36.             return StartCommandResult.Sticky;
  37.         }
  39.         public override void OnDestroy()
  40.         {
  41.             if (_cts != null)
  42.             {
  43.                 _cts.Token.ThrowIfCancellationRequested();
  44.                 _cts.Cancel();
  45.             }
  46.             base.OnDestroy();
  47.         }
  48.     }
  50.     public class Location
  51.     {
  52.         readonly bool stopping = false;
  53.         public Location()
  54.         {
  55.             try
  56.             {
  57.                 //
  58.             }
  59.             catch (Java.Lang.Exception ex)
  60.             {
  61.                 Android.Util.Log.Error("上报", ex.Message);
  62.             }
  63.         }
  65.         public async Task Run(CancellationToken token)
  66.         {
  67.             await Task.Run(async () => 
  68.             {
  69.                 while (!stopping)
  70.                 {
  71.                     token.ThrowIfCancellationRequested();
  72.                     try
  73.                     {
  74.                         await Task.Delay(2000);
  75.                         System.Diagnostics.Debug.Print($"间隔2秒GPS定位一次.....");
  77.                         var request = new GeolocationRequest(GeolocationAccuracy.Best);
  78.                         var location = await Geolocation.GetLocationAsync(request);
  79.                         if (location != null)
  80.                         {
  81.                             GlobalSettings.Latitude = location.Latitude;
  82.                             GlobalSettings.Longitude = location.Longitude;
  83.                             System.Diagnostics.Debug.Print($"{location.Latitude} {location.Longitude}");
  84.                         }
  85.                     }
  86.                     catch (Exception)
  87.                     {
  88.                         Device.BeginInvokeOnMainThread(() =>
  89.                         {
  90.                             var errormessage = new LocationErrorMessage();
  91.                             MessagingCenter.Send(errormessage, "LocationError");
  92.                         });
  93.                     }
  94.                 }
  95.             }, token);
  96.         }
  97.     }

Screenshot