//See Android SDK Setup for details https://documentation.onesignal.com/docs/android-sdk-setup
OneSignal.initWithContext(this);
OneSignal.setAppId(ONESIGNAL_APP_ID);

//See iOS SDK Setup for details https://documentation.onesignal.com/docs/ios-sdk-setup
OneSignal.initWithLaunchOptions(launchOptions)
OneSignal.setAppId("YOUR_ONESIGNAL_APP_ID")

//See iOS SDK Setup for details https://documentation.onesignal.com/docs/ios-sdk-setup
[OneSignal initWithLaunchOptions:launchOptions];
[OneSignal setAppId:@"YOUR_ONESIGNAL_APP_ID"];

OneSignal.Default.Initialize("your_app_id");

/* This is for Expo Bare Workflows. If using a managed workflow,
see the Expo set up guide (https://documentation.onesignal.com/docs/react-native-expo-sdk-setup)*/

//Place code in your index.js/main.js
OneSignal.setAppId("YOUR-ONESIGNAL-APP-ID");

//Remove this method to stop OneSignal Debugging 
OneSignal.shared.setLogLevel(OSLogLevel.verbose, OSLogLevel.none);

OneSignal.shared.setAppId("YOUR_ONESIGNAL_APP_ID");

// The promptForPushNotificationsWithUserResponse function will show the iOS push notification prompt. We recommend removing the following code and instead using an In-App Message to prompt for notification permission
OneSignal.shared.promptUserForPushNotificationPermission().then((accepted) {
    print("Accepted permission: $accepted");
});

window.plugins.OneSignal.setAppId("YOUR_ONESIGNAL_APP_ID");

//The following options are available with increasingly more information:
//NONE, FATAL, ERROR, WARN, INFO, DEBUG, VERBOSE
OneSignal.setLogLevel(OneSignal.LOG_LEVEL.VERBOSE, OneSignal.LOG_LEVEL.NONE);

//The following options are available with increasingly more information: 
//.LL_NONE, .LL_FATAL, .LL_ERROR, .LL_WARN, .LL_INFO, .LL_DEBUG, .LL_VERBOSE.
OneSignal.setLogLevel(.LL_VERBOSE, visualLevel: .LL_NONE)

////The following options are available with increasingly more information: 
//ONE_S_LL_NONE, ONE_S_LL_FATAL, ONE_S_LL_ERROR, ONE_S_LL_WARN, ONE_S_LL_INFO, ONE_S_LL_DEBUG, ONE_S_LL_VERBOSE.
[OneSignal setLogLevel:ONE_S_LL_VERBOSE visualLevel:ONE_S_LL_NONE];

//The following options are available with increasingly more information:
//None, Fatal, Error, Warn, Info, Debug, Verbose
OneSignal.Default.LogLevel = LogLevel.Info;
OneSignal.Default.AlertLevel = LogLevel.Error;

//The following options are available with increasingly more information: 
//0 = NONE, 1 = FATAL, 2 = ERROR, 3 = WARN, 4 = INFO, 5 = DEBUG, 6 = VERBOSE
OneSignal.setLogLevel(6, 0);

//The following options are available with increasingly more information:
//none, fatal, error, warn, info, debug, verbose
OneSignal.shared.setLogLevel(OSLogLevel.verbose, OSLogLevel.none);

//The following options are available with increasingly more information: 
//0 = NONE, 1 = FATAL, 2 = ERROR, 3 = WARN, 4 = INFO, 5 = DEBUG, 6 = VERBOSE
// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.setLogLevel({logLevel: 6, visualLevel: 0});

//The following options are available with increasingly more information:
//NONE, FATAL, ERROR, WARN, INFO, DEBUG, VERBOSE
// Needs: using Com.OneSignal.Abstractions;
OneSignal.Current.SetLogLevel(LOG_LEVEL.VERBOSE, LOG_LEVEL.NONE);

-- The following options are available with increasingly more information:
--0 = NONE, 1 = FATAL, 2 = ERROR, 3 = WARN, 4 = INFO, 5 = DEBUG, 6 = VERBOSE
OneSignal.SetLogLevel(6, 0)

OneSignal.promptForPushNotifications(userResponse: { accepted in
  print("User accepted notifications: \(accepted)")
})

