Meiro Mobile SDK

The Meiro Mobile SDK is a powerful tool designed to enhance the capabilities of client iOS and Android applications. Integrated with Firebase, it also facilitates the delivery of push notifications.

Key functionalities:

Event Tracking: The Meiro SDK supports a wide range of predefined event tracking options, allowing developers to track various user interactions within the app. Additionally, the SDK enables the collection of custom events tailored to individual client requirements, providing a comprehensive view of user behavior.
Communication Activation: The Meiro SDK integrates with Firebase Cloud Messaging (FCM) to enable the sending of mobile push notifications to users. This feature empowers clients to effectively engage with their app users and deliver targeted content or updates.

The Meiro SDK provides a robust foundation for comprehensive tracking and the future enhancement of mobile activation channels, such as in-app messages and content blocks.

Implementation Steps

1. Planning: you should identify the key events and data points that you want to track. The Meiro team can provide guidance and suggestions to ensure the tracking is tailored to the specific needs.

2. App Code Implementation: incorporate the SDKs into the application’s codebase and implement the necessary event tracking and data collection points.

Learn more: how to integrate Meiro SDK for Android and iOS devices.

3. Testing: after implementing the SDK, thoroughly test the integration by checking the incoming events in the Meiro Events dashboard.

4. App Deployment: Once the testing is completed, you can prepare the app for deployment and submit it to the respective app stores (App Store or Google Play Store).

5. Mobile Push Setup: System entities are automatically created based on known events' structures. Custom events require individual settings by analysts.

Mobile Push Initial Setup

Remember: The Meiro SDK is required to enable and run Mobile Push notifications in your application.

Enable the mobile push channel: This action installs system entities relevant to push notifications, such as sources, events, attributes, and stitching rules.
Configure System Events for Analytics: add the system source "Meiro Mobile Apps" into the CDP. This will include the necessary sources, events, attributes, and stitching rules aggregated for all potential applications.
Define Events and Attributes: Predefined events and attributes are automatically created by the system based on known schemas, requiring no additional configuration. For custom events, you must manually create the events and any necessary attributes, tailoring them to specific use cases.

SDKs testing process

1. Plan Your Testing Process
Establish Testing Environments: Ideally, use a separate testing or staging environment to validate the SDK implementation before deploying to production.

2. Testing phase:

2.1 Testing During Implementation

Developer Responsibility: Developers are responsible for ensuring the correct implementation of the SDK.
Validation: Developers should validate that all events are being sent to the ME instance using the Meiro Events dashboard.
Tools: Testing is conducted using device simulators in Android Studio or XCode.

2.2 Testing Before App Release

Staging Builds: Ideally, clients should have 'staging' app builds that can be installed on real devices.
QA Responsibility: QA on the client side should install the staging builds, verify that they are sending the expected events, and validate the event reception in Meiro.
Firebase Configuration: It's highly recommended that a different Firebase service account/project be used for these staging app builds. These should be added separately in the CDP.

3. Verification and Validation

Testing Once the App is Released: QA on the client side should also validate the entire functionality once again after the app is released to ensure all events are being tracked and reported accurately. Continue to monitor events post-deployment to catch any issues early.

Testing Meiro Mobile SDK integration

Prerequisites in CDP

Mobile Push channel activated (in case you’re going to implement sending Mobile Push notifications)
Meiro Mobile Apps system source created (in case you’re going to receive mobile analytics events)

Meiro Events
1. Open your ME instance dashboard.

2. Open your app with the Meiro Mobile SDK integrated and make sure you have cleared the application data to start with a fresh state.

3. If your app includes consent management, the SDK should be initialized only after users give their consent. Subsequently, users must confirm the system prompt to grant permission to receive mobile push notifications.

4. After completing the above steps, you should see events coming into the ME instance dashboard under the meiro_mobile endpoint.

There will be events like app_installed, app_foreground, and app_background (if you put the application in the background).
There should also be an fcm_registration_token_registered event to enable receiving mobile push notifications. Save your user_id value somewhere so that you can later find your profile in the CDP.

If developers have implemented link tracking in your app, you should see link_click events when you click on the links.
~~Same~~The same rule applies to screen_view events.
The last thing to check is ~~that~~whether you're receiving event_custom events if you have implemented custom events for specific use cases. Ensure that they contain your desired payload.

Meiro Business Explorer (CDP)

1. Open your MBE instance.

2. Go to the profiles search tab:

Select the User ID dimension of the Mobile Push Subscription attribute and fill in your user_id value into the text field.

You should be able to find your profile and validate that you can see values for some Meiro Mobile Push and Meiro Mobile Apps attributes. You should also see all the events received on the profile timeline, the same as you saw on the ME dashboard.

