ImageHandler (RabbIT/4)
Date: 2009-12-20

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## rabbit.handler
Class ImageHandler

    java.lang.Object
      rabbit.handler.BaseHandler
          rabbit.handler.ImageHandler

All Implemented Interfaces:
  Handler, HandlerFactory, AsyncListener, BlockListener, BlockSentListener, HttpHeaderSentListener

    public class ImageHandler

extends BaseHandler

This handler first downloads the image runs convert on it and then serves the smaller image.

Author:
  Robert Olofsson

Nested Class Summary
`static class` | `ImageHandler.ImageConversionResult`

Field Summary
`protected File` | `convertedFile`

Fields inherited from class rabbit.handler.BaseHandler
`cacheChannel, clientHandle, con, content, entry, mayCache, mayFilter, request, response, size, tlh, totalRead`

Constructor Summary
`ImageHandler()` For creating the factory.
`ImageHandler(Connection con, TrafficLoggerHandler tlh, HttpHeader request, BufferHandle clientHandle, HttpHeader response, ResourceSource content, boolean mayCache, boolean mayFilter, long size, SProperties config, boolean doConvert, int minSizeToConvert, ImageConverter imageConverter)` Create a new ImageHandler for the given request.

Method Summary
`protected void` | `addCache()` Set up the cache stream if available.
`boolean` | `changesContentSize()` ®return true this handler modifies the content.
`protected String` | `checkFileType(File typeFile)`
`protected void` | `convertImage()` Convert the image into a small low quality image (normally a jpeg).
`protected void` | `finish(boolean good)` clear up the mess we made (remove intermediate files etc).
`SProperties` | `getConfig()`
`boolean` | `getDoConvert()`
`int` | `getMinSizeToConvert()`
`Handler` | `getNewInstance(Connection con, TrafficLoggerHandler tlh, HttpHeader header, BufferHandle bufHandle, HttpHeader webHeader, ResourceSource content, boolean mayCache, boolean mayFilter, long size)` Get a new Handler for the given request made.
`void` | `handle()` Try to convert the image before letting the superclass handle it.
`protected ImageHandler.ImageConversionResult` | `internalConvertImage(File input, String entryName)` Perform the actual image conversion.
`protected boolean` | `mayCacheFromSize()` Images needs to be cacheable to be compressed.
`protected boolean` | `mayRestrictCacheSize()` Check if this handler may force the cached resource to be less than the cache max size.
`protected void` | `readImage()` Read in the image
`protected void` | `removeCache()` Remove the cachestream and the cache entry.
`void` | `setDoConvert(boolean doConvert)`
`void` | `setup(SProperties prop)` setup the handler factory.
`protected void` | `tryconvert()` Try to convert the image.

Methods inherited from class rabbit.handler.BaseHandler
`blockSent, bufferRead, deleteFile, failed, finishData, finishedRead, getLogger, httpHeaderSent, mayTransfer, prepare, prepareStream, send, sendHeader, setPartialContent, timeout, writeCache`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### convertedFile

    protected File convertedFile

Constructor Detail

### ImageHandler

    public ImageHandler()

  For creating the factory.

### ImageHandler

    public ImageHandler(Connection con,
                        TrafficLoggerHandler tlh,
                        HttpHeader request,
                        BufferHandle clientHandle,
                        HttpHeader response,
                        ResourceSource content,
                        boolean mayCache,
                        boolean mayFilter,
                        long size,
                        SProperties config,
                        boolean doConvert,
                        int minSizeToConvert,
                        ImageConverter imageConverter)

  Create a new ImageHandler for the given request.

  Parameters:
    `con` - the Connection handling the request.
    `request` - the actual request made.
    `clientHandle` - the client side buffer.
    `response` - the actual response.
    `content` - the resource.
    `mayCache` - May we cache this request?
    `mayFilter` - May we filter this request?
    `size` - the size of the data beeing handled.

Method Detail

