Integration guide

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://blainks.com/maven") }
    }
}

dependencies {
    implementation("com.blainks:blaink:1.0.0")
}

plugins {
    id("com.google.gms.google-services")
}

<application ...>

    <!-- Blaink FCM Service -->
    <service
        android:name="com.blaink.push.BlainkFCMService"
        android:exported="false">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>

    <!-- Blaink Notification Dismiss Receiver (for tracking dismissed notifications) -->
    <receiver
        android:name="com.blaink.push.NotificationDismissReceiver"
        android:exported="false">
        <intent-filter>
            <action android:name="BLAINK_NOTIFICATION_DISMISS" />
        </intent-filter>
    </receiver>

    <!-- Add deeplink support to your launcher activity -->
    <activity
        android:name=".MainActivity"
        android:exported="true"
        android:launchMode="singleTask">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>

        <!-- Blaink Deeplink Handler -->
        <intent-filter>
            <action android:name="android.intent.action.VIEW" />
            <category android:name="android.intent.category.DEFAULT" />
            <category android:name="android.intent.category.BROWSABLE" />
            <data android:scheme="YOUR_DEEPLINK_SCHEME" />
        </intent-filter>
    </activity>

</application>

class MyApplication : Application(), BlainkDelegate {

    override fun onCreate() {
        super.onCreate()

        Blaink.getInstance().apply {
            delegate = this@MyApplication
            setup(
                context = this@MyApplication,
                sdkKey = "YOUR_SDK_KEY",
                environment = PushEnvironment.PRODUCTION,
                isDebugLogsEnabled = BuildConfig.DEBUG
            )
        }
    }

    override fun didReceiveNotification(notification: Map<String, Any>) {
        // Called when a push notification is received
        Log.d("Blaink", "Notification received: $notification")
    }

    override fun didRegisterForBlainkNotifications(blainkUserId: String) {
        // Called when device is successfully registered with Blaink
        Log.d("Blaink", "Registered with user ID: $blainkUserId")
    }
}

<application
    android:name=".MyApplication"
    ...>

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Register for push notifications
        // This automatically:
        // - Requests POST_NOTIFICATIONS permission on Android 13+
        // - Fetches the FCM token
        // - Registers with Blaink backend
        Blaink.getInstance().registerForRemoteNotifications(this)
    }
}

FirebaseMessaging.getInstance().token.addOnSuccessListener { token ->
    Blaink.getInstance().registerFCMToken(token)
}

// Returns true if the deeplink was handled by Blaink
val handled = Blaink.getInstance().handleDeeplink(uri.toString())

// Check if user is authenticated
if (UserSession.isAuthenticated) {
    // User is logged in
}

// Get current user
lifecycleScope.launch {
    val result = Blaink.getInstance().getCurrentUser()
    result.onSuccess { userId ->
        Log.d("Blaink", "User ID: $userId")
    }
}

// Logout
lifecycleScope.launch {
    val result = Blaink.getInstance().logout()
    result.onSuccess {
        Log.d("Blaink", "Logged out successfully")
    }
}

# Blaink SDK
-keep class com.blaink.** { *; }
-dontwarn com.blaink.**

# Kotlinx Serialization
-keepattributes *Annotation*, InnerClasses
-dontnote kotlinx.serialization.AnnotationsKt

npm install react-native-blaink

allprojects {
    repositories {
        maven { url "https://blainks.com/maven" }
    }
}

<application ...>

    <!-- Blaink FCM Service -->
    <service
        android:name="com.blaink.push.BlainkFCMService"
        android:exported="false">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>

    <!-- Blaink Notification Dismiss Receiver -->
    <receiver
        android:name="com.blaink.push.NotificationDismissReceiver"
        android:exported="false">
        <intent-filter>
            <action android:name="BLAINK_NOTIFICATION_DISMISS" />
        </intent-filter>
    </receiver>

    <!-- Add deeplink support to your main activity -->
    <activity
        android:name=".MainActivity"
        android:exported="true"
        android:launchMode="singleTask">

        <!-- Blaink Deeplink Handler -->
        <intent-filter>
            <action android:name="android.intent.action.VIEW" />
            <category android:name="android.intent.category.DEFAULT" />
            <category android:name="android.intent.category.BROWSABLE" />
            <data android:scheme="YOUR_DEEPLINK_SCHEME" />
        </intent-filter>
    </activity>

</application>

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>YOUR_DEEPLINK_SCHEME</string>
        </array>
    </dict>
</array>

import { useEffect } from 'react';
import { Platform } from 'react-native';
import {
  Blaink,
  PushEnvironment,
  addNotificationListener,
  addRegistrationListener,
} from 'react-native-blaink';

