Android读取SD/USB空间大小以及内容

最新推荐文章于 2021-05-25 19:01:10 发布
最新推荐文章于 2021-05-25 19:01:10 发布
阅读量1.9k 收藏
点赞数
分类专栏： Android开发 Android菜鸟自学之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a550508153/article/details/51646662
版权

  Android.os下的StatFs类主要用来获取文件系统的状态，能够获取sd卡的大小和剩余空间，获取系统内部空间也就是/system的大小和剩余空间等等。


　　看下读取sd卡的：

　　 Java代码
  1. void  readSDCard() {  
  2.         String state = Environment.getExternalStorageState();  
  3.         if (Environment.MEDIA_MOUNTED.equals(state)) {  
  4.             File sdcardDir = Environment.getExternalStorageDirectory();  
  5.             StatFs sf = new  StatFs(sdcardDir.getPath());  
  6.             long  blockSize = sf.getBlockSize();  
  7.             long  blockCount = sf.getBlockCount();  
  8.             long  availCount = sf.getAvailableBlocks();  
  9.             Log.d("" ,  "block大小:" + blockSize+ ",block数目:" + blockCount+ ",总大小:" +blockSize*blockCount/ 1024 + "KB" );  
  10.             Log.d("" ,  "可用的block数目：:" + availCount+ ",剩余空间:" + availCount*blockSize/ 1024 + "KB" );  
  11.         }     
  12.     }  
  13. void readSDCard() {
  14.      String state = Environment.getExternalStorageState();
  15.      if(Environment.MEDIA_MOUNTED.equals(state)) {
  16.       File sdcardDir = Environment.getExternalStorageDirectory();
  17.       StatFs sf = new StatFs(sdcardDir.getPath());
  18.       long blockSize = sf.getBlockSize();
  19.       long blockCount = sf.getBlockCount();
  20.       long availCount = sf.getAvailableBlocks();
  21.       Log.d("", "block大小:"+ blockSize+",block数目:"+ blockCount+",总大小:"+blockSize*blockCount/1024+"KB");
  22.       Log.d("", "可用的block数目：:"+ availCount+",剩余空间:"+ availCount*blockSize/1024+"KB");
  23.      }  
  24.     }   
复制代码
然后看下读取系统内部空间的：

　　 Java代码
  1. 　　void readSystem() {

  3. 　　File root = Environment.getRootDirectory();

  5. 　　StatFs sf = new StatFs(root.getPath());

  7. 　　long blockSize = sf.getBlockSize();

  9. 　　long blockCount = sf.getBlockCount();

  11. 　　long availCount = sf.getAvailableBlocks();

  13. 　　Log.d("" , "block大小:" + blockSize+ ",block数目:" + blockCount+ ",总大小:" +blockSize*blockCount/ 1024 + "KB" );

  15. 　　Log.d("" , "可用的block数目：:" + availCount+ ",可用大小:" + availCount*blockSize/ 1024 + "KB" );

  17. 　　}

  19. 　　void readSystem() {

  21. 　　File root = Environment.getRootDirectory();

  23. 　　StatFs sf = new StatFs(root.getPath());

  25. 　　long blockSize = sf.getBlockSize();

  27. 　　long blockCount = sf.getBlockCount();

  29. 　　long availCount = sf.getAvailableBlocks();

  31. 　　Log.d("", "block大小:"+ blockSize+",block数目:"+ blockCount+",总大小:"+blockSize*blockCount/1024+"KB");

  33. 　　Log.d("", "可用的block数目：:"+ availCount+",可用大小:"+ availCount*blockSize/1024+"KB");

  35. 　　}
复制代码

      StatFs获取的都是以block为单位的，这里我解释一下block的概念：


　　1.硬件上的 block size, 应该是"sector size"，linux的扇区大小是512byte

　　2.有文件系统的分区的block size, 是"block size"，大小不一，可以用工具查看

　　3.没有文件系统的分区的block size，也叫“block size”，大小指的是1024 byte

　　4.Kernel buffer cache 的block size, 就是"block size"，大部分PC是1024

　　5.磁盘分区的"cylinder size"，用fdisk 可以查看。

　　我们这里的block size是第二种情况，一般SD卡都是fat32的文件系统，block size是4096.

　　这样就可以知道手机的内部存储空间和sd卡存储空间的总大小和可用大小了。 
public class GetMediasInfo {
	
	private static final String TAG = "MediaInfoUtil";
	
	private static final String USB_PATH = "/storage/usbotg";
	private static final String USB_FILTER = "usbotg";
	private static final String SD_PATH = "/storage/sdcard1";
	private static final String SD_FILTER = "sdcard1";
	private static final String INTERNAL_PATH = "/storage/sdcard0";
	private static final String INTERNAL_FILTER = "sdcard0";
	
