map-o file-code-o arrow-directionplatform-webreach-project-type-boarding-passreach-project-type-couponreach-project-type-event-ticketreach-project-type-genericreach-project-type-gift-cardreach-project-type-loyalty-cardreach-project-type-member-card pictures more_vert chain

Xamarin

The Urban Airship Xamarin component provides full bindings to the Urban Airship SDK for use in Xamarin Studio. With this component, Xamarin developers can target both iOS and Android devices with access to the full scope of the Urban Airship SDK, all while remaining in the C#/.NET ecosystem.

We provide two packages:

Resources

Setup

Before you begin, set up Push and any other Urban Airship features for iOS and Android. The Xamarin bindings, like the SDKs that they wrap, are platform-specific, so this would be a good time to familiarize yourself with the SDK APIs and features for each platform you wish to target.

Installation

Installing the Urban Airship components is a quick and easy process, seamlessly integrated into Xamarin Studio. You have two installation options:

If you choose to install the PCL, note that it must be installed in each platform-specific project.

Both components can be installed via the NuGet package manager, and the native bindings can be found in the component store as well.

NuGet

Native Bindings:

PM> Install-Package UrbanAirship

Portable Client Library:

PM> Install-Package UrbanAirship.Portable

Double click the Packages folder in the Solution Explorer. With nuget.org selected as the source, search for Urban Airship SDK. Choose either the portable library or native bindings, and select Add Package.

Xamarin Component Store (Native Bindings Only)

In the Solution Explorer, double-click the Components folder under your app’s project. This will bring up a screen with a button inviting you to Get More Components. Click this button to bring up a window for the Xamarin Component Store, and search for Urban Airship SDK. Navigate to the component’s details page, and click the Install button.

Xamarin Studio will automatically download and configure all DLLs and package dependencies. Once the installation is complete, you can move on to the integration steps for your target platform.

iOS Integration

Airship Config

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
  <dict>
     <key>detectProvisioningMode</key>
     <true/>
     <key>developmentAppKey</key>
     <string>Your Development App Key</string>
     <key>developmentAppSecret</key>
     <string>Your Development App Secret</string>
     <key>productionAppKey</key>
     <string>Your Production App Key</string>
     <key>productionAppSecret</key>
     <string>Your Production App Secret</string>
  </dict>
</plist>

Provide AirshipConfig.plist file with the application’s configuration. In order for this file to be visible to the SDK during TakeOff, be sure that its BuildAction is set to “Bundle Resource” in your app project.

TakeOff

[Register ("AppDelegate")]
public class AppDelegate : UIApplicationDelegate
{
   public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
   {
      UAirship.TakeOff ();
      // Configure airship here
      return true;
   }
}

Note that if the TakeOff process fails due to improper or missing configuration, the shared UAirship instance will be null. The Urban Airship SDK always logs implementation errors at high visibility.

The Urban Airship SDK requires only a single entry point in the app delegate, known as takeOff. Inside your application delegate’s FinishedLaunching method, initialize a shared UAirship instance by calling UAirship takeOff . This will bootstrap the SDK and look for settings specified in the AirshipConfig.plist config file.

Enabling User notifications

UAirship.Push.UserPushNotificationsEnabled = true;

Enabling UserPushNotificationsEnabled will prompt the user to for permission to send notifications. To increase the likelihood that the user will accept, you should avoid prompting the user for permission immediately, and instead wait for a more appropriate time in the app.

The Urban Airship SDK makes a distinction between “user notifications”, which can be seen by the user, and other forms of push that allow you to send data to your app silently, or in the background. Enabling or disabling user notifications is a preference often best left up to the user, so by default, user notifications are disabled.

Android Integration

Airship Config

Example airshipconfig.properties:

developmentAppKey = Your Development App Key
developmentAppSecret = Your Development App Secret

productionAppKey = Your Production App Key
productionAppSecret = Your Production Secret

# Toggles between the development and production app credentials
# Before submitting your application to an app store set to true
inProduction = false

# LogLevel is "VERBOSE", "DEBUG", "INFO", "WARN", "ERROR" or "ASSERT"
developmentLogLevel = DEBUG
productionLogLevel = ERROR

# FCM/GCM Sender ID
gcmSender = Your Google API Project Number

# Notification customization
notificationIcon = ic_notification
notificationAccentColor = #ff0000

Airship config options are a convenient way to pass custom settings to your app without needing to edit the source code. By default the Urban Airship SDK loads these settings from the airshipconfig.properties file located in your application’s Assets directory. Use this file, among other things, to set the backend credentials for your app, and to toggle between development and production builds.

TakeOff

[Register("com.example.SampleAutopilot")]
public class SampleAutopilot : Autopilot
{

