mobile.php

См. документацию.

<?php
 
namespace Bitrix\MobileApp;
 
use Bitrix\Main\Application;
use Bitrix\Main\Context;
use Bitrix\Main\IO\File;
use Bitrix\Main\Text\Encoding;
 
class Mobile
{
    public static $platform = "ios";
    public static $apiVersion = 1;
    public static $pgVersion = "2.0.0";
    public static $supportedCordovaVersion = "3.6.3";
    public static $isDev = false;
    protected static $instance;
    protected static $isAlreadyInit = false;
    protected static $systemVersion = 9;
    private $pixelRatio = 1.0;
    private $minScale = false;
    private $iniScale = false;
    private $maxScale = false;
    private $scale = 1.2;
    private $width = false;
    private $userScalable = "no";
    private $deviceWidth = 320;
    private $deviceHeight = 480;
    private $screenCategory = "NORMAL";
    private $device = "";
    private $largeScreenSupport = true;
    private $isWebRtcSupported = false;
    private $isBXScriptSupported = false;
 
    private function __construct()
    {
        global $APPLICATION;
 
        $this->setDeviceWidth($_COOKIE["MOBILE_RESOLUTION_WIDTH"] ?? null);
        $this->setDeviceHeight($_COOKIE["MOBILE_RESOLUTION_HEIGHT"] ?? null);
        $this->setPixelratio($_COOKIE["MOBILE_SCALE"] ?? null);
        $this->screenCategory = $_COOKIE["MOBILE_SCREEN_CATEGORY"] ?? null;
 
        if (!empty($_COOKIE["PG_VERSION"]))
        {
            self::$pgVersion = $_COOKIE["PG_VERSION"];
        }
 
        self::$isDev = (isset($_COOKIE["MOBILE_DEV"]) && $_COOKIE["MOBILE_DEV"] == "Y");
        $this->device = $_COOKIE["MOBILE_DEVICE"] ?? null;
        if (!empty($_COOKIE["IS_WEBRTC_SUPPORTED"]) && $_COOKIE["IS_WEBRTC_SUPPORTED"] == "Y")
        {
            $this->setWebRtcSupport(true);
        }
        if (!empty($_COOKIE["IS_BXSCRIPT_SUPPORTED"]) && $_COOKIE["IS_BXSCRIPT_SUPPORTED"] == "Y")
        {
            $this->setBXScriptSupported(true);
        }
 
        if ($this->getDevice() == "iPad")
        {
            $this->setScreenCategory("LARGE");
            if (intval($this->getPixelRatio()) == 2) //retina hack
            {
                $this->setDeviceWidth($_COOKIE["MOBILE_RESOLUTION_WIDTH"] / 2);
                $this->setDeviceHeight($_COOKIE["MOBILE_RESOLUTION_HEIGHT"] / 2);
            }
        }
 
        //detecting OS
        if (array_key_exists("MOBILE_DEVICE", $_COOKIE))
        {
            $deviceDetectSource = $_COOKIE["MOBILE_DEVICE"];
        }
        else
        {
            $deviceDetectSource = mb_strtolower(Context::getCurrent()->getServer()->get("HTTP_USER_AGENT"));
        }
 
        if (mb_strrpos(mb_strtoupper($deviceDetectSource), "IPHONE") > 0 || mb_strrpos(mb_strtoupper($deviceDetectSource), "IPAD") > 0)
        {
            self::$platform = "ios";
        }
        elseif (mb_strrpos(mb_strtoupper($deviceDetectSource), "ANDROID") > 0 || mb_strrpos(mb_strtoupper($deviceDetectSource), "ANDROID") === 0)
        {
            self::$platform = "android";
        }
 
        $userAgent = \Bitrix\Main\Context::getCurrent()->getServer()->get("HTTP_USER_AGENT");
        if (!empty($_COOKIE["MOBILE_SYSTEM_VERSION"]))
        {
            self::$systemVersion = $_COOKIE["MOBILE_SYSTEM_VERSION"];
        }
        else
        {
            //iOS
            preg_match("/iOS\s(\d+\.\d+)/i",$userAgent, $pregMatch);
            if(count($pregMatch) == 2)
                self::$systemVersion = floatval($pregMatch[1]);
        }
 
        if (array_key_exists("emulate_platform", $_REQUEST))
        {
            self::$platform = $_REQUEST["emulate_platform"];
        }
 
        if ($mobileTZ = $APPLICATION->get_cookie("TZ", "MOBILE")) {
            $tz = $APPLICATION->get_cookie("TZ");
            if ($tz != $mobileTZ) {
                $cookie = new \Bitrix\Main\Web\Cookie("TZ", $mobileTZ, time() + 60 * 60 * 24 * 30 * 12);
                \Bitrix\Main\Context::getCurrent()->getResponse()->addCookie($cookie);
            }
 
        }
 
        if (array_key_exists("MOBILE_API_VERSION", $_COOKIE))
        {
            self::$apiVersion = $_COOKIE["MOBILE_API_VERSION"];
        }
        elseif ($APPLICATION->get_cookie("MOBILE_APP_VERSION"))
        {
            self::$apiVersion = $APPLICATION->get_cookie("MOBILE_APP_VERSION");
        }
        elseif (array_key_exists("api_version", $_REQUEST))
        {
            self::$apiVersion = $_REQUEST["api_version"];
        }
        else
        {
            preg_match("/(?<=BitrixMobile\/Version=).*\d/i",$userAgent, $pregMatch);
 
            if(count($pregMatch) == 1)
            {
                self::$apiVersion = $pregMatch[0];
            }
        }
 
        self::$apiVersion = intval(self::$apiVersion);
    }

