Android crop bitmap on top corners of image năm 2024

In this section I'll show how to crop image via rectangle shape using Android-Image-Cropper and image from camera.

To get picture from Camera and write access to disk I'm going to use EasyPermissions.

Add the below line in your module’s build.gradle file:

dependencies {

...
implementation 'pub.devrel:easypermissions:1.2.0'
implementation 'com.theartofdev.edmodo:android-image-cropper:2.7.0'

Add permissions and

9 into your AndroidManifest.xml

Following is layout for MainActivity.

android:layout_width="match_parent" android:layout_height="match_parent">

Following is MainActivity.

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

Android 7.0 Nougat introduced some file system permission changes in order to improve security. If you’ve already updated your app to

android:layout_width="match_parent" android:layout_height="match_parent">

0 (or higher) and you’re passing a

android:layout_width="match_parent" android:layout_height="match_parent">

1 URI outside your package domain through an

android:layout_width="match_parent" android:layout_height="match_parent">

2, then what you’ll get is a

android:layout_width="match_parent" android:layout_height="match_parent">

3.

So, Android may throw

android:layout_width="match_parent" android:layout_height="match_parent">

3 in Android 7.0 (API level 24) and above, this exception will come when you will expose a

android:layout_width="match_parent" android:layout_height="match_parent">

1 URIs outside your package domain through

android:layout_width="match_parent" android:layout_height="match_parent">

2.

android:layout_width="match_parent" android:layout_height="match_parent">

7 is a special subclass of ContentProvider which allows us to securely share file through a

android:layout_width="match_parent" android:layout_height="match_parent">

8 URI instead of

android:layout_width="match_parent" android:layout_height="match_parent">

1 one. Why is this a better approach? Because you’re granting a temporary access to the file, which will be available for the receiver activity or service until they are active/running.

We create our own class inheriting

android:layout_width="match_parent" android:layout_height="match_parent">

7 in order to make sure our

android:layout_width="match_parent" android:layout_height="match_parent">

7 doesn't conflict with

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

2 declared in imported dependencies as described here.

Add a class extending

android:layout_width="match_parent" android:layout_height="match_parent">

7

public class GenericFileProvider extends FileProvider {}

Next, add the

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

4 in our AndroidManifest.xml:

...

    ...
    
        
    
    ...

We’re going to set

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

5 to

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

6 because we don’t need it to be public,

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

7 to

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

8 because it will grant temporary access to files and

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

private ImageView iv;
private File file;
private Uri uri;
private Activity activity = MainActivity.this;
private String TAG = MainActivity.class.getSimpleName();
private String PERM_RATIONALE = "This app needs access to your camera.";
private static final int RC_SETTINGS = 126;
private static final int RC_PERM_CAMERA_STORAGE = 127;
private static final int CAMERA_TAKE_REQUEST = 200;
private String[] wantedPerms = {Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE};
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    iv = findViewById(R.id.iv);
    if (!EasyPermissions.hasPermissions(activity, wantedPerms)) {
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(requestCode){
        case CAMERA_TAKE_REQUEST:
            CropImage.activity(android.net.Uri.parse(file.toURI().toString()))
                    .setAspectRatio(1,1)
                    .setFixAspectRatio(true)
                    .start(activity);
            break;
        case CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE:
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == RESULT_OK) {
                iv.setImageURI(result.getUri());
            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Log.d(TAG, "onActivityResult: " + error.getMessage());
            }
            break;
    }
}
//
// Permissions
//
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@Override
public void onPermissionsGranted(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsGranted:" + requestCode + ":" + perms.size());
}
@Override
public void onPermissionsDenied(int requestCode, List perms) {
    Log.d(TAG, "onPermissionsDenied:" + requestCode + ":" + perms.size());
    if (EasyPermissions.somePermissionPermanentlyDenied(activity, perms)) {
        new AppSettingsDialog.Builder(activity)
                .setTitle("Permissions Required")
                .setPositiveButton("Settings")
                .setNegativeButton("Cancel")
                .setRequestCode(RC_SETTINGS)
                .build()
                .show();
    }
}
@AfterPermissionGranted(RC_PERM_CAMERA_STORAGE)
private void afterCameraStoragePermission() {
    if (EasyPermissions.hasPermissions(this, wantedPerms)) {
        Log.d(TAG, "Already have permission, do the thing");
    } else {
        Log.d(TAG, "Do not have permission, request them now");
        EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
            RC_PERM_CAMERA_STORAGE, wantedPerms);
    }
}
//
// Camera
//
@TargetApi(Build.VERSION_CODES.M)
public void take(View v) {
    if(checkCameraExists()) {
        if (EasyPermissions.hasPermissions(activity, wantedPerms)) {
            launchCamera();
        } else {
            EasyPermissions.requestPermissions(activity, PERM_RATIONALE, 
               RC_PERM_CAMERA_STORAGE, wantedPerms);
        }
    } else {
        Toast.makeText(activity, "Camera not available.", Toast.LENGTH_SHORT).show();
    }
}
public boolean checkCameraExists() {
    return activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
private void launchCamera() {
    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    file = new File(Environment.getExternalStorageDirectory(), 
        String.valueOf(System.currentTimeMillis()) + ".jpg");
    uri = FileProvider.getUriForFile(activity, 
        activity.getApplicationContext().getPackageName() + ".provider", file);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    startActivityForResult(intent, CAMERA_TAKE_REQUEST);
}

}