[OneSignal promptForPushNotificationsWithUserResponse:^(BOOL accepted) {
  NSLog(@"User accepted notifications: %d", accepted);
}];

var response = await OneSignal.Default.PromptForPushNotificationsWithUserResponse();
if (response == NotificationPermission.Authorized) {
    // user accepted
}

OneSignal.promptForPushNotificationsWithUserResponse(response => {
  console.log("Prompt response:", response);
});

OneSignal.shared.promptUserForPushNotificationPermission().then((accepted) {
    print("Accepted permission: $accepted");
});

OneSignal.promptForPushNotificationsWithUserResponse(function(accepted) {
    console.log("User accepted notifications: " + accepted);
});

window.plugins.OneSignal.promptForPushNotificationsWithUserResponse(function(accepted) {
    console.log("User accepted notifications: " + accepted);
});

// Returns an `OSDeviceState` object with the current immediate device state info
OSDeviceState device = OneSignal.getDeviceState(); 

//Status of ability to send push notifications to the current device (See status chart below)
Integer notificationPermissionStatus = device.notificationPermissionStatus();

//Get the OneSignal Push Player Id
String userId = device.getUserId();

//Get device's push token identifier
String getPushToken = device.getPushToken();

//Get whether notifications are enabled on the device at the app level
boolean areNotificationsEnabled = device.areNotificationsEnabled();

//The device's push subscription status
boolean isSubscribed = device.isSubscribed();

//Returns value of pushDisabled method
boolean isPushDisabled = device.isPushDisabled();

//Returns an `OSDeviceState` object with the current immediate device state info
if let deviceState = OneSignal.getDeviceState() {
   //Status of ability to send push notifications to the current device (See status chart below)
   let notificationPermissionStatus = deviceState.notificationPermissionStatus.rawValue
   print("Device's notification permission status: ", notificationPermissionStatus)

   // Get the OneSignal Push Player Id
   let userId = deviceState.userId
   print("OneSignal Push Player ID: ", userId ?? "called too early, not set yet")

   //Get device's push token identifier
   let pushToken = deviceState.pushToken
   print("Device's push token: ", pushToken ?? "called too early or not set yet" )

   // Get whether notifications are enabled on the device at the app level
   let hasNotificationPermission = deviceState.hasNotificationPermission
   print("Has device allowed push permission at some point: ", hasNotificationPermission)

   // The device's push subscription status
   let isSubscribed = deviceState.isSubscribed
   print("Device is subscribed to push notifications: ", isSubscribed)

   // Returns value of pushDisabled method
   let isPushDisabled = deviceState.isPushDisabled
   print("Push notifications are disabled with disablePush method: ", isPushDisabled)
}

// Returns an `OSDeviceState` object with the current immediate device state info
OSDeviceState *deviceState = [OneSignal getDeviceState];

//Get the OneSignal Push Player Id
NSString *userId = deviceState.userId;

//Get device's push token identifier
NSString *pushToken = deviceState.pushToken;

//The device's push subscription status
BOOL subscribed = deviceState.isSubscribed;

//Status of ability to send push notifications to the current device (See status chart below)
var currentStatus = OneSignal.Default.NotificationPermission;
if (currentStatus == NotificationPermission.NotDetermined) {
    // do if user was not prompted
}

//The unique OneSignal id of this subscription
var pushUserId = OneSignal.Default.PushSubscriptionState.userId;
  
//The device's push subscription status
var pushState = OneSignal.Default.PushSubscriptionState;
  
//The unique token provided by the device's operating system used to send push notifications
var pushToken = OneSignal.Default.PushSubscriptionState.pushToken;
  
//Returns value of pushDisabled method
var isPushDisabled = OneSignal.Default.PushSubscriptionState.isPushDisabled;

// Returns an `OSDeviceState` object with the current immediate device state info
const deviceState = await OneSignal.getDeviceState();

// Returns an `OSDeviceState` object with the current immediate device state info
OneSignal.shared.getDeviceState().then((deviceState) {
     print("OneSignal: device state: ${deviceState.jsonRepresentation()}");
});

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.getDeviceState(function(stateChanges) {
  console.log('OneSignal getDeviceState: ' + JSON.stringify(stateChanges));
});

