Interface Context

Provides APIs to handle data campaigns, track Item views and interactions, and track manual actions, all within a lifecycle-managed context such as Screen.

public interface Context

Typically used as Evergage.getScreenForActivity(android.app.Activity), and if necessary, Evergage.getGlobalContext() for behavior outside of an Activity.

Method Summary

Method	Modifier and Type	Description
`addToCart(LineItem lineItem)`	`void`	Tracks that a line item is being added to the shopping cart.
`comment(Item item)`	`void`	Tracks that an item was commented on.
`favorite(Item item)`	`void`	Tracks that an item was marked by the user as a favorite item.
`isActive()`	`boolean`	If this context is currently active or not.
`purchase(Order order)`	`void`	Tracks that an order was purchased.
`review(Item item)`	`void`	Tracks that an item was reviewed, with no additional details.
`review(Item item, Review reviewDetails)`	`void`	Tracks that an item was reviewed, with the contents (optional) of the review.
`setCampaignHandler(CampaignHandler handler, java.lang.String target)`	`void`	To optionally support custom 'Data' campaigns, register a campaign handler for the app-defined target within this context.
`share(Item item)`	`void`	Tracks that an item was shared, for instance by email or on a social network.
`trackAction(java.lang.String action)`	`void`	Sends an event to Personalization describing an action to track.
`trackClickthrough(Campaign campaign)`	`void`	Tracks a clickthrough for the provided data campaign.
`trackClickthrough(android.content.Intent notificationIntent)`	`void`	Track an uncommonly handled push notification clickthrough that can't be automatically tracked.
`trackClickthrough(java.util.Map<java.lang.String,java.lang.String> notificationData)`	`void`	Track an uncommonly handled push notification clickthrough that can't be automatically tracked.
`trackDismissal(Campaign campaign)`	`void`	Tracks a dismissal for the provided data campaign.
`trackImpression(Campaign campaign)`	`void`	Tracks an impression for the provided data campaign.
`viewCategory(Category category)`	`void`	Tracks that a category is being viewed.
`viewCategory(Category category, java.lang.String actionName)`	`void`	Same as `viewCategory(Category)` but with a different action name to distinguish this View Category.
`viewItem(Item item)`	`void`	Tracks that an item is being viewed.
`viewItem(Item item, java.lang.String actionName)`	`void`	Same as `viewItem(Item)` but with a different action name to distinguish this View Item.
`viewItemDetail(Item item)`	`void`	Tracks that the details of an item are being viewed, such as other product images or a specifications tab.
`viewItemDetail(Item item, java.lang.String actionName)`	`void`	Same as `viewItemDetail(Item)` but with a different action name to distinguish this View Item Detail.
`viewTag(Tag tag)`	`void`	Tracks that a tag is being viewed.
`viewTag(Tag tag, java.lang.String actionName)`	`void`	Same as `viewTag(Tag)` but with a different action name to distinguish this View Tag.

isActive

boolean isActive()

If this context is currently active or not.

A typical Screen context is active when Screen.isRunning() and the app and user are active.

Besides some initial setup just before becoming visible (setCampaignHandler(com.evergage.android.CampaignHandler, java.lang.String), viewItem(com.evergage.android.promote.Item) etc), activity generally occurs while a context is active. Context activity, in addition to app state and user idleness, can affect campaign delivery. For more information, see setCampaignHandler(com.evergage.android.CampaignHandler, java.lang.String).

Returns

true, if this context is currently active.

setCampaignHandler

void setCampaignHandler(CampaignHandler handler,
                         java.lang.String target)

To optionally support custom data campaigns, register a campaign handler for the app-defined target within this context. Can set a null handler for a target to clear.

The "target" is an app-defined string that uniquely identifies the payload data schema - what the data represents and its purpose. See Campaign.getTarget().

While the context, app, and user is active, the handler may receive asynchronous callbacks (on the main thread) with campaigns for the target, in response to actions/events sent. The handler code should show/update the campaign to the user, when appropriate. For example code, see CampaignHandler.

