AbstractAdapter.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Image\Adapter;

use Magento\Framework\App\Filesystem\DirectoryList;

abstract class AbstractAdapter implements AdapterInterface
{
    public $imageBackgroundColor = 0;

    const POSITION_TOP_LEFT = 'top-left';

    const POSITION_TOP_RIGHT = 'top-right';

    const POSITION_BOTTOM_LEFT = 'bottom-left';

    const POSITION_BOTTOM_RIGHT = 'bottom-right';

    const POSITION_STRETCH = 'stretch';

    const POSITION_TILE = 'tile';

    const POSITION_CENTER = 'center';

    const DEFAULT_FONT_SIZE = 15;

    protected $_fileType;

    protected $_fileName;

    protected $_fileMimeType;

    protected $_fileSrcName;

    protected $_fileSrcPath;

    protected $_imageHandler;

    protected $_imageSrcWidth;

    protected $_imageSrcHeight;

    protected $_requiredExtensions;

    protected $_watermarkPosition;

    protected $_watermarkWidth;

    protected $_watermarkHeight;

    protected $_watermarkImageOpacity;

    protected $_quality;

    protected $_fontSize = self::DEFAULT_FONT_SIZE;

    protected $_keepAspectRatio;

    protected $_keepFrame;

    protected $_keepTransparency;

    protected $_backgroundColor;

    protected $_constrainOnly;

    protected $_filesystem;

    protected $directoryWrite;

    protected $logger;

    abstract public function open($fileName);

    abstract public function save($destination = null, $newName = null);

    abstract public function getImage();

    abstract public function resize($width = null, $height = null);

    abstract public function rotate($angle);

    abstract public function crop($top = 0, $left = 0, $right = 0, $bottom = 0);

    abstract public function watermark($imagePath, $positionX = 0, $positionY = 0, $opacity = 30, $tile = false);

    abstract public function checkDependencies();

    abstract public function createPngFromString($text, $font = '');

    abstract public function refreshImageDimensions();

    abstract public function getColorAt($x, $y);

    public function __construct(
        \Magento\Framework\Filesystem $filesystem,
        \Psr\Log\LoggerInterface $logger,
        array $data = []
    ) {
        $this->_filesystem = $filesystem;
        $this->logger = $logger;
        $this->directoryWrite = $this->_filesystem->getDirectoryWrite(DirectoryList::ROOT);
    }

    public function getMimeType()
    {
        if ($this->_fileMimeType) {
            return $this->_fileMimeType;
        } else {
            $this->_fileMimeType = image_type_to_mime_type($this->getImageType());
            return $this->_fileMimeType;
        }
    }

    public function getImageType()
    {
        if ($this->_fileType) {
            return $this->_fileType;
        } else {
            if ($this->_canProcess()) {
                list($this->_imageSrcWidth, $this->_imageSrcHeight, $this->_fileType) = getimagesize($this->_fileName);
                return $this->_fileType;
            }
        }
        return null;
    }

    public function getOriginalWidth()
    {
        $this->getImageType();
        return $this->_imageSrcWidth;
    }

    public function getOriginalHeight()
    {
        $this->getImageType();
        return $this->_imageSrcHeight;
    }

    public function setWatermarkPosition($position)
    {
        $this->_watermarkPosition = $position;
        return $this;
    }

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

    public function setWatermarkImageOpacity($imageOpacity)
    {
        $this->_watermarkImageOpacity = $imageOpacity;
        return $this;
    }

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

    public function setWatermarkWidth($width)
    {
        $this->_watermarkWidth = $width;
        return $this;
    }

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

    public function setWatermarkHeight($height)
    {
        $this->_watermarkHeight = $height;
        return $this;
    }

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

    public function keepAspectRatio($value = null)
    {
        if (null !== $value) {
            $this->_keepAspectRatio = (bool)$value;
        }
        return $this->_keepAspectRatio;
    }

    public function keepFrame($value = null)
    {
        if (null !== $value) {
            $this->_keepFrame = (bool)$value;
        }
        return $this->_keepFrame;
    }

    public function keepTransparency($value = null)
    {
        if (null !== $value) {
            $this->_keepTransparency = (bool)$value;
        }
        return $this->_keepTransparency;
    }

    public function constrainOnly($value = null)
    {
        if (null !== $value) {
            $this->_constrainOnly = (bool)$value;
        }
        return $this->_constrainOnly;
    }

    public function quality($value = null)
    {
        if (null !== $value) {
            $this->_quality = (int)$value;
        }
        return $this->_quality;
    }

    public function backgroundColor($value = null)
    {
        if (null !== $value) {
            if (!is_array($value) || 3 !== count($value)) {
                return;
            }
            foreach ($value as $color) {
                if (!is_integer($color) || $color < 0 || $color > 255) {
                    return;
                }
            }
        }
        $this->_backgroundColor = $value;
        return $this->_backgroundColor;
    }