    public function setWebRtcSupport($isWebRtcSupported)
    {
        $this->isWebRtcSupported = $isWebRtcSupported;
    }

    public function setBXScriptSupported($isBXScriptSupported)
    {
        $this->isBXScriptSupported = $isBXScriptSupported;
    }

    public function getDevice()
    {
        return $this->device;
    }

    public function getPixelRatio()
    {
        return $this->pixelRatio;
    }

    public function setPixelRatio($pixelRatio)
    {
        $this->pixelRatio = $pixelRatio;
    }

    public static function isAppBackground()
    {
        $isBackground = Context::getCurrent()->getServer()->get("HTTP_BX_MOBILE_BACKGROUND");
        return ($isBackground === "true");
    }

    public static function Init()
    {
        self::getInstance()->_Init();
    }

    protected function _Init()
    {
        if (self::$isAlreadyInit)
        {
            return;
        }
 
        header("BX-Cordova-Version: " . self::$supportedCordovaVersion);
        $GLOBALS["BITRIX_PLATFORM"] = self::$platform;
        $GLOBALS["BITRIX_API_VERSION"] = self::$apiVersion;
 
        AddEventHandler("main", "OnBeforeEndBufferContent", Array(__CLASS__, "initScripts"));
        AddEventHandler("main", "OnEpilog", Array($this, "onMobileInit"));
        self::$isAlreadyInit = true;
    }

    public static function getInstance()
    {
        if (is_null(self::$instance))
        {
            self::$instance = new Mobile();
        }
 
        return self::$instance;
    }