Campaigns may be held for delivery while either:

The context, app, or user is inactive
No handler is found for the campaign's target within this context

For each context and target, only the most recent campaign will be held.

Lifecycle details:

For an Activity, it is recommended to always get Evergage.getScreenForActivity(Activity) and call this method just before becoming visible, specifically in onStart(). For example code, see CampaignHandler.
In order to prevent accidental leaks in the CampaignHandler, a Screen has a limited time to become visible, after which its handlers and held campaigns will be cleared.
When a screen transitions to not visible onStop(), all handlers and held campaigns are cleared.

Parameters:

Parameter	Description
`handler`	The campaign handler this context should use for the specified target.
`target`	App-defined string that uniquely identifies the payload data schema - what the data represents and its purpose. For more information, see `Campaign.getTarget()`.

See Also

trackImpression

void trackImpression(Campaign campaign)

Tracks an impression for the provided data campaign. Call this method after showing the campaign to the user or if the campaign would be shown but the user is in the control group. For more information, see Mobile Data Campaigns and CampaignHandler.

Parameters:

Parameter	Description
`campaign`	The campaign for which an impression should be tracked.

See Also

CampaignHandler

trackDismissal

void trackDismissal(Campaign campaign)

Tracks a dismissal for the provided data campaign. Call this method after showing the campaign to the user and the user dismissed the campaign. For more information, see Mobile Data Campaigns and CampaignHandler.

Parameter	Description
`campaign`	The campaign for which a dismissal should be tracked.

See Also

CampaignHandler

trackClickthrough

void trackClickthrough(Campaign campaign)

Tracks a clickthrough for the provided data campaign. Call this method after showing the campaign to the user and the user clicked campaign content. For more information, see Mobile Data Campaigns and CampaignHandler.

Parameters

Parameter	Description
`campaign`	The campaign for which a clickthrough should be tracked.

See Also

CampaignHandler

trackClickthrough(Map)

void trackClickthrough(java.util.Map<java.lang.String,java.lang.String> notificationData)

Track an uncommonly handled push notification clickthrough that can't be automatically tracked.

Personalization automatically tracks clicks/opens from Firebase notifications received in the background, and from Firebase notifications received in the foreground that your app chooses to handle by launching an activity in the default launchMode "standard" (for example, intent did not have flags such as FLAG_ACTIVITY_CLEAR_TOP). Any Activity using a different launchMode can enable tracking by calling setIntent within onNewIntent, as shown in the following example.

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    setIntent(intent);
}

This tracking method may be required if you manually render a notification from the push. For example, if the Firebase notification is received while the app is in the foreground, it is not automatically shown - instead FirebaseMessagingService#onMessageReceived is called. At this point your app can decide if it wants to manually show a notification. For example code using notifications, see trackClickthrough(Intent).

The following code example uses an AlertActivity/Dialog.

// In the FirebaseMessagingService:
@Override
public void onMessageReceived(final RemoteMessage remoteMessage) {
    super.onMessageReceived(remoteMessage);

    Map<String, String> data = remoteMessage.getData();
    RemoteMessage.Notification notification = remoteMessage.getNotification();
    if (notification == null) {
        // ... process data, but typically nothing to show user unless content within data
        return;
    }

    // ...app logic decides to show an alert-styled Activity...

    Intent alertIntent = new Intent(this, AlertActivity.class);
    alertIntent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
    alertIntent.putExtra("remoteMessage", remoteMessage);
    startActivity(alertIntent);
}

// In your app manifest:
<activity
    android:name=".AlertActivity"
    android:launchMode="singleInstance"
    android:taskAffinity=""
    android:excludeFromRecents="true"
    android:noHistory="true" />

