Pinpoint SDK #

• Introduction

• Features

• Getting Started

  • Requirements

  • Supported Platforms

  • Setup Environment

• Usage

  • Migration from geolocator

  • Example

  • API

• License

Introduction #

The Pinpoint SDK is a cross-platform (Android/iOS) Flutter plugin for Ultra-Wideband (UWB) positioning with Pinpoint's technology.

Note: this a prerelease and is only meant for wrapping the functions of the geolocator package. It does not yet include any Pinpoint functionality.

This plugin in based on version 13.0.3 of geolocator.

The integration of navigation based on Pinpoint's technology will be included in the next release.

Features #

• Get the last known location;
• Get the current location of the device
• Get continuous location updates
• Check if location services are enabled on the device
• Calculate the distance (in meters) between two geocoordinates
• Calculate the bearing between two geocoordinates

Getting started #

Requirements #

• Flutter (minimum version: 3.27.0)
• Visual Studio Code (minimum version: 1.92.2) or Android Studio (minimum version: Android Studio Giraffe | 2022.3.1)

Supported Platforms #

• Android (minimum Android 10, API level 29)
• iOS (minimum 11)

Setup Environment #

To add the pinpoint_sdk to your Flutter application read the install instructions. Below are some Android and iOS specifics that are required for the plugin to work correctly.

android.useAndroidX=true
android.enableJetifier=true

android {
  compileSdkVersion 35
}

android {
  compileSdk = 35
}

defaultConfig {
  minSdkVersion 29
}

defaultConfig {
  minSdk = 29
}

-keep class com.lib.flutter_blue_plus.* { *; }
-keep public class de.IPinpointPositionListener$Stub.** { *; }
-keep public class de.IPinpointPositionListener.** { *; }
-keep public class de.pinpoint.ServiceTest.** { *; }
-ignorewarnings

android {
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(
                    'proguard-android-optimize.txt'),
                    'proguard-rules.pro'

        }
    }
}

