]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - lib/oembedhelper.php
Merge remote-tracking branch 'origin/1.0.x' into 1.0.x
[quix0rs-gnu-social.git] / lib / oembedhelper.php
1 <?php
2 /*
3  * StatusNet - the distributed open-source microblogging tool
4  * Copyright (C) 2008-2010, StatusNet, Inc.
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU Affero General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the
14  * GNU Affero General Public License for more details.
15  *
16  * You should have received a copy of the GNU Affero General Public License
17  * along with this program.     If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 if (!defined('STATUSNET')) {
21     exit(1);
22 }
23
24
25 /**
26  * Utility class to wrap basic oEmbed lookups.
27  *
28  * Blacklisted hosts will use an alternate lookup method:
29  *  - Twitpic
30  *
31  * Whitelisted hosts will use known oEmbed API endpoints:
32  *  - Flickr, YFrog
33  *
34  * Sites that provide discovery links will use them directly; a bug
35  * in use of discovery links with query strings is worked around.
36  *
37  * Others will fall back to oohembed (unless disabled).
38  * The API endpoint can be configured or disabled through config
39  * as 'oohembed'/'endpoint'.
40  */
41 class oEmbedHelper
42 {
43     protected static $apiMap = array(
44         'flickr.com' => 'http://www.flickr.com/services/oembed/',
45         'yfrog.com' => 'http://www.yfrog.com/api/oembed',
46         'youtube.com' => 'http://www.youtube.com/oembed',
47         'viddler.com' => 'http://lab.viddler.com/services/oembed/',
48         'qik.com' => 'http://qik.com/api/oembed.json',
49         'revision3.com' => 'http://revision3.com/api/oembed/',
50         'hulu.com' => 'http://www.hulu.com/api/oembed.json',
51         'vimeo.com' => 'http://www.vimeo.com/api/oembed.json',
52         'my.opera.com' => 'http://my.opera.com/service/oembed',
53     );
54     protected static $functionMap = array(
55         'twitpic.com' => 'oEmbedHelper::twitPic',
56     );
57
58     /**
59      * Perform or fake an oEmbed lookup for the given resource.
60      *
61      * Some known hosts are whitelisted with API endpoints where we
62      * know they exist but autodiscovery data isn't available.
63      * If autodiscovery links are missing and we don't recognize the
64      * host, we'll pass it to oohembed.com's public service which
65      * will either proxy or fake info on a lot of sites.
66      *
67      * A few hosts are blacklisted due to known problems with oohembed,
68      * in which case we'll look up the info another way and return
69      * equivalent data.
70      *
71      * Throws exceptions on failure.
72      *
73      * @param string $url
74      * @param array $params
75      * @return object
76      */
77     public static function getObject($url, $params=array())
78     {
79         $host = parse_url($url, PHP_URL_HOST);
80         if (substr($host, 0, 4) == 'www.') {
81             $host = substr($host, 4);
82         }
83
84         common_log(LOG_INFO, 'Checking for oEmbed data for ' . $url);
85
86         // You can fiddle with the order of discovery -- either skipping
87         // some types or re-ordering them.
88
89         $order = common_config('oembed', 'order');
90
91         foreach ($order as $method) {
92
93             switch ($method) {
94             case 'built-in':
95                 common_log(LOG_INFO, 'Considering built-in oEmbed methods...');
96                 // Blacklist: systems with no oEmbed API of their own, which are
97                 // either missing from or broken on oohembed.com's proxy.
98                 // we know how to look data up in another way...
99                 if (array_key_exists($host, self::$functionMap)) {
100                     common_log(LOG_INFO, 'We have a built-in method for ' . $host);
101                     $func = self::$functionMap[$host];
102                     return call_user_func($func, $url, $params);
103                 }
104                 break;
105             case 'well-known':
106                 common_log(LOG_INFO, 'Considering well-known oEmbed endpoints...');
107                 // Whitelist: known API endpoints for sites that don't provide discovery...
108                 if (array_key_exists($host, self::$apiMap)) {
109                     $api = self::$apiMap[$host];
110                     common_log(LOG_INFO, 'Using well-known endpoint "' . $api . '" for "' . $host . '"');
111                     break 2;
112                 }
113                 break;
114             case 'discovery':
115                 try {
116                     common_log(LOG_INFO, 'Trying to discover an oEmbed endpoint using link headers.');
117                     $api = self::discover($url);
118                     common_log(LOG_INFO, 'Found API endpoint ' . $api . ' for URL ' . $url);
119                     break 2;
120                 } catch (Exception $e) {
121                     common_log(LOG_INFO, 'Could not find an oEmbed endpoint using link headers.');
122                     // Just ignore it!
123                 }
124                 break;
125             case 'service':
126                 $api = common_config('oembed', 'endpoint');
127                 common_log(LOG_INFO, 'Using service API endpoint ' . $api);
128                 break 2;
129                 break;
130             }
131         }
132
133         if (empty($api)) {
134             // TRANS: Server exception thrown in oEmbed action if no API endpoint is available.
135             throw new ServerException(_('No oEmbed API endpoint available.'));
136         }
137
138         return self::getObjectFrom($api, $url, $params);
139     }
140
141     /**
142      * Perform basic discovery.
143      * @return string
144      */
145     static function discover($url)
146     {
147         // @fixme ideally skip this for non-HTML stuff!
148         $body = self::http($url);
149         return self::discoverFromHTML($url, $body);
150     }
151
152     /**
153      * Partially ripped from OStatus' FeedDiscovery class.
154      *
155      * @param string $url source URL, used to resolve relative links
156      * @param string $body HTML body text
157      * @return mixed string with URL or false if no target found
158      */
159     static function discoverFromHTML($url, $body)
160     {
161         // DOMDocument::loadHTML may throw warnings on unrecognized elements,
162         // and notices on unrecognized namespaces.
163         $old = error_reporting(error_reporting() & ~(E_WARNING | E_NOTICE));
164         $dom = new DOMDocument();
165         $ok = $dom->loadHTML($body);
166         error_reporting($old);
167
168         if (!$ok) {
169             throw new oEmbedHelper_BadHtmlException();
170         }
171
172         // Ok... now on to the links!
173         $feeds = array(
174             'application/json+oembed' => false,
175         );
176
177         $nodes = $dom->getElementsByTagName('link');
178         for ($i = 0; $i < $nodes->length; $i++) {
179             $node = $nodes->item($i);
180             if ($node->hasAttributes()) {
181                 $rel = $node->attributes->getNamedItem('rel');
182                 $type = $node->attributes->getNamedItem('type');
183                 $href = $node->attributes->getNamedItem('href');
184                 if ($rel && $type && $href) {
185                     $rel = array_filter(explode(" ", $rel->value));
186                     $type = trim($type->value);
187                     $href = trim($href->value);
188
189                     if (in_array('alternate', $rel) && array_key_exists($type, $feeds) && empty($feeds[$type])) {
190                         // Save the first feed found of each type...
191                         $feeds[$type] = $href;
192                     }
193                 }
194             }
195         }
196
197         // Return the highest-priority feed found
198         foreach ($feeds as $type => $url) {
199             if ($url) {
200                 return $url;
201             }
202         }
203
204         throw new oEmbedHelper_DiscoveryException();
205     }
206
207     /**
208      * Actually do an oEmbed lookup to a particular API endpoint.
209      *
210      * @param string $api oEmbed API endpoint URL
211      * @param string $url target URL to look up info about
212      * @param array $params
213      * @return object
214      */
215     static function getObjectFrom($api, $url, $params=array())
216     {
217         $params['url'] = $url;
218         $params['format'] = 'json';
219         $data = self::json($api, $params);
220         return self::normalize($data);
221     }
222
223     /**
224      * Normalize oEmbed format.
225      *
226      * @param object $orig
227      * @return object
228      */
229     static function normalize($orig)
230     {
231         $data = clone($orig);
232
233         if (empty($data->type)) {
234             throw new Exception('Invalid oEmbed data: no type field.');
235         }
236
237         if ($data->type == 'image') {
238             // YFrog does this.
239             $data->type = 'photo';
240         }
241
242         if (isset($data->thumbnail_url)) {
243             if (!isset($data->thumbnail_width)) {
244                 // !?!?!
245                 $data->thumbnail_width = common_config('attachments', 'thumb_width');
246                 $data->thumbnail_height = common_config('attachments', 'thumb_height');
247             }
248         }
249
250         return $data;
251     }
252
253     /**
254      * Using a local function for twitpic lookups, as oohembed's adapter
255      * doesn't return a valid result:
256      * http://code.google.com/p/oohembed/issues/detail?id=19
257      *
258      * This code fetches metadata from Twitpic's own API, and attempts
259      * to guess proper thumbnail size from the original's size.
260      *
261      * @todo respect maxwidth and maxheight params
262      *
263      * @param string $url
264      * @param array $params
265      * @return object
266      */
267     static function twitPic($url, $params=array())
268     {
269         $matches = array();
270         if (preg_match('!twitpic\.com/(\w+)!', $url, $matches)) {
271             $id = $matches[1];
272         } else {
273             throw new Exception("Invalid twitpic URL");
274         }
275
276         // Grab metadata from twitpic's API...
277         // http://dev.twitpic.com/docs/2/media_show
278         $data = self::json('http://api.twitpic.com/2/media/show.json',
279                 array('id' => $id));
280         $oembed = (object)array('type' => 'photo',
281                                 'url' => 'http://twitpic.com/show/full/' . $data->short_id,
282                                 'width' => $data->width,
283                                 'height' => $data->height);
284         if (!empty($data->message)) {
285             $oembed->title = $data->message;
286         }
287
288         // Thumbnail is cropped and scaled to 150x150 box:
289         // http://dev.twitpic.com/docs/thumbnails/
290         $thumbSize = 150;
291         $oembed->thumbnail_url = 'http://twitpic.com/show/thumb/' . $data->short_id;
292         $oembed->thumbnail_width = $thumbSize;
293         $oembed->thumbnail_height = $thumbSize;
294
295         return $oembed;
296     }
297
298     /**
299      * Fetch some URL and return JSON data.
300      *
301      * @param string $url
302      * @param array $params query-string params
303      * @return object
304      */
305     static protected function json($url, $params=array())
306     {
307         $data = self::http($url, $params);
308         return json_decode($data);
309     }
310
311     /**
312      * Hit some web API and return data on success.
313      * @param string $url
314      * @param array $params
315      * @return string
316      */
317     static protected function http($url, $params=array())
318     {
319         $client = HTTPClient::start();
320         if ($params) {
321             $query = http_build_query($params, null, '&');
322             if (strpos($url, '?') === false) {
323                 $url .= '?' . $query;
324             } else {
325                 $url .= '&' . $query;
326             }
327         }
328         $response = $client->get($url);
329         if ($response->isOk()) {
330             return $response->getBody();
331         } else {
332             throw new Exception('Bad HTTP response code: ' . $response->getStatus());
333         }
334     }
335 }
336
337 class oEmbedHelper_Exception extends Exception
338 {
339     public function __construct($message = "", $code = 0, $previous = null)
340     {
341         parent::__construct($message, $code);
342     }
343 }
344
345 class oEmbedHelper_BadHtmlException extends oEmbedHelper_Exception
346 {
347     function __construct($previous=null)
348     {
349         return parent::__construct('Bad HTML in discovery data.', 0, $previous);
350     }
351 }
352
353 class oEmbedHelper_DiscoveryException extends oEmbedHelper_Exception
354 {
355     function __construct($previous=null)
356     {
357         return parent::__construct('No oEmbed discovery data.', 0, $previous);
358     }
359 }