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 com.ddoskify; import android.Manifest; 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.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Matrix; import android.graphics.Paint; import android.os.Bundle; import android.os.Environment; import android.support.annotation.NonNull; import android.support.design.widget.Snackbar; import android.support.v4.app.ActivityCompat; import android.support.v7.app.AppCompatActivity; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.ImageButton; import android.widget.Toast; import com.facebook.FacebookSdk; import com.facebook.appevents.AppEventsLogger; import com.google.android.gms.common.ConnectionResult; import com.google.android.gms.common.GoogleApiAvailability; import com.google.android.gms.vision.CameraSource; import com.google.android.gms.vision.Detector; import com.google.android.gms.vision.MultiProcessor; import com.google.android.gms.vision.Tracker; import com.google.android.gms.vision.face.Face; import com.google.android.gms.vision.face.FaceDetector; import com.ddoskify.ui.camera.CameraSourcePreview; import com.ddoskify.ui.camera.GraphicOverlay; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; /** * Superimposes a graphic on top of a face. For this, we will have Ddoski's face! * * This app supports both a front facing mode and a rear facing mode, which demonstrate different * API functionality trade-offs:<p> * * Front facing mode uses the device's front facing camera to track one user, in a "selfie" fashion. * The settings for the face detector and its associated processing pipeline are set to optimize for * the single face case, where the face is relatively large. These factors allow the face detector * to be faster and more responsive to quick motion.<p> * * Rear facing mode uses the device's rear facing camera to track any number of faces. The settings * for the face detector and its associated processing pipeline support finding multiple faces, and * attempt to find smaller faces in comparison to the front facing mode. But since this requires * more scanning at finer levels of detail, rear facing mode may not be as responsive as front * facing mode.<p> */ public final class CameraOverlayActivity extends AppCompatActivity { public static final String BITMAP_MESSAGE = "bitmap_message"; private static final String TAG = "Ddoskify"; private static final int RC_HANDLE_GMS = 9001; // permission request codes need to be < 256 private static final int RC_HANDLE_CAMERA_PERM = 2; private static final int RC_HANDLE_STORAGE_PERM = 3; private CameraSource mCameraSource = null; private CameraSourcePreview mPreview; private GraphicOverlay mGraphicOverlay; private Button mTakePictureButton; private boolean mIsFrontFacing = true; private ArrayList<FaceTracker> mFaces; //============================================================================================== // Activity Methods //============================================================================================== /** * Initializes the UI and initiates the creation of a face detector. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); FacebookSdk.sdkInitialize(getApplicationContext()); AppEventsLogger.activateApp(this); mPreview = (CameraSourcePreview) findViewById(R.id.preview); mGraphicOverlay = (GraphicOverlay) findViewById(R.id.faceOverlay); mFaces = new ArrayList<FaceTracker>(); final ImageButton button = (ImageButton) findViewById(R.id.flipButton); button.setOnClickListener(mFlipButtonListener); if (savedInstanceState != null) { mIsFrontFacing = savedInstanceState.getBoolean("IsFrontFacing"); } mTakePictureButton = (Button) findViewById(R.id.takePictureButton); mTakePictureButton.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { Log.e("CameraOverlay", "Button has been pressed"); mCameraSource.takePicture(new CameraSource.ShutterCallback() { @Override public void onShutter() { // mCameraSource.stop(); Snackbar.make(findViewById(android.R.id.content), "Picture Taken!", Snackbar.LENGTH_SHORT) .setActionTextColor(Color.BLACK).show(); } }, new CameraSource.PictureCallback() { public void onPictureTaken(byte[] data) { int re = ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.WRITE_EXTERNAL_STORAGE); if (!isStorageAllowed()) { requestStoragePermission(); } File pictureFile = getOutputMediaFile(); if (pictureFile == null) { return; } try { Bitmap picture = BitmapFactory.decodeByteArray(data, 0, data.length); Bitmap resizedBitmap = Bitmap.createBitmap(mGraphicOverlay.getWidth(), mGraphicOverlay.getHeight(), picture.getConfig()); Canvas canvas = new Canvas(resizedBitmap); Matrix matrix = new Matrix(); matrix.setScale((float) resizedBitmap.getWidth() / (float) picture.getWidth(), (float) resizedBitmap.getHeight() / (float) picture.getHeight()); if (mIsFrontFacing) { // mirror by inverting scale and translating matrix.preScale(-1, 1); matrix.postTranslate(canvas.getWidth(), 0); } Paint paint = new Paint(); canvas.drawBitmap(picture, matrix, paint); mGraphicOverlay.draw(canvas); // make those accessible FileOutputStream fos = new FileOutputStream(pictureFile); resizedBitmap.compress(Bitmap.CompressFormat.JPEG, 80, fos); fos.close(); Intent intent = new Intent(getApplicationContext(), PhotoReviewActivity.class); intent.putExtra(BITMAP_MESSAGE, pictureFile.toString()); startActivity(intent); Log.d("CameraOverlay", "Starting PhotoReviewActivity " + pictureFile.toString()); } catch (FileNotFoundException e) { Log.e("CameraOverlay", e.toString()); } catch (IOException e) { Log.e("CameraOverlay", e.toString()); } } }); } }); // Check for the camera permission before accessing the camera. If the // permission is not granted yet, request permission. int rc = ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA); if (rc == 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() { Log.w(TAG, "Camera permission is not granted. Requesting permission"); final String[] permissions = new String[] { Manifest.permission.CAMERA }; if (!ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) { ActivityCompat.requestPermissions(this, permissions, RC_HANDLE_CAMERA_PERM); return; } final Activity thisActivity = this; View.OnClickListener listener = new View.OnClickListener() { @Override public void onClick(View view) { ActivityCompat.requestPermissions(thisActivity, permissions, RC_HANDLE_CAMERA_PERM); } }; Snackbar.make(mGraphicOverlay, R.string.permission_camera_rationale, Snackbar.LENGTH_INDEFINITE) .setAction(R.string.ok, listener).show(); } /** * Restarts the camera. */ @Override protected void onResume() { super.onResume(); startCameraSource(); } /** * Stops the camera. */ @Override protected void onPause() { super.onPause(); mPreview.stop(); } /** * Releases the resources associated with the camera source, the associated detector, and the * rest of the processing pipeline. */ @Override protected void onDestroy() { super.onDestroy(); if (mCameraSource != null) { mCameraSource.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 != RC_HANDLE_CAMERA_PERM) { Log.d(TAG, "Got unexpected permission result: " + requestCode); super.onRequestPermissionsResult(requestCode, permissions, grantResults); return; } if (grantResults.length != 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Log.d(TAG, "Camera permission granted - initialize the camera source"); // we have permission, so create the camerasource createCameraSource(); return; } Log.e(TAG, "Permission not granted: results len = " + grantResults.length + " Result code = " + (grantResults.length > 0 ? grantResults[0] : "(empty)")); DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { finish(); } }; AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Face Tracker sample").setMessage(R.string.no_camera_permission) .setPositiveButton(R.string.ok, listener).show(); } //============================================================================================== // UI //============================================================================================== /** * Saves the camera facing mode, so that it can be restored after the device is rotated. */ @Override public void onSaveInstanceState(Bundle savedInstanceState) { super.onSaveInstanceState(savedInstanceState); savedInstanceState.putBoolean("IsFrontFacing", mIsFrontFacing); } /** * Toggles between front-facing and rear-facing modes. */ private View.OnClickListener mFlipButtonListener = new View.OnClickListener() { public void onClick(View v) { mIsFrontFacing = !mIsFrontFacing; if (mCameraSource != null) { mCameraSource.release(); mCameraSource = null; } createCameraSource(); startCameraSource(); } }; //============================================================================================== // Detector //============================================================================================== /** * Creates the face detector and associated processing pipeline to support either front facing * mode or rear facing mode. Checks if the detector is ready to use, and displays a low storage * warning if it was not possible to download the face library. */ @NonNull private FaceDetector createFaceDetector(Context context) { // For both front facing and rear facing modes, the detector is initialized to do landmark // detection (to find the eyes), classification (to determine if the eyes are open), and // tracking. // // Use of "fast mode" enables faster detection for frontward faces, at the expense of not // attempting to detect faces at more varied angles (e.g., faces in profile). Therefore, // faces that are turned too far won't be detected under fast mode. // // For front facing mode only, the detector will use the "prominent face only" setting, // which is optimized for tracking a single relatively large face. This setting allows the // detector to take some shortcuts to make tracking faster, at the expense of not being able // to track multiple faces. // // Setting the minimum face size not only controls how large faces must be in order to be // detected, it also affects performance. Since it takes longer to scan for smaller faces, // we increase the minimum face size for the rear facing mode a little bit in order to make // tracking faster (at the expense of missing smaller faces). But this optimization is less // important for the front facing case, because when "prominent face only" is enabled, the // detector stops scanning for faces after it has found the first (large) face. FaceDetector detector = new FaceDetector.Builder(context).setLandmarkType(FaceDetector.ALL_LANDMARKS) .setClassificationType(FaceDetector.ALL_CLASSIFICATIONS).setTrackingEnabled(true) .setMode(FaceDetector.FAST_MODE).setProminentFaceOnly(false).setMinFaceSize(0.10f).build(); Detector.Processor<Face> processor; // For rear facing mode, a factory is used to create per-face tracker instances. A // tracker is created for each face and is maintained as long as the same face is // visible, enabling per-face state to be maintained over time. This is used to store // the iris position and velocity for each face independently, simulating the motion of // the eyes of any number of faces over time. // // Both the front facing mode and the rear facing mode use the same tracker // implementation, avoiding the need for any additional code. The only difference // between these cases is the choice of Processor: one that is specialized for tracking // a single face or one that can handle multiple faces. Here, we use MultiProcessor, // which is a standard component of the mobile vision API for managing multiple items. // Always use multiple face detection MultiProcessor.Factory<Face> factory = new MultiProcessor.Factory<Face>() { @Override public Tracker<Face> create(Face face) { FaceTracker f = new FaceTracker(mGraphicOverlay, getBaseContext(), mIsFrontFacing); mFaces.add(f); return f; } }; processor = new MultiProcessor.Builder<>(factory).build(); detector.setProcessor(processor); if (!detector.isOperational()) { // Note: The first time that an app using face API is installed on a device, GMS will // download a native library 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 faces. // // isOperational() can be used to check if the required native library is currently // available. The detector will automatically become operational once the library // download completes on device. Log.w(TAG, "Face detector dependencies are not yet available."); // 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, R.string.low_storage_error, Toast.LENGTH_LONG).show(); Log.w(TAG, getString(R.string.low_storage_error)); } } return detector; } //============================================================================================== // Camera Source //============================================================================================== /** * Creates the face detector and the camera. */ private void createCameraSource() { Context context = getApplicationContext(); FaceDetector detector = createFaceDetector(context); int facing = CameraSource.CAMERA_FACING_FRONT; if (!mIsFrontFacing) { facing = CameraSource.CAMERA_FACING_BACK; } // The camera source is initialized to use either the front or rear facing camera. We use a // relatively low resolution for the camera preview, since this is sufficient for this app // and the face detector will run faster at lower camera resolutions. // // However, note that there is a speed/accuracy trade-off with respect to choosing the // camera resolution. The face detector will run faster with lower camera resolutions, // but may miss smaller faces, landmarks, or may not correctly detect eyes open/closed in // comparison to using higher camera resolutions. If you have any of these issues, you may // want to increase the resolution. mCameraSource = new CameraSource.Builder(context, detector).setFacing(facing) .setRequestedPreviewSize(1000, 750).setRequestedFps(15.0f).setAutoFocusEnabled(true).build(); } /** * 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() { // 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, RC_HANDLE_GMS); dlg.show(); } if (mCameraSource != null) { try { mPreview.start(mCameraSource, mGraphicOverlay); } catch (IOException e) { Log.e(TAG, "Unable to start camera source.", e); mCameraSource.release(); mCameraSource = null; } } } private static File getOutputMediaFile() { File mediaStorageDir = new File( Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "ddoskify"); if (!mediaStorageDir.exists()) { if (!mediaStorageDir.mkdirs()) { Log.e("Ddoski", "failed to create directory " + mediaStorageDir.toString()); return null; } } // Create a media file name String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); File mediaFile; mediaFile = new File(mediaStorageDir.getPath() + File.separator + "IMG_" + timeStamp + ".jpg"); return mediaFile; } private boolean isStorageAllowed() { //Getting the permission status int result = ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.WRITE_EXTERNAL_STORAGE); return result == PackageManager.PERMISSION_GRANTED; } //Requesting permission private void requestStoragePermission() { if (ActivityCompat.shouldShowRequestPermissionRationale(this, android.Manifest.permission.WRITE_EXTERNAL_STORAGE)) { //If the user has denied the permission previously your code will come to this block //Here you can explain why you need this permission //Explain here why you need this permission } final String[] permissions = new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE }; if (!ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) { ActivityCompat.requestPermissions(this, permissions, RC_HANDLE_CAMERA_PERM); final Activity thisActivity = this; View.OnClickListener listener = new View.OnClickListener() { @Override public void onClick(View view) { ActivityCompat.requestPermissions(thisActivity, permissions, RC_HANDLE_STORAGE_PERM); } }; Snackbar.make(mGraphicOverlay, R.string.permission_camera_rationale, Snackbar.LENGTH_INDEFINITE) .setAction(R.string.ok, listener).show(); return; } } }