listenLocation method

Stream<Location> listenLocation({ LocationAccuracy mode = LocationAccuracy.Low, bool? needAddress, Duration? timeout, int? interval, double? distanceFilter, })

连续获取定位信息

选择定位模式mode, 设置定位同时是否需要返回地址描述needAddress, 设置定位请求超时时间，默认为30秒timeout 设置定位间隔interval, 默认2000 ms， 设置是否开启定位缓存机制cacheEnable. distanceFilter ios only: 设置更新定位的最小偏移距离, 单位:米.

Implementation

Stream<Location> listenLocation({
  LocationAccuracy mode = LocationAccuracy.Low,
  bool? needAddress,
  Duration? timeout,
  int? interval,
  double? distanceFilter,
}) async* {
  _locationController ??= StreamController<Location>();

  if (Platform.isAndroid) {
    final listener =
        await com_amap_api_location_AMapLocationListener.anonymous__();
    listener.onLocationChanged = (location) async {
      if (!_locationController!.isClosed) {
        _locationController!.add(
          Location(
            address: await location!.getAddress(),
            latLng: LatLng(
              await location.getLatitude() ?? 0,
              await location.getLongitude() ?? 0,
            ),
            altitude: await location.getAltitude(),
            bearing: await location.getBearing(),
            country: await location.getCountry(),
            province: await location.getProvince(),
            city: await location.getCity(),
            cityCode: await location.getCityCode(),
            adCode: await location.getAdCode(),
            district: await location.getDistrict(),
            poiName: await location.getPoiName(),
            street: await location.getStreet(),
            streetNumber: await location.getStreetNum(),
            aoiName: await location.getAoiName(),
            accuracy: await location.getAccuracy(),
            speed: await location.speed,
          ),
        );
      }
    };
    await _androidClient?.setLocationListener(listener);

    // 创建选项
    final options =
        await com_amap_api_location_AMapLocationClientOption.create__();
    // 设置连续定位
    await options.setOnceLocation(false);
    // 设置定位模式
    switch (mode) {
      // 高精度定位模式：会同时使用网络定位和GPS定位，优先返回最高精度的定位结果，以及对应的地址描述信息。
      case LocationAccuracy.High:
        await options.setLocationMode(
            com_amap_api_location_AMapLocationClientOption_AMapLocationMode
                .Hight_Accuracy);
        break;
      // 低功耗定位模式：不会使用GPS和其他传感器，只会使用网络定位（Wi-Fi和基站定位）；
      case LocationAccuracy.Low:
        await options.setLocationMode(
            com_amap_api_location_AMapLocationClientOption_AMapLocationMode
                .Battery_Saving);
        break;
      case LocationAccuracy.DeviceSensor:
        await options.setLocationMode(
            com_amap_api_location_AMapLocationClientOption_AMapLocationMode
                .Device_Sensors);
        break;
    }
    // 是否返回地址描述
    if (needAddress != null) await options.setNeedAddress(needAddress);
    // 设置定位请求超时时间，默认为30秒。
    if (timeout != null) await options.setHttpTimeOut(timeout.inSeconds);
    // 设置定位间隔
    if (interval != null) await options.setInterval(interval);

    await options.setSensorEnable(true);

    // 设置选项
    await _androidClient?.setLocationOption(options);

    // 开始定位
    await _androidClient?.startLocation();

    yield* _locationController!.stream;
  } else if (Platform.isIOS) {
    // 设置定位模式
    switch (mode) {
      // 高精度定位模式：会同时使用网络定位和GPS定位，优先返回最高精度的定位结果，以及对应的地址描述信息。
      case LocationAccuracy.High:
        await _iosClient?.set_desiredAccuracy(10);
        break;
      // 低功耗定位模式：不会使用GPS和其他传感器，只会使用网络定位（Wi-Fi和基站定位）；
      case LocationAccuracy.Low:
      case LocationAccuracy.DeviceSensor:
        await _iosClient?.set_desiredAccuracy(100);
        break;
    }
    // 设置定位请求超时时间，默认为30秒。
    if (timeout != null) {
      await _iosClient?.set_locationTimeout(timeout.inSeconds);
    }
    // 设定定位的最小更新距离
    if (distanceFilter != null) {
      await _iosClient?.set_distanceFilter(distanceFilter);
    }

    // 设置回调
    _iosLocationDelegate ??= await AMapLocationManagerDelegate.anonymous__();
    _iosLocationDelegate!.amapLocationManager_didUpdateLocation_reGeocode =
        (_, location, regeocode) async {
      final latitude = await location!.coordinate.then((it) => it.latitude);
      final longitude = await location.coordinate.then((it) => it.longitude);
      if (!_locationController!.isClosed) {
        _locationController!.add(Location(
          address: await regeocode?.get_formattedAddress(),
          latLng: LatLng(await latitude ?? 0, await longitude ?? 0),
          altitude: await location.altitude,
          bearing: await location.course,
          country: await regeocode?.get_country(),
          province: await regeocode?.get_province(),
          city: await regeocode?.get_city(),
          cityCode: await regeocode?.get_citycode(),
          adCode: await regeocode?.get_adcode(),
          district: await regeocode?.get_district(),
          poiName: await regeocode?.get_POIName(),
          street: await regeocode?.get_street(),
          streetNumber: await regeocode?.get_number(),
          aoiName: await regeocode?.get_AOIName(),
          accuracy: await location.horizontalAccuracy,
          speed: await location.speed,
        ));
      }
    };
    await _iosClient?.set_delegate(_iosLocationDelegate!);
    await _iosClient?.set_locatingWithReGeocode(true);
    await _iosClient?.startUpdatingLocation();

    yield* _locationController!.stream;
  }
}