android {
    buildTypes{
        release {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
  }
}

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

<key>NSLocationWhenInUseUsageDescription</key>
<string>This app needs access to location when open.</string>

post_install do |installer|
  installer.pods_project.targets.each do |target|
    if target.name == "geolocator_apple"
      target.build_configurations.each do |config|
        config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= ['$(inherited)', 'BYPASS_PERMISSION_LOCATION_ALWAYS=1']
      end
    end
  end
end

<key>NSLocationTemporaryUsageDescriptionDictionary</key>
<dict>
  <key>YourPurposeKey</key>
  <string>The example App requires temporary access to the device&apos;s precise location.</string>
</dict>

Usage #

1. Install the Pinpoint SDK by following the instructions from Getting started. Pay attention to the platform specific requirements (Android, iOS).
2. Import it:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';

3. Call the function initGeolocator to enable the wrapping of geolocator. This function only needs to be called once at a central place, e.g. in the main of your app:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
void main () {
  // wraps original GeolocatorPlatform instance
  initGeolocator();
  runApp(const GeolocatorApp());
}

Migration from geolocator #

1. Follow the steps from above (Usage). Pay attention that under Android you can only use the permission ACCESS_FINE_LOCATION.ACCESS_COARSE_LOCATIONis not supported.

2. Remove geolocator from the dependencies of your app by deleting it from the dependencies in your pubspec.yaml or by calling flutter pub remove geolocator

3. Replace the original imports of package:geolocator/geolocator.dart with package:pinpoint_sdk/pinpoint_sdk.dart

Example #

The code below shows an example on how to acquire the current position of the device, including checking if the location services are enabled and checking / requesting permission to access the position of the device:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';

// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

/// Determine the current position of the device.
///
/// When the location services are not enabled or permissions
/// are denied the `Future` will return an error.
Future<Position> _determinePosition() async {
  bool serviceEnabled;
  LocationPermission permission;

  // Test if location services are enabled.
  serviceEnabled = await Geolocator.isLocationServiceEnabled();
  if (!serviceEnabled) {
    // Location services are not enabled don't continue
    // accessing the position and request users of the 
    // App to enable the location services.
    return Future.error('Location services are disabled.');
  }

  permission = await Geolocator.checkPermission();
  if (permission == LocationPermission.denied) {
    permission = await Geolocator.requestPermission();
    if (permission == LocationPermission.denied) {
      // Permissions are denied, next time you could try
      // requesting permissions again (this is also where
      // Android's shouldShowRequestPermissionRationale 
      // returned true. According to Android guidelines
      // your App should show an explanatory UI now.
      return Future.error('Location permissions are denied');
    }
  }
  
  if (permission == LocationPermission.deniedForever) {
    // Permissions are denied forever, handle appropriately. 
    return Future.error(
      'Location permissions are permanently denied, we cannot request permissions.');
  } 

  // When we reach here, permissions are granted and we can
  // continue accessing the position of the device.
  return await Geolocator.getCurrentPosition();
}

API #

Geolocation #

Current location

To query the current location of the device simply make a call to the getCurrentPosition method. You can finetune the results by specifying the following parameters:

• desiredAccuracy: the accuracy of the location data that your app wants to receive;
• timeLimit: the maximum amount of time allowed to acquire the current location. When the time limit is passed a TimeoutException will be thrown and the call will be cancelled. By default no limit is configured.

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

final LocationSettings locationSettings = LocationSettings(
  accuracy: LocationAccuracy.high,
  distanceFilter: 100,
);

Position position = await Geolocator.getCurrentPosition(locationSettings: locationSettings);

Last known location

To query the last known location retrieved stored on the device you can use the getLastKnownPosition method (note that this can result in a null value when no location details are available):

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

Position? position = await Geolocator.getLastKnownPosition();

Listen to location updates

To listen for location changes you can call the getPositionStream to receive stream you can listen to and receive position updates. You can finetune the results by specifying the following parameters:

• accuracy: the accuracy of the location data that your app wants to receive;
• distanceFilter: the minimum distance (measured in meters) a device must move horizontally before an update event is generated;
• timeLimit: the maximum amount of time allowed between location updates. When the time limit is passed a TimeoutException will be thrown and the stream will be cancelled. By default no limit is configured.

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

final LocationSettings locationSettings = LocationSettings(
  accuracy: LocationAccuracy.high,
  distanceFilter: 100,
);
StreamSubscription<Position> positionStream = Geolocator.getPositionStream(locationSettings: locationSettings).listen(
    (Position? position) {
        print(position == null ? 'Unknown' : '${position.latitude.toString()}, ${position.longitude.toString()}');
    });

Platform specific location settings #

In certain situation it is necessary to specify some platform specific settings. This can be accomplished using the platform specific AndroidSettings or AppleSettings classes. When using a platform specific class, the platform specific package of geolocator (geolocator_android for Android or geolocator_apple for iOS) must be imported as well. For example:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();
import 'package:geolocator_android/geolocator_android.dart';
import 'package:geolocator_apple/geolocator_apple.dart';

late LocationSettings locationSettings;

if (defaultTargetPlatform == TargetPlatform.android) {
  locationSettings = AndroidSettings(
      accuracy: LocationAccuracy.high,
      distanceFilter: 100,
      forceLocationManager: true,
      intervalDuration: const Duration(seconds: 10),
      //(Optional) Set foreground notification config to keep the app alive 
      //when going to the background
      foregroundNotificationConfig: const ForegroundNotificationConfig(
        notificationText:
        "Example app will continue to receive your location even when you aren't using it",
        notificationTitle: "Running in Background",
        enableWakeLock: true,
      )
  );
} else if (defaultTargetPlatform == TargetPlatform.iOS) {
  locationSettings = AppleSettings(
    accuracy: LocationAccuracy.high,
    activityType: ActivityType.fitness,
    distanceFilter: 100,
    pauseLocationUpdatesAutomatically: true,
    // Only set to true if our app will be started up in the background.
    showBackgroundLocationIndicator: false,
  );
} else {
  locationSettings = LocationSettings(
    accuracy: LocationAccuracy.high,
    distanceFilter: 100,
  );
}

// supply location settings to getCurrentPosition
Position position = await Geolocator.getCurrentPosition(locationSettings: locationSettings);

// supply location settings to getPositionStream
StreamSubscription<Position> positionStream = Geolocator.getPositionStream(locationSettings: locationSettings).listen(
        (Position? position) {
      print(position == null ? 'Unknown' : '${position.latitude.toString()}, ${position.longitude.toString()}');
    });

Location accuracy (Android and iOS 14+ only)

To query if a user enabled Approximate location fetching or Precise location fetching, you can call the Geolocator().getLocationAccuracy() method. This will return a Future<LocationAccuracyStatus>, which when completed contains a LocationAccuracyStatus.reduced if the user has enabled Approximate location fetching or LocationAccuracyStatus.precise if the user has enabled Precise location fetching. When calling getLocationAccuracy before the user has given permission, the method will return LocationAccuracyStatus.reduced by default. On iOS 13 or below, the method getLocationAccuracy will always return LocationAccuracyStatus.precise, since that is the default value for iOS 13 and below.

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();
var accuracy = await Geolocator.getLocationAccuracy();

Location service information

To check if location services are enabled you can call the isLocationServiceEnabled method:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();
bool isLocationServiceEnabled  = await Geolocator.isLocationServiceEnabled();

To listen for service status changes you can call the getServiceStatusStream. This will return a Stream<ServiceStatus> which can be listened to, to receive location service status updates.

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();
StreamSubscription<ServiceStatus> serviceStatusStream = Geolocator.getServiceStatusStream().listen(
    (ServiceStatus status) {
        print(status);
    });

Permissions #

If you want to check if the user already granted permissions to acquire the device's location you can make a call to the checkPermission method:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

LocationPermission permission = await Geolocator.checkPermission();

If you want to request permission to access the device's location you can call the requestPermission method:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

LocationPermission permission = await Geolocator.requestPermission();

Possible results from the checkPermission and requestPermission methods are:

Note: Android can only return whileInUse, always or denied when checking permissions. Due to limitations on the Android OS it is not possible to determine if permissions are denied permanently when checking permissions. Using a workaround the geolocator is only able to do so as a result of the requestPermission method. More information can be found in geolocator's wiki.

Settings #

In some cases it is necessary to ask the user and update their device settings. For example when the user initially permanently denied permissions to access the device's location or if the location services are not enabled (and, on Android, automatic resolution didn't work). In these cases you can use the openAppSettings or openLocationSettings methods to immediately redirect the user to the device's settings page.