//The following methods are only available if `SetEmail` was called
// Returns an `OSDeviceState` object with the current immediate device state info
OSDeviceState device = OneSignal.getDeviceState(); 

//Get the OneSignal Email Player Id
String emailUserId = device.getEmailUserId();

//Get the email address tied to the device
String emailAddress = device.getEmailAddress();

//This device's email subscription status
boolean isEmailSubscribed = device.isEmailSubscribed();

//The following methods are only available if `SetEmail` was called

if let deviceState = OneSignal.getDeviceState() {
   //Get the OneSignal Email Player Id
   let emailAddress = deviceState.emailAddress
   print("Email Address tied to this device with setEmail: ", emailAddress ?? "called too early or not set yet" )

   //Get the email address tied to the device
   let emailUserId = deviceState.emailUserId
   print("OneSignal Email player ID: ", emailUserId ?? "called too early or not set yet")

   //This device's email subscription status
   let isEmailSubscribed = deviceState.isEmailSubscribed
   print("is the email address tied to this record subscribed to receive email: ", isEmailSubscribed)       
}

//The following methods are only available if `SetEmail` was called

//Get the OneSignal Email Player Id
var emailUserId = OneSignal.Default.EmailSubscriptionState.emailUserId

//Get the email address tied to the device
var emailAddress = OneSignal.Default.EmailSubscriptionState.emailAddress
  
//This device's email subscription status
var isSubscribed = OneSignal.Default.EmailSubscriptionState.isSubscribed

//The following methods are only available if `SetSMSNumber` was called
// Returns an `OSDeviceState` object with the current immediate device state info
OSDeviceState device = OneSignal.getDeviceState(); 

// Get the SMS Phone Number tied to the device. Only available if OneSignal.setSMSNumber() was called.
String smsUserId = device.getSMSUserId();

//Get the phone number tied to the device
String smsNumber = device.getSMSNumber();

//This device's SMS subscription status
boolean isSMSSubscribed = device.isSMSSubscribed();

//The following methods are only available if `SetSMSNumber` was called

if let deviceState = OneSignal.getDeviceState() {
     //Get the OneSignal SMS Player Id
   let smsUserId = deviceState.smsUserId
   print("OneSignal SMS player ID: ", smsUserId ?? "called too early or not set yet")
  
   //Get the phone number tied to the device
   let smsNumber = deviceState.smsNumber
   print("Phone Number tied to this device with setSMSNumber: ", smsNumber ?? "called too early or not set yet" )
  
   //This device's SMS subscription status
   let isSMSSubscribed = deviceState.isSMSSubscribed
   print("is the phone number tied to this record subscribed to receive sms: ", isSMSSubscribed)
}

//The following methods are only available if `SetSMSNumber` was called

//Get the OneSignal SMS Player Id
string smsUserId = OneSignal.Default.SMSSubscriptionState.smsUserId

//Get the phone number tied to the device
string smsNumber = OneSignal.Default.SMSSubscriptionState.smsNumber
  
//This device's SMS subscription status
bool isSubscribed = OneSignal.Default.SMSSubscriptionState.isSubscribed

public class MainActivity extends Activity implements OSPermissionObserver {
  protected void onCreate(Bundle savedInstanceState) {
    OneSignal.addPermissionObserver(this);
  }
  
  public void onOSPermissionChanged(OSPermissionStateChanges stateChanges) {
    if (stateChanges.getFrom().getEnabled() &&
        !stateChanges.getTo().getEnabled()) {
         new AlertDialog.Builder(this)
             .setMessage("Notifications Disabled!")
             .show();
      }
   
      Log.i("Debug", "onOSPermissionChanged: " + stateChanges);
  }
}

// Example Logcat entry - User disabling notifications then returning to your app.
// onOSPermissionChanged{"from":{"enabled":true},"to":{"enabled":false}}

