sendMediaEvent

Última actualización: 6 de diciembre de 2024
  • Temas:

Creado para:

  • Desarrollador

El comando sendMediaEvent forma parte del componente streamingMedia del SDK web. Puede utilizar este componente para recopilar datos relacionados con las sesiones de contenido en el sitio web. Consulte la streamingMedia documentación para obtener información sobre cómo configurar este componente.

Utilice el comando sendMediaEvent para rastrear reproducciones de contenido, pausas, finalizaciones, actualizaciones de estado del reproductor y otros eventos relacionados.

El SDK web puede gestionar eventos de medios en función del tipo de seguimiento de sesión de medios:

  • Control de eventos para sesiones con seguimiento automático. En este modo no necesita pasar sessionID al evento de medios o al valor del cabezal de reproducción. El SDK web se encargará de esto, según el ID del reproductor proporcionado y la función de devolución de llamada getPlayerDetails proporcionada al iniciar la sesión de contenido.
  • Control de eventos para sesiones con seguimiento manual. En este modo necesita pasar sessionID al evento multimedia, junto con el valor del cabezal de reproducción (valor entero). También puede pasar los detalles de calidad de los datos de experiencia, si es necesario.

Administrar eventos de medios por tipo

Seleccione las pestañas siguientes para ver ejemplos de control de tipo de evento para cada tipo de evento y método de seguimiento de sesión (automático o manual).

Reproducir

El tipo de evento media.play se usa para rastrear cuándo comienza la reproducción de contenido. Este evento debe enviarse cuando el reproductor cambia de estado a "reproduciendo". Otros estados desde los que el reproductor pasa a "reproduciendo" incluyen "almacenamiento en búfer", reanudación de "pausa" por parte del usuario, recuperación de un error o reproducción automática.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.play"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.play",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Pause

El tipo de evento media.pauseStart se usa para hacer un seguimiento de cuándo se pone en pausa una reproducción de contenido. Este evento debe enviarse cuando el usuario presione Pausa. No hay ningún tipo de evento de reanudación. Se infiere una reanudación cuando se envía un evento media.play después de media.pauseStart.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.pauseStart"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.pauseStart",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Error

El tipo de evento media.error se usa para realizar un seguimiento de cuándo se produce un error durante la reproducción de contenido. Este evento debe enviarse cuando se produce un error.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.error",
        mediaCollection: {
            errorDetails: {
                name: "network-error",
                source: "player"
            }
        }
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.error",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID,
                errorDetails: {
                    name: "network-error",
                    source: "player"
                }
            }
        }
    });
});

Inicio de pausa publicitaria

El tipo de evento media.adBreakStart se usa para hacer un seguimiento de cuándo comienza una pausa publicitaria. Este evento debe enviarse cuando se inicie una pausa publicitaria.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.adBreakStart",
        mediaCollection: {
            advertisingPodDetails: {
                friendlyName: "Mid-roll",
                offset: 0,
                index: 1
            }
        }
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.adBreakStart",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID,
                advertisingPodDetails: {
                    friendlyName: "Mid-roll",
                    offset: 0,
                    index: 1
                }
            }
        }
    });
});

Pausa publicitaria completa

El tipo de evento media.adBreakComplete se usa para hacer un seguimiento de cuándo finaliza una pausa publicitaria. Este evento debe enviarse cuando se complete una pausa publicitaria.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.adBreakComplete"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.adBreakComplete",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Inicio del anuncio

El tipo de evento media.adStart se usa para hacer un seguimiento del inicio de un anuncio. Este evento debe enviarse cuando se inicie un anuncio.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.adStart",
        mediaCollection: {
            advertisingDetails: {
                friendlyName: "Ad 1",
                name: "/uri-reference/001",
                length: 10,
                advertiser: "Adobe Marketing",
                campaignID: "Adobe Analytics",
                creativeID: "creativeID",
                creativeURL: "https://creativeurl.com",
                placementID: "placementID",
                siteID: "siteID",
                podPosition: 11,
                playerName: "HTML5 player"
            },
            customMetadata: [{
                    name: "myCustomValue3",
                    value: "c3"
                },
                {
                    name: "myCustomValue2",
                    value: "c2"
                },
                {
                    name: "myCustomValue1",
                    value: "c1"
                }
            ]
        }
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
        eventType: "media.adStart",
        mediaCollection: {
            playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
            sessionID,
            advertisingDetails: {
              friendlyName: "Ad 1",
              name: "/uri-reference/001",
              length: 10,
              advertiser: "Adobe Marketing",
              campaignID: "Adobe Analytics",
              creativeID: "creativeID",
              creativeURL: "https://creativeurl.com",
              placementID: "placementID",
              siteID: "siteID",
              podPosition: 11,
              playerName: "HTML5 player"
            },
            customMetadata: [
              {
                name: "myCustomValue3",
                value: "c3"
              },
              {
                name: "myCustomValue2",
                value: "c2"
              },
              {
                name: "myCustomValue1",
                value: "c1"
              }]
        }
        }
    });
});

