1 /*
2 * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javax.print;
27
28 import java.io.OutputStream;
29
30 import java.util.ArrayList;
31 import java.util.Iterator;
32
33 import javax.print.DocFlavor;
34
35 import sun.awt.AppContext;
36 import java.util.ServiceLoader;
37 import java.util.ServiceConfigurationError;
38
39 /**
40 * A <code>StreamPrintServiceFactory</code> is the factory for
41 * {@link StreamPrintService} instances,
42 * which can print to an output stream in a particular
43 * document format described as a mime type.
44 * A typical output document format may be Postscript(TM).
45 * <p>
46 * This class is implemented by a service and located by the
47 * implementation using the
48 * <a href="../../../technotes/guides/jar/jar.html#Service%20Provider">
49 * SPI JAR File specification</a>.
50 * <p>
51 * Applications locate instances of this class by calling the
52 * {@link #lookupStreamPrintServiceFactories(DocFlavor, String)} method.
53 * <p>
54 * Applications can use a <code>StreamPrintService</code> obtained from a
55 * factory in place of a <code>PrintService</code> which represents a
56 * physical printer device.
57 */
58
59 public abstract class StreamPrintServiceFactory {
60
61 static class Services {
62 private ArrayList<StreamPrintServiceFactory> listOfFactories = null;
63 }
64
65 private static Services getServices() {
66 Services services =
67 (Services)AppContext.getAppContext().get(Services.class);
68 if (services == null) {
69 services = new Services();
70 AppContext.getAppContext().put(Services.class, services);
71 }
72 return services;
73 }
74
75 private static ArrayList<StreamPrintServiceFactory> getListOfFactories() {
76 return getServices().listOfFactories;
77 }
78
79 private static ArrayList<StreamPrintServiceFactory> initListOfFactories() {
80 ArrayList<StreamPrintServiceFactory> listOfFactories = new ArrayList<>();
81 getServices().listOfFactories = listOfFactories;
82 return listOfFactories;
83 }
84
85 /**
86 * Locates factories for print services that can be used with
87 * a print job to output a stream of data in the
88 * format specified by {@code outputMimeType}.
89 * <p>
90 * The {@code outputMimeType} parameter describes the document type that
91 * you want to create, whereas the {@code flavor} parameter describes the
92 * format in which the input data will be provided by the application
93 * to the {@code StreamPrintService}.
94 * <p>
95 * Although null is an acceptable value to use in the lookup of stream
96 * printing services, it's typical to search for a particular
97 * desired format, such as Postscript(TM).
98 *
99 * @param flavor of the input document type - null means match all
100 * types.
101 * @param outputMimeType representing the required output format, used to
102 * identify suitable stream printer factories. A value of null means
103 * match all formats.
104 * @return matching factories for stream print service instance,
105 * empty if no suitable factories could be located.
106 */
107 public static StreamPrintServiceFactory[]
108 lookupStreamPrintServiceFactories(DocFlavor flavor,
109 String outputMimeType) {
110
111 ArrayList<StreamPrintServiceFactory> list = getFactories(flavor, outputMimeType);
112 return list.toArray(new StreamPrintServiceFactory[list.size()]);
113 }
114
115 /** Queries the factory for the document format that is emitted
116 * by printers obtained from this factory.
117 *
118 * @return the output format described as a mime type.
119 */
120 public abstract String getOutputFormat();
121
122 /**
123 * Queries the factory for the document flavors that can be accepted
124 * by printers obtained from this factory.
125 * @return array of supported doc flavors.
126 */
127 public abstract DocFlavor[] getSupportedDocFlavors();
128
129 /**
130 * Returns a <code>StreamPrintService</code> that can print to
131 * the specified output stream.
132 * The output stream is created and managed by the application.
133 * It is the application's responsibility to close the stream and
134 * to ensure that this Printer is not reused.
135 * The application should not close this stream until any print job
136 * created from the printer is complete. Doing so earlier may generate
137 * a <code>PrinterException</code> and an event indicating that the
138 * job failed.
139 * <p>
140 * Whereas a <code>PrintService</code> connected to a physical printer
141 * can be reused,
142 * a <code>StreamPrintService</code> connected to a stream cannot.
143 * The underlying <code>StreamPrintService</code> may be disposed by
144 * the print system with
145 * the {@link StreamPrintService#dispose() dispose} method
146 * before returning from the
147 * {@link DocPrintJob#print(Doc, javax.print.attribute.PrintRequestAttributeSet) print}
148 * method of <code>DocPrintJob</code> so that the print system knows
149 * this printer is no longer usable.
150 * This is equivalent to a physical printer going offline - permanently.
151 * Applications may supply a null print stream to create a queryable
152 * service. It is not valid to create a PrintJob for such a stream.
153 * Implementations which allocate resources on construction should examine
154 * the stream and may wish to only allocate resources if the stream is
155 * non-null.
156 *
157 * @param out destination stream for generated output.
158 * @return a PrintService which will generate the format specified by the
159 * DocFlavor supported by this Factory.
160 */
161 public abstract StreamPrintService getPrintService(OutputStream out);
162
163
164 private static ArrayList<StreamPrintServiceFactory> getAllFactories() {
165 synchronized (StreamPrintServiceFactory.class) {
166
167 ArrayList<StreamPrintServiceFactory> listOfFactories = getListOfFactories();
168 if (listOfFactories != null) {
169 return listOfFactories;
170 } else {
171 listOfFactories = initListOfFactories();
172 }
173
174 try {
175 java.security.AccessController.doPrivileged(
176 new java.security.PrivilegedExceptionAction<Object>() {
177 public Object run() {
178 Iterator<StreamPrintServiceFactory> iterator =
179 ServiceLoader.load
180 (StreamPrintServiceFactory.class).iterator();
181 ArrayList<StreamPrintServiceFactory> lof = getListOfFactories();
182 while (iterator.hasNext()) {
183 try {
184 lof.add(iterator.next());
185 } catch (ServiceConfigurationError err) {
186 /* In the applet case, we continue */
187 if (System.getSecurityManager() != null) {
188 err.printStackTrace();
189 } else {
190 throw err;
191 }
192 }
193 }
194 return null;
195 }
196 });
197 } catch (java.security.PrivilegedActionException e) {
198 }
199 return listOfFactories;
200 }
201 }
202
203 private static boolean isMember(DocFlavor flavor, DocFlavor[] flavors) {
204 for (int f=0; f<flavors.length; f++ ) {
205 if (flavor.equals(flavors[f])) {
206 return true;
207 }
208 }
209 return false;
210 }
211
212 private static ArrayList<StreamPrintServiceFactory> getFactories(DocFlavor flavor, String outType) {
213
214 if (flavor == null && outType == null) {
215 return getAllFactories();
216 }
217
218 ArrayList<StreamPrintServiceFactory> list = new ArrayList<>();
219 Iterator<StreamPrintServiceFactory> iterator = getAllFactories().iterator();
220 while (iterator.hasNext()) {
221 StreamPrintServiceFactory factory = iterator.next();
222 if ((outType == null ||
223 outType.equalsIgnoreCase(factory.getOutputFormat())) &&
224 (flavor == null ||
225 isMember(flavor, factory.getSupportedDocFlavors()))) {
226 list.add(factory);
227 }
228 }
229
230 return list;
231 }
232
233 }