Permissions

Request notification, App Tracking Transparency, and location permissions inside flows.

Configure Permissions First

Permission APIs require native configuration. Make sure you've configured the appropriate permissions in your Podfile (iOS) and AndroidManifest.xml (Android). See the Installation guide.

Notification Permissions#

checkNotificationPermission()#

Check the current notification permission status without prompting.

Mobana.checkNotificationPermission(): Promise<{ status, granted, settings? }>

Property	Type	Description
`status`	`string`	`granted`, `denied`, `blocked`, or `unavailable`
`granted`	`boolean`	Whether notifications are allowed
`settings`	`object`	iOS only: detailed settings (alert, badge, sound, etc.)

requestNotificationPermission()#

Request notification permission. Shows the system permission dialog.

Mobana.requestNotificationPermission(): Promise<boolean>

Example: Notification Permission Flow

flow.js

// Check current status first
const status = await Mobana.checkNotificationPermission();

if (status.granted) {
  // Already granted
  showNextStep();
} else if (status.status === 'blocked') {
  // User previously denied - show settings prompt
  document.getElementById('settings-prompt').style.display = 'block';
} else {
  // Can request permission
  document.getElementById('request-btn').addEventListener('click', async () => {
    const granted = await Mobana.requestNotificationPermission();
    
    if (granted) {
      Mobana.trackEvent('notification_permission_granted');
      Mobana.haptic('success');
    } else {
      Mobana.trackEvent('notification_permission_denied');
    }
    
    showNextStep();
  });
}

App Tracking Transparency#

checkATTPermission()#

Check the current ATT status without prompting. iOS only.

Mobana.checkATTPermission(): Promise<ATTStatus>

Property	Type	Description
`status`	`ATTStatus`	`authorized`, `denied`, `not-determined`, or `restricted`

requestATTPermission()#

Request App Tracking Transparency permission. Shows the system ATT dialog. iOS only.

Mobana.requestATTPermission(): Promise<ATTStatus>

Example: ATT Permission Flow

flow.js

// Only relevant on iOS
if (Mobana.getPlatform() === 'ios') {
  // Check current status
  const status = await Mobana.checkATTPermission();
  
  if (status === 'not-determined') {
    // Can request permission
    document.getElementById('att-explainer').style.display = 'block';
    
    document.getElementById('allow-tracking-btn').addEventListener('click', async () => {
      const result = await Mobana.requestATTPermission();
      
      Mobana.trackEvent('att_' + result); // att_authorized, att_denied, etc.
      showNextStep();
    });
  } else {
    // Already determined, move on
    showNextStep();
  }
} else {
  // Android - skip ATT
  showNextStep();
}

On Android, both ATT methods return authorized immediately since Android doesn't have ATT.

Location Permissions#

getLocationPermissionStatus()#

Get comprehensive location permission status.

Mobana.getLocationPermissionStatus(): Promise<LocationStatus>

Property	Type	Description
`foreground`	`string`	`granted`, `denied`, `blocked`, or `not_requested`
`background`	`string`	`granted`, `denied`, `blocked`, or `not_requested`
`precision`	`string`	`precise`, `coarse`, or `unknown`

requestLocationPermission()#

Request foreground location permission.

Mobana.requestLocationPermission(options?: { precision: 'precise' | 'coarse' }): Promise<string>

// Request precise location (default)
const result = await Mobana.requestLocationPermission();
// Or explicitly:
const result = await Mobana.requestLocationPermission({ precision: 'precise' });

// Request coarse/approximate location only
const result = await Mobana.requestLocationPermission({ precision: 'coarse' });
// On Android: requests ACCESS_COARSE_LOCATION instead of ACCESS_FINE_LOCATION
// On iOS: precision is controlled by user in the permission dialog

requestBackgroundLocationPermission()#

Request background location permission. Must have foreground permission first.

Mobana.requestBackgroundLocationPermission(): Promise<string>

// First request foreground location
const foregroundResult = await Mobana.requestLocationPermission();

if (foregroundResult === 'granted') {
  // Now can request background location
  const backgroundResult = await Mobana.requestBackgroundLocationPermission();
  
  if (backgroundResult === 'granted') {
    Mobana.trackEvent('background_location_granted');
  }
}

getCurrentLocation()#

Get the current device location. Requires location permission.

Mobana.getCurrentLocation(): Promise<LocationCoordinates>

Property	Type	Description
`latitude`	`number`	Latitude in degrees
`longitude`	`number`	Longitude in degrees
`accuracy`	`number`	Accuracy in meters
`altitude`	`number \| null`	Altitude in meters
`heading`	`number \| null`	Heading in degrees
`speed`	`number \| null`	Speed in m/s
`timestamp`	`number`	Unix timestamp

Example: Location Permission Flow

flow.js

// Request foreground location
async function requestLocation() {
  // Check current status
  const status = await Mobana.getLocationPermissionStatus();
  
  if (status.foreground === 'granted') {
    // Already have permission
    const coords = await Mobana.getCurrentLocation();
    handleLocation(coords);
    return;
  }
  
  if (status.foreground === 'blocked') {
    // User previously denied - need to go to settings
    showSettingsPrompt();
    return;
  }
  
  // Request permission
  const result = await Mobana.requestLocationPermission();
  
  if (result === 'granted') {
    Mobana.trackEvent('location_permission_granted');
    const coords = await Mobana.getCurrentLocation();
    handleLocation(coords);
  } else {
    Mobana.trackEvent('location_permission_denied');
    handleNoLocation();
  }
}

Opening Settings#

When permission is blocked, direct users to app settings:

// User needs to enable permission in settings
document.getElementById('open-settings-btn').addEventListener('click', () => {
  Mobana.openSettings();
});

Flow Events

Native Utilities