// AppDelegate.swift
// Add OSPermissionObserver after UIApplicationDelegate
class AppDelegate: UIResponder, UIApplicationDelegate, OSPermissionObserver {

   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
      // Add your AppDelegate as an obsserver
      OneSignal.add(self as OSPermissionObserver)
   }

   // Add this new method
   func onOSPermissionChanged(_ stateChanges: OSPermissionStateChanges!) {
      // Example of detecting answering the permission prompt
      if stateChanges.from.status == OSNotificationPermission.notDetermined {
         if stateChanges.to.status == OSNotificationPermission.authorized {
            print("Thanks for accepting notifications!")
         } else if stateChanges.to.status == OSNotificationPermission.denied {
            print("Notifications not accepted. You can turn them on later under your iOS settings.")
         }
      }
      // prints out all properties
      print("PermissionStateChanges: \n\(stateChanges)")
   }

   // Output:
   /*
   Thanks for accepting notifications!
   PermissionStateChanges:
   Optional(<OSSubscriptionStateChanges:
   from: <OSPermissionState: hasPrompted: 0, status: NotDetermined>,
   to:   <OSPermissionState: hasPrompted: 1, status: Authorized>
   >
   */
}

// AppDelegate.h
// Add OSPermissionObserver after UIApplicationDelegate
@interface AppDelegate : UIResponder <UIApplicationDelegate, OSPermissionObserver>
@end

// AppDelegate.m
@implementation AppDelegate
  
- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  // Add your AppDelegate as an obsserver
  [OneSignal addPermissionObserver:self];
}

// Add this new method
- (void)onOSPermissionChanged:(OSPermissionStateChanges*)stateChanges {
  
    // Example of detecting anwsering the permission prompt
    if (stateChanges.from.status == OSNotificationPermissionNotDetermined) {
      if (stateChanges.to.status == OSNotificationPermissionAuthorized)
         NSLog(@"Thanks for accepting notifications!");
      else if (stateChanges.to.status == OSNotificationPermissionDenied)
         NSLog(@"Notifications not accepted. You can turn them on later under your iOS settings.");
    }
    
   // prints out all properties 
   NSLog(@"PermissionStateChanges:\n%@", stateChanges);
}

// Output:
/*
Thanks for accepting notifications!
PermissionStateChanges:
<OSSubscriptionStateChanges:
from: <OSPermissionState: hasPrompted: 1, status: NotDetermined>,
to:   <OSPermissionState: hasPrompted: 1, status: Authorized>
>
*/

@end

OneSignal.Default.NotificationPermissionChanged += (current, previous) => {
    if (current != NotificationPermission.NotDetermined) {
        // do if user was prompted
    }
};

OneSignal.addPermissionObserver(event => {
    console.log("OneSignal: permission changed:", event);
});

OneSignal.shared.setPermissionObserver((OSPermissionStateChanges changes) {
    // will be called whenever the permission changes
  
  if (changes.to.status == OSNotificationPermission.authorized) {
    //tells you that the user has fully authorized push permissions
  }
});

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.addPermissionObserver(function(state) {
  console.log("Notification permission state changed: " + state.hasPrompted);
  console.log("Notification permission status: " + state.status);
});

//Currently not available, use the idsAvailableCallback and check if a pushtoken is provided to make sure the user is subscribed

public class MainActivity extends Activity implements OSSubscriptionObserver {
  protected void onCreate(Bundle savedInstanceState) {
    OneSignal.addSubscriptionObserver(this);
  }
  
  public void onOSSubscriptionChanged(OSSubscriptionStateChanges stateChanges) {
    if (!stateChanges.getFrom().getSubscribed() &&
        stateChanges.getTo().getSubscribed()) {
         new AlertDialog.Builder(this)
             .setMessage("You've successfully subscribed to push notifications!")
             .show();
        // get player ID
        stateChanges.getTo().getUserId();
      }
   
      Log.i("Debug", "onOSSubscriptionChanged: " + stateChanges);
  }
}

