Support Kontakt Support | Systemstatus Systemstatus
Seiteninhalt

    Lernhandbuch: 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 in diesem Dokument wird ein tieferer Tauchgang den Beispielcode besprechen. Das erste Beispiel verwendet die Analytics API abzurufen und in der anzuzeigen Brightcove player Steuerleiste Die Anzahl der Aufrufe des Videos in der player hat gehabt. Das zweite und etwas komplexere Beispiel verwendet das Analytics API in Verbindung mit den Brightcove Player Katalog, um die beliebtesten Videos von einem Konto abzurufen und in einer Wiedergabeliste anzuzeigen. Die Codediskussion in diesem Dokument konzentriert sich auf das Abrufen der gewünschten Daten von der richtigen REST-API.

    High-Level-Ansicht

    Um die REST-APIs verwenden zu können, müssen einige Teile vorhanden sein. Kurz gesagt, sind sie:

    • Clientcode: 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.
    • Proxy ServerAus Sicherheitsgründen akzeptieren die REST-APIs keine Datenanforderungen direkt vom Client, da dies das Senden vertraulicher Informationen wie Clientanmeldeinformationen vom Client anregen 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 besprochen. Der Proxy muss auf einem Server unter Ihrer Kontrolle eingerichtet werden und kann in der Sprache Ihrer Wahl geschrieben werden. Die vorgeschlagene Konfiguration des Proxy ermöglicht es, dass er einmal geschrieben und von einer der APIs verwendet wird.
    • REST-APIs: Brightcove bietet einen umfassenden Satz von APIs zum Anpassen, Erweitern und Integrieren in die Brightcove-Plattform. Siehe die Überblick: Video Cloud APIs Dokument für weitere Informationen.

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

    Grundlegende Stückübersicht

    Client-Funktionsübersicht

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

    Das folgende Diagramm konzentriert sich auf Schlüsselbereiche des Client-Codes:

    • Die Funktion, die das macht HTTPRequest zum Proxy. Um Mehrdeutigkeiten zu vermeiden, wird die Funktion benannt makeRequest(). Es ist auf der rechten Seite des Diagramms unten abgebildet.
    • Der Code, der erforderliche Informationen für die Anforderung erfasst. Es ist oben links im Diagramm dargestellt. Dieser Code ist in der Regel ziemlich geradlinig und verwendet Konzepte, die selbst für Anfänger sehr bekannt sind.
    • Der Aufruf, der das zuvor erwähnte ausführt makeRequest() Funktion. Es ist auf der unteren linken Seite des Diagramms abgebildet. Der Anruf übergibt eine Funktion an makeRequest() als ein Parameter. Dann in makeRequest() Diese Funktion wird aufgerufen. Dies ist ein Beispiel für eine anonym definierte callback Funktion.

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

    • Der Client, um die Anfrage an den Proxy zu senden.
    • Der Proxy zum Anfordern von Daten von der API.
    • Die API, um die Ergebnismenge zu erstellen und an den Proxy zurückzugeben.
    • Der Proxy, um die Daten an den Client zurückzugeben.

    Beachten Sie, dass die Logikflusspfeile aus dem Feld, das aufruft makeRequest() (unten links) scheint anzuzeigen, dass der Code zu zwei verschiedenen Zeiten ausgeführt wird, was genau der Fall ist. Der Aufruf der Funktion erfolgt, aber die Callback-Funktion wird erst ausgeführt makeRequest() hat seine Aufgabe erfüllt und die Callback-Funktion ausgeführt, die die angeforderten Daten an die Funktionsaufruf-Code zurückgibt.

    Client-Funktionsübersicht

    Beispielcode-Walkthrough

    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 player Code

    Dieser Codeabschnitt enthält die Grundlagen Brightcove Player In-Page-Embed-Code.

    • Zeilen 11-21: Standard Brightcove Player Code mit dem Zusatz eines id Attribut 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, um einen Anruf zu tätigen

    Dieser Codeabschnitt initialisiert Variablen und macht sich bereit, den Aufruf zu machen makeRequest(). Im Allgemeinen müssen Sie für eine Leseanfrage folgende Informationen angeben:

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

    Ein Beispiel folgt:

    • Zeile 1: Standardcode zum Warten bis zum player ist bereit zu interagieren.
    • Zeilen 2-4: Erstellen / Festlegen von Werten für Variablen, die später im Code benötigt werden.
    • Zeilen 7-12: Warte auf die loadstart Ereignis also das mediainfo Objekt ist gefüllt. Weisen Sie Variablen zu, die die für die erforderlichen Werte enthalten Analytics API Endpunkt.
    • 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 Sie uns an makeRequest()

    Dieser Codeabschnitt ruft den Aufruf auf makeRequest() Funktion. 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, so dass die anonym definierte Callback-Funktion erst aufgerufen wird, wenn Daten von der REST-API an die zurückgegeben wurden makeRequest() Funktion.

    • Linie 1: Rufen Sie die makeRequest() Funktion, übergibt die erforderlichen Werte für den Aufruf in der options Objekt. In diesem Fall enthält das Objekt Folgendes:
      Optionen 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 aufgerufen wird, sondern später im Code.
    • Zeilen 6, 8, 10: console.log() Anweisungen, die anzeigen:
      • Die unformatierte JSON-Zeichenfolge, die vom API-Aufruf zurückgegeben wird.
      • Das JSON-Objekt, das von JSON.parse() Methode, die die Umwandlung von String in Objekt durchführt.
      • Die tatsächlichen Ansichten zählen, extrahiert aus dem Objekt mit einfachen object.property Notation.
    • Linie 12: Ruft die Funktion auf, die die Anzahl der Ansichten in der Kontrollleiste anzeigt.

    Der folgende Screenshot von der Konsole zeigt die aktuell angezeigten Daten aus der console.log Aussagen:

    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ächlich makeRequest() Funktion

    Dieser Abschnitt des Dokuments untersucht den Code, der den makeRequest() Funktion. Der Code, der die Funktion definiert, ist so geschrieben, dass er NICHT geändert werden muss, sondern wie er ist wiederholt verwendet wird. Möglicherweise finden Sie Randfälle, in denen dies nicht der Fall ist, aber für die überwiegende Mehrheit der Verwendungen muss dieser Code NICHT geändert werden.

    Eine Zeile für Zeile Diskussion des Codes folgt:

    • Zeilen 1-6: Funktionsdefinition und Variablenerstellung. Ein wichtiger Punkt ist, dass ein neuer XMLHttpRequest Objekt wird erstellt.
    • Zeilen 8, 26: Definiert die Event-Handler-Funktion für readyState ändert.
    • Zeilen 9, 23, 25: Verwenden Sie a try-catch falls die Anfrage auf einem hohen Level fehlschlägt.
    • Zeilen 10, 11: Verwenden if Aussagen, um sicher zu sein, dass die Anfrage beendet ist (readyState ist 4) und erfolgreich abgeschlossen, der Status liegt im 200-Bereich. Das Folgende zeigt die Konsolenprotokollierung des readyState und status Werte in der Event-Handler-Definition:
      Logging readyState und Status
    • Zeile 18: Die Callback-Funktion wird ausgeführt. Dadurch werden die zurückgegebenen Daten von der API zurück an die Rückruffunktion übergeben, wie in den Details beschrieben Aufruf makeRequest () Abschnitt oben.
    • Zeile 33: Legen Sie den Ereignishandler für die XMLHttpRequest.onreadystatechange Ereignis.
    • 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));
    	}

    Zeigen Sie die zurückgegebenen Daten an

    Dieser Code zeigt, wie die zurückgegebenen Daten in der Steuerleiste platziert werden. Diese Funktion wird am Ende der Callback-Funktion aufgerufen, angezeigt in Aufruf makeRequest () Abschnitt oben.

    • Zeilen 5, 16: Definieren Sie die Funktion.
    • Zeile 6: Erstelle eine Variable für die spacer Element in der Steuerleiste.
    • Linie 7: Erstelle dynamisch ein div Element.
    • Zeile 9: Platziere eine Beschriftung und den Wert der Ansichten in dem neu erstellten div Element.
    • Linie 11: Verwenden Sie JavaScript document.getElementsByClassName() Methode, um die Controlbars zu bekommen spacer Element.
    • Linie 13: Stil der spacer um die Gesamtansichten rechtsbündig und 10px von oben nach unten anzuzeigen spacer.
    • Linie 15: Fügen Sie das neu erstellte, bevölkerte und gestylte Element 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);
    	}

    Vollständige Code-Auflistung

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

    Einfaches Debugging

    Wie Sie sehen, sind bei der Verwendung der REST-APIs einige Elemente beteiligt. Dies kann zu Problemen führen, wenn eine App nicht ordnungsgemäß funktioniert. Wo fängst du an zu debuggen?

    In diesem Abschnitt werden einige einfache Vorschläge gemacht, die ein großartiger Ort sind, um mit Ihrem Debugging-Abenteuer zu beginnen. In den folgenden zwei Abschnitten können Sie die grundlegendsten Informationen anzeigen, die Sie benötigen, was zum Anruf übergeben wird und was zurückgegeben wird.

    Anrufoptionen prüfen

    Bei dem in diesem Dokument behandelten clientseitigen Code handelt es sich im Wesentlichen nur darum, die richtigen Optionen bereitzustellen, die mit dem Proxy verwendet werden sollen, und wiederum die tatsächliche API. Das Wissen um die richtigen Optionen ist daher für die korrekte Funktionsweise Ihres Codes unerlässlich. Ein einfacher Weg, dies zu tun, ist die Anmeldung an der Konsole options Objekt kurz bevor sie in die übergehen makeRequest Funktion, wo sie verwendet werden:

    Optionen für das Debuggen von Code-Protokollen

    Was das Optionsobjekt enthält, hängt von dem ab, was Sie versuchen, aber es werden immer einige Grundlagen vorhanden sein.

    • Die Konto-ID Dies kann entweder eine separate Eigenschaft sein oder Teil der API-EndPoint-URL.
    • Die URL zum Proxy, die davon abhängt, wo Sie Ihren Proxy speichern.
    • Zum Beispiel der HTTP-Methodentyp GET, POST or PATCH.
    • Die API-Endpunkt-URL, die vom Proxy verwendet wird, um die tatsächliche Anforderung von der API auszuführen. Zum 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

    Abhängig von der API-Anforderung können im Optionsobjekt andere Eigenschaften erforderlich sein. Hier ein Beispiel, was Sie in der Konsole sehen würden, wenn Sie das Optionsobjekt für eine Anforderung an alle Spieler in einem bestimmten Konto protokollieren:

    Debugging-Optionen einfach

    Hier ist ein etwas komplexeres Objekt für protokollierte Optionen, das beim Aktualisieren verwendet wird players:

    Debugging-Optionen

    Anzeigen der zurückgegebenen 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, das Raw-Protokoll an der Konsole anzumelden response Daten kurz nach dem Aufruf an die makeRequest Funktion:

    Optionen für das Debuggen von Code-Protokollen

    Was zurückgegeben wird, hat nahezu unendlich viele Möglichkeiten, aber im Folgenden sind einige Beispiele aufgeführt. Die erste zeigt den Beginn einer Antwort, wenn nach allen gefragt wird players in einem Konto:

    Debugging-Antwort auf Spieleranfrage

    Hier ist die Antwort nach dem Update players, mit dem PATCH HTTP-Methode:

    Debugging-Antwort auf Player-Patch

    Hier ist eine schönere 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 zum Schluss noch eine wertvolle Antwort darauf, wann ein Fehler aufgetreten ist. In diesem Fall wurde ein Konto ohne korrekte Anmeldeinformationen verwendet:

    Debugging-Antwort auf Fehler

    Weitere Tipps zur Fehlerbehebung

    Wenn Sie Probleme haben, sollten Sie einige andere Dinge beachten.

    Keine Antwort erhalten
    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 Anforderung eine Antwort zurückgibt. Einige geben nur eine 201- oder 204-Antwort ohne Inhalt zurück (insbesondere aber nicht nur DELETE-Anforderungen). Sie müssen Ihren Code anpassen, um diesen Fall zu bearbeiten.
    • Überprüfen Sie den Netzwerkabschnitt der Entwicklertools in Ihrem Browser, um sicherzustellen, dass ein erfolgreicher Aufruf des Proxys angezeigt wird (dieser Server ist möglicherweise vorübergehend nicht verfügbar):
      Developer Tools Network-Abschnitt
      Developer Tools Network-Abschnitt
    Ich sehe eine Antwort, aber wenn ich es versuche JSON.parse() Ich bekomme eine Ausnahme.
    Einige Möglichkeiten hier:
    • Siehe vorheriges Element - Wenn Sie versuchen, einen leeren Stich zu analysieren, wird eine JSON-Ausnahme ausgelöst
    • Sehen Sie sich die Antwort an und stellen Sie sicher, dass es sich um eine JSON-Zeichenfolge handelt (beginnend mit einem { oder nach einem [). Es gibt einige Fälle, in denen eine Anforderung möglicherweise kein JSON zurückgibt - eine Analytics API anrufen, wenn Sie z format Parameter csv or xlxs. Wenn Sie diese Art von Abfragen durchführen, müssen Sie Ihren Code anpassen, um Nicht-JSON-Antworten zu verarbeiten.

    • In den meisten Fällen liegen die von den APIs zurückgegebenen Fehler auch im JSON-Format vor. Es gibt jedoch einige Ausnahmen, bei denen der Fehler als Nur-Text oder HTML-Code zurückgegeben wird.

    Proxy-Code

    Wie bereits erwähnt, kann der Proxy in der Sprache Ihrer Wahl verfasst werden. In den Dokumentationsbeispielen für die Brightcove-API 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 im Detail analysiert.

    Die von einem Proxy bereitgestellte grundlegende Funktionalität muss Folgendes umfassen:

    1. Akzeptieren Sie die Clientanfrage.
    2. Holen Sie ein Authentifizierungs-Token von dem OAuth API.
    3. Senden Sie das Authentifizierungs-Token und die Datenanforderung (Endpunkt) an die beabsichtigte API.
    4. Empfangen von Daten von der API
    5. Senden Sie Daten zurück zum Client.
    	<?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;
    	?>

    Der gesamte Code für den Proxyserver ist oben aufgeführt, befindet sich jedoch auch im GitHub-Repository: Beispiel-Proxy-Apps in php Ordner.

    Beispiel 2

    Dieses zweite Beispiel ist komplexer als das zuvor beschriebene. In diesem Beispiel werden die beliebtesten 10-Videos von einem Konto in einer Wiedergabeliste angezeigt. Die wichtigsten Schritte des Codes sind:

    1. Anfrage von der Analytics API die 10-Videos mit den meisten Ansichten in einem Konto. Dieser Schritt beinhaltet einen asynchronen Aufruf unter Verwendung einer Rückruffunktion.
    2. Von den zurückgekehrten Analytics API Daten, extrahieren Sie nur die Video-IDs und platzieren Sie sie in einem Array. Eine Hilfsfunktion wird 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 Schleifen des Arrays und das Anfordern der Videoobjekte mit player.catalog.getVideo(). Dies betrifft natürlich mehrere asynchrone Aufrufe mit dem 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 von Videoobjekten in der Wiedergabeliste für eine Wiedergabeliste, die aktiviert ist player.

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

    • Linie 2: Rufen Sie die makeRequest() Funktion übergibt als Argumente die für einen erfolgreichen REST-API-Aufruf erforderlichen Optionen sowie eine anonym definierte Callback-Funktion (gelb hervorgehoben). Dies sollte von oben bekannt klingen. Sehr wichtig, die makeRequest() Funktion, die als genau die gleiche Funktion wie im vorherigen Beispiel verwendet wird. Sie können dasselbe in Ihrem Code tun. Das makeRequest() Die Funktion wurde so geschrieben, dass sie bei Aufrufen einer Brightcove-REST-API wiederverwendet werden kann.
    • Zeile 3: Erstellen Sie eine Variable, die die von JSON analysierten zurückgegebenen Daten enthält.
    • Zeile 5: Analysiert die zurückgegebenen Daten, um sie von einer Zeichenfolge in ein Objekt zu konvertieren.
    • Zeile 7: Verwenden Sie die Hilfsfunktion, um Video-IDs aus den zurückgegebenen Daten zu extrahieren. Leider die Analytics API gibt nicht die vollständigen Videoobjekte zurück, daher sind IDs erforderlich, um auf die vollständigen Objekte zuzugreifen.
    • Zeilen 9-12: Rufen Sie die getVideoData Hilfsfunktion, die eine Callback - Funktion zum Auffüllen der videoObjects Array basierend auf übergebenen IDs.
    • Zeile 11: Füllen Sie die Wiedergabeliste mit dem Array von Videoobjekten auf.
    	// +++ 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);
    		});
    	});

    Vollständige Code-Auflistung

    Das vollständige Funktionsbeispiel finden Sie in diesem CodePen: Die meisten beobachteten Videos in einer Playlist.


    Seite zuletzt aktualisiert am 28