    public static function initScripts()
    {
        global $APPLICATION, $USER;
 
        \CJSCore::Init();
        \CJSCore::Init("db");
        $jsVarsFormat = <<<JSCODE
        <script>
            (window.BX||top.BX).message({ 'USER_ID': '%s'});
            var appVersion = "%s";
            var platform = "%s";
            var mobileSiteDir = "%s";
        </script>
            
JSCODE;
 
        $APPLICATION->AddHeadString(
            sprintf($jsVarsFormat,
                $USER->getId(),
                self::$apiVersion,
                self::$platform,
                SITE_DIR
            ), false, true);
 
        if (self::$platform == "android")
        {
            $androidJS = <<<JSCODE
                <script>
                    console.log("bxdata://success");
                </script>
JSCODE;
 
            $APPLICATION->AddHeadString($androidJS, false, true);
        }
        $userAgent = \Bitrix\Main\Context::getCurrent()->getServer()->get("HTTP_USER_AGENT");
        if(mb_strpos($userAgent, "WKWebView/BitrixMobile") === false)
        {
            $pgJsFile = "/bitrix/js/mobileapp/__deviceload__/cordova.js?mod=1";
            $APPLICATION->AddHeadString("<script src='$pgJsFile'></script>", false, true);
        }
 
 
        $APPLICATION->AddHeadString("<script src=\"" . \CUtil::GetAdditionalFileURL("/bitrix/js/mobileapp/bitrix_mobile.js") . "\"></script>", false, true);
        $APPLICATION->AddHeadString("<script src=\"" . \CUtil::GetAdditionalFileURL("/bitrix/js/mobileapp/mobile_lib.js") . "\"></script>", false, true);
 
 
        if (self::$platform == "android")
        {
            $APPLICATION->AddHeadString("<script>app.bindloadPageBlank();</script>", false, false);
        }
 
        if (!array_key_exists("doNotUseViewPort", $_REQUEST))
        {
            $APPLICATION->AddHeadString(Mobile::getInstance()->getViewPort());
        }
 
        \Bitrix\Main\UI\Extension::load([
            'mobile.ajax'
        ]);
    }

    public function getBXScriptSupported()
    {
        return $this->isBXScriptSupported;
    }

    public function getViewPort($width = "")
    {
 
        if ($width == "")
        {
            $width = $this->getDevicewidth();
        }
 
        if ($this->largeScreenSupport == true)
        {
            //we need to change densitydpi for large screens
            if ($this->getDevice() == "iPad")
            {
                //ipad large screen setting
                return $this->getIPadViewPort();
 
            }
            elseif (($this->getScreenCategory() == "LARGE" || $this->getScreenCategory() == "XLARGE"))
            {
                //android large screen setting
                return $this->getLargeScreenViewPort();
            }
        }
 
        $viewPortMeta = "<meta id=\"bx_mobile_viewport\" name=\"viewport\" content=\"#content_value#\">";
        if ($this->getIniscale())
        {
            $contentAttributes[] = "initial-scale=" . $this->getIniscale();
        }
        if ($this->getMaxscale())
        {
            $contentAttributes[] = "maximum-scale=" . $this->getMaxscale();
        }
        if ($this->getMinscale())
        {
            $contentAttributes[] = "minimum-scale=" . $this->getMinscale();
        }
 
 
        if ($this->getWidth())
        {
            $contentAttributes[] = "width=" . $this->getWidth();
        }
        elseif ($this->getIniscale())
        {
            $contentAttributes[] = "width=" . ($width / $this->getIniscale());
        }
 
        if (!$this->getWidth())
        {
            $contentAttributes[] = "width=device-width";
        }
 
 
        $contentAttributes[] = "user-scalable=" . $this->getUserScalable();
        $contentAttributes[] = "viewport-fit=cover";
 
        return str_replace("#content_value#", implode(", ", $contentAttributes), $viewPortMeta);
    }

    public function getDeviceWidth()
    {
        return $this->deviceWidth;
    }

    public function setDeviceWidth($deviceWidth)
    {
        $this->deviceWidth = $deviceWidth;
    }

    public function getIPadViewPort($width = 320)
    {
        if ($width == false)
        {
            $width = $this->getDevicewidth();
        }
        $viewPortMeta = "<meta id=\"bx_mobile_viewport\" name=\"viewport\" content=\"#content_value#\">";
        $contentAttributes = Array(
            "width=" . ($width / $this->scale),
            "user-scalable=no"
        );
        $content = implode(", ", $contentAttributes);
 
        return str_replace("#content_value#", $content, $viewPortMeta);
    }