/*
Example Logcat entry - User disabling notifications then returning to your app.
onOSSubscriptionChanged:
{"from":{"pushToken":"APA91bG9cmZ262s5gJhr8jvbg1q7aiviEC6lcOCgAQliEzHKO3eOdX5cm7IQqMSWfy8Od7Ol3jSjFfvCfeO2UYUpanJCURJ8RdhgEuV8grYxOCwPNJr5GoqcWTQOaL9u-qE2PQcFlv4K","userSubscriptionSetting":true,"subscribed":false},
 "to":  {"userId":"22712a53-9b5c-4eab-a828-f18f81167fef","pushToken":"APA91bG9cmZ262s5gJhr8jvbg1q7aiviEC6lcOCgAQliEzHKO3eOdX5cm7IQqMSWfy8Od7Ol3jSjFfvCfeO2UYUpanJCURJ8RdhgEuV8grYxOCwPNJr5GoqcWTQOaL9u-qE2PQcFlv4K","userSubscriptionSetting":true,"subscribed":true}}

// AppDelegate.swift
// Add OSSubscriptionObserver after UIApplicationDelegate
class AppDelegate: UIResponder, UIApplicationDelegate, OSSubscriptionObserver {

   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
      // Add your AppDelegate as an obsserver
      OneSignal.add(self as OSSubscriptionObserver)
   }

   // Add this new method
   func onOSSubscriptionChanged(_ stateChanges: OSSubscriptionStateChanges!) {
      if !stateChanges.from.subscribed && stateChanges.to.subscribed {
         print("Subscribed for OneSignal push notifications!")
         // get player ID
         stateChanges.to.userId
      }
      print("SubscriptionStateChange: \n\(stateChanges)")
   }

   // Output:
   /*
   Subscribed for OneSignal push notifications!
   PermissionStateChanges:
   Optional(<OSSubscriptionStateChanges:
   from: <OSSubscriptionState: userId: (null), pushToken: 0000000000000000000000000000000000000000000000000000000000000000 userSubscriptionSetting: 1, subscribed: 0>,
   to:   <OSSubscriptionState: userId: 11111111-222-333-444-555555555555, pushToken: 0000000000000000000000000000000000000000000000000000000000000000, userSubscriptionSetting: 1, subscribed: 1>
   >
   */
}

// AppDelegate.h
// Add OSSubscriptionObserver after UIApplicationDelegate
@interface AppDelegate : UIResponder <UIApplicationDelegate, OSSubscriptionObserver>
@end

// AppDelegate.m
@implementation AppDelegate
  
- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  // Add your AppDelegate as an obsserver
  [OneSignal addSubscriptionObserver:self];
}

// Add this new method
- (void)onOSSubscriptionChanged:(OSSubscriptionStateChanges*)stateChanges {
  
    // Example of detecting subscribing to OneSignal
    if (!stateChanges.from.subscribed && stateChanges.to.subscribed) {
      NSLog(@"Subscribed for OneSignal push notifications!");
      // get player ID
      stateChanges.to.userId;
    }
    
   // prints out all properties
   NSLog(@"SubscriptionStateChanges:\n%@", stateChanges);
}

// Output:
/*
Subscribed for OneSignal push notifications!
PermissionStateChanges:
<OSSubscriptionStateChanges:
from: <OSSubscriptionState: userId: (null), pushToken: 0000000000000000000000000000000000000000000000000000000000000000 userSubscriptionSetting: 1, subscribed: 0>,
to:   <OSSubscriptionState: userId: 11111111-222-333-444-555555555555, pushToken: 0000000000000000000000000000000000000000000000000000000000000000, userSubscriptionSetting: 1, subscribed: 1>
>
*/

@end

//Push State Changes
OneSignal.Default.PushSubscriptionStateChanged += (current, previous) => {
    var pushToken   = current.pushToken;
    var pushEnabled = !current.isPushDisabled;
};

//Email State changes
OneSignal.Default.EmailSubscriptionStateChanged += (current, previous) => {
    var emailSubscribed = current.isSubscribed;
};

//SMS State Changes
OneSignal.Default.SMSSubscriptionStateChanged += (current, previous) => {
    var smsSubscribed = current.isSubscribed;
};

OneSignal.addSubscriptionObserver(event => {
  console.log("OneSignal: subscription changed event:", event);
  console.log("OneSignal: subscription changed from userId:", event.from.userId);
  console.log("OneSignal: subscription changed to userId:", event.to.userId);
  console.log("OneSignal: subscription changed from pushToken:", event.from.pushToken);
  console.log("OneSignal: subscription changed to pushToken:", event.to.pushToken);
  console.log("OneSignal: subscription changed from isPushDisabled:", event.from.isPushDisabled);
  console.log("OneSignal: subscription changed to isPushDisabled:", event.to.isPushDisabled);
  console.log("OneSignal: subscription changed from isSubscribed:", event.from.isSubscribed);
  console.log("OneSignal: subscription changed to isSubscribed:", event.to.isSubscribed);
});

