Implementation

If you've completed the steps described in the Setup guides, you are now ready to implement our Flutter library in your app. Our library supports Android 6+ and iOS 13+. Make sure you always have the latest Flutter SDK when using this library and the latest Xcode.

Dependencies

We understand that not every app will take advantage of every bit of functionality provided by our platform. To help reduce your app's size, dependency footprint and automatically included permissions, you can cherry-pick which modules you want to include in your app.

1. Add the dependencies to your pubspec.yaml:

dependencies:
  # Required
  notificare: ^3.0.0

  # Optional modules
  notificare_assets: ^3.0.0
  notificare_authentication: ^3.0.0
  notificare_geo: ^3.0.0
  notificare_in_app_messaging: ^3.0.0
  notificare_inbox: ^3.0.0
  notificare_loyalty: ^3.0.0
  notificare_monetize: ^3.0.0
  notificare_push: ^3.0.0
  notificare_push_ui: ^3.0.0
  notificare_scannables: ^3.0.0

2. Run the following command:

flutter pub get; cd ios; pod install

//
// root build.gradle
//
buildscript {
    repositories {
        // ...
        maven { url 'https://developer.huawei.com/repo' }
    }

    dependencies {
        // ...
        classpath 'com.huawei.agconnect:agcp:1.6.2.300' // use the latest version.
    }
}

//
// app build.gradle
//
apply plugin: 'com.huawei.agconnect'

Configuration file

In order to connect your app to Notificare, you need to download the configuration file from the Dashboard and place it under your project's native modules. The configuration file can be downloaded by opening your Notificare application and going into the App Keys section via Menu > Settings > App Keys.

{
  "project_info": {
    "application_id": "{{ YOUR APPLICATION ID }}",
    "application_key": "{{ YOUR APPLICATION KEY }}",
    "application_secret": "{{ YOUR APPLICATION SECRET }}"
  }
}

//
// root build.gradle
//
buildscript {
    repositories {
        maven { url 'https://maven.notifica.re/releases' }
    }
    dependencies {
        classpath 're.notifica.gradle:notificare-services:1.0.1'
    }
}

allprojects {
    repositories {
        maven { url 'https://maven.notifica.re/releases' }
        maven { url 'https://developer.huawei.com/repo' }
    }
}

//
// app build.gradle
//
apply plugin: 're.notifica.gradle.notificare-services'

<?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>APPLICATION_ID</key>
    <string>{{ YOUR APPLICATION ID }}</string>
    <key>APPLICATION_KEY</key>
    <string>{{ YOUR APPLICATION KEY }}</string>
    <key>APPLICATION_SECRET</key>
    <string>{{ YOUR APPLICATION SECRET }}</string>
</dict>
</plist>

Notifications Activity

If you're planning on using the managed approach to display notifications, you should add a translucent theme to the NotificationActivity. This enables it to show floating alerts over your content on an Android app.

<application>
    <activity
        android:name="re.notifica.push.ui.NotificationActivity"
        android:theme="@style/Theme.App.Translucent" />
</application>

As a reference, you can use the example theme below. This needs to be added to your resources folder. Make sure the theme you inherit from is an AppCompat theme. For instance, Theme.AppCompat.Light.DarkActionBar.

<resources>
    <!-- adjust the name and parent to match your theme -->
    <style name="Theme.App.Translucent" parent="Theme.App">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowBackground">@android:color/transparent</item>
    </style>
</resources>

You can find additional information about the theming system in Android's official documentation located here.

Launching Notificare

Launching Notificare is as simple as calling Notificare.launch(). However, before launching, you may want to consider customising some properties.

You should launch Notificare when the main application component initialises its state. A small code sample can be found below.

class _MyAppState extends State<MyApp> {
  @override
  void initState() {
    super.initState();

    _setupNotificare();
  }

  void _setupNotificare() async {
    // Launch Notificare! 🚀
    await Notificare.launch();
  }
}

You can delay launching Notificare for the first time. Otherwise, make sure you launch() during the application's initialization phase to prevent missing important updates when the app is created in the background.

Beware the launch() method completes before the launch process finishes. You can use the Notificare.onReady event to control the state of dependencies in your application initialization flow.

Listening to events

You can listen to the Notificare.onReady and Notificare.onDeviceRegistered events. This is a good opportunity to perform additional steps when Notificare becomes ready or when the device is updated.

void _setupNotificare() async {
  Notificare.onReady.listen((application) {
    // At this point you have been assigned a temporary device identifier.
    // Notificare is now safe to use.
  });

  Notificare.onDeviceRegistered.listen((device) {
    // At this point you know a device is registered with the Notificare API
    // This method will be called every time something changes, be it token, push enabled/disabled or other property changes
    // Use this method to keep track of device changes in your own app or act on those changes
  });

  // More code ...
}

Events are queued until the Flutter engine and the plugins are ready. At that point, the plugins will emit the events to Flutter. Therefore, you should listen to the events as soon as possible during your app's initialization process to avoid missing any events.

Un-launch Notificare

It is possible to completely remove all data for a device, both locally in your app and remotely in our servers. You want to avoid doing so, but for cases when the user requests their account to be removed, you can use the following method:

await Notificare.unlaunch()

After invoking this, all the device's data will be destroyed and cannot be undone. Once the process is complete, the Notificare.onUnlaunched event will be executed.

Notificare.onUnlaunched.listen((application) {
  // All device data was deleted.
  // Notificare cannot be used until it's launched again.
});

At this point, invoking any other method in Notificare will fail, and the only way to start using the SDK again, is by invoking its counterpart, the launch method.