9 to a domain you control, so if your domain is

public class GenericFileProvider extends FileProvider {}

0 then you can use something like

public class GenericFileProvider extends FileProvider {}

1. The authority of a provider should be unique and that’s the reason why we are using our application ID plus something like .provider.

Then we need to create the

public class GenericFileProvider extends FileProvider {}

2 in the

public class GenericFileProvider extends FileProvider {}

3 folder. That’s the file which defines the folders which contain the files you will be allowed to share safely. In our case we just need access to the external storage folder:

The final step is to change the line of code below in

File file = new File(Environment.getExternalStorageDirectory(),

String.valueOf(System.currentTimeMillis()) + ".jpg");

Uri photoURI = Uri.fromFile(file);

to

Uri photoURI = FileProvider.getUriForFile(context,

context.getApplicationContext().getPackageName() + ".provider", file);

If you're using an

android:layout_width="match_parent" android:layout_height="match_parent">

2 to make the system open your file, you may need to add the following line of code:

intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

Instead of using

public class GenericFileProvider extends FileProvider {}

5 we create our URI with

public class GenericFileProvider extends FileProvider {}

6 which will generate a new

android:layout_width="match_parent" android:layout_height="match_parent">

8 URI with the authority defined pointing to the file we passed in.

Result

Other useful libs for image crop:

• uCrop
• SimpleCropView
• cropiwa

Crop image via custom shape from bitmap

Sometimes you want to crop a bitmap, but it’s not an ordinary cropping, it’s a cropping to get rounded corners, cropping to get it as a circle, cropping to get it as a star, or cropping to get it as any shape.

In this post, we will crop a heart from an Android bitmap.

At first get a bitmap to crop a shape from it.

0

Create an empty and mutable bitmap with the same height and width of the source.

1

Create a canvas with the mutable bitmap to draw into.

2

Create a paint with any solid color, this color is for drawing a heart which you want to crop from the bitmap.

3

Draw a heart path at the center of the canvas.

4

In our case, the heart shape which you have drawn is called the destination image, it’s the shape which you want to crop from the bitmap.

The magic will be in the next line of code, set the transfer mode which defines how source pixels are composited or merged with the destination pixels.

5

Draw the source image on the canvas which has the destination image and use the paint with the

public class GenericFileProvider extends FileProvider {}

8 transformation mode.

How to set bitmap image in Android?

Creating a Bitmap from a View in Android is a common task that involves the following steps:.

Step 1: Create a Bitmap. A Bitmap is an image representation that consists of pixels with a specified width, height, and color format. ... .

Step 2: Create a Canvas. ... .

Step 3: Draw the View on the Canvas. ... .

Step 4: Return the Bitmap..

How to cut a bitmap in CorelDraw?

You can also quickly crop a bitmap into a rectangular shape by using the Crop tool . For information about the Crop tool, see To crop an object or imported photo. You can also crop a selected bitmap after you drag the corner nodes by clicking the Pick tool , then clicking the Crop bitmap button on the property bar.