//More details: https://documentation.onesignal.com/docs/flutter-sdk#section--setsubscriptionobserver-
OneSignal.shared.setSubscriptionObserver((OSSubscriptionStateChanges changes) {
  //will be called whenever the OS subscription changes
});

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.addSubscriptionObserver(function (state) {
  if (!state.from.subscribed && state.to.subscribed) {
    console.log("Subscribed for OneSignal push notifications!")
    // get player ID
    state.to.userId
  }
  console.log("Push Subscription state changed: " + JSON.stringify(state));
});

//Currently not available, use the idsAvailableCallback and check if a pushtoken is provided to make sure the user is subscribed: https://documentation.onesignal.com/docs/xamarin-sdk#section--idsavailablecallback-

//Requires SDK 3.16.0+
OneSignal.setLanguage("es");

//Requires SDK 3.6.0+
OneSignal.setLanguage("es")

//Requires SDK 3.6.0+
[OneSignal setLanguage:@"es"];

OneSignal.Default.SetLanguage("es");

//Requires SDK 4.2.0+
OneSignal.setLanguage("es");

//Requires SDK 3.2.0+
OneSignal.setLanguage("es");

OneSignal.setRequiresUserPrivacyConsent(true);

//to require the user's consent before the SDK initializes
OneSignal.setRequiresUserPrivacyConsent(true);

//to require the user's consent before the SDK initializes
[OneSignal setRequiresUserPrivacyConsent:true];

OneSignal.Default.RequiresPrivacyConsent = true; // before init

// Will delay initialization of the SDK until the user provides consent
OneSignal.setRequiresUserPrivacyConsent(true);

await OneSignal.shared.setRequiresUserPrivacyConsent(true);

//will delay initialization of the SDK until the user provides consent
// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.setRequiresUserPrivacyConsent(true);

//will delay initialization of the SDK
//make sure to call before init()
OneSignal.SetRequiresUserPrivacyConsent(true);

public void onUserTappedProvidePrivacyConsent(View v) {
  //will initialize the OneSignal SDK and enable push notifications
  OneSignal.provideUserConsent(true);
}

@IBAction func userTappedProvideConsentButton(_ sender : UIButton) {
  //this will complete the initialization of the SDK
    OneSignal.consentGranted(true); 
}

- (IBAction)setEmailButtonPressed:(UIButton *)sender {
  //this will complete the initialization of the SDK
  [OneSignal consentGranted:true];
}

OneSignal.Default.PrivacyConsent = true;

if (OneSignal.Default.PrivacyConsent) {
    // user provided consent
}

function userTappedProvideConsentButton() {
  // Will initialize the SDK and register for push notifications
  OneSignal.provideUserConsent(true);
}

// the SDK will now initialize
await OneSignal.shared.consentGranted(true);

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.userProvidedPrivacyConsent((providedConsent) => {
  //if providedConsent == true, it means the SDK has been initialized and can be used
});

PrivacyConsentButton.TouchUpInside += delegate
{
  //the SDK will now be initialized
    OneSignal.UserDidProvidePrivacyConsent(true);
};

OneSignal.setLocationShared(false);

OneSignal.setLocationShared(false)

[OneSignal setLocationShared:false];

OneSignal.Default.ShareLocation = true;

OneSignal.setLocationShared(false);

await OneSignal.shared.setLocationShared(false);

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.setLocationShared(false)

OneSignal.SetLocationShared(false);

//Our Web SDK does not track location, you can setup the browser to track this and tag the user with the latitutde and longitude

boolean locationShared = OneSignal.isLocationShared();

let locationShared = OneSignal.isLocationShared()

BOOL locationShared = [OneSignal isLocationShared];

var locationShared = OneSignal.Default.ShareLocation;

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.isLocationShared(function(shared) {
});

// Make sure you add one of the following permissions
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

//These are examples of how you may setup the app. See Apple's Guide on this: https://developer.apple.com/documentation/corelocation/requesting_authorization_for_location_services
// Example plist image: https://i.imgur.com/OZDQpyQ.png

