//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.Default.LogLevel = LogLevel.VERBOSE;

-- 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)

let externalUserId = "123456789"; // You will supply the external user id to the OneSignal SDK

OneSignal.push(function() {
  OneSignal.setExternalUserId(externalUserId);
});

String externalUserId = "123456789"; // You will supply the external user id to the OneSignal SDK

// Setting External User Id with Callback Available in SDK Version 4.0.0+
OneSignal.setExternalUserId(externalUserId, new OneSignal.OSExternalUserIdUpdateCompletionHandler() {
    @Override
    public void onSuccess(JSONObject results) {
        try {
            if (results.has("push") && results.getJSONObject("push").has("success")) {
                boolean isPushSuccess = results.getJSONObject("push").getBoolean("success");
                OneSignal.onesignalLog(OneSignal.LOG_LEVEL.VERBOSE, "Set external user id for push status: " + isPushSuccess);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }

        try {
            if (results.has("email") && results.getJSONObject("email").has("success")) {
                boolean isEmailSuccess = results.getJSONObject("email").getBoolean("success");
                OneSignal.onesignalLog(OneSignal.LOG_LEVEL.VERBOSE, "Set external user id for email status: " + isEmailSuccess);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        try {
            if (results.has("sms") && results.getJSONObject("sms").has("success")) {
                boolean isSmsSuccess = results.getJSONObject("sms").getBoolean("success");
                OneSignal.onesignalLog(OneSignal.LOG_LEVEL.VERBOSE, "Set external user id for sms status: " + isSmsSuccess);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onFailure(OneSignal.ExternalIdError error) {
        // The results will contain channel failure statuses
        // Use this to detect if external_user_id was not set and retry when a better network connection is made
        OneSignal.onesignalLog(OneSignal.LOG_LEVEL.VERBOSE, "Set external user id done with error: " + error.toString());
    }
});

let externalUserId = "123456789" // You will supply the external user id to the OneSignal SDK

// Setting External User Id with Callback Available in SDK Version 3.0.0+
OneSignal.setExternalUserId(externalUserId, withSuccess: { results in
    // The results will contain push and email success statuses
    print("External user id update complete with results: ", results!.description)
    // Push can be expected in almost every situation with a success status, but
    // as a pre-caution its good to verify it exists
    if let pushResults = results!["push"] {
        print("Set external user id push status: ", pushResults)
    }
    if let emailResults = results!["email"] {
        print("Set external user id email status: ", emailResults)
    }
    if let smsResults = results!["sms"] {
        print("Set external user id sms status: ", smsResults)
    }
}, withFailure: {error in
    print("Set external user id done with error: " + error.debugDescription)
})

NSString* externalUserId = @"123456789"; // You will supply the external user id to the OneSignal SDK

// Setting External User Id with Callback Available in SDK Version 3.0.0+
[OneSignal setExternalUserId:externalUserId withSuccess:^(NSDictionary *results) {
    // The results will contain push and email success statuses
    NSLog(@"External user id update complete with results: %@", results.description);
    // Push can be expected in almost every situation with a success status, but
    // as a pre-caution its good to verify it exists
    if (results[@"push"] && results[@"push"][@"success"])
      NSLog(@"Set external user id push status: %@", results[@"push"][@"success"]);
    // Verify the email is set or check that the results have an email success status
    if (results[@"email"] && results[@"email"][@"success"])
      NSLog(@"Set external user id email status: %@", results[@"email"][@"success"]);
    // Verify the number is set or check that the results have an sms success status
    if (results[@"sms"] && results[@"sms"][@"success"])
      NSLog(@"Set external user id sms status: %@", results[@"sms"][@"success"]);
} withFailure:^(NSError *error) {
      NSLog(@"External user id update failed with error: %@", error);
}];

OneSignal.Default.SetExternalUserId("123456789");
// or
var result = await OneSignal.Default.SetExternalUserId("123456789");
if (result) {
    Debug.Log("success");
}

let externalUserId = '123456789'; // You will supply the external user id to the OneSignal SDK

// Setting External User Id with Callback Available in SDK Version 3.9.3+
OneSignal.setExternalUserId(externalUserId, (results) => {
  // The results will contain push and email success statuses
  console.log('Results of setting external user id');
  console.log(results);
  
  // Push can be expected in almost every situation with a success status, but
  // as a pre-caution its good to verify it exists
  if (results.push && results.push.success) {
    console.log('Results of setting external user id push status:');
    console.log(results.push.success);
  }
  
  // Verify the email is set or check that the results have an email success status
  if (results.email && results.email.success) {
    console.log('Results of setting external user id email status:');
    console.log(results.email.success);
  }

  // Verify the number is set or check that the results have an sms success status
  if (results.sms && results.sms.success) {
    console.log('Results of setting external user id sms status:');
    console.log(results.sms.success);
  }
});

let externalUserId = '123456789'; // You will supply the external user id to the OneSignal SDK

// Setting External User Id with Callback Available in SDK Version 3.9.3+
OneSignal.shared.setExternalUserId(externalUserId).then((results) {
  log(results.toString());
}).catchError((error) {
  log(error.toString());
});

let externalUserId = '123456789'; // You will supply the external user id to the OneSignal SDK

// Setting External User Id with Callback Available in SDK Version 2.11.2+
window.plugins.OneSignal.setExternalUserId(externalUserId, (results) => {
  // The results will contain push and email success statuses
  console.log('Results of setting external user id');
  console.log(results);
  
  // Push can be expected in almost every situation with a success status, but
  // as a pre-caution its good to verify it exists
  if (results.push && results.push.success) {
    console.log('Results of setting external user id push status:');
    console.log(results.push.success);
  }
  
  // Verify the email is set or check that the results have an email success status
  if (results.email && results.email.success) {
    console.log('Results of setting external user id email status:');
    console.log(results.email.success);
  }

  // Verify the number is set or check that the results have an sms success status
  if (results.sms && results.sms.success) {
    console.log('Results of setting external user id sms status:');
    console.log(results.sms.success);
  }
});

string externalUserId = "123456789"; // You will supply the external user id to the OneSignal SDK

// Setting External User Id with Callback Available in SDK Version 3.8.0+
OneSignal.Current.SetExternalUserId(externalId);

//Callback available in SDK Version 3.8.0+
private static void OneSignalSetExternalUserId(Dictionary<string, object> results)
{
  // The results will contain push and email success statuses
  Debug.WriteLine("External user id updated with results: " + Json.Serialize(results));
  // Push can be expected in almost every situation with a success status, but
  // as a pre-caution its good to verify it exists
  if (results.ContainsKey("push"))
  {
    Dictionary<string, object> pushStatusDict = results["push"] as Dictionary<string, object>;
    if (pushStatusDict.ContainsKey("success"))
    {
      Debug.WriteLine("External user id updated for push with results: " + pushStatusDict["success"] as string);
    }
  }
  // Verify the email is set or check that the results have an email success status
  if (results.ContainsKey("email"))
  {
    Dictionary<string, object> emailStatusDict = results["email"] as Dictionary<string, object>;
    if (emailStatusDict.ContainsKey("success"))
    {
      Debug.WriteLine("External user id updated for email with results: " + emailStatusDict["success"] as string);
    }
  }
}

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

//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()}");
});

/The unique OneSignal id of this subscription

var playerId = deviceState?.userId;


//Get device's push token identifier

  var pushToken = deviceState?.pushToken;


//The device's push subscription status

var pushState = deviceState?.subscribed;

// 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();

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

OneSignal.promptForPushNotifications()

OneSignal.promptForPushNotifications();

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

OneSignal.Default.PromptForPushNotificationsWithUserResponse();

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);
});

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();
}