const SDK_KEY = Platform.select({
  ios: '<span class="sdk-key-placeholder">YOUR_IOS_SDK_KEY</span>',
  android: '<span class="sdk-key-placeholder">YOUR_ANDROID_SDK_KEY</span>',
})!;

export default function App() {
  useEffect(() => {
    // Initialize the SDK
    Blaink.setup({
      sdkKey: SDK_KEY,
      environment: PushEnvironment.PRODUCTION,
      debugLogsEnabled: __DEV__,
    });

    // Listen for push notifications
    const notifSub = addNotificationListener((payload) => {
      console.log('Notification:', payload);
    });

    // Listen for Blaink registration
    const regSub = addRegistrationListener((blainkUserId) => {
      console.log('Registered:', blainkUserId);
    });

    return () => {
      notifSub.remove();
      regSub.remove();
    };
  }, []);

  // ...
}

import { Blaink } from 'react-native-blaink';

async function registerPush() {
  try {
    await Blaink.registerForRemoteNotifications();
    console.log('Push registration requested');
  } catch (error) {
    console.error('Push registration failed:', error);
  }
}

import { Blaink } from 'react-native-blaink';
import { Linking } from 'react-native';

// Listen for deeplinks from React Native's Linking API
Linking.addEventListener('url', async ({ url }) => {
  const handled = await Blaink.handleDeeplink(url);
  if (!handled) {
    // Handle non-Blaink deeplinks yourself
  }
});

# Add after your main app target block

target 'NotificationService' do
  pod 'BlainkNotificationService', :path => '.'
end

require Pod::Executable.execute_command('node', ['-p',
  'require.resolve("react-native/scripts/react_native_pods.rb", {paths: [process.argv[1]]})',
  __dir__ + '/..'
]).strip

Pod::Spec.new do |s|
  s.name         = "BlainkNotificationService"
  s.version      = "1.0.0"
  s.summary      = "Blainks SDK for Notification Service Extension"
  s.homepage     = "https://blainks.com"
  s.license      = "MIT"
  s.authors      = "Blaink"
  s.platforms    = { :ios => "13.0" }
  s.source       = { :git => "" }
  s.source_files = "NotificationService/**/*.swift"

  spm_dependency(s,
    url: 'https://git.blainks.com/blainks/blainks-ios.git',
    requirement: { kind: 'upToNextMajorVersion', minimumVersion: '1.3.69' },
    products: ['Blainks']
  )
end

import UserNotifications
import Blainks

class NotificationService: UNNotificationServiceExtension {
    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(
        _ request: UNNotificationRequest,
        withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void
    ) {
        self.contentHandler = contentHandler
        bestAttemptContent = request.content.mutableCopy() as? UNMutableNotificationContent

        // Track delivery with Blainks
        Task {
            await Blaink.shared.didReceive(request)
        }

        // Deliver the notification
        if let bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }

    override func serviceExtensionTimeWillExpire() {
        if let contentHandler, let bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }
}

import { analytics } from 'react-native-blaink';

// Track a custom event
analytics.log('purchase_completed', {
  productId: '12345',
  amount: 29.99,
});

// Track screen view
analytics.setScreen('ProductDetail', 'App');

// Set user properties
analytics.setUserProperty('premium', 'true');
analytics.setUser({ tier: 'premium', region: 'eu' });

// Flush pending events
analytics.flush();

import { localisation } from 'react-native-blaink';

// Sync translations from the backend
const updatedKeys = await localisation.sync();

// Get a translated string
const title = await localisation.getString('welcome_title');

// Get translation for a specific language
const titleDE = await localisation.getString('welcome_title', 'de');

// Get current language
const lang = await localisation.getLanguage();

// Set active language
localisation.setLanguage('fr');

// Get all available languages
const languages = await localisation.getAvailableLanguages();

<!-- Blaink Web SDK -->
<script src="https://blainks.com/blaink.js"></script>

importScripts('https://www.gstatic.com/firebasejs/9.22.0/firebase-app-compat.js');
importScripts('https://www.gstatic.com/firebasejs/9.22.0/firebase-messaging-compat.js');

firebase.initializeApp({
  apiKey: 'YOUR_API_KEY',
  authDomain: 'YOUR_PROJECT.firebaseapp.com',
  projectId: 'YOUR_PROJECT_ID',
  storageBucket: 'YOUR_PROJECT.appspot.com',
  messagingSenderId: 'YOUR_SENDER_ID',
  appId: 'YOUR_APP_ID'
});

const messaging = firebase.messaging();