Anuncio completado

El tipo de evento media.adComplete se usa para hacer un seguimiento del momento en el que finaliza un anuncio. Este evento debe enviarse cuando se complete un anuncio.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.adComplete"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.adComplete",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Omisión de publicidad

El tipo de evento media.adSkip se usa para rastrear cuándo se omite un anuncio. Este evento debe enviarse cuando se omite un anuncio.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.adSkip"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.adSkip",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Inicio del capítulo

El tipo de evento media.chapterStart se usa para hacer un seguimiento de cuándo comienza un capítulo. Este evento debe enviarse cuando comience un capítulo.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.chapterStart",
        mediaCollection: {
            chapterDetails: {
                friendlyName: "Chapter 1",
                position: 1,
                length: 10,
                index: 1,
                offset: 0
            },
            customMetadata: [{
                    name: "myCustomValue3",
                    value: "c3"
                },
                {
                    name: "myCustomValue2",
                    value: "c2"
                },
                {
                    name: "myCustomValue1",
                    value: "c1"
                }
            ]
        }
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.chapterStart",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID,
                chapterDetails: {
                    friendlyName: "Chapter 1",
                    position: 1,
                    length: 10,
                    index: 1,
                    offset: 0
                },
                customMetadata: [{
                        name: "myCustomValue3",
                        value: "c3"
                    },
                    {
                        name: "myCustomValue2",
                        value: "c2"
                    },
                    {
                        name: "myCustomValue1",
                        value: "c1"
                    }
                ]
            }
        }
    });
});

Capítulo completado

El tipo de evento media.chapterComplete se usa para realizar un seguimiento del momento en que finaliza un capítulo. Este evento debe enviarse cuando se complete un capítulo.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.chapterComplete"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.chapterComplete",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Omisión de capítulo

El tipo de evento media.chapterSkip se usa para hacer un seguimiento de cuándo se omite un capítulo. Este evento debe enviarse cuando se omita un capítulo.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.chapterSkip"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.chapterSkip",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Inicio del búfer

El tipo de evento media.bufferStart se usa para hacer un seguimiento del inicio del almacenamiento en búfer. Este evento debe enviarse cuando se inicie el almacenamiento en búfer. No hay ningún tipo de evento bufferResume. Se infiere un bufferResume al enviar un evento de reproducción después de bufferStart.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.bufferStart"
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.bufferStart",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID
            }
        }
    });
});

Cambio de velocidad de bits

El tipo de evento media.bitrateChange se usa para realizar un seguimiento de cuándo cambia la velocidad de bits. Este evento debe enviarse cuando cambie la velocidad de bits.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.bitrateChange",
        mediaCollection: {
            qoeDataDetails: {
                framesPerSecond: 1,
                bitrate: 35000,
                droppedFrames: 30,
                timeToStart: 1364
            }
        }
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.bitrateChange",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID,
                qoeDataDetails: {
                    bitrate: 35000,
                    droppedFrames: 30,
                    timeToStart: 1364
                }
            }
        }
    });
});

Actualizaciones de estado

El tipo de evento media.statesUpdate se usa para rastrear cuándo cambia el estado del reproductor. Este evento debe enviarse cuando cambie el estado del reproductor.

alloy("sendMediaEvent", {
    playerId: "movie-test",
    xdm: {
        eventType: "media.statesUpdate",
        mediaCollection: {
            statesStart: [{
                    name: "mute"
                },
                {
                    name: "pictureInPicture"
                }
            ],
            statesEnd: [{
                name: "fullScreen"
            }]
        }
    }
});

sessionPromise.then(sessionID => {
    alloy("sendMediaEvent", {
        xdm: {
            eventType: "media.stateUpdate",
            mediaCollection: {
                playhead: parseInt(document.getElementById("movie-test").currentTime, 10),
                sessionID,
                statesStart: [{
                        name: "mute"
                    },
                    {
                        name: "pictureInPicture"
                    }
                ],
                statesEnd: [{
                    name: "fullScreen"
                }]
            }
        }
    });
});