Merge branch 'MDL-41662_master' of https://github.com/totara/openbadges
[moodle.git] / lib / classes / useragent.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Environment class to aid with the detection and establishment of the working environment.
19  *
20  * @package    core
21  * @copyright  2013 Sam Hemelryk
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 /**
26  * The user agent class.
27  *
28  * It's important to note that we do not like browser sniffing and its use in core code is highly discouraged.
29  * No new uses of this API will be integrated unless there is absolutely no alternative.
30  *
31  * This API supports the few browser checks we do have in core, all of which one day will hopefully be removed.
32  * The API will remain to support any third party use out there, however at some point like all code it will be deprecated.
33  *
34  * Use sparingly and only with good cause!
35  *
36  * @package    core
37  * @copyright  2013 Sam Hemelryk
38  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
39  */
40 class core_useragent {
42     /**
43      * The default for devices, think of as a computer.
44      */
45     const DEVICETYPE_DEFAULT = 'default';
46     /**
47      * Legacy devices, or at least legacy browsers. These are older devices/browsers
48      * that don't support standards.
49      */
50     const DEVICETYPE_LEGACY = 'legacy';
51     /**
52      * Mobile devices like your cell phone or hand held gaming device.
53      */
54     const DEVICETYPE_MOBILE = 'mobile';
55     /**
56      * Tables, larger than hand held, but still easily portable and smaller than a laptop.
57      */
58     const DEVICETYPE_TABLET = 'tablet';
60     /**
61      * An instance of this class.
62      * @var core_useragent
63      */
64     protected static $instance = null;
66     /**
67      * The device types we track.
68      * @var array
69      */
70     public static $devicetypes = array(
71         self::DEVICETYPE_DEFAULT,
72         self::DEVICETYPE_LEGACY,
73         self::DEVICETYPE_MOBILE,
74         self::DEVICETYPE_TABLET
75     );
77     /**
78      * The current requests user agent string if there was one.
79      * @var string|bool|null Null until initialised, false if none available, or string when available.
80      */
81     protected $useragent = null;
83     /**
84      * The users device type, one of self::DEVICETYPE_*.
85      * @var string null until initialised
86      */
87     protected $devicetype = null;
89     /**
90      * Custom device types entered into the admin interface.
91      * @var array
92      */
93     protected $devicetypecustoms = array();
95     /**
96      * True if the user agent supports the display of svg images. False if not.
97      * @var bool|null Null until initialised, then true or false.
98      */
99     protected $supportssvg = null;
101     /**
102      * Get an instance of the user agent object.
103      *
104      * @param bool $reload If set to true the user agent will be reset and all ascertations remade.
105      * @param string $forceuseragent The string to force as the user agent, don't use unless absolutely unavoidable.
106      * @return core_useragent
107      */
108     public static function instance($reload = false, $forceuseragent = null) {
109         if (!self::$instance || $reload) {
110             self::$instance = new core_useragent($forceuseragent);
111         }
112         return self::$instance;
113     }
115     /**
116      * Constructs a new user agent object. Publically you must use the instance method above.
117      *
118      * @param string|null $forceuseragent Optional a user agent to force.
119      */
120     protected function __construct($forceuseragent = null) {
121         global $CFG;
122         if (!empty($CFG->devicedetectregex)) {
123             $this->devicetypecustoms = json_decode($CFG->devicedetectregex);
124         }
125         if ($forceuseragent !== null) {
126             $this->useragent = $forceuseragent;
127         } else if (!empty($_SERVER['HTTP_USER_AGENT'])) {
128             $this->useragent = $_SERVER['HTTP_USER_AGENT'];
129         } else {
130             $this->useragent = false;
131             $this->devicetype = self::DEVICETYPE_DEFAULT;
132         }
133     }
135     /**
136      * Returns the user agent string.
137      * @return bool|string The user agent string or false if one isn't available.
138      */
139     public static function get_user_agent_string() {
140         $instance = self::instance();
141         return $instance->useragent;
142     }
144     /**
145      * Returns the device type we believe is being used.
146      * @return string
147      */
148     public static function get_device_type() {
149         $instance = self::instance();
150         if ($instance->devicetype === null) {
151             return $instance->guess_device_type();
152         }
153         return $instance->devicetype;
154     }
156     /**
157      * Guesses the device type the user agent is running on.
158      *
159      * @return string
160      */
161     protected function guess_device_type() {
162         global $CFG;
163         if (empty($CFG->enabledevicedetection)) {
164             $this->devicetype = self::DEVICETYPE_DEFAULT;
165             return $this->devicetype;
166         }
167         foreach ($this->devicetypecustoms as $value => $regex) {
168             if (preg_match($regex, $this->useragent)) {
169                 $this->devicetype = $value;
170                 return $this->devicetype;
171             }
172         }
173         if ($this->is_useragent_mobile()) {
174             $this->devicetype = 'mobile';
175         } else if ($this->is_useragent_tablet()) {
176             $this->devicetype = 'tablet';
177         } else if (substr($this->useragent, 0, 34) === 'Mozilla/4.0 (compatible; MSIE 6.0;') {
178             // Safe way to check for IE6 and not get false positives for some IE 7/8 users.
179             $this->devicetype = 'legacy';
180         } else {
181             $this->devicetype = self::DEVICETYPE_DEFAULT;
182         }
183         return $this->devicetype;
184     }
186     /**
187      * Returns true if the user appears to be on a mobile device.
188      * @return bool
189      */
190     protected function is_useragent_mobile() {
191         // Mobile detection PHP direct copy from open source detectmobilebrowser.com.
192         $phonesregex = '/android .+ mobile|avantgo|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i';
193         $modelsregex = '/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|e\-|e\/|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(di|rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|xda(\-|2|g)|yas\-|your|zeto|zte\-/i';
194         return (preg_match($phonesregex, $this->useragent) || preg_match($modelsregex, substr($this->useragent, 0, 4)));
195     }
197     /**
198      * Returns true if the user appears to be on a tablet.
199      * @return int
200      */
201     protected function is_useragent_tablet() {
202         $tabletregex = '/Tablet browser|android|iPad|iProd|GT-P1000|GT-I9000|SHW-M180S|SGH-T849|SCH-I800|Build\/ERE27|sholest/i';
203         return (preg_match($tabletregex, $this->useragent));
204     }
206     /**
207      * Gets a list of known device types.
208      *
209      * @param bool $includecustomtypes If set to true we'll include types that have been added by the admin.
210      * @return array
211      */
212     public static function get_device_type_list($includecustomtypes = true) {
213         $types = self::$devicetypes;
214         if ($includecustomtypes) {
215             $instance = self::instance();
216             $types = array_merge($types, array_keys($instance->devicetypecustoms));
217         }
218         return $types;
219     }
221     /**
222      * Returns the theme to use for the given device type.
223      *
224      * This used to be get_selected_theme_for_device_type.
225      * @param null|string $devicetype The device type to find out for. Defaults to the device the user is using,
226      * @return bool
227      */
228     public static function get_device_type_theme($devicetype = null) {
229         global $CFG;
230         if ($devicetype === null) {
231             $devicetype = self::get_device_type();
232         }
233         $themevarname = self::get_device_type_cfg_var_name($devicetype);
234         if (empty($CFG->$themevarname)) {
235             return false;
236         }
237         return $CFG->$themevarname;
238     }
240     /**
241      * Returns the CFG var used to find the theme to use for the given device.
242      *
243      * Used to be get_device_cfg_var_name.
244      *
245      * @param null|string $devicetype The device type to find out for. Defaults to the device the user is using,
246      * @return string
247      */
248     public static function get_device_type_cfg_var_name($devicetype = null) {
249         if ($devicetype == self::DEVICETYPE_DEFAULT || empty($devicetype)) {
250             return 'theme';
251         }
252         return 'theme' . $devicetype;
253     }
255     /**
256      * Gets the device type the user is currently using.
257      * @return string
258      */
259     public static function get_user_device_type() {
260         $device = self::get_device_type();
261         $switched = get_user_preferences('switchdevice'.$device, false);
262         if ($switched != false) {
263             return $switched;
264         }
265         return $device;
266     }
268     /**
269      * Switches the device type we think the user is using to what ever was given.
270      * @param string $newdevice
271      * @return bool
272      * @throws coding_exception
273      */
274     public static function set_user_device_type($newdevice) {
275         $devicetype = self::get_device_type();
276         if ($newdevice == $devicetype) {
277             unset_user_preference('switchdevice'.$devicetype);
278             return true;
279         } else {
280             $devicetypes = self::get_device_type_list();
281             if (in_array($newdevice, $devicetypes)) {
282                 set_user_preference('switchdevice'.$devicetype, $newdevice);
283                 return true;
284             }
285         }
286         throw new coding_exception('Invalid device type provided to set_user_device_type');
287     }
289     /**
290      * Returns true if the user agent matches the given brand and the version is equal to or greater than that specified.
291      *
292      * @param string $brand The branch to check for.
293      * @param scalar $version The version if we need to find out if it is equal to or greater than that specified.
294      * @return bool
295      */
296     public static function check_browser_version($brand, $version = null) {
297         switch ($brand) {
299             case 'MSIE':
300                 // Internet Explorer.
301                 return self::check_ie_version($version);
303             case 'Firefox':
304                 // Mozilla Firefox browsers.
305                 return self::check_firefox_version($version);
307             case 'Chrome':
308                 return self::check_chrome_version($version);
310             case 'Opera':
311                 // Opera.
312                 return self::check_opera_version($version);
314             case 'Safari':
315                 // Desktop version of Apple Safari browser - no mobile or touch devices.
316                 return self::check_safari_version($version);
318             case 'Safari iOS':
319                 // Safari on iPhone, iPad and iPod touch.
320                 return self::check_safari_ios_version($version);
322             case 'WebKit':
323                 // WebKit based browser - everything derived from it (Safari, Chrome, iOS, Android and other mobiles).
324                 return self::check_webkit_version($version);
326             case 'Gecko':
327                 // Gecko based browsers.
328                 return self::check_gecko_version($version);
330             case 'WebKit Android':
331                 // WebKit browser on Android.
332                 return self::check_webkit_android_version($version);
334             case 'Camino':
335                 // OSX browser using Gecke engine.
336                 return self::check_camino_version($version);
337         }
338         // Who knows?! doesn't pass anyway.
339         return false;
340     }
342     /**
343      * Checks the user agent is camino based and that the version is equal to or greater than that specified.
344      *
345      * Camino browser is at the end of its life, its no longer being developed or supported, just don't worry about it.
346      *
347      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
348      * @return bool
349      */
350     protected static function check_camino_version($version = null) {
351         // OSX browser using Gecko engine.
352         $useragent = self::get_user_agent_string();
353         if ($useragent === false) {
354             return false;
355         }
356         if (strpos($useragent, 'Camino') === false) {
357             return false;
358         }
359         if (empty($version)) {
360             return true; // No version specified.
361         }
362         if (preg_match("/Camino\/([0-9\.]+)/i", $useragent, $match)) {
363             if (version_compare($match[1], $version) >= 0) {
364                 return true;
365             }
366         }
367         return false;
368     }
370     /**
371      * Checks the user agent is Firefox based and that the version is equal to or greater than that specified.
372      *
373      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
374      * @return bool
375      */
376     public static function check_firefox_version($version = null) {
377         // Mozilla Firefox browsers.
378         $useragent = self::get_user_agent_string();
379         if ($useragent === false) {
380             return false;
381         }
382         if (strpos($useragent, 'Firefox') === false && strpos($useragent, 'Iceweasel') === false) {
383             return false;
384         }
385         if (empty($version)) {
386             return true; // No version specified..
387         }
388         if (preg_match("/(Iceweasel|Firefox)\/([0-9\.]+)/i", $useragent, $match)) {
389             if (version_compare($match[2], $version) >= 0) {
390                 return true;
391             }
392         }
393         return false;
394     }
396     /**
397      * Checks the user agent is Gecko based and that the version is equal to or greater than that specified.
398      *
399      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
400      * @return bool
401      */
402     public static function check_gecko_version($version = null) {
403         // Gecko based browsers.
404         // Do not look for dates any more, we expect real Firefox version here.
405         $useragent = self::get_user_agent_string();
406         if ($useragent === false) {
407             return false;
408         }
409         if (empty($version)) {
410             $version = 1;
411         } else if ($version > 20000000) {
412             // This is just a guess, it is not supposed to be 100% accurate!
413             if (preg_match('/^201/', $version)) {
414                 $version = 3.6;
415             } else if (preg_match('/^200[7-9]/', $version)) {
416                 $version = 3;
417             } else if (preg_match('/^2006/', $version)) {
418                 $version = 2;
419             } else {
420                 $version = 1.5;
421             }
422         }
423         if (preg_match("/(Iceweasel|Firefox)\/([0-9\.]+)/i", $useragent, $match)) {
424             // Use real Firefox version if specified in user agent string.
425             if (version_compare($match[2], $version) >= 0) {
426                 return true;
427             }
428         } else if (preg_match("/Gecko\/([0-9\.]+)/i", $useragent, $match)) {
429             // Gecko might contain date or Firefox revision, let's just guess the Firefox version from the date.
430             $browserver = $match[1];
431             if ($browserver > 20000000) {
432                 // This is just a guess, it is not supposed to be 100% accurate!
433                 if (preg_match('/^201/', $browserver)) {
434                     $browserver = 3.6;
435                 } else if (preg_match('/^200[7-9]/', $browserver)) {
436                     $browserver = 3;
437                 } else if (preg_match('/^2006/', $version)) {
438                     $browserver = 2;
439                 } else {
440                     $browserver = 1.5;
441                 }
442             }
443             if (version_compare($browserver, $version) >= 0) {
444                 return true;
445             }
446         }
447         return false;
448     }
450     /**
451      * Checks the user agent is IE and that the version is equal to or greater than that specified.
452      *
453      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
454      * @return bool
455      */
456     public static function check_ie_version($version = null) {
457         // Internet Explorer.
458         $useragent = self::get_user_agent_string();
459         if ($useragent === false) {
460             return false;
461         }
462         if (strpos($useragent, 'Opera') !== false) {
463             // Reject Opera.
464             return false;
465         }
466         // In case of IE we have to deal with BC of the version parameter.
467         if (is_null($version)) {
468             $version = 5.5; // Anything older is not considered a browser at all!
469         }
470         // IE uses simple versions, let's cast it to float to simplify the logic here.
471         $version = round($version, 1);
472         // See: http://www.useragentstring.com/pages/Internet%20Explorer/.
473         if (preg_match("/MSIE ([0-9\.]+)/", $useragent, $match)) {
474             $browser = $match[1];
475         } else {
476             return false;
477         }
478         // IE8 and later versions may pretend to be IE7 for intranet sites, use Trident version instead,
479         // the Trident should always describe the capabilities of IE in any emulation mode.
480         if ($browser === '7.0' and preg_match("/Trident\/([0-9\.]+)/", $useragent, $match)) {
481             $browser = $match[1] + 4; // NOTE: Hopefully this will work also for future IE versions.
482         }
483         $browser = round($browser, 1);
484         return ($browser >= $version);
485     }
487     /**
488      * Checks the user agent is Opera and that the version is equal to or greater than that specified.
489      *
490      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
491      * @return bool
492      */
493     public static function check_opera_version($version = null) {
494         // Opera.
495         $useragent = self::get_user_agent_string();
496         if ($useragent === false) {
497             return false;
498         }
499         if (strpos($useragent, 'Opera') === false) {
500             return false;
501         }
502         if (empty($version)) {
503             return true; // No version specified.
504         }
505         // Recent Opera useragents have Version/ with the actual version, e.g.:
506         // Opera/9.80 (Windows NT 6.1; WOW64; U; en) Presto/2.10.289 Version/12.01
507         // That's Opera 12.01, not 9.8.
508         if (preg_match("/Version\/([0-9\.]+)/i", $useragent, $match)) {
509             if (version_compare($match[1], $version) >= 0) {
510                 return true;
511             }
512         } else if (preg_match("/Opera\/([0-9\.]+)/i", $useragent, $match)) {
513             if (version_compare($match[1], $version) >= 0) {
514                 return true;
515             }
516         }
517         return false;
518     }
520     /**
521      * Checks the user agent is Webkit based and that the version is equal to or greater than that specified.
522      *
523      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
524      * @return bool
525      */
526     public static function check_webkit_version($version = null) {
527         // WebKit based browser - everything derived from it (Safari, Chrome, iOS, Android and other mobiles).
528         $useragent = self::get_user_agent_string();
529         if ($useragent === false) {
530             return false;
531         }
532         if (strpos($useragent, 'AppleWebKit') === false) {
533             return false;
534         }
535         if (empty($version)) {
536             return true; // No version specified.
537         }
538         if (preg_match("/AppleWebKit\/([0-9.]+)/i", $useragent, $match)) {
539             if (version_compare($match[1], $version) >= 0) {
540                 return true;
541             }
542         }
543         return false;
544     }
546     /**
547      * Checks the user agent is Safari based and that the version is equal to or greater than that specified.
548      *
549      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
550      * @return bool
551      */
552     public static function check_safari_version($version = null) {
553         // Desktop version of Apple Safari browser - no mobile or touch devices.
554         $useragent = self::get_user_agent_string();
555         if ($useragent === false) {
556             return false;
557         }
558         if (strpos($useragent, 'AppleWebKit') === false) {
559             return false;
560         }
561         // Look for AppleWebKit, excluding strings with OmniWeb, Shiira and SymbianOS and any other mobile devices.
562         if (strpos($useragent, 'OmniWeb')) {
563             // Reject OmniWeb.
564             return false;
565         }
566         if (strpos($useragent, 'Shiira')) {
567             // Reject Shiira.
568             return false;
569         }
570         if (strpos($useragent, 'SymbianOS')) {
571             // Reject SymbianOS.
572             return false;
573         }
574         if (strpos($useragent, 'Android')) {
575             // Reject Androids too.
576             return false;
577         }
578         if (strpos($useragent, 'iPhone') or strpos($useragent, 'iPad') or strpos($useragent, 'iPod')) {
579             // No Apple mobile devices here - editor does not work, course ajax is not touch compatible, etc.
580             return false;
581         }
582         if (strpos($useragent, 'Chrome')) { // Reject chrome browsers - it needs to be tested explicitly.
583             return false;
584         }
586         if (empty($version)) {
587             return true; // No version specified.
588         }
589         if (preg_match("/AppleWebKit\/([0-9.]+)/i", $useragent, $match)) {
590             if (version_compare($match[1], $version) >= 0) {
591                 return true;
592             }
593         }
594         return false;
595     }
597     /**
598      * Checks the user agent is Chrome based and that the version is equal to or greater than that specified.
599      *
600      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
601      * @return bool
602      */
603     public static function check_chrome_version($version = null) {
604         // Chrome.
605         $useragent = self::get_user_agent_string();
606         if ($useragent === false) {
607             return false;
608         }
609         if (strpos($useragent, 'Chrome') === false) {
610             return false;
611         }
612         if (empty($version)) {
613             return true; // No version specified.
614         }
615         if (preg_match("/Chrome\/(.*)[ ]+/i", $useragent, $match)) {
616             if (version_compare($match[1], $version) >= 0) {
617                 return true;
618             }
619         }
620         return false;
621     }
623     /**
624      * Checks the user agent is Webkit based and on Android and that the version is equal to or greater than that specified.
625      *
626      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
627      * @return bool
628      */
629     public static function check_webkit_android_version($version = null) {
630         // WebKit browser on Android.
631         $useragent = self::get_user_agent_string();
632         if ($useragent === false) {
633             return false;
634         }
635         if (strpos($useragent, 'Linux; U; Android') === false) {
636             return false;
637         }
638         if (empty($version)) {
639             return true; // No version specified.
640         }
641         if (preg_match("/AppleWebKit\/([0-9]+)/i", $useragent, $match)) {
642             if (version_compare($match[1], $version) >= 0) {
643                 return true;
644             }
645         }
646         return false;
647     }
649     /**
650      * Checks the user agent is Safari on iOS and that the version is equal to or greater than that specified.
651      *
652      * @param string|int $version A version to check for, returns true if its equal to or greater than that specified.
653      * @return bool
654      */
655     public static function check_safari_ios_version($version = null) {
656         // Safari on iPhone, iPad and iPod touch.
657         $useragent = self::get_user_agent_string();
658         if ($useragent === false) {
659             return false;
660         }
661         if (strpos($useragent, 'AppleWebKit') === false or strpos($useragent, 'Safari') === false) {
662             return false;
663         }
664         if (!strpos($useragent, 'iPhone') and !strpos($useragent, 'iPad') and !strpos($useragent, 'iPod')) {
665             return false;
666         }
667         if (empty($version)) {
668             return true; // No version specified.
669         }
670         if (preg_match("/AppleWebKit\/([0-9]+)/i", $useragent, $match)) {
671             if (version_compare($match[1], $version) >= 0) {
672                 return true;
673             }
674         }
675         return false;
676     }
678     /**
679      * Check if the user agent matches a given brand.
680      *
681      * Known brand: 'Windows','Linux','Macintosh','SGI','SunOS','HP-UX'
682      *
683      * @param string $brand
684      * @return bool
685      */
686     public static function check_browser_operating_system($brand) {
687         $useragent = self::get_user_agent_string();
688         return ($useragent !== false && preg_match("/$brand/i", $useragent));
689     }
691     /**
692      * Gets an array of CSS classes to represent the user agent.
693      * @return array
694      */
695     public static function get_browser_version_classes() {
696         $classes = array();
697         if (self::check_ie_version('0')) {
698             $classes[] = 'ie';
699             for ($i = 12; $i >= 6; $i--) {
700                 if (self::check_ie_version($i)) {
701                     $classes[] = 'ie'.$i;
702                     break;
703                 }
704             }
705         } else if (self::check_firefox_version() || self::check_gecko_version() || self::check_camino_version()) {
706             $classes[] = 'gecko';
707             if (preg_match('/rv\:([1-2])\.([0-9])/', self::get_user_agent_string(), $matches)) {
708                 $classes[] = "gecko{$matches[1]}{$matches[2]}";
709             }
710         } else if (self::check_webkit_version()) {
711             $classes[] = 'safari';
712             if (self::check_safari_ios_version()) {
713                 $classes[] = 'ios';
714             } else if (self::check_webkit_android_version()) {
715                 $classes[] = 'android';
716             }
717         } else if (self::check_opera_version()) {
718             $classes[] = 'opera';
719         }
720         return $classes;
721     }
723     /**
724      * Returns true if the user agent supports the display of SVG images.
725      *
726      * @return bool
727      */
728     public static function supports_svg() {
729         // IE 5 - 8 don't support SVG at all.
730         $instance = self::instance();
731         if ($instance->supportssvg === null) {
732             if ($instance->useragent === false) {
733                 // Can't be sure, just say no.
734                 $instance->supportssvg = false;
735             } else if (self::check_ie_version() and !self::check_ie_version('9')) {
736                 // IE < 9 doesn't support SVG. Say no.
737                 $instance->supportssvg = false;
738             } else if (preg_match('#Android +[0-2]\.#', $instance->useragent)) {
739                 // Android < 3 doesn't support SVG. Say no.
740                 $instance->supportssvg = false;
741             } else if (self::check_opera_version()) {
742                 // Opera 12 still does not support SVG well enough. Say no.
743                 $instance->supportssvg = false;
744             } else {
745                 // Presumed fine.
746                 $instance->supportssvg = true;
747             }
748         }
749         return $instance->supportssvg;
750     }