Wyświetl listę galerii zdjęć na Androidzie

Question

Szukam: Lista istniejących nazw galerii zdjęć (miejmy nadzieję, że także ich najlepsza miniatura) Zawartość galerii (mogę wtedy załadować miniatury i pełny rozmiar w razie potrzeby)

Jak mogę uzyskać listę "Galerii" (nie wiem, czy to jest właściwe określenie w Androidzie dla grup obrazów widocznych w aplikacji Galeria ...) i ich zawartość? Potrzebuję dostępu do galerii w jej strukturze bez użycia istniejącego widoku galerii (tworzę zupełnie nowy, nie przesłonę nad requesterem zdjęć itp.).

Zakładam, że MediaStore.Images jest tam, gdzie muszę ale nie widzę niczego, co da mi grupy ...

Answer 1

Grupowanie jest zdefiniowane przez MediaStore.Images.Media.BUCKET_DISPLAY_NAME. Oto przykładowy kod do listy obrazów i rejestrować swoją nazwę wiadro i 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

Oto pełne rozwiązanie w kilku prostych krokach:

Kilka następnych krokach guid jak utworzyć Vector, która będzie zawierać albumy znalezione na danym urządzeniu. Każdy album będzie zawierał obraz podglądu, a także wewnętrzny plik Vector, który będzie zawierał wszystkie obrazy albumu.

1. Utwórz obiekt, który będzie przechowywać obrazy po wyodrębnieniu z pamięci. Nazwiemy to PhoneAlbum. Jak to będzie wyglądać:

   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. Utwórz obiekt, który odbędzie się obrazów w obrębie albumu o nazwie: 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. Załóż interfejs do obsługi wyodrębnione obrazy po zakończeniu. Nazwamy to OnPhoneImagesObtained. Oto ona:

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

4. Utwórz nową klasę: DeviceImageManager

   public class DeviceImageManager { 
   
   } 
   

5. Po stworzony DeviceImageManager, dodaj następującą metodę:

   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. Teraz wszystko, co pozostaje, to aby renderować obrazy na ekran. W moim przypadku lubię używać Picasso. Oto jak to zrobić:

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

7. Nie zapomnij dodać uprawnienia do odczytu pamięci zewnętrznej w swoim manifeście:

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

To wszystko. Możesz ruszać! Powodzenia!

Answer 4

Pobierz kod źródłowy stąd (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(); 
        } 
       } 
      } 
     } 
    } 

}