Get Liste der Fotogalerien auf Android

Question

Ich suche nach: Eine Liste der vorhandenen Fotogalerie Namen (hoffentlich auch ihre Top-Thumbnail) Der Inhalt der Galerie (Ich kann dann Thumbnails und voller Größe nach Bedarf laden)

Wie würde ich eine Liste der "Galerien" (weiß nicht, ob das ist der richtige Begriff in Android für die Gruppierungen von Bildern in der Galerie App sichtbar ...) und deren Inhalt gehen? Ich brauche Zugriff auf die Galerie in ihrer Struktur, ohne die vorhandene Galerie-Anzeige zu verwenden (ich erstelle eine völlig neue, nicht eine Überschicht für den Fotoanforderer etc.)

Ich gehe davon aus, dass MediaStore.Images wo ich brauche Sei aber ich sehe nichts, das mir die Gruppierungen geben würde ...

Answer 1

Gruppierungen sind definiert durch MediaStore.Images.Media.BUCKET_DISPLAY_NAME. Hier ist der Beispielcode die Bilder zur Liste und melden ihre Eimer Namen und date_taken:

// which image properties are we querying 
String[] projection = new String[] { 
     MediaStore.Images.Media._ID, 
     MediaStore.Images.Media.BUCKET_DISPLAY_NAME, 
     MediaStore.Images.Media.DATE_TAKEN 
}; 

// content:// style URI for the "primary" external storage volume 
Uri images = MediaStore.Images.Media.EXTERNAL_CONTENT_URI; 

// Make the query. 
Cursor cur = managedQuery(images, 
     projection, // Which columns to return 
     null,  // Which rows to return (all rows) 
     null,  // Selection arguments (none) 
     null  // Ordering 
     ); 

Log.i("ListingImages"," query count=" + cur.getCount()); 

if (cur.moveToFirst()) { 
    String bucket; 
    String date; 
    int bucketColumn = cur.getColumnIndex(
     MediaStore.Images.Media.BUCKET_DISPLAY_NAME); 

    int dateColumn = cur.getColumnIndex(
     MediaStore.Images.Media.DATE_TAKEN); 

    do { 
     // Get the field values 
     bucket = cur.getString(bucketColumn); 
     date = cur.getString(dateColumn); 

     // Do something with the values. 
     Log.i("ListingImages", " bucket=" + bucket 
       + " date_taken=" + date); 
    } while (cur.moveToNext()); 

} 

Answer 2

/** 
* Getting All Images Path 
* 
* @param activity 
* @return ArrayList with images Path 
*/ 
public static ArrayList<String> getAllShownImagesPath(Activity activity) { 
    Uri uri; 
    Cursor cursor; 
    int column_index_data, column_index_folder_name; 
    ArrayList<String> listOfAllImages = new ArrayList<String>(); 
    String absolutePathOfImage = null; 
    uri = android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI; 

    String[] projection = { MediaColumns.DATA, 
      MediaStore.Images.Media.BUCKET_DISPLAY_NAME }; 

    cursor = activity.getContentResolver().query(uri, projection, null, 
      null, null); 

    column_index_data = cursor.getColumnIndexOrThrow(MediaColumns.DATA); 
    column_index_folder_name = cursor 
      .getColumnIndexOrThrow(MediaStore.Images.Media.BUCKET_DISPLAY_NAME); 
    while (cursor.moveToNext()) { 
     absolutePathOfImage = cursor.getString(column_index_data); 

     listOfAllImages.add(absolutePathOfImage); 
    } 
    return listOfAllImages; 
} 

Answer 3

Hier ist die vollständige Lösung in wenigen einfachen Schritten:

Die nächsten Schritte werden Sie guid wie man eine Vector erstellt, die die Alben enthält, die auf einem bestimmten Gerät gefunden wurden. Jedes Album enthält ein Vorschaubild sowie eine innere Vector, die alle Bilder des Albums enthält.