messaging.onBackgroundMessage((payload) => {
  const title = payload.notification?.title || 'New Notification';
  return self.registration.showNotification(title, {
    body: payload.notification?.body || '',
    icon: payload.notification?.icon,
    data: payload.data
  });
});

self.addEventListener('notificationclick', (event) => {
  event.notification.close();
  event.waitUntil(clients.openWindow(event.notification.data?.url || '/'));
});

<!-- SDK auto-attaches click handler to this button -->
<button id="blaink-notification-button">Enable Notifications</button>

<script>Blaink.init();</script>

<!-- PWA Configuration -->
<link rel="manifest" href="/manifest.json">

<!-- Apple Touch Icon (use your own icon) -->
<link rel="icon" type="image/png" href="/images/app_icon.png">
<link rel="apple-touch-icon" href="/images/app_icon.png">
<meta name="theme-color" content="#0f172a">

import Blainks

class AppDelegate: UIResponder, UIApplicationDelegate,
                   BlainksDeferredDeeplinkDelegate {

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions options: ...) -> Bool {

        Blaink.shared.deferredDeeplinkDelegate = self
        Blaink.shared.setup(sdkKey: "<span class="sdk-key-placeholder">YOUR_SDK_KEY</span>")

        return true
    }

    // Forward Universal Links (with a SceneDelegate, do this in
    // scene(_:continue:) instead)
    func application(_ application: UIApplication,
                     continue userActivity: NSUserActivity,
                     restorationHandler: ...) -> Bool {
        guard let url = userActivity.webpageURL else { return false }
        return Blaink.shared.handleDeeplink(url)
    }

    // MARK: - BlainksDeferredDeeplinkDelegate

    func didResolveDeferredDeeplink(destination: String,
                                    metadata: [String: String]?) {
        // Navigate to the destination screen
        print("Deferred link: \(destination)")
    }

    func deferredDeeplinkResolutionFailed(
        error: BlainksDeferredDeeplinkError
    ) {
        // Optional: log or handle failures
    }
}

applinks:yourapp.blainks.com

import com.blaink.Blaink
import com.blaink.core.deferredlink.BlainkDeferredDeeplinkListener
import com.blaink.core.deferredlink.BlainkDeferredDeeplinkError

class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        val blaink = Blaink.getInstance()

        blaink.deferredDeeplinkListener =
            object : BlainkDeferredDeeplinkListener {
                override fun onDeferredDeeplinkResolved(
                    destination: String,
                    metadata: Map<String, String>?
                ) {
                    Log.d("Blaink", "Deferred link: $destination")
                }

                override fun onDeferredDeeplinkFailed(
                    error: BlainkDeferredDeeplinkError
                ) {
                    // Optional: handle failures
                }
            }

        blaink.setup(
            context = this,
            sdkKey = "<span class="sdk-key-placeholder">YOUR_SDK_KEY</span>"
        )
    }
}

import { useEffect } from 'react';
import { Platform } from 'react-native';
import {
  Blaink,
  PushEnvironment,
  addDeferredDeeplinkResolvedListener,
  addDeferredDeeplinkFailedListener,
} from 'react-native-blaink';

const SDK_KEY = Platform.select({
  ios: '<span class="sdk-key-placeholder">YOUR_IOS_SDK_KEY</span>',
  android: '<span class="sdk-key-placeholder">YOUR_ANDROID_SDK_KEY</span>',
})!;

export default function App() {
  useEffect(() => {
    // Register deferred deeplink listeners BEFORE setup
    const resolvedSub = addDeferredDeeplinkResolvedListener((result) => {
      console.log('Deferred link destination:', result.destination);
      console.log('Metadata:', result.metadata);
      // Navigate to the destination screen
    });

    const failedSub = addDeferredDeeplinkFailedListener((error) => {
      console.log('Deferred link failed:', error);
    });

    // Initialize the SDK
    Blaink.setup({
      sdkKey: SDK_KEY,
      environment: PushEnvironment.PRODUCTION,
      debugLogsEnabled: __DEV__,
    });

    return () => {
      resolvedSub.remove();
      failedSub.remove();
    };
  }, []);

  // ...
}

import {
  addDeferredDeeplinkFailedListener,
  DeferredDeeplinkError,
} from 'react-native-blaink';

addDeferredDeeplinkFailedListener((error) => {
  switch (error) {
    case DeferredDeeplinkError.NO_MATCH_FOUND:
      // The link expired or its token is unknown
      break;
    case DeferredDeeplinkError.NETWORK_ERROR:
      // Retry or show offline banner
      break;
    case DeferredDeeplinkError.SDK_NOT_INITIALIZED:
      console.error('Blaink.setup() must be called first');
      break;
  }
});