// AlertActivity:
public class AlertActivity extends Activity {
    private AlertDialog currentDialog;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setVisible(false);
        handleAlertIntent(getIntent());
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        // Another potential alert has arrived
        handleAlertIntent(intent);
    }

    private void handleAlertIntent(Intent intent) {
        overridePendingTransition(0,0);
        Parcelable parcelable = intent != null ? intent.getParcelableExtra("remoteMessage") : null;
        final RemoteMessage remoteMessage = (parcelable instanceof RemoteMessage) ? (RemoteMessage)parcelable : null;
        if (remoteMessage != null && remoteMessage.getNotification() != null) {
            // New dialog build
            AlertDialog.Builder builder = new AlertDialog.Builder(this)
                .setTitle(remoteMessage.getNotification().getTitle())
                .setMessage(remoteMessage.getNotification().getBody())
                .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {

                        // *** TRACKING THE CLICK: ***
                        com.evergage.android.Context globalContext = Evergage.getInstance().getGlobalContext();
                        if (globalContext != null) {
                            globalContext.trackClickthrough(remoteMessage.getData());
                        }

                        exitIfNoContent(dialogInterface);
                    }
                });

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                builder.setOnDismissListener(new DialogInterface.OnDismissListener() {
                    @Override
                    public void onDismiss(DialogInterface dialogInterface) {
                        exitIfNoContent(dialogInterface);
                    }
                });
            } else {
                builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel(DialogInterface dialogInterface) {
                        exitIfNoContent(dialogInterface);
                    }
                });
            }

            // Remove previous dialog
            AlertDialog previousDialog = currentDialog;
            currentDialog = null;
            if (previousDialog != null) {
                previousDialog.hide();
            }

            // Show new dialog
            currentDialog = builder.create();
            currentDialog.show();
        }

        exitIfNoContent(null);
    }

    private void exitIfNoContent(@Nullable DialogInterface dialogBeingDismissed) {
        if (currentDialog != null && currentDialog != dialogBeingDismissed) {
            return;
        }

        currentDialog = null;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            finishAndRemoveTask();
        } else {
            finish();
        }
        overridePendingTransition(0,0);
    }
}

Parameters

Parameter	Description
`notificationData`	Pass `remoteMessage.getData()`, after it's been manually rendered and clicked.

Since

1.3.0

See Also

trackClickthrough(Intent)

void trackClickthrough(android.content.Intent notificationIntent)

Track an uncommonly handled push notification clickthrough that can't be automatically tracked.

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    setIntent(intent);
}

This tracking method may be required if you manually render a Notification from the push. For example, if the Firebase notification is received while the app is in the foreground, it is not automatically shown - instead FirebaseMessagingService#onMessageReceived is called. At this point your app can decide if it wants to manually show a notification. See trackClickthrough(Map) for an example using an AlertActivity/Dialog.

The following is example code that uses intents for an Activity and BroadcastReceiver.