<key>NSLocationUsageDescription</key>
  <string>Your message goes here</string>
<key>NSLocationWhenInUseUsageDescription</key>
    <string>Your message goes here</string>  
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
  <string>Your message goes here</string>
<key>NSLocationAlwaysUsageDescription</key>
    <string>Your message goes here</string>
<key>UIBackgroundModes</key>
    <array>
        <string>location</string>
        <string>remote-notification</string>
    </array>

dependencies {
  ...
  implementation 'com.google.android.gms:play-services-location:YOUR_PLAY_SERVICES_VERSION'
}

OneSignal.promptLocation();

OneSignal.promptLocation()

[OneSignal promptLocation];

OneSignal.Default.PromptLocation();

// Calling promptLocation
OneSignal.promptLocation();

await OneSignal.shared.promptLocationPermission();

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.promptLocation();

OneSignal.Current.PromptLocation();

try {
  OneSignal.postNotification(new JSONObject("{'contents': {'en':'Test Message'}, 'include_player_ids': ['" + "userId" + "']}"),
     new OneSignal.PostNotificationResponseHandler() {
       @Override
       public void onSuccess(JSONObject response) {
         Log.i("OneSignalExample", "postNotification Success: " + response.toString());
       }

       @Override
       public void onFailure(JSONObject response) {
         Log.e("OneSignalExample", "postNotification Failure: " + response.toString());
       }
     });
} catch (JSONException e) {
  e.printStackTrace();
}

OneSignal.postNotification(["contents": ["en": "Test Message"], "include_player_ids": ["3009e210-3166-11e5-bc1b-db44eb02b120"]])

[OneSignal postNotification:@{
   @"contents" : @{@"en": @"Test Message"},
   @"include_player_ids": @[@"3009e210-3166-11e5-bc1b-db44eb02b120"]
}];

var pushUserId = OneSignal.Default.PushSubscriptionState.userId;
var pushOptions = new Dictionary<string, object> {
    ["contents"]           = new Dictionary<string, string> { ["en"] = "Test Message" },
    ["include_player_ids"] = new List<string> { pushUserId },
    ["send_after"]         = DateTime.Now.ToUniversalTime().AddSeconds(30).ToString("U")
};

var result = await OneSignal.Default.PostNotification(pushOptions);
if (result != null)
    Debug.Log("success");
else
    Debug.Log("error");

const { userId } = await OneSignal.getDeviceState();

const notificationObj = {
  contents: {en: "Message Body"},
  include_player_ids: [userId]
};

const jsonString = JSON.stringify(notificationObj);

OneSignal.postNotification(jsonString, (success) => {
  console.log("Success:", success);
}, (error) => {
  console.log("Error:", error );
});

var status = await OneSignal.shared.getPermissionSubscriptionState();

var playerId = status.subscriptionStatus.userId;

await OneSignal.shared.postNotification(OSCreateNotification(
  playerIds: [playerId],
  content: "this is a test from OneSignal's Flutter SDK",
  heading: "Test Notification",
  send_after: DateTime.now().add(Duration(minutes: 30)).toUtc().toIso8601String();,
  buttons: [
    OSActionButton(text: "test1", id: "id1"),
    OSActionButton(text: "test2", id: "id2")
  ]
));

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.getIds(function(ids) {
  var notificationObj = { contents: {en: "message body"},
                          include_player_ids: [ids.userId]};
  window.plugins.OneSignal.postNotification(notificationObj,
    function(successResponse) {
      console.log("Notification Post Success:", successResponse);
    },
    function (failedResponse) {
      console.log("Notification Post Failed: ", failedResponse);
      alert("Notification Post Failed:\n" + JSON.stringify(failedResponse));
    }
  );
});

using OneSignalPush.MiniJSON;

private static string oneSignalDebugMessage;