1. Erstellen Sie ein Objekt, das die einmal aus dem Speicher extrahierten Bilder enthält. Wir werden es PhoneAlbum nennen. Dies ist, wie es aussehen gehen:

   public class PhoneAlbum { 
   
       private int id; 
       private String name; 
       private String coverUri; 
       private Vector<PhonePhoto> albumPhotos; 
   
       public int getId() { 
        return id; 
       } 
   
       public void setId(int id) { 
        this.id = id; 
       } 
   
       public String getName() { 
        return name; 
       } 
   
       public void setName(String name) { 
        this.name = name; 
       } 
   
       public String getCoverUri() { 
        return coverUri; 
       } 
   
       public void setCoverUri(String albumCoverUri) { 
        this.coverUri = albumCoverUri; 
       } 
   
       public Vector<PhonePhoto> getAlbumPhotos() { 
        if (albumPhotos == null) { 
         albumPhotos = new Vector<>(); 
        } 
        return albumPhotos; 
       } 
   
       public void setAlbumPhotos(Vector<PhonePhoto> albumPhotos) { 
        this.albumPhotos = albumPhotos; 
       } 
   } 
   

2. Erstellen Sie ein Objekt, das die Bilder im Album halten wird genannt: PhonePhoto

   public class PhonePhoto { 
   
       private int id; 
       private String albumName; 
       private String photoUri; 
   
       public int getId() { 
        return id; 
       } 
   
       public void setId(int id) { 
        this.id = id; 
       } 
   
       public String getAlbumName() { 
        return albumName; 
       } 
   
       public void setAlbumName(String name) { 
        this.albumName = name; 
       } 
   
       public String getPhotoUri() { 
        return photoUri; 
       } 
   
       public void setPhotoUri(String photoUri) { 
        this.photoUri = photoUri; 
       } 
   } 
   

3. eine Schnittstelle Erstellen Sie die extrahierten Bilder nach Abschluss zu behandeln. Wir werden es OnPhoneImagesObtained nennen. Hier ist sie:

   public interface OnPhoneImagesObtained { 
   
       void onComplete(Vector<PhoneAlbum> albums); 
       void onError(); 
   
   } 
   

4. eine neue Klasse erstellen: DeviceImageManager

   public class DeviceImageManager { 
   
   } 
   

