, graphicOverlay: GraphicOverlay) {
40 | for (barcode in results) {
41 | val graphic = BarcodeGraphic(barcode, graphicOverlay, drawOverlay, drawBanner, focusBoxSize) { isInFocus ->
42 | val displayValue = barcode.displayValue
43 | val rawValue = barcode.rawValue
44 | if (isInFocus && displayValue != null && rawValue != null) {
45 | callback.onNewBarcodeScanned(displayValue, rawValue)
46 | }
47 | }
48 | graphicOverlay.add(graphic)
49 | }
50 | }
51 |
52 | override fun onFailure(e: Exception) {
53 | // do nothing
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/BitmapUtils.java:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner;
2 |
3 | import android.graphics.Bitmap;
4 | import android.graphics.BitmapFactory;
5 | import android.graphics.ImageFormat;
6 | import android.graphics.Matrix;
7 | import android.graphics.Rect;
8 | import android.graphics.YuvImage;
9 | import android.media.Image;
10 | import android.media.Image.Plane;
11 | import android.util.Log;
12 |
13 | import androidx.annotation.Nullable;
14 | import androidx.camera.core.ExperimentalGetImage;
15 | import androidx.camera.core.ImageProxy;
16 |
17 | import java.io.ByteArrayOutputStream;
18 | import java.nio.ByteBuffer;
19 |
20 | /** Utils functions for bitmap conversions. */
21 | class BitmapUtils {
22 | /** Converts NV21 format byte buffer to bitmap. */
23 | @Nullable
24 | public static Bitmap getBitmap(ByteBuffer data, FrameMetadata metadata) {
25 | data.rewind();
26 | byte[] imageInBuffer = new byte[data.limit()];
27 | data.get(imageInBuffer, 0, imageInBuffer.length);
28 | try {
29 | YuvImage image =
30 | new YuvImage(
31 | imageInBuffer, ImageFormat.NV21, metadata.getWidth(), metadata.getHeight(), null);
32 | ByteArrayOutputStream stream = new ByteArrayOutputStream();
33 | image.compressToJpeg(new Rect(0, 0, metadata.getWidth(), metadata.getHeight()), 80, stream);
34 |
35 | Bitmap bmp = BitmapFactory.decodeByteArray(stream.toByteArray(), 0, stream.size());
36 |
37 | stream.close();
38 | return rotateBitmap(bmp, metadata.getRotation());
39 | } catch (Exception e) {
40 | Log.e("VisionProcessorBase", "Error: " + e.getMessage());
41 | }
42 | return null;
43 | }
44 |
45 | /** Converts a YUV_420_888 image from CameraX API to a bitmap. */
46 | @Nullable
47 | @ExperimentalGetImage
48 | public static Bitmap getBitmap(ImageProxy image) {
49 | FrameMetadata frameMetadata =
50 | new FrameMetadata.Builder()
51 | .setWidth(image.getWidth())
52 | .setHeight(image.getHeight())
53 | .setRotation(image.getImageInfo().getRotationDegrees())
54 | .build();
55 |
56 | ByteBuffer nv21Buffer = yuv420ThreePlanesToNV21(image.getImage().getPlanes(), image.getWidth(), image.getHeight());
57 | return getBitmap(nv21Buffer, frameMetadata);
58 | }
59 |
60 | /** Rotates a bitmap if it is converted from a bytebuffer. */
61 | private static Bitmap rotateBitmap(Bitmap bitmap, int rotationDegrees) {
62 | Matrix matrix = new Matrix();
63 |
64 | // Rotate the image back to straight.
65 | matrix.postRotate(rotationDegrees);
66 |
67 | // Mirror the image along the X or Y axis.
68 | matrix.postScale(1.0f, 1.0f);
69 | Bitmap rotatedBitmap =
70 | Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
71 |
72 | // Recycle the old bitmap if it has changed.
73 | if (rotatedBitmap != bitmap) {
74 | bitmap.recycle();
75 | }
76 | return rotatedBitmap;
77 | }
78 |
79 | /**
80 | * Converts YUV_420_888 to NV21 bytebuffer.
81 | *
82 | * The NV21 format consists of a single byte array containing the Y, U and V values. For an
83 | * image of size S, the first S positions of the array contain all the Y values. The remaining
84 | * positions contain interleaved V and U values. U and V are subsampled by a factor of 2 in both
85 | * dimensions, so there are S/4 U values and S/4 V values. In summary, the NV21 array will contain
86 | * S Y values followed by S/4 VU values: YYYYYYYYYYYYYY(...)YVUVUVUVU(...)VU
87 | *
88 | *
YUV_420_888 is a generic format that can describe any YUV image where U and V are subsampled
89 | * by a factor of 2 in both dimensions. {@link Image#getPlanes} returns an array with the Y, U and
90 | * V planes. The Y plane is guaranteed not to be interleaved, so we can just copy its values into
91 | * the first part of the NV21 array. The U and V planes may already have the representation in the
92 | * NV21 format. This happens if the planes share the same buffer, the V buffer is one position
93 | * before the U buffer and the planes have a pixelStride of 2. If this is case, we can just copy
94 | * them to the NV21 array.
95 | */
96 | private static ByteBuffer yuv420ThreePlanesToNV21(
97 | Plane[] yuv420888planes, int width, int height) {
98 | int imageSize = width * height;
99 | byte[] out = new byte[imageSize + 2 * (imageSize / 4)];
100 |
101 | if (areUVPlanesNV21(yuv420888planes, width, height)) {
102 | // Copy the Y values.
103 | yuv420888planes[0].getBuffer().get(out, 0, imageSize);
104 |
105 | ByteBuffer uBuffer = yuv420888planes[1].getBuffer();
106 | ByteBuffer vBuffer = yuv420888planes[2].getBuffer();
107 | // Get the first V value from the V buffer, since the U buffer does not contain it.
108 | vBuffer.get(out, imageSize, 1);
109 | // Copy the first U value and the remaining VU values from the U buffer.
110 | uBuffer.get(out, imageSize + 1, 2 * imageSize / 4 - 1);
111 | } else {
112 | // Fallback to copying the UV values one by one, which is slower but also works.
113 | // Unpack Y.
114 | unpackPlane(yuv420888planes[0], width, height, out, 0, 1);
115 | // Unpack U.
116 | unpackPlane(yuv420888planes[1], width, height, out, imageSize + 1, 2);
117 | // Unpack V.
118 | unpackPlane(yuv420888planes[2], width, height, out, imageSize, 2);
119 | }
120 |
121 | return ByteBuffer.wrap(out);
122 | }
123 |
124 | /** Checks if the UV plane buffers of a YUV_420_888 image are in the NV21 format. */
125 | private static boolean areUVPlanesNV21(Plane[] planes, int width, int height) {
126 | int imageSize = width * height;
127 |
128 | ByteBuffer uBuffer = planes[1].getBuffer();
129 | ByteBuffer vBuffer = planes[2].getBuffer();
130 |
131 | // Backup buffer properties.
132 | int vBufferPosition = vBuffer.position();
133 | int uBufferLimit = uBuffer.limit();
134 |
135 | // Advance the V buffer by 1 byte, since the U buffer will not contain the first V value.
136 | vBuffer.position(vBufferPosition + 1);
137 | // Chop off the last byte of the U buffer, since the V buffer will not contain the last U value.
138 | uBuffer.limit(uBufferLimit - 1);
139 |
140 | // Check that the buffers are equal and have the expected number of elements.
141 | boolean areNV21 =
142 | (vBuffer.remaining() == (2 * imageSize / 4 - 2)) && (vBuffer.compareTo(uBuffer) == 0);
143 |
144 | // Restore buffers to their initial state.
145 | vBuffer.position(vBufferPosition);
146 | uBuffer.limit(uBufferLimit);
147 |
148 | return areNV21;
149 | }
150 |
151 | /**
152 | * Unpack an image plane into a byte array.
153 | *
154 | *
The input plane data will be copied in 'out', starting at 'offset' and every pixel will be
155 | * spaced by 'pixelStride'. Note that there is no row padding on the output.
156 | */
157 | private static void unpackPlane(
158 | Plane plane, int width, int height, byte[] out, int offset, int pixelStride) {
159 | ByteBuffer buffer = plane.getBuffer();
160 | buffer.rewind();
161 |
162 | // Compute the size of the current plane.
163 | // We assume that it has the aspect ratio as the original image.
164 | int numRow = (buffer.limit() + plane.getRowStride() - 1) / plane.getRowStride();
165 | if (numRow == 0) {
166 | return;
167 | }
168 | int scaleFactor = height / numRow;
169 | int numCol = width / scaleFactor;
170 |
171 | // Extract the data in the output buffer.
172 | int outputPos = offset;
173 | int rowStart = 0;
174 | for (int row = 0; row < numRow; row++) {
175 | int inputPos = rowStart;
176 | for (int col = 0; col < numCol; col++) {
177 | out[outputPos] = buffer.get(inputPos);
178 | outputPos += pixelStride;
179 | inputPos += plane.getPixelStride();
180 | }
181 | rowStart += plane.getRowStride();
182 | }
183 | }
184 | }
185 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/CameraImageGraphic.java:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner;
2 |
3 | import android.graphics.Bitmap;
4 | import android.graphics.Canvas;
5 |
6 | /** Draw camera image to background. */
7 | class CameraImageGraphic extends GraphicOverlay.Graphic {
8 |
9 | private final Bitmap bitmap;
10 |
11 | public CameraImageGraphic(GraphicOverlay overlay, Bitmap bitmap) {
12 | super(overlay);
13 | this.bitmap = bitmap;
14 | }
15 |
16 | @Override
17 | public void draw(Canvas canvas) {
18 | canvas.drawBitmap(bitmap, getTransformationMatrix(), null);
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/CameraXViewModel.java:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner;
2 |
3 | import android.app.Application;
4 | import android.util.Log;
5 |
6 | import androidx.annotation.NonNull;
7 | import androidx.camera.lifecycle.ProcessCameraProvider;
8 | import androidx.core.content.ContextCompat;
9 | import androidx.lifecycle.AndroidViewModel;
10 | import androidx.lifecycle.LiveData;
11 | import androidx.lifecycle.MutableLiveData;
12 |
13 | import com.google.common.util.concurrent.ListenableFuture;
14 |
15 | import java.util.concurrent.ExecutionException;
16 |
17 | /** View model for interacting with CameraX. */
18 | public final class CameraXViewModel extends AndroidViewModel {
19 |
20 | private static final String TAG = "CameraXViewModel";
21 | private MutableLiveData cameraProviderLiveData;
22 |
23 | /**
24 | * Create an instance which interacts with the camera service via the given application context.
25 | */
26 | public CameraXViewModel(@NonNull Application application) {
27 | super(application);
28 | }
29 |
30 | public LiveData getProcessCameraProvider() {
31 | if (cameraProviderLiveData == null) {
32 | cameraProviderLiveData = new MutableLiveData<>();
33 |
34 | ListenableFuture cameraProviderFuture =
35 | ProcessCameraProvider.getInstance(getApplication());
36 | cameraProviderFuture.addListener(
37 | () -> {
38 | try {
39 | cameraProviderLiveData.setValue(cameraProviderFuture.get());
40 | } catch (ExecutionException | InterruptedException e) {
41 | Log.e(TAG, "Unhandled exception", e);
42 | }
43 | },
44 | ContextCompat.getMainExecutor(getApplication()));
45 | }
46 |
47 | return cameraProviderLiveData;
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/FrameMetadata.java:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner;
2 |
3 | /** Describing a frame info. */
4 | class FrameMetadata {
5 |
6 | private final int width;
7 | private final int height;
8 | private final int rotation;
9 |
10 | public int getWidth() {
11 | return width;
12 | }
13 |
14 | public int getHeight() {
15 | return height;
16 | }
17 |
18 | public int getRotation() {
19 | return rotation;
20 | }
21 |
22 | private FrameMetadata(int width, int height, int rotation) {
23 | this.width = width;
24 | this.height = height;
25 | this.rotation = rotation;
26 | }
27 |
28 | /** Builder of {@link FrameMetadata}. */
29 | public static class Builder {
30 |
31 | private int width;
32 | private int height;
33 | private int rotation;
34 |
35 | public Builder setWidth(int width) {
36 | this.width = width;
37 | return this;
38 | }
39 |
40 | public Builder setHeight(int height) {
41 | this.height = height;
42 | return this;
43 | }
44 |
45 | public Builder setRotation(int rotation) {
46 | this.rotation = rotation;
47 | return this;
48 | }
49 |
50 | public FrameMetadata build() {
51 | return new FrameMetadata(width, height, rotation);
52 | }
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/GraphicOverlay.java:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner;
2 |
3 | import android.content.Context;
4 | import android.graphics.Canvas;
5 | import android.graphics.Matrix;
6 | import android.graphics.Paint;
7 | import android.util.AttributeSet;
8 | import android.view.View;
9 |
10 | import com.google.android.gms.common.internal.Preconditions;
11 |
12 | import java.util.ArrayList;
13 | import java.util.List;
14 |
15 | /**
16 | * A view which renders a series of custom graphics to be overlayed on top of an associated preview
17 | * (i.e., the camera preview). The creator can add graphics objects, update the objects, and remove
18 | * them, triggering the appropriate drawing and invalidation within the view.
19 | *
20 | * Supports scaling and mirroring of the graphics relative the camera's preview properties. The
21 | * idea is that detection items are expressed in terms of an image size, but need to be scaled up
22 | * to the full view size, and also mirrored in the case of the front-facing camera.
23 | *
24 | *
Associated {@link Graphic} items should use the following methods to convert to view
25 | * coordinates for the graphics that are drawn:
26 | *
27 | *
28 | * - {@link Graphic#scale(float)} adjusts the size of the supplied value from the image scale
29 | * to the view scale.
30 | *
- {@link Graphic#translateX(float)} and {@link Graphic#translateY(float)} adjust the
31 | * coordinate from the image's coordinate system to the view coordinate system.
32 | *
33 | */
34 | public class GraphicOverlay extends View {
35 | private final Object lock = new Object();
36 | private final List graphics = new ArrayList<>();
37 | // Matrix for transforming from image coordinates to overlay view coordinates.
38 | private final Matrix transformationMatrix = new Matrix();
39 |
40 | private int imageWidth;
41 | private int imageHeight;
42 | // The factor of overlay View size to image size. Anything in the image coordinates need to be
43 | // scaled by this amount to fit with the area of overlay View.
44 | private float scaleFactor = 1.0f;
45 | // The number of horizontal pixels needed to be cropped on each side to fit the image with the
46 | // area of overlay View after scaling.
47 | private float postScaleWidthOffset;
48 | // The number of vertical pixels needed to be cropped on each side to fit the image with the
49 | // area of overlay View after scaling.
50 | private float postScaleHeightOffset;
51 | private boolean isImageFlipped;
52 | private boolean needUpdateTransformation = true;
53 |
54 | /**
55 | * Base class for a custom graphics object to be rendered within the graphic overlay. Subclass
56 | * this and implement the {@link Graphic#draw(Canvas)} method to define the graphics element. Add
57 | * instances to the overlay using {@link GraphicOverlay#add(Graphic)}.
58 | */
59 | public abstract static class Graphic {
60 | private GraphicOverlay overlay;
61 |
62 | public Graphic(GraphicOverlay overlay) {
63 | this.overlay = overlay;
64 | }
65 |
66 | /**
67 | * Draw the graphic on the supplied canvas. Drawing should use the following methods to convert
68 | * to view coordinates for the graphics that are drawn:
69 | *
70 | *
71 | * - {@link Graphic#scale(float)} adjusts the size of the supplied value from the image
72 | * scale to the view scale.
73 | *
- {@link Graphic#translateX(float)} and {@link Graphic#translateY(float)} adjust the
74 | * coordinate from the image's coordinate system to the view coordinate system.
75 | *
76 | *
77 | * @param canvas drawing canvas
78 | */
79 | public abstract void draw(Canvas canvas);
80 |
81 | protected void drawRect(
82 | Canvas canvas, float left, float top, float right, float bottom, Paint paint) {
83 | canvas.drawRect(left, top, right, bottom, paint);
84 | }
85 |
86 | protected void drawText(Canvas canvas, String text, float x, float y, Paint paint) {
87 | canvas.drawText(text, x, y, paint);
88 | }
89 |
90 | /** Adjusts the supplied value from the image scale to the view scale. */
91 | public float scale(float imagePixel) {
92 | return imagePixel * overlay.scaleFactor;
93 | }
94 |
95 | /** Returns the application context of the app. */
96 | public Context getApplicationContext() {
97 | return overlay.getContext().getApplicationContext();
98 | }
99 |
100 | public boolean isImageFlipped() {
101 | return overlay.isImageFlipped;
102 | }
103 |
104 | /**
105 | * Adjusts the x coordinate from the image's coordinate system to the view coordinate system.
106 | */
107 | public float translateX(float x) {
108 | if (overlay.isImageFlipped) {
109 | return overlay.getWidth() - (scale(x) - overlay.postScaleWidthOffset);
110 | } else {
111 | return scale(x) - overlay.postScaleWidthOffset;
112 | }
113 | }
114 |
115 | /**
116 | * Adjusts the y coordinate from the image's coordinate system to the view coordinate system.
117 | */
118 | public float translateY(float y) {
119 | return scale(y) - overlay.postScaleHeightOffset;
120 | }
121 |
122 | /**
123 | * Returns a {@link Matrix} for transforming from image coordinates to overlay view coordinates.
124 | */
125 | public Matrix getTransformationMatrix() {
126 | return overlay.transformationMatrix;
127 | }
128 |
129 | public void postInvalidate() {
130 | overlay.postInvalidate();
131 | }
132 | }
133 |
134 | public GraphicOverlay(Context context, AttributeSet attrs) {
135 | super(context, attrs);
136 | addOnLayoutChangeListener(
137 | (view, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom) ->
138 | needUpdateTransformation = true);
139 | }
140 |
141 | /** Removes all graphics from the overlay. */
142 | public void clear() {
143 | synchronized (lock) {
144 | graphics.clear();
145 | }
146 | postInvalidate();
147 | }
148 |
149 | /** Adds a graphic to the overlay. */
150 | public void add(Graphic graphic) {
151 | synchronized (lock) {
152 | graphics.add(graphic);
153 | }
154 | }
155 |
156 | /** Removes a graphic from the overlay. */
157 | public void remove(Graphic graphic) {
158 | synchronized (lock) {
159 | graphics.remove(graphic);
160 | }
161 | postInvalidate();
162 | }
163 |
164 | /**
165 | * Sets the source information of the image being processed by detectors, including size and
166 | * whether it is flipped, which informs how to transform image coordinates later.
167 | *
168 | * @param imageWidth the width of the image sent to ML Kit detectors
169 | * @param imageHeight the height of the image sent to ML Kit detectors
170 | * @param isFlipped whether the image is flipped. Should set it to true when the image is from the
171 | * front camera.
172 | */
173 | public void setImageSourceInfo(int imageWidth, int imageHeight, boolean isFlipped) {
174 | Preconditions.checkState(imageWidth > 0, "image width must be positive");
175 | Preconditions.checkState(imageHeight > 0, "image height must be positive");
176 | synchronized (lock) {
177 | this.imageWidth = imageWidth;
178 | this.imageHeight = imageHeight;
179 | this.isImageFlipped = isFlipped;
180 | needUpdateTransformation = true;
181 | }
182 | postInvalidate();
183 | }
184 |
185 | public int getImageWidth() {
186 | return imageWidth;
187 | }
188 |
189 | public int getImageHeight() {
190 | return imageHeight;
191 | }
192 |
193 | private void updateTransformationIfNeeded() {
194 | if (!needUpdateTransformation || imageWidth <= 0 || imageHeight <= 0) {
195 | return;
196 | }
197 | float viewAspectRatio = (float) getWidth() / getHeight();
198 | float imageAspectRatio = (float) imageWidth / imageHeight;
199 | postScaleWidthOffset = 0;
200 | postScaleHeightOffset = 0;
201 | if (viewAspectRatio > imageAspectRatio) {
202 | // The image needs to be vertically cropped to be displayed in this view.
203 | scaleFactor = (float) getWidth() / imageWidth;
204 | postScaleHeightOffset = ((float) getWidth() / imageAspectRatio - getHeight()) / 2;
205 | } else {
206 | // The image needs to be horizontally cropped to be displayed in this view.
207 | scaleFactor = (float) getHeight() / imageHeight;
208 | postScaleWidthOffset = ((float) getHeight() * imageAspectRatio - getWidth()) / 2;
209 | }
210 |
211 | transformationMatrix.reset();
212 | transformationMatrix.setScale(scaleFactor, scaleFactor);
213 | transformationMatrix.postTranslate(-postScaleWidthOffset, -postScaleHeightOffset);
214 |
215 | if (isImageFlipped) {
216 | transformationMatrix.postScale(-1f, 1f, getWidth() / 2f, getHeight() / 2f);
217 | }
218 |
219 | needUpdateTransformation = false;
220 | }
221 |
222 | /** Draws the overlay with its associated graphic objects. */
223 | @Override
224 | protected void onDraw(Canvas canvas) {
225 | super.onDraw(canvas);
226 |
227 | synchronized (lock) {
228 | updateTransformationIfNeeded();
229 |
230 | for (Graphic graphic : graphics) {
231 | graphic.draw(canvas);
232 | }
233 | }
234 | }
235 | }
236 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/MLBarcodeScanner.kt:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner
2 |
3 | import android.annotation.SuppressLint
4 | import android.content.Context
5 | import android.util.Log
6 | import android.util.Size
7 | import androidx.camera.core.CameraSelector
8 | import androidx.camera.core.ImageAnalysis
9 | import androidx.camera.core.ImageProxy
10 | import androidx.camera.core.Preview
11 | import androidx.camera.lifecycle.ProcessCameraProvider
12 | import androidx.camera.view.PreviewView
13 | import androidx.core.content.ContextCompat
14 | import androidx.lifecycle.DefaultLifecycleObserver
15 | import androidx.lifecycle.LifecycleOwner
16 | import androidx.lifecycle.ViewModelProvider
17 | import androidx.lifecycle.ViewModelStoreOwner
18 | import com.google.mlkit.common.MlKitException
19 | import com.google.mlkit.vision.barcode.common.Barcode
20 |
21 | /**
22 | * Delegate class to wrap all functionalities of barcode scanning and handling it's resources in a lifecycle aware manner
23 | *
24 | * @param callback listen to new scanned barcode
25 | * @param focusBoxSize width/height of the focus box in pixels (box must be square)
26 | * @param graphicOverlay overlay graphic to be drawn on screen to recognize barcode
27 | * @param previewView camera preview object in your view
28 | * @param lifecycleOwner lifecycle owner of your view (viewLifecycleOwner in fragment and this in activity)
29 | * @param context ui context
30 | * @param drawOverlay if set to true, will display a rectangle around detected barcode (default to true)
31 | * @param drawBanner if set to true, will display detected barcode value on top of it's rectangle (default to false)
32 | * @param targetResolution resolution of the camera view (default to 768 * 1024)
33 | * @param supportedBarcodeFormats list of all supported barcode formats (default to all)
34 | */
35 | class MLBarcodeScanner(
36 | private val callback: MLBarcodeCallback,
37 | private val context: Context,
38 | private val lifecycleOwner: LifecycleOwner,
39 | private val focusBoxSize: Int,
40 | private val graphicOverlay: GraphicOverlay,
41 | private val previewView: PreviewView,
42 | private val drawOverlay: Boolean = true,
43 | private val drawBanner: Boolean = false,
44 | private val targetResolution: Size = Size(768, 1024),
45 | private val supportedBarcodeFormats: List = listOf(Barcode.FORMAT_ALL_FORMATS)
46 | ) : DefaultLifecycleObserver {
47 |
48 | init {
49 | lifecycleOwner.lifecycle.addObserver(this)
50 | }
51 |
52 | private var lensFacing = CameraSelector.LENS_FACING_BACK
53 | private val cameraXViewModel: CameraXViewModel by lazy {
54 | ViewModelProvider(lifecycleOwner as ViewModelStoreOwner)[CameraXViewModel::class.java]
55 | }
56 | private lateinit var cameraSelector: CameraSelector
57 | private var cameraProvider: ProcessCameraProvider? = null
58 | private var previewUseCase: Preview? = null
59 | private var analysisUseCase: ImageAnalysis? = null
60 | private var needUpdateGraphicOverlayImageSourceInfo = false
61 | private var imageProcessor: VisionImageProcessor? = null
62 |
63 | init {
64 | initialize()
65 | }
66 |
67 | /**
68 | * initialize instance members
69 | */
70 | fun initialize() {
71 | cameraSelector = CameraSelector.Builder().requireLensFacing(lensFacing).build()
72 | cameraXViewModel.processCameraProvider.observe(lifecycleOwner) { provider: ProcessCameraProvider? ->
73 | cameraProvider = provider
74 | bindAllCameraUseCases()
75 | }
76 | }
77 |
78 | /**
79 | * Stop processing images in camera
80 | */
81 | fun stop() {
82 | imageProcessor?.stop()
83 | }
84 |
85 | private fun bindAllCameraUseCases() {
86 | // As required by CameraX API, unbinds all use cases before trying to re-bind any of them.
87 | cameraProvider?.unbindAll()
88 | bindPreviewUseCase()
89 | bindAnalysisUseCase()
90 | }
91 |
92 | private fun bindPreviewUseCase() {
93 | if (cameraProvider == null) {
94 | return
95 | }
96 | cameraProvider?.unbind(previewUseCase)
97 | val builder = Preview.Builder()
98 | previewUseCase = builder.build()
99 | previewUseCase?.setSurfaceProvider(previewView.surfaceProvider)
100 | cameraProvider?.bindToLifecycle(lifecycleOwner, cameraSelector, previewUseCase)
101 | }
102 |
103 | @SuppressLint("UnsafeOptInUsageError")
104 | private fun bindAnalysisUseCase() {
105 | if (cameraProvider == null) {
106 | return
107 | }
108 | cameraProvider?.unbind(analysisUseCase)
109 | imageProcessor?.stop()
110 | imageProcessor = BarcodeScannerProcessor(
111 | callback, drawOverlay, drawBanner, focusBoxSize, supportedBarcodeFormats
112 | )
113 |
114 | val builder = ImageAnalysis.Builder()
115 | builder.setTargetResolution(targetResolution)
116 | analysisUseCase = builder.build()
117 |
118 | needUpdateGraphicOverlayImageSourceInfo = true
119 |
120 | analysisUseCase?.setAnalyzer(
121 | // imageProcessor.processImageProxy will use another thread to run the detection underneath,
122 | // thus we can just runs the analyzer itself on main thread.
123 | ContextCompat.getMainExecutor(context)
124 | ) { imageProxy: ImageProxy ->
125 | if (needUpdateGraphicOverlayImageSourceInfo) {
126 | val rotationDegrees = imageProxy.imageInfo.rotationDegrees
127 | if (rotationDegrees == 0 || rotationDegrees == 180) {
128 | graphicOverlay.setImageSourceInfo(imageProxy.width, imageProxy.height, false)
129 | } else {
130 | graphicOverlay.setImageSourceInfo(imageProxy.height, imageProxy.width, false)
131 | }
132 | needUpdateGraphicOverlayImageSourceInfo = false
133 | }
134 |
135 | try {
136 | imageProcessor?.processImageProxy(imageProxy, graphicOverlay)
137 | } catch (e: MlKitException) {
138 | Log.e("TAG", "Failed to process image. Error: " + e.localizedMessage)
139 | }
140 | }
141 | cameraProvider?.bindToLifecycle(lifecycleOwner, cameraSelector, analysisUseCase)
142 | }
143 |
144 | override fun onPause(owner: LifecycleOwner) {
145 | imageProcessor?.stop()
146 | super.onPause(owner)
147 | }
148 |
149 | override fun onResume(owner: LifecycleOwner) {
150 | bindAllCameraUseCases()
151 | super.onResume(owner)
152 | }
153 |
154 | override fun onDestroy(owner: LifecycleOwner) {
155 | imageProcessor?.stop()
156 | lifecycleOwner.lifecycle.removeObserver(this)
157 | super.onDestroy(owner)
158 | }
159 | }
160 |
161 | /**
162 | * Listen to new scanned barcodes
163 | */
164 | fun interface MLBarcodeCallback {
165 | /**
166 | * @param displayValue Returns barcode value in a user-friendly format.
167 | * This method may omit some of the information encoded in the barcode. For example, if getRawValue() returns 'MEBKM:TITLE:Google;URL://www.google.com;;', the display value might be '//www.google.com'.
168 | * This value may be multiline, for example, when line breaks are encoded into the original TEXT barcode value. May include the supplement value.
169 | *
170 | * @param rawValue Returns barcode value as it was encoded in the barcode. Structured values are not parsed, for example: 'MEBKM:TITLE:Google;URL://www.google.com;;'.
171 | */
172 | fun onNewBarcodeScanned(displayValue: String, rawValue: String)
173 | }
174 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/ScopedExecutor.java:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner;
2 |
3 | import androidx.annotation.NonNull;
4 |
5 | import java.util.concurrent.Executor;
6 | import java.util.concurrent.atomic.AtomicBoolean;
7 |
8 | /**
9 | * Wraps an existing executor to provide a {@link #shutdown} method that allows subsequent
10 | * cancellation of submitted runnables.
11 | */
12 | class ScopedExecutor implements Executor {
13 |
14 | private final Executor executor;
15 | private final AtomicBoolean shutdown = new AtomicBoolean();
16 |
17 | public ScopedExecutor(@NonNull Executor executor) {
18 | this.executor = executor;
19 | }
20 |
21 | @Override
22 | public void execute(@NonNull Runnable command) {
23 | // Return early if this object has been shut down.
24 | if (shutdown.get()) {
25 | return;
26 | }
27 | executor.execute(
28 | () -> {
29 | // Check again in case it has been shut down in the mean time.
30 | if (shutdown.get()) {
31 | return;
32 | }
33 | command.run();
34 | });
35 | }
36 |
37 | /**
38 | * After this method is called, no runnables that have been submitted or are subsequently
39 | * submitted will start to execute, turning this executor into a no-op.
40 | *
41 | * Runnables that have already started to execute will continue.
42 | */
43 | public void shutdown() {
44 | shutdown.set(true);
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/VisionImageProcessor.kt:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner
2 |
3 | import androidx.camera.core.ImageProxy
4 | import com.google.mlkit.common.MlKitException
5 |
6 | /**
7 | * An interface to process the images with different vision detectors and custom image models.
8 | */
9 | internal interface VisionImageProcessor {
10 | /**
11 | * Processes ImageProxy image data, e.g. used for CameraX live preview case.
12 | */
13 | @Throws(MlKitException::class)
14 | fun processImageProxy(image: ImageProxy, graphicOverlay: GraphicOverlay)
15 |
16 | /**
17 | * Stops the underlying machine learning model and release resources.
18 | */
19 | fun stop()
20 | }
--------------------------------------------------------------------------------
/lib/src/main/java/com/buildtoapp/mlbarcodescanner/VisionProcessorBase.kt:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner
2 |
3 | import android.content.Context
4 | import android.graphics.Bitmap
5 | import androidx.annotation.GuardedBy
6 | import androidx.camera.core.ExperimentalGetImage
7 | import androidx.camera.core.ImageProxy
8 | import com.google.android.gms.tasks.Task
9 | import com.google.android.gms.tasks.TaskExecutors
10 | import com.google.android.gms.tasks.Tasks
11 | import com.google.android.odml.image.MediaMlImageBuilder
12 | import com.google.android.odml.image.MlImage
13 | import com.google.mlkit.common.MlKitException
14 | import com.google.mlkit.vision.common.InputImage
15 | import java.nio.ByteBuffer
16 |
17 | /**
18 | * Abstract base class for ML Kit frame processors. Subclasses need to implement {@link
19 | * #onSuccess(T, FrameMetadata, GraphicOverlay)} to define what they want to with the detection
20 | * results and {@link #detectInImage(VisionImage)} to specify the detector object.
21 | *
22 | * @param The type of the detected feature.
23 | */
24 | internal abstract class VisionProcessorBase : VisionImageProcessor {
25 |
26 | private val executor = ScopedExecutor(TaskExecutors.MAIN_THREAD)
27 |
28 | // Whether this processor is already shut down
29 | private var isShutdown = false
30 |
31 | // To keep the latest images and its metadata.
32 | @GuardedBy("this")
33 | private var latestImage: ByteBuffer? = null
34 | @GuardedBy("this")
35 | private var latestImageMetaData: FrameMetadata? = null
36 |
37 | // To keep the images and metadata in process.
38 | @GuardedBy("this")
39 | private var processingImage: ByteBuffer? = null
40 | @GuardedBy("this")
41 | private var processingMetaData: FrameMetadata? = null
42 |
43 | @ExperimentalGetImage
44 | override fun processImageProxy(image: ImageProxy, graphicOverlay: GraphicOverlay) {
45 | if (isShutdown) {
46 | return
47 | }
48 | val bitmap: Bitmap? = BitmapUtils.getBitmap(image)
49 | val mediaImage = image.image ?: error("image should not be null here")
50 |
51 | if (isMlImageEnabled(graphicOverlay.context)) {
52 | val mlImage =
53 | MediaMlImageBuilder(mediaImage).setRotation(image.imageInfo.rotationDegrees).build()
54 | requestDetectInImage(
55 | mlImage,
56 | graphicOverlay,
57 | bitmap
58 | )
59 | // When the image is from CameraX analysis use case, must call image.close() on received
60 | // images when finished using them. Otherwise, new images may not be received or the camera
61 | // may stall.
62 | // Currently MlImage doesn't support ImageProxy directly, so we still need to call
63 | // ImageProxy.close() here.
64 | .addOnCompleteListener { image.close() }
65 |
66 | return
67 | }
68 |
69 | requestDetectInImage(
70 | InputImage.fromMediaImage(mediaImage, image.imageInfo.rotationDegrees),
71 | graphicOverlay,
72 | bitmap
73 | )
74 | // When the image is from CameraX analysis use case, must call image.close() on received
75 | // images when finished using them. Otherwise, new images may not be received or the camera
76 | // may stall.
77 | .addOnCompleteListener { image.close() }
78 | }
79 |
80 | private fun requestDetectInImage(
81 | image: InputImage,
82 | graphicOverlay: GraphicOverlay,
83 | originalCameraImage: Bitmap?
84 | ): Task {
85 | return setUpListener(detectInImage(image), graphicOverlay, originalCameraImage)
86 | }
87 |
88 | private fun requestDetectInImage(
89 | image: MlImage,
90 | graphicOverlay: GraphicOverlay,
91 | originalCameraImage: Bitmap?
92 | ): Task {
93 | return setUpListener(detectInImage(image), graphicOverlay, originalCameraImage)
94 | }
95 |
96 | private fun setUpListener(
97 | task: Task,
98 | graphicOverlay: GraphicOverlay,
99 | originalCameraImage: Bitmap?
100 | ): Task {
101 | return task
102 | .addOnSuccessListener(executor) { results: T ->
103 | graphicOverlay.clear()
104 | if (originalCameraImage != null) {
105 | graphicOverlay.add(CameraImageGraphic(graphicOverlay, originalCameraImage))
106 | }
107 | this@VisionProcessorBase.onSuccess(results, graphicOverlay)
108 | graphicOverlay.postInvalidate()
109 | }
110 | .addOnFailureListener(executor) { e: Exception ->
111 | graphicOverlay.clear()
112 | graphicOverlay.postInvalidate()
113 | this@VisionProcessorBase.onFailure(e)
114 | }
115 | }
116 |
117 | override fun stop() {
118 | executor.shutdown()
119 | isShutdown = true
120 | }
121 |
122 | protected abstract fun detectInImage(image: InputImage): Task
123 |
124 | protected open fun detectInImage(image: MlImage): Task {
125 | return Tasks.forException(
126 | MlKitException(
127 | "MlImage is currently not demonstrated for this feature",
128 | MlKitException.INVALID_ARGUMENT
129 | )
130 | )
131 | }
132 |
133 | protected abstract fun onSuccess(results: T, graphicOverlay: GraphicOverlay)
134 |
135 | protected abstract fun onFailure(e: Exception)
136 |
137 | protected open fun isMlImageEnabled(context: Context?): Boolean {
138 | return false
139 | }
140 | }
141 |
--------------------------------------------------------------------------------
/lib/src/test/java/com/buildtoapp/mlbarcodescanner/ExampleUnitTest.kt:
--------------------------------------------------------------------------------
1 | package com.buildtoapp.mlbarcodescanner
2 |
3 | import org.junit.Test
4 |
5 | import org.junit.Assert.*
6 |
7 | /**
8 | * Example local unit test, which will execute on the development machine (host).
9 | *
10 | * See [testing documentation](http://d.android.com/tools/testing).
11 | */
12 | class ExampleUnitTest {
13 | @Test
14 | fun addition_isCorrect() {
15 | assertEquals(4, 2 + 2)
16 | }
17 | }
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | pluginManagement {
2 | repositories {
3 | gradlePluginPortal()
4 | google()
5 | mavenCentral()
6 | }
7 | }
8 | dependencyResolutionManagement {
9 | repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
10 | repositories {
11 | google()
12 | mavenCentral()
13 | }
14 | }
15 | rootProject.name = "MLBarcodeScanner"
16 | include ':app'
17 | include ':lib'
18 |
--------------------------------------------------------------------------------
8 |
9 | # Usage
10 | ## Dependency
11 | Top level build.gradle
12 | ```groovy
13 | allprojects {
14 | repositories {
15 | maven { url 'https://jitpack.io' }
16 | // other repositories
17 | }
18 | }
19 | ```
20 |
21 | Module level build.gradle
22 | ```groovy
23 | dependencies {
24 | implementation "com.github.javaherisaber:MLBarcodeScanner:1.0.0"
25 | }
26 | ```
27 |
28 | Create your layout
29 | ```xml
30 |