void someMethod() {
// Just an example userId, use your own or get it the devices by calling OneSignal.GetIdsAvailable
string userId = "b2f7f966-d8cc-11e4-bed1-df8f05be55ba";

var notification = new Dictionary<string, object>();
notification["contents"] = new Dictionary<string, string>() { {"en", "Test Message"} };

notification["include_player_ids"] = new List<string>() { userId };
// Example of scheduling a notification in the future.
notification["send_after"] = System.DateTime.Now.ToUniversalTime().AddSeconds(30).ToString("U");

OneSignal.Current.PostNotification(notification, (responseSuccess) => {
  oneSignalDebugMessage = "Notification posted successful! Delayed by about 30 secounds to give you time to press the home button to see a notification vs an in-app alert.\n" + Json.Serialize(responseSuccess);
}, (responseFailure) => {
  oneSignalDebugMessage = "Notification failed to post:\n" + Json.Serialize(responseFailure);
});

}

function IdsAvailable(userID, pushToken)
    if (pushToken) then
        local notification = {
            ["contents"] = {["en"] = "test"}
        }
        notification["include_player_ids"] = {userID}
        
        OneSignal.PostNotification(notification,
            function(jsonData)
                native.showAlert( "DEBUG", "POST OK!!!", { "OK" } )
                local json = require "json"
                print(json.encode(jsonData))
            end,
            function(jsonData)
                native.showAlert( "DEBUG", "POST NOT OK!!!", { "OK" } )
                local json = require "json"
                print(json.encode(jsonData))
            end
        )
    end
end

OneSignal.IdsAvailableCallback(IdsAvailable)

OneSignal.sendSelfNotification(
  /* Title (defaults if unset) */
  "OneSignal Web Push Notification",
  /* Message (defaults if unset) */
  "Action buttons increase the ways your users can interact with your notification.", 
   /* URL (defaults if unset) */
  'https://example.com/?_osp=do_not_open',
  /* Icon */
  'https://onesignal.com/images/notification_logo.png',
  {
    /* Additional data hash */
    notificationType: 'news-feature'
  }, 
  [{ /* Buttons */
    /* Choose any unique identifier for your button. The ID of the clicked button is passed to you so you can identify which button is clicked */
    id: 'like-button',
    /* The text the button should display. Supports emojis. */
    text: 'Like',
    /* A valid publicly reachable URL to an icon. Keep this small because it's downloaded on each notification display. */
    icon: 'http://i.imgur.com/N8SN8ZS.png',
    /* The URL to open when this action button is clicked. See the sections below for special URLs that prevent opening any window. */
    url: 'https://example.com/?_osp=do_not_open'
  },
  {
    id: 'read-more-button',
    text: 'Read more',
    icon: 'http://i.imgur.com/MIxJp1L.png',
    url: 'https://example.com/?_osp=do_not_open'
  }]
);

OneSignal.clearOneSignalNotifications();

OneSignal.Default.ClearOneSignalNotifications();

OneSignal.clearOneSignalNotifications();

//Currently not available

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
OneSignal.clearOneSignalNotifications();

OneSignal.Current.ClearOneSignalNotifications();

OneSignal.ClearAllNotifications()

//Not available

// Android SDK version 4.x.x
OneSignal.disablePush(true);

//Android SDK version 3.x.x
OneSignal.setSubscription(false);

// iOS SDK 3.x.x use
OneSignal.disablePush(true)

// iOS SDK 2.x.x use
OneSignal.setSubscription(false)

// iOS SDK 3.x.x use
[OneSignal disablePush:true];

// iOS SDK 2.x.x use
[OneSignal setSubscription:false];

OneSignal.Default.PushEnabled = false;

// RN SDK 4.x.x use
OneSignal.disablePush(true);

// RN SDK 3.x.x use
OneSignal.setSubscription(false);

// Flutter SDK 3.x.x use
await OneSignal.shared.disablePush(true);

// Flutter SDK 2.x.x use
await OneSignal.shared.setSubscription(false);

// Ionic 5 Capacitor may need to use (window as any).plugins.OneSignal
window.plugins.OneSignal.disablePush(false);

OneSignal.SetSubscription(false);

OneSignal.SetSubscription(false)

OneSignal.setSubscription(false);

OneSignal.unsubscribeWhenNotificationsAreDisabled(false);

REMOVED - Stopped working in Android 8+ due to a breaking change. 
To customize going forward, use Notification Categories (Channels).

OneSignal.Default.SetLaunchURLsInApp(true); // before Initialize