Lassen Sie den Benutzer crop Bild

Question

Ich habe eine harte Zeit herauszufinden, wie der Benutzer das Bild beschneiden lassen. Ich möchte Bitmap-Variable mit geladenen Bitmap geben, um das Bild zu beschneiden, bevor es als Hintergrundbild festgelegt wird. Aber ich versage es ... Hier ist, dass ich es versucht habe.

Erste Version. = Funktioniert wie erwartet, aber das zurückgegebene Bild hat eine schlechte Auflösung. Das Ändern der Ausgabe auf einen höheren Wert hilft nicht. Wie ich in einem Post gesehen habe, ist es nicht empfehlenswert, die Kamera zu benutzen, da nicht alle Geräte dies unterstützen.

Intent intent = new Intent("com.android.camera.action.CROP"); 
String path = Images.Media.insertImage(context.getContentResolver(), loaded,null, null); 
Uri uri = Uri.parse(path);    
intent.setData(uri); 
intent.putExtra("crop", "true"); 
intent.putExtra("aspectX", 1); 
intent.putExtra("aspectY", 1); 
intent.putExtra("outputX", 300); 
intent.putExtra("outputY", 300); 
intent.putExtra("noFaceDetection", true); 
intent.putExtra("return-data", true);         
startActivityForResult(intent, 2); 

Sekunde. Bildauswahl laden und danach zuschneiden. Wie kann ich das so konfigurieren, dass das Bild direkt auf mein Bild geladen wird? Genau wie in Version 1

Intent photoPickerIntent = new Intent(MediaStore.ACTION_PICK); 
photoPickerIntent.setData(uri); 
photoPickerIntent.putExtra("crop", "true"); 
photoPickerIntent.putExtra(MediaStore.EXTRA_OUTPUT, uri); 
photoPickerIntent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString()); 
startActivityForResult(photoPickerIntent, 2); 

Und onActivity Ergebnis

protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
    if (resultCode != RESULT_OK) { return; } 
    if(requestCode == 2) { 
     Bundle extras = data.getExtras(); 
     if(extras != null) { 
      Bitmap photo = extras.getParcelable("data"); 
      loaded = photo; 
     } 
     WallpaperManager myWallpaperManager = WallpaperManager.getInstance(getApplicationContext()); 

     try { 
      myWallpaperManager.setBitmap(loaded); 
     } catch (IOException e) {} 
    } 
} 

Ich weiß nicht, whever das sind die richtigen Methoden, um dies zu tun, aber ich hoffe, dass jemand mich in die richtige Richtung zeigen könnte. Welches, warum und wie zu verwenden.

Update: ich noch für jemanden warte darauf hinzuweisen, wie man es richtig zu tun, unten Antworten arbeiten aber Bilder in schlechter Auflösung zurückkehren, so dass sie keine Option verwenden

Answer 1

Ich hatte auch die Problem bei der Verwendung der Kamera und ACTION_PICK, dass das zurückgegebene Bild sehr klein war, obwohl die Auflösung viel größer ist. Ich habe um dies die Folge Ernte Bild in einer temporären Datei

// temporary storage location, preferably in your cache directory 
private final String tempFilePath = "somePath"; 

// URI instantiated with your temporary storage location 
private Uri tempuri = Uri.fromFile(new File(tempFilePath)); 

// code for startActivityForResult 
private final static int ACTIVITY_CROP_IMAGE = 1; 

und den Aufruf der Absicht wie diese

Intent photoPickerIntent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI); 
photoPickerIntent.setType("image/*"); 
photoPickerIntent.putExtra("crop", "true"); 
photoPickerIntent.putExtra("aspectX", wallpaperWidth); 
photoPickerIntent.putExtra("aspectY", wallpaperHeight); 
photoPickerIntent.putExtra(MediaStore.EXTRA_OUTPUT, tempuri); 
photoPickerIntent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString()); 
startActivityForResult(photoPickerIntent, ACTIVITY_CROP_IMAGE); 

zu speichern und dann in onActivityResult

protected void onActivityResult(int requestCode, int resultCode, Intent data) 
{ 
    if (resultCode != RESULT_OK) 
     return; 

    if(requestCode == ACTIVITY_CROP_IMAGE) 
    { 
     try 
     { 
      Bitmap bmp = BitmapFactory.decodeFile(tempFilePath); 
      if(bmp != null) 
      { 
       WallpaperManager myWallpaperManager = WallpaperManager.getInstance(getApplicationContext()); 
       myWallpaperManager.setBitmap(bmp); 
      } 
     } 
     catch (IOException e) 
     { 
      e.printStackTrace(); 
     } 
     finally 
     { 
      if(tempFilePath != null) 
      { 
       File tempFile = new File(tempFilePath); 
       if(tempFile.exists()) 
       { 
        tempFile.delete(); 
       } 
      } 
     } 
    } 
} 

Ich konstruierte den obigen Code aus die Spitze meines Kopfes und kompilierte eigentlich nichts davon. Aber die Grundlagen sind richtig, und Sie sollten den Dreh raus ;-)

Answer 2

Zuerst Variablen erhalten:

final int PIC_CROP = 2; 

Uri imageUri; 
Bitmap thePic; 

Bevor Sie ein Bild von Ihrer Kamera oder Ihre Galerie nehmen, setzen Sie Ihr Bild in eine Uri (imageUri) , eine Methode namens innen verwenden hier als "performCrop()" try/catch:

private void performCrop(){ 
     try { 
      Intent intent = new Intent("com.android.camera.action.CROP"); 
      intent.setType("image/*"); 

      List<ResolveInfo> list = getPackageManager().queryIntentActivities(intent, 0); 
      int size = list.size(); 

      if (size >= 0) { 
       intent.setData(imageUri);   
       intent.putExtra("crop", "false"); 
       intent.putExtra("aspectX", 1); 
       intent.putExtra("aspectY", 1); 
       intent.putExtra("outputX", 256); 
       intent.putExtra("outputY", 256); 
       intent.putExtra("scale", true); 
       intent.putExtra("return-data", true); 

       Intent i = new Intent(intent); 
       ResolveInfo res = list.get(0); 
       i.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name)); 

       startActivityForResult(i, PIC_CROP); 
      } 

     } 
     catch(ActivityNotFoundException anfe){ 
      String errorMessage = "Whoops - your device doesn't support the crop action!"; 
      Toast toast = Toast.makeText(this, errorMessage, Toast.LENGTH_SHORT); 
      toast.show(); 
     } 
    } 

Auf Methode onActivityResult:

@Override 
    protected void onActivityResult(int requestCode, int resultCode, Intent intent) { 

     if(requestCode == PIC_CROP){ 

     if (resultCode == RESULT_OK) { 
      Bundle extras = intent.getExtras(); 
      thePic = extras.getParcelable("data"); 
      imageViewPhoto.setImageBitmap(thePic); //in my case, set the image on screen 

     }else{ 
      //do something 
     } 
    } 
} 

Answer 3

Ok Hallo, hier habe ich meinen ganzen Code von Crop Image in Android. Dies ist die globale Variable. Diese

//This For Image Crop 
     /** 
     * Uri for set image crop option . 
     */ 
     private Uri mImageCaptureUri; 
     /** 
     * int for set key and get key from result activity . 
     */ 
     public final int CROP_FROM_CAMERA = 0; 

/** 
    * Bitmap for apply Crop Operation Result. 
    */ 
    private Bitmap _tempOpration; 

    //This is Crop Method. 

/** 
    * Method for apply Crop . 
    * @param filePath - String path of file . 
    */ 
    private void doCrop(String filePath){ 
     try{ 
      //New Flow 
      mImageCaptureUri = Uri.fromFile(new File(filePath)); 

      final ArrayList<CropOption> cropOptions = new ArrayList<CropOption>(); 
      Intent intent = new Intent("com.android.camera.action.CROP"); 
      intent.setType("image/*"); 
      List<ResolveInfo> list = getPackageManager().queryIntentActivities(intent, 0); 

      int size = list.size(); 
      if (size == 0) 
      {   
       Toast.makeText(this, "Can not find image crop app", Toast.LENGTH_SHORT).show(); 
       return; 
      } 
      else 
      { 
       intent.setData(mImageCaptureUri); 
       intent.putExtra("outputX", 300); 
       intent.putExtra("outputY", 300); 
       intent.putExtra("aspectX", 1); 
       intent.putExtra("aspectY", 1); 
       intent.putExtra("scale", true); 
       intent.putExtra("return-data", true); 

       if (size == 1) 
       { 
        Intent i = new Intent(intent); 
        ResolveInfo res = list.get(0); 
        i.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name)); 
        startActivityForResult(i, CROP_FROM_CAMERA); 
       } 

       else 
       { 
        for (ResolveInfo res : list) 
        { 
         final CropOption co = new CropOption(); 
         co.title = getPackageManager().getApplicationLabel(res.activityInfo.applicationInfo); 
         co.icon = getPackageManager().getApplicationIcon(res.activityInfo.applicationInfo); 
         co.appIntent= new Intent(intent); 
         co.appIntent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name)); 
         cropOptions.add(co); 
        } 

        CropOptionAdapter adapter = new CropOptionAdapter(getApplicationContext(), cropOptions); 
        AlertDialog.Builder builder = new AlertDialog.Builder(this); 
        builder.setTitle("Choose Crop App"); 
        builder.setAdapter(adapter, new DialogInterface.OnClickListener() 
        { 
         public void onClick(DialogInterface dialog, int item) 
         { 
          startActivityForResult(cropOptions.get(item).appIntent, CROP_FROM_CAMERA); 
         } 
        }); 

        builder.setOnCancelListener(new DialogInterface.OnCancelListener() 
        { 
         public void onCancel(DialogInterface dialog) 
         { 
          if (mImageCaptureUri != null) 
          { 
           getContentResolver().delete(mImageCaptureUri, null, null); 
           mImageCaptureUri = null; 
          } 
         } 
        }); 
        AlertDialog alert = builder.create(); 
        alert.show(); 
       } 
      } 
     } 
     catch (Exception ex) 
     { 
      genHelper.showErrorLog("Error in Crop Function-->"+ex.toString()); 
     } 
    } 