    public function getScreenCategory()
    {
        return $this->screenCategory;
    }

    public function setScreenCategory($screenCategory)
    {
        $this->screenCategory = $screenCategory;
    }

    public function getLargeScreenViewPort()
    {
        return "<meta id=\"bx_mobile_viewport\" name=\"viewport\" content=\"user-scalable=no width=device-width target-densitydpi=" . $this->getTargetDpi() . "\">";
    }

    public function getTargetDpi()
    {
        $targetDpi = "medium-dpi";
        if ($this->getDevice() == "iPad")
        {
            return $targetDpi;
        }
        switch ($this->getScreenCategory())
        {
            case 'NORMAL':
                $targetDpi = "medium-dpi";
                break;
            case 'LARGE':
                $targetDpi = "low-dpi";
                break;
            case 'XLARGE':
                $targetDpi = "low-dpi";
                break;
            case 'SMALL':
                $targetDpi = "medium-dpi";
                break;
            default:
                $targetDpi = "medium-dpi";
                break;
        }
 
        return $targetDpi;
    }

    public function getIniScale()
    {
        return $this->iniScale;
    }

    public function setIniScale($iniScale)
    {
        $this->iniScale = $iniScale;
    }

    public function getMaxScale()
    {
        return $this->maxScale;
    }

    public function setMaxScale($maxScale)
    {
        $this->maxScale = $maxScale;
    }

    public function getMinScale()
    {
        return $this->minScale;
    }

    public function setMinScale($minScale)
    {
        $this->minScale = $minScale;
    }

    public function getWidth()
    {
        return $this->width;
    }

    public function setWidth($width)
    {
        $this->width = $width;
    }

    public static function getPlatform()
    {
        return self::$platform;
    }

    public function getUserScalable()
    {
        return $this->userScalable;
    }

    public function setUserScalable($userScalable)
    {
        $this->userScalable = ($userScalable === false ? "no" : "yes");
    }

    public static function PrepareStrToJson($s = '')
    {
        return $s;
    }

    public static function ConvertFromUtf($s = '')
    {
        return $s;
    }
 
    public static function onMobileInit()
    {
        if (!defined("MOBILE_INIT_EVENT_SKIP"))
        {
            $db_events = getModuleEvents("mobileapp", "OnMobileInit");
            while ($arEvent = $db_events->Fetch())
            {
                ExecuteModuleEventEx($arEvent);
            }
        }
    }

    public static function getApiVersion()
    {
        return self::$apiVersion;
    }

    public static function getPgVersion()
    {
        return self::$pgVersion;
    }

    public static function getSystemVersion()
    {
        return (float) self::$systemVersion;
    }

    public function isWebRtcSupported()
    {
        return $this->isWebRtcSupported;
    }

    public function getViewPortPortrait()
    {
        return $this->getViewPort($this->deviceWidth);
    }

    public function getViewPortLandscape()
    {
        return $this->getViewPort($this->deviceHeight);
    }

    public function getDeviceHeight()
    {
        return $this->deviceHeight;
    }

    public function setDeviceHeight($deviceHeight)
    {
        $this->deviceHeight = $deviceHeight;
    }

    public function getLargeScreenSupport()
    {
        return $this->largeScreenSupport;
    }

    public function setLargeScreenSupport($largeScreenSupport)
    {
        $this->largeScreenSupport = $largeScreenSupport;
    }

    public function getScale()
    {
        return $this->scale;
    }

 
    public function setScale($scale)
    {
        $this->scale = $scale;
    }

    public function isLarge()
    {
        return ($this->getScreenCategory() == "LARGE" || $this->getScreenCategory() == "XLARGE");
    }
 
    private function __clone()
    {
        //you can't clone it
    }
}
 
?>