| /* |
| * Copyright (c) 2003, 2014, 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 sun.print; |
| |
| import javax.print.attribute.*; |
| import javax.print.attribute.standard.*; |
| import javax.print.DocFlavor; |
| import javax.print.DocPrintJob; |
| import javax.print.PrintService; |
| import javax.print.ServiceUIFactory; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Locale; |
| import java.util.Date; |
| import java.util.Arrays; |
| import java.security.AccessController; |
| import java.security.PrivilegedActionException; |
| import java.security.PrivilegedExceptionAction; |
| import javax.print.event.PrintServiceAttributeListener; |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.net.HttpURLConnection; |
| import java.io.File; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.DataInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.ByteArrayInputStream; |
| import java.io.BufferedReader; |
| import java.io.InputStreamReader; |
| import java.nio.charset.Charset; |
| |
| import java.util.Iterator; |
| import java.util.HashSet; |
| import java.util.Map; |
| |
| |
| public class IPPPrintService implements PrintService, SunPrinterJobService { |
| |
| public static final boolean debugPrint; |
| private static final String debugPrefix = "IPPPrintService>> "; |
| protected static void debug_println(String str) { |
| if (debugPrint) { |
| System.out.println(str); |
| } |
| } |
| |
| private static final String FORCE_PIPE_PROP = "sun.print.ippdebug"; |
| |
| static { |
| String debugStr = java.security.AccessController.doPrivileged( |
| new sun.security.action.GetPropertyAction(FORCE_PIPE_PROP)); |
| |
| debugPrint = "true".equalsIgnoreCase(debugStr); |
| } |
| |
| private String printer; |
| private URI myURI; |
| private URL myURL; |
| private transient ServiceNotifier notifier = null; |
| |
| private static int MAXCOPIES = 1000; |
| private static short MAX_ATTRIBUTE_LENGTH = 255; |
| |
| private CUPSPrinter cps; |
| private HttpURLConnection urlConnection = null; |
| private DocFlavor[] supportedDocFlavors; |
| private Class<?>[] supportedCats; |
| private MediaTray[] mediaTrays; |
| private MediaSizeName[] mediaSizeNames; |
| private CustomMediaSizeName[] customMediaSizeNames; |
| private int defaultMediaIndex; |
| private int[] rawResolutions = null; |
| private PrinterResolution[] printerResolutions = null; |
| private boolean isCupsPrinter; |
| private boolean init; |
| private Boolean isPS; |
| private HashMap<String, AttributeClass> getAttMap; |
| private boolean pngImagesAdded = false; |
| private boolean gifImagesAdded = false; |
| private boolean jpgImagesAdded = false; |
| |
| |
| /** |
| * IPP Status Codes |
| */ |
| private static final byte STATUSCODE_SUCCESS = 0x00; |
| |
| /** |
| * IPP Group Tags. Each tag is used once before the first attribute |
| * of that group. |
| */ |
| // operation attributes group |
| private static final byte GRPTAG_OP_ATTRIBUTES = 0x01; |
| // job attributes group |
| private static final byte GRPTAG_JOB_ATTRIBUTES = 0x02; |
| // printer attributes group |
| private static final byte GRPTAG_PRINTER_ATTRIBUTES = 0x04; |
| // used as the last tag in an IPP message. |
| private static final byte GRPTAG_END_ATTRIBUTES = 0x03; |
| |
| /** |
| * IPP Operation codes |
| */ |
| // gets the attributes for a printer |
| public static final String OP_GET_ATTRIBUTES = "000B"; |
| // gets the default printer |
| public static final String OP_CUPS_GET_DEFAULT = "4001"; |
| // gets the list of printers |
| public static final String OP_CUPS_GET_PRINTERS = "4002"; |
| |
| |
| /** |
| * List of all PrintRequestAttributes. This is used |
| * for looping through all the IPP attribute name. |
| */ |
| private static Object[] printReqAttribDefault = { |
| Chromaticity.COLOR, |
| new Copies(1), |
| Fidelity.FIDELITY_FALSE, |
| Finishings.NONE, |
| //new JobHoldUntil(new Date()), |
| //new JobImpressions(0), |
| //JobImpressions, |
| //JobKOctets, |
| //JobMediaSheets, |
| new JobName("", Locale.getDefault()), |
| //JobPriority, |
| JobSheets.NONE, |
| (Media)MediaSizeName.NA_LETTER, |
| //MediaPrintableArea.class, // not an IPP attribute |
| //MultipleDocumentHandling.SINGLE_DOCUMENT, |
| new NumberUp(1), |
| OrientationRequested.PORTRAIT, |
| new PageRanges(1), |
| //PresentationDirection, |
| // CUPS does not supply printer-resolution attribute |
| //new PrinterResolution(300, 300, PrinterResolution.DPI), |
| //PrintQuality.NORMAL, |
| new RequestingUserName("", Locale.getDefault()), |
| //SheetCollate.UNCOLLATED, //CUPS has no sheet collate? |
| Sides.ONE_SIDED, |
| }; |
| |
| |
| /** |
| * List of all PrintServiceAttributes. This is used |
| * for looping through all the IPP attribute name. |
| */ |
| private static Object[][] serviceAttributes = { |
| {ColorSupported.class, "color-supported"}, |
| {PagesPerMinute.class, "pages-per-minute"}, |
| {PagesPerMinuteColor.class, "pages-per-minute-color"}, |
| {PDLOverrideSupported.class, "pdl-override-supported"}, |
| {PrinterInfo.class, "printer-info"}, |
| {PrinterIsAcceptingJobs.class, "printer-is-accepting-jobs"}, |
| {PrinterLocation.class, "printer-location"}, |
| {PrinterMakeAndModel.class, "printer-make-and-model"}, |
| {PrinterMessageFromOperator.class, "printer-message-from-operator"}, |
| {PrinterMoreInfo.class, "printer-more-info"}, |
| {PrinterMoreInfoManufacturer.class, "printer-more-info-manufacturer"}, |
| {PrinterName.class, "printer-name"}, |
| {PrinterState.class, "printer-state"}, |
| {PrinterStateReasons.class, "printer-state-reasons"}, |
| {PrinterURI.class, "printer-uri"}, |
| {QueuedJobCount.class, "queued-job-count"} |
| }; |
| |
| |
| /** |
| * List of DocFlavors, grouped based on matching mime-type. |
| * NOTE: For any change in the predefined DocFlavors, it must be reflected |
| * here also. |
| */ |
| // PDF DocFlavors |
| private static DocFlavor[] appPDF = { |
| DocFlavor.BYTE_ARRAY.PDF, |
| DocFlavor.INPUT_STREAM.PDF, |
| DocFlavor.URL.PDF |
| }; |
| |
| // Postscript DocFlavors |
| private static DocFlavor[] appPostScript = { |
| DocFlavor.BYTE_ARRAY.POSTSCRIPT, |
| DocFlavor.INPUT_STREAM.POSTSCRIPT, |
| DocFlavor.URL.POSTSCRIPT |
| }; |
| |
| // Autosense DocFlavors |
| private static DocFlavor[] appOctetStream = { |
| DocFlavor.BYTE_ARRAY.AUTOSENSE, |
| DocFlavor.INPUT_STREAM.AUTOSENSE, |
| DocFlavor.URL.AUTOSENSE |
| }; |
| |
| // Text DocFlavors |
| private static DocFlavor[] textPlain = { |
| DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_8, |
| DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_16, |
| DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_16BE, |
| DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_16LE, |
| DocFlavor.BYTE_ARRAY.TEXT_PLAIN_US_ASCII, |
| DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_8, |
| DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_16, |
| DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_16BE, |
| DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_16LE, |
| DocFlavor.INPUT_STREAM.TEXT_PLAIN_US_ASCII, |
| DocFlavor.URL.TEXT_PLAIN_UTF_8, |
| DocFlavor.URL.TEXT_PLAIN_UTF_16, |
| DocFlavor.URL.TEXT_PLAIN_UTF_16BE, |
| DocFlavor.URL.TEXT_PLAIN_UTF_16LE, |
| DocFlavor.URL.TEXT_PLAIN_US_ASCII, |
| DocFlavor.CHAR_ARRAY.TEXT_PLAIN, |
| DocFlavor.STRING.TEXT_PLAIN, |
| DocFlavor.READER.TEXT_PLAIN |
| }; |
| |
| private static DocFlavor[] textPlainHost = { |
| DocFlavor.BYTE_ARRAY.TEXT_PLAIN_HOST, |
| DocFlavor.INPUT_STREAM.TEXT_PLAIN_HOST, |
| DocFlavor.URL.TEXT_PLAIN_HOST |
| }; |
| |
| // JPG DocFlavors |
| private static DocFlavor[] imageJPG = { |
| DocFlavor.BYTE_ARRAY.JPEG, |
| DocFlavor.INPUT_STREAM.JPEG, |
| DocFlavor.URL.JPEG |
| }; |
| |
| // GIF DocFlavors |
| private static DocFlavor[] imageGIF = { |
| DocFlavor.BYTE_ARRAY.GIF, |
| DocFlavor.INPUT_STREAM.GIF, |
| DocFlavor.URL.GIF |
| }; |
| |
| // PNG DocFlavors |
| private static DocFlavor[] imagePNG = { |
| DocFlavor.BYTE_ARRAY.PNG, |
| DocFlavor.INPUT_STREAM.PNG, |
| DocFlavor.URL.PNG |
| }; |
| |
| // HTML DocFlavors |
| private static DocFlavor[] textHtml = { |
| DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_8, |
| DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_16, |
| DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_16BE, |
| DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_16LE, |
| DocFlavor.BYTE_ARRAY.TEXT_HTML_US_ASCII, |
| DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_8, |
| DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_16, |
| DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_16BE, |
| DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_16LE, |
| DocFlavor.INPUT_STREAM.TEXT_HTML_US_ASCII, |
| DocFlavor.URL.TEXT_HTML_UTF_8, |
| DocFlavor.URL.TEXT_HTML_UTF_16, |
| DocFlavor.URL.TEXT_HTML_UTF_16BE, |
| DocFlavor.URL.TEXT_HTML_UTF_16LE, |
| DocFlavor.URL.TEXT_HTML_US_ASCII, |
| // These are not handled in UnixPrintJob so commenting these |
| // for now. |
| /* |
| DocFlavor.CHAR_ARRAY.TEXT_HTML, |
| DocFlavor.STRING.TEXT_HTML, |
| DocFlavor.READER.TEXT_HTML, |
| */ |
| }; |
| |
| private static DocFlavor[] textHtmlHost = { |
| DocFlavor.BYTE_ARRAY.TEXT_HTML_HOST, |
| DocFlavor.INPUT_STREAM.TEXT_HTML_HOST, |
| DocFlavor.URL.TEXT_HTML_HOST, |
| }; |
| |
| |
| // PCL DocFlavors |
| private static DocFlavor[] appPCL = { |
| DocFlavor.BYTE_ARRAY.PCL, |
| DocFlavor.INPUT_STREAM.PCL, |
| DocFlavor.URL.PCL |
| }; |
| |
| // List of all DocFlavors, used in looping |
| // through all supported mime-types |
| private static Object[] allDocFlavors = { |
| appPDF, appPostScript, appOctetStream, |
| textPlain, imageJPG, imageGIF, imagePNG, |
| textHtml, appPCL, |
| }; |
| |
| |
| IPPPrintService(String name, URL url) { |
| if ((name == null) || (url == null)){ |
| throw new IllegalArgumentException("null uri or printer name"); |
| } |
| try { |
| printer = java.net.URLDecoder.decode(name, "UTF-8"); |
| } catch (java.io.UnsupportedEncodingException e) { |
| printer = name; |
| } |
| supportedDocFlavors = null; |
| supportedCats = null; |
| mediaSizeNames = null; |
| customMediaSizeNames = null; |
| mediaTrays = null; |
| myURL = url; |
| cps = null; |
| isCupsPrinter = false; |
| init = false; |
| defaultMediaIndex = -1; |
| |
| String host = myURL.getHost(); |
| if (host!=null && host.equals(CUPSPrinter.getServer())) { |
| isCupsPrinter = true; |
| try { |
| myURI = new URI("ipp://"+host+ |
| "/printers/"+printer); |
| debug_println(debugPrefix+"IPPPrintService myURI : "+myURI); |
| } catch (java.net.URISyntaxException e) { |
| throw new IllegalArgumentException("invalid url"); |
| } |
| } |
| } |
| |
| |
| IPPPrintService(String name, String uriStr, boolean isCups) { |
| if ((name == null) || (uriStr == null)){ |
| throw new IllegalArgumentException("null uri or printer name"); |
| } |
| try { |
| printer = java.net.URLDecoder.decode(name, "UTF-8"); |
| } catch (java.io.UnsupportedEncodingException e) { |
| printer = name; |
| } |
| supportedDocFlavors = null; |
| supportedCats = null; |
| mediaSizeNames = null; |
| customMediaSizeNames = null; |
| mediaTrays = null; |
| cps = null; |
| init = false; |
| defaultMediaIndex = -1; |
| try { |
| myURL = |
| new URL(uriStr.replaceFirst("ipp", "http")); |
| } catch (Exception e) { |
| IPPPrintService.debug_println(debugPrefix+ |
| " IPPPrintService, myURL="+ |
| myURL+" Exception= "+ |
| e); |
| throw new IllegalArgumentException("invalid url"); |
| } |
| |
| isCupsPrinter = isCups; |
| try { |
| myURI = new URI(uriStr); |
| debug_println(debugPrefix+"IPPPrintService myURI : "+myURI); |
| } catch (java.net.URISyntaxException e) { |
| throw new IllegalArgumentException("invalid uri"); |
| } |
| } |
| |
| |
| /* |
| * Initialize mediaSizeNames, mediaTrays and other attributes. |
| * Media size/trays are initialized to non-null values, may be 0-length |
| * array. |
| * NOTE: Must be called from a synchronized block only. |
| */ |
| private void initAttributes() { |
| if (!init) { |
| // init customMediaSizeNames |
| customMediaSizeNames = new CustomMediaSizeName[0]; |
| |
| if ((urlConnection = getIPPConnection(myURL)) == null) { |
| mediaSizeNames = new MediaSizeName[0]; |
| mediaTrays = new MediaTray[0]; |
| debug_println(debugPrefix+"initAttributes, NULL urlConnection "); |
| init = true; |
| return; |
| } |
| |
| // get all supported attributes through IPP |
| opGetAttributes(); |
| |
| if (isCupsPrinter) { |
| // note, it is possible to query media in CUPS using IPP |
| // right now we always get it from PPD. |
| // maybe use "&& (usePPD)" later? |
| // Another reason why we use PPD is because |
| // IPP currently does not support it but PPD does. |
| |
| try { |
| cps = new CUPSPrinter(printer); |
| mediaSizeNames = cps.getMediaSizeNames(); |
| mediaTrays = cps.getMediaTrays(); |
| customMediaSizeNames = cps.getCustomMediaSizeNames(); |
| defaultMediaIndex = cps.getDefaultMediaIndex(); |
| rawResolutions = cps.getRawResolutions(); |
| urlConnection.disconnect(); |
| init = true; |
| return; |
| } catch (Exception e) { |
| IPPPrintService.debug_println(debugPrefix+ |
| "initAttributes, error creating CUPSPrinter e="+e); |
| } |
| } |
| |
| // use IPP to get all media, |
| Media[] allMedia = getSupportedMedia(); |
| ArrayList<Media> sizeList = new ArrayList<>(); |
| ArrayList<Media> trayList = new ArrayList<>(); |
| for (int i=0; i<allMedia.length; i++) { |
| if (allMedia[i] instanceof MediaSizeName) { |
| sizeList.add(allMedia[i]); |
| } else if (allMedia[i] instanceof MediaTray) { |
| trayList.add(allMedia[i]); |
| } |
| } |
| |
| if (sizeList != null) { |
| mediaSizeNames = new MediaSizeName[sizeList.size()]; |
| mediaSizeNames = sizeList.toArray(mediaSizeNames); |
| } |
| if (trayList != null) { |
| mediaTrays = new MediaTray[trayList.size()]; |
| mediaTrays = trayList.toArray(mediaTrays); |
| } |
| urlConnection.disconnect(); |
| |
| init = true; |
| } |
| } |
| |
| |
| public DocPrintJob createPrintJob() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkPrintJobAccess(); |
| } |
| // REMIND: create IPPPrintJob |
| return new UnixPrintJob(this); |
| } |
| |
| |
| public synchronized Object |
| getSupportedAttributeValues(Class<? extends Attribute> category, |
| DocFlavor flavor, |
| AttributeSet attributes) |
| { |
| if (category == null) { |
| throw new NullPointerException("null category"); |
| } |
| if (!Attribute.class.isAssignableFrom(category)) { |
| throw new IllegalArgumentException(category + |
| " does not implement Attribute"); |
| } |
| if (flavor != null) { |
| if (!isDocFlavorSupported(flavor)) { |
| throw new IllegalArgumentException(flavor + |
| " is an unsupported flavor"); |
| } else if (isAutoSense(flavor)) { |
| return null; |
| } |
| |
| } |
| |
| if (!isAttributeCategorySupported(category)) { |
| return null; |
| } |
| |
| /* Test if the flavor is compatible with the attributes */ |
| if (!isDestinationSupported(flavor, attributes)) { |
| return null; |
| } |
| |
| initAttributes(); |
| |
| /* Test if the flavor is compatible with the category */ |
| if ((category == Copies.class) || |
| (category == CopiesSupported.class)) { |
| if (flavor == null || |
| !(flavor.equals(DocFlavor.INPUT_STREAM.POSTSCRIPT) || |
| flavor.equals(DocFlavor.URL.POSTSCRIPT) || |
| flavor.equals(DocFlavor.BYTE_ARRAY.POSTSCRIPT))) { |
| CopiesSupported cs = new CopiesSupported(1, MAXCOPIES); |
| AttributeClass attribClass = (getAttMap != null) ? |
| getAttMap.get(cs.getName()) : null; |
| if (attribClass != null) { |
| int[] range = attribClass.getIntRangeValue(); |
| cs = new CopiesSupported(range[0], range[1]); |
| } |
| return cs; |
| } else { |
| return null; |
| } |
| } else if (category == Chromaticity.class) { |
| if (flavor == null || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE) || |
| !isIPPSupportedImages(flavor.getMimeType())) { |
| Chromaticity[]arr = new Chromaticity[1]; |
| arr[0] = Chromaticity.COLOR; |
| return (arr); |
| } else { |
| return null; |
| } |
| } else if (category == Destination.class) { |
| if (flavor == null || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE)) { |
| try { |
| return new Destination((new File("out.ps")).toURI()); |
| } catch (SecurityException se) { |
| try { |
| return new Destination(new URI("file:out.ps")); |
| } catch (URISyntaxException e) { |
| return null; |
| } |
| } |
| } |
| return null; |
| } else if (category == Fidelity.class) { |
| Fidelity []arr = new Fidelity[2]; |
| arr[0] = Fidelity.FIDELITY_FALSE; |
| arr[1] = Fidelity.FIDELITY_TRUE; |
| return arr; |
| } else if (category == Finishings.class) { |
| AttributeClass attribClass = (getAttMap != null) ? |
| getAttMap.get("finishings-supported") |
| : null; |
| if (attribClass != null) { |
| int[] finArray = attribClass.getArrayOfIntValues(); |
| if ((finArray != null) && (finArray.length > 0)) { |
| Finishings[] finSup = new Finishings[finArray.length]; |
| for (int i=0; i<finArray.length; i++) { |
| finSup[i] = Finishings.NONE; |
| Finishings[] fAll = (Finishings[]) |
| (new ExtFinishing(100)).getAll(); |
| for (int j=0; j<fAll.length; j++) { |
| if (finArray[i] == fAll[j].getValue()) { |
| finSup[i] = fAll[j]; |
| break; |
| } |
| } |
| } |
| return finSup; |
| } |
| } |
| } else if (category == JobName.class) { |
| return new JobName("Java Printing", null); |
| } else if (category == JobSheets.class) { |
| JobSheets arr[] = new JobSheets[2]; |
| arr[0] = JobSheets.NONE; |
| arr[1] = JobSheets.STANDARD; |
| return arr; |
| |
| } else if (category == Media.class) { |
| Media[] allMedia = new Media[mediaSizeNames.length+ |
| mediaTrays.length]; |
| |
| for (int i=0; i<mediaSizeNames.length; i++) { |
| allMedia[i] = mediaSizeNames[i]; |
| } |
| |
| for (int i=0; i<mediaTrays.length; i++) { |
| allMedia[i+mediaSizeNames.length] = mediaTrays[i]; |
| } |
| |
| if (allMedia.length == 0) { |
| allMedia = new Media[1]; |
| allMedia[0] = (Media)getDefaultAttributeValue(Media.class); |
| } |
| |
| return allMedia; |
| } else if (category == MediaPrintableArea.class) { |
| MediaPrintableArea[] mpas = null; |
| if (cps != null) { |
| mpas = cps.getMediaPrintableArea(); |
| } |
| |
| if (mpas == null) { |
| mpas = new MediaPrintableArea[1]; |
| mpas[0] = (MediaPrintableArea) |
| getDefaultAttributeValue(MediaPrintableArea.class); |
| } |
| |
| if ((attributes == null) || (attributes.size() == 0)) { |
| ArrayList<MediaPrintableArea> printableList = |
| new ArrayList<MediaPrintableArea>(); |
| |
| for (int i=0; i<mpas.length; i++) { |
| if (mpas[i] != null) { |
| printableList.add(mpas[i]); |
| } |
| } |
| if (printableList.size() > 0) { |
| mpas = new MediaPrintableArea[printableList.size()]; |
| printableList.toArray(mpas); |
| } |
| return mpas; |
| } |
| |
| int match = -1; |
| Media media = (Media)attributes.get(Media.class); |
| if (media != null && media instanceof MediaSizeName) { |
| MediaSizeName msn = (MediaSizeName)media; |
| |
| // case when no supported mediasizenames are reported |
| // check given media against the default |
| if (mediaSizeNames.length == 0 && |
| msn.equals(getDefaultAttributeValue(Media.class))) { |
| //default printable area is that of default mediasize |
| return mpas; |
| } |
| |
| for (int i=0; i<mediaSizeNames.length; i++) { |
| if (msn.equals(mediaSizeNames[i])) { |
| match = i; |
| } |
| } |
| } |
| |
| if (match == -1) { |
| return null; |
| } else { |
| MediaPrintableArea []arr = new MediaPrintableArea[1]; |
| arr[0] = mpas[match]; |
| return arr; |
| } |
| } else if (category == NumberUp.class) { |
| AttributeClass attribClass = (getAttMap != null) ? |
| getAttMap.get("number-up-supported") : null; |
| if (attribClass != null) { |
| int[] values = attribClass.getArrayOfIntValues(); |
| if (values != null) { |
| NumberUp[] nUp = new NumberUp[values.length]; |
| for (int i=0; i<values.length; i++) { |
| nUp[i] = new NumberUp(values[i]); |
| } |
| return nUp; |
| } else { |
| return null; |
| } |
| } |
| } else if (category == OrientationRequested.class) { |
| if ((flavor != null) && |
| (flavor.equals(DocFlavor.INPUT_STREAM.POSTSCRIPT) || |
| flavor.equals(DocFlavor.URL.POSTSCRIPT) || |
| flavor.equals(DocFlavor.BYTE_ARRAY.POSTSCRIPT))) { |
| return null; |
| } |
| |
| boolean revPort = false; |
| OrientationRequested[] orientSup = null; |
| |
| AttributeClass attribClass = (getAttMap != null) ? |
| getAttMap.get("orientation-requested-supported") |
| : null; |
| if (attribClass != null) { |
| int[] orientArray = attribClass.getArrayOfIntValues(); |
| if ((orientArray != null) && (orientArray.length > 0)) { |
| orientSup = |
| new OrientationRequested[orientArray.length]; |
| for (int i=0; i<orientArray.length; i++) { |
| switch (orientArray[i]) { |
| default: |
| case 3 : |
| orientSup[i] = OrientationRequested.PORTRAIT; |
| break; |
| case 4: |
| orientSup[i] = OrientationRequested.LANDSCAPE; |
| break; |
| case 5: |
| orientSup[i] = |
| OrientationRequested.REVERSE_LANDSCAPE; |
| break; |
| case 6: |
| orientSup[i] = |
| OrientationRequested.REVERSE_PORTRAIT; |
| revPort = true; |
| break; |
| } |
| } |
| } |
| } |
| if (flavor == null || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE)) { |
| |
| if (revPort && flavor == null) { |
| OrientationRequested []orSup = new OrientationRequested[4]; |
| orSup[0] = OrientationRequested.PORTRAIT; |
| orSup[1] = OrientationRequested.LANDSCAPE; |
| orSup[2] = OrientationRequested.REVERSE_LANDSCAPE; |
| orSup[3] = OrientationRequested.REVERSE_PORTRAIT; |
| return orSup; |
| } else { |
| OrientationRequested []orSup = new OrientationRequested[3]; |
| orSup[0] = OrientationRequested.PORTRAIT; |
| orSup[1] = OrientationRequested.LANDSCAPE; |
| orSup[2] = OrientationRequested.REVERSE_LANDSCAPE; |
| return orSup; |
| } |
| } else { |
| return orientSup; |
| } |
| } else if (category == PageRanges.class) { |
| if (flavor == null || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE)) { |
| PageRanges []arr = new PageRanges[1]; |
| arr[0] = new PageRanges(1, Integer.MAX_VALUE); |
| return arr; |
| } else { |
| // Returning null as this is not yet supported in UnixPrintJob. |
| return null; |
| } |
| } else if (category == RequestingUserName.class) { |
| String userName = ""; |
| try { |
| userName = System.getProperty("user.name", ""); |
| } catch (SecurityException se) { |
| } |
| return new RequestingUserName(userName, null); |
| } else if (category == Sides.class) { |
| // The printer takes care of Sides so if short-edge |
| // is chosen in a job, the rotation is done by the printer. |
| // Orientation is rotated by emulation if pageable |
| // or printable so if the document is in Landscape, this may |
| // result in double rotation. |
| AttributeClass attribClass = (getAttMap != null) ? |
| getAttMap.get("sides-supported") |
| : null; |
| if (attribClass != null) { |
| String[] sidesArray = attribClass.getArrayOfStringValues(); |
| if ((sidesArray != null) && (sidesArray.length > 0)) { |
| Sides[] sidesSup = new Sides[sidesArray.length]; |
| for (int i=0; i<sidesArray.length; i++) { |
| if (sidesArray[i].endsWith("long-edge")) { |
| sidesSup[i] = Sides.TWO_SIDED_LONG_EDGE; |
| } else if (sidesArray[i].endsWith("short-edge")) { |
| sidesSup[i] = Sides.TWO_SIDED_SHORT_EDGE; |
| } else { |
| sidesSup[i] = Sides.ONE_SIDED; |
| } |
| } |
| return sidesSup; |
| } |
| } |
| } else if (category == PrinterResolution.class) { |
| PrinterResolution[] supportedRes = getPrintResolutions(); |
| if (supportedRes == null) { |
| return null; |
| } |
| PrinterResolution []arr = |
| new PrinterResolution[supportedRes.length]; |
| System.arraycopy(supportedRes, 0, arr, 0, supportedRes.length); |
| return arr; |
| } |
| |
| return null; |
| } |
| |
| //This class is for getting all pre-defined Finishings |
| @SuppressWarnings("serial") // JDK implementation class |
| private class ExtFinishing extends Finishings { |
| ExtFinishing(int value) { |
| super(100); // 100 to avoid any conflicts with predefined values. |
| } |
| |
| EnumSyntax[] getAll() { |
| EnumSyntax[] es = super.getEnumValueTable(); |
| return es; |
| } |
| } |
| |
| |
| public AttributeSet getUnsupportedAttributes(DocFlavor flavor, |
| AttributeSet attributes) { |
| if (flavor != null && !isDocFlavorSupported(flavor)) { |
| throw new IllegalArgumentException("flavor " + flavor + |
| "is not supported"); |
| } |
| |
| if (attributes == null) { |
| return null; |
| } |
| |
| Attribute attr; |
| AttributeSet unsupp = new HashAttributeSet(); |
| Attribute []attrs = attributes.toArray(); |
| for (int i=0; i<attrs.length; i++) { |
| try { |
| attr = attrs[i]; |
| if (!isAttributeCategorySupported(attr.getCategory())) { |
| unsupp.add(attr); |
| } else if (!isAttributeValueSupported(attr, flavor, |
| attributes)) { |
| unsupp.add(attr); |
| } |
| } catch (ClassCastException e) { |
| } |
| } |
| if (unsupp.isEmpty()) { |
| return null; |
| } else { |
| return unsupp; |
| } |
| } |
| |
| |
| public synchronized DocFlavor[] getSupportedDocFlavors() { |
| |
| if (supportedDocFlavors != null) { |
| int len = supportedDocFlavors.length; |
| DocFlavor[] copyflavors = new DocFlavor[len]; |
| System.arraycopy(supportedDocFlavors, 0, copyflavors, 0, len); |
| return copyflavors; |
| } |
| initAttributes(); |
| |
| if ((getAttMap != null) && |
| getAttMap.containsKey("document-format-supported")) { |
| |
| AttributeClass attribClass = |
| getAttMap.get("document-format-supported"); |
| if (attribClass != null) { |
| String mimeType; |
| boolean psSupported = false; |
| String[] docFlavors = attribClass.getArrayOfStringValues(); |
| DocFlavor[] flavors; |
| HashSet<Object> docList = new HashSet<>(); |
| int j; |
| String hostEnc = DocFlavor.hostEncoding. |
| toLowerCase(Locale.ENGLISH); |
| boolean addHostEncoding = !hostEnc.equals("utf-8") && |
| !hostEnc.equals("utf-16") && !hostEnc.equals("utf-16be") && |
| !hostEnc.equals("utf-16le") && !hostEnc.equals("us-ascii"); |
| |
| for (int i = 0; i < docFlavors.length; i++) { |
| for (j=0; j<allDocFlavors.length; j++) { |
| flavors = (DocFlavor[])allDocFlavors[j]; |
| |
| mimeType = flavors[0].getMimeType(); |
| if (mimeType.startsWith(docFlavors[i])) { |
| |
| docList.addAll(Arrays.asList(flavors)); |
| |
| if (mimeType.equals("text/plain") && |
| addHostEncoding) { |
| docList.add(Arrays.asList(textPlainHost)); |
| } else if (mimeType.equals("text/html") && |
| addHostEncoding) { |
| docList.add(Arrays.asList(textHtmlHost)); |
| } else if (mimeType.equals("image/png")) { |
| pngImagesAdded = true; |
| } else if (mimeType.equals("image/gif")) { |
| gifImagesAdded = true; |
| } else if (mimeType.equals("image/jpeg")) { |
| jpgImagesAdded = true; |
| } else if (mimeType.indexOf("postscript") != -1) { |
| psSupported = true; |
| } |
| break; |
| } |
| } |
| |
| // Not added? Create new DocFlavors |
| if (j == allDocFlavors.length) { |
| // make new DocFlavors |
| docList.add(new DocFlavor.BYTE_ARRAY(docFlavors[i])); |
| docList.add(new DocFlavor.INPUT_STREAM(docFlavors[i])); |
| docList.add(new DocFlavor.URL(docFlavors[i])); |
| } |
| } |
| |
| // check if we need to add image DocFlavors |
| // and Pageable/Printable flavors |
| if (psSupported || isCupsPrinter) { |
| /* |
| Always add Pageable and Printable for CUPS |
| since it uses Filters to convert from Postscript |
| to device printer language. |
| */ |
| docList.add(DocFlavor.SERVICE_FORMATTED.PAGEABLE); |
| docList.add(DocFlavor.SERVICE_FORMATTED.PRINTABLE); |
| |
| docList.addAll(Arrays.asList(imageJPG)); |
| docList.addAll(Arrays.asList(imagePNG)); |
| docList.addAll(Arrays.asList(imageGIF)); |
| } |
| supportedDocFlavors = new DocFlavor[docList.size()]; |
| docList.toArray(supportedDocFlavors); |
| int len = supportedDocFlavors.length; |
| DocFlavor[] copyflavors = new DocFlavor[len]; |
| System.arraycopy(supportedDocFlavors, 0, copyflavors, 0, len); |
| return copyflavors; |
| } |
| } |
| DocFlavor[] flavor = new DocFlavor[2]; |
| flavor[0] = DocFlavor.SERVICE_FORMATTED.PAGEABLE; |
| flavor[1] = DocFlavor.SERVICE_FORMATTED.PRINTABLE; |
| supportedDocFlavors = flavor; |
| return flavor; |
| } |
| |
| |
| public boolean isDocFlavorSupported(DocFlavor flavor) { |
| if (supportedDocFlavors == null) { |
| getSupportedDocFlavors(); |
| } |
| if (supportedDocFlavors != null) { |
| for (int f=0; f<supportedDocFlavors.length; f++) { |
| if (flavor.equals(supportedDocFlavors[f])) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| |
| /** |
| * Finds matching CustomMediaSizeName of given media. |
| */ |
| public CustomMediaSizeName findCustomMedia(MediaSizeName media) { |
| if (customMediaSizeNames == null) { |
| return null; |
| } |
| for (int i=0; i< customMediaSizeNames.length; i++) { |
| CustomMediaSizeName custom = customMediaSizeNames[i]; |
| MediaSizeName msn = custom.getStandardMedia(); |
| if (media.equals(msn)) { |
| return customMediaSizeNames[i]; |
| } |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Returns the matching standard Media using string comparison of names. |
| */ |
| private Media getIPPMedia(String mediaName) { |
| CustomMediaSizeName sampleSize = new CustomMediaSizeName("sample", "", |
| 0, 0); |
| Media[] sizes = sampleSize.getSuperEnumTable(); |
| for (int i=0; i<sizes.length; i++) { |
| if (mediaName.equals(""+sizes[i])) { |
| return sizes[i]; |
| } |
| } |
| CustomMediaTray sampleTray = new CustomMediaTray("sample", ""); |
| Media[] trays = sampleTray.getSuperEnumTable(); |
| for (int i=0; i<trays.length; i++) { |
| if (mediaName.equals(""+trays[i])) { |
| return trays[i]; |
| } |
| } |
| return null; |
| } |
| |
| private Media[] getSupportedMedia() { |
| if ((getAttMap != null) && |
| getAttMap.containsKey("media-supported")) { |
| |
| AttributeClass attribClass = getAttMap.get("media-supported"); |
| |
| if (attribClass != null) { |
| String[] mediaVals = attribClass.getArrayOfStringValues(); |
| Media msn; |
| Media[] mediaNames = |
| new Media[mediaVals.length]; |
| for (int i=0; i<mediaVals.length; i++) { |
| msn = getIPPMedia(mediaVals[i]); |
| //REMIND: if null, create custom? |
| mediaNames[i] = msn; |
| } |
| return mediaNames; |
| } |
| } |
| return new Media[0]; |
| } |
| |
| |
| public synchronized Class<?>[] getSupportedAttributeCategories() { |
| if (supportedCats != null) { |
| Class<?> [] copyCats = new Class<?>[supportedCats.length]; |
| System.arraycopy(supportedCats, 0, copyCats, 0, copyCats.length); |
| return copyCats; |
| } |
| |
| initAttributes(); |
| |
| ArrayList<Class<?>> catList = new ArrayList<>(); |
| |
| for (int i=0; i < printReqAttribDefault.length; i++) { |
| PrintRequestAttribute pra = |
| (PrintRequestAttribute)printReqAttribDefault[i]; |
| if (getAttMap != null && |
| getAttMap.containsKey(pra.getName()+"-supported")) { |
| catList.add(pra.getCategory()); |
| } |
| } |
| |
| // Some IPP printers like lexc710 do not have list of supported media |
| // but CUPS can get the media from PPD, so we still report as |
| // supported category. |
| if (isCupsPrinter) { |
| if (!catList.contains(Media.class)) { |
| catList.add(Media.class); |
| } |
| |
| // Always add MediaPrintable for cups, |
| // because we can get it from PPD. |
| catList.add(MediaPrintableArea.class); |
| |
| // this is already supported in UnixPrintJob |
| catList.add(Destination.class); |
| |
| // It is unfortunate that CUPS doesn't provide a way to query |
| // if printer supports collation but since most printers |
| // now supports collation and that most OS has a way |
| // of setting it, it is a safe assumption to just always |
| // include SheetCollate as supported attribute. |
| |
| catList.add(SheetCollate.class); |
| |
| } |
| |
| // With the assumption that Chromaticity is equivalent to |
| // ColorSupported. |
| if (getAttMap != null && getAttMap.containsKey("color-supported")) { |
| catList.add(Chromaticity.class); |
| } |
| |
| // CUPS does not report printer resolution via IPP but it |
| // may be gleaned from the PPD. |
| PrinterResolution[] supportedRes = getPrintResolutions(); |
| if (supportedRes != null && (supportedRes.length > 0)) { |
| catList.add(PrinterResolution.class); |
| } |
| |
| supportedCats = new Class<?>[catList.size()]; |
| catList.toArray(supportedCats); |
| Class<?>[] copyCats = new Class<?>[supportedCats.length]; |
| System.arraycopy(supportedCats, 0, copyCats, 0, copyCats.length); |
| return copyCats; |
| } |
| |
| |
| public boolean |
| isAttributeCategorySupported(Class<? extends Attribute> category) |
| { |
| if (category == null) { |
| throw new NullPointerException("null category"); |
| } |
| if (!(Attribute.class.isAssignableFrom(category))) { |
| throw new IllegalArgumentException(category + |
| " is not an Attribute"); |
| } |
| |
| if (supportedCats == null) { |
| getSupportedAttributeCategories(); |
| } |
| |
| // It is safe to assume that Orientation is always supported |
| // and even if CUPS or an IPP device reports it as not, |
| // our renderer can do portrait, landscape and |
| // reverse landscape. |
| if (category == OrientationRequested.class) { |
| return true; |
| } |
| |
| for (int i=0;i<supportedCats.length;i++) { |
| if (category == supportedCats[i]) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public synchronized <T extends PrintServiceAttribute> |
| T getAttribute(Class<T> category) |
| { |
| if (category == null) { |
| throw new NullPointerException("category"); |
| } |
| if (!(PrintServiceAttribute.class.isAssignableFrom(category))) { |
| throw new IllegalArgumentException("Not a PrintServiceAttribute"); |
| } |
| |
| initAttributes(); |
| |
| if (category == PrinterName.class) { |
| return (T)(new PrinterName(printer, null)); |
| } else if (category == PrinterInfo.class) { |
| PrinterInfo pInfo = new PrinterInfo(printer, null); |
| AttributeClass ac = (getAttMap != null) ? |
| getAttMap.get(pInfo.getName()) |
| : null; |
| if (ac != null) { |
| return (T)(new PrinterInfo(ac.getStringValue(), null)); |
| } |
| return (T)pInfo; |
| } else if (category == QueuedJobCount.class) { |
| QueuedJobCount qjc = new QueuedJobCount(0); |
| AttributeClass ac = (getAttMap != null) ? |
| getAttMap.get(qjc.getName()) |
| : null; |
| if (ac != null) { |
| qjc = new QueuedJobCount(ac.getIntValue()); |
| } |
| return (T)qjc; |
| } else if (category == PrinterIsAcceptingJobs.class) { |
| PrinterIsAcceptingJobs accJob = |
| PrinterIsAcceptingJobs.ACCEPTING_JOBS; |
| AttributeClass ac = (getAttMap != null) ? |
| getAttMap.get(accJob.getName()) |
| : null; |
| if ((ac != null) && (ac.getByteValue() == 0)) { |
| accJob = PrinterIsAcceptingJobs.NOT_ACCEPTING_JOBS; |
| } |
| return (T)accJob; |
| } else if (category == ColorSupported.class) { |
| ColorSupported cs = ColorSupported.SUPPORTED; |
| AttributeClass ac = (getAttMap != null) ? |
| getAttMap.get(cs.getName()) |
| : null; |
| if ((ac != null) && (ac.getByteValue() == 0)) { |
| cs = ColorSupported.NOT_SUPPORTED; |
| } |
| return (T)cs; |
| } else if (category == PDLOverrideSupported.class) { |
| |
| if (isCupsPrinter) { |
| // Documented: For CUPS this will always be false |
| return (T)PDLOverrideSupported.NOT_ATTEMPTED; |
| } else { |
| // REMIND: check attribute values |
| return (T)PDLOverrideSupported.NOT_ATTEMPTED; |
| } |
| } else if (category == PrinterURI.class) { |
| return (T)(new PrinterURI(myURI)); |
| } else { |
| return null; |
| } |
| } |
| |
| |
| public synchronized PrintServiceAttributeSet getAttributes() { |
| // update getAttMap by sending again get-attributes IPP request |
| init = false; |
| initAttributes(); |
| |
| HashPrintServiceAttributeSet attrs = |
| new HashPrintServiceAttributeSet(); |
| |
| for (int i=0; i < serviceAttributes.length; i++) { |
| String name = (String)serviceAttributes[i][1]; |
| if (getAttMap != null && getAttMap.containsKey(name)) { |
| @SuppressWarnings("unchecked") |
| Class<PrintServiceAttribute> c = (Class<PrintServiceAttribute>)serviceAttributes[i][0]; |
| PrintServiceAttribute psa = getAttribute(c); |
| if (psa != null) { |
| attrs.add(psa); |
| } |
| } |
| } |
| return AttributeSetUtilities.unmodifiableView(attrs); |
| } |
| |
| public boolean isIPPSupportedImages(String mimeType) { |
| if (supportedDocFlavors == null) { |
| getSupportedDocFlavors(); |
| } |
| |
| if (mimeType.equals("image/png") && pngImagesAdded) { |
| return true; |
| } else if (mimeType.equals("image/gif") && gifImagesAdded) { |
| return true; |
| } else if (mimeType.equals("image/jpeg") && jpgImagesAdded) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| |
| private boolean isSupportedCopies(Copies copies) { |
| CopiesSupported cs = (CopiesSupported) |
| getSupportedAttributeValues(Copies.class, null, null); |
| int[][] members = cs.getMembers(); |
| int min, max; |
| if ((members.length > 0) && (members[0].length > 0)) { |
| min = members[0][0]; |
| max = members[0][1]; |
| } else { |
| min = 1; |
| max = MAXCOPIES; |
| } |
| |
| int value = copies.getValue(); |
| return (value >= min && value <= max); |
| } |
| |
| private boolean isAutoSense(DocFlavor flavor) { |
| if (flavor.equals(DocFlavor.BYTE_ARRAY.AUTOSENSE) || |
| flavor.equals(DocFlavor.INPUT_STREAM.AUTOSENSE) || |
| flavor.equals(DocFlavor.URL.AUTOSENSE)) { |
| return true; |
| } |
| else { |
| return false; |
| } |
| } |
| |
| private synchronized boolean isSupportedMediaTray(MediaTray msn) { |
| initAttributes(); |
| |
| if (mediaTrays != null) { |
| for (int i=0; i<mediaTrays.length; i++) { |
| if (msn.equals(mediaTrays[i])) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private synchronized boolean isSupportedMedia(MediaSizeName msn) { |
| initAttributes(); |
| |
| if (msn.equals((Media)getDefaultAttributeValue(Media.class))) { |
| return true; |
| } |
| for (int i=0; i<mediaSizeNames.length; i++) { |
| debug_println(debugPrefix+"isSupportedMedia, mediaSizeNames[i] "+mediaSizeNames[i]); |
| if (msn.equals(mediaSizeNames[i])) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /* Return false if flavor is not null, pageable, nor printable and |
| * Destination is part of attributes. |
| */ |
| private boolean |
| isDestinationSupported(DocFlavor flavor, AttributeSet attributes) { |
| |
| if ((attributes != null) && |
| (attributes.get(Destination.class) != null) && |
| !(flavor == null || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE))) { |
| return false; |
| } |
| return true; |
| } |
| |
| |
| public boolean isAttributeValueSupported(Attribute attr, |
| DocFlavor flavor, |
| AttributeSet attributes) { |
| if (attr == null) { |
| throw new NullPointerException("null attribute"); |
| } |
| if (flavor != null) { |
| if (!isDocFlavorSupported(flavor)) { |
| throw new IllegalArgumentException(flavor + |
| " is an unsupported flavor"); |
| } else if (isAutoSense(flavor)) { |
| return false; |
| } |
| } |
| Class<? extends Attribute> category = attr.getCategory(); |
| if (!isAttributeCategorySupported(category)) { |
| return false; |
| } |
| |
| /* Test if the flavor is compatible with the attributes */ |
| if (!isDestinationSupported(flavor, attributes)) { |
| return false; |
| } |
| |
| /* Test if the flavor is compatible with the category */ |
| if (attr.getCategory() == Chromaticity.class) { |
| if ((flavor == null) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE) || |
| !isIPPSupportedImages(flavor.getMimeType())) { |
| return attr == Chromaticity.COLOR; |
| } else { |
| return false; |
| } |
| } else if (attr.getCategory() == Copies.class) { |
| return (flavor == null || |
| !(flavor.equals(DocFlavor.INPUT_STREAM.POSTSCRIPT) || |
| flavor.equals(DocFlavor.URL.POSTSCRIPT) || |
| flavor.equals(DocFlavor.BYTE_ARRAY.POSTSCRIPT))) && |
| isSupportedCopies((Copies)attr); |
| |
| } else if (attr.getCategory() == Destination.class) { |
| if (flavor == null || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE)) { |
| URI uri = ((Destination)attr).getURI(); |
| if ("file".equals(uri.getScheme()) && |
| !(uri.getSchemeSpecificPart().equals(""))) { |
| return true; |
| } |
| } |
| return false; |
| } else if (attr.getCategory() == Media.class) { |
| if (attr instanceof MediaSizeName) { |
| return isSupportedMedia((MediaSizeName)attr); |
| } |
| if (attr instanceof MediaTray) { |
| return isSupportedMediaTray((MediaTray)attr); |
| } |
| } else if (attr.getCategory() == PageRanges.class) { |
| if (flavor != null && |
| !(flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE))) { |
| return false; |
| } |
| } else if (attr.getCategory() == SheetCollate.class) { |
| if (flavor != null && |
| !(flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) || |
| flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE))) { |
| return false; |
| } |
| } else if (attr.getCategory() == Sides.class) { |
| Sides[] sidesArray = (Sides[])getSupportedAttributeValues( |
| Sides.class, |
| flavor, |
| attributes); |
| |
| if (sidesArray != null) { |
| for (int i=0; i<sidesArray.length; i++) { |
| if (sidesArray[i] == (Sides)attr) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } else if (attr.getCategory() == OrientationRequested.class) { |
| OrientationRequested[] orientArray = |
| (OrientationRequested[])getSupportedAttributeValues( |
| OrientationRequested.class, |
| flavor, |
| attributes); |
| |
| if (orientArray != null) { |
| for (int i=0; i<orientArray.length; i++) { |
| if (orientArray[i] == (OrientationRequested)attr) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } if (attr.getCategory() == PrinterResolution.class) { |
| if (attr instanceof PrinterResolution) { |
| return isSupportedResolution((PrinterResolution)attr); |
| } |
| } |
| return true; |
| } |
| |
| |
| public synchronized Object |
| getDefaultAttributeValue(Class<? extends Attribute> category) |
| { |
| if (category == null) { |
| throw new NullPointerException("null category"); |
| } |
| if (!Attribute.class.isAssignableFrom(category)) { |
| throw new IllegalArgumentException(category + |
| " is not an Attribute"); |
| } |
| if (!isAttributeCategorySupported(category)) { |
| return null; |
| } |
| |
| initAttributes(); |
| |
| String catName = null; |
| for (int i=0; i < printReqAttribDefault.length; i++) { |
| PrintRequestAttribute pra = |
| (PrintRequestAttribute)printReqAttribDefault[i]; |
| if (pra.getCategory() == category) { |
| catName = pra.getName(); |
| break; |
| } |
| } |
| String attribName = catName+"-default"; |
| AttributeClass attribClass = (getAttMap != null) ? |
| getAttMap.get(attribName) : null; |
| |
| if (category == Copies.class) { |
| if (attribClass != null) { |
| return new Copies(attribClass.getIntValue()); |
| } else { |
| return new Copies(1); |
| } |
| } else if (category == Chromaticity.class) { |
| return Chromaticity.COLOR; |
| } else if (category == Destination.class) { |
| try { |
| return new Destination((new File("out.ps")).toURI()); |
| } catch (SecurityException se) { |
| try { |
| return new Destination(new URI("file:out.ps")); |
| } catch (URISyntaxException e) { |
| return null; |
| } |
| } |
| } else if (category == Fidelity.class) { |
| return Fidelity.FIDELITY_FALSE; |
| } else if (category == Finishings.class) { |
| return Finishings.NONE; |
| } else if (category == JobName.class) { |
| return new JobName("Java Printing", null); |
| } else if (category == JobSheets.class) { |
| if (attribClass != null && |
| attribClass.getStringValue().equals("none")) { |
| return JobSheets.NONE; |
| } else { |
| return JobSheets.STANDARD; |
| } |
| } else if (category == Media.class) { |
| if (defaultMediaIndex == -1) { |
| defaultMediaIndex = 0; |
| } |
| if (mediaSizeNames.length == 0) { |
| String defaultCountry = Locale.getDefault().getCountry(); |
| if (defaultCountry != null && |
| (defaultCountry.equals("") || |
| defaultCountry.equals(Locale.US.getCountry()) || |
| defaultCountry.equals(Locale.CANADA.getCountry()))) { |
| return MediaSizeName.NA_LETTER; |
| } else { |
| return MediaSizeName.ISO_A4; |
| } |
| } |
| |
| if (attribClass != null) { |
| String name = attribClass.getStringValue(); |
| if (isCupsPrinter) { |
| return mediaSizeNames[defaultMediaIndex]; |
| } else { |
| for (int i=0; i< mediaSizeNames.length; i++) { |
| if (mediaSizeNames[i].toString().indexOf(name) != -1) { |
| defaultMediaIndex = i; |
| return mediaSizeNames[defaultMediaIndex]; |
| } |
| } |
| } |
| } |
| return mediaSizeNames[defaultMediaIndex]; |
| |
| } else if (category == MediaPrintableArea.class) { |
| MediaPrintableArea[] mpas; |
| if ((cps != null) && |
| ((mpas = cps.getMediaPrintableArea()) != null)) { |
| if (defaultMediaIndex == -1) { |
| // initializes value of defaultMediaIndex |
| getDefaultAttributeValue(Media.class); |
| } |
| return mpas[defaultMediaIndex]; |
| } else { |
| String defaultCountry = Locale.getDefault().getCountry(); |
| float iw, ih; |
| if (defaultCountry != null && |
| (defaultCountry.equals("") || |
| defaultCountry.equals(Locale.US.getCountry()) || |
| defaultCountry.equals(Locale.CANADA.getCountry()))) { |
| iw = MediaSize.NA.LETTER.getX(Size2DSyntax.INCH) - 0.5f; |
| ih = MediaSize.NA.LETTER.getY(Size2DSyntax.INCH) - 0.5f; |
| } else { |
| iw = MediaSize.ISO.A4.getX(Size2DSyntax.INCH) - 0.5f; |
| ih = MediaSize.ISO.A4.getY(Size2DSyntax.INCH) - 0.5f; |
| } |
| return new MediaPrintableArea(0.25f, 0.25f, iw, ih, |
| MediaPrintableArea.INCH); |
| } |
| } else if (category == NumberUp.class) { |
| return new NumberUp(1); // for CUPS this is always 1 |
| } else if (category == OrientationRequested.class) { |
| if (attribClass != null) { |
| switch (attribClass.getIntValue()) { |
| default: |
| case 3: return OrientationRequested.PORTRAIT; |
| case 4: return OrientationRequested.LANDSCAPE; |
| case 5: return OrientationRequested.REVERSE_LANDSCAPE; |
| case 6: return OrientationRequested.REVERSE_PORTRAIT; |
| } |
| } else { |
| return OrientationRequested.PORTRAIT; |
| } |
| } else if (category == PageRanges.class) { |
| if (attribClass != null) { |
| int[] range = attribClass.getIntRangeValue(); |
| return new PageRanges(range[0], range[1]); |
| } else { |
| return new PageRanges(1, Integer.MAX_VALUE); |
| } |
| } else if (category == RequestingUserName.class) { |
| String userName = ""; |
| try { |
| userName = System.getProperty("user.name", ""); |
| } catch (SecurityException se) { |
| } |
| return new RequestingUserName(userName, null); |
| } else if (category == SheetCollate.class) { |
| return SheetCollate.UNCOLLATED; |
| } else if (category == Sides.class) { |
| if (attribClass != null) { |
| if (attribClass.getStringValue().endsWith("long-edge")) { |
| return Sides.TWO_SIDED_LONG_EDGE; |
| } else if (attribClass.getStringValue().endsWith( |
| "short-edge")) { |
| return Sides.TWO_SIDED_SHORT_EDGE; |
| } |
| } |
| return Sides.ONE_SIDED; |
| } else if (category == PrinterResolution.class) { |
| PrinterResolution[] supportedRes = getPrintResolutions(); |
| if ((supportedRes != null) && (supportedRes.length > 0)) { |
| return supportedRes[0]; |
| } else { |
| return new PrinterResolution(300, 300, PrinterResolution.DPI); |
| } |
| } |
| |
| return null; |
| } |
| |
| private PrinterResolution[] getPrintResolutions() { |
| if (printerResolutions == null) { |
| if (rawResolutions == null) { |
| printerResolutions = new PrinterResolution[0]; |
| } else { |
| int numRes = rawResolutions.length / 2; |
| PrinterResolution[] pres = new PrinterResolution[numRes]; |
| for (int i=0; i < numRes; i++) { |
| pres[i] = new PrinterResolution(rawResolutions[i*2], |
| rawResolutions[i*2+1], |
| PrinterResolution.DPI); |
| } |
| printerResolutions = pres; |
| } |
| } |
| return printerResolutions; |
| } |
| |
| private boolean isSupportedResolution(PrinterResolution res) { |
| PrinterResolution[] supportedRes = getPrintResolutions(); |
| if (supportedRes != null) { |
| for (int i=0; i<supportedRes.length; i++) { |
| if (res.equals(supportedRes[i])) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| public ServiceUIFactory getServiceUIFactory() { |
| return null; |
| } |
| |
| public void wakeNotifier() { |
| synchronized (this) { |
| if (notifier != null) { |
| notifier.wake(); |
| } |
| } |
| } |
| |
| public void addPrintServiceAttributeListener( |
| PrintServiceAttributeListener listener) { |
| synchronized (this) { |
| if (listener == null) { |
| return; |
| } |
| if (notifier == null) { |
| notifier = new ServiceNotifier(this); |
| } |
| notifier.addListener(listener); |
| } |
| } |
| |
| public void removePrintServiceAttributeListener( |
| PrintServiceAttributeListener listener) { |
| synchronized (this) { |
| if (listener == null || notifier == null ) { |
| return; |
| } |
| notifier.removeListener(listener); |
| if (notifier.isEmpty()) { |
| notifier.stopNotifier(); |
| notifier = null; |
| } |
| } |
| } |
| |
| String getDest() { |
| return printer; |
| } |
| |
| public String getName() { |
| /* |
| * Mac is using printer-info IPP attribute for its human-readable printer |
| * name and is also the identifier used in NSPrintInfo:setPrinter. |
| */ |
| if (PrintServiceLookupProvider.isMac()) { |
| PrintServiceAttributeSet psaSet = this.getAttributes(); |
| if (psaSet != null) { |
| PrinterInfo pName = (PrinterInfo)psaSet.get(PrinterInfo.class); |
| if (pName != null) { |
| return pName.toString(); |
| } |
| } |
| } |
| return printer; |
| } |
| |
| |
| public boolean usesClass(Class<?> c) { |
| return (c == sun.print.PSPrinterJob.class); |
| } |
| |
| |
| public static HttpURLConnection getIPPConnection(URL url) { |
| HttpURLConnection connection; |
| URLConnection urlc; |
| try { |
| urlc = url.openConnection(); |
| } catch (java.io.IOException ioe) { |
| return null; |
| } |
| if (!(urlc instanceof HttpURLConnection)) { |
| return null; |
| } |
| connection = (HttpURLConnection)urlc; |
| connection.setUseCaches(false); |
| connection.setDoInput(true); |
| connection.setDoOutput(true); |
| connection.setRequestProperty("Content-type", "application/ipp"); |
| return connection; |
| } |
| |
| |
| public synchronized boolean isPostscript() { |
| if (isPS == null) { |
| isPS = Boolean.TRUE; |
| if (isCupsPrinter) { |
| try { |
| urlConnection = getIPPConnection( |
| new URL(myURL+".ppd")); |
| |
| InputStream is = urlConnection.getInputStream(); |
| if (is != null) { |
| BufferedReader d = |
| new BufferedReader(new InputStreamReader(is, |
| Charset.forName("ISO-8859-1"))); |
| String lineStr; |
| while ((lineStr = d.readLine()) != null) { |
| if (lineStr.startsWith("*cupsFilter:")) { |
| isPS = Boolean.FALSE; |
| break; |
| } |
| } |
| } |
| } catch (java.io.IOException e) { |
| debug_println(" isPostscript, e= "+e); |
| /* if PPD is not found, this may be a raw printer |
| and in this case it is assumed that it is a |
| Postscript printer */ |
| // do nothing |
| } |
| } |
| } |
| return isPS.booleanValue(); |
| } |
| |
| |
| private void opGetAttributes() { |
| try { |
| debug_println(debugPrefix+"opGetAttributes myURI "+myURI+" myURL "+myURL); |
| |
| AttributeClass attClNoUri[] = { |
| AttributeClass.ATTRIBUTES_CHARSET, |
| AttributeClass.ATTRIBUTES_NATURAL_LANGUAGE}; |
| |
| AttributeClass attCl[] = { |
| AttributeClass.ATTRIBUTES_CHARSET, |
| AttributeClass.ATTRIBUTES_NATURAL_LANGUAGE, |
| new AttributeClass("printer-uri", |
| AttributeClass.TAG_URI, |
| ""+myURI)}; |
| |
| OutputStream os = java.security.AccessController. |
| doPrivileged(new java.security.PrivilegedAction<OutputStream>() { |
| public OutputStream run() { |
| try { |
| return urlConnection.getOutputStream(); |
| } catch (Exception e) { |
| } |
| return null; |
| } |
| }); |
| |
| if (os == null) { |
| return; |
| } |
| |
| boolean success = (myURI == null) ? |
| writeIPPRequest(os, OP_GET_ATTRIBUTES, attClNoUri) : |
| writeIPPRequest(os, OP_GET_ATTRIBUTES, attCl); |
| if (success) { |
| InputStream is = null; |
| if ((is = urlConnection.getInputStream())!=null) { |
| HashMap<String, AttributeClass>[] responseMap = readIPPResponse(is); |
| |
| if (responseMap != null && responseMap.length > 0) { |
| getAttMap = responseMap[0]; |
| // If there is extra hashmap created due to duplicate |
| // key/attribute present in IPPresponse, then use that |
| // map too by appending to getAttMap after removing the |
| // duplicate key/value |
| if (responseMap.length > 1) { |
| for (int i = 1; i < responseMap.length; i++) { |
| for (Map.Entry<String, AttributeClass> entry : responseMap[i].entrySet()) { |
| if (!getAttMap.containsKey(entry.getValue())) { |
| getAttMap.put(entry.getKey(), entry.getValue()); |
| } |
| } |
| } |
| } |
| } |
| } else { |
| debug_println(debugPrefix+"opGetAttributes - null input stream"); |
| } |
| is.close(); |
| } |
| os.close(); |
| } catch (java.io.IOException e) { |
| debug_println(debugPrefix+"opGetAttributes - input/output stream: "+e); |
| } |
| } |
| |
| |
| public static boolean writeIPPRequest(OutputStream os, |
| String operCode, |
| AttributeClass[] attCl) { |
| OutputStreamWriter osw; |
| try { |
| osw = new OutputStreamWriter(os, "UTF-8"); |
| } catch (java.io.UnsupportedEncodingException exc) { |
| debug_println(debugPrefix+"writeIPPRequest, UTF-8 not supported? Exception: "+exc); |
| return false; |
| } |
| debug_println(debugPrefix+"writeIPPRequest, op code= "+operCode); |
| char[] opCode = new char[2]; |
| opCode[0] = (char)Byte.parseByte(operCode.substring(0,2), 16); |
| opCode[1] = (char)Byte.parseByte(operCode.substring(2,4), 16); |
| char[] bytes = {0x01, 0x01, 0x00, 0x01}; |
| try { |
| osw.write(bytes, 0, 2); // version number |
| osw.write(opCode, 0, 2); // operation code |
| bytes[0] = 0x00; bytes[1] = 0x00; |
| osw.write(bytes, 0, 4); // request ID #1 |
| |
| bytes[0] = 0x01; // operation-group-tag |
| osw.write(bytes[0]); |
| |
| String valStr; |
| char[] lenStr; |
| |
| AttributeClass ac; |
| for (int i=0; i < attCl.length; i++) { |
| ac = attCl[i]; |
| osw.write(ac.getType()); // value tag |
| |
| lenStr = ac.getLenChars(); |
| osw.write(lenStr, 0, 2); // length |
| osw.write(""+ac, 0, ac.getName().length()); |
| |
| // check if string range (0x35 -> 0x49) |
| if (ac.getType() >= AttributeClass.TAG_TEXT_LANGUAGE && |
| ac.getType() <= AttributeClass.TAG_MIME_MEDIATYPE){ |
| valStr = (String)ac.getObjectValue(); |
| bytes[0] = 0; bytes[1] = (char)valStr.length(); |
| osw.write(bytes, 0, 2); |
| osw.write(valStr, 0, valStr.length()); |
| } // REMIND: need to support other value tags but for CUPS |
| // string is all we need. |
| } |
| |
| osw.write(GRPTAG_END_ATTRIBUTES); |
| osw.flush(); |
| osw.close(); |
| } catch (java.io.IOException ioe) { |
| debug_println(debugPrefix+"writeIPPRequest, IPPPrintService Exception in writeIPPRequest: "+ioe); |
| return false; |
| } |
| return true; |
| } |
| |
| |
| public static HashMap<String, AttributeClass>[] readIPPResponse(InputStream inputStream) { |
| |
| if (inputStream == null) { |
| return null; |
| } |
| |
| byte response[] = new byte[MAX_ATTRIBUTE_LENGTH]; |
| try { |
| |
| DataInputStream ois = new DataInputStream(inputStream); |
| |
| // read status and ID |
| if ((ois.read(response, 0, 8) > -1) && |
| (response[2] == STATUSCODE_SUCCESS)) { |
| |
| ByteArrayOutputStream outObj; |
| int counter=0; |
| short len = 0; |
| String attribStr = null; |
| // assign default value |
| byte valTagByte = AttributeClass.TAG_KEYWORD; |
| ArrayList<HashMap<String, AttributeClass>> respList = new ArrayList<>(); |
| HashMap<String, AttributeClass> responseMap = new HashMap<>(); |
| |
| response[0] = ois.readByte(); |
| |
| // check for group tags |
| while ((response[0] >= GRPTAG_OP_ATTRIBUTES) && |
| (response[0] <= GRPTAG_PRINTER_ATTRIBUTES) |
| && (response[0] != GRPTAG_END_ATTRIBUTES)) { |
| debug_println(debugPrefix+"readIPPResponse, checking group tag, response[0]= "+ |
| response[0]); |
| |
| outObj = new ByteArrayOutputStream(); |
| //make sure counter and attribStr are re-initialized |
| counter = 0; |
| attribStr = null; |
| |
| // read value tag |
| response[0] = ois.readByte(); |
| while (response[0] >= AttributeClass.TAG_UNSUPPORTED_VALUE && |
| response[0] <= AttributeClass.TAG_MEMBER_ATTRNAME) { |
| // read name length |
| len = ois.readShort(); |
| |
| // If current value is not part of previous attribute |
| // then close stream and add it to HashMap. |
| // It is part of previous attribute if name length=0. |
| if ((len != 0) && (attribStr != null)) { |
| //last byte is the total # of values |
| outObj.write(counter); |
| outObj.flush(); |
| outObj.close(); |
| byte outArray[] = outObj.toByteArray(); |
| |
| // if key exists, new HashMap |
| if (responseMap.containsKey(attribStr)) { |
| respList.add(responseMap); |
| responseMap = new HashMap<>(); |
| } |
| |
| // exclude those that are unknown |
| if (valTagByte >= AttributeClass.TAG_INT) { |
| AttributeClass ac = |
| new AttributeClass(attribStr, |
| valTagByte, |
| outArray); |
| |
| responseMap.put(ac.getName(), ac); |
| debug_println(debugPrefix+ "readIPPResponse "+ac); |
| } |
| |
| outObj = new ByteArrayOutputStream(); |
| counter = 0; //reset counter |
| } |
| //check if this is new value tag |
| if (counter == 0) { |
| valTagByte = response[0]; |
| } |
| // read attribute name |
| if (len != 0) { |
| // read "len" characters |
| // make sure it doesn't exceed the maximum |
| if (len > MAX_ATTRIBUTE_LENGTH) { |
| response = new byte[len]; // expand as needed |
| } |
| ois.read(response, 0, len); |
| attribStr = new String(response, 0, len); |
| } |
| // read value length |
| len = ois.readShort(); |
| // write name length |
| outObj.write(len); |
| // read value, make sure it doesn't exceed the maximum |
| if (len > MAX_ATTRIBUTE_LENGTH) { |
| response = new byte[len]; // expand as needed |
| } |
| ois.read(response, 0, len); |
| // write value of "len" length |
| outObj.write(response, 0, len); |
| counter++; |
| // read next byte |
| response[0] = ois.readByte(); |
| } |
| |
| if (attribStr != null) { |
| outObj.write(counter); |
| outObj.flush(); |
| outObj.close(); |
| |
| // if key exists in old HashMap, new HashMap |
| if ((counter != 0) && |
| responseMap.containsKey(attribStr)) { |
| respList.add(responseMap); |
| responseMap = new HashMap<>(); |
| } |
| |
| byte outArray[] = outObj.toByteArray(); |
| |
| AttributeClass ac = |
| new AttributeClass(attribStr, |
| valTagByte, |
| outArray); |
| responseMap.put(ac.getName(), ac); |
| } |
| } |
| ois.close(); |
| if ((responseMap != null) && (responseMap.size() > 0)) { |
| respList.add(responseMap); |
| } |
| @SuppressWarnings({"unchecked", "rawtypes"}) |
| HashMap<String, AttributeClass>[] tmp = |
| respList.toArray((HashMap<String, AttributeClass>[])new HashMap[respList.size()]); |
| return tmp; |
| } else { |
| debug_println(debugPrefix+ |
| "readIPPResponse client error, IPP status code: 0x"+ |
| toHex(response[2]) + toHex(response[3])); |
| return null; |
| } |
| |
| } catch (java.io.IOException e) { |
| debug_println(debugPrefix+"readIPPResponse: "+e); |
| if (debugPrint) { |
| e.printStackTrace(); |
| } |
| return null; |
| } |
| } |
| |
| private static String toHex(byte v) { |
| String s = Integer.toHexString(v&0xff); |
| return (s.length() == 2) ? s : "0"+s; |
| } |
| |
| public String toString() { |
| return "IPP Printer : " + getName(); |
| } |
| |
| public boolean equals(Object obj) { |
| return (obj == this || |
| (obj instanceof IPPPrintService && |
| ((IPPPrintService)obj).getName().equals(getName()))); |
| } |
| |
| public int hashCode() { |
| return this.getClass().hashCode()+getName().hashCode(); |
| } |
| } |
