5.2 Processing SWF Movies

/**
 * SWFInputType implementation for simple SWF files 
 */
public class SWFFileInput implements SWFInputType {

    private File mySWFFile;
      
    /**
     * Create the input with an SWF file and the output RVML file - the ouptut RVML file
     * is used to calculate the location of the repository for the SWF assets  
     */
    public SWFFileInput( File swfFile)
    {
        if ( swfFile == null ) throw new NullPointerException( "Input file cannot be null");
        if ( !swfFile.isFile()) throw new IllegalArgumentException("Specified file is not an XML file");
        mySWFFile = swfFile;
    }

    
    /**
     * Return an identifier for this document that is used in reporting errors and
     * other status messages 
     * @return
     */
    public String getDocumentIdentifier()
    {
        return mySWFFile.getAbsolutePath();
    }
    
 
    /**
     * Returns an input stream from which to read the SWF movie
     * @return an input stream from which to read the SWF movie
     * @throws IOException if a error occured when trying to create the input stream
     */
   public InputStream getInputStream() throws IOException
    {
        return new BufferedInputStream( new FileInputStream ( mySWFFile));
    }

   /**
    * Set whether  the application should close the stream after reading the SWF document. 
    * If false, it is up to the creator of the InputStream to ensure the reader is closed 
    * appropriately. If a single InputStream is capable of supplying multiple SWF documents 
    * this should be set to false.
    * @return true if the InputStream should be closed automatically by the application after procesing
    */
   public boolean closeStreamAfterUse()
    {
         return true;
    }

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import resources.FileRepositoryParameters;

import com.kinesis.RVMLStreamOutputType;
import com.kinesis.io.resources.RepositoryParametersType;

/**
 * RVMLOutputType implementation for writing RVML documents 
 */
public class RVMLFileOutput implements RVMLStreamOutputType {


    private File myRVMLFile;
    private File myRepositoryRoot;
    
    private RepositoryParametersType myRepositoryParameters;
 
    /**
     * Write the RVML output to a file and use a default fileRepository
     * @param rvmlFile
     */
    public RVMLFileOutput( File rvmlFile)
    {
        initialiseFile( rvmlFile );
         myRepositoryParameters = new FileRepositoryParameters( rvmlFile);
    }
    
    /**
     * Write the RVML output to a file and use the specified RepositoryParametersType for
     * storing all SWF resources
     * @param rvmlFile
     * @param repParameters
     */
    public RVMLFileOutput( File rvmlFile, RepositoryParametersType repParameters)
    {
        initialiseFile( rvmlFile );
        myRepositoryParameters = repParameters;
    }

    
    /**
     * @param rvmlFile
     */
    private void initialiseFile(File rvmlFile)
    {
        if ( rvmlFile == null ) throw new NullPointerException( "Output file cannot be null");
        if ( rvmlFile.isDirectory()) throw new IllegalArgumentException("Specified output is a directory");
        if (rvmlFile.exists() &&  ! rvmlFile.canWrite()) throw new IllegalArgumentException("Cannot write specified location");
        myRVMLFile = rvmlFile;
    }

    /**
     * Returns an output stream in which the RVML document movie can be written
     * @return
     * @throws IOException if a error occured when trying to create the output stream
     */
    public OutputStream getOutputStream() throws IOException
    {
        return new FileOutputStream( myRVMLFile);        
    }
    
    /**
     * Should the application close the output stream  afterwriting the RVML document. If false, it
     * is up to the creator of the output stream  to ensure the stream is closed appropriately.
     * @return
     */
    public boolean closeStreamAfterUse()
    {
        return true;
    }

    
    /**
     * Returns the root repository  folder for the document. 
     * @return
     */
    public File getRepositoryRoot()
    {
        return myRepositoryRoot;
    }
    
    /**
     * Return an identifier for this document that is used in reporting errors and
     * other status messages. Generally this is the short file name of the  SWF document that is being
     * processed. It is combined with the RepositoryRoot File to give a unique location for storing resources. 
     * @return Identifier for the document
     */
    public String getDocumentName()
    {
        return myRVMLFile.getName();
    }
        