    protected function _getFileAttributes()
    {
        $pathinfo = pathinfo($this->_fileName);

        $this->_fileSrcPath = $pathinfo['dirname'];
        $this->_fileSrcName = $pathinfo['basename'];
    }

    protected function _adaptResizeValues($frameWidth, $frameHeight)
    {
        $this->_checkDimensions($frameWidth, $frameHeight);

        // calculate lacking dimension
        if (!$this->_keepFrame && $this->_checkSrcDimensions()) {
            if (null === $frameWidth) {
                $frameWidth = round($frameHeight * ($this->_imageSrcWidth / $this->_imageSrcHeight));
            } elseif (null === $frameHeight) {
                $frameHeight = round($frameWidth * ($this->_imageSrcHeight / $this->_imageSrcWidth));
            }
        } else {
            if (null === $frameWidth) {
                $frameWidth = $frameHeight;
            } elseif (null === $frameHeight) {
                $frameHeight = $frameWidth;
            }
        }

        // define coordinates of image inside new frame
        $srcX = 0;
        $srcY = 0;
        list($dstWidth, $dstHeight) = $this->_checkAspectRatio($frameWidth, $frameHeight);

        // define position in center
        // TODO: add positions option
        $dstY = round(($frameHeight - $dstHeight) / 2);
        $dstX = round(($frameWidth - $dstWidth) / 2);

        // get rid of frame (fallback to zero position coordinates)
        if (!$this->_keepFrame) {
            $frameWidth = $dstWidth;
            $frameHeight = $dstHeight;
            $dstY = 0;
            $dstX = 0;
        }

        return [
            'src' => ['x' => $srcX, 'y' => $srcY],
            'dst' => ['x' => $dstX, 'y' => $dstY, 'width' => $dstWidth, 'height' => $dstHeight],
            // size for new image
            'frame' => ['width' => $frameWidth, 'height' => $frameHeight]
        ];
    }

    protected function _checkAspectRatio($frameWidth, $frameHeight)
    {
        $dstWidth = $frameWidth;
        $dstHeight = $frameHeight;
        if ($this->_keepAspectRatio && $this->_checkSrcDimensions()) {
            // do not make picture bigger, than it is, if required
            if ($this->_constrainOnly) {
                if ($frameWidth >= $this->_imageSrcWidth && $frameHeight >= $this->_imageSrcHeight) {
                    $dstWidth = $this->_imageSrcWidth;
                    $dstHeight = $this->_imageSrcHeight;
                }
            }
            // keep aspect ratio
            if ($this->_imageSrcWidth / $this->_imageSrcHeight >= $frameWidth / $frameHeight) {
                $dstHeight = round($dstWidth / $this->_imageSrcWidth * $this->_imageSrcHeight);
            } else {
                $dstWidth = round($dstHeight / $this->_imageSrcHeight * $this->_imageSrcWidth);
            }
        }
        return [$dstWidth, $dstHeight];
    }

    protected function _checkDimensions($frameWidth, $frameHeight)
    {
        if ($frameWidth !== null && $frameWidth <= 0 ||
            $frameHeight !== null && $frameHeight <= 0 ||
            empty($frameWidth) && empty($frameHeight)
        ) {
            throw new \Exception('Invalid image dimensions.');
        }
    }

    protected function _checkSrcDimensions()
    {
        return !empty($this->_imageSrcWidth) && !empty($this->_imageSrcHeight);
    }

    protected function _getImageOptions($filePath)
    {
        return getimagesize($filePath);
    }

    public function getSupportedFormats()
    {
        return ['gif', 'jpeg', 'jpg', 'png'];
    }

    protected function _prepareDestination($destination = null, $newName = null)
    {
        if (empty($destination)) {
            $destination = $this->_fileSrcPath;
        } else {
            if (empty($newName)) {
                $info = pathinfo($destination);
                $newName = $info['basename'];
                $destination = $info['dirname'];
            }
        }

        if (empty($newName)) {
            $newFileName = $this->_fileSrcName;
        } else {
            $newFileName = $newName;
        }
        $fileName = $destination . '/' . $newFileName;

        if (!is_writable($destination)) {
            try {
                $this->directoryWrite->create($this->directoryWrite->getRelativePath($destination));
            } catch (\Magento\Framework\Exception\FileSystemException $e) {
                $this->logger->critical($e);
                throw new \Exception('Unable to write file into directory ' . $destination . '. Access forbidden.');
            }
        }

        return $fileName;
    }

    protected function _canProcess()
    {
        return !empty($this->_fileName);
    }

    public function validateUploadFile($filePath)
    {
        if (!file_exists($filePath)) {
            throw new \InvalidArgumentException("File '{$filePath}' does not exists.");
        }
        if (!getimagesize($filePath)) {
            throw new \InvalidArgumentException('Disallowed file type.');
        }
        $this->checkDependencies();
        $this->open($filePath);

        return $this->getImageType() !== null;
    }
}