// In the FirebaseMessagingService:
@Override
public void onMessageReceived(final RemoteMessage remoteMessage) {
    super.onMessageReceived(remoteMessage);

    Map<String, String> data = remoteMessage.getData();
    RemoteMessage.Notification notification = remoteMessage.getNotification();
    if (notification == null) {
        // ... process data, but typically nothing to show user unless content within data
        return;
    }

    // ...app logic decides to show an alert-styled Activity...

    // Need to get RemoteMessage data into intent extras for tracking
    Bundle bundle = new Bundle();
    Map<String, String> data = remoteMessage.getData();
    if (data != null) {
        for (Map.Entry<String, String> entry : data.entrySet()) {
            bundle.putString(entry.getKey(), entry.getValue());
        }
    }
    // Your app might instead have a specific id in remoteMessage.getData()
    int notificationId = RANDOM.nextInt(Integer.SIZE-1);
    bundle.putInt("notificationId", notificationId);

    // See https://developer.android.com/training/notify-user/build-notification

    // This Activity intent should automatically track, though you may need onNewIntent (see method doc above)
    Intent activityIntent = new Intent(this, MainActivity.class);
    activityIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    activityIntent.putExtras(bundle);
    PendingIntent pendingActivityIntent = PendingIntent.getActivity(this, 0, activityIntent, PendingIntent.FLAG_ONE_SHOT);

    // This non-Activity intent's click handler will need to use this method to track, see AlertBroadcastReceiver below
    Intent broadcastIntent = new Intent(this, AlertBroadcastReceiver.class);
    broadcastIntent.setAction("Action");
    broadcastIntent.putExtras(bundle);
    PendingIntent pendingBroadcastIntent = PendingIntent.getBroadcast(this, 0, broadcastIntent, PendingIntent.FLAG_ONE_SHOT);

    NotificationCompat.Builder notificationBuilder =
        new NotificationCompat.Builder(this, "default")
            .setContentTitle(remoteMessage.getNotification().getTitle())
            .setContentText(remoteMessage.getNotification().getBody())
            .setSmallIcon(R.mipmap.ic_launcher)
            .setAutoCancel(true)
            .setContentIntent(pendingActivityIntent)
            .addAction(R.mipmap.ic_launcher, "Action", pendingBroadcastIntent);

    NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationChannel channel = new NotificationChannel(
            "default", "Notifications", NotificationManager.IMPORTANCE_DEFAULT);
        notificationManager.createNotificationChannel(channel);
    }
    notificationManager.notify(notificationId, notificationBuilder.build());
}

// In your app manifest:
<receiver
    android:name=".AlertBroadcastReceiver"
    android:exported="false" />

// AlertBroadcastReceiver:
public class AlertBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        int notificationId = intent.getIntExtra("notificationId", -1);
        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        if (notificationId >= 0 && notificationManager != null) {
            // Clear notification:
            notificationManager.cancel(notificationId);

            // *** TRACKING THE CLICK: ***
            com.evergage.android.Context globalContext = Evergage.getInstance().getGlobalContext();
            if (globalContext != null) {
                globalContext.trackClickthrough(intent);
            }

            // ...any app-specific processing
        }
    }
}

Parameters

Parameter	Description
`notificationIntent`	The intent containing extras from the original `remoteMessage.getData()`, after the notification has been manually rendered and clicked

Since

1.3.0

See Also

viewItem

void viewItem(Item item)

Tracks that an item is being viewed.

Set null to indicate no longer viewing any item/category/tag.

For an Activity Screen, it is recommended to call this method within onStart() or onResume() before super.onResume(), if the item is known at that time.

Personalization will automatically track the time spent viewing the item while the context, app, and user is active. The item will remain the one viewed until viewItem or viewItemDetail(com.evergage.android.promote.Item) are called again.

Parameters

Parameter	Description
`item`	The item being viewed.

See Also

viewItem(Item, String)

viewItem(Item, String)

void viewItem(Item item,
              java.lang.String actionName)

Same as viewItem(Item) but with a different action name to distinguish this View Item. Only tracks an action if item is non-null.

Parameters

Parameter	Description
`item`	The item being viewed.
`actionName`	Optional different action name.

Since

1.3.0

viewItemDetail

void viewItemDetail(Item item)

Tracks that the details of an item are being viewed, such as other product images or a specifications tab. Set null to indicate no longer viewing any item/category/tag.

For an Activity Screen, it is recommended to call this method within onStart() or onResume() before super.onResume(), if the item is known at that time.

Personalization will automatically track the time spent viewing the item while the context, app, and user is active. The item will remain the one viewed until this method or viewItem(com.evergage.android.promote.Item) are called again.

Parameters

Parameter	Description
`item`	The item whose details are being viewed.

See Also

viewItemDetail(Item, String)

viewItemDetail(Item, String)

void viewItemDetail(Item item,
                    java.lang.String actionName)

Same as viewItemDetail(Item) but with a different action name to distinguish this View Item Detail.

Only tracks an action if the item is non-null.

Parameters

Parameter	Description
`item`	The item whose details are being viewed.
`actionName`	Optional different action name.

Since

1.3.0