### getNewInstance

    public Handler getNewInstance(Connection con,
                                  TrafficLoggerHandler tlh,
                                  HttpHeader header,
                                  BufferHandle bufHandle,
                                  HttpHeader webHeader,
                                  ResourceSource content,
                                  boolean mayCache,
                                  boolean mayFilter,
                                  long size)

  Description copied from interface: `HandlerFactory`
  Get a new Handler for the given request made.

  Specified by:
    `getNewInstance` in interface `HandlerFactory`
  Overrides:
    `getNewInstance` in class `BaseHandler`
  Parameters:
    `con` - the Connection handling the request.
    `tlh` - the Traffic logger handler.
    `header` - the request.
    `bufHandle` - the client side buffer handle (may contain the next request).
    `webHeader` - the response.
    `content` - the resource.
    `mayCache` - if the handler may cache the response.
    `mayFilter` - if the handler may filter the response.
    `size` - the Size of the data beeing handled (-1 = unknown length).

### changesContentSize

    public boolean changesContentSize()

  ®return true this handler modifies the content.

  Specified by:
    `changesContentSize` in interface `Handler`
  Overrides:
    `changesContentSize` in class `BaseHandler`
  Returns:
    true if Content-Lenght may be changed by this handler typically used for handlers that may modify the content. Return false if this handler will not change the size.

### mayCacheFromSize

    protected boolean mayCacheFromSize()

  Images needs to be cacheable to be compressed.

  Overrides:
    `mayCacheFromSize` in class `BaseHandler`
  Returns:
    true

### mayRestrictCacheSize

    protected boolean mayRestrictCacheSize()

  Check if this handler may force the cached resource to be less than the cache max size.

  Overrides:
    `mayRestrictCacheSize` in class `BaseHandler`
  Returns:
    false

### handle

    public void handle()

  Try to convert the image before letting the superclass handle it.

  Specified by:
    `handle` in interface `Handler`
  Overrides:
    `handle` in class `BaseHandler`

### addCache

    protected void addCache()

  Description copied from class: `BaseHandler`
  Set up the cache stream if available.

  Overrides:
    `addCache` in class `BaseHandler`

### finish

    protected void finish(boolean good)

  clear up the mess we made (remove intermediate files etc).

  Overrides:
    `finish` in class `BaseHandler`
  Parameters:
    `good` - if true then the connection may be restarted, if false then the connection may not be restared

### removeCache

    protected void removeCache()

  Remove the cachestream and the cache entry.

  Overrides:
    `removeCache` in class `BaseHandler`

### tryconvert

    protected void tryconvert()
                       throws IOException

  Try to convert the image. This is done like this:

        super.addCache ();
        readImage();
        convertImage();
        cacheChannel = null;

  We have to use the cachefile to convert the image, and if we convert it we dont want to write the file to the cache later on.

  Throws:
    `IOException`

### readImage

    protected void readImage()
                      throws IOException

  Read in the image

  Throws:
    `IOException` - if reading of the image fails.

### convertImage

    protected void convertImage()

  Convert the image into a small low quality image (normally a jpeg).

  Throws:
    `IOException` - if conversion fails.

### internalConvertImage

    protected ImageHandler.ImageConversionResult internalConvertImage(File input,
                                                                      String entryName)
                                                               throws IOException

  Perform the actual image conversion.

  Parameters:
    `entryName` - the filename of the cache entry to use.
  Throws:
    `IOException`

### checkFileType

    protected String checkFileType(File typeFile)
                            throws IOException

  Throws:
    `IOException`

### setDoConvert

    public void setDoConvert(boolean doConvert)

### getDoConvert

    public boolean getDoConvert()

### getConfig

    public SProperties getConfig()

### getMinSizeToConvert

    public int getMinSizeToConvert()

### setup

    public void setup(SProperties prop)

  Description copied from interface: `HandlerFactory`
  setup the handler factory.

  Specified by:
    `setup` in interface `HandlerFactory`
  Overrides:
    `setup` in class `BaseHandler`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD