vendor/tattali/mobile-detect-bundle/src/EventListener/RequestResponseListener.php line 153

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the MobileDetectBundle.
  5.  *
  6.  * (c) Nikolay Ivlev <nikolay.kotovsky@gmail.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. declare(strict_types=1);
  14. namespace MobileDetectBundle\EventListener;
  16. use MobileDetectBundle\DeviceDetector\MobileDetectorInterface;
  17. use MobileDetectBundle\Helper\DeviceView;
  18. use MobileDetectBundle\Helper\RedirectResponseWithCookie;
  19. use Symfony\Component\HttpFoundation\RedirectResponse;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpKernel\Event\RequestEvent;
  22. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  23. use Symfony\Component\Routing\Route;
  24. use Symfony\Component\Routing\RouterInterface;
  26. /**
  27.  * @author suncat2000 <nikolay.kotovsky@gmail.com>
  28.  * @author HenriVesala <henri.vesala@gmail.com>
  29.  */
  30. class RequestResponseListener
  31. {
  32.     public const REDIRECT = 'redirect';
  33.     public const NO_REDIRECT = 'no_redirect';
  34.     public const REDIRECT_WITHOUT_PATH = 'redirect_without_path';
  36.     public const MOBILE = 'mobile';
  37.     public const TABLET = 'tablet';
  38.     public const FULL = 'full';
  40.     /**
  41.      * @var RouterInterface
  42.      */
  43.     protected $router;
  45.     /**
  46.      * @var MobileDetectorInterface
  47.      */
  48.     protected $mobileDetector;
  50.     /**
  51.      * @var DeviceView
  52.      */
  53.     protected $deviceView;
  55.     /**
  56.      * @var array
  57.      */
  58.     protected $redirectConf;
  60.     /**
  61.      * @var bool
  62.      */
  63.     protected $isFullPath;
  65.     /**
  66.      * @var bool
  67.      */
  68.     protected $needModifyResponse = false;
  70.     /**
  71.      * @var \Closure
  72.      */
  73.     protected $modifyResponseClosure;
  75.     public function __construct(
  76.         MobileDetectorInterface $mobileDetector,
  77.         DeviceView $deviceView,
  78.         RouterInterface $router,
  79.         array $redirectConf,
  80.         bool $fullPath = true
  81.     ) {
  82.         $this->mobileDetector = $mobileDetector;
  83.         $this->deviceView = $deviceView;
  84.         $this->router = $router;
  86.         // Configs mobile & tablet
  87.         $this->redirectConf = $redirectConf;
  88.         $this->isFullPath = $fullPath;
  89.     }
  91.     public function handleRequest(RequestEvent $event): void
  92.     {
  93.         // only handle master request, do not handle sub request like esi includes
  94.         // If the device view is "not the mobile view" (e.g. we're not in the request context)
  95.         if ((\defined('Symfony\Component\HttpKernel\HttpKernelInterface::MAIN_REQUEST') ? \constant('Symfony\Component\HttpKernel\HttpKernelInterface::MAIN_REQUEST') : \constant('Symfony\Component\HttpKernel\HttpKernelInterface::MASTER_REQUEST')) !== $event->getRequestType() || $this->deviceView->isNotMobileView()) {
  96.             return;
  97.         }
  99.         $request = $event->getRequest();
  100.         $this->mobileDetector->setUserAgent($request->headers->get('user-agent'));
  102.         // Sets the flag for the response handled by the GET switch param and the type of the view.
  103.         if ($this->deviceView->hasSwitchParam()) {
  104.             $event->setResponse($this->getRedirectResponseBySwitchParam($request));
  106.             return;
  107.         }
  109.         // If neither the SwitchParam nor the cookie are set, detect the view...
  110.         $cookieIsSet = null !== $this->deviceView->getRequestedViewType();
  111.         if (!$cookieIsSet) {
  112.             if (false === $this->redirectConf['detect_tablet_as_mobile'] && $this->mobileDetector->isTablet()) {
  113.                 $this->deviceView->setTabletView();
  114.             } elseif ($this->mobileDetector->isMobile()) {
  115.                 $this->deviceView->setMobileView();
  116.             } else {
  117.                 $this->deviceView->setFullView();
  118.             }
  119.         }
  121.         $viewType = $this->deviceView->getViewType();
  122.         // Check if we must redirect to the target view and do so if needed
  123.         if ($viewType && $this->mustRedirect($request, $viewType)) {
  124.             if ($response = $this->getRedirectResponse($request, $viewType)) {
  125.                 $event->setResponse($response);
  126.             }
  128.             return;
  129.         }
  131.         // No need to redirect
  133.         // We don't need to modify _every_ response: once the cookie is set,
  134.         // save bandwith and CPU cycles by just letting it expire someday.
  135.         if ($cookieIsSet) {
  136.             return;
  137.         }
  139.         // Sets the flag for the response handler and prepares the modification closure
  140.         $this->needModifyResponse = true;
  141.         $this->prepareResponseModification($this->deviceView->getViewType());
  142.     }
  144.     /**
  145.      * Will this request listener modify the response? This flag will be set during the "handleRequest" phase.
  146.      * Made public for testability.
  147.      */
  148.     public function needsResponseModification(): bool
  149.     {
  150.         return $this->needModifyResponse;
  151.     }
  153.     public function handleResponse(ResponseEvent $event): void
  154.     {
  155.         if ($this->needModifyResponse && $this->modifyResponseClosure instanceof \Closure) {
  156.             $modifyClosure = $this->modifyResponseClosure;
  157.             $event->setResponse($modifyClosure($this->deviceView, $event));
  159.             return;
  160.         }
  161.     }
  163.     protected function getRedirectResponseBySwitchParam(Request $request): RedirectResponseWithCookie
  164.     {
  165.         if ($this->mustRedirect($request, $this->deviceView->getViewType())) {
  166.             // Avoid unnecessary redirects: if we need to redirect to another view,
  167.             // do it in one response while setting the cookie.
  168.             $redirectUrl = $this->getRedirectUrl($request, $this->deviceView->getViewType());
  169.         } else {
  170.             if (true === $this->isFullPath) {
  171.                 $redirectUrl = $request->getUriForPath($request->getPathInfo());
  172.                 // $redirectUrl = ($request->getPathInfo()) ? $request->getUriForPath($request->getPathInfo()) : $this->getCurrentHost($request);
  173.                 $queryParams = $request->query->all();
  174.                 if (\array_key_exists($this->deviceView->getSwitchParam(), $queryParams)) {
  175.                     unset($queryParams[$this->deviceView->getSwitchParam()]);
  176.                 }
  177.                 if (\count($queryParams) > 0) {
  178.                     $redirectUrl .= '?'.Request::normalizeQueryString(http_build_query($queryParams, '', '&'));
  179.                 }
  180.             } else {
  181.                 $redirectUrl = $request->getSchemeAndHttpHost();
  182.             }
  183.         }
  185.         return $this->deviceView->getRedirectResponseBySwitchParam($redirectUrl);
  186.     }
  188.     /**
  189.      * Do we have to redirect?
  190.      *
  191.      * @param string $viewType The view we want to redirect to
  192.      */
  193.     protected function mustRedirect(Request $request, string $viewType): bool
  194.     {
  195.         if (!isset($this->redirectConf[$viewType])
  196.             || !$this->redirectConf[$viewType]['is_enabled']
  197.             || (self::NO_REDIRECT === $this->getRoutingOption($request->get('_route'), $viewType))
  198.         ) {
  199.             return false;
  200.         }
  202.         return $request->getSchemeAndHttpHost() !== $this->redirectConf[$viewType]['host'];
  203.     }
  205.     protected function getRoutingOption(string $routeName, string $optionName): ?string
  206.     {
  207.         $option = null;
  208.         $route = $this->router->getRouteCollection()->get($routeName);
  210.         if ($route instanceof Route) {
  211.             $option = $route->getOption($optionName);
  212.         }
  214.         if (!$option && isset($this->redirectConf[$optionName])) {
  215.             $option = $this->redirectConf[$optionName]['action'];
  216.         }
  218.         if (\in_array($option, [self::REDIRECT, self::REDIRECT_WITHOUT_PATH, self::NO_REDIRECT], true)) {
  219.             return $option;
  220.         }
  222.         return null;
  223.     }
  225.     protected function getRedirectUrl(Request $request, string $view): ?string
  226.     {
  227.         if ($routingOption = $this->getRoutingOption($request->get('_route'), $view)) {
  228.             if (self::REDIRECT === $routingOption) {
  229.                 // Make sure to hint at the device override, otherwise infinite loop
  230.                 // redirection may occur if different device views are hosted on
  231.                 // different domains (since the cookie can't be shared across domains)
  232.                 $queryParams = $request->query->all();
  233.                 $queryParams[$this->deviceView->getSwitchParam()] = $view;
  235.                 return rtrim($this->redirectConf[$view]['host'], '/').$request->getPathInfo().'?'.Request::normalizeQueryString(http_build_query($queryParams));
  236.             }
  237.             if (self::REDIRECT_WITHOUT_PATH === $routingOption) {
  238.                 // Make sure to hint at the device override, otherwise infinite loop
  239.                 // redirections may occur if different device views are hosted on
  240.                 // different domains (since the cookie can't be shared across domains)
  241.                 return $this->redirectConf[$view]['host'].'?'.$this->deviceView->getSwitchParam().'='.$view;
  242.             }
  244.             return null;
  245.         }
  247.         return null;
  248.     }
  250.     /**
  251.      * Gets the RedirectResponse for the specified view.
  252.      *
  253.      * @param string $view the view for which we want the RedirectResponse
  254.      */
  255.     protected function getRedirectResponse(Request $request, string $view): ?RedirectResponse
  256.     {
  257.         if ($host = $this->getRedirectUrl($request, $view)) {
  258.             return $this->deviceView->getRedirectResponse(
  259.                 $view,
  260.                 $host,
  261.                 $this->redirectConf[$view]['status_code']
  262.             );
  263.         }
  265.         return null;
  266.     }
  268.     /**
  269.      * Prepares the response modification which will take place after the controller logic has been executed.
  270.      *
  271.      * @param string $view the view for which to prepare the response modification
  272.      */
  273.     protected function prepareResponseModification(string $view): void
  274.     {
  275.         $this->modifyResponseClosure = function (DeviceView $deviceView, ResponseEvent $event) use ($view) {
  276.             return $deviceView->modifyResponse($view, $event->getResponse());
  277.         };
  278.     }
  279. }