viewCategory

void viewCategory(Category category)

Tracks that a category is being viewed.

Set null to indicate no longer viewing any item/category/tag.

For an Activity Screen, it is recommended to call this method within onStart() or onResume() before super.onResume(), if the category is known at that time.

Parameters

Parameter	Description
`category`	The category being viewed.

See Also

viewCategory(Category, String)

viewCategory(Category, String)

void viewCategory(Category category,
                  java.lang.String actionName)

Same as viewCategory(Category) but with a different action name to distinguish this View Category.

Only tracks an action if the category is non-null.

Parameters

Parameter	Description
`category`	The category being viewed.
`actionName`	Optional different action name.

Since

1.3.0

viewTag

void viewTag(Tag tag)

Tracks that a tag is being viewed. Set null to indicate no longer viewing any item/category/tag.

For an Activity Screen, it is recommended to call this method within onStart() or onResume() before super.onResume(), if the tag is known at that time.

Parameters

Parameter	Description
`tag`	The tag being viewed.

See Also

viewTag(Tag, String)

viewTag(Tag, String)

void viewTag(Tag tag,
             java.lang.String actionName)

Same as viewTag(Tag) but with a different action name to distinguish this View Tag. Only tracks an action if the tag is non-null.

Parameters

Parameter	Description
`tag`	The tag being viewed.
`actionName`	Optional different action name.

Since

1.3.0

addToCart

void addToCart(LineItem lineItem)

Tracks that a line item is being added to the shopping cart.

Parameters

Parameter	Description
`lineItem`	The line item being added.

purchase

void purchase(Order order)

Tracks that an order was purchased. If the order contains no lineItems, the lineItems currently in the cart will be used. If orderId is set and multiple purchase events are received for the same orderId, only the first will be used (all others will be ignored.)

Parameters

Parameter	Description
`order`	The order that was purchased.

review

void review(Item item)

Tracks that an item was reviewed, with no additional details. Equivalent of calling review(Item, Review) with null for the optional review details.

Parameters

Parameter	Description
`item`	The item that was reviewed.

review(Item, Review)

void review(Item item,
            Review reviewDetails)

Tracks that an item was reviewed, with the contents (optional) of the review.

Parameters

Parameter	Description
`item`	The item that was reviewed.
`reviewDetails`	The optional contents of the review, such as the rating.

void share(Item item)

Tracks that an item was shared, for instance by email or on a social network.

Parameters

Parameter	Description
`item`	The item that was shared.

comment

void comment(Item item)

Tracks that an item was commented on. For instance, an article or blog might accept comments.

Parameters

Parameter	Description
`item`	The item that was commented on.

favorite

void favorite(Item item)

Tracks that an item was marked by the user as a favorite item. This is an explicit action taken by the user (often indicated by a single star).

Parameters

Parameter	Description
`item`	The item that was marked as favorite.

trackAction

void trackAction(java.lang.String action)

Sends an event to Personalization describing an action to track. When considering the action name, remember that datasets encompass multiple platforms and apps. The name can match a corresponding action/behavior from another platform/app. A campaign can use a source rule to be limited to a specific source or set of sources. For information on recommended rules, see Mobile Data Campaigns.

Actions sent from this context (including Item APIs) can potentially receive a campaign in response, delivered to a handler via setCampaignHandler(com.evergage.android.CampaignHandler, java.lang.String).

Parameters

Parameter	Description
`action`	A short string that identifies the action.

Newer Version Available

This content describes an older version of this product. View Latest

Interface Context

Method Summary

isActive

setCampaignHandler

trackImpression

trackDismissal

trackClickthrough

trackClickthrough(Map)

trackClickthrough(Intent)

viewItem

viewItem(Item, String)

viewItemDetail

viewItemDetail(Item, String)

viewCategory

viewCategory(Category, String)

viewTag

viewTag(Tag, String)

addToCart

purchase

review

review(Item, Review)

comment

favorite

trackAction

No Results

Contents