	public static final int PARAMETER_SOURCE_TYPE_INTERNAL = 0;
	public static final int PARAMETER_SOURCE_TYPE_SD = 1;
	public static final int PARAMETER_SOURCE_TYPE_USB = 2;
		
	public static final int PARAMETER_STORAGE_UNIT_MB = 3;
	public static final int PARAMETER_STORAGE_UNIT_GB = 4;
	
	public static final int RESULT_SOURCE_ERROR = -1;
	public static final int RESULT_INTERNAL_ERROR = -2;
	public static final int RESULT_PARAMETER_ERROR = -3;
	public static final int RESULT_INFO_NUMBER_ZERO = -4;
	public static final int RESULT_INFO_Resolver_NULL = -5;
		
	public static boolean storageExist(String path){
		
		try {
			File file = new File(path);
			if(null == file){
				return false;
			}
				
			File[] files = file.listFiles();
			if(null == files || files.length == 0){
				return false;
			}
			return true;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return false;
	}
	
	public static boolean getUsbState(){
		return storageExist(USB_PATH);
	}
	
	public static boolean getSdState(){
		return storageExist(SD_PATH);
	}
	
    @SuppressLint("NewApi") 
    public static double getStorageTotalSize(int sourceType, int unit){
		
		String path = null;
		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			
			if(!storageExist(SD_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			path = SD_PATH;
		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			
			if(!storageExist(USB_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			path = USB_PATH;
		}else{
			
			return RESULT_PARAMETER_ERROR;
		}
		try {
			StatFs stat = new StatFs(path); 
			long blockSize = stat.getBlockSizeLong();
			long blockCount = stat.getBlockCountLong();
			double Total;
			
			if(unit == PARAMETER_STORAGE_UNIT_MB){
				
				Total = blockCount * blockSize / 1024 / 1024;
				Total = (double)Math.round(Total*10)/10;
				Log.w(TAG, "TotalSize:"+Total+"MB");
			}else if(unit == PARAMETER_STORAGE_UNIT_GB){
				
				Total = ( 10 * blockCount * blockSize / 1024 / 1024 / 1024 ) * 0.1;
				Total = (double)Math.round(Total*10)/10;
				Log.w(TAG, "TotalSize:"+Total+"GB");
			}else{
				
				Total = blockCount * blockSize / 1024 / 1024;
				Total = (double)Math.round(Total*10)/10;
				Log.w(TAG, "TotalSize:"+Total+"MB");
			}
					
			return Total;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return 0;
	}
	
	@SuppressLint("NewApi")
	public static double getStorageAvailaleSize(int sourceType, int unit){
		//get used space size
		String path = null;
		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			
			if(!storageExist(SD_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			path = SD_PATH;
		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			
			if(!storageExist(USB_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			path = USB_PATH;
		}else{
			
			return RESULT_PARAMETER_ERROR;
		}
		try {
			StatFs stat = new StatFs(path); 
			long blockSize = stat.getBlockSizeLong();
			long availaleBlockCount = stat.getAvailableBlocksLong();
			
			double Total;
			
			if(unit == PARAMETER_STORAGE_UNIT_MB){
				
				Total = availaleBlockCount * blockSize / 1024 / 1024;
				Total = (double)Math.round(Total*10)/10;
				Log.w(TAG, "availaleSize:"+Total+"MB");
			}else if(unit == PARAMETER_STORAGE_UNIT_GB){
				
				Total = ( 10 * availaleBlockCount * blockSize / 1024 / 1024 / 1024 ) * 0.1;
				Total = (double)Math.round(Total*10)/10;
				Log.w(TAG, "availaleSize:"+Total+"GB");
			}else{
				
				Total = availaleBlockCount * blockSize / 1024 / 1024;
				Total = (double)Math.round(Total*10)/10;
				Log.w(TAG, "availaleSize:"+Total+"MB");
			}
					
			return Total;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return 0;
	}
	
	public static int getMusicInfoSongNums(Context context,int sourceType){
		String pathFilter = " ";
		Uri queryUri;
		int Result_count = 0;
		
		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			if(!storageExist(SD_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			pathFilter = SD_FILTER;
			queryUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;

		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			if(!storageExist(USB_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			pathFilter = USB_FILTER;
			queryUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_INTERNAL == sourceType){
			if(!storageExist(INTERNAL_PATH)){
				return RESULT_SOURCE_ERROR;
			}	
			pathFilter = INTERNAL_FILTER;
			queryUri = MediaStore.Audio.Media.INTERNAL_CONTENT_URI;
		}else{
			return RESULT_PARAMETER_ERROR;
		}

        ContentResolver contentResolver = context.getContentResolver();
        Cursor cursor = contentResolver.query(queryUri, null,
                null, null, MediaStore.Audio.Media.DEFAULT_SORT_ORDER);
        
        int fileNum = cursor.getCount();
        Log.d(TAG,"cursor.getCount: "+fileNum);
        cursor.moveToFirst();
        Result_count = 0;

        for(int counter = 0; counter < fileNum; counter++){ 
            String path = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));
            if(!path.contains(pathFilter)){
            	cursor.moveToNext();
            	continue;
            }
            Result_count++;
            cursor.moveToNext();
        }
        cursor.close();
        Log.d(TAG, "=====>Result_count1 is:"+Result_count);
        return Result_count;
	}
	
	
	
	public static int getMusicInfo(Context context,int sourceType, ArrayList<MusicInfo> infoList){
		
		String pathFilter = " ";
		Uri queryUri;
		int Result_count = 0;

		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			if(!storageExist(SD_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			pathFilter = SD_FILTER;
			queryUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;

		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			if(!storageExist(USB_PATH)){
				return RESULT_SOURCE_ERROR;
			}
			pathFilter = USB_FILTER;
			queryUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_INTERNAL == sourceType){
			if(!storageExist(INTERNAL_PATH)){
				return RESULT_SOURCE_ERROR;
			}	
			pathFilter = INTERNAL_FILTER;
			queryUri = MediaStore.Audio.Media.INTERNAL_CONTENT_URI;
		}else{
			return RESULT_PARAMETER_ERROR;
		}

        ContentResolver contentResolver = context.getContentResolver();
        Cursor cursor = contentResolver.query(queryUri, null,
                null, null, MediaStore.Audio.Media.DEFAULT_SORT_ORDER);

            if(cursor == null){
                Log.w(TAG, "query music result Cursor == null");
                return RESULT_INTERNAL_ERROR;
            }

            int fileNum = cursor.getCount();
            Log.d(TAG,"cursor.getCount: "+fileNum);
            cursor.moveToFirst();
            infoList.clear();
            for(int counter = 0; counter < fileNum; counter++){ 
                String path = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));
                if(!path.contains(pathFilter)){
                	cursor.moveToNext();
                	continue;
                }

                MusicInfo info = new MusicInfo();
                info.setMusicId(cursor.getInt(cursor.getColumnIndex(BaseColumns._ID)));
                info.setTitle(cursor.getString(cursor.getColumnIndex(MediaColumns.TITLE)));
                info.setArtist(cursor.getString(cursor.getColumnIndex(AudioColumns.ARTIST)));
                info.setAlbum(cursor.getString(cursor.getColumnIndex(AudioColumns.ALBUM)));
                info.setAlbumId(cursor.getInt(cursor.getColumnIndex(AudioColumns.ALBUM_ID)));
                info.setDuration(cursor.getString(cursor.getColumnIndex(AudioColumns.DURATION)));
                info.setPath(cursor.getString(cursor.getColumnIndex(MediaColumns.DATA)));
                info.setSize(cursor.getString(cursor.getColumnIndex(MediaColumns.SIZE)));
                //info.setAlbumImage(getMusicAlbumImage(context,cursor.getString(cursor.getColumnIndex(AudioColumns.ALBUM_ID))));
                if(PARAMETER_SOURCE_TYPE_SD == sourceType){
                	info.setMusicResource(PARAMETER_SOURCE_TYPE_SD);
                }else if(PARAMETER_SOURCE_TYPE_USB == sourceType){
                	info.setMusicResource(PARAMETER_SOURCE_TYPE_USB);
                }              
                infoList.add(info);
                Result_count++;
                cursor.moveToNext();
            }
        cursor.close();
        return Result_count;
    }
	
	public static int getVideoInfoVideoNums(Context context,int sourceType){
		String pathFilter = " ";
		Uri queryUri;
		int Result_count = 0;

		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			
			if(!storageExist(SD_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = SD_FILTER;
			queryUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			
			if(!storageExist(USB_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = USB_FILTER;
			queryUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_INTERNAL == sourceType){
			
			if(!storageExist(INTERNAL_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = INTERNAL_FILTER;
			queryUri = MediaStore.Video.Media.INTERNAL_CONTENT_URI;
		}else{
			
			return RESULT_PARAMETER_ERROR;
		}

        ContentResolver contentResolver = context.getContentResolver();
        Cursor cursor = contentResolver.query(queryUri, null,
                null, null, MediaStore.Video.Media.DEFAULT_SORT_ORDER);


            if(cursor == null){
                Log.w(TAG, "query music result Cursor == null");
                return RESULT_INTERNAL_ERROR;
            }

            int fileNum = cursor.getCount();
            cursor.moveToFirst();
            Result_count = 0;
            for(int counter = 0; counter < fileNum; counter++){            	 
                String path = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));
                if(!path.contains(pathFilter)){
                	cursor.moveToNext();
                	continue;
                }
                Result_count++;
                cursor.moveToNext();
            }
        cursor.close();
        Log.d(TAG, "=====>Result_count2 is:"+Result_count);
        return Result_count;
	}
	
	public static int getVideoInfo(Context context,int sourceType,ArrayList<VideoInfo> infoList){
		
		Log.d(TAG, "getVideoInfo");
		
		BitmapFactory.Options options = new BitmapFactory.Options();
        options.inDither = false;
        options.inJustDecodeBounds = false; 
    	options.inSampleSize = 30;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
		
		String pathFilter = " ";
		Uri queryUri;
		int Result_count = 0;

		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			
			if(!storageExist(SD_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = SD_FILTER;
			queryUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			
			if(!storageExist(USB_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = USB_FILTER;
			queryUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_INTERNAL == sourceType){
			
			if(!storageExist(INTERNAL_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = INTERNAL_FILTER;
			queryUri = MediaStore.Video.Media.INTERNAL_CONTENT_URI;
		}else{
			
			return RESULT_PARAMETER_ERROR;
		}

        ContentResolver contentResolver = context.getContentResolver();
        Cursor cursor = contentResolver.query(queryUri, null,
                null, null, MediaStore.Video.Media.DEFAULT_SORT_ORDER);


            if(cursor == null){
                Log.w(TAG, "query music result Cursor == null");
                return RESULT_INTERNAL_ERROR;
            }

            int fileNum = cursor.getCount();
            cursor.moveToFirst();
            infoList.clear();
            for(int counter = 0; counter < fileNum; counter++){
                String path = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));
                if(!path.contains(pathFilter)){
                	cursor.moveToNext();
                	continue;
                }

                VideoInfo info = new VideoInfo();
                info.setId(cursor.getString(cursor.getColumnIndex(BaseColumns._ID)));
                info.setTitle(cursor.getString(cursor.getColumnIndex(MediaColumns.TITLE)));
                info.setArtist(cursor.getString(cursor.getColumnIndex(VideoColumns.ARTIST)));
                info.setAlbum(cursor.getString(cursor.getColumnIndex(VideoColumns.ALBUM)));
                info.setDuration(cursor.getString(cursor.getColumnIndex(VideoColumns.DURATION)));
                info.setPath(cursor.getString(cursor.getColumnIndex(MediaColumns.DATA)));
                info.setSize(cursor.getString(cursor.getColumnIndex(MediaColumns.SIZE)));
                infoList.add(info);
                
                
                Result_count++;
                cursor.moveToNext();
            }
        cursor.close();
        return Result_count;
    }
	
	public static int getImageInfoImageNums(Context context,int sourceType){
		String pathFilter = " ";
		Uri queryUri;
		int Result_count = 0;

		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			
			if(!storageExist(SD_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = SD_FILTER;
			queryUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			
			if(!storageExist(USB_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = USB_FILTER;
			queryUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_INTERNAL == sourceType){
			
			if(!storageExist(INTERNAL_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = INTERNAL_FILTER;
			queryUri = MediaStore.Images.Media.INTERNAL_CONTENT_URI;
		}else{
			
			return RESULT_PARAMETER_ERROR;
		}

        ContentResolver contentResolver = context.getContentResolver();
        
        if(contentResolver == null){
        	Log.w("contentResolver", sourceType+" :RESULT_INFO_Resolver_NULL");
        	return RESULT_INFO_Resolver_NULL;
        }
        Cursor cursor = contentResolver.query(queryUri, null,
                null, null, MediaStore.Images.Media.DEFAULT_SORT_ORDER);


        if(cursor == null){
            Log.w(TAG, "query music result Cursor == null");
            return RESULT_INTERNAL_ERROR;
        }

        int fileNum = cursor.getCount();
        Log.d(TAG,"cursor.getCount: "+fileNum);
        Result_count = 0;
        cursor.moveToFirst();
        for(int counter = 0; counter < fileNum; counter++){            	 
            String path = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));                
            if(!path.contains(pathFilter)){
            	cursor.moveToNext();
            	continue;
            }
            Result_count++;
            cursor.moveToNext();
        }
        cursor.close();
        Log.d("getImageInfo", "getImageInfo Result_count :"+Result_count);
        Log.d(TAG, "=====>Result_count3 is:"+Result_count);
        return Result_count;

	}
	
	public static int getImageInfo(Context context,int sourceType,ArrayList<ImageInfo> infoList){
		
		Log.d("getImageInfo", "getImageInfo");
		
		BitmapFactory.Options options = new BitmapFactory.Options();
        options.inDither = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
		
		String pathFilter = " ";
		Uri queryUri;
		int Result_count = 0;

		if( PARAMETER_SOURCE_TYPE_SD == sourceType){
			
			if(!storageExist(SD_PATH))
				return RESULT_SOURCE_ERROR;
			//pathFilter = SD_PATH;
			pathFilter = SD_FILTER;
			queryUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_USB == sourceType){
			
			if(!storageExist(USB_PATH))
				return RESULT_SOURCE_ERROR;
			//pathFilter = USB_PATH;
			pathFilter = USB_FILTER;
			queryUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
		}else if( PARAMETER_SOURCE_TYPE_INTERNAL == sourceType){
			
			if(!storageExist(INTERNAL_PATH))
				return RESULT_SOURCE_ERROR;
			pathFilter = INTERNAL_FILTER;
			queryUri = MediaStore.Images.Media.INTERNAL_CONTENT_URI;
		}else{
			
			return RESULT_PARAMETER_ERROR;
		}

        ContentResolver contentResolver = context.getContentResolver();
        
        if(contentResolver == null){
        	Log.w("contentResolver", sourceType+" :RESULT_INFO_Resolver_NULL");
        	return RESULT_INFO_Resolver_NULL;
        }
        Cursor cursor = contentResolver.query(queryUri, null,
                null, null, MediaStore.Images.Media.DEFAULT_SORT_ORDER);


            if(cursor == null){
                Log.w(TAG, "query music result Cursor == null");
                return RESULT_INTERNAL_ERROR;
            }

            int fileNum = cursor.getCount();
            Log.d(TAG,"cursor.getCount: "+fileNum);

            cursor.moveToFirst();
            infoList.clear();
            for(int counter = 0; counter < fileNum; counter++){
            
            	//Log.w(TAG, "path is: " + cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA)));
            	 
                String path = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));
                /*if(!path.startsWith(pathFilter))
                	continue;*/
                
                if(!path.contains(pathFilter)){
                	cursor.moveToNext();
                	continue;
                }

                ImageInfo info = new ImageInfo();
                info.setId(cursor.getString(cursor.getColumnIndex(BaseColumns._ID)));
                info.setTitle(cursor.getString(cursor.getColumnIndex(MediaColumns.TITLE)));
                info.setPath(cursor.getString(cursor.getColumnIndex(MediaColumns.DATA)));
                info.setSize(cursor.getString(cursor.getColumnIndex(MediaColumns.SIZE)));
                /*Bitmap bitmap = MediaStore.Images.Thumbnails.getThumbnail(contentResolver,cursor.getLong(cursor.getColumnIndex(MediaStore.Images.Media._ID)),
                		Images.Thumbnails.MICRO_KIND, options);
                if(bitmap == null){
                	
                	Log.w("getImageInfo",info.getTitle()+":Thumbnails == null");
                	
                }
                info.setThumbnail(bitmap);*/
                infoList.add(info);
                Result_count++;
                cursor.moveToNext();
            }
        cursor.close();
        Log.d("getImageInfo", "getImageInfo Result_count :"+Result_count);
        return Result_count;

    }
	
	
	public static String getMusicAlbumImage(Context context,String album_id) {  
        String mUriAlbums = "content://media/external/audio/albums";  
        String[] projection = new String[] { "album_art" };  
        Cursor cur = context.getContentResolver().query(Uri.parse(mUriAlbums + "/" + album_id),  
										                projection, null, null, null);  
       String album_art = null;  
        if (cur.getCount() > 0 && cur.getColumnCount() > 0) {  
            cur.moveToNext();  
            album_art = cur.getString(0);  
        }  
        cur.close();  
        cur = null;  
        return album_art;  
    }
	
	
	public static String getVideoAlbumArt(Context context,String album_id) {  
        String mUriAlbums = "content://media/external/video/albums";  
        String[] projection = new String[] { "album_art" };  
        Cursor cur = context.getContentResolver().query(  
                Uri.parse(mUriAlbums + "/" + album_id),  
                projection, null, null, null);  
       String album_art = null;  
        if (cur.getCount() > 0 && cur.getColumnCount() > 0) {  
            cur.moveToNext();  
            album_art = cur.getString(0);  
        }  
        cur.close();  
        cur = null;  
        return album_art;  
    }
	
	private static Bitmap mCachedBit = null;
    private static final BitmapFactory.Options sBitmapOptionsCache = new BitmapFactory.Options();
    private static final BitmapFactory.Options sBitmapOptions = new BitmapFactory.Options();
    private static final Uri sArtworkUri = Uri.parse("content://media/external/audio/albumart");
    
    static protected Uri getContentURIForPath(String path) {
        return Uri.fromFile(new File(path));
    }

    private static StringBuilder sFormatBuilder = new StringBuilder();
    private static Formatter sFormatter = new Formatter(sFormatBuilder, Locale.getDefault());
    private static final Object[] sTimeArgs = new Object[5];
    
    
    public static Bitmap getAlbumBitmap(Context context,long songId,long albumId){
    	
    	 Bitmap bm = GetMediasInfo.getArtwork(context, songId, albumId, false);
         if (bm == null) {
             bm = GetMediasInfo.getArtwork(context, songId, -1);
         }
         return bm;
    }
    
   /* public static Bitmap getImageBitmap(Context context,long imageId){
    	
   	 Bitmap bm = GetMediasInfo.getArtwork(context, imageId, albumId, false);
        if (bm == null) {
            bm = GetMediasInfo.getArtwork(context, imageId, -1);
        }
        return bm;
   }*/
    
    private static BitmapFactory.Options options = null;
	
	static{
		
		options = new BitmapFactory.Options();
        options.inDither = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
	}
	
	public static Bitmap getVideoBitmap(Context context,int videoId){
		Bitmap map = MediaStore.Images.Thumbnails.getThumbnail(context.getContentResolver(),videoId,Images.Thumbnails.MICRO_KIND, options);
		if(map == null){
			return BitmapFactory.decodeStream(
	                context.getResources().openRawResource(R.drawable.video_bg), null, options);
		}
		return map;
	}
	
	public static Bitmap getImageBitmap(Context context,int imageId){
		Bitmap map = MediaStore.Images.Thumbnails.getThumbnail(context.getContentResolver(),imageId,Images.Thumbnails.MICRO_KIND, options);
		if(map == null){
			return BitmapFactory.decodeStream(
	                context.getResources().openRawResource(R.drawable.video_bg), null, options);
		}
		return map;
	}

   
    public static Bitmap getArtwork(Context context, long song_id, long album_id) {
        return getArtwork(context, song_id, album_id, true);
    }

    /** Get album art for specified album. You should not pass in the album id
     * for the "unknown" album here (use -1 instead)
     */
    public static Bitmap getArtwork(Context context, long song_id, long album_id,
            boolean allowdefault) {

        if (album_id < 0) {
            // This is something that is not in the database, so get the album art directly
            // from the file.
            if (song_id >= 0) {
                Bitmap bm = getArtworkFromFile(context, song_id, -1);
                if (bm != null) {
                	ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
                    if (baos.toByteArray().length / 1024 < 50) { 
                        return bm;
                    }
                }
            }
            if (allowdefault) {
                return getDefaultArtwork(context);
            }
            return null;
        }

        ContentResolver res = context.getContentResolver();
        Uri uri = ContentUris.withAppendedId(sArtworkUri, album_id);
        if (uri != null) {
            InputStream in = null;
            try {
                in = res.openInputStream(uri);
                //return BitmapFactory.decodeStream(in, null, sBitmapOptions);
                return decodeSampledBitmapFromStream(in, 100, 100);
            } catch (FileNotFoundException ex) {
                // The album art thumbnail does not actually exist. Maybe the user deleted it, or
                // maybe it never existed to begin with.
                Bitmap bm = getArtworkFromFile(context, song_id, album_id);
                if (bm != null) {
                    if (bm.getConfig() == null) {
                        bm = bm.copy(Bitmap.Config.RGB_565, false);
                        if (bm == null && allowdefault) {
                            return getDefaultArtwork(context);
                        }
                    }
                } else if (allowdefault) {
                    bm = getDefaultArtwork(context);
                }
                return bm;
            } finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                } catch (IOException ex) {
                }
            }
        }
        return null;
    }
    
    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {   
	    final int height = options.outHeight;   
	    final int width = options.outWidth;   
	    int inSampleSize = 1;   
	    if (height > reqHeight || width > reqWidth) {   
	        final int heightRatio = Math.round((float) height / (float) reqHeight);   
	        final int widthRatio = Math.round((float) width / (float) reqWidth);    
	        inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;   
	    }   
	    return inSampleSize;   
	} 
	
	public static Bitmap decodeSampledBitmapFromStream(InputStream res, int reqWidth, int reqHeight) {   
	    BitmapFactory.Options options = new BitmapFactory.Options();   
	    options.inJustDecodeBounds = true; 
	    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);   
	    options.inJustDecodeBounds = false;   
	    return BitmapFactory.decodeStream(res, null, options);   
	}  
   
    private static final String sExternalMediaUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI.toString();
    private static Bitmap getArtworkFromFile(Context context, long songid, long albumid) {
        Bitmap bm = null;
        byte [] art = null;
        String path = null;

    	BitmapFactory.Options options=new BitmapFactory.Options();  
    	options.inJustDecodeBounds = false;  
    	options.inSampleSize = 20;     
    	//Bitmap btp =BitmapFactory.decodeStream(is,null,options);

        if (albumid < 0 && songid < 0) {
            throw new IllegalArgumentException("Must specify an album or a song id");
        }

        try {
            if (albumid < 0) {
                Uri uri = Uri.parse("content://media/external/audio/media/" + songid + "/albumart");
                ParcelFileDescriptor pfd = context.getContentResolver().openFileDescriptor(uri, "r");
                if (pfd != null) {
                    FileDescriptor fd = pfd.getFileDescriptor();
                    bm = BitmapFactory.decodeFileDescriptor(fd);
                    BitmapFactory.decodeFileDescriptor(fd, null, options);
                }
            } else {
                Uri uri = ContentUris.withAppendedId(sArtworkUri, albumid);
                ParcelFileDescriptor pfd = context.getContentResolver().openFileDescriptor(uri, "r");
                if (pfd != null) {
                    FileDescriptor fd = pfd.getFileDescriptor();
                    bm = BitmapFactory.decodeFileDescriptor(fd, null, options);
                }
            }
        } catch (IllegalStateException ex) {
        } catch (FileNotFoundException ex) {
        }
        if (bm != null) {
            mCachedBit = bm;
        }
        return bm;
    }
    
    private static Bitmap getDefaultArtwork(Context context) {
        BitmapFactory.Options opts = new BitmapFactory.Options();
        opts.inPreferredConfig = Bitmap.Config.ARGB_8888;
        return BitmapFactory.decodeStream(
                context.getResources().openRawResource(R.drawable.cd_bg), null, opts);
    }
}

风轻云喏
关注
专栏目录
Android 6.0上sdcard和U盘路径获取和区分
xuan521521的博客
04-26 5729
Android6.0上会根据卡的种类和卡的挂载状态来动态生成挂载路径，所以之前写固定路径的办法不可用，最后通过网上查找和分析android源码，通过反射获取到路径，并且进行了正确区分，代码如下： /**      * 6.0获取外置sdcard和U盘路径，并区分      * @param mContext      * @param keyword  SD = "内部存储"; EXT =
android u盘挂载监听,Android SD卡及U盘插拔状态监听及内容读取
weixin_39986896的博客
05-30 1782
本篇是通过系统方法来对sd卡及U盘插拔监听及数据获取，Android盒子端开发，有系统权限，当然，这个比较简单，知道具体方法，可以通过反射来实现。先贴上效果图：获取外置存储设备并监听插拔状态获取文件内容前言先说需求，App在引导过程中，通过外置存储设备(U盘或者sd卡)上传指定的配置文件，开始我没打算用系统方法，网上看到 libaums 这个库文件，尝试使用了一下，但是最后发现它并不能友好的支持N...
Android 对于外部TF（SD）卡和U盘的读写操作
空中的晨曦博客
09-17 6065
首先读取外置TF卡，需要获取到外置TF卡的权限，因为Android 在4.4版本之后 引入了外部存储访问的框架（SAF）。SAF其中的部分功能就是通过其获取对外置TF卡的读写权限，从而操作外置TF卡。 在Android7.0时对外部存储进行了简化 1、TF卡读写操作 1.1获取TF卡权限 private void showOpenDocumentTree(String rootPath) { Intent intent = null; if (Build.VERSION.SDK_I
Android获取u盘容量的方法,android经过usb读取U盘的方法
weixin_39931101的博客
05-25 1695
本文实例为你们分享了android经过usb读取U盘的具体代码，供你们参考，具体内容以下java1.关联 compile ‘com.github.mjdev:libaums:+'android2.权限设置git3.监听u盘 插入拔出的广播github//监听otg插入 拔出IntentFilter usbDeviceStateFilter = new IntentFilter();usbDevic...
Android监听外部存储设备的状态（SD卡、U盘等等）
winson_jason的专栏
01-20 3480
最近在项目中需要对外部存储设备的状态进行监听，所以整理了此笔记，以便日后查看。 外部存储设备的状态变化时发出的广播 对比不同状态下的广播 1. 插入外部SD卡时： 2. 移除外部SD卡时： 3. 连接PC进入USB大容量存储模式时： 4. 连接PC退出USB大
android 6.0 获取U盘的各种信息
xzx208的博客
03-02 1745
权限 首先获取U盘信息，我们需要在androidmanifest.xml中添加以下权限 &lt;uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /&gt; &lt;uses-permission android:name="android.permission.READ_EXTERNAL_STOR...
android U盘检测及获取内存信息
abc137508277的专栏
08-14 4201
在网上查了一些资料。U盘检测的方法一般有两种方式，检测电池或者查看配置信息。 1.Batterymanager检测方法如下： IntentFilter mIntentFilter = new IntentFilter(); mIntentFilter.addAction(Intent.ACTION_BATTERY_CHANGED); registerReceiver(BtStatusR
Android获取可用内存（系统，sd卡，u盘）
FErryer_linj的博客
02-07 1456
/** *通过反射获取不同存储卡的路径，主要是用来获取外挂sd卡路径，内置sd卡路径可通过Environment类的方法获得 */ public static boolean hasEnoughStorage(Context context) { // StorageManager storageManager = (StorageManager) context.getSystem
Android获取u盘容量的方法,Android 6.0上sdcard和U盘路径获取和区分方法
weixin_31653453的博客
05-25 587
Android6.0上会根据卡的种类和卡的挂载状态来动态生成挂载路径，所以之前写固定路径的办法不可用，最后通过网上查找和分析android源码，通过反射获取到路径，并且进行了正确区分，代码如下：/*** 6.0获取外置sdcard和U盘路径，并区分* @param mContext* @param keyword SD = "内部存储"; EXT = "SD卡"; USB = "U盘"* @ret...
Android 7.1获取外置SD卡和ＵＳＢ路径的几种方式
qq_32390877的博客
05-22 8350
在把Android4.4的代码移植到Android7.1的时候发现原来的SD卡路径不可用了，通过log日志的查看发现路径变成了/storage/7A40-AD28了，看见这个一脸懵逼啊，总感觉这个路径怪怪的。抱着疑惑的态度我又插了另外一张SD卡，谁知道路径又变了。这不是坑吗？在网上找了一大堆的，发现这个的方法可行：https://blog.csdn.net/u010663758/article/d...
android 读取外置和内置存储卡路径和大小
07-29
android 读取外置和内置存储卡路径和大小,亲测好使，项目中以运用
Android编程获取SD卡路径及剩余容量的方法
01-21
本文实例讲述了Android编程获取SD卡路径及剩余容量的方法。分享给大家供大家参考，具体如下： public static String getExternalStoragePath() { // 获取SdCard状态 String state = android.os.Environment.getExternalStorageState(); // 判断SdCard是否存在并且是可用的 if (android.os.Environment.MEDIA_MOUNTED.equals(state)) { if (android.os.Environment.getExternal
Android U盘读写 反射获取U盘路径
04-09
Android U盘读写 反射获取U盘路径
Android 6.0上sdcard和U盘路径获取和区分方法
08-27
今天小编就为大家分享一篇Android 6.0上sdcard和U盘路径获取和区分方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Android代码-大容量存储(U盘配置)
08-06
UMS Interface This program allows you to chose a block device or disk image as a 'disk', and communicate with PC through usb mass storage (just as usb disk do). Root permission is needed. download apk introduction quick start usb connection: set current data source as U disk mount to: mount current data source quick create: create a image with the given size,format as vfat,mount it,and use it as U disk *If the file you just copied can not be displayed immediately, try click 'close'/'lau
android-usb-cardreader:在 Android 上与 USB 读卡器接口的示例
06-01
这个项目对于开发者来说是一个宝贵的资源，它提供了详细的代码示例，可以帮助他们理解和实现Android设备通过USB接口读取SD卡或其他存储设备上的数据。 在描述中提到的“android-usb-读卡器&rdquo;，进一步强调了这个项目...
Android TV USB路径或手机SDCARD路径获取
04-08
请注意，对于USB OTG设备（例如USB闪存盘），路径可能会是`/dev/bus/usb/001/002`这样的形式，而不是传统的文件系统路径。在这种情况下，你可能需要通过`ParcelFileDescriptor`来读写文件。 在Android TV设备上，...
Win32 Disk Imager:Windows工具，用于将图像写入USB记忆棒或SD / CF卡-开源
05-08
这对于嵌入式开发（即Arm开发项目（Android，Arm上的Ubuntu等））非常有用。 任何人都可以自由分支和修改此程序。 补丁总是受欢迎的。 此版本适用于Windows 7 / 8.1 / 10。 它也将在Windows Server 2008/2012/2016...
android u盘检测工具,android U盘检测及获取内存储器信息
weixin_34036667的博客
05-25 850
android U盘检测及获取内存信息在网上查了一些资料。U盘检测的方法一般有两种方式，检测电池或者查看配置信息。1.Batterymanager检测方法如下：IntentFilter mIntentFilter = new IntentFilter();mIntentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);registerReceiver(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值