  public override void OnAirshipReady(UAirship airship)
  {
    // perform any post takeOff airship customizations
  }

  public override AirshipConfigOptions CreateAirshipConfigOptions(Context context)
  {
    /* Optionally set your config at runtime
    AirshipConfigOptions options = new AirshipConfigOptions.Builder()
         .SetInProduction(!BuildConfig.DEBUG)
         .SetDevelopmentAppKey("Your Development App Key")
         .SetDevelopmentAppSecret("Your Development App Secret")
         .SetProductionAppKey("Your Production App Key")
         .SetProductionAppSecret("Your Production App Secret")
         .SetNotificationAccentColor(ContextCompat.getColor(this, R.color.color_accent))
         .SetNotificationIcon(R.drawable.ic_notification)
         .Build();
    return options;
    */
    return base.CreateAirshipConfigOptions(context);
  }
}

Assemblyinfo.cs

[assembly: MetaData("com.urbanairship.autopilot", Value = "sample.SampleAutopilot")]

Create a class that extends Autopilot. Register the autopilot in the Assemblyinfo.cs to generate the required metadata in the AndroidManifest.xml file.

Enable user notifications:

UAirship.Shared().PushManager.UserNotificationsEnabled = true;

The Urban Airship SDK makes a distinction between “user notifications”, which can be seen by the user, and other forms of push that allow you to send data to your app silently.

Enabling or disabling user notifications is a preference often best left up to the user, so by default, user notifications are disabled. However they are easily enabled with a single call to the PushManager instance.

Native Bindings

Using the native binding libraries is similar to using either the Android or iOS SDKs. Below we provide a simple comparison between setting a named user ID in the native SDK and binding library. In general, the two changes you will notice between the bindings and SDKs are:

Android

Native Java Call

// Set the named user ID
UAirship.shared().getNamedUser().setId("NamedUserID");

Binding Library:

// Set the named user ID
UAirship.Shared().NamedUser.Id = "NamedUserID"

For more information on the Android SDK, please see the Android platform documentation

iOS

Native Objective-C Call:

// Set the named user ID
[UAirship namedUser].identifier = "NamedUserId"

Binding Library:

// Set the named user ID
UAirship.NamedUser.Identifier = "NamedUserID"

For more information on the iOS SDK, please see the iOS platform documentation

Portable Class Library

Add Device Tags:

Airship.Instance.EditDeviceTags()
       .AddTag('tag1')
       .AddTag('tag2')
       .RemoveTag('tag3')
       .Apply();

Add Custom Event:

CustomEvent customEvent = new CustomEvent();
customEvent.EventName = "purchased";
customEvent.EventValue = 123.45;
customEvent.TransactionId = "xxxxxxxxx";
customEvent.InteractionId = "your.store/us/en_us/pd/pgid-10978234";
customEvent.InteractionType = "url";
customEvent.AddProperty("category", "shoes");

Airship.Instance.AddCustomEvent(customEvent);

Associate Identifier:

Airship.Instance.AssociateIdentifier("customKey", "customIdentifier");

Display Message Center:

Airship.Instance.DisplayMessageCenter();

Edit Named User Tag Groups:

Airship.Instance.EditNamedUserTagGroups()
       .AddTag("tag1", "group1")
       .AddTag("tag2", "group1")
       .RemoveTag("tag3", "group2")
       .SetTag("pizza", "loyalty")
       .Apply();

Edit Channel Tag Groups:

Airship.Instance.EditChannelTagGroups()
       .AddTag("tag1", "group1")
       .AddTag("tag2", "group1")
       .RemoveTag("tag3", "group2")
       .SetTag("pizza", "loyalty")
       .Apply();

Properties:

// Properties with getters and setters
Airship.Instance.UserNotificationsEnabled = true;
Airship.Instance.LocationEnabled = true;
Airship.Instance.BackgroundLocationEnabled = true;
Airship.Instance.NamedUser = "namedUser123";

// Properties with getters only
List<string> tags = Airship.Instance.Tags;
string channelId = Airship.Instance.ChannelId;
int count = Airship.Instance.MessageCenterCount;
int unreadCount = Airship.Instance.MessageCenterCount;

The portable class library (PCL) provides a unified interface for common SDK calls, allowing users to place common code in a shared location. This is ideal for working with Xamarin Forms – simply place the portable library into both of your platform-specific projects, follow the integration instructions detailed above for each platform, and all of these calls should be available from your shared codebase.

Because the PCL currently has no shared interface for initializing the app (i.e., calling TakeOff), you must install the native bindings into each platform-specific project.

All of these calls are accessible through the Airship class, found in the UrbanAirship.Portable namespace. Full documentation for the PCL can be found here.