ist die eine andere Klasse Hexe Verwendung für Fund Crop Aktivität Intent in Anwendung.

CropOption-Klasse.

public class CropOption 
{ 
    public CharSequence title; 
    public Drawable icon; 
    public Intent appIntent; 
} 

dies ist für Anzeige Liste verwenden.

CropOptionAdapter

public class CropOptionAdapter extends ArrayAdapter<CropOption> 
{ 
    private ArrayList<CropOption> mOptions; 
    private LayoutInflater mInflater; 

    public CropOptionAdapter(Context context, ArrayList<CropOption> options) 
    { 
     super(context, R.layout.crop_selector, options); 

     mOptions = options; 

     mInflater = LayoutInflater.from(context); 
    } 

    @Override 
    public View getView(int position, View convertView, ViewGroup group) 
    { 
     if (convertView == null) 
      convertView = mInflater.inflate(R.layout.crop_selector, null); 

     CropOption item = mOptions.get(position); 

     if (item != null) { 
      ((ImageView) convertView.findViewById(R.id.iv_icon)).setImageDrawable(item.icon); 
      ((TextView) convertView.findViewById(R.id.tv_name)).setText(item.title); 

      return convertView; 
     } 

     return null; 
    } 
} 

Layout-Datei Für CropOptionAdapter

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android" 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:padding="10dp" 
    android:gravity="center_vertical"> 

    <ImageView 
     android:id="@+id/iv_icon" 
     android:layout_width="wrap_content" 
     android:layout_height="wrap_content"/> 

    <TextView 
     android:id="@+id/tv_name" 
     android:layout_width="wrap_content" 
     android:layout_height="wrap_content" 
     android:text=""/> 
</LinearLayout> 

Dies ist die resultActivity.witch die Ernte Bild geben.

/** 
    * @see android.app.Activity#onActivityResult(int, int, android.content.Intent) 
    */ 
    @Override 
    protected void onActivityResult(int requestCode, int resultCode, Intent data) 
    { 
     super.onActivityResult(requestCode, resultCode, data); 
     if (resultCode != RESULT_OK) return; 
     switch (requestCode) 
     { 
     case CROP_FROM_CAMERA: 
      if (data == null) 
      { 
       genHelper.showToast("No Crop Activity in This"); 
       return; 
      } 
      final Bundle extras = data.getExtras(); 
      if (extras != null) 
      { 
       try 
       { 

        _tempOpration=extras.getParcelable("data"); 
        imageLayout.setImageBitmap(_tempOpration); 
        _tempOpration=null; 

       } 
       catch (Exception e) 
       { 
        e.printStackTrace(); 
       } 
      } 
      break; 
     } 

    } 

// Ist diese Art Es ist Arbeit auf meinem Live-App.

genHelper.showToast ("Keine Pflanzenaktivität in diesem");

ist meine allgemeine Klasse To Toast Nachricht und Fehlerprotokoll anzeigen zu helfen.

Bestof Glück.

Answer 4

Wie in ähnlichen Threads erwähnt, hat Android keine offizielle Ernteabsicht (https://commonsware.com/blog/2013/01/23/no-android-does-not-have-crop-intent.html), also würde ich bleiben von der Verwendung von "com.android.camera.action.CROP".

In der Zeit, seit diese Frage ursprünglich gestellt wurde, hat Android eine neue API in Kitkat (Level 19) hinzugefügt, die es Benutzern ermöglicht, eine Crop-This-Image-und-Set-as-Wallpaper-Aktivität aufzurufen. Siehe WallpaperManager.getCropAndSetWallpaperIntent(), und dies könnte Ihre ursprüngliche Frage adressieren.