/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.ofbiz.common.qrcode;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.io.IOException;
import java.lang.Integer;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.FileUtil;
import org.apache.ofbiz.base.util.UtilProperties;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.common.image.ImageTransform;
import org.apache.ofbiz.service.DispatchContext;
import org.apache.ofbiz.service.ServiceUtil;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.ChecksumException;
import com.google.zxing.DecodeHintType;
import com.google.zxing.EncodeHintType;
import com.google.zxing.FormatException;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.NotFoundException;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.DecoderResult;
import com.google.zxing.common.DetectorResult;
import com.google.zxing.qrcode.decoder.Decoder;
import com.google.zxing.qrcode.detector.Detector;
import freemarker.template.utility.StringUtil;
/**
* Services for QRCode.
*/
public class QRCodeServices {
public static final String module = QRCodeServices.class.getName();
public static final String QRCODE_DEFAULT_WIDTH = UtilProperties.getPropertyValue("qrcode", "qrcode.default.width", "200");
public static final String QRCODE_DEFAULT_HEIGHT = UtilProperties.getPropertyValue("qrcode", "qrcode.default.height", "200");
public static final String QRCODE_DEFAULT_FORMAT = UtilProperties.getPropertyValue("qrcode", "qrcode.default.format", "jpg");
public static final String QRCODE_FORMAT_SUPPORTED = UtilProperties.getPropertyValue("qrcode", "qrcode.format.supported", "jpg|png|bmp");
public static final String QRCODE_DEFAULT_LOGOIMAGE = UtilProperties.getPropertyValue("qrcode", "qrcode.default.logoimage");
public static BufferedImage defaultLogoImage;
public static final String[] FORMAT_NAMES = StringUtil.split(QRCODE_FORMAT_SUPPORTED, '|');
public static final List<String> FORMATS_SUPPORTED = Arrays.asList(FORMAT_NAMES);
public static final int MIN_SIZE = 20;
public static final int MAX_SIZE = 500;
private static final int BLACK = 0xFF000000;
private static final int WHITE = 0xFFFFFFFF;
static {
if (UtilValidate.isNotEmpty(QRCODE_DEFAULT_LOGOIMAGE)) {
try {
Map<String, Object> logoImageResult = ImageTransform.getBufferedImage(FileUtil.getFile(QRCODE_DEFAULT_LOGOIMAGE).getAbsolutePath(), Locale.getDefault());
defaultLogoImage = (BufferedImage) logoImageResult.get("bufferedImage");
if (UtilValidate.isEmpty(defaultLogoImage)) {
Debug.logError("Your logo image file(" + QRCODE_DEFAULT_LOGOIMAGE + ") cannot be read by javax.imageio.ImageIO. Please use png, jpeg formats instead of ico and etc.", module);
}
} catch (IllegalArgumentException e) {
defaultLogoImage = null;
} catch (IOException e) {
defaultLogoImage = null;
}
}
}
/** Streams QR Code to the result. */
public static Map<String, Object> generateQRCodeImage(DispatchContext ctx,Map<String, Object> context) {
Locale locale = (Locale) context.get("locale");
String message = (String) context.get("message");
Integer width = (Integer) context.get("width");
Integer height = (Integer) context.get("height");
String format = (String) context.get("format");
String encoding = (String) context.get("encoding");
Boolean verifyOutput = (Boolean) context.get("verifyOutput");
String logoImage = (String) context.get("logoImage");
Integer logoImageMaxWidth = (Integer) context.get("logoImageMaxWidth");
Integer logoImageMaxHeight = (Integer) context.get("logoImageMaxHeight");
if (UtilValidate.isEmpty(message)) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "ParameterCannotEmpty", new Object[] { "message" }, locale));
}
if (width == null) {
width = Integer.parseInt(QRCODE_DEFAULT_WIDTH);
}
if (width.intValue() < MIN_SIZE || width.intValue() > MAX_SIZE) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "SizeOutOfBorderError", new Object[] {"width", String.valueOf(width), String.valueOf(MIN_SIZE), String.valueOf(MAX_SIZE)}, locale));
}
if (height == null) {
height = Integer.parseInt(QRCODE_DEFAULT_HEIGHT);
}
if (height.intValue() < MIN_SIZE || height.intValue() > MAX_SIZE) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "SizeOutOfBorderError",
new Object[] { "height", String.valueOf(height), String.valueOf(MIN_SIZE), String.valueOf(MAX_SIZE) }, locale));
}
if (UtilValidate.isEmpty(format)) {
format = QRCODE_DEFAULT_FORMAT;
}
if (!FORMATS_SUPPORTED.contains(format)) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "ErrorFormatNotSupported", new Object[] { format }, locale));
}
Map<EncodeHintType, Object> encodeHints = null;
if (UtilValidate.isNotEmpty(encoding)) {
encodeHints = new EnumMap<>(EncodeHintType.class);
encodeHints.put(EncodeHintType.CHARACTER_SET, encoding);
}
try {
BitMatrix bitMatrix = new MultiFormatWriter().encode(message, BarcodeFormat.QR_CODE, width, height, encodeHints);
BufferedImage bufferedImage = toBufferedImage(bitMatrix, format);
BufferedImage logoBufferedImage = null;
if (UtilValidate.isNotEmpty(logoImage)) {
Map<String, Object> logoImageResult;
try {
logoImageResult = ImageTransform.getBufferedImage(FileUtil.getFile(logoImage).getAbsolutePath(), locale);
logoBufferedImage = (BufferedImage) logoImageResult.get("bufferedImage");
} catch (IllegalArgumentException e) {
// do nothing
} catch (IOException e) {
// do nothing
}
}
if (UtilValidate.isEmpty(logoBufferedImage)) {
logoBufferedImage = defaultLogoImage;
}
BufferedImage newBufferedImage = null;
if (UtilValidate.isNotEmpty(logoBufferedImage)) {
if (UtilValidate.isNotEmpty(logoImageMaxWidth) && UtilValidate.isNotEmpty(logoImageMaxHeight) && (logoBufferedImage.getWidth() > logoImageMaxWidth.intValue() || logoBufferedImage.getHeight() > logoImageMaxHeight.intValue())) {
Map<String, String> typeMap = new HashMap<String, String>();
typeMap.put("width", logoImageMaxWidth.toString());
typeMap.put("height", logoImageMaxHeight.toString());
Map<String, Map<String, String>> dimensionMap = new HashMap<String, Map<String, String>>();
dimensionMap.put("QRCode", typeMap);
Map<String, Object> logoImageResult = ImageTransform.scaleImage(logoBufferedImage, (double) logoBufferedImage.getWidth(), (double) logoBufferedImage.getHeight(), dimensionMap, "QRCode", locale);
logoBufferedImage = (BufferedImage) logoImageResult.get("bufferedImage");
}
BitMatrix newBitMatrix = bitMatrix.clone();
newBufferedImage = toBufferedImage(newBitMatrix, format);
Graphics2D graphics = newBufferedImage.createGraphics();
graphics.drawImage(logoBufferedImage, new AffineTransformOp(AffineTransform.getTranslateInstance(1, 1), null), (newBufferedImage.getWidth() - logoBufferedImage.getWidth())/2, (newBufferedImage.getHeight() - logoBufferedImage.getHeight())/2);
graphics.dispose();
}
if (UtilValidate.isNotEmpty(verifyOutput) && verifyOutput.booleanValue()) {
Decoder decoder = new Decoder();
Map<DecodeHintType, Object> decodeHints = new EnumMap<>(DecodeHintType.class);
decodeHints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE);
if (UtilValidate.isNotEmpty(encoding)) {
decodeHints.put(DecodeHintType.CHARACTER_SET, encoding);
}
DetectorResult detectorResult = null;
if (UtilValidate.isNotEmpty(newBufferedImage)) {
BitMatrix newBitMatrix = createMatrixFromImage(newBufferedImage);
DecoderResult result = null;
try {
detectorResult = new Detector(newBitMatrix).detect(decodeHints);
result = decoder.decode(detectorResult.getBits(), decodeHints);
} catch (ChecksumException e) {
// do nothing
} catch (FormatException e) {
// do nothing
} catch (NotFoundException e) {
// do nothing
}
if (UtilValidate.isNotEmpty(result) && !result.getText().equals(message)) {
detectorResult = new Detector(bitMatrix).detect(decodeHints);
result = decoder.decode(detectorResult.getBits(), decodeHints);
if (!result.getText().equals(message)) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "GeneratedTextNotMatchOriginal", new Object[]{result.getText(), message}, locale));
}
} else {
bufferedImage = newBufferedImage;
}
} else {
detectorResult = new Detector(bitMatrix).detect(decodeHints);
DecoderResult result = decoder.decode(detectorResult.getBits(), decodeHints);
if (!result.getText().equals(message)) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "GeneratedTextNotMatchOriginal", new Object[]{result.getText(), message}, locale));
}
}
} else if (UtilValidate.isNotEmpty(newBufferedImage)) {
bufferedImage = newBufferedImage;
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("bufferedImage", bufferedImage);
return result;
} catch (WriterException e) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "ErrorGenerateQRCode", new Object[] { e.toString() }, locale));
} catch (ChecksumException e) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "ErrorVerifyQRCode", new Object[] { e.toString() }, locale));
} catch (FormatException e) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "ErrorVerifyQRCode", new Object[] { e.toString() }, locale));
} catch (NotFoundException e) {
return ServiceUtil.returnError(UtilProperties.getMessage("QRCodeUiLabels", "ErrorVerifyQRCode", new Object[] { e.toString() }, locale));
}
}
/**
* Renders a {@link BitMatrix} as an image, where "false" bits are rendered
* as white, and "true" bits are rendered as black.
*
* This is to replace MatrixToImageWriter.toBufferedImage(bitMatrix) if you
* find the output image is not right, you can change BufferedImage image =
* new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); to
* BufferedImage image = new BufferedImage(width, height,
* BufferedImage.TYPE_INT_RGB); or others to make it work correctly.
*/
private static BufferedImage toBufferedImage(BitMatrix matrix, String format) {
int width = matrix.getWidth();
int height = matrix.getHeight();
BufferedImage image = null;
String osName = System.getProperty("os.name").toLowerCase();
image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
if (osName.startsWith("mac os") && format.equals("png")) {
image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
}
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
image.setRGB(x, y, matrix.get(x, y) ? BLACK : WHITE);
}
}
return image;
}
private static BitMatrix createMatrixFromImage(BufferedImage image) {
int width = image.getWidth();
int height = image.getHeight();
int[] pixels = new int[width * height];
image.getRGB(0, 0, width, height, pixels, 0, width);
BitMatrix matrix = new BitMatrix(width, height);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int pixel = pixels[y * width + x];
int luminance = (306 * ((pixel >> 16) & 0xFF) +
601 * ((pixel >> 8) & 0xFF) +
117 * (pixel & 0xFF)) >> 10;
if (luminance <= 0x7F) {
matrix.set(x, y);
}
}
}
return matrix;
}
}