3. Create a segment containing only your profile. You can use the same attribute as you ~~did~~used ~~for~~to ~~filtering~~filter your profile. Confirm that ~~there is~~ one profile is available to activate in the Mobile Push channel.

4. Create a Mobile Push campaign for testing ~~purposes~~ and fill in the required details. Select the correct application from the dropdown menu.

5. Go to the activation tab of the Mobile Push campaign and select the segment containing your profile. Press 'Send now'.
6. You should receive a push notification on your device ~~once~~after the activation is finished. Tap on the received notification.

Meiro Events
Go back to the ME dashboard and check that you’ve received the fcm_message_received and fcm_message_click events.

Meiro Business Explorer

Return to the MBE instance and locate your profile again. You should see new attributes with values related to the recently sent push notification. The profile timeline should also display new events related to this push notification.

Meiro SDK and Firebase Integration

The Meiro SDK and Firebase work together to provide a comprehensive solution for mobile push notifications. The Meiro SDK handles the tracking of user activity and the display of push notifications, while Firebase Cloud Messaging (FCM) enables the sending of these notifications across multiple platforms (iOS and Android).

Remember: Firebase provides a unified suite of tools to streamline the development process, improve app performance, and enhance user engagement. In that order, Firebase SDK has to be implemented on the client's side.

This is the way how Meiro SDK and Firebase SDK work together:

Integration with Existing Mobile Measurement Partners

Mobile Measurement Partners (MMPs) are platforms that help marketers track mobile app installs, user engagement, and other key metrics. They provide comprehensive analytics to understand the performance of mobile marketing campaigns. Examples of popular MMPs include Appsflyer and Adjust.

If a client uses an MMP like AppsFlyer or Adjust and wants to continue using it for app event tracking, they can integrate the Meiro SDK solely for mobile push notifications.

By setting the automaticTrackingEnabled configuration to false, the Meiro SDK will collect only events related to mobile push, such as token registration, message received, and message click events.

This allows the client to benefit from Meiro’s mobile push capabilities without duplicating event-tracking efforts already handled by the MMP.

Tracking Events

Understanding user behavior and enhancing app performance can be achieved by tracking events with the Meiro SDK and the Mobile Push channel.

Tracking events with Meiro SDK

Even if the Mobile Push use case is not activated, the SDK remains valuable for tracking user interactions within your app and collecting event data for analytics purposes.

The Meiro SDK tracks a variety of events, both default system events and custom events defined by the client.

Default System Events:

Application Foregrounded - When the user brings the app to the foreground (i.e. when they open or switch back to the app from another app or the home screen).
Application Backgrounded - When the user sends the app to the background (i.e. when they switch to another app or go to the home screen).
App Install Event - When the app is installed on a user’s device for the first time.

These event tracking could be implemented on the client’s side:

Screen Views - When a user views a specific screen within the app.
Link Clicks - When a user clicks on a link within the app. This includes links to external websites, other parts of the app, or specific features within the app.
Custom events - When specific actions (defined by the client) occur within the app. These can be tailored to track particular user interactions, such as completing a purchase, sharing content, or using a particular feature.

Tracking events with Mobile Push

FCM Registration Token Registered: Tracks the registration of a new Firebase Cloud Messaging (FCM) token, which is essential for enabling push notifications. This token is essential for enabling push notifications on a user's device.
- When a user installs the app or re-installs it after uninstalling.
- When the FCM registration token is refreshed (e.g., when it expires or is manually refreshed).
FCM Message Received: Tracks the delivery of push notifications sent via FCM. This does not necessarily mean that the user has seen or interacted with the notification.
- When a new promotional offer or update is pushed to the user's device.
- Tracking the delivery rate of push notifications.

Warning: The "Mobile Push Received" event might not be sent until the user opens the app. This behaviour depends on various factors, such as the system's state, battery optimisation settings, and whether the app is running in the background or closed. Once the user opens the app, any potentially received push notifications from the past will be sent, along with the correct timestamp of when the user received the notification.

FCM Message Click: Tracks user interaction with push notifications, indicating engagement with the content.
- Monitoring user interaction with in-app content and links.

SDK updates

How Updates Work

Updating our SDK is a straightforward process that primarily involves changing the version of the SDK used in clients' applications. This ensures you always have access to the latest features, improvements, and bug fixes.

Expected Frequency

The frequency of SDK updates can vary. While we aim to provide a stable and reliable SDK, there may be instances where updates are necessary, such as:

Hotfixes: If a bug is discovered, we will release a hotfix as soon as possible to address the issue.
Feature Releases: When new features are developed and added to the SDK, we will release an update to make these available.

Currently, we do not anticipate frequent updates unless a critical issue arises or a new feature is developed. Meiro Devs will communicate updates as early or in advance as possible.

Requirements for Clients

When an update is released, clients will need to upload the new version of the SDK into their application. This may require minor adjustments in your code to accommodate changes or new features.