let content: [String : Any] = [
    //"content_available" : true,
    //"send_after" : "2021-10-20 14:58:49 GMT+3",
    "contents": ["en": "Contents Example"],
    "headings": ["en": "Headings Example"],
    "include_player_ids": [osPlayerId],
    "data" : ["action" : "custom_action"]
]

OneSignal.postNotification(content,onSuccess: {
    osResultSuccessBlock in print(osResultSuccessBlock.debugDescription)
    },
    onFailure: {
      osFailureBlock in print(osFailureBlock.debugDescription)
})

[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

// ... your app's code 
let activity = try Activity<OneSignalWidgetAttributes>.request(
  attributes: attributes,
  contentState: contentState,
  pushType: .token)
Task {
    for await data in activity.pushTokenUpdates {
        let myToken = data.map {String(format: "%02x", $0)}.joined()
        // ... required code for entering a live activity
        OneSignal.enterLiveActivity("my_activity_id", withToken: myToken)
    }
}

OneSignal.enterLiveActivity("my_activity_id", token, (res: object) => {
    loggingFunction("enterLiveActivity completed with result: ", JSON.stringify(res));
})

OneSignal.shared.enterLiveActivity("my_activity_id", token).then((v) {
    print("Successfully enter live activity");
}).catchError((error) {
    print("Failed to enter live activity with error: $error");
});

window.plugins.OneSignal.enterLiveActivity("my_activity_id", token);

var result = OneSignalSDK.DotNet.OneSignal.Default.EnterLiveActivity("my_activity_id", token);
if(result) {
    Console.WriteLine("Success");
}

var result = OneSignalSDK.Xamarin.OneSignal.Default.EnterLiveActivity("my_activity_id", token);
if(result) {
    Console.WriteLine("Success");
}

OneSignal.Default.enterLiveActivity("my_activity_id", token);

OneSignal.exitLiveActivity("my_activity_id")

OneSignal.exitLiveActivity("my_activity_id", (res: object) => {
    loggingFunction("exitLiveActivity completed with result: ", JSON.stringify(res));
})

OneSignal.shared.exitLiveActivity("your_activity_id").then((v) {
    print("Successfully exit live activity");
}).catchError((error) {
    print("Failed to exit live activity: $error");
});

window.plugins.OneSignal.exitLiveActivity("my_activity_id");

OneSignalSDK.DotNet.OneSignal.Default.ExitLiveActivity("my_activity_id");

OneSignalSDK.DotNet.OneSignal.Default.ExitLiveActivity("my_activity_id");

OneSignal.Default.exitLiveActivity("my_activity_id");