MediaFormatHandlerImpl.java

  1. /*
  2.  * #%L
  3.  * wcm.io
  4.  * %%
  5.  * Copyright (C) 2014 wcm.io
  6.  * %%
  7.  * Licensed under the Apache License, Version 2.0 (the "License");
  8.  * you may not use this file except in compliance with the License.
  9.  * You may obtain a copy of the License at
  10.  *
  11.  *      http://www.apache.org/licenses/LICENSE-2.0
  12.  *
  13.  * Unless required by applicable law or agreed to in writing, software
  14.  * distributed under the License is distributed on an "AS IS" BASIS,
  15.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16.  * See the License for the specific language governing permissions and
  17.  * limitations under the License.
  18.  * #L%
  19.  */
  20. package io.wcm.handler.media.format.impl;

  22. import java.util.Collections;
  23. import java.util.Comparator;
  24. import java.util.HashMap;
  25. import java.util.Map;
  26. import java.util.SortedSet;
  27. import java.util.TreeSet;

  29. import org.apache.commons.lang3.StringUtils;
  30. import org.apache.sling.api.SlingHttpServletRequest;
  31. import org.apache.sling.api.resource.Resource;
  32. import org.apache.sling.models.annotations.Model;
  33. import org.apache.sling.models.annotations.injectorspecific.OSGiService;
  34. import org.apache.sling.models.annotations.injectorspecific.SlingObject;
  35. import org.jetbrains.annotations.NotNull;
  36. import org.jetbrains.annotations.Nullable;

  38. import io.wcm.handler.media.MediaFileType;
  39. import io.wcm.handler.media.format.MediaFormat;
  40. import io.wcm.handler.media.format.MediaFormatHandler;
  41. import io.wcm.handler.media.format.MediaFormatProviderManager;
  42. import io.wcm.handler.media.format.MediaFormatRankingComparator;
  43. import io.wcm.handler.media.format.MediaFormatSizeRankingComparator;
  44. import io.wcm.handler.media.format.Ratio;

  46. /**
  47.  * Media format handling.
  48.  */
  49. @Model(adaptables = {
  50.     SlingHttpServletRequest.class, Resource.class
  51. }, adapters = MediaFormatHandler.class)
  52. public final class MediaFormatHandlerImpl implements MediaFormatHandler {

  54.   @SlingObject
  55.   private Resource currentResource;
  56.   @OSGiService
  57.   private MediaFormatProviderManager mediaFormatProviderManager;

  59.   // do not access directly - used for caching. use getMediaFormatsForCurrentResource() and getMediaFormatMap() instead
  60.   private SortedSet<MediaFormat> mediaFormats;
  61.   private Map<String, MediaFormat> mediaFormatMap;

  63.   private SortedSet<MediaFormat> getMediaFormatsForCurrentResource() {
  64.     if (this.mediaFormats == null) {
  65.       this.mediaFormats = mediaFormatProviderManager.getMediaFormats(currentResource);
  66.     }
  67.     return this.mediaFormats;
  68.   }

  70.   private Map<String, MediaFormat> getMediaFormatMap() {
  71.     if (this.mediaFormatMap == null) {
  72.       this.mediaFormatMap = new HashMap<>();
  73.       for (MediaFormat mediaFormat : getMediaFormatsForCurrentResource()) {
  74.         this.mediaFormatMap.put(mediaFormat.getName(), mediaFormat);
  75.       }
  76.     }
  77.     return this.mediaFormatMap;
  78.   }

  80.   /**
  81.    * Resolves media format name to media format object.
  82.    * @param mediaFormatName Media format name
  83.    * @return Media format or null if no match found
  84.    */
  85.   @Override
  86.   public MediaFormat getMediaFormat(@NotNull String mediaFormatName) {
  87.     return getMediaFormatMap().get(mediaFormatName);
  88.   }

  90.   /**
  91.    * Get media formats defined by a CMS application that is responsible for the given media library path.
  92.    * @return Media formats sorted by media format name.
  93.    */
  94.   @Override
  95.   public @NotNull SortedSet<MediaFormat> getMediaFormats() {
  96.     return getMediaFormatsForCurrentResource();
  97.   }

  99.   /**
  100.    * Get media formats defined by a CMS application that is responsible for the given media library path.
  101.    * @param comparator Comparator for set
  102.    * @return Media formats
  103.    */
  104.   @Override
  105.   public @NotNull SortedSet<MediaFormat> getMediaFormats(@NotNull Comparator<MediaFormat> comparator) {
  106.     SortedSet<MediaFormat> set = new TreeSet<>(comparator);
  107.     set.addAll(getMediaFormatsForCurrentResource());
  108.     return Collections.unmodifiableSortedSet(set);
  109.   }

  111.   /**
  112.    * Get list of media formats that have the same (or bigger) resolution as the requested media format
  113.    * and (nearly) the same aspect ratio.
  114.    * @param mediaFormatRequested Requested media format
  115.    * @param filterRenditionGroup Only check media formats of the same rendition group.
  116.    * @return Matching media formats, sorted by size (biggest first), ranking, name
  117.    */
  118.   @Override
  119.   @SuppressWarnings({ "java:S3776", "java:S1066" }) //ignore complexity
  120.   public @NotNull SortedSet<MediaFormat> getSameBiggerMediaFormats(@NotNull MediaFormat mediaFormatRequested, boolean filterRenditionGroup) {
  121.     SortedSet<MediaFormat> matchingFormats = new TreeSet<>(new MediaFormatSizeRankingComparator());

  123.     // if filter by rendition group is enabled, but the requested media format does not define one,
  124.     // use only the requested format
  125.     if (filterRenditionGroup && StringUtils.isEmpty(mediaFormatRequested.getRenditionGroup())) {
  126.       matchingFormats.add(mediaFormatRequested);
  127.     }
  128.     else {
  129.       for (MediaFormat mediaFormat : getMediaFormats()) {

  131.         // if filter by rendition group is enabled, check only media formats of same rendition group
  132.         if (!filterRenditionGroup
  133.             || StringUtils.equals(mediaFormat.getRenditionGroup(), mediaFormatRequested.getRenditionGroup())) {

  135.           // check if size matched (image size is same or bigger)
  136.           if (isRenditionMatchSizeSameBigger(mediaFormat, mediaFormatRequested)) { //NOPMD

  138.             // if media formats have ratios, check ratio (with tolerance)
  139.             // otherwise add to list anyway, it *can* contain matching media items
  140.             if (Ratio.matches(mediaFormat, mediaFormatRequested) //NOPMD
  141.                 || !mediaFormat.hasRatio() || !mediaFormatRequested.hasRatio()) {

  143.               // check for supported file extension
  144.               if (isRenditionMatchExtension(mediaFormat)) { //NOPMD
  145.                 matchingFormats.add(mediaFormat);
  146.               }
  147.             }

  149.           }

  151.         }

  153.       }
  154.     }

  156.     return matchingFormats;
  157.   }

  159.   /**
  160.    * Get list of possible media formats that can be rendered from the given media format, i.e. same size or smaller
  161.    * and (nearly) the same aspect ratio.
  162.    * @param mediaFormatRequested Available media format
  163.    * @param filterRenditionGroup Only check media formats of the same rendition group.
  164.    * @return Matching media formats, sorted by size (biggest first), ranking, name
  165.    */
  166.   @Override
  167.   @SuppressWarnings({ "java:S3776", "java:S1066" }) //ignore complexity
  168.   public @NotNull SortedSet<MediaFormat> getSameSmallerMediaFormats(@NotNull MediaFormat mediaFormatRequested, boolean filterRenditionGroup) {
  169.     SortedSet<MediaFormat> matchingFormats = new TreeSet<>(new MediaFormatSizeRankingComparator());

  171.     // if filter by rendition group is enabled, but the requested media format does not define one,
  172.     // use only the requested format
  173.     if (filterRenditionGroup && StringUtils.isEmpty(mediaFormatRequested.getRenditionGroup())) {
  174.       matchingFormats.add(mediaFormatRequested);
  175.     }
  176.     else {
  177.       for (MediaFormat mediaFormat : getMediaFormats()) {

  179.         // if filter by rendition group is enabled, check only media formats of same rendition group
  180.         if (!filterRenditionGroup
  181.             || StringUtils.equals(mediaFormat.getRenditionGroup(), mediaFormatRequested.getRenditionGroup())) {

  183.           // check if size matched (image size is same or smaller)
  184.           if (isRenditionMatchSizeSameSmaller(mediaFormat, mediaFormatRequested)) { //NOPMD

  186.             // if media formats have ratios, check ratio (with tolerance)
  187.             // otherwise add to list anyway, it *can* contain matching media items
  188.             if (Ratio.matches(mediaFormat, mediaFormatRequested) //NOPMD
  189.                 || !mediaFormat.hasRatio() || !mediaFormatRequested.hasRatio()) {

  191.               // check for supported file extension
  192.               if (isRenditionMatchExtension(mediaFormat)) { //NOPMD
  193.                 matchingFormats.add(mediaFormat);
  194.               }
  195.             }

  197.           }

  199.         }

  201.       }
  202.     }

  204.     return matchingFormats;
  205.   }

  207.   /**
  208.    * Checks if the given media format size is same size or bigger than the requested one.
  209.    * @param mediaFormat Media format
  210.    * @param mediaFormatRequested Requested media format
  211.    * @return true if media format is same size or bigger
  212.    */
  213.   private boolean isRenditionMatchSizeSameBigger(MediaFormat mediaFormat, MediaFormat mediaFormatRequested) {
  214.     long widthRequested = getEffectiveMinWidthPreferringMinWidthHeight(mediaFormatRequested);
  215.     long heightRequested = getEffectiveMinHeightPreferringMinWidthHeight(mediaFormatRequested);

  217.     long widthMax = mediaFormat.getEffectiveMaxWidth();
  218.     long heightMax = mediaFormat.getEffectiveMaxHeight();

  220.     return ((widthMax >= widthRequested) || (widthMax == 0))
  221.         && ((heightMax >= heightRequested) || (heightMax == 0));
  222.   }

  224.   /**
  225.    * Checks if the given media format size is same size or smaller than the requested one.
  226.    * @param mediaFormat Media format
  227.    * @param mediaFormatRequested Requested media format
  228.    * @return true if media format is same size or smaller
  229.    */
  230.   private boolean isRenditionMatchSizeSameSmaller(MediaFormat mediaFormat, MediaFormat mediaFormatRequested) {
  231.     long widthRequested = getEffectiveMinWidthPreferringMinWidthHeight(mediaFormatRequested);
  232.     long heightRequested = getEffectiveMinHeightPreferringMinWidthHeight(mediaFormatRequested);

  234.     long widthMin = getEffectiveMinWidthPreferringMinWidthHeight(mediaFormat);
  235.     long heightMin = getEffectiveMinHeightPreferringMinWidthHeight(mediaFormat);

  237.     return widthMin <= widthRequested && heightMin <= heightRequested;
  238.   }

  240.   private long getEffectiveMinWidthPreferringMinWidthHeight(MediaFormat mf) {
  241.     if (mf.getMinWidthHeight() > 0) {
  242.       return mf.getMinWidthHeight();
  243.     }
  244.     else {
  245.       return mf.getEffectiveMinWidth();
  246.     }
  247.   }

  249.   private long getEffectiveMinHeightPreferringMinWidthHeight(MediaFormat mf) {
  250.     if (mf.getMinWidthHeight() > 0) {
  251.       return mf.getMinWidthHeight();
  252.     }
  253.     else {
  254.       return mf.getEffectiveMinHeight();
  255.     }
  256.   }

  258.   /**
  259.    * Checks if one of the extensions of the given media format are supported for renditions.
  260.    * @param mediaFormat Media format
  261.    * @return true if supported extension found
  262.    */
  263.   private boolean isRenditionMatchExtension(MediaFormat mediaFormat) {
  264.     for (String extension : mediaFormat.getExtensions()) {
  265.       if (MediaFileType.isImage(extension)) {
  266.         return true;
  267.       }
  268.     }
  269.     return false;
  270.   }

  272.   /**
  273.    * Detect matching media format.
  274.    * @param extension File extension
  275.    * @param fileSize File size
  276.    * @param width Image width (or 0 if not image)
  277.    * @param height Image height (or 0 if not image)
  278.    * @return Media format or null if no matching media format found
  279.    */
  280.   @Override
  281.   public MediaFormat detectMediaFormat(@Nullable String extension, long fileSize, long width, long height) {
  282.     SortedSet<MediaFormat> matchingFormats = detectMediaFormats(extension, fileSize, width, height);
  283.     return !matchingFormats.isEmpty() ? matchingFormats.first() : null;
  284.   }

  286.   /**
  287.    * Detect all matching media formats.
  288.    * @param extension File extension
  289.    * @param fileSize File size
  290.    * @param width Image width (or 0 if not image)
  291.    * @param height Image height (or 0 if not image)
  292.    * @return Matching media formats sorted by their ranking or an empty list if no matching format was found
  293.    */
  294.   @Override
  295.   @SuppressWarnings("java:S3776") //ignore complexity
  296.   public @NotNull SortedSet<MediaFormat> detectMediaFormats(@Nullable String extension, long fileSize, long width, long height) {

  298.     // sort media formats by ranking
  299.     SortedSet<MediaFormat> matchingFormats = new TreeSet<>(new MediaFormatRankingComparator());

  301.     for (MediaFormat mediaFormat : getMediaFormats()) {

  303.       // skip media formats with negative ranking
  304.       if (mediaFormat.getRanking() < 0) {
  305.         continue;
  306.       }

  308.       // check extension
  309.       boolean extensionMatch = false;
  310.       if (mediaFormat.getExtensions() != null) {
  311.         for (String ext : mediaFormat.getExtensions()) {
  312.           if (StringUtils.equalsIgnoreCase(ext, extension)) {
  313.             extensionMatch = true;
  314.             break;
  315.           }
  316.         }
  317.       }
  318.       else {
  319.         extensionMatch = true;
  320.       }

  322.       // check file size
  323.       boolean fileSizeMatch = false;
  324.       if (mediaFormat.getFileSizeMax() > 0) {
  325.         fileSizeMatch = (fileSize <= mediaFormat.getFileSizeMax());
  326.       }
  327.       else {
  328.         fileSizeMatch = true;
  329.       }

  331.       // width/height match
  332.       boolean dimensionMatch = false;
  333.       if (width > 0 && height > 0) {
  334.         if (mediaFormat.getMinWidthHeight() > 0) {
  335.           dimensionMatch = (width >= mediaFormat.getMinWidthHeight())
  336.               || (height >= mediaFormat.getMinWidthHeight());
  337.         }
  338.         else {
  339.           dimensionMatch = (mediaFormat.getEffectiveMinWidth() == 0 || width >= mediaFormat.getEffectiveMinWidth())
  340.               && (mediaFormat.getEffectiveMaxWidth() == 0 || width <= mediaFormat.getEffectiveMaxWidth())
  341.               && (mediaFormat.getEffectiveMinHeight() == 0 || height >= mediaFormat.getEffectiveMinHeight())
  342.               && (mediaFormat.getEffectiveMaxHeight() == 0 || height <= mediaFormat.getEffectiveMaxHeight());
  343.         }
  344.       }
  345.       else {
  346.         dimensionMatch = true;
  347.       }

  349.       boolean ratioMatch = false;
  350.       if (mediaFormat.hasRatio() && width > 0 && height > 0) {
  351.         double formatRatio = mediaFormat.getRatio();
  352.         double ratio = (double)width / height;
  353.         ratioMatch = Ratio.matches(ratio, formatRatio);
  354.       }
  355.       else {
  356.         ratioMatch = true;
  357.       }

  359.       if (extensionMatch && fileSizeMatch && dimensionMatch && ratioMatch) {
  360.         matchingFormats.add(mediaFormat);
  361.       }
  362.     }

  364.     return matchingFormats;
  365.   }

  367. }
Created with JaCoCo 0.8.13.202504020838