Android-Kamera: Datenabsicht gibt null zurück

Ich habe eine Android-Anwendung, die mehrere Aktivitäten enthält.

In einem von ihnen verwende ich eine Taste, die die Gerätekamera aufruft:

public void onClick(View view) {
    Intent photoIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    startActivityForResult(photoIntent, IMAGE_CAPTURE);
}

In derselben Aktivität rufe ich die OnActivityResultMethode für das Bildergebnis auf:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == IMAGE_CAPTURE) {
        if (resultCode == RESULT_OK) {
            Bitmap image = (Bitmap) data.getExtras().get("data");
            ImageView imageview = (ImageView) findViewById(R.id.pic);
            imageview.setImageBitmap(image);
        } else if (resultCode == RESULT_CANCELED) {
            Toast.makeText(this, "CANCELED ", Toast.LENGTH_LONG).show();
        }
    }
}

Das Problem ist, dass die Absicht datanull ist und sich die OnActivityResultMethode direkt an die wendet (resultCode == RESULT_CANCELED)und die Anwendung zur vorherigen Aktivität zurückkehrt.

Wie kann ich dieses Problem beheben und nach dem Aufrufen der Kamera kehrt die Anwendung zur aktuellen Aktivität zurück, die eine ImageViewenthält, die das aufgenommene Bild enthält?

Vielen Dank

Die Standardanwendung für Android-Kameras gibt nur dann eine Nicht-Null-Absicht zurück, wenn eine Miniaturansicht in der zurückgegebenen Absicht zurückgegeben wird. Wenn Sie EXTRA_OUTPUTmit einer URI übergeben, an die geschrieben werden soll, wird eine nullAbsicht zurückgegeben, und das Bild befindet sich in der URI, die Sie übergeben haben.

Sie können dies überprüfen, indem Sie sich den Quellcode der Kamera-App auf GitHub ansehen:

• https://github.com/android/platform_packages_apps_camera/blob/gingerbread-release/src/com/android/camera/Camera.java#L1186

  Bundle newExtras = new Bundle();
  if (mCropValue.equals("circle")) {
      newExtras.putString("circleCrop", "true");
  }
  if (mSaveUri != null) {
      newExtras.putParcelable(MediaStore.EXTRA_OUTPUT, mSaveUri);
  } else {
      newExtras.putBoolean("return-data", true);
  }

Ich würde vermuten, dass Sie entweder EXTRA_OUTPUTirgendwie vorbeikommen oder die Kamera-App auf Ihrem Telefon anders funktioniert.

Ich fand eine einfache Antwort. Es klappt!!

private void openCameraForResult(int requestCode){
    Intent photo = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    Uri uri  = Uri.parse("file:///sdcard/photo.jpg");
    photo.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    startActivityForResult(photo,requestCode);
}

if (requestCode == CAMERA_REQUEST_CODE) {
        if (resultCode == Activity.RESULT_OK) {
            File file = new File(Environment.getExternalStorageDirectory().getPath(), "photo.jpg");
            Uri uri = Uri.fromFile(file);
            Bitmap bitmap;
            try {
                bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), uri);
                bitmap = cropAndScale(bitmap, 300); // if you mind scaling
                profileImageView.setImageBitmap(bitmap);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }

Wenn Sie dieses Bild zuschneiden und skalieren möchten

public static  Bitmap cropAndScale (Bitmap source, int scale){
    int factor = source.getHeight() <= source.getWidth() ? source.getHeight(): source.getWidth();
    int longer = source.getHeight() >= source.getWidth() ? source.getHeight(): source.getWidth();
    int x = source.getHeight() >= source.getWidth() ?0:(longer-factor)/2;
    int y = source.getHeight() <= source.getWidth() ?0:(longer-factor)/2;
    source = Bitmap.createBitmap(source, x, y, factor, factor);
    source = Bitmap.createScaledBitmap(source, scale, scale, false);
    return source;
}

Ich habe dieses Problem erlebt, das intentist nicht null, aber die darüber gesendeten Informationen werden intentnicht in empfangenonActionActivit()

Dies ist eine bessere Lösung mit getContentResolver () :

    private Uri imageUri;
    private ImageView myImageView;
    private Bitmap thumbnail;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

      ...
      ...    
      ...
      myImageview = (ImageView) findViewById(R.id.pic); 

      values = new ContentValues();
      values.put(MediaStore.Images.Media.TITLE, "MyPicture");
      values.put(MediaStore.Images.Media.DESCRIPTION, "Photo taken on " + System.currentTimeMillis());
      imageUri = getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
      Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
      intent.putExtra(MediaStore.EXTRA_OUTPUT, imageUri);
      startActivityForResult(intent, PICTURE_RESULT);

  }

die onActivityResult()von getContentResolver () gespeicherte Bitmap abrufen :

 @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (requestCode == REQUEST_CODE_TAKE_PHOTO && resultCode == RESULT_OK) {

            Bitmap bitmap;
            try {
                bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), imageUri);
                myImageView.setImageBitmap(bitmap);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

Überprüfen Sie mein Beispiel in Github:

https://github.com/Jorgesys/TakePicture

Einfache funktionierende Kamera-App, die das Null-Intent-Problem vermeidet

- alle geänderten Codes, die in dieser Antwort enthalten sind; in der Nähe von Android Tutorial

Ich habe viel Zeit mit diesem Thema verbracht, daher habe ich beschlossen, ein Konto zu erstellen und meine Ergebnisse mit Ihnen zu teilen.

Das offizielle Android-Tutorial "Taking Photos Simply" hat nicht ganz das gehalten, was es versprochen hatte. Der dort bereitgestellte Code funktionierte auf meinem Gerät nicht: ein Samsung Galaxy S4 Mini GT-I9195 mit Android Version 4.4.2 / KitKat / API Level 19.

Ich fand heraus, dass das Hauptproblem die folgende Zeile in der Methode war, die beim Aufnehmen des Fotos aufgerufen wurde ( dispatchTakePictureIntentim Tutorial):

takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI);

Dies führte dazu onActivityResult, dass die Absicht später durch Null erfasst wurde .

Um dieses Problem zu lösen, habe ich mich von früheren Antworten hier und einigen hilfreichen Beiträgen zu Github inspirieren lassen (meistens von Deepwinter - ein großes Dankeschön an ihn; vielleicht möchten Sie auch seine Antwort auf einen eng verwandten Beitrag lesen ).

Nach diesen angenehmen Ratschlägen entschied ich mich für die Strategie, die erwähnte putExtraZeile zu löschen und stattdessen das aufgenommene Bild von der Kamera innerhalb der onActivityResult () -Methode zurückzugewinnen. Die entscheidenden Codezeilen, um die dem Bild zugeordnete Bitmap wiederherzustellen, sind:

        Uri uri = intent.getData();
        Bitmap bitmap = null;
        try {
            bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), uri);
        } catch (IOException e) {
            e.printStackTrace();
        }

Ich habe eine beispielhafte App erstellt, mit der Sie einfach ein Bild aufnehmen, auf der SD-Karte speichern und anzeigen können. Ich denke, dies könnte für Leute in der gleichen Situation wie ich hilfreich sein, als ich über dieses Problem gestolpert bin, da sich die aktuellen Hilfevorschläge meist auf ziemlich umfangreiche Github-Posts beziehen, die die fragliche Sache tun, aber für Neulinge wie nicht allzu leicht zu überwachen sind mich. In Bezug auf das Dateisystem, das Android Studio beim Erstellen eines neuen Projekts standardmäßig erstellt, musste ich nur drei Dateien für meinen Zweck ändern:

activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context="com.example.android.simpleworkingcameraapp.MainActivity">

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="takePicAndDisplayIt"
    android:text="Take a pic and display it." />

<ImageView
    android:id="@+id/image1"
    android:layout_width="match_parent"
    android:layout_height="200dp" />

</LinearLayout>

MainActivity.java:

package com.example.android.simpleworkingcameraapp;

import android.content.Intent;
import android.graphics.Bitmap;
import android.media.Image;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.Toast;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MainActivity extends AppCompatActivity {

private ImageView image;
static final int REQUEST_TAKE_PHOTO = 1;
String mCurrentPhotoPath;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    image = (ImageView) findViewById(R.id.image1);
}

// copied from the android development pages; just added a Toast to show the storage location
private File createImageFile() throws IOException {
    // Create an image file name
    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmm").format(new Date());
    String imageFileName = "JPEG_" + timeStamp + "_";
    File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
    File image = File.createTempFile(
            imageFileName,  /* prefix */
            ".jpg",         /* suffix */
            storageDir      /* directory */
    );

    // Save a file: path for use with ACTION_VIEW intents
    mCurrentPhotoPath = image.getAbsolutePath();
    Toast.makeText(this, mCurrentPhotoPath, Toast.LENGTH_LONG).show();
    return image;
}

public void takePicAndDisplayIt(View view) {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    if (intent.resolveActivity(getPackageManager()) != null) {
        File file = null;
        try {
            file = createImageFile();
        } catch (IOException ex) {
            // Error occurred while creating the File
        }

        startActivityForResult(intent, REQUEST_TAKE_PHOTO);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultcode, Intent intent) {
    if (requestCode == REQUEST_TAKE_PHOTO && resultcode == RESULT_OK) {
        Uri uri = intent.getData();
        Bitmap bitmap = null;
        try {
            bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), uri);
        } catch (IOException e) {
            e.printStackTrace();
        }
        image.setImageBitmap(bitmap);
    }
}
}

AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.simpleworkingcameraapp">


<!--only added paragraph-->
<uses-feature
    android:name="android.hardware.camera"
    android:required="true" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  <!-- only crucial line to add; for me it still worked without the other lines in this paragraph -->
<uses-permission android:name="android.permission.CAMERA" />


<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity android:name=".MainActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
</application>

</manifest>

Beachten Sie, dass die Lösung, die ich für das Problem gefunden habe, auch zu einer Vereinfachung der Android-Manifest-Datei geführt hat: Die im Android-Tutorial vorgeschlagenen Änderungen zum Hinzufügen eines Anbieters werden nicht mehr benötigt, da ich in meinem Java-Code keine mehr verwende. Daher mussten der Manifestdatei nur wenige Standardzeilen hinzugefügt werden - hauptsächlich in Bezug auf Berechtigungen.

Es kann außerdem hilfreich sein, darauf hinzuweisen, dass der Autoimport von Android Studio möglicherweise nicht in der Lage ist, java.text.SimpleDateFormatund zu verarbeiten java.util.Date. Ich musste beide manuell importieren.

Wahrscheinlich, weil du so etwas hattest?

Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);                        
Uri fileUri =  CommonUtilities.getTBCameraOutputMediaFileUri();                  
takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);                        
startActivityForResult(takePictureIntent, 2);

Sie dürfen die zusätzliche Ausgabe jedoch nicht in die Absicht einfügen, da die Daten dann anstelle der Datenvariablen in den URI eingegeben werden. Aus diesem Grund müssen Sie die beiden Zeilen in der Mitte herausnehmen, damit Sie haben

Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
startActivityForResult(takePictureIntent, 2);

Das hat das Problem für mich verursacht, hoffe das hat geholfen.

Der folgende Code funktioniert für mich:

Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
startActivityForResult(cameraIntent, 2);

Und hier ist das Ergebnis:

