package org.jboss.media.entity;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.Vector;
import javax.ejb.CreateException;
import javax.emb.ContentAccessException;
import javax.emb.ContentUnmutableException;
import javax.emb.ConversionException;
import javax.emb.FormatNotFoundException;
import javax.emb.GenericMediaFormat;
import javax.emb.Media;
import javax.emb.MediaBean;
import javax.emb.MediaConverter;
import javax.emb.MediaConverterSpec;
import javax.emb.MediaEntityLocal;
import javax.emb.MediaException;
import javax.emb.MediaFormat;
import javax.emb.MediaFormatRegistry;
import javax.emb.MediaHeader;
import javax.emb.MediaListener;
import javax.emb.MetaDataEntityLocal;
import javax.emb.ProtocolConstraints;
import org.jboss.logging.Logger;
public abstract class MediaEntity
{
private Logger log = Logger.getLogger(MediaEntity.class);
public abstract String getManagedIdentity();
public abstract void setManagedIdentity(String identity);
public abstract byte[] getManagedContent();
public abstract void setManagedContent(byte[] content);
public abstract String getManagedLocation();
public abstract void setManagedLocation(String location);
public abstract String getManagedDescription();
public abstract void setManagedDescription(String description);
public abstract String getManagedName();
public abstract void setManagedName(String name);
public abstract String getManagedMimeType();
public abstract void setManagedMimeType(String mimeType);
public abstract long getManagedLastModified();
public abstract void setManagedLastModified(long lastModified);
public abstract Vector getManagedListeners();
public abstract void setManagedListeners(Vector listeners);
public abstract MediaEntityLocal getManagedProxy();
public abstract void setManagedProxy(MediaEntityLocal proxy);
public abstract MediaEntityLocal getManagedPreviousVersion();
public abstract void setManagedPreviousVersion(MediaEntityLocal previousVersion);
public abstract MediaEntityLocal getManagedNextVersion();
public abstract void setManagedNextVersion(MediaEntityLocal nextVersion);
public abstract Collection getManagedParents();
public abstract void setManagedParents(Collection parents);
public abstract Collection getManagedChildren();
public abstract void setManagedChildren(Collection children);
public abstract Collection getManagedMetaDatas();
public abstract void setManagedMetaDatas(Collection metadatas);
public void addListener(MediaListener listener)
{
if (listener == null)
{
throw new NullPointerException();
}
Vector listeners = getManagedListeners();
if (!listeners.contains(listener))
{
listeners.add(listener);
setManagedListeners(listeners);
}
}
public void addMetaData(MetaDataEntityLocal metaData) throws MediaException
{
if (metaData == null)
{
throw new NullPointerException();
}
if (!getManagedMetaDatas().contains(metaData))
{
getManagedMetaDatas().add(metaData);
}
}
public void convert(MediaConverterSpec[] specifications)
throws MediaException
{
if (specifications == null)
{
throw new NullPointerException();
}
if (getManagedLocation() != null)
{
throw new ContentUnmutableException();
}
int specificationsLength = specifications.length;
if (specificationsLength == 0)
{
return;
}
for (int i = 0; i < specificationsLength; i++)
{
if (specifications[i] == null)
{
throw new ConversionException();
}
}
InputStream inputStream = new ByteArrayInputStream(getContent());
for (int i = 0; i < specificationsLength - 1; i++)
{
MediaConverterSpec mediaConverterSpec = specifications[i];
MediaConverter mediaConverter = mediaConverterSpec.getConverter();
inputStream = mediaConverter.process(inputStream);
}
MediaConverterSpec lastSpecification =
specifications[specificationsLength - 1];
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
lastSpecification.getConverter().process(inputStream, outputStream);
byte[] convertedContent = outputStream.toByteArray();
try
{
outputStream.close();
}
catch (IOException ignore)
{
}
String convertedName =
getFileName(getManagedName())
+ "."
+ lastSpecification.getTargetFileExtension();
String convertedMimeType = lastSpecification.getTargetMimeType();
setContent(convertedContent);
setName(convertedName);
setMimeType(convertedMimeType);
updateLastModified();
}
public URL exportMedia(URL targetDirectoryLocation) throws MediaException
{
String name = getManagedName();
String exportedFilePrefix = getFileName(name);
String exportedFileSuffix = getFileExtension(name);
try
{
File targetDirectory = new File(targetDirectoryLocation.getPath());
File exportedFile =
File.createTempFile(
exportedFilePrefix,
exportedFileSuffix,
targetDirectory);
OutputStream exportedFileStream = new FileOutputStream(exportedFile);
try
{
int DEFAULT_BUFFER_SIZE = 65536;
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int bytesRead;
long position = 0;
while ((bytesRead = readContent(position, buffer)) != -1)
{
exportedFileStream.write(buffer, 0, bytesRead);
position += bytesRead;
}
return exportedFile.toURL();
}
catch (IOException e)
{
throw new ContentAccessException(e.getMessage());
}
finally
{
try
{
exportedFileStream.close();
}
catch (IOException ignore)
{
}
}
}
catch (IOException e)
{
throw new ContentAccessException(e.getMessage());
}
}
public MediaEntityLocal[] getChildren() throws MediaException
{
Collection children = getManagedChildren();
return (MediaEntityLocal[]) children.toArray(new MediaEntityLocal[0]);
}
public byte[] getContent() throws MediaException
{
byte[] content = getManagedContent();
if (content == null)
{
throw new ContentAccessException();
}
else
{
return content;
}
}
public String getDescription() throws MediaException
{
return getManagedDescription();
}
public MediaFormat getFormat() throws MediaException
{
String name = getName();
if (name == null)
{
throw new FormatNotFoundException();
}
String fileExtension = getFileExtension(name);
MediaFormat mediaFormat =
MediaFormatRegistry.SINGLETON.lookup(fileExtension);
return mediaFormat;
}
public MediaHeader getHeader() throws MediaException
{
InputStream content = new ByteArrayInputStream(getContent());
return getFormat().extractHeader(content);
}
public long getLastModified() throws MediaException
{
return getManagedLastModified();
}
public MediaListener[] getListeners() throws MediaException
{
Vector listeners = getManagedListeners();
return (MediaListener[]) listeners.toArray(new MediaListener[0]);
}
public URL getLocation() throws MediaException
{
String location = getManagedLocation();
try
{
return new URL(location);
}
catch (MalformedURLException e)
{
return null;
}
}
public MetaDataEntityLocal[] getMetaData() throws MediaException
{
return (MetaDataEntityLocal[]) getManagedMetaDatas().toArray(
new MetaDataEntityLocal[0]);
}
public String getMimeType() throws MediaException
{
String mimeType = getManagedMimeType();
if (mimeType == null)
{
mimeType = getFormat().getDefaultMimeType();
}
return mimeType;
}
public String getName() throws MediaException
{
return getManagedName();
}
public MediaEntityLocal getNextVersion() throws MediaException
{
return getManagedNextVersion();
}
public MediaEntityLocal[] getParents() throws MediaException
{
Collection parents = getManagedParents();
return (MediaEntityLocal[]) parents.toArray(new MediaEntityLocal[0]);
}
public MediaEntityLocal getPreviousVersion() throws MediaException
{
return getManagedPreviousVersion();
}
public Media getProxy() throws MediaException
{
MediaEntityLocal proxy = getManagedProxy();
Media proxyMedia = null;
try
{
if (proxy != null)
{
InputStream content = new ByteArrayInputStream(proxy.getContent());
proxyMedia =
new MediaBean(content, proxy.getMimeType(), proxy.getName());
}
else
{
InputStream content = new ByteArrayInputStream(getContent());
proxyMedia = getFormat().extractProxy(content);
}
if (proxyMedia != null)
{
return proxyMedia;
}
else
{
return new GenericMediaFormat().extractProxy(null);
}
}
catch (MediaException e)
{
return new GenericMediaFormat().extractProxy(null);
}
}
public long getSize() throws MediaException
{
if (getContent() == null)
{
throw new ContentAccessException();
}
return getContent().length;
}
public void importMedia(URL sourceLocation, String name)
throws MediaException
{
if (sourceLocation == null)
{
throw new NullPointerException();
}
setName(name);
InputStream sourceStream = null;
try
{
sourceStream = new FileInputStream(sourceLocation.getPath());
setContent(sourceStream);
}
catch (IOException e)
{
throw new ContentAccessException();
}
finally
{
if (sourceStream != null)
{
try
{
sourceStream.close();
}
catch (IOException ignore)
{
}
}
}
}
public int readContent(long position, byte[] buffer) throws MediaException
{
return readContent(position, buffer, 0, buffer.length);
}
public int readContent(long position, byte[] buffer, int offset, int length)
throws MediaException
{
byte[] content = getManagedContent();
if (content == null)
{
throw new ContentAccessException();
}
System.arraycopy(content, (int) position, buffer, offset, length);
return content.length;
}
public void removeListener(MediaListener listener) throws MediaException
{
if (listener == null)
{
throw new NullPointerException();
}
Vector listeners = getManagedListeners();
if (listeners.contains(listener))
{
listeners.remove(listener);
setManagedListeners(listeners);
}
}
public void removeMetaData(MetaDataEntityLocal metaData)
throws MediaException
{
if (metaData == null)
{
throw new NullPointerException();
}
getManagedMetaDatas().remove(metaData);
}
public void setChildren(MediaEntityLocal[] children) throws MediaException
{
if (children == null)
{
throw new NullPointerException();
}
if (getLocation() != null)
{
throw new ContentUnmutableException();
}
if (getContent() == null)
{
throw new ContentAccessException();
}
for (int i = 0; i < children.length; i++)
{
getManagedChildren().add(children[i]);
}
}
public void setContent(byte[] content) throws MediaException
{
if (getLocation() != null)
{
throw new ContentUnmutableException();
}
setManagedContent(content);
updateLastModified();
}
public void setContent(InputStream content) throws MediaException
{
if (content == null)
{
throw new NullPointerException();
}
if (getLocation() != null)
{
throw new ContentUnmutableException();
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
try
{
int DEFAULT_BUFFER_SIZE = 65536;
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int bytesRead;
while ((bytesRead = content.read(buffer)) != -1)
{
out.write(buffer, 0, bytesRead);
}
byte[] newContent = new byte[out.size()];
newContent = out.toByteArray();
setManagedContent(newContent);
updateLastModified();
}
catch (IOException e)
{
throw new ContentAccessException(e.getMessage());
}
finally
{
try
{
out.close();
}
catch (IOException ignore)
{
}
}
}
public void setDescription(String description) throws MediaException
{
setManagedDescription(description);
updateLastModified();
}
public void setLocation(URL location) throws MediaException
{
if (getContent() != null)
{
throw new ContentUnmutableException();
}
setManagedLocation(location.toExternalForm());
updateLastModified();
}
public void setMimeType(String mimeType) throws MediaException
{
setManagedMimeType(mimeType);
updateLastModified();
}
public void setName(String name) throws MediaException
{
setManagedName(name);
updateLastModified();
}
public void setPreviousVersion(MediaEntityLocal mediaEntity)
throws MediaException
{
throw new UnsupportedOperationException("Not implemented yet!");
}
public void setProxy(MediaEntityLocal mediaEntity) throws MediaException
{
setManagedProxy(mediaEntity);
}
public URL[] ejbHomeExportMedia(
MediaEntityLocal[] sourceMedia,
URL targetDirectoryLocation)
throws MediaException
{
throw new UnsupportedOperationException("Not implemented yet!");
}
public MediaEntityLocal[] ejbHomeImportMedia(
URL[] sourceLocations,
String[] names)
throws CreateException, MediaException
{
throw new UnsupportedOperationException("Not implemented yet!");
}
public URL ejbHomePublishContent(
Media mediaObject,
byte protocol,
ProtocolConstraints constraints)
throws MediaException
{
throw new UnsupportedOperationException("Not implemented yet!");
}
public Media ejbHomePublishMedia(
MediaEntityLocal[] playlist,
byte transferType,
ProtocolConstraints constraints)
throws MediaException
{
throw new UnsupportedOperationException("Not implemented yet!");
}
protected void updateLastModified()
{
setManagedLastModified(System.currentTimeMillis());
}
private String getFileName(String name)
{
int lastDotPosition = name.lastIndexOf('.');
if (lastDotPosition == -1)
{
return name;
}
else
{
return name.substring(0, lastDotPosition);
}
}
private String getFileExtension(String name)
{
int lastDotPosition = name.lastIndexOf('.');
if (lastDotPosition == -1)
{
return null;
}
else
{
return name.substring(lastDotPosition + 1);
}
}
}