1 /*
2 * Copyright (c) 2000, 2017, 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} 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 {@link java.util.ServiceLoader} facility.
48 * <p>
49 * Applications locate instances of this class by calling the
50 * {@link #lookupStreamPrintServiceFactories(DocFlavor, String)} method.
51 * <p>
52 * Applications can use a {@code StreamPrintService} obtained from a
53 * factory in place of a {@code PrintService} which represents a
54 * physical printer device.
55 */
56
57 public abstract class StreamPrintServiceFactory {
58
59 static class Services {
60 private ArrayList<StreamPrintServiceFactory> listOfFactories = null;
61 }
62
63 private static Services getServices() {
64 Services services =
65 (Services)AppContext.getAppContext().get(Services.class);
66 if (services == null) {
67 services = new Services();
68 AppContext.getAppContext().put(Services.class, services);
69 }
70 return services;
71 }
72
73 private static ArrayList<StreamPrintServiceFactory> getListOfFactories() {
74 return getServices().listOfFactories;
75 }
76
77 private static ArrayList<StreamPrintServiceFactory> initListOfFactories() {
78 ArrayList<StreamPrintServiceFactory> listOfFactories = new ArrayList<>();
79 getServices().listOfFactories = listOfFactories;
80 return listOfFactories;
81 }
82
83 /**
84 * Locates factories for print services that can be used with
85 * a print job to output a stream of data in the
86 * format specified by {@code outputMimeType}.
87 * <p>
88 * The {@code outputMimeType} parameter describes the document type that
89 * you want to create, whereas the {@code flavor} parameter describes the
90 * format in which the input data will be provided by the application
91 * to the {@code StreamPrintService}.
92 * <p>
93 * Although null is an acceptable value to use in the lookup of stream
94 * printing services, it's typical to search for a particular
95 * desired format, such as Postscript(TM).
96 *
97 * @param flavor of the input document type - null means match all
98 * types.
99 * @param outputMimeType representing the required output format, used to
100 * identify suitable stream printer factories. A value of null means
101 * match all formats.
102 * @return matching factories for stream print service instance,
103 * empty if no suitable factories could be located.
104 */
105 public static StreamPrintServiceFactory[]
106 lookupStreamPrintServiceFactories(DocFlavor flavor,
107 String outputMimeType) {
108
109 ArrayList<StreamPrintServiceFactory> list = getFactories(flavor, outputMimeType);
110 return list.toArray(new StreamPrintServiceFactory[list.size()]);
111 }
112
113 /** Queries the factory for the document format that is emitted
114 * by printers obtained from this factory.
115 *
116 * @return the output format described as a mime type.
117 */
118 public abstract String getOutputFormat();
119
120 /**
121 * Queries the factory for the document flavors that can be accepted
122 * by printers obtained from this factory.
123 * @return array of supported doc flavors.
124 */
125 public abstract DocFlavor[] getSupportedDocFlavors();
126
127 /**
128 * Returns a {@code StreamPrintService} that can print to
129 * the specified output stream.
130 * The output stream is created and managed by the application.
131 * It is the application's responsibility to close the stream and
132 * to ensure that this Printer is not reused.
133 * The application should not close this stream until any print job
134 * created from the printer is complete. Doing so earlier may generate
135 * a {@code PrinterException} and an event indicating that the
136 * job failed.
137 * <p>
138 * Whereas a {@code PrintService} connected to a physical printer
139 * can be reused,
140 * a {@code StreamPrintService} connected to a stream cannot.
141 * The underlying {@code StreamPrintService} may be disposed by
142 * the print system with
143 * the {@link StreamPrintService#dispose() dispose} method
144 * before returning from the
145 * {@link DocPrintJob#print(Doc, javax.print.attribute.PrintRequestAttributeSet) print}
146 * method of {@code DocPrintJob} so that the print system knows
147 * this printer is no longer usable.
148 * This is equivalent to a physical printer going offline - permanently.
149 * Applications may supply a null print stream to create a queryable
150 * service. It is not valid to create a PrintJob for such a stream.
151 * Implementations which allocate resources on construction should examine
152 * the stream and may wish to only allocate resources if the stream is
153 * non-null.
154 *
155 * @param out destination stream for generated output.
156 * @return a PrintService which will generate the format specified by the
157 * DocFlavor supported by this Factory.
158 */
159 public abstract StreamPrintService getPrintService(OutputStream out);
160
161
162 private static ArrayList<StreamPrintServiceFactory> getAllFactories() {
163 synchronized (StreamPrintServiceFactory.class) {
164
165 ArrayList<StreamPrintServiceFactory> listOfFactories = getListOfFactories();
166 if (listOfFactories != null) {
167 return listOfFactories;
168 } else {
169 listOfFactories = initListOfFactories();
170 }
171
172 try {
173 java.security.AccessController.doPrivileged(
174 new java.security.PrivilegedExceptionAction<Object>() {
175 public Object run() {
176 Iterator<StreamPrintServiceFactory> iterator =
177 ServiceLoader.load
178 (StreamPrintServiceFactory.class).iterator();
179 ArrayList<StreamPrintServiceFactory> lof = getListOfFactories();
180 while (iterator.hasNext()) {
181 try {
182 lof.add(iterator.next());
183 } catch (ServiceConfigurationError err) {
184 /* In the applet case, we continue */
185 if (System.getSecurityManager() != null) {
186 err.printStackTrace();
187 } else {
188 throw err;
189 }
190 }
191 }
192 return null;
193 }
194 });
195 } catch (java.security.PrivilegedActionException e) {
196 }
197 return listOfFactories;
198 }
199 }
200
201 private static boolean isMember(DocFlavor flavor, DocFlavor[] flavors) {
202 for (int f=0; f<flavors.length; f++ ) {
203 if (flavor.equals(flavors[f])) {
204 return true;
205 }
206 }
207 return false;
208 }
209
210 private static ArrayList<StreamPrintServiceFactory> getFactories(DocFlavor flavor, String outType) {
211
212 if (flavor == null && outType == null) {
213 return getAllFactories();
214 }
215
216 ArrayList<StreamPrintServiceFactory> list = new ArrayList<>();
217 Iterator<StreamPrintServiceFactory> iterator = getAllFactories().iterator();
218 while (iterator.hasNext()) {
219 StreamPrintServiceFactory factory = iterator.next();
220 if ((outType == null ||
221 outType.equalsIgnoreCase(factory.getOutputFormat())) &&
222 (flavor == null ||
223 isMember(flavor, factory.getSupportedDocFlavors()))) {
224 list.add(factory);
225 }
226 }
227
228 return list;
229 }
230
231 }