source/mircoders/media/MediaHandlerImagesExtern.java

   1 /*
   2  * Copyright (C) 2001, 2002 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30 package mircoders.media;
  31
  32
  33 import java.io.File;
  34 import java.io.FileInputStream;
  35 import java.io.InputStream;
  36
  37 import mir.config.MirPropertiesConfiguration;
  38 import mir.entity.Entity;
  39 import mir.log.LoggerWrapper;
  40 import mir.media.MediaExc;
  41 import mir.media.MediaFailure;
  42 import mir.misc.StringUtil;
  43
  44
  45 /**
  46  * Image handler that stores images outside of the database. Will be replaced by the new
  47  *   media handling system.
  48  * @author Zapata
  49  * @version 1.0
  50  */
  51
  52 public class MediaHandlerImagesExtern extends MediaHandlerGeneric
  53 {
  54   private int maxIconSize;
  55   private float minDescaleRatio;
  56   private int minDescaleReduction;
  57
  58   public MediaHandlerImagesExtern() {
  59
  60     logger = new LoggerWrapper("Media.Images.Extern");
  61     try {
  62       MirPropertiesConfiguration configuration = MirPropertiesConfiguration.instance();
  63     }
  64     catch (Throwable t) {
  65       logger.fatal("MediaHandlerImagesExtern: can't get configuration");
  66
  67       throw new RuntimeException(t.toString());
  68     }
  69
  70     maxIconSize = configuration.getInt("Producer.Image.MaxIconSize");
  71     minDescaleRatio = configuration.getFloat("Producer.Image.MinDescalePercentage")/100;
  72     minDescaleReduction = configuration.getInt("Producer.Image.MinDescaleReduction");
  73   }
  74
  75   public void produce(Entity anImageEntity, Entity mediaTypeEnt) throws MediaExc, MediaFailure {
  76     try {
  77       String date = anImageEntity.getValue("date");
  78       String datePath = StringUtil.webdbDate2path(date);
  79       String ext = "." + mediaTypeEnt.getValue("name");
  80       String fileBasePath = datePath + anImageEntity.getId();
  81       String filePath = fileBasePath + ext;
  82       String iconPath = getIconStoragePath() + fileBasePath + ".jpg";
  83       String iconStoragePath = configuration.getString("Producer.StorageRoot") + iconPath;
  84       String imageFilePath = getStoragePath() + File.separator + filePath;
  85
  86       File imageFile = new File(imageFilePath);
  87       File iconFile = new File(iconStoragePath);
  88
  89       if (!imageFile.exists()) {
  90         throw new MediaExc("error in MediaHandlerImagesExtern.produce(): " + filePath + " does not exist!");
  91       }
  92       else {
  93         ImageProcessor processor = new ImageProcessor(imageFile);
  94
  95         processor.descaleImage(maxIconSize, minDescaleRatio, minDescaleReduction);
  96         File dir = new File(iconFile.getParent());
  97           if (dir!=null && !dir.exists()){
  98             dir.mkdirs();
  99         }
 100         processor.writeScaledData(iconFile, "JPEG");
 101
 102         anImageEntity.setValueForProperty("img_height", new Integer(processor.getHeight()).toString());
 103         anImageEntity.setValueForProperty("img_width", new Integer(processor.getWidth()).toString());
 104
 105         anImageEntity.setValueForProperty("icon_height", new Integer(processor.getScaledHeight()).toString());
 106         anImageEntity.setValueForProperty("icon_width", new Integer(processor.getScaledWidth()).toString());
 107
 108         anImageEntity.setValueForProperty("icon_path", iconPath);
 109         anImageEntity.setValueForProperty("publish_path", filePath);
 110
 111         anImageEntity.update();
 112
 113
 114       }
 115     }
 116     catch(Throwable t) {
 117       logger.error("MediaHandlerImagesExtern.produce: " + t.getMessage());
 118       t.printStackTrace(logger.asPrintWriter(LoggerWrapper.DEBUG_MESSAGE));
 119       throw new MediaFailure(t.getMessage(), t);
 120     }
 121   }
 122
 123
 124   public InputStream getIcon(Entity anImageEntity) throws MediaExc, MediaFailure {
 125     try {
 126       String filePath =
 127           configuration.getString("Producer.StorageRoot") + anImageEntity.getValue("icon_path");
 128
 129       logger.info(filePath);
 130
 131       return new FileInputStream(new File(filePath));
 132     }
 133     catch (Throwable t) {
 134       return null;
 135     }
 136   }
 137
 138   public String getIconMimeType(Entity anImageEntity, Entity aMediaType) {
 139     return "image/jpeg";
 140   }
 141
 142   public String getStoragePath()
 143   {
 144     return configuration.getString("Producer.Image.Path");
 145   }
 146
 147   public String getIconStoragePath()
 148   {
 149     return configuration.getString("Producer.Image.IconPath");
 150   }
 151
 152   public String getPublishHost()
 153   {
 154     return StringUtil.removeSlash(configuration.getString("Producer.Image.Host"));
 155   }
 156
 157   public String getTinyIconName()
 158   {
 159     return configuration.getString("Producer.Icon.TinyImage");
 160   }
 161
 162   public String getBigIconName()
 163   {
 164     return configuration.getString("Producer.Icon.BigImage");
 165   }
 166
 167   public String getIconAltName()
 168   {
 169     return "Image";
 170   }
 171
 172   public boolean isVideo()
 173   {
 174     return false;
 175   }
 176
 177   public boolean isAudio()
 178   {
 179     return false;
 180   }
 181
 182   public boolean isImage ()
 183   {
 184     return true;
 185   }
 186
 187   public String getDescr(Entity mediaType)
 188   {
 189      return "image/jpeg";
 190   }
 191 }