Java tutorial
/* * Copyright (C) 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 io.github.marcelbraghetto.alexandria.features.scanner.ui; import android.Manifest; import android.annotation.SuppressLint; import android.app.Activity; import android.app.AlertDialog; import android.app.Dialog; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.IntentFilter; import android.content.pm.PackageManager; import android.graphics.Point; import android.hardware.Camera; import android.os.Bundle; import android.support.annotation.NonNull; import android.support.design.widget.Snackbar; import android.support.v4.app.ActivityCompat; import android.view.View; import android.widget.Toast; import com.google.android.gms.common.ConnectionResult; import com.google.android.gms.common.GoogleApiAvailability; import com.google.android.gms.common.api.CommonStatusCodes; import com.google.android.gms.vision.MultiProcessor; import com.google.android.gms.vision.barcode.Barcode; import com.google.android.gms.vision.barcode.BarcodeDetector; import java.io.IOException; import javax.inject.Inject; import io.github.marcelbraghetto.alexandria.R; import io.github.marcelbraghetto.alexandria.framework.application.MainApp; import io.github.marcelbraghetto.alexandria.framework.providers.device.contracts.DeviceUtilsProvider; import io.github.marcelbraghetto.alexandria.framework.providers.strings.contracts.AppStringsProvider; import io.github.marcelbraghetto.alexandria.framework.ui.BaseActivity; /** * Note from Marcel: I did not author the original activity - it came * from Google's samples for bar code scanning. I did however modify * the code somewhat to fit my needs - it could probably do with a * heap more refactoring to make it nicer to use. */ /** * Activity for the multi-tracker app. This app detects barcodes and displays the value with the * rear facing camera. During detection overlay graphics are drawn to indicate the position, * size, and ID of each barcode. */ public final class ScannerActivity extends BaseActivity { public static final int SCANNER_REQUEST_CODE = 1111; public static final String BARCODE_RESULT = "SABR"; private static final int RESULT_CODE_MISSING_GOOGLE_PLAY_SERVICES = 9001; private static final int PERMISSION_REQUEST_CAMERA = 2; private CameraSource mCameraSource; private CameraSourcePreview mPreview; @Inject DeviceUtilsProvider mDeviceUtilsProvider; @Inject AppStringsProvider mAppStringsProvider; /** * Initializes the UI and creates the detector pipeline. */ @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); MainApp.getDagger().inject(this); Point windowSize = mDeviceUtilsProvider.getWindowSizePx(); int windowWidth; int windowHeight; if (mDeviceUtilsProvider.isPortrait()) { windowWidth = (int) (windowSize.x * 0.8); windowHeight = (int) (windowSize.y * 0.5); } else { windowWidth = (int) (windowSize.x * 0.5); windowHeight = (int) (windowSize.y * 0.8); } setupFloatingWindow(windowWidth, windowHeight); setContentView(R.layout.scanner_activity); mPreview = (CameraSourcePreview) findViewById(R.id.scanner_preview); // Check for the camera permission before accessing the camera. If the // permission is not granted yet, request permission. int permission = ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA); if (permission == PackageManager.PERMISSION_GRANTED) { createCameraSource(); } else { requestCameraPermission(); } } /** * Handles the requesting of the camera permission. This includes * showing a "Snackbar" message of why the permission is needed then * sending the request. */ private void requestCameraPermission() { final String[] permissions = new String[] { Manifest.permission.CAMERA }; if (!ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) { ActivityCompat.requestPermissions(this, permissions, PERMISSION_REQUEST_CAMERA); return; } final Activity thisActivity = this; View.OnClickListener listener = new View.OnClickListener() { @Override public void onClick(View view) { ActivityCompat.requestPermissions(thisActivity, permissions, PERMISSION_REQUEST_CAMERA); } }; Snackbar.make(mPreview, mAppStringsProvider.getString(R.string.scanner_enable_permissions_message), Snackbar.LENGTH_INDEFINITE).setAction(mAppStringsProvider.getString(R.string.ok), listener).show(); } /** * Creates and starts the camera. Note that this uses a higher resolution in comparison * to other detection examples to enable the barcode detector to detect small barcodes * at long distances. * * Suppressing InlinedApi since there is a check that the minimum version is met before using * the constant. */ @SuppressLint("InlinedApi") private void createCameraSource() { Context context = getApplicationContext(); // A barcode detector is created to track barcodes. An associated multi-processor instance // is set to receive the barcode detection results, track the barcodes, and maintain // graphics for each barcode on screen. The factory is used by the multi-processor to // create a separate tracker instance for each barcode. BarcodeDetector barcodeDetector = new BarcodeDetector.Builder(context).build(); BarcodeTrackerFactory barcodeFactory = new BarcodeTrackerFactory(); barcodeDetector.setProcessor(new MultiProcessor.Builder<>(barcodeFactory).build()); barcodeFactory.setDelegate(new BarcodeTrackerFactory.BarcodeDetectionDelegate() { @Override public void barCodeDetected(@NonNull Barcode barcode) { Intent data = new Intent(); data.putExtra(BARCODE_RESULT, barcode); setResult(CommonStatusCodes.SUCCESS, data); finish(); } }); if (!barcodeDetector.isOperational()) { // Note: The first time that an app using the barcode or face API is installed on a // device, GMS will download a native libraries to the device in order to do detection. // Usually this completes before the app is run for the first time. But if that // download has not yet completed, then the above call will not detect any barcodes // and/or faces. // // isOperational() can be used to check if the required native libraries are currently // available. The detectors will automatically become operational once the library // downloads complete on device. // Check for low storage. If there is low storage, the native library will not be // downloaded, so detection will not become operational. IntentFilter lowstorageFilter = new IntentFilter(Intent.ACTION_DEVICE_STORAGE_LOW); boolean hasLowStorage = registerReceiver(null, lowstorageFilter) != null; if (hasLowStorage) { Toast.makeText(this, mAppStringsProvider.getString(R.string.scanner_device_storage_low), Toast.LENGTH_LONG).show(); } } // Creates and starts the camera. Note that this uses a higher resolution in comparison // to other detection examples to enable the barcode detector to detect small barcodes // at long distances. CameraSource.Builder builder = new CameraSource.Builder(getApplicationContext(), barcodeDetector) .setFacing(CameraSource.CAMERA_FACING_BACK).setRequestedPreviewSize(1600, 1024) .setRequestedFps(30.0f); // make sure that auto focus is an available option if (mDeviceUtilsProvider.isAtLeastIceCreamSandwich()) { builder = builder.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE); } mCameraSource = builder.build(); } /** * Restarts the camera. */ @Override protected void onResume() { super.onResume(); startCameraSource(); } /** * Stops the camera. */ @Override protected void onPause() { super.onPause(); if (mPreview != null) { mPreview.stop(); } } /** * Releases the resources associated with the camera source, the associated detectors, and the * rest of the processing pipeline. */ @Override protected void onDestroy() { super.onDestroy(); if (mPreview != null) { mPreview.release(); } } /** * Callback for the result from requesting permissions. This method * is invoked for every call on {@link #requestPermissions(String[], int)}. * <p> * <strong>Note:</strong> It is possible that the permissions request interaction * with the user is interrupted. In this case you will receive empty permissions * and results arrays which should be treated as a cancellation. * </p> * * @param requestCode The request code passed in {@link #requestPermissions(String[], int)}. * @param permissions The requested permissions. Never null. * @param grantResults The grant results for the corresponding permissions * which is either {@link PackageManager#PERMISSION_GRANTED} * or {@link PackageManager#PERMISSION_DENIED}. Never null. * @see #requestPermissions(String[], int) */ @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { if (requestCode != PERMISSION_REQUEST_CAMERA) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); return; } if (grantResults.length != 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { createCameraSource(); return; } AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle(mAppStringsProvider.getString(R.string.scanner_enable_permissions_title)) .setMessage(mAppStringsProvider.getString(R.string.scanner_enable_permissions_message)) .setPositiveButton(mAppStringsProvider.getString(R.string.ok), new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { finish(); } }) .show(); } /** * Starts or restarts the camera source, if it exists. If the camera source doesn't exist yet * (e.g., because onResume was called before the camera source was created), this will be called * again when the camera source is created. */ private void startCameraSource() throws SecurityException { // check that the device has play services available. int code = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(getApplicationContext()); if (code != ConnectionResult.SUCCESS) { Dialog dlg = GoogleApiAvailability.getInstance().getErrorDialog(this, code, RESULT_CODE_MISSING_GOOGLE_PLAY_SERVICES); dlg.show(); return; } if (mCameraSource != null) { try { mPreview.start(mCameraSource); } catch (IOException e) { mCameraSource.release(); mCameraSource = null; } } } }