5. Sobald Sie DeviceImageManager erstellt, fügen Sie die folgende Methode:

   public static void getPhoneAlbums(Context context , OnPhoneImagesObtained listener){ 
       // Creating vectors to hold the final albums objects and albums names 
       Vector<PhoneAlbum> phoneAlbums = new Vector<>(); 
       Vector<String> albumsNames = new Vector<>(); 
   
       // which image properties are we querying 
       String[] projection = new String[] { 
         MediaStore.Images.Media.BUCKET_DISPLAY_NAME, 
         MediaStore.Images.Media.DATA, 
         MediaStore.Images.Media._ID 
       }; 
   
       // content: style URI for the "primary" external storage volume 
       Uri images = MediaStore.Images.Media.EXTERNAL_CONTENT_URI; 
   
       // Make the query. 
       Cursor cur = context.getContentResolver().query(images, 
         projection, // Which columns to return 
         null,  // Which rows to return (all rows) 
         null,  // Selection arguments (none) 
         null  // Ordering 
       ); 
   
       if (cur != null && cur.getCount() > 0) { 
        Log.i("DeviceImageManager"," query count=" + cur.getCount()); 
   
        if (cur.moveToFirst()) { 
         String bucketName; 
         String data; 
         String imageId; 
         int bucketNameColumn = cur.getColumnIndex(
          MediaStore.Images.Media.BUCKET_DISPLAY_NAME); 
   
         int imageUriColumn = cur.getColumnIndex(
          MediaStore.Images.Media.DATA); 
   
         int imageIdColumn = cur.getColumnIndex(
          MediaStore.Images.Media._ID); 
   
         do { 
          // Get the field values 
          bucketName = cur.getString(bucketNameColumn); 
          data = cur.getString(imageUriColumn); 
          imageId = cur.getString(imageIdColumn); 
   
          // Adding a new PhonePhoto object to phonePhotos vector 
          PhonePhoto phonePhoto = new PhonePhoto(); 
          phonePhoto.setAlbumName(bucketName); 
          phonePhoto.setPhotoUri(data); 
          phonePhoto.setId(Integer.valueOf(imageId)); 
   
          if (albumsNames.contains(bucketName)) { 
           for (PhoneAlbum album : phoneAlbums) { 
            if (album.getName().equals(bucketName)) { 
             album.getAlbumPhotos().add(phonePhoto); 
             Log.i("DeviceImageManager", "A photo was added to album => " + bucketName); 
             break; 
            } 
           } 
          } else { 
           PhoneAlbum album = new PhoneAlbum(); 
           Log.i("DeviceImageManager", "A new album was created => " + bucketName); 
           album.setId(phonePhoto.getId()); 
           album.setName(bucketName); 
           album.setCoverUri(phonePhoto.getPhotoUri()); 
           album.getAlbumPhotos().add(phonePhoto); 
           Log.i("DeviceImageManager", "A photo was added to album => " + bucketName); 
   
           phoneAlbums.add(album); 
           albumsNames.add(bucketName); 
          } 
   
         } while (cur.moveToNext()); 
        } 
   
        cur.close(); 
        listener.onComplete(phoneAlbums); 
       } else { 
        listener.onError(); 
       } 
   } 
   

6. Alles was Sie jetzt verlassen haben, ist um die Bilder auf dem Bildschirm darzustellen. In meinem Fall verwende ich gerne Picasso. Hier ist, wie ich es tun:

   Picasso.with(getActivity()) 
          .load("file:" + mPhoneAlbums.get(i).getCoverUri()) 
          .centerCrop() 
          .fit() 
          .placeholder(R.drawable.temp_image) 
          .into(mAlbumPreview); 
   

7. Vergessen Sie nicht eine Berechtigung zum Lesen externen Speichers in Ihrem Manifest hinzuzufügen:

   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> 
   

das ist es. Du bist startklar! Viel Glück!

Answer 4

den Code Quelle von hier herunterladen (Get all images from gallery in android programmatically)

activity_main.xml

<RelativeLayout android:layout_width="match_parent" 
    android:layout_height="match_parent" 
    android:background="#ffffff" 
    xmlns:android="http://schemas.android.com/apk/res/android"> 


    <GridView 
     android:layout_width="match_parent" 
     android:layout_height="match_parent" 
     android:id="@+id/gv_folder" 
     android:numColumns="2" 
     android:layout_marginLeft="10dp" 
     android:layout_marginRight="10dp"></GridView> 


</RelativeLayout> 

MainActivity.java

package galleryimages.galleryimages; 

import android.Manifest; 
import android.content.Intent; 
import android.content.pm.PackageManager; 
import android.database.Cursor; 
import android.net.Uri; 
import android.provider.MediaStore; 
import android.support.v4.app.ActivityCompat; 
import android.support.v4.content.ContextCompat; 
import android.support.v7.app.AppCompatActivity; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
import android.widget.AdapterView; 
import android.widget.GridView; 
import android.widget.Toast; 

import java.util.ArrayList; 

public class MainActivity extends AppCompatActivity { 
    public static ArrayList<Model_images> al_images = new ArrayList<>(); 
    boolean boolean_folder; 
    Adapter_PhotosFolder obj_adapter; 
    GridView gv_folder; 
    private static final int REQUEST_PERMISSIONS = 100; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     gv_folder = (GridView)findViewById(R.id.gv_folder); 

     gv_folder.setOnItemClickListener(new AdapterView.OnItemClickListener() { 
      @Override 
      public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) { 
       Intent intent = new Intent(getApplicationContext(), PhotosActivity.class); 
       intent.putExtra("value",i); 
       startActivity(intent); 
      } 
     }); 


     if ((ContextCompat.checkSelfPermission(getApplicationContext(), 
       Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) && (ContextCompat.checkSelfPermission(getApplicationContext(), 
       Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)) { 
      if ((ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this, 
        Manifest.permission.WRITE_EXTERNAL_STORAGE)) && (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this, 
        Manifest.permission.READ_EXTERNAL_STORAGE))) { 

      } else { 
       ActivityCompat.requestPermissions(MainActivity.this, 
         new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE}, 
         REQUEST_PERMISSIONS); 
      } 
     }else { 
      Log.e("Else","Else"); 
      fn_imagespath(); 
     } 



    } 

    public ArrayList<Model_images> fn_imagespath() { 
     al_images.clear(); 

     int int_position = 0; 
     Uri uri; 
     Cursor cursor; 
     int column_index_data, column_index_folder_name; 

     String absolutePathOfImage = null; 
     uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI; 

     String[] projection = {MediaStore.MediaColumns.DATA, MediaStore.Images.Media.BUCKET_DISPLAY_NAME}; 

     final String orderBy = MediaStore.Images.Media.DATE_TAKEN; 
     cursor = getApplicationContext().getContentResolver().query(uri, projection, null, null, orderBy + " DESC"); 

     column_index_data = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA); 
     column_index_folder_name = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.BUCKET_DISPLAY_NAME); 
     while (cursor.moveToNext()) { 
      absolutePathOfImage = cursor.getString(column_index_data); 
      Log.e("Column", absolutePathOfImage); 
      Log.e("Folder", cursor.getString(column_index_folder_name)); 

      for (int i = 0; i < al_images.size(); i++) { 
       if (al_images.get(i).getStr_folder().equals(cursor.getString(column_index_folder_name))) { 
        boolean_folder = true; 
        int_position = i; 
        break; 
       } else { 
        boolean_folder = false; 
       } 
      } 


      if (boolean_folder) { 

       ArrayList<String> al_path = new ArrayList<>(); 
       al_path.addAll(al_images.get(int_position).getAl_imagepath()); 
       al_path.add(absolutePathOfImage); 
       al_images.get(int_position).setAl_imagepath(al_path); 

      } else { 
       ArrayList<String> al_path = new ArrayList<>(); 
       al_path.add(absolutePathOfImage); 
       Model_images obj_model = new Model_images(); 
       obj_model.setStr_folder(cursor.getString(column_index_folder_name)); 
       obj_model.setAl_imagepath(al_path); 

       al_images.add(obj_model); 


      } 


     } 


     for (int i = 0; i < al_images.size(); i++) { 
      Log.e("FOLDER", al_images.get(i).getStr_folder()); 
      for (int j = 0; j < al_images.get(i).getAl_imagepath().size(); j++) { 
       Log.e("FILE", al_images.get(i).getAl_imagepath().get(j)); 
      } 
     } 
     obj_adapter = new Adapter_PhotosFolder(getApplicationContext(),al_images); 
     gv_folder.setAdapter(obj_adapter); 
     return al_images; 
    } 

    @Override 
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
     super.onRequestPermissionsResult(requestCode, permissions, grantResults); 

     switch (requestCode) { 
      case REQUEST_PERMISSIONS: { 
       for (int i = 0; i < grantResults.length; i++) { 
        if (grantResults.length > 0 && grantResults[i] == PackageManager.PERMISSION_GRANTED) { 
         fn_imagespath(); 
        } else { 
         Toast.makeText(MainActivity.this, "The app was not allowed to read or write to your storage. Hence, it cannot function properly. Please consider granting it this permission", Toast.LENGTH_LONG).show(); 
        } 
       } 
      } 
     } 
    } 

}