On Android the openAppSettings method will redirect the user to the App specific settings where the user can update necessary permissions. The openLocationSettings method will redirect the user to the location settings where the user can enable/ disable the location services.

On iOS we are not allowed to open specific setting pages so both methods will redirect the user to the Settings App from where the user can navigate to the correct settings category to update permissions or enable/ disable the location services.

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

await Geolocator.openAppSettings();
await Geolocator.openLocationSettings();

Utility methods #

To calculate the distance (in meters) between two geocoordinates you can use the distanceBetween method. The distanceBetween method takes four parameters:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

double distanceInMeters = Geolocator.distanceBetween(52.2165157, 6.9437819, 52.3546274, 4.8285838);

If you want to calculate the bearing between two geocoordinates you can use the bearingBetween method. The bearingBetween method also takes four parameters:

import 'package:pinpoint_sdk/pinpoint_sdk.dart';
// call init function for wrapping of Geolocator (only needs to be done once at a central place, e.g. in main of app)
initGeolocator();

double bearing = Geolocator.bearingBetween(52.2165157, 6.9437819, 52.3546274, 4.8285838);

Location accuracy #

Android

On Android, the LocationAccuracy enum controls the accuracy of the location data the app wants to receive. It also provides control over the priority given to the location stream. This can be confusing, as a priority of lowest might not return any location, while one might expect it to give the quickest responses. The table below outlines the priority and its meaning per accuracy option:

iOS

On iOS, the LocationAccuracy enum controls the accuracy of the location data the app wants to receive. It also provides control on the battery consumption of the device: the more detailed data is requested, the larger the impact on the battery consumption. More details can be found on Apple's documentation. The table below shows how the LocationAccuracy values map to the native iOS accuracy settings.

License #

This package is licensed under a proprietary license with MIT licensed components. Please refer to the LICENSE file for more details.