Capacitor plugin

npm install --save capacitor-radar

npx cap sync

✔ Updating Android plugins
  Found 1 Capacitor plugin for android:
    capacitor-radar
✔ update android
...
✔ Updating iOS plugins
  Found 1 Capacitor plugin for ios:
    capacitor-radar
✔ Updating iOS native dependencies with "pod install" (may take several minutes)
✔ update ios

import Capacitor
import RadarSDK

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        Radar.initialize(publishableKey: publishableKey)
        return true
    }
}

implementation "com.google.android.gms:play-services-location:21.0.1"

import android.os.Bundle;

import com.getcapacitor.BridgeActivity;
import io.radar.sdk.Radar;

public class MainActivity extends BridgeActivity {

    @Override 
    public void onCreate(Bundle savedInstanceState) {
        Radar.initialize(this, publishableKey);
        super.onCreate(savedInstanceState);
    }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android">

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

</manifest>

import { Radar } from 'capacitor-radar';

Radar.setUserId(userId);

Radar.setMetadata(metadata);

Radar.setDescription(description);

Radar.getLocationPermissionsStatus().then((result) => { 
    // do something with result.status
});

Radar.requestLocationPermissions({ background: true });

Radar.trackOnce().then((result) => { 
    // do something with result.location, result.events, result.user.geofences
}).catch((err) => { 
    // optionally, do something with err
});

Radar.startTrackingEfficient();

Radar.startTrackingResponsive();

Radar.startTrackingContinuous();

// optionally adjust foreground service options for android
Radar.setForegroundServiceOptions({ 
    options: { 
        text: "Location tracking started", 
        title: "Location updates", 
        updatesOnly: false,
        importance: 2, 
        activity: 'com.yourapp.MainActivity' 
    }
});

Radar.startTrackingCustom({ 
    options: { 
        desiredStoppedUpdateInterval: 180, 
        fastestStoppedUpdateInterval: 15, 
        desiredMovingUpdateInterval: 60,
        fastestMovingUpdateInterval: 15, 
        desiredSyncInterval: 10,
        desiredAccuracy: 'high', 
        stopDuration: 140, 
        stopDistance: 70, 
        sync: 'all', 
        replay: 'none', 
        useStoppedGeofence: true, 
        showBlueBar: true,
        foregroundServiceEnabled: true 
    }
});

Radar.isTracking();

Radar.stopTracking();

Radar.addListener('clientLocation', (result) => { 
    // do something with result.location, result.stopped, result.source
});

Radar.addListener('location', (result) => { 
    // do something with result.location, result.user
});

Radar.addListener('events', (result) => { 
    // do something with result.events, result.user
});

Radar.addListener('error', (result) => { 
    // do something with result.err
});

Radar.addListener('log', (result) => { 
    // do something with result.message
});

Radar.mockTracking({ 
    origin: { 
        latitude: 40.714708, 
        longitude: -74.035807 
    }, 
    destination: { 
        latitude: 40.717410, 
        longitude: -74.053334 
    }, 
    mode: 'car', 
    steps: 10, 
    interval: 3
});

Radar.startTrip({
    options: { 
        tripOptions: { 
            externalId: '299',
            destinationGeofenceTag: 'store', 
            destinationGeofenceExternalId: '123', 
            mode: 'car' as RadarRouteMode 
        }, 
        trackingOptions: {
            desiredStoppedUpdateInterval: 30, 
            fastestStoppedUpdateInterval: 30,
            desiredMovingUpdateInterval: 30, 
            fastestMovingUpdateInterval: 30,
            desiredSyncInterval: 20, 
            desiredAccuracy: 'high' as RadarTrackingOptionsDesiredAccuracy, 
            stopDuration: 0, 
            stopDistance: 0,
            replay: "none", 
            sync: "all", 
            showBlueBar: true, 
            syncGeofences: false, 
            syncGeofencesLimit: 0, 
            beacons: false, 
            foregroundServiceEnabled: true
        }
    }
}).then((result) => { 
    // do something with result.status
});

Radar.completeTrip().then((result) => { 
    // do something with result.status
});

Radar.cancelTrip().then((result) => { 
    // do something with result.status
});

Radar.trackOnce({ 
    latitude: 39.2904, 
    longitude: -76.6122, 
    accuracy: 65
}, (result) => { 
    // do something with result.status, result.location, result.events, result.user
});

Radar.getLocation((result) => { 
    // do something with result.status, result.location
});

Radar.getContext({ 
    latitude: 40.783826, 
    longitude: -73.975363, 
    accuracy: 65
}, (result) => { 
    // do something with result.status, result.context
});

Radar.geocode({ 
    query: '20 jay st brooklyn ny'
}, (result) => { 
    // do something with result.status, result.addresses
});

Radar.reverseGeocode({ 
    latitude: 40.783826, 
    longitude: -73.975363
}, (result) => { 
    // do something with result.status, result.addresses
});

Radar.ipGeocode((result) => { 
    // do something with result.status, result.address
});

Radar.autocomplete({ 
    query: 'brooklyn roasting', 
    near: { 
        latitude: 40.783826, 
        longitude: -73.975363 
    }, 
    limit: 10
}, (result) => { 
    // do something with result.status, result.addresses
});

Radar.searchGeofences({ 
    radius: 1000, 
    tags: ['venue'], 
    limit: 10
}, (result) => { 
    // do something with result.status, result.geofences
});

Radar.searchPlaces({ 
    near: { 
        latitude: 40.783826, 
        longitude: -73.975363 
    }, 
    radius: 1000, 
    chains: ['starbucks'], 
    limit: 10
}, (result) => { 
    // do something with result.status, result.places
});

Radar.getDistance({ 
    origin: { 
        latitude: 40.78382, 
        longitude: -73.97536 
    }, 
    destination: { 
        latitude: 40.70390, 
        longitude: -73.98670 
    }, 
    modes: [ 'foot', 'car' ], 
    units: 'imperial'
}, (result) => { 
    // do something with result.status, result.routes
});