The data layer is a map holding generic information about the application. It uses a standard set of keys so it can be read by any party that understands the specification. The data layer state is updated through its API. For example, an app might start with the following dataLayer:
{ title: "Original screen title" }
dataLayer.push(DataLayer.mapOf("title", "New screen title"));
{ title: "New screen title" }
dataLayer.push(DataLayer.mapOf("xyz", 3));
{ "title": "New screen title", "xyz": 3 }
{ "items": ["item1", null, "item2", {"a": "aValue", "b": "bValue"}] }
dataLayer.push("items", DataLayer.listOf(null, "item6", DataLayer.OBJECT_NOT_PRESENT, DataLayer.mapOf("a", null)));
{ "items": [null, "item6", "item2", {"a": null, "b": "bValue"}] }
Pushes happen synchronously; after the push, changes have been reflected in the model.
When an event
key is pushed to the data layer, rules for tags are evaluated and any
tags matching this event will fire.
For example, given a container with a tag whose firing rule is that "event" is equal to
"openScreen", after this push:
dataLayer.push("event", "openScreen");
Field Summary
public static final Object | OBJECT_NOT_PRESENT | Values of this type used in a List causes the List to be sparse when merging; it's as if there were no element at that index. |
Public Method Summary
Object |
get(String key)
|
static List<Object> |
listOf(Object... objects)
|
static Map<Object, Object> |
mapOf(Object... objects)
|
void |
push(Map<Object, Object> update)
|
void |
Fields
public static final Object OBJECT_NOT_PRESENT
Values of this type used in a List causes the List to be sparse when merging; it's as if there were no element at that index.
Public Methods
public Object get (String key)
Returns the object in the model associated with the given key. If the key is not found,
null
is returned.
The key can can have embedded periods. For example:
a key of "a.b.c"
returns a map with key "c"
in a map
with key "b"
in a map with key "a"
in the model.
public static List<Object> listOf (Object... objects)
Utility method that creates a list.
For example, the following creates a list containing "object1"
and
"object2"
:
List<Object> list = DataLayer.listOf("object1", "object2");
public static Map<Object, Object> mapOf (Object... objects)
Utility method that creates a map. The parameters should be pairs of key values.
For example, the following creates a map mapping "key1"
to "value1"
and "key2"
to "value2"
:
Map<Object, Object> map = DataLayer.mapOf("key1", "value1", "key2", "value2");
Throws
IllegalArgumentException | if there are an odd number of parameters |
public void push (Map<Object, Object> update)
Merges the given update
object into the existing data model, calling
any listeners with the update (after the merge occurs).
If you want to represent a missing value (like an empty index in a List),
use the OBJECT_NOT_PRESENT
object.
If another thread is executing a push, this call blocks until that thread is finished.
This is normally a synchronous call. However, if, while the thread is executing the push, another push happens from the same thread, then that second push is asynchronous (the second push will return before changes have been made to the data layer). This second push from the same thread can occur, for example, if a data layer push is made in response to a tag firing.
If the update
contains the key event
, rules will be evaluated and
matching tags will fire.
Parameters
update | the update object to process |
public void push (Object key, Object value)
Pushes a key/value pair of data to the data layer. This is just a convenience method
that calls push(DataLayer.mapOf(key, value))
.