src.com.android.printspooler.util.PageRangeUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.printspooler.util;
import android.print.PageRange;
import android.print.PrintDocumentInfo;
import android.util.Pair;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
/**
* This class contains utility functions for working with page ranges.
*/
public final class PageRangeUtils {
private static final PageRange[] ALL_PAGES_RANGE = new PageRange[] {PageRange.ALL_PAGES};
private static final Comparator sComparator = new Comparator() {
@Override
public int compare(PageRange lhs, PageRange rhs) {
return lhs.getStart() - rhs.getStart();
}
};
private PageRangeUtils() {
/* do nothing - hide constructor */
}
/**
* Gets whether page ranges contains a given page.
*
* @param pageRanges The page ranges.
* @param pageIndex The page for which to check.
* @return Whether the page is within the ranges.
*/
public static boolean contains(PageRange[] pageRanges, int pageIndex) {
final int rangeCount = pageRanges.length;
for (int i = 0; i < rangeCount; i++) {
PageRange pageRange = pageRanges[i];
if (pageRange.contains(pageIndex)) {
return true;
}
}
return false;
}
/**
* Checks whether one page range array contains another one.
*
* @param ourRanges The container page ranges.
* @param otherRanges The contained page ranges.
* @param pageCount The total number of pages.
* @return Whether the container page ranges contains the contained ones.
*/
public static boolean contains(PageRange[] ourRanges, PageRange[] otherRanges, int pageCount) {
if (ourRanges == null || otherRanges == null) {
return false;
}
if (Arrays.equals(ourRanges, ALL_PAGES_RANGE)) {
return true;
}
if (Arrays.equals(otherRanges, ALL_PAGES_RANGE)) {
otherRanges[0] = new PageRange(0, pageCount - 1);
}
ourRanges = normalize(ourRanges);
otherRanges = normalize(otherRanges);
// Note that the code below relies on the ranges being normalized
// which is they contain monotonically increasing non-intersecting
// sub-ranges whose start is less that or equal to the end.
int otherRangeIdx = 0;
final int ourRangeCount = ourRanges.length;
final int otherRangeCount = otherRanges.length;
for (int ourRangeIdx = 0; ourRangeIdx < ourRangeCount; ourRangeIdx++) {
PageRange ourRange = ourRanges[ourRangeIdx];
for (; otherRangeIdx < otherRangeCount; otherRangeIdx++) {
PageRange otherRange = otherRanges[otherRangeIdx];
if (otherRange.getStart() > ourRange.getEnd()) {
break;
}
if (otherRange.getStart() < ourRange.getStart()
|| otherRange.getEnd() > ourRange.getEnd()) {
return false;
}
}
}
return (otherRangeIdx >= otherRangeCount);
}
/**
* Normalizes a page range, which is the resulting page ranges are
* non-overlapping with the start lesser than or equal to the end
* and ordered in an ascending order.
*
* @param pageRanges The page ranges to normalize.
* @return The normalized page ranges.
*/
public static PageRange[] normalize(PageRange[] pageRanges) {
if (pageRanges == null) {
return null;
}
final int oldRangeCount = pageRanges.length;
if (oldRangeCount <= 1) {
return pageRanges;
}
Arrays.sort(pageRanges, sComparator);
int newRangeCount = 1;
for (int i = 0; i < oldRangeCount - 1; i++) {
PageRange currentRange = pageRanges[i];
PageRange nextRange = pageRanges[i + 1];
if (currentRange.getEnd() + 1 >= nextRange.getStart()) {
pageRanges[i] = null;
pageRanges[i + 1] = new PageRange(currentRange.getStart(),
Math.max(currentRange.getEnd(), nextRange.getEnd()));
} else {
newRangeCount++;
}
}
if (newRangeCount == oldRangeCount) {
return pageRanges;
}
int normalRangeIndex = 0;
PageRange[] normalRanges = new PageRange[newRangeCount];
for (int i = 0; i < oldRangeCount; i++) {
PageRange normalRange = pageRanges[i];
if (normalRange != null) {
normalRanges[normalRangeIndex] = normalRange;
normalRangeIndex++;
}
}
return normalRanges;
}
/**
* Return the next position after {@code pos} that is not a space character.
*
* @param s The string to parse
* @param pos The starting position
*
* @return The position of the first space character
*/
private static int readWhiteSpace(CharSequence s, int pos) {
while (pos < s.length() && s.charAt(pos) == ' ') {
pos++;
}
return pos;
}
/**
* Read a number from a string at a certain position.
*
* @param s The string to parse
* @param pos The starting position
*
* @return The position after the number + the number read or null if the number was not found
*/
private static Pair readNumber(CharSequence s, int pos) {
Integer result = 0;
while (pos < s.length() && s.charAt(pos) >= '0' && s.charAt(pos) <= '9') {
// Number cannot start with 0
if (result == 0 && s.charAt(pos) == '0') {
break;
}
result = result * 10 + (s.charAt(pos) - '0');
// Abort on overflow
if (result < 0) {
break;
}
pos++;
}
// 0 is not a valid page number
if (result == 0) {
return new Pair<>(pos, null);
} else {
return new Pair<>(pos, result);
}
}
/**
* Read a single character from a string at a certain position.
*
* @param s The string to parse
* @param pos The starting position
* @param expectedChar The character to read
*
* @return The position after the character + the character read or null if the character was
* not found
*/
private static Pair readChar(CharSequence s, int pos, char expectedChar) {
if (pos < s.length() && s.charAt(pos) == expectedChar) {
return new Pair<>(pos + 1, expectedChar);
} else {
return new Pair<>(pos, null);
}
}
/**
* Read a page range character from a string at a certain position.
*
* @param s The string to parse
* @param pos The starting position
* @param maxPageNumber The highest page number to accept.
*
* @return The position after the page range + the page range read or null if the page range was
* not found
*/
private static Pair readRange(CharSequence s, int pos, int maxPageNumber) {
Pair retInt;
Pair retChar;
Character comma;
if (pos == 0) {
// When we reading the first range, we do not want to have a comma
comma = ',';
} else {
retChar = readChar(s, pos, ',');
pos = retChar.first;
comma = retChar.second;
}
pos = readWhiteSpace(s, pos);
retInt = readNumber(s, pos);
pos = retInt.first;
Integer start = retInt.second;
pos = readWhiteSpace(s, pos);
retChar = readChar(s, pos, '-');
pos = retChar.first;
Character separator = retChar.second;
pos = readWhiteSpace(s, pos);
retInt = readNumber(s, pos);
pos = retInt.first;
Integer end = retInt.second;
pos = readWhiteSpace(s, pos);
if (comma != null &&
// range, maybe unbounded
((separator != null && (start != null || end != null)) ||
// single page
(separator == null && start != null && end == null))) {
if (start == null) {
start = 1;
}
if (end == null) {
if (separator == null) {
end = start;
} else {
end = maxPageNumber;
}
}
if (start <= end && start >= 1 && end <= maxPageNumber) {
return new Pair<>(pos, new PageRange(start - 1, end - 1));
}
}
return new Pair<>(pos, null);
}
/**
* Parse a string into an array of page ranges.
*
* @param s The string to parse
* @param maxPageNumber The highest page number to accept.
*
* @return The parsed ranges or null if the string could not be parsed.
*/
public static PageRange[] parsePageRanges(CharSequence s, int maxPageNumber) {
ArrayList ranges = new ArrayList<>();
int pos = 0;
while (pos < s.length()) {
Pair retRange = readRange(s, pos, maxPageNumber);
if (retRange.second == null) {
ranges.clear();
break;
}
ranges.add(retRange.second);
pos = retRange.first;
}
return PageRangeUtils.normalize(ranges.toArray(new PageRange[ranges.size()]));
}
/**
* Offsets a the start and end of page ranges with the given value.
*
* @param pageRanges The page ranges to offset.
* @param offset The offset value.
*/
public static void offset(PageRange[] pageRanges, int offset) {
if (offset == 0) {
return;
}
final int pageRangeCount = pageRanges.length;
for (int i = 0; i < pageRangeCount; i++) {
final int start = pageRanges[i].getStart() + offset;
final int end = pageRanges[i].getEnd() + offset;
pageRanges[i] = new PageRange(start, end);
}
}
/**
* Gets the number of pages in a normalized range array.
*
* @param pageRanges Normalized page ranges.
* @param layoutPageCount Page count after reported after layout pass.
* @return The page count in the ranges.
*/
public static int getNormalizedPageCount(PageRange[] pageRanges, int layoutPageCount) {
int pageCount = 0;
if (pageRanges != null) {
final int pageRangeCount = pageRanges.length;
for (int i = 0; i < pageRangeCount; i++) {
PageRange pageRange = pageRanges[i];
if (PageRange.ALL_PAGES.equals(pageRange)) {
return layoutPageCount;
}
pageCount += pageRange.getSize();
}
}
return pageCount;
}
public static PageRange asAbsoluteRange(PageRange pageRange, int pageCount) {
if (PageRange.ALL_PAGES.equals(pageRange)) {
return new PageRange(0, pageCount - 1);
}
return pageRange;
}
public static boolean isAllPages(PageRange[] pageRanges) {
final int pageRangeCount = pageRanges.length;
for (int i = 0; i < pageRangeCount; i++) {
PageRange pageRange = pageRanges[i];
if (isAllPages(pageRange)) {
return true;
}
}
return false;
}
public static boolean isAllPages(PageRange pageRange) {
return PageRange.ALL_PAGES.equals(pageRange);
}
public static boolean isAllPages(PageRange[] pageRanges, int pageCount) {
final int pageRangeCount = pageRanges.length;
for (int i = 0; i < pageRangeCount; i++) {
PageRange pageRange = pageRanges[i];
if (isAllPages(pageRange, pageCount)) {
return true;
}
}
return false;
}
public static boolean isAllPages(PageRange pageRanges, int pageCount) {
return pageRanges.getStart() == 0 && pageRanges.getEnd() == pageCount - 1;
}
/**
* Compute the pages of the file that correspond to the requested pages in the doc.
*
* @param pagesInDocRequested The requested pages, doc-indexed
* @param pagesWrittenToFile The pages in the file
* @param pageCount The number of pages in the doc
*
* @return The pages, file-indexed
*/
public static PageRange[] computeWhichPagesInFileToPrint(PageRange[] pagesInDocRequested,
PageRange[] pagesWrittenToFile, int pageCount) {
// Adjust the print job pages based on what was requested and written.
// The cases are ordered in the most expected to the least expected
// with a special case first where the app does not know the page count
// so we ask for all to be written.
if (Arrays.equals(pagesInDocRequested, ALL_PAGES_RANGE)
&& pageCount == PrintDocumentInfo.PAGE_COUNT_UNKNOWN) {
return ALL_PAGES_RANGE;
} else if (Arrays.equals(pagesWrittenToFile, pagesInDocRequested)) {
// We got a document with exactly the pages we wanted. Hence,
// the printer has to print all pages in the data.
return ALL_PAGES_RANGE;
} else if (Arrays.equals(pagesWrittenToFile, ALL_PAGES_RANGE)) {
// We requested specific pages but got all of them. Hence,
// the printer has to print only the requested pages.
return pagesInDocRequested;
} else if (PageRangeUtils.contains(pagesWrittenToFile, pagesInDocRequested, pageCount)) {
// We requested specific pages and got more but not all pages.
// Hence, we have to offset appropriately the printed pages to
// be based off the start of the written ones instead of zero.
// The written pages are always non-null and not empty.
final int offset = -pagesWrittenToFile[0].getStart();
PageRangeUtils.offset(pagesInDocRequested.clone(), offset);
return pagesInDocRequested;
} else if (Arrays.equals(pagesInDocRequested, ALL_PAGES_RANGE)
&& isAllPages(pagesWrittenToFile, pageCount)) {
// We requested all pages via the special constant and got all
// of them as an explicit enumeration. Hence, the printer has
// to print only the requested pages.
return ALL_PAGES_RANGE;
}
return null;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy