Support Kontaktieren Sie Support | Systemstatus Systemstatus
Inhalt der Seite

    Leitfaden zum Lernen: Verwenden der REST APIs

    In diesem Thema erhalten Sie zunächst einen allgemeinen Überblick über die Verwendung der REST-APIs in Webanwendungen über XMLHttpRequest() und ein Proxy. Später im Dokument wird ein tieferer Tauchgang den Beispielcode diskutieren. Im ersten Beispiel wird der verwendet Analytics API , um in der Brightcove Player-Steuerleiste die Anzahl der Aufrufe abzurufen und anzuzeigen, die das Video derzeit im Player hat. Das zweite und etwas komplexere Beispiel verwendet den Analytics API in Verbindung mit dem Brightcove Player-Katalog, um die beliebtesten Videos von einem Konto abzurufen und in einer Playlist anzuzeigen. Die Codediskussion in diesem Dokument wird darauf abstehen, die gewünschten Daten aus der richtigen REST-API abzurufen.

    Ansicht auf hoher Ebene

    Um die REST APIs verwenden zu können, müssen Sie ein paar Teile an Ort und Stelle haben. In Kürze sind sie:

    • Code des Kunden: Der Client-Code fragt nach bestimmten Daten und zeigt sie dann entsprechend den Anwendungsanforderungen an. Der Client-Code wird in diesem Dokument ausführlich besprochen, da Sie am häufigsten schreiben müssen.
    • Proxyserver: Aus Sicherheitsgründen akzeptieren die REST-APIs keine Datenanfragen direkt vom Kunden, da dies das Senden vertraulicher Informationen, wie Kundenanmeldeinformationen, vom Kunden fördern würde. Dies bedeutet, dass ein Proxy als Vermittler zwischen dem Client und der REST-API fungiert. Der in den Beispielen verwendete Proxy wird in PHP geschrieben und später in diesem Dokument diskutiert. Der Proxy muss auf einem Server unter Ihrer Kontrolle eingerichtet sein und kann in der Sprache Ihrer Wahl geschrieben werden. Die vorgeschlagene Konfiguration des Proxys ermöglicht es, ihn einmal zu schreiben und von einer der APIs zu verwenden.
    • REST-APIs: Brightcove bietet einen umfassenden Satz von APIs zur Anpassung, Erweiterung und Integration in die Brightcove-Plattform. Sehen Sie sich die Übersicht an: Video Cloud-APIs Dokument für weitere Informationen.

    Das folgende Diagramm zeigt die Interaktion zwischen den drei Kerneinheiten des Prozesses zum Abrufen von Daten aus einer der REST-APIs von Brightcove:

    Grundlegende Stücke Überblick

    Überblick über Client-Funktionen

    Der clientseitige Code ändert sich erheblich, je nachdem, von welcher API Sie Daten anfordern. Wie oben erwähnt, ist der Proxy einmal geschrieben und ändert keinen Code, und die APIs werden von Brightcove verwaltet. Aus diesem Grund liegt der Schwerpunkt des Dokuments darauf, zu lernen, wie der Client-Code geändert werden kann, um die gewünschten Daten aus einer der APIs abzurufen.

    Das folgende Diagramm konzentriert sich auf wichtige Teile des Kundencodes, darunter:

    • Die Funktion, die das HTTPRequest zum Proxy macht. Um Mehrdeutigkeiten zu vermeiden, wird die Funktion benannt makeRequest(). Es ist auf der rechten Seite des Diagramms unten abgebildet.
    • Der Code, der die erforderlichen Informationen für die Anfrage sammelt. Es ist oben links im Diagramm abgebildet. Dieser Code ist in der Regel recht einfach und verwendet Konzepte, die selbst Anfängern bekannt sind.
    • Der Aufruf, der die zuvor erwähnte makeRequest() Funktion ausführt. Es ist unten links im Diagramm abgebildet. Der Aufruf übergibt eine Funktion makeRequest() als Parameter. Dann wird makeRequest() diese Funktion aufgerufen. Dies ist ein Beispiel für eine anonym definierte Callback-Funktion .

    Sie sehen die beiden Abschnitte im Diagramm mit der Bezeichnung Asynchrone Aktivität. Obwohl dies im Diagramm an zwei verschiedenen Stellen dargestellt wird, ist dies tatsächlich dieselbe asynchrone Aktivität und stellt die unbekannte Zeit dar, die für Folgendes benötigt wird:

    • Der Kunde, der die Anfrage an den Proxy sendet.
    • Der Proxy, der Daten von der API anfordert.
    • Die API, um das Resultset zu erstellen und an den Proxy zurückzugeben.
    • Der Proxy, der die Daten an den Client zurückgibt.

    Beachten Sie, dass die Logikflusspfeile aus der Box, die aufruft makeRequest() (unten links) darauf hinweisen, dass der Code zu zwei verschiedenen Zeiten ausgeführt wird, was genau der Fall ist. Der Aufruf der Funktion wird durchgeführt, aber die Callback-Funktion wird erst ausgeführt, wenn sie ihre Arbeit erledigt makeRequest() hat und die Callback-Funktion ausgeführt wird, die die angeforderten Daten an die Funktion zurückgibt, die Code aufruft.

    Überblick über Client-Funktionen

    Beispiel für Code-Reinung

    Anstatt den Code als ein Stück zu betrachten, wird er in Abschnitten vorgestellt und diskutiert. Einige der Abschnitte beziehen sich auf das obige Diagramm.

    Standard-Spielercode

    Dieser Codeabschnitt enthält den grundlegenden In-Page-Einbettungscode von Brightcove Player.

    • Zeilen 11 bis 21: Standardcode von Brightcove Player mit dem Hinzufügen eines id Attributs hinzugefügt.
    	<!doctype html>
    	<html>
    	
    	<head>
    		<meta charset="UTF-8">
    		<title>Untitled Document</title>
    	</head>
    	
    	<body>
    	
    	<video-js id="myPlayerID"
    		data-video-id="3851380732001"
    		data-account="1752604059001"
    		data-player="HkAzSmB0l"
    		data-embed="default"
    		data-application-id
    		class="video-js"
    		controls
    		width="640"
    		height="360"></video-js>
    	<script src="https://players.brightcove.net/1752604059001/HkAzSmB0l_default/index.min.js"></script>

    Vorbereiten eines Anrufs

    In diesem Codeabschnitt werden Variablen initialisiert und ist bereit für den Aufruf von makeRequest(). Im Allgemeinen müssen Sie für eine Leseanfrage die folgenden Informationen angeben:

    1. Die URL zu dem Proxy, den Sie verwenden werden, zum Beispiel (dies muss natürlich ein Proxy sein, der unter Ihrer Kontrolle steht):
      	https://solutions.brightcove.com/bcls/bcls-proxy/doc-samples-proxy-v2.php
    2. Die für die eigentliche Anfrage benötigte URL, normalerweise dynamisch aufgebaut:
      	https://analytics.api.brightcove.com/v1/alltime/accounts/1752604059001/videos/4825279519001
    3. Die HTTP-Methode zum Beispiel GET.

    Es folgt ein Beispiel:

    • 1. Zeile: Standardcode, um zu warten, bis der Spieler bereit ist, mit ihm zu interagieren.
    • Zeilen 2-4: Erstellen/setzen Sie Werte für später im Code benötigte Variablen.
    • Zeilen 7-12: Warten Sie auf das loadstart Ereignis, damit das mediainfo Objekt gefüllt ist. Weisen Sie Variablen zu, um die für den Analytics API Endpunkt benötigten Werte aufzunehmen.
    • Zeile 13: Legen Sie die HTTP-Methode für den Aufruf fest.
    	videojs.getPlayer('myPlayerID').ready(function() {
    	  var myPlayer = this,
    		accountId = myPlayer.bcinfo.accountId,
    		options = {};
    	
    		// +++ Wait for loadstart event so can use mediainfo object +++
    		myPlayer.on('loadstart', function() {
    			var videoId = myPlayer.mediainfo.id,
    			baseURL = 'https://analytics.api.brightcove.com/v1/alltime/accounts/',
    			endPoint = accountId + '/videos/' + videoId;
    			options.proxyURL = "https://solutions.brightcove.com/bcls/bcls-proxy/doc-samples-proxy-v2.php";
    			options.url = baseURL + endPoint;
    			options.requestType = "GET";

    Rufen makeRequest()

    In diesem Codeabschnitt wird der Aufruf zur makeRequest() Funktion gebracht. Beachten Sie, dass zwei Parameter übergeben werden. Das erste ist das Optionsobjekt, das Informationen für den Endpunkt enthält, und das zweite ist die Callback-Funktion. Denken Sie daran, dass dies ein asynchroner Aufruf ist, sodass die anonym definierte Callback-Funktion nicht aufgerufen wird, bis Daten von der REST-API an die makeRequest() Funktion zurückgegeben wurden.

    • 1. Zeile: Rufen Sie die makeRequest() Funktion auf und übergeben Sie die erforderlichen Werte für den Aufruf im options Objekt. In diesem Fall enthält das Objekt Folgendes:
      options -Objekt
    • Zeilen 3-13: Die Callback-Funktion ist als anonyme Funktion definiert (gelb hervorgehoben). Denken Sie daran, dass diese Funktion ein Parameter ist und nicht hier, sondern später im Code aufgerufen wird.
    • Zeilen 6, 8, 10: console.log() Anweisungen, die Folgendes anzeigen:
      • Die rohe JSON-Zeichenfolge, die vom API-Aufruf zurückgegeben wird.
      • Das von der JSON.parse() Methode generierte JSON-Objekt, das von einer Zeichenfolge in ein Objekt konvertiert.
      • Die tatsächlichen Ansichten zählen, die mit einfacher object.property Notation aus dem Objekt extrahiert werden.
    • Zeile 12: Ruft die Funktion auf, die die Anzahl der Ansichten in der Steuerungsleiste anzeigt.

    Der folgende Screenshot von der Konsole zeigt die tatsächlich angezeigten Daten aus den console.log Anweisungen:

    Verarbeitung von Daten in Callback-Funktion
    	// +++ Make the request to the Analytics API +++
    	// Extract views from data returned by Analytics API
    	makeRequest(options, function(viewsRaw) {
    	var viewsCount;
    	// Remove console.log command for production code
    	console.log('viewsRaw', viewsRaw);
    	viewsObject = JSON.parse(viewsRaw);
    	console.log('viewsObject', viewsObject);
    	viewsCount = viewsObject.alltime_video_views;
    	console.log('views', viewsCount);
    	// Call function to place data in controlbar
    	placeCountInControlbar(viewsCount);
    	});

    Tatsächliche makeRequest() Funktion

    In diesem Abschnitt des Dokuments wird der Code untersucht, der die makeRequest() Funktion tatsächlich definiert. Der Code, der die Funktion definiert, wird so geschrieben, dass er NICHT geändert, sondern wiederholt verwendet werden muss. Möglicherweise stellen Sie Edge Fälle fest, dass dies nicht der Fall ist, aber für die überwiegende Mehrheit der Anwendungen muss dieser Code NICHT geändert werden.

    Es folgt eine zeilenweise Diskussion des Codes:

    • Zeilen 1-6: Funktionsdefinition und Erstellung von Variablen Ein wichtiger Punkt ist, dass ein neues XMLHttpRequest Objekt erstellt wird.
    • Zeilen 8, 26: Definiert die Event-Handler-Funktion für readyState Änderungen.
    • Zeilen 9, 23, 25: Verwenden Sie a try-catch , falls die Anfrage auf hohem Niveau fehlschlägt.
    • Zeilen 10, 11: Verwenden Sie if Anweisungen, um sicherzustellen, dass die Anfrage beendetreadyState ist (4 ist) und erfolgreich abgeschlossen wurde. Der Status liegt im Bereich von 200. Das Folgende zeigt die Konsolenprotokollierung der readyState und status Werte in der Definition des Ereignishandlers:
      Logging ReadyState und Status
    • Zeile 18: Die Callback-Funktion wird ausgeführt. Dadurch werden die zurückgegebenen Daten von der API an die Callback-Funktion weitergeleitet, wie oben im Abschnitt Call MakeRequest () beschrieben.
    • Zeile 33: Legen Sie den Ereignishandler für das XMLHttpRequest.onreadystatechange Ereignis fest.
    • Zeile 35: Initialisiert die Anfrage an den Proxy.
    • Zeile 38: Sendet die Anfrage, die asynchron ist.
    	function makeRequest(options, callback) {
    	var httpRequest = new XMLHttpRequest(),
    	response,
    	requestParams,
    	dataString,
    	proxyURL = options.proxyURL,
    	// response handler
    	getResponse = function() {
    	try {
    		if (httpRequest.readyState === 4) {
    			if (httpRequest.status >= 200 && httpRequest.status < 300) {
    				response = httpRequest.responseText;
    				// some API requests return '{null}' for empty responses - breaks JSON.parse
    				if (response === '{null}') {
    					response = null;
    				}
    				// return the response
    				callback(response);
    			} else {
    				alert('There was a problem with the request. Request returned ' + httpRequest.status);
    			}
    		}
    	} catch (e) {
    		alert('Caught Exception: ' + e);
    	}
    	};
    	/**
    	* set up request data
    	* the proxy used here takes the following request body:
    	* JSON.stringify(options)
    	*/
    	// set response handler
    	httpRequest.onreadystatechange = getResponse;
    	// open the request
    	httpRequest.open('POST', proxyURL);
    	// set headers if there is a set header line, remove it
    	// open and send request
    	httpRequest.send(JSON.stringify(options));
    	}

    Anzeige der zurückgegebenen Daten

    Dieser Code zeigt, wie die zurückgegebenen Daten in die Steuerungsleiste eingefügt werden. Diese Funktion wird am Ende der Callback-Funktion aufgerufen, die oben im Abschnitt Call MakeREquest () angezeigt wird.

    • Zeilen 5, 16: Definieren Sie die Funktion.
    • Zeile 6: Erstellen Sie eine Variable für das spacer Element in der Steuerungsleiste.
    • Zeile 7: Erstellen Sie dynamisch ein div Element.
    • Zeile 9: Platzieren Sie eine Beschriftung und den Wert der Ansichten im neu erstellten div Element.
    • Zeile 11: Verwenden Sie die document.getElementsByClassName() JavaScript-Methode, um das spacer Element der Steuerungsleiste zu erhalten.
    • Zeile 13: Gestalten spacer Sie die, um die Gesamtansichten rechtsbündig und 10 px von oben nach unten anzuzeigen spacer.
    • Linie 15: Fügen Sie das neu erstellte, gefüllte und gestaltete Element dem hinzu spacer.
    	/**
    	* Dynamically build a div that is then
    	* placed in the controlbar's spacer element
    	*/
    	function placeCountInControlbar(viewsCount) {
    	var spacer,
    	newElement = document.createElement('div');
    	//Place data in div
    	newElement.innerHTML = "Total Views: " + viewsCount;
    	//Get the spacer in the controlbar
    	spacer = document.getElementsByClassName('vjs-spacer')[0];
    	//Right justify content in the spacer and add top margin
    	spacer.setAttribute('style', 'justify-content: flex-end; margin-top: 10px');
    	//Add the dynamically built div to the spacer in the controlbar
    	spacer.appendChild(newElement);
    	}

    Komplette Codeliste

    Der vollständige, funktionierende Code befindet sich in diesem GitHub-Repository: display-views-in-controlbar.html.

    Einfaches Debuggen

    Wie Sie sehen, gibt es eine Reihe von Teilen, die bei der Verwendung der REST-APIs beteiligt sind. Dies kann zu Herausforderungen führen, wenn eine App nicht ordnungsgemäß funktioniert. Wo fängst du an zu debuggen?

    Ein paar einfache Vorschläge werden in diesem Abschnitt gemacht und sind ein großartiger Ort, um Ihr Debugging-Abenteuer zu beginnen. In den folgenden beiden Abschnitten können Sie die grundlegendsten Informationen anzeigen, die Sie benötigen, was für den Anruf weitergeleitet wird und was zurückgegeben wird.

    Überprüfung der Anrufoptionen

    Beim clientseitigen Code, der in diesem Dokument diskutiert wird, geht es im Wesentlichen darum, die richtigen Optionen für die Verwendung mit dem Proxy und damit der eigentlichen API bereitzustellen. Daher ist es für das korrekte Funktionieren Ihres Codes von entscheidender Bedeutung, zu wissen, ob die Optionen korrekt sind. Eine einfache Möglichkeit, dies zu tun, besteht darin, das options Objekt an die Konsole zu protokollieren, bevor es an die makeRequest Funktion übergeben wird, in der es verwendet wird:

    Debugging-Code-Log-Optionen

    Was das Optionsobjekt enthält, hängt davon ab, was Sie tun möchten, aber einige Grundlagen werden immer vorhanden sein, die sind:

    • Die Konto-ID. Dies kann entweder eine separate Eigenschaft oder ein Teil der API-EndPoint-URL sein.
    • Die URL zum Proxy, die davon abhängt, wo Sie Ihren Proxy speichern.
    • Der HTTP-Methoden-Typ, zum Beispiel GET, POST oder PATCH.
    • Die API-Endpunkt-URL, die vom Proxy verwendet wird, um die eigentliche Anfrage von der API zu stellen. Beispiel:
      	https://players.api.brightcove.com/v2/accounts/57838016001/players
      	https://edge.api.brightcove.com/playback/v1/accounts/1752604059001/videos/5842800655001
      	https://analytics.api.brightcove.com/v1/alltime/accounts/1752604059001/videos/4093643993001

    Je nach API-Anforderung sind möglicherweise andere Eigenschaften im Optionsobjekt erforderlich. Hier ist ein Beispiel dafür, was Sie in der Konsole sehen würden, wenn Sie das Optionsobjekt protokollieren, um eine Anfrage für alle Spieler in einem bestimmten Konto zu stellen:

    Debugging-Optionen einfach

    Hier ist ein etwas komplexeres protokollierter Optionsobjekt, das beim Aktualisieren von

    Debugging-Optionen

    Anzeigen zurückgegebener Daten

    Was zurückgegeben wird, hängt davon ab, welche Daten Sie angefordert haben und ob ein Fehler zurückgegeben wird. Unabhängig davon, was zurückgegeben wird, möchten Sie höchstwahrscheinlich sehen, welche Daten zurückgegeben werden. Eine einfache Möglichkeit, dies zu tun, besteht darin, die response Rohdaten direkt nach dem Aufruf der makeRequest Funktion an die Konsole zu protokollieren:

    Debugging-Code-Log-Optionen

    Was zurückgegeben wird, hat fast unendliche Möglichkeiten, aber im Folgenden sind einige Beispiele aufgeführt. Der erste zeigt den Beginn einer Antwort, wenn Sie nach allen Spielern eines Kontos fragen:

    Debugging-Antwort auf Spieleranfrage

    Hier ist die Antwort nach der Aktualisierung der Spieler mit der PATCH HTTP-Methode:

    Debugging-Antwort auf Player-Patch

    Hier ist eine besser formatierte Ansicht der Daten in der ersten Antwort:

    	{
    		"id": "1OHQdsTAr",
    		"preview_url": "http://preview-players.brightcove.net/v2/accounts/.../master/index.html",
    		"preview_embed_in_page": "http://preview-players.brightcove.net/v2/accounts/.../master/in_page.embed",
    		"preview_embed_code": "<iframe src='//preview-players.brightcove.net/v2/accounts/.../master/index.html' ...></iframe>"
    	}

    Und schließlich ist hier eine sehr wertvolle Antwort aus dem Zeitpunkt, an dem ein Fehler aufgetreten ist. In diesem Fall wurde ein Konto ohne ordnungsgemäße Anmeldeinformationen verwendet:

    Debugging-Antwort bei Fehler

    Weitere Tipps zur Problembehandlung

    Wenn Sie Probleme haben, sollten Sie nach anderen Dingen suchen.

    Keine Antwort bekommen
    Es gibt ein paar Dinge, die Sie überprüfen sollten, wenn Sie eine leere Antwort erhalten:
    • Überprüfen Sie die API-Referenz, um sicherzustellen, dass die Anfrage eine Antwort zurückgibt. Einige geben nur eine Antwort von 201 oder 204 zurück, ohne Inhalt (insbesondere, aber nicht nur DELETE-Anfragen). Sie müssen Ihren Code anpassen, um diesen Fall zu behandeln.
    • Überprüfen Sie den Abschnitt Netzwerk der Developer Tools in Ihrem Browser, um sicherzustellen, dass Sie einen erfolgreichen Aufruf des Proxys sehen (dieser Server könnte vorübergehend nicht verfügbar sein):
      Abschnitt Developer Tools Netzwerk
      Abschnitt Developer Tools Netzwerk
    Ich sehe eine Antwort, aber wenn ich JSON.parse() es versuche, bekomme ich eine Ausnahme.
    Einige Möglichkeiten hier:
    • Siehe den vorherigen Punkt - der Versuch, einen leeren Stachel zu analysieren, löst eine JSON-Ausnahme aus
    • Sehen Sie sich die Antwort an und stellen Sie sicher, dass es sich um eine JSON-Zeichenfolge handelt (beginnend mit a { oder a [). Es gibt einige Fälle, in denen eine Anfrage JSON möglicherweise nicht zurückgibt - einen Analytics API Aufruf, z. B. wenn Sie den format Parameter auf csv oder setzen xlxs. Wenn Sie diese Art von Anfragen stellen, müssen Sie Ihren Code anpassen, um die Antworten ohne JSON zu verarbeiten.

    • In den meisten Fällen liegen Fehler, die von den APIs zurückgegeben werden, ebenfalls im JSON-Format vor, aber es gibt einige Ausnahmen, bei denen der Fehler als Klartext oder HTML zurückgegeben wird.

    Proxy-Code

    Wie bereits erwähnt, kann der Proxy in der Sprache Ihrer Wahl verfasst werden. In den Beispielen der Brightcove API-Dokumentation wird ein in PHP geschriebener Proxy verwendet. Da die Implementierung des Proxys so sprachabhängig ist, wird der folgende PHP-Code in diesem Dokument nicht detailliert analysiert.

    Die grundlegenden Funktionen eines Proxys müssen Folgendes umfassen:

    1. Akzeptiere die Kundenanfrage.
    2. Holen Sie sich ein Auth-Token von der OAuth API.
    3. Senden Sie das Auth-Token und die Datenanforderung (Endpunkt) an die beabsichtigte API.
    4. Empfangen Sie Daten von der API zurück.
    5. Senden Sie Daten zurück an den Kunden.
    	<?php
    	/**
    	 * proxy for Brightcove RESTful APIs
    	 * gets an access token, makes the request, and returns the response
    	 * Accessing:
    	 *     (note you should **always** access the proxy via HTTPS)
    	 *     Method: POST
    	 *     request body (accessed via php://input) is a JSON object with the following properties
    	 *
    	 * {string} url - the URL for the API request
    	 * {string} [requestType=GET] - HTTP method for the request
    	 * {string} [requestBody] - JSON data to be sent with write requests
    	 * {string} [client_id] - OAuth2 client id with sufficient permissions for the request
    	 * {string} [client_secret] - OAuth2 client secret with sufficient permissions for the request
    	 *
    	 * Example:
    	 * {
    	 *    "url": "https://cms.api.brightcove.com/v1/accounts/57838016001/video",
    	 *    "requestType": "PATCH",
    	 *    "client_id": "0072bebf-0616-442c-84de-7215bb176061",
    	 *    "client_secret": "7M0vMete8vP_Dmb9oIRdUN1S5lrqTvgtVvdfsasd",
    	 *    "requestBody": "{\"description\":\"Updated video description\"}"
    	 * }
    	 *
    	 * if client_id and client_secret are not included in the request, default values will be used
    	 *
    	 * @returns {string} $response - JSON response received from the API
    	 */
    	
    	// security checks
    	// if you want to do some basic security checks, such as checking the origin of the
    	// the request against some white list, this would be a good place to do it
    	// CORS enablement and other headers
    	header("Access-Control-Allow-Origin: *");
    	header("Content-type: application/json");
    	header("X-Content-Type-Options: nosniff");
    	header("X-XSS-Protection");
    	
    	// default account values
    	// if you work on one Brightcove account, put in the values below
    	// if you do not provide defaults, the client id, and client secret must
    	// be sent in the request body for each request
    	$default_client_id     = 'YOUR_CLIENT_ID';
    	$default_client_secret = 'YOUR_CLIENT_SECRET';
    	
    	// get request body
    	$requestData = json_decode(file_get_contents('php://input'));
    	
    	// set up access token request
    	// check to see if client id and secret were passed with the request
    	// and if so, use them instead of defaults
    	if (isset($requestData->client_id)) {
    			$client_id = $requestData->client_id;
    	}
    	
    	if (isset($requestData->client_secret)) {
    			$client_secret = $requestData->client_secret;
    	}
    	
    	$auth_string = "{$client_id}:{$client_secret}";
    	
    	// make the request to get an access token
    	$request = "https://oauth.brightcove.com/v4/access_token?grant_type=client_credentials";
    	$curl          = curl_init($request);
    	curl_setopt($curl, CURLOPT_USERPWD, $auth_string);
    	curl_setopt($curl, CURLOPT_POST, TRUE);
    	curl_setopt($curl, CURLOPT_RETURNTRANSFER, TRUE);
    	curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE);
    	curl_setopt($curl, CURLOPT_HTTPHEADER, array(
    		'Content-type: application/x-www-form-urlencoded',
    	));
    	
    	$response = curl_exec($curl);
    	$curl_info = curl_getinfo($curl);
    	$php_log = array(
    		"php_error_info" => $curl_info
    	);
    	$curl_error = curl_error($curl);
    	
    	curl_close($curl);
    	
    	// Check for errors
    	// it's useful to log as much info as possible for debugging
    	if ($response === FALSE) {
    		log_error($php_log, $curl_error);
    	}
    	
    	// Decode the response and get access token
    	$responseData = json_decode($response, TRUE);
    	$access_token = $responseData["access_token"];
    	// get request type or default to GET
    	$method = "GET";
    	if ($requestData->requestType) {
    			$method = $requestData->requestType;
    	}
    	
    	// get the URL and authorization info from the form data
    	$request = $requestData->url;
    	// check for a request body sent with the request
    	if (isset($requestData->requestBody)) {
    		$data = $requestData->requestBody;
    	}
    		$curl = curl_init($request);
    		curl_setopt($curl, CURLOPT_RETURNTRANSFER, TRUE);
    		curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE);
    		curl_setopt($curl, CURLOPT_HTTPHEADER, array(
    			'Content-type: application/json',
    			"Authorization: Bearer {$access_token}"
    		));
    		switch ($method)
    			{
    				case "POST":
    					curl_setopt($curl, CURLOPT_POST, TRUE);
    					if ($requestData->requestBody) {
    						curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
    					}
    					break;
    				case "PUT":
    					// don't use CURLOPT_PUT; it is not reliable
    					curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
    					if ($requestData->requestBody) {
    						curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
    					}
    					break;
    				case "PATCH":
    					curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
    					if ($requestData->requestBody) {
    						curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
    					}
    					break;
    				case "DELETE":
    					curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
    					if ($requestData->requestBody) {
    						curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
    					}
    					break;
    				default:
    					// GET request, nothing to do;
    			}
    		$response = curl_exec($curl);
    		$curl_info = curl_getinfo($curl);
    		$php_log = array(
    			"php_error_info" => $curl_info
    		);
    		$curl_error = curl_error($curl);
    		curl_close($curl);
    	
    	// Check for errors and log them if any
    	// note that logging will fail unless
    	// the file log.txt exists in the same
    	// directory as the proxy and is writable
    	
    	if ($response === FALSE) {
    		log_error($php_log, $curl_error);
    	}
    	
    	function log_error($php_log, $curl_error) {
    		$logEntry = "\nError:\n". "\n".date("Y-m-d H:i:s"). " UTC \n" .$curl_error. "\n".json_encode($php_log, JSON_PRETTY_PRINT);
    		$logFileLocation = "log.txt";
    		$fileHandle      = fopen($logFileLocation, 'a') or die("-1");
    		fwrite($fileHandle, $logEntry);
    		fclose($fileHandle);
    		echo "Error: there was a problem with your API call"+
    		die(json_encode($php_log, JSON_PRETTY_PRINT));
    	}
    	
    	// return the response to the AJAX caller
    	echo $response;
    	?>

    Obwohl der gesamte Code für den Proxy-Server oben dargestellt ist, befindet er sich auch im GitHub-Repository: sample-proxy-apps im php-Ordner .

    Beispiel 2

    Dieses zweite Beispiel ist komplexer als das zuvor ausführliche. In diesem Beispiel werden die 10 beliebtesten Videos eines Kontos in einer Playlist angezeigt. Die Hauptschritte des Codes sind:

    1. Anfrage von Analytics API den 10 Videos mit den meisten Ansichten in einem Konto. Dieser Schritt beinhaltet einen asynchronen Aufruf mit einer Callback-Funktion.
    2. Extrahieren Sie aus den zurückgegebenen Analytics API Daten nur die Video-IDs und platzieren Sie sie in einem Array. Es wird eine Hilfsfunktion geschrieben, um IDs aus den zurückgegebenen Daten zu extrahieren.
    3. Fordern Sie die vollständigen Videoobjekte für jedes der Videos in der Liste der IDs im Array an. Dieser Schritt beinhaltet das Überlaufen des Arrays und das Anfordern der Verwendung der Videoobjekte player.catalog.getVideo(). Dies beinhaltet natürlich mehrere asynchrone Anrufe, die den verwenden catalog. Eine Hilfsfunktion wird geschrieben, um die Videoobjekte basierend auf IDs abzurufen und die Objekte in ein Array zu platzieren.
    4. Platzieren Sie das Array der Videoobjekte in der Wiedergabeliste für einen Playlist-fähigen Player.

    Da Sie jetzt mit vielen der Konzepte und dem spezifischen Code zum Aufrufen der APIs vertraut sind, wird nur der Code beschrieben, der die makeRequest() Funktion aufruft.

    • Zeile 2: Rufen Sie die makeRequest() Funktion auf, die die für einen erfolgreichen REST-API-Aufruf erforderlichen Optionen zusammen mit einer anonym definierten Callback-Funktion (gelb hervorgehoben) als Argumente übergibt. Das dürfte von oben bekannt klingen. Ganz wichtig ist, dass die makeRequest() Funktion, die aufgerufen wird, GENAU DIESELBE FUNKTION IST, DIE IM VORHERIGEN BEISPIEL VERWENDET WURDE. Sie können das Gleiche in Ihrem Code tun. Die makeRequest() Funktion wurde so geschrieben, dass sie bei Aufrufen einer Brightcove REST API wiederverwendet werden kann.
    • 3. Zeile: Erstellen Sie eine Variable für die geparten JSON-Daten.
    • Zeile 5: Analysiert die zurückgegebenen Daten, die konvertiert werden sollen, wenn sie von einer Zeichenfolge in ein Objekt
    • Zeile 7: Verwenden Sie die Hilfsfunktion, um Video-IDs aus zurückgegebenen Daten zu extrahieren. Leider Analytics API gibt der nicht die vollständigen Videoobjekte zurück, daher werden IDs benötigt, um auf die vollständigen Objekte zuzugreifen.
    • Zeilen 9-12: Rufen Sie die getVideoData Hilfsfunktion auf, die eine Callback-Funktion verwendet, um das videoObjects Array basierend auf übergebenen IDs zu füllen.
    • Zeile 11: Füllen Sie die Wiedergabeliste mit dem Array von Videoobjekten.
    	// +++ Make the CMS API request to get matching video IDs +++
    	makeRequest(options, function(mostWatchedVideos) {
    		var JSONmostWatchedVideos;
    		// Convert response string into JSON
    		JSONmostWatchedVideos = JSON.parse(mostWatchedVideos);
    		// Extract the needed video IDs into an array
    		videoData = extractVideoData(JSONmostWatchedVideos);
    		// Get video objects based on array of video IDs
    		getVideoData(videoData, function(videoObjects) {
    			// Add the most watched videos list to the player as a playlist
    			myPlayer.playlist(videoObjects);
    		});
    	});

    Komplette Codeliste

    Das vollständige, funktionierende Beispiel befindet sich in diesem CodePen: Die meistgesehene Videos in einer Playlist.


    Seite zuletzt aktualisiert am 28 Sep 2020