protected void onActivityResult(int requestCode, int resultCode, Intent imageReturnedIntent)
{ 
    super.onActivityResult(requestCode, resultCode, imageReturnedIntent);

    if(resultCode == RESULT_OK)
    {
        Uri selectedImage = imageReturnedIntent.getData();
        ImageView photo = (ImageView) findViewById(R.id.add_contact_label_photo);
        Bitmap mBitmap = null;
        try
        {
            mBitmap = Media.getBitmap(this.getContentResolver(), selectedImage);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

So greifen Sie auf die Kamera zu, nehmen Bilder auf und stellen ImageView auf Android ein

Sie müssen Uri file = Uri.fromFile(getOutputMediaFile());für Marshmallow verwenden.

Verwenden Sie den folgenden Link, um den Pfad zu erhalten

https://androidkennel.org/android-camera-access-tutorial/

Kotlin-Code, der für mich funktioniert:

 private fun takePhotoFromCamera() {
          val intent = Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE)
        startActivityForResult(intent, PERMISSIONS_REQUEST_TAKE_PICTURE_CAMERA)
      }

Und Ergebnis erhalten:

 override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
 if (requestCode == PERMISSIONS_REQUEST_TAKE_PICTURE_CAMERA) {
         if (resultCode == Activity.RESULT_OK) {
           val photo: Bitmap? =  MediaStore.Images.Media.getBitmap(this.contentResolver, Uri.parse( data!!.dataString)   )
            // Do something here : set image to an ImageView or save it ..   
              imgV_pic.imageBitmap = photo 
        } else if (resultCode == Activity.RESULT_CANCELED) {
            Log.i(TAG, "Camera  , RESULT_CANCELED ")
        }

    }

}

und vergessen Sie nicht, den Anforderungscode anzugeben:

companion object {
 const val PERMISSIONS_REQUEST_TAKE_PICTURE_CAMERA = 300
  }

Nach vielen Versuchen und Studien konnte ich es herausfinden. Erstens sind die variablen Daten von Intent immer null. !nullWenn Sie also nach prüfen , stürzt Ihre App ab, solange Sie einen URI an startActivityForResult übergeben. Befolgen Sie das folgende Beispiel. Ich werde Kotlin benutzen.

1. Öffnen Sie die Kameraabsicht

   fun addBathroomPhoto(){
   addbathroomphoto.setOnClickListener{
   
       request_capture_image=2
   
       var takePictureIntent:Intent?
       takePictureIntent =Intent(MediaStore.ACTION_IMAGE_CAPTURE)
       if(takePictureIntent.resolveActivity(activity?.getPackageManager()) != null){
   
           val photoFile: File? = try {
               createImageFile()
           } catch (ex: IOException) {
               // Error occurred while creating the File
   
               null
           }
   
           if (photoFile != null) {
               val photoURI: Uri = FileProvider.getUriForFile(
                   activity!!,
                   "ogavenue.ng.hotelroomkeeping.fileprovider",photoFile)
               takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT,
                   photoURI);
               startActivityForResult(takePictureIntent,
                   request_capture_image);
           }
   
   
       }
   
   }

   } `

2. Erstellen Sie die Datei createImageFile (). Sie MÜSSEN jedoch die Variable imageFilePath global machen. Ein Beispiel für die Erstellung finden Sie in der offiziellen Android-Dokumentation und sind recht unkompliziert

3. Holen Sie sich die Absicht

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
   
   if (requestCode == 1 && resultCode == RESULT_OK) {
       add_room_photo_txt.text=""
       var myBitmap=BitmapFactory.decodeFile(imageFilePath)
       addroomphoto.setImageBitmap(myBitmap)
       var file=File(imageFilePath)
       var fis=FileInputStream(file)
       var bm = BitmapFactory.decodeStream(fis);
       roomphoto=getBytesFromBitmap(bm) }}

4. Die Methode getBytesFromBitmap

     fun getBytesFromBitmap(bitmap:Bitmap):ByteArray{
   
     var stream=ByteArrayOutputStream()
     bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
     return stream.toByteArray();
     }

Ich hoffe das hilft.

Wenn wir das Bild von der Kamera in Android aufnehmen, dann ist Uri oder data.getdata()null. Wir haben zwei Lösungen, um dieses Problem zu beheben.

1. Wir können den Uri-Pfad aus dem Bitmap-Bild erhalten
2. Wir können den Uri-Pfad vom Cursor erhalten.

Ich werde alle Methoden hier implementieren. Bitte beachten und lesen Sie diese sorgfältig: -

Zuerst werde ich erzählen, wie man Uri von Bitmap erhält. Bild: Der vollständige Code lautet:

Zuerst werden wir ein Bild durch Intent aufnehmen, das für beide Methoden gleich ist, so dass ich diesen Code nur einmal hier schreibe:

// Capture Image
captureImg.setOnClickListener(new View.OnClickListener(){
    @Override public void onClick(View view){
        Intent intent=new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        if(intent.resolveActivity(getPackageManager())!=null){
            startActivityForResult(intent,reqcode);
        }

    }
});  

Jetzt implementieren wir OnActivityResult :-( Dies ist für beide oben genannten 2 Methoden gleich): -

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data)
{
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == reqcode && resultCode == RESULT_OK)
    {

        Bitmap photo = (Bitmap) data.getExtras().get("data");
        ImageView.setImageBitmap(photo);

        // CALL THIS METHOD TO GET THE URI FROM THE BITMAP
        Uri tempUri = getImageUri(getApplicationContext(), photo);

        //Show Uri path based on Image
        Toast.makeText(LiveImage.this, "Here " + tempUri, Toast.LENGTH_LONG).show();

        //Show Uri path based on Cursor Content Resolver
        Toast.makeText(this, "Real path for URI : " + getRealPathFromURI(tempUri), Toast.LENGTH_SHORT).show();
    }
    else
    {
        Toast.makeText(this, "Failed To Capture Image", Toast.LENGTH_SHORT).show();
    }
}     

Jetzt werden wir alle oben genannten Methoden erstellen, um Uri aus Bild- und Cursormethoden über Klassen zu erstellen:

Jetzt URI-Pfad von Bitmap Image

private Uri getImageUri(Context applicationContext, Bitmap photo)
{
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    photo.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
    String path = MediaStore.Images.Media.insertImage(LiveImage.this.getContentResolver(), photo, "Title", null);
    return Uri.parse(path);
}

\ Uri vom realen Pfad des gespeicherten Bildes

public String getRealPathFromURI(Uri uri)
{
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);
    cursor.moveToFirst();
    int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
    return cursor.getString(idx);
}

Wenn wir das Bild von der Kamera in Android aufnehmen, wird es Urioder data.getdata()wird null. Wir haben zwei Lösungen, um dieses Problem zu beheben.

1. Rufen Sie den Uri-Pfad aus dem Bitmap-Image ab
2. Rufen Sie den Uri-Pfad vom Cursor ab.

So rufen Sie den Uri aus dem Bitmap-Image ab. Nehmen Sie zuerst ein Bild über Intent auf, das für beide Methoden gleich ist:

// Capture Image
captureImg.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        if (intent.resolveActivity(getPackageManager()) != null) {
            startActivityForResult(intent, reqcode);
        }
    }
});

Implementieren Sie nun OnActivityResult, was für beide Methoden gleich ist:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if(requestCode==reqcode && resultCode==RESULT_OK)
    {
        Bitmap photo = (Bitmap) data.getExtras().get("data");
        ImageView.setImageBitmap(photo);

        // CALL THIS METHOD TO GET THE URI FROM THE BITMAP
        Uri tempUri = getImageUri(getApplicationContext(), photo);

        // Show Uri path based on Image
        Toast.makeText(LiveImage.this,"Here "+ tempUri, Toast.LENGTH_LONG).show();

        // Show Uri path based on Cursor Content Resolver
        Toast.makeText(this, "Real path for URI : "+getRealPathFromURI(tempUri), Toast.LENGTH_SHORT).show();
    }
    else
    {
        Toast.makeText(this, "Failed To Capture Image", Toast.LENGTH_SHORT).show();
    }
}

Erstellen Sie nun alle oben genannten Methoden, um den Uri aus den Bild- und Cursormethoden zu erstellen:

Uri-Pfad von Bitmap Bild:

private Uri getImageUri(Context applicationContext, Bitmap photo) {
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    photo.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
    String path = MediaStore.Images.Media.insertImage(LiveImage.this.getContentResolver(), photo, "Title", null);
    return Uri.parse(path);
}

Uri vom realen Pfad des gespeicherten Bildes:

public String getRealPathFromURI(Uri uri) {
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);
    cursor.moveToFirst();
    int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
    return cursor.getString(idx);
}