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.
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
0 [or higher] and you’re passing a
1 URI outside your package domain through an
2, then what you’ll get is a
3.
So, Android may throw
3 in Android 7.0 [API level 24] and above, this exception will come when you will expose a
1 URIs outside your package domain through
2.
7 is a special subclass of ContentProvider which allows us to securely share file through a
8 URI instead of
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
7 in order to make sure our
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
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"];
to
Uri photoURI = FileProvider.getUriForFile[context,
context.getApplicationContext[].getPackageName[] + ".provider", file];
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
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.