rhodes 2.4.1 → 3.0.0.beta.1

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/ChecksumException.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * 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.google.zxing;
+
+/**
+ * Thrown when a barcode was successfully detected and decoded, but
+ * was not returned because its checksum feature failed.
+ *
+ * @author Sean Owen
+ */
+public final class ChecksumException extends ReaderException {
+
+  private static final ChecksumException instance = new ChecksumException();
+
+  private ChecksumException() {
+    // do nothing
+  }
+
+  public static ChecksumException getChecksumInstance() {
+    return instance;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/DecodeHintType.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * 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.google.zxing;
+
+/**
+ * Encapsulates a type of hint that a caller may pass to a barcode reader to help it
+ * more quickly or accurately decode it. It is up to implementations to decide what,
+ * if anything, to do with the information that is supplied.
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @see Reader#decode(BinaryBitmap,java.util.Hashtable)
+ */
+public final class DecodeHintType {
+
+  // No, we can't use an enum here. J2ME doesn't support it.
+
+  /**
+   * Unspecified, application-specific hint. Maps to an unspecified {@link Object}.
+   */
+  public static final DecodeHintType OTHER = new DecodeHintType();
+
+  /**
+   * Image is a pure monochrome image of a barcode. Doesn't matter what it maps to;
+   * use {@link Boolean#TRUE}.
+   */
+  public static final DecodeHintType PURE_BARCODE = new DecodeHintType();
+
+  /**
+   * Image is known to be of one of a few possible formats.
+   * Maps to a {@link java.util.Vector} of {@link BarcodeFormat}s.
+   */
+  public static final DecodeHintType POSSIBLE_FORMATS = new DecodeHintType();
+
+  /**
+   * Spend more time to try to find a barcode; optimize for accuracy, not speed.
+   * Doesn't matter what it maps to; use {@link Boolean#TRUE}.
+   */
+  public static final DecodeHintType TRY_HARDER = new DecodeHintType();
+
+  /**
+   * Specifies what character encoding to use when decoding, where applicable (type String)
+   */
+  public static final DecodeHintType CHARACTER_SET = new DecodeHintType();
+
+  /**
+   * Allowed lengths of encoded data -- reject anything else. Maps to an int[].
+   */
+  public static final DecodeHintType ALLOWED_LENGTHS = new DecodeHintType();
+
+  /**
+   * Assume Code 39 codes employ a check digit. Maps to {@link Boolean}.
+   */
+  public static final DecodeHintType ASSUME_CODE_39_CHECK_DIGIT = new DecodeHintType();
+
+  /**
+   * The caller needs to be notified via callback when a possible {@link ResultPoint}
+   * is found. Maps to a {@link ResultPointCallback}.
+   */
+  public static final DecodeHintType NEED_RESULT_POINT_CALLBACK = new DecodeHintType();
+
+  private DecodeHintType() {
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/EncodeHintType.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * 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.google.zxing;
+
+/**
+ * These are a set of hints that you may pass to Writers to specify their behavior.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class EncodeHintType {
+
+  /**
+   * Specifies what degree of error correction to use, for example in QR Codes (type Integer).
+   */
+  public static final EncodeHintType ERROR_CORRECTION = new EncodeHintType();
+
+  /**
+   * Specifies what character encoding to use where applicable (type String)
+   */
+  public static final EncodeHintType CHARACTER_SET = new EncodeHintType();
+
+  private EncodeHintType() {
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/FormatException.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * 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.google.zxing;
+
+/**
+ * Thrown when a barcode was successfully detected, but some aspect of
+ * the content did not conform to the barcode's format rules. This could have
+ * been due to a mis-detection.
+ *
+ * @author Sean Owen
+ */
+public final class FormatException extends ReaderException {
+
+  private static final FormatException instance = new FormatException();
+
+  private FormatException() {
+    // do nothing
+  }
+
+  public static FormatException getFormatInstance() {
+    return instance;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/LuminanceSource.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * 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.google.zxing;
+
+/**
+ * The purpose of this class hierarchy is to abstract different bitmap implementations across
+ * platforms into a standard interface for requesting greyscale luminance values. The interface
+ * only provides immutable methods; therefore crop and rotation create copies. This is to ensure
+ * that one Reader does not modify the original luminance source and leave it in an unknown state
+ * for other Readers in the chain.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public abstract class LuminanceSource {
+
+  private final int width;
+  private final int height;
+
+  protected LuminanceSource(int width, int height) {
+    this.width = width;
+    this.height = height;
+  }
+
+  /**
+   * Fetches one row of luminance data from the underlying platform's bitmap. Values range from
+   * 0 (black) to 255 (white). Because Java does not have an unsigned byte type, callers will have
+   * to bitwise and with 0xff for each value. It is preferable for implementations of this method
+   * to only fetch this row rather than the whole image, since no 2D Readers may be installed and
+   * getMatrix() may never be called.
+   *
+   * @param y The row to fetch, 0 <= y < getHeight().
+   * @param row An optional preallocated array. If null or too small, it will be ignored.
+   *            Always use the returned object, and ignore the .length of the array.
+   * @return An array containing the luminance data.
+   */
+  public abstract byte[] getRow(int y, byte[] row);
+
+  /**
+   * Fetches luminance data for the underlying bitmap. Values should be fetched using:
+   * int luminance = array[y * width + x] & 0xff;
+   *
+   * @return A row-major 2D array of luminance values. Do not use result.length as it may be
+   *         larger than width * height bytes on some platforms. Do not modify the contents
+   *         of the result.
+   */
+  public abstract byte[] getMatrix();
+
+  /**
+   * @return The width of the bitmap.
+   */
+  public final int getWidth() {
+    return width;
+  }
+
+  /**
+   * @return The height of the bitmap.
+   */
+  public final int getHeight() {
+    return height;
+  }
+
+  /**
+   * @return Whether this subclass supports cropping.
+   */
+  public boolean isCropSupported() {
+    return false;
+  }
+
+  /**
+   * Returns a new object with cropped image data. Implementations may keep a reference to the
+   * original data rather than a copy. Only callable if isCropSupported() is true.
+   *
+   * @param left The left coordinate, 0 <= left < getWidth().
+   * @param top The top coordinate, 0 <= top <= getHeight().
+   * @param width The width of the rectangle to crop.
+   * @param height The height of the rectangle to crop.
+   * @return A cropped version of this object.
+   */
+  public LuminanceSource crop(int left, int top, int width, int height) {
+    throw new RuntimeException("This luminance source does not support cropping.");
+  }
+
+  /**
+   * @return Whether this subclass supports counter-clockwise rotation.
+   */
+  public boolean isRotateSupported() {
+    return false;
+  }
+
+  /**
+   * Returns a new object with rotated image data. Only callable if isRotateSupported() is true.
+   *
+   * @return A rotated version of this object.
+   */
+  public LuminanceSource rotateCounterClockwise() {
+    throw new RuntimeException("This luminance source does not support rotation.");
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/MultiFormatReader.java

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * 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.google.zxing;
+
+import com.google.zxing.datamatrix.DataMatrixReader;
+import com.google.zxing.oned.MultiFormatOneDReader;
+import com.google.zxing.pdf417.PDF417Reader;
+import com.google.zxing.qrcode.QRCodeReader;
+
+import java.util.Hashtable;
+import java.util.Vector;
+
+/**
+ * MultiFormatReader is a convenience class and the main entry point into the library for most uses.
+ * By default it attempts to decode all barcode formats that the library supports. Optionally, you
+ * can provide a hints object to request different behavior, for example only decoding QR codes.
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class MultiFormatReader implements Reader {
+
+  private Hashtable hints;
+  private Vector readers;
+
+  /**
+   * This version of decode honors the intent of Reader.decode(BinaryBitmap) in that it
+   * passes null as a hint to the decoders. However, that makes it inefficient to call repeatedly.
+   * Use setHints() followed by decodeWithState() for continuous scan applications.
+   *
+   * @param image The pixel data to decode
+   * @return The contents of the image
+   * @throws NotFoundException Any errors which occurred
+   */
+  public Result decode(BinaryBitmap image) throws NotFoundException {
+    setHints(null);
+    return decodeInternal(image);
+  }
+
+  /**
+   * Decode an image using the hints provided. Does not honor existing state.
+   *
+   * @param image The pixel data to decode
+   * @param hints The hints to use, clearing the previous state.
+   * @return The contents of the image
+   * @throws NotFoundException Any errors which occurred
+   */
+  public Result decode(BinaryBitmap image, Hashtable hints) throws NotFoundException {
+    setHints(hints);
+    return decodeInternal(image);
+  }
+
+  /**
+   * Decode an image using the state set up by calling setHints() previously. Continuous scan
+   * clients will get a <b>large</b> speed increase by using this instead of decode().
+   *
+   * @param image The pixel data to decode
+   * @return The contents of the image
+   * @throws NotFoundException Any errors which occurred
+   */
+  public Result decodeWithState(BinaryBitmap image) throws NotFoundException {
+    // Make sure to set up the default state so we don't crash
+    if (readers == null) {
+      setHints(null);
+    }
+    return decodeInternal(image);
+  }
+
+  /**
+   * This method adds state to the MultiFormatReader. By setting the hints once, subsequent calls
+   * to decodeWithState(image) can reuse the same set of readers without reallocating memory. This
+   * is important for performance in continuous scan clients.
+   *
+   * @param hints The set of hints to use for subsequent calls to decode(image)
+   */
+  public void setHints(Hashtable hints) {
+    this.hints = hints;
+
+    boolean tryHarder = hints != null && hints.containsKey(DecodeHintType.TRY_HARDER);
+    Vector formats = hints == null ? null : (Vector) hints.get(DecodeHintType.POSSIBLE_FORMATS);
+    readers = new Vector();
+    if (formats != null) {
+      boolean addOneDReader =
+          formats.contains(BarcodeFormat.UPC_A) ||
+              formats.contains(BarcodeFormat.UPC_E) ||
+              formats.contains(BarcodeFormat.EAN_13) ||
+              formats.contains(BarcodeFormat.EAN_8) ||
+              //formats.contains(BarcodeFormat.CODABAR) ||
+              formats.contains(BarcodeFormat.CODE_39) ||
+              formats.contains(BarcodeFormat.CODE_93) ||
+              formats.contains(BarcodeFormat.CODE_128) ||
+              formats.contains(BarcodeFormat.ITF) ||
+              formats.contains(BarcodeFormat.RSS14) ||
+              formats.contains(BarcodeFormat.RSS_EXPANDED);
+      // Put 1D readers upfront in "normal" mode
+      if (addOneDReader && !tryHarder) {
+        readers.addElement(new MultiFormatOneDReader(hints));
+      }
+      if (formats.contains(BarcodeFormat.QR_CODE)) {
+        readers.addElement(new QRCodeReader());
+      }
+      if (formats.contains(BarcodeFormat.DATA_MATRIX)) {
+        readers.addElement(new DataMatrixReader());
+      }
+      if (formats.contains(BarcodeFormat.PDF417)) {
+         readers.addElement(new PDF417Reader());
+       }
+      // At end in "try harder" mode
+      if (addOneDReader && tryHarder) {
+        readers.addElement(new MultiFormatOneDReader(hints));
+      }
+    }
+    if (readers.isEmpty()) {
+      if (!tryHarder) {
+        readers.addElement(new MultiFormatOneDReader(hints));
+      }
+      readers.addElement(new QRCodeReader());
+
+      readers.addElement(new DataMatrixReader());
+
+      // TODO: Enable once PDF417 has passed QA
+      //readers.addElement(new PDF417Reader());
+
+      if (tryHarder) {
+        readers.addElement(new MultiFormatOneDReader(hints));
+      }
+    }
+  }
+
+  public void reset() {
+    int size = readers.size();
+    for (int i = 0; i < size; i++) {
+      Reader reader = (Reader) readers.elementAt(i);
+      reader.reset();
+    }
+  }
+
+  private Result decodeInternal(BinaryBitmap image) throws NotFoundException {
+    int size = readers.size();
+    for (int i = 0; i < size; i++) {
+      Reader reader = (Reader) readers.elementAt(i);
+      try {
+        return reader.decode(image, hints);
+      } catch (ReaderException re) {
+        // continue
+      }
+    }
+
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+}