    /**
     * Return an identifier for this document that is used in reporting errors and
     * other status messages 
     * @return
     */
    public String getDocumentIdentifier()
    {
        return myRVMLFile.getAbsolutePath();
    }

    
    /**
     * Return an object defining the attributes for storing external resources to be referenced inside the
     * RVML document
     * @return The parameters for the resource repository
     */
    public RepositoryParametersType getRepositoryParameters()
    {
        return myRepositoryParameters;
    }
}

import java.io.File;

import org.xml.sax.ContentHandler;

import resources.FileRepositoryParameters;

import com.kinesis.RVMLSAXOutputType;
import com.kinesis.io.resources.RepositoryParametersType;

public class RVMLSAXOutput implements RVMLSAXOutputType {

    private String myID;

    private ContentHandler myHandler;
    
    private RepositoryParametersType myParameters;

    /**
     * Create with a file used to store external resources and the content handler to receive 
     * RVML SAX Events
     * @param myRVMLFile
     * @param handler
     */
    public RVMLSAXOutput(File myRVMLFile, ContentHandler handler)
    {
        myID =  myRVMLFile.getAbsolutePath();
        myHandler = handler;
        myParameters = new FileRepositoryParameters( myRVMLFile);
    }

    /**
     * Create with an explicit RepositoryParameters type  used to store external resources and 
     * the content handler to receive RVML SAX Events
     * @param id Used for identifying th document in output messages
     * @param repParameters 
     * @param handler
     */
    public RVMLSAXOutput(String id, RepositoryParametersType repParameters, ContentHandler handler)
    {
        myID =  id;
        myHandler = handler;
        myParameters = repParameters;
    }

    /
    public String getDocumentIdentifier()
    {
        return myID;
    }

    public ContentHandler getContentHandler()
    {
        return myHandler;
    }

    public RepositoryParametersType getRepositoryParameters()
    {
        return myParameters;
    }

}

    /**
     * Class used to implement the storing of resources as byte arrays. The byte array is created only
     * by populating the output stream. Once the resource has been written to the output stream
     * it can be provided as an input stream.While the resource is being written the original contents will
     * always be available for reading. 
     */
    final class ByteResource implements InputResourceType, OutputResourceType
    {
        private byte[] myContents;
        
        private String myName;
        
        private long lastModified = 0;
        /**
         * @param stream
         * @param name
         */
        protected ByteResource(String name)
        {
            myName = name;
        }

        /**
         * Returns a stream that will updates this object when it is closed 
         * @return
         * @throws IOException
         */
         synchronized public OutputStream getOutputStream() throws IOException
        {
            return new ResourceByteStream( this);
        }
        
         /**
          * When the OutputStream is closed by the client the contents of the stream are copied
          * into the resource using this method
          * @param contents
          */
         synchronized protected void setContents( byte[] contents)
         {
             if (myContents != null)
                 throw new IllegalStateException("Contents of resource are already defined");
             myContents = contents;
             lastModified = System.currentTimeMillis();
         }
         
        /**
         * Return an input stream - if the contents have not yet been read the contents 
         * of the stream will be zero. 
          * @return
         * @throws IOException
         */
        synchronized public InputStream getInputStream() throws IOException
        {
            byte[] contents = ( myContents == null)? new byte[0] : myContents;            
            return new ByteArrayInputStream( contents);
        }

        /**
         *  The contents are deemed to have changed if the resource has been written since the specified time
         * @param sinceTime
         * @return
         */
        synchronized public boolean isChangedExternally(long sinceTime)
        {
            return lastModified > sinceTime;
        }

        /**
         * Resource exists only if it has been populated by an output stream
         * @return
         */
        synchronized public boolean resourceExists()
        {
            return myContents != null;
        }

        /**
         * Returns the redefined name of the resource 
         * @return
         */
        public String getResourceName()
        {
             return myName;
        }
    }

   /**
     * Byte stream used to load the contents of a resource. Once the stream is closed then contents 
     * are moved into the resource
     */
    static private final class ResourceByteStream extends ByteArrayOutputStream{

            private ByteResource myResource;
            
            public ResourceByteStream( ByteResource contents)
            {
                myResource = contents;
            }
            
            public void close() throws IOException
            {
                super.close();
                myResource.setContents(toByteArray());
            }
     }