vendor/matomo/device-detector/DeviceDetector.php line 188

Open in your IDE?
  1. <?php
  3. /**
  4.  * Device Detector - The Universal Device Detection library for parsing User Agents
  5.  *
  6.  * @link https://matomo.org
  7.  *
  8.  * @license http://www.gnu.org/licenses/lgpl.html LGPL v3 or later
  9.  */
  11. declare(strict_types=1);
  13. namespace DeviceDetector;
  15. use DeviceDetector\Cache\CacheInterface;
  16. use DeviceDetector\Cache\StaticCache;
  17. use DeviceDetector\Parser\AbstractBotParser;
  18. use DeviceDetector\Parser\Bot;
  19. use DeviceDetector\Parser\Client\AbstractClientParser;
  20. use DeviceDetector\Parser\Client\Browser;
  21. use DeviceDetector\Parser\Client\FeedReader;
  22. use DeviceDetector\Parser\Client\Library;
  23. use DeviceDetector\Parser\Client\MediaPlayer;
  24. use DeviceDetector\Parser\Client\MobileApp;
  25. use DeviceDetector\Parser\Client\PIM;
  26. use DeviceDetector\Parser\Device\AbstractDeviceParser;
  27. use DeviceDetector\Parser\Device\Camera;
  28. use DeviceDetector\Parser\Device\CarBrowser;
  29. use DeviceDetector\Parser\Device\Console;
  30. use DeviceDetector\Parser\Device\HbbTv;
  31. use DeviceDetector\Parser\Device\Mobile;
  32. use DeviceDetector\Parser\Device\Notebook;
  33. use DeviceDetector\Parser\Device\PortableMediaPlayer;
  34. use DeviceDetector\Parser\Device\ShellTv;
  35. use DeviceDetector\Parser\OperatingSystem;
  36. use DeviceDetector\Parser\VendorFragment;
  37. use DeviceDetector\Yaml\ParserInterface as YamlParser;
  38. use DeviceDetector\Yaml\Spyc;
  40. /**
  41.  * Class DeviceDetector
  42.  *
  43.  * Magic Device Type Methods:
  44.  * @method bool isSmartphone()
  45.  * @method bool isFeaturePhone()
  46.  * @method bool isTablet()
  47.  * @method bool isPhablet()
  48.  * @method bool isConsole()
  49.  * @method bool isPortableMediaPlayer()
  50.  * @method bool isCarBrowser()
  51.  * @method bool isTV()
  52.  * @method bool isSmartDisplay()
  53.  * @method bool isSmartSpeaker()
  54.  * @method bool isCamera()
  55.  * @method bool isWearable()
  56.  * @method bool isPeripheral()
  57.  *
  58.  * Magic Client Type Methods:
  59.  * @method bool isBrowser()
  60.  * @method bool isFeedReader()
  61.  * @method bool isMobileApp()
  62.  * @method bool isPIM()
  63.  * @method bool isLibrary()
  64.  * @method bool isMediaPlayer()
  65.  */
  66. class DeviceDetector
  67. {
  68.     /**
  69.      * Current version number of DeviceDetector
  70.      */
  71.     public const VERSION = '6.0.5';
  73.     /**
  74.      * Constant used as value for unknown browser / os
  75.      */
  76.     public const UNKNOWN = 'UNK';
  78.     /**
  79.      * Holds all registered client types
  80.      * @var array
  81.      */
  82.     protected $clientTypes = [];
  84.     /**
  85.      * Holds the useragent that should be parsed
  86.      * @var string
  87.      */
  88.     protected $userAgent = '';
  90.     /**
  91.      * Holds the client hints that should be parsed
  92.      * @var ?ClientHints
  93.      */
  94.     protected $clientHints = null;
  96.     /**
  97.      * Holds the operating system data after parsing the UA
  98.      * @var ?array
  99.      */
  100.     protected $os = null;
  102.     /**
  103.      * Holds the client data after parsing the UA
  104.      * @var ?array
  105.      */
  106.     protected $client = null;
  108.     /**
  109.      * Holds the device type after parsing the UA
  110.      * @var ?int
  111.      */
  112.     protected $device = null;
  114.     /**
  115.      * Holds the device brand data after parsing the UA
  116.      * @var string
  117.      */
  118.     protected $brand = '';
  120.     /**
  121.      * Holds the device model data after parsing the UA
  122.      * @var string
  123.      */
  124.     protected $model = '';
  126.     /**
  127.      * Holds bot information if parsing the UA results in a bot
  128.      * (All other information attributes will stay empty in that case)
  129.      *
  130.      * If $discardBotInformation is set to true, this property will be set to
  131.      * true if parsed UA is identified as bot, additional information will be not available
  132.      *
  133.      * If $skipBotDetection is set to true, bot detection will not be performed and isBot will
  134.      * always be false
  135.      *
  136.      * @var array|bool|null
  137.      */
  138.     protected $bot = null;
  140.     /**
  141.      * @var bool
  142.      */
  143.     protected $discardBotInformation = false;
  145.     /**
  146.      * @var bool
  147.      */
  148.     protected $skipBotDetection = false;
  150.     /**
  151.      * Holds the cache class used for caching the parsed yml-Files
  152.      * @var CacheInterface
  153.      */
  154.     protected $cache = null;
  156.     /**
  157.      * Holds the parser class used for parsing yml-Files
  158.      * @var YamlParser
  159.      */
  160.     protected $yamlParser = null;
  162.     /**
  163.      * @var array<AbstractClientParser>
  164.      */
  165.     protected $clientParsers = [];
  167.     /**
  168.      * @var array<AbstractDeviceParser>
  169.      */
  170.     protected $deviceParsers = [];
  172.     /**
  173.      * @var array<AbstractBotParser>
  174.      */
  175.     public $botParsers = [];
  177.     /**
  178.      * @var bool
  179.      */
  180.     private $parsed = false;
  182.     /**
  183.      * Constructor
  184.      *
  185.      * @param string      $userAgent   UA to parse
  186.      * @param ClientHints $clientHints Browser client hints to parse
  187.      */
  188.     public function __construct(string $userAgent = '', ?ClientHints $clientHints = null)
  189.     {
  190.         if ('' !== $userAgent) {
  191.             $this->setUserAgent($userAgent);
  192.         }
  194.         if ($clientHints instanceof ClientHints) {
  195.             $this->setClientHints($clientHints);
  196.         }
  198.         $this->addClientParser(new FeedReader());
  199.         $this->addClientParser(new MobileApp());
  200.         $this->addClientParser(new MediaPlayer());
  201.         $this->addClientParser(new PIM());
  202.         $this->addClientParser(new Browser());
  203.         $this->addClientParser(new Library());
  205.         $this->addDeviceParser(new HbbTv());
  206.         $this->addDeviceParser(new ShellTv());
  207.         $this->addDeviceParser(new Notebook());
  208.         $this->addDeviceParser(new Console());
  209.         $this->addDeviceParser(new CarBrowser());
  210.         $this->addDeviceParser(new Camera());
  211.         $this->addDeviceParser(new PortableMediaPlayer());
  212.         $this->addDeviceParser(new Mobile());
  214.         $this->addBotParser(new Bot());
  215.     }
  217.     /**
  218.      * @param string $methodName
  219.      * @param array  $arguments
  220.      *
  221.      * @return bool
  222.      */
  223.     public function __call(string $methodName, array $arguments): bool
  224.     {
  225.         foreach (AbstractDeviceParser::getAvailableDeviceTypes() as $deviceName => $deviceType) {
  226.             if (\strtolower($methodName) === 'is' . \strtolower(\str_replace(' ', '', $deviceName))) {
  227.                 return $this->getDevice() === $deviceType;
  228.             }
  229.         }
  231.         foreach ($this->clientTypes as $client) {
  232.             if (\strtolower($methodName) === 'is' . \strtolower(\str_replace(' ', '', $client))) {
  233.                 return $this->getClient('type') === $client;
  234.             }
  235.         }
  237.         throw new \BadMethodCallException("Method {$methodName} not found");
  238.     }
  240.     /**
  241.      * Sets the useragent to be parsed
  242.      *
  243.      * @param string $userAgent
  244.      */
  245.     public function setUserAgent(string $userAgent): void
  246.     {
  247.         if ($this->userAgent !== $userAgent) {
  248.             $this->reset();
  249.         }
  251.         $this->userAgent = $userAgent;
  252.     }
  254.     /**
  255.      * Sets the browser client hints to be parsed
  256.      *
  257.      * @param ?ClientHints $clientHints
  258.      */
  259.     public function setClientHints(?ClientHints $clientHints = null): void
  260.     {
  261.         if ($this->clientHints !== $clientHints) {
  262.             $this->reset();
  263.         }
  265.         $this->clientHints = $clientHints;
  266.     }
  268.     /**
  269.      * @param AbstractClientParser $parser
  270.      *
  271.      * @throws \Exception
  272.      */
  273.     public function addClientParser(AbstractClientParser $parser): void
  274.     {
  275.         $this->clientParsers[] = $parser;
  276.         $this->clientTypes[]   = $parser->getName();
  277.     }
  279.     /**
  280.      * @return array<AbstractClientParser>
  281.      */
  282.     public function getClientParsers(): array
  283.     {
  284.         return $this->clientParsers;
  285.     }
  287.     /**
  288.      * @param AbstractDeviceParser $parser
  289.      *
  290.      * @throws \Exception
  291.      */
  292.     public function addDeviceParser(AbstractDeviceParser $parser): void
  293.     {
  294.         $this->deviceParsers[] = $parser;
  295.     }
  297.     /**
  298.      * @return array<AbstractDeviceParser>
  299.      */
  300.     public function getDeviceParsers(): array
  301.     {
  302.         return $this->deviceParsers;
  303.     }
  305.     /**
  306.      * @param AbstractBotParser $parser
  307.      */
  308.     public function addBotParser(AbstractBotParser $parser): void
  309.     {
  310.         $this->botParsers[] = $parser;
  311.     }
  313.     /**
  314.      * @return array<AbstractBotParser>
  315.      */
  316.     public function getBotParsers(): array
  317.     {
  318.         return $this->botParsers;
  319.     }
  321.     /**
  322.      * Sets whether to discard additional bot information
  323.      * If information is discarded it's only possible check whether UA was detected as bot or not.
  324.      * (Discarding information speeds up the detection a bit)
  325.      *
  326.      * @param bool $discard
  327.      */
  328.     public function discardBotInformation(bool $discard = true): void
  329.     {
  330.         $this->discardBotInformation = $discard;
  331.     }
  333.     /**
  334.      * Sets whether to skip bot detection.
  335.      * It is needed if we want bots to be processed as a simple clients. So we can detect if it is mobile client,
  336.      * or desktop, or enything else. By default all this information is not retrieved for the bots.
  337.      *
  338.      * @param bool $skip
  339.      */
  340.     public function skipBotDetection(bool $skip = true): void
  341.     {
  342.         $this->skipBotDetection = $skip;
  343.     }
  345.     /**
  346.      * Returns if the parsed UA was identified as a Bot
  347.      *
  348.      * @see bots.yml for a list of detected bots
  349.      *
  350.      * @return bool
  351.      */
  352.     public function isBot(): bool
  353.     {
  354.         return !empty($this->bot);
  355.     }
  357.     /**
  358.      * Returns if the parsed UA was identified as a touch enabled device
  359.      *
  360.      * Note: That only applies to windows 8 tablets
  361.      *
  362.      * @return bool
  363.      */
  364.     public function isTouchEnabled(): bool
  365.     {
  366.         $regex = 'Touch';
  368.         return !!$this->matchUserAgent($regex);
  369.     }
  371.     /**
  372.      * Returns if the parsed UA is detected as a mobile device
  373.      *
  374.      * @return bool
  375.      */
  376.     public function isMobile(): bool
  377.     {
  378.         // Client hints indicate a mobile device
  379.         if ($this->clientHints instanceof ClientHints && $this->clientHints->isMobile()) {
  380.             return true;
  381.         }
  383.         // Mobile device types
  384.         if (\in_array($this->device, [
  385.             AbstractDeviceParser::DEVICE_TYPE_FEATURE_PHONE,
  386.             AbstractDeviceParser::DEVICE_TYPE_SMARTPHONE,
  387.             AbstractDeviceParser::DEVICE_TYPE_TABLET,
  388.             AbstractDeviceParser::DEVICE_TYPE_PHABLET,
  389.             AbstractDeviceParser::DEVICE_TYPE_CAMERA,
  390.             AbstractDeviceParser::DEVICE_TYPE_PORTABLE_MEDIA_PAYER,
  391.         ])
  392.         ) {
  393.             return true;
  394.         }
  396.         // non mobile device types
  397.         if (\in_array($this->device, [
  398.             AbstractDeviceParser::DEVICE_TYPE_TV,
  399.             AbstractDeviceParser::DEVICE_TYPE_SMART_DISPLAY,
  400.             AbstractDeviceParser::DEVICE_TYPE_CONSOLE,
  401.         ])
  402.         ) {
  403.             return false;
  404.         }
  406.         // Check for browsers available for mobile devices only
  407.         if ($this->usesMobileBrowser()) {
  408.             return true;
  409.         }
  411.         $osName = $this->getOs('name');
  413.         if (empty($osName) || self::UNKNOWN === $osName) {
  414.             return false;
  415.         }
  417.         return !$this->isBot() && !$this->isDesktop();
  418.     }
  420.     /**
  421.      * Returns if the parsed UA was identified as desktop device
  422.      * Desktop devices are all devices with an unknown type that are running a desktop os
  423.      *
  424.      * @see OperatingSystem::$desktopOsArray
  425.      *
  426.      * @return bool
  427.      */
  428.     public function isDesktop(): bool
  429.     {
  430.         $osName = $this->getOsAttribute('name');
  432.         if (empty($osName) || self::UNKNOWN === $osName) {
  433.             return false;
  434.         }
  436.         // Check for browsers available for mobile devices only
  437.         if ($this->usesMobileBrowser()) {
  438.             return false;
  439.         }
  441.         return OperatingSystem::isDesktopOs($osName);
  442.     }
  444.     /**
  445.      * Returns the operating system data extracted from the parsed UA
  446.      *
  447.      * If $attr is given only that property will be returned
  448.      *
  449.      * @param string $attr property to return(optional)
  450.      *
  451.      * @return array|string|null
  452.      */
  453.     public function getOs(string $attr = '')
  454.     {
  455.         if ('' === $attr) {
  456.             return $this->os;
  457.         }
  459.         return $this->getOsAttribute($attr);
  460.     }
  462.     /**
  463.      * Returns the client data extracted from the parsed UA
  464.      *
  465.      * If $attr is given only that property will be returned
  466.      *
  467.      * @param string $attr property to return(optional)
  468.      *
  469.      * @return array|string|null
  470.      */
  471.     public function getClient(string $attr = '')
  472.     {
  473.         if ('' === $attr) {
  474.             return $this->client;
  475.         }
  477.         return $this->getClientAttribute($attr);
  478.     }
  480.     /**
  481.      * Returns the device type extracted from the parsed UA
  482.      *
  483.      * @see AbstractDeviceParser::$deviceTypes for available device types
  484.      *
  485.      * @return int|null
  486.      */
  487.     public function getDevice(): ?int
  488.     {
  489.         return $this->device;
  490.     }
  492.     /**
  493.      * Returns the device type extracted from the parsed UA
  494.      *
  495.      * @see AbstractDeviceParser::$deviceTypes for available device types
  496.      *
  497.      * @return string
  498.      */
  499.     public function getDeviceName(): string
  500.     {
  501.         if (null !== $this->getDevice()) {
  502.             return AbstractDeviceParser::getDeviceName($this->getDevice());
  503.         }
  505.         return '';
  506.     }
  508.     /**
  509.      * Returns the device brand extracted from the parsed UA
  510.      *
  511.      * @see self::$deviceBrand for available device brands
  512.      *
  513.      * @return string
  514.      *
  515.      * @deprecated since 4.0 - short codes might be removed in next major release
  516.      */
  517.     public function getBrand(): string
  518.     {
  519.         return AbstractDeviceParser::getShortCode($this->brand);
  520.     }
  522.     /**
  523.      * Returns the full device brand name extracted from the parsed UA
  524.      *
  525.      * @see self::$deviceBrand for available device brands
  526.      *
  527.      * @return string
  528.      */
  529.     public function getBrandName(): string
  530.     {
  531.         return $this->brand;
  532.     }
  534.     /**
  535.      * Returns the device model extracted from the parsed UA
  536.      *
  537.      * @return string
  538.      */
  539.     public function getModel(): string
  540.     {
  541.         return $this->model;
  542.     }
  544.     /**
  545.      * Returns the user agent that is set to be parsed
  546.      *
  547.      * @return string
  548.      */
  549.     public function getUserAgent(): string
  550.     {
  551.         return $this->userAgent;
  552.     }
  554.     /**
  555.      * Returns the client hints that is set to be parsed
  556.      *
  557.      * @return ?ClientHints
  558.      */
  559.     public function getClientHints(): ?ClientHints
  560.     {
  561.         return $this->clientHints;
  562.     }
  564.     /**
  565.      * Returns the bot extracted from the parsed UA
  566.      *
  567.      * @return array|bool|null
  568.      */
  569.     public function getBot()
  570.     {
  571.         return $this->bot;
  572.     }
  574.     /**
  575.      * Returns true, if userAgent was already parsed with parse()
  576.      *
  577.      * @return bool
  578.      */
  579.     public function isParsed(): bool
  580.     {
  581.         return $this->parsed;
  582.     }
  584.     /**
  585.      * Triggers the parsing of the current user agent
  586.      */
  587.     public function parse(): void
  588.     {
  589.         if ($this->isParsed()) {
  590.             return;
  591.         }
  593.         $this->parsed = true;
  595.         // skip parsing for empty useragents or those not containing any letter (if no client hints were provided)
  596.         if ((empty($this->userAgent) || !\preg_match('/([a-z])/i', $this->userAgent))
  597.             && empty($this->clientHints)
  598.         ) {
  599.             return;
  600.         }
  602.         $this->parseBot();
  604.         if ($this->isBot()) {
  605.             return;
  606.         }
  608.         $this->parseOs();
  610.         /**
  611.          * Parse Clients
  612.          * Clients might be browsers, Feed Readers, Mobile Apps, Media Players or
  613.          * any other application accessing with an parseable UA
  614.          */
  615.         $this->parseClient();
  617.         $this->parseDevice();
  618.     }
  620.     /**
  621.      * Parses a useragent and returns the detected data
  622.      *
  623.      * ATTENTION: Use that method only for testing or very small applications
  624.      * To get fast results from DeviceDetector you need to make your own implementation,
  625.      * that should use one of the caching mechanisms. See README.md for more information.
  626.      *
  627.      * @internal
  628.      *
  629.      * @deprecated
  630.      *
  631.      * @param string       $ua          UserAgent to parse
  632.      * @param ?ClientHints $clientHints Client Hints to parse
  633.      *
  634.      * @return array
  635.      */
  636.     public static function getInfoFromUserAgent(string $ua, ?ClientHints $clientHints = null): array
  637.     {
  638.         static $deviceDetector;
  640.         if (!($deviceDetector instanceof DeviceDetector)) {
  641.             $deviceDetector = new DeviceDetector();
  642.         }
  644.         $deviceDetector->setUserAgent($ua);
  645.         $deviceDetector->setClientHints($clientHints);
  647.         $deviceDetector->parse();
  649.         if ($deviceDetector->isBot()) {
  650.             return [
  651.                 'user_agent' => $deviceDetector->getUserAgent(),
  652.                 'bot'        => $deviceDetector->getBot(),
  653.             ];
  654.         }
  656.         /** @var array $client */
  657.         $client        = $deviceDetector->getClient();
  658.         $browserFamily = 'Unknown';
  660.         if ($deviceDetector->isBrowser()
  661.             && true === \is_array($client)
  662.             && true === \array_key_exists('family', $client)
  663.             && null !== $client['family']
  664.         ) {
  665.             $browserFamily = $client['family'];
  666.         }
  668.         unset($client['short_name'], $client['family']);
  670.         /** @var array $os */
  671.         $os       = $deviceDetector->getOs();
  672.         $osFamily = $os['family'] ?? 'Unknown';
  674.         unset($os['short_name'], $os['family']);
  676.         return [
  677.             'user_agent'     => $deviceDetector->getUserAgent(),
  678.             'os'             => $os,
  679.             'client'         => $client,
  680.             'device'         => [
  681.                 'type'  => $deviceDetector->getDeviceName(),
  682.                 'brand' => $deviceDetector->getBrandName(),
  683.                 'model' => $deviceDetector->getModel(),
  684.             ],
  685.             'os_family'      => $osFamily,
  686.             'browser_family' => $browserFamily,
  687.         ];
  688.     }
  690.     /**
  691.      * Sets the Cache class
  692.      *
  693.      * @param CacheInterface $cache
  694.      */
  695.     public function setCache(CacheInterface $cache): void
  696.     {
  697.         $this->cache = $cache;
  698.     }
  700.     /**
  701.      * Returns Cache object
  702.      *
  703.      * @return CacheInterface
  704.      */
  705.     public function getCache(): CacheInterface
  706.     {
  707.         if (!empty($this->cache)) {
  708.             return $this->cache;
  709.         }
  711.         return new StaticCache();
  712.     }
  714.     /**
  715.      * Sets the Yaml Parser class
  716.      *
  717.      * @param YamlParser $yamlParser
  718.      */
  719.     public function setYamlParser(YamlParser $yamlParser): void
  720.     {
  721.         $this->yamlParser = $yamlParser;
  722.     }
  724.     /**
  725.      * Returns Yaml Parser object
  726.      *
  727.      * @return YamlParser
  728.      */
  729.     public function getYamlParser(): YamlParser
  730.     {
  731.         if (!empty($this->yamlParser)) {
  732.             return $this->yamlParser;
  733.         }
  735.         return new Spyc();
  736.     }
  738.     /**
  739.      * @param string $attr
  740.      *
  741.      * @return string
  742.      */
  743.     protected function getClientAttribute(string $attr): string
  744.     {
  745.         if (!isset($this->client[$attr])) {
  746.             return self::UNKNOWN;
  747.         }
  749.         return $this->client[$attr];
  750.     }
  752.     /**
  753.      * @param string $attr
  754.      *
  755.      * @return string
  756.      */
  757.     protected function getOsAttribute(string $attr): string
  758.     {
  759.         if (!isset($this->os[$attr])) {
  760.             return self::UNKNOWN;
  761.         }
  763.         return $this->os[$attr];
  764.     }
  766.     /**
  767.      * Returns if the parsed UA contains the 'Android; Tablet;' fragment
  768.      *
  769.      * @return bool
  770.      */
  771.     protected function hasAndroidTableFragment(): bool
  772.     {
  773.         $regex = 'Android( [\.0-9]+)?; Tablet;';
  775.         return !!$this->matchUserAgent($regex);
  776.     }
  778.     /**
  779.      * Returns if the parsed UA contains the 'Android; Mobile;' fragment
  780.      *
  781.      * @return bool
  782.      */
  783.     protected function hasAndroidMobileFragment(): bool
  784.     {
  785.         $regex = 'Android( [\.0-9]+)?; Mobile;';
  787.         return !!$this->matchUserAgent($regex);
  788.     }
  790.     /**
  791.      * Returns if the parsed UA contains the 'Desktop x64;' or 'Desktop x32;' or 'Desktop WOW64' fragment
  792.      *
  793.      * @return bool
  794.      */
  795.     protected function hasDesktopFragment(): bool
  796.     {
  797.         $regex = 'Desktop (x(?:32|64)|WOW64);';
  799.         return !!$this->matchUserAgent($regex);
  800.     }
  802.     /**
  803.      * Returns if the parsed UA contains usage of a mobile only browser
  804.      *
  805.      * @return bool
  806.      */
  807.     protected function usesMobileBrowser(): bool
  808.     {
  809.         return 'browser' === $this->getClient('type')
  810.             && Browser::isMobileOnlyBrowser($this->getClientAttribute('name'));
  811.     }
  813.     /**
  814.      * Parses the UA for bot information using the Bot parser
  815.      */
  816.     protected function parseBot(): void
  817.     {
  818.         if ($this->skipBotDetection) {
  819.             $this->bot = false;
  821.             return;
  822.         }
  824.         $parsers = $this->getBotParsers();
  826.         foreach ($parsers as $parser) {
  827.             $parser->setYamlParser($this->getYamlParser());
  828.             $parser->setCache($this->getCache());
  829.             $parser->setUserAgent($this->getUserAgent());
  830.             $parser->setClientHints($this->getClientHints());
  832.             if ($this->discardBotInformation) {
  833.                 $parser->discardDetails();
  834.             }
  836.             $bot = $parser->parse();
  838.             if (!empty($bot)) {
  839.                 $this->bot = $bot;
  841.                 break;
  842.             }
  843.         }
  844.     }
  846.     /**
  847.      * Tries to detect the client (e.g. browser, mobile app, ...)
  848.      */
  849.     protected function parseClient(): void
  850.     {
  851.         $parsers = $this->getClientParsers();
  853.         foreach ($parsers as $parser) {
  854.             $parser->setYamlParser($this->getYamlParser());
  855.             $parser->setCache($this->getCache());
  856.             $parser->setUserAgent($this->getUserAgent());
  857.             $parser->setClientHints($this->getClientHints());
  858.             $client = $parser->parse();
  860.             if (!empty($client)) {
  861.                 $this->client = $client;
  863.                 break;
  864.             }
  865.         }
  866.     }
  868.     /**
  869.      * Tries to detect the device type, model and brand
  870.      */
  871.     protected function parseDevice(): void
  872.     {
  873.         $parsers = $this->getDeviceParsers();
  875.         foreach ($parsers as $parser) {
  876.             $parser->setYamlParser($this->getYamlParser());
  877.             $parser->setCache($this->getCache());
  878.             $parser->setUserAgent($this->getUserAgent());
  879.             $parser->setClientHints($this->getClientHints());
  881.             if ($parser->parse()) {
  882.                 $this->device = $parser->getDeviceType();
  883.                 $this->model  = $parser->getModel();
  884.                 $this->brand  = $parser->getBrand();
  886.                 break;
  887.             }
  888.         }
  890.         /**
  891.          * If no model could be parsed from useragent, we use the one from client hints if available
  892.          */
  893.         if ($this->clientHints instanceof ClientHints && empty($this->model)) {
  894.             $this->model = $this->clientHints->getModel();
  895.         }
  897.         /**
  898.          * If no brand has been assigned try to match by known vendor fragments
  899.          */
  900.         if (empty($this->brand)) {
  901.             $vendorParser = new VendorFragment($this->getUserAgent());
  902.             $vendorParser->setYamlParser($this->getYamlParser());
  903.             $vendorParser->setCache($this->getCache());
  904.             $this->brand = $vendorParser->parse()['brand'] ?? '';
  905.         }
  907.         $osName     = $this->getOsAttribute('name');
  908.         $osFamily   = $this->getOsAttribute('family');
  909.         $osVersion  = $this->getOsAttribute('version');
  910.         $clientName = $this->getClientAttribute('name');
  912.         /**
  913.          * Assume all devices running iOS / Mac OS are from Apple
  914.          */
  915.         if (empty($this->brand) && \in_array($osName, ['iPadOS', 'tvOS', 'watchOS', 'iOS', 'Mac'])) {
  916.             $this->brand = 'Apple';
  917.         }
  919.         /**
  920.          * Chrome on Android passes the device type based on the keyword 'Mobile'
  921.          * If it is present the device should be a smartphone, otherwise it's a tablet
  922.          * See https://developer.chrome.com/multidevice/user-agent#chrome_for_android_user_agent
  923.          * Note: We do not check for browser (family) here, as there might be mobile apps using Chrome, that won't have
  924.          *       a detected browser, but can still be detected. So we check the useragent for Chrome instead.
  925.          */
  926.         if (null === $this->device && 'Android' === $osFamily
  927.             && $this->matchUserAgent('Chrome/[\.0-9]*')
  928.         ) {
  929.             if ($this->matchUserAgent('(?:Mobile|eliboM) Safari/')) {
  930.                 $this->device = AbstractDeviceParser::DEVICE_TYPE_SMARTPHONE;
  931.             } elseif ($this->matchUserAgent('(?!Mobile )Safari/')) {
  932.                 $this->device = AbstractDeviceParser::DEVICE_TYPE_TABLET;
  933.             }
  934.         }
  936.         /**
  937.          * Some UA contain the fragment 'Android; Tablet;' or 'Opera Tablet', so we assume those devices as tablets
  938.          */
  939.         if (null === $this->device && ($this->hasAndroidTableFragment()
  940.             || $this->matchUserAgent('Opera Tablet'))
  941.         ) {
  942.             $this->device = AbstractDeviceParser::DEVICE_TYPE_TABLET;
  943.         }
  945.         /**
  946.          * Some user agents simply contain the fragment 'Android; Mobile;', so we assume those devices as smartphones
  947.          */
  948.         if (null === $this->device && $this->hasAndroidMobileFragment()) {
  949.             $this->device = AbstractDeviceParser::DEVICE_TYPE_SMARTPHONE;
  950.         }
  952.         /**
  953.          * Android up to 3.0 was designed for smartphones only. But as 3.0, which was tablet only, was published
  954.          * too late, there were a bunch of tablets running with 2.x
  955.          * With 4.0 the two trees were merged and it is for smartphones and tablets
  956.          *
  957.          * So were are expecting that all devices running Android < 2 are smartphones
  958.          * Devices running Android 3.X are tablets. Device type of Android 2.X and 4.X+ are unknown
  959.          */
  960.         if (null === $this->device && 'Android' === $osName && '' !== $osVersion) {
  961.             if (-1 === \version_compare($osVersion, '2.0')) {
  962.                 $this->device = AbstractDeviceParser::DEVICE_TYPE_SMARTPHONE;
  963.             } elseif (\version_compare($osVersion, '3.0') >= 0
  964.                 && -1 === \version_compare($osVersion, '4.0')
  965.             ) {
  966.                 $this->device = AbstractDeviceParser::DEVICE_TYPE_TABLET;
  967.             }
  968.         }
  970.         /**
  971.          * All detected feature phones running android are more likely a smartphone
  972.          */
  973.         if (AbstractDeviceParser::DEVICE_TYPE_FEATURE_PHONE === $this->device && 'Android' === $osFamily) {
  974.             $this->device = AbstractDeviceParser::DEVICE_TYPE_SMARTPHONE;
  975.         }
  977.         /**
  978.          * All unknown devices under running Java ME are more likely a features phones
  979.          */
  980.         if ('Java ME' === $osName && null === $this->device) {
  981.             $this->device = AbstractDeviceParser::DEVICE_TYPE_FEATURE_PHONE;
  982.         }
  984.         /**
  985.          * According to http://msdn.microsoft.com/en-us/library/ie/hh920767(v=vs.85).aspx
  986.          * Internet Explorer 10 introduces the "Touch" UA string token. If this token is present at the end of the
  987.          * UA string, the computer has touch capability, and is running Windows 8 (or later).
  988.          * This UA string will be transmitted on a touch-enabled system running Windows 8 (RT)
  989.          *
  990.          * As most touch enabled devices are tablets and only a smaller part are desktops/notebooks we assume that
  991.          * all Windows 8 touch devices are tablets.
  992.          */
  994.         if (null === $this->device && ('Windows RT' === $osName || ('Windows' === $osName
  995.             && \version_compare($osVersion, '8') >= 0)) && $this->isTouchEnabled()
  996.         ) {
  997.             $this->device = AbstractDeviceParser::DEVICE_TYPE_TABLET;
  998.         }
  1000.         /**
  1001.          * All devices running Opera TV Store are assumed to be a tv
  1002.          */
  1003.         if ($this->matchUserAgent('Opera TV Store| OMI/')) {
  1004.             $this->device = AbstractDeviceParser::DEVICE_TYPE_TV;
  1005.         }
  1007.         /**
  1008.          * All devices that contain Andr0id in string are assumed to be a tv
  1009.          */
  1010.         if ($this->matchUserAgent('Andr0id|Android TV')) {
  1011.             $this->device = AbstractDeviceParser::DEVICE_TYPE_TV;
  1012.         }
  1014.         /**
  1015.          * All devices running Tizen TV or SmartTV are assumed to be a tv
  1016.          */
  1017.         if (null === $this->device && $this->matchUserAgent('SmartTV|Tizen.+ TV .+$')) {
  1018.             $this->device = AbstractDeviceParser::DEVICE_TYPE_TV;
  1019.         }
  1021.         /**
  1022.          * Devices running Kylo or Espital TV Browsers are assumed to be a TV
  1023.          */
  1024.         if (null === $this->device && \in_array($clientName, ['Kylo', 'Espial TV Browser'])) {
  1025.             $this->device = AbstractDeviceParser::DEVICE_TYPE_TV;
  1026.         }
  1028.         /**
  1029.          * All devices containing TV fragment are assumed to be a tv
  1030.          */
  1031.         if (null === $this->device && $this->matchUserAgent('\(TV;')) {
  1032.             $this->device = AbstractDeviceParser::DEVICE_TYPE_TV;
  1033.         }
  1035.         /**
  1036.          * Set device type desktop if string ua contains desktop
  1037.          */
  1038.         $hasDesktop = AbstractDeviceParser::DEVICE_TYPE_DESKTOP !== $this->device
  1039.             && false !== \strpos($this->userAgent, 'Desktop')
  1040.             && $this->hasDesktopFragment();
  1042.         if ($hasDesktop) {
  1043.             $this->device = AbstractDeviceParser::DEVICE_TYPE_DESKTOP;
  1044.         }
  1046.         // set device type to desktop for all devices running a desktop os that were not detected as another device type
  1047.         if (null !== $this->device || !$this->isDesktop()) {
  1048.             return;
  1049.         }
  1051.         $this->device = AbstractDeviceParser::DEVICE_TYPE_DESKTOP;
  1052.     }
  1054.     /**
  1055.      * Tries to detect the operating system
  1056.      */
  1057.     protected function parseOs(): void
  1058.     {
  1059.         $osParser = new OperatingSystem();
  1060.         $osParser->setUserAgent($this->getUserAgent());
  1061.         $osParser->setClientHints($this->getClientHints());
  1062.         $osParser->setYamlParser($this->getYamlParser());
  1063.         $osParser->setCache($this->getCache());
  1064.         $this->os = $osParser->parse();
  1065.     }
  1067.     /**
  1068.      * @param string $regex
  1069.      *
  1070.      * @return array|null
  1071.      */
  1072.     protected function matchUserAgent(string $regex): ?array
  1073.     {
  1074.         $regex = '/(?:^|[^A-Z_-])(?:' . \str_replace('/', '\/', $regex) . ')/i';
  1076.         if (\preg_match($regex, $this->userAgent, $matches)) {
  1077.             return $matches;
  1078.         }
  1080.         return null;
  1081.     }
  1083.     /**
  1084.      * Resets all detected data
  1085.      */
  1086.     protected function reset(): void
  1087.     {
  1088.         $this->bot    = null;
  1089.         $this->client = null;
  1090.         $this->device = null;
  1091.         $this->os     = null;
  1092.         $this->brand  = '';
  1093.         $this->model  = '';
  1094.         $this->parsed = false;
  1095.     }
  1096. }