Obtenga una lista de las galerías de fotos en Android

Question

Estoy buscando: Una lista de los nombres de las galerías de fotos existentes (con suerte su miniatura superior también) El contenido de la galería (puedo cargar miniaturas y tamaño completo según sea necesario))

¿Cómo me gustaría obtener una lista de las "Galerías" (no sé si ese es el término correcto en Android para las agrupaciones de imágenes visibles en la aplicación Galería ...) y sus contenidos? Necesito acceso a la galería en su estructura sin usar la pantalla existente de la galería (estoy creando una totalmente nueva, no una capa superior para el solicitante de la foto, etc.)

Supongo que MediaStore.Images es donde necesito pero no veo nada que me dé las agrupaciones ...

Answer 1

Las agrupaciones están definidas por MediaStore.Images.Media.BUCKET_DISPLAY_NAME. Aquí está el código de ejemplo para mostrar las imágenes y registrar su nombre de depósito y 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

aquí es la solución completa en pocos pasos simples:

Los próximos pasos serán GUID cómo crear un Vector que contendrá los álbumes encontrados en un dispositivo determinado. Todos los álbumes contendrán una imagen de vista previa así como un Vector interno que contendrá todas las imágenes del álbum.

1. Cree un objeto que contendrá las imágenes una vez extraídas del almacenamiento. Vamos a llamarlo PhoneAlbum. Así es como se va a ver:

   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. crear un objeto que contendrá las imágenes dentro del álbum llamado: 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. crear una interfaz para manejar las imágenes extraídas al finalizar. Vamos a llamarlo OnPhoneImagesObtained. Aquí está:

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

4. crear una clase nueva: DeviceImageManager

   public class DeviceImageManager { 
   
   } 
   

5. Una vez que ha creado DeviceImageManager, agregue el siguiente método:

   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. Ahora todo lo que queda es para renderizar las imágenes a la pantalla. En mi caso, me gusta usar Picasso. Aquí es cómo lo hago:

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

7. No se olvide de añadir un permiso para leer almacenamiento externo en su manifiesto:

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

eso es todo. tú eres bueno para irte. ¡Buena suerte!

Answer 4

descargar el código fuente desde aquí (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(); 
        } 
       } 
      } 
     } 
    } 

}