/*
* Copyright (c) 2000, 2007, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.print;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Iterator;
import javax.print.DocFlavor;
import sun.awt.AppContext;
import java.util.ServiceLoader;
import java.util.ServiceConfigurationError;
/**
* A <code>StreamPrintServiceFactory</code> is the factory for
* {@link StreamPrintService} instances,
* which can print to an output stream in a particular
* document format described as a mime type.
* A typical output document format may be Postscript(TM).
* <p>
* This class is implemented by a service and located by the
* implementation using the
* <a href="../../../technotes/guides/jar/jar.html#Service Provider">
* SPI JAR File specification</a>.
* <p>
* Applications locate instances of this class by calling the
* {@link #lookupStreamPrintServiceFactories(DocFlavor, String)} method.
* <p>
* Applications can use a <code>StreamPrintService</code> obtained from a
* factory in place of a <code>PrintService</code> which represents a
* physical printer device.
*/
public abstract class StreamPrintServiceFactory {
static class Services {
private ArrayList listOfFactories = null;
}
private static Services getServices() {
Services services =
(Services)AppContext.getAppContext().get(Services.class);
if (services == null) {
services = new Services();
AppContext.getAppContext().put(Services.class, services);
}
return services;
}
private static ArrayList getListOfFactories() {
return getServices().listOfFactories;
}
private static ArrayList initListOfFactories() {
ArrayList listOfFactories = new ArrayList();
getServices().listOfFactories = listOfFactories;
return listOfFactories;
}
/**
* Locates factories for print services that can be used with
* a print job to output a stream of data in the
* format specified by {@code outputMimeType}.
* <p>
* The {@code outputMimeType} parameter describes the document type that
* you want to create, whereas the {@code flavor} parameter describes the
* format in which the input data will be provided by the application
* to the {@code StreamPrintService}.
* <p>
* Although null is an acceptable value to use in the lookup of stream
* printing services, it's typical to search for a particular
* desired format, such as Postscript(TM).
* <p>
* @param flavor of the input document type - null means match all
* types.
* @param outputMimeType representing the required output format, used to
* identify suitable stream printer factories. A value of null means
* match all formats.
* @return - matching factories for stream print service instance,
* empty if no suitable factories could be located.
*/
public static StreamPrintServiceFactory[]
lookupStreamPrintServiceFactories(DocFlavor flavor,
String outputMimeType) {
ArrayList list = getFactories(flavor, outputMimeType);
return (StreamPrintServiceFactory[])
(list.toArray(new StreamPrintServiceFactory[list.size()]));
}
/** Queries the factory for the document format that is emitted
* by printers obtained from this factory.
*
* @return the output format described as a mime type.
*/
public abstract String getOutputFormat();
/**
* Queries the factory for the document flavors that can be accepted
* by printers obtained from this factory.
* @return array of supported doc flavors.
*/
public abstract DocFlavor[] getSupportedDocFlavors();
/**
* Returns a <code>StreamPrintService</code> that can print to
* the specified output stream.
* The output stream is created and managed by the application.
* It is the application's responsibility to close the stream and
* to ensure that this Printer is not reused.
* The application should not close this stream until any print job
* created from the printer is complete. Doing so earlier may generate
* a <code>PrinterException</code> and an event indicating that the
* job failed.
* <p>
* Whereas a <code>PrintService</code> connected to a physical printer
* can be reused,
* a <code>StreamPrintService</code> connected to a stream cannot.
* The underlying <code>StreamPrintService</code> may be disposed by
* the print system with
* the {@link StreamPrintService#dispose() dispose} method
* before returning from the
* {@link DocPrintJob#print(Doc, javax.print.attribute.PrintRequestAttributeSet) print}
* method of <code>DocPrintJob</code> so that the print system knows
* this printer is no longer usable.
* This is equivalent to a physical printer going offline - permanently.
* Applications may supply a null print stream to create a queryable
* service. It is not valid to create a PrintJob for such a stream.
* Implementations which allocate resources on construction should examine
* the stream and may wish to only allocate resources if the stream is
* non-null.
* <p>
* @param out destination stream for generated output.
* @return a PrintService which will generate the format specified by the
* DocFlavor supported by this Factory.
*/
public abstract StreamPrintService getPrintService(OutputStream out);
private static ArrayList getAllFactories() {
synchronized (StreamPrintServiceFactory.class) {
ArrayList listOfFactories = getListOfFactories();
if (listOfFactories != null) {
return listOfFactories;
} else {
listOfFactories = initListOfFactories();
}
try {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedExceptionAction() {
public Object run() {
Iterator<StreamPrintServiceFactory> iterator =
ServiceLoader.load
(StreamPrintServiceFactory.class).iterator();
ArrayList lof = getListOfFactories();
while (iterator.hasNext()) {
try {
lof.add(iterator.next());
} catch (ServiceConfigurationError err) {
/* In the applet case, we continue */
if (System.getSecurityManager() != null) {
err.printStackTrace();
} else {
throw err;
}
}
}
return null;
}
});
} catch (java.security.PrivilegedActionException e) {
}
return listOfFactories;
}
}
private static boolean isMember(DocFlavor flavor, DocFlavor[] flavors) {
for (int f=0; f<flavors.length; f++ ) {
if (flavor.equals(flavors[f])) {
return true;
}
}
return false;
}
private static ArrayList getFactories(DocFlavor flavor, String outType) {
if (flavor == null && outType == null) {
return getAllFactories();
}
ArrayList list = new ArrayList();
Iterator iterator = getAllFactories().iterator();
while (iterator.hasNext()) {
StreamPrintServiceFactory factory =
(StreamPrintServiceFactory)iterator.next();
if ((outType == null ||
outType.equalsIgnoreCase(factory.getOutputFormat())) &&
(flavor == null ||
isMember(flavor, factory.getSupportedDocFlavors()))) {
list.add(factory);
}
}
return list;
}
}