Obtenir la liste des galeries de photos sur Android

Question

Je recherche: Une liste des galeries d'art existantes (nous espérons aussi leur miniature supérieure) Le contenu de la galerie (Je peux charger les vignettes et avoir un agrandissement si besoin est

Comment pourrais-je obtenir une liste des "Galeries" (je ne sais pas si c'est le bon terme dans android pour les regroupements d'images visibles dans l'application Galerie ...) et leur contenu? J'ai besoin d'accéder à la galerie dans sa structure sans utiliser l'affichage de la galerie existante (je crée un écran totalement nouveau, pas un sur-couche au demandeur de photo etc.)

Je suppose que MediaStore.Images est là où j'ai besoin être mais je ne vois rien qui me donnera les groupements ...

Answer 1

Les regroupements sont définis par MediaStore.Images.Media.BUCKET_DISPLAY_NAME. Voici l'exemple de code pour lister les images et enregistrer leur nom de seau et 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

Voici la solution complète en quelques étapes simples:

Les prochaines étapes vous guid comment créer un Vector qui contiendra les albums trouvés sur un périphérique donné. Chaque album contiendra une image d'aperçu ainsi qu'une image intérieure qui contiendra toutes les images de l'album.

1. Créez un objet qui conservera les images une fois extraites du stockage. Nous allons l'appeler PhoneAlbum. Voici comment cela va chercher:

   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. Créer un objet qui contiendra les images dans l'album intitulé: 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. Créer une interface pour gérer les images extraites à la fin. Nous allons l'appeler OnPhoneImagesObtained. Ici, il est:

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

4. Créer une nouvelle classe: DeviceImageManager

   public class DeviceImageManager { 
   
   } 
   

5. Une fois que vous avez créé DeviceImageManager, ajoutez la méthode suivante:

   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. Maintenant, tout ce qu'il vous reste est pour rendre les images à l'écran. Dans mon cas j'aime utiliser Picasso. Voici comment je le fais:

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

7. Ne pas oublier d'ajouter une autorisation de lecture stockage externe dans votre manifeste:

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

Voilà. Tu es prêt! Bonne chance!

Answer 4

télécharger le code source ici (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(); 
        } 
       } 
      } 
     } 
    } 

}