原生Android缩略图填满SD卡的问题

最新推荐文章于 2021-05-29 06:41:30 发布
最新推荐文章于 2021-05-29 06:41:30 发布
阅读量5.4k 收藏 1
点赞数
分类专栏： ANDROID 文章标签： ANDROID 移动开发
google原生Android中，MiniThumbFile.java里存储图片/视频的缩略图的算法有问题。
该算法的漏洞造成微缩略图文件（ DCIM\.thumbnails\.thumbdata4--1967290299 ）非常庞大和臃肿，多达1G，理论上可以无限大，直到填满SD卡
重现步骤：
第一步 ：插入一张拥有10万张图片的外部ＳＤ卡，
第二步 ：等待手机扫描完整个ＳＤ卡，这个过程大概30分钟。至于扫描是否完成，你可以看TAG为MediaProvider的日志。
第三步 ：拔出外部SD卡，再次等手机进行扫描大概10分钟。
第四步 ：按下手机的电源key +音量down key来截屏。
第五步 ：通过电脑查看内部SD卡的DCIM\.thumbnails\.thumbdata4--1967290299文件。这时你会发现，该文件多达1G.
对于该问题，大概的逻辑是这样的：
MediaProvider会对SD卡上的文件的进行扫描，得到一些基本的信息放入数据库的files这个表中。
对于一些图片（比如手机截屏图片），手机会以这些图片文件在files表中的_id的值，作为一个定位标志，把其缩略文件存放在.thumbdata4--1967290299中。
比如 ：_id为1，那么该文件的缩略图就存放在.thumbdata4--1967290299文件的_id * BYTES_PER_MINTHUMB开始的位置，其中BYTES_PER_MINTHUMB = 17000，
对此可以参照MiniThumbFile.java文件中的 saveMiniThumbToFile(byte[] data, long id, long magic)等函数
对于Android的Sqlite3数据库，_id是自增的。比如，最开始我插入了10001记录，这时最后一条记录的_id为10001,这时如果删除1到10000条记录，
再插入一条记录，那么这条的记录的_id值为10002.
因此， 随着用户日常中不停的向SD卡反复地添加删除文件，那么files表中的_id的值会不停的增大，
当该值为10万时，即使我们截屏时，系统只把该截屏图片这样一张图的缩略图保存在.thumbdata4--1967290299文件，
10万*BYTES_PER_MINTHUMB>1G,也就是说.thumbdata4--1967290299文件就会占用了1G多的SD空间。随着时间的推移，该值会继续变大，直到填满SD卡。
我们的方案就是把 .thumbdata4--1967290299 文件分成多个文件来存储缩略图。
比如.thumbdata4--1967290299-0存_id 为1到1024的文件的缩略图，.thumbdata4--1967290299-1存_id 为1025到2048的文件的缩略图
同时对缩略图文件做一些维护，即如果一个缩略图文件本身对应原文件不在时，清理掉该微缩略图文件。
另外在极端情况下（剩余容量小于100M下），清理掉所有的微缩略图文件。
在MTK 6575平台上对该问题的修改包含2个文件的修改： 
  
  

   
         modified
   
   :
   
    frameworks
   
   /
   
   base
   
   /
   
   media
   
   /
   
   java
   
   /
   
   android
   
   /
   
   media
   
   /
   
   MediaScanner
   
   .
   
   java
  
  

  
  

   
         modified
   
   :
   
    frameworks
   
   /
   
   base
   
   /
   
   media
   
   /
   
   java
   
   /
   
   android
   
   /
   
   media
   
   /
   
   MiniThumbFile
   
   .
   
   java
MiniThumbFile.java文件的主要修改如下： 
/**
@@ -85,16 +89,34 @@ public class MiniThumbFile {
     /*add 1 on google's version.*/
     /*this version add check code for thumbdata.*/
    private static final int MINI_THUMB_DATA_FILE_VERSION = 3 + 1;
    public static final int BYTES_PER_MINTHUMB = 17000;
    public static final int BYTES_PER_MINTHUMB = 17000;
    private static final int HEADER_SIZE = 1 + 8 + 4 + 8;
    private Uri mUri;
    private RandomAccessFile mMiniThumbFile;
    Map<Long,RandomAccessFile> mMiniThumbFilesMap = Collections.synchronizedMap(new HashMap<Long,RandomAccessFile>(5));
    private FileChannel mChannel;
    private ByteBuffer mBuffer;
    private static Hashtable<String, MiniThumbFile> sThumbFiles =
         new Hashtable<String, MiniThumbFile>();
    private static java.util.zip.Adler32 sChecker = new Adler32();
    private static final long UNKNOWN_CHECK_CODE = -1;
    final static char SEPERATE_CHAR='_';
    public static String[] parseFileName(String fileName)
    {
       String str=fileName;
       if(fileName==null)
             return null;
       int index=fileName.lastIndexOf("/");
       if(index!=-1)
       {
             str=fileName.substring(index+1);
       }
       String strs[]=str.split(SEPERATE_CHAR+"");
       if(strs==null||strs.length!=4||(!str.startsWith(".thumbdata")))
       {
             return null;
       }
       return strs;
    }
     /**
      * We store different types of thumbnails in different files. To remain backward compatibility,
      * we should hashcode of content://media/external/images/media remains the same.
@@ -105,7 +127,18 @@ public class MiniThumbFile {
        }
         sThumbFiles.clear();
    }

    private final static long getMiniThumbFileId(long id)
    {
       return (id>>8);
    }
    public final static int getMiniThumbDataFileBlockNum()
    {
       return (1<<8);
    }
    private final static long getPositionInMiniThumbFile(long id)
    {
       return (id&0xff)*BYTES_PER_MINTHUMB;
    }
    public static synchronized MiniThumbFile instance(Uri uri) {
        String type = uri.getPathSegments().get(1);
        MiniThumbFile file = sThumbFiles.get(type);
@@ -120,10 +153,11 @@ public class MiniThumbFile {
    }
    private String randomAccessFilePath(int version) {
        String type = mUri.getPathSegments().get(1);
        String directoryName =
                 Environment.getExternalStorageDirectory().toString() + "/DCIM/.thumbnails";
        return directoryName + "/.thumbdata" + version + "-" + mUri.hashCode();
        return directoryName + "/.thumbdata" + version + SEPERATE_CHAR + mUri.hashCode()+SEPERATE_CHAR+type;
    }
    /**
@@ -131,18 +165,18 @@ public class MiniThumbFile {
      * @param uri the Uri same as instance(Uri uri).
      * @return
      */
    public static String getThumbdataPath(Uri uri) {
    /*public static String getThumbdataPath(Uri uri) {
        String type = uri.getPathSegments().get(1);
        Uri thumbFileUri = Uri.parse("content://media/external/" + type + "/media");
        String directoryName = Environment.getExternalStorageDirectory().toString()
            + "/DCIM/.thumbnails";
        String path = directoryName + "/.thumbdata" + MINI_THUMB_DATA_FILE_VERSION + "-" + thumbFileUri.hashCode();
        String path = directoryName + "/.thumbdata" + MINI_THUMB_DATA_FILE_VERSION +SEPERATE_CHAR + thumbFileUri.hashCode()+SEPERATE_CHAR+type;
        if (LOG) Log.i(TAG, "getThumbdataPath(" + uri + ") return " + path);
        return path;
    }
    }*/
    private void removeOldFile() {
        String oldPath = randomAccessFilePath(MINI_THUMB_DATA_FILE_VERSION - 1);
    private void removeOldMiniThumbDataFile(long miniThumbDataFileId) {
        String oldPath =getMiniThumbDataFilePath(MINI_THUMB_DATA_FILE_VERSION - 1,miniThumbDataFileId);
        File oldFile = new File(oldPath);
        if (oldFile.exists()) {
            try {
@@ -152,35 +186,43 @@ public class MiniThumbFile {
            }
        }
    }

    private RandomAccessFile miniThumbDataFile() {
        if (mMiniThumbFile == null) {
            removeOldFile();
            String path = randomAccessFilePath(MINI_THUMB_DATA_FILE_VERSION);
            File directory = new File(path).getParentFile();
            if (!directory.isDirectory()) {
                if (!directory.mkdirs()) {
                    Log.e(TAG, "Unable to create .thumbnails directory "
                            + directory.toString());
                }
            }
    final private String getMiniThumbDataFilePath(int version,long miniThumbDataFileId)
    {
       return randomAccessFilePath(version)+SEPERATE_CHAR+miniThumbDataFileId;
    }
    private RandomAccessFile miniThumbDataFile(final long miniThumbDataFileId) {
       return miniThumbDataFile(miniThumbDataFileId,false);
    }
    private RandomAccessFile miniThumbDataFile(final long miniThumbDataFileId,boolean onlyRead) {
            RandomAccessFile miniThumbFile=mMiniThumbFilesMap.get(miniThumbDataFileId);
            String path = getMiniThumbDataFilePath(MINI_THUMB_DATA_FILE_VERSION,miniThumbDataFileId);
            File f = new File(path);
            if (miniThumbFile == null||!f.exists()) {
			if(onlyRead)
				return null;
            removeOldMiniThumbDataFile(miniThumbDataFileId);
                File directory = new File(path).getParentFile();
                if (!directory.isDirectory()) {
                    if (!directory.mkdirs()) {
                        Log.e(TAG, "Unable to create .thumbnails directory "
                                + directory.toString());
                    }
                }
           
            try {
                mMiniThumbFile = new RandomAccessFile(f, "rw");
                miniThumbFile = new RandomAccessFile(f, "rw");
            } catch (IOException ex) {
                 // Open as read-only so we can at least read the existing
                 // thumbnails.
                try {
                    mMiniThumbFile = new RandomAccessFile(f, "r");
					miniThumbFile = new RandomAccessFile(f, "r");
                } catch (IOException ex2) {
                }
            }
            if (mMiniThumbFile != null) {
                mChannel = mMiniThumbFile.getChannel();
            }
            mMiniThumbFilesMap.put(miniThumbDataFileId, miniThumbFile);
        }
        return mMiniThumbFile;
        return miniThumbFile;
    }
     public MiniThumbFile(Uri uri) {
@@ -189,10 +231,19 @@ public class MiniThumbFile {
     }
     public synchronized void deactivate() {
        if (mMiniThumbFile != null) {
        if (mMiniThumbFilesMap != null) {
              Set<Long> keySet=mMiniThumbFilesMap.keySet();
            try {
                mMiniThumbFile.close();
                mMiniThumbFile = null;
				for(Long key:keySet)
				{
                    RandomAccessFile file=mMiniThumbFilesMap.get(key);
                    if(file!=null)
                    {
                        mMiniThumbFilesMap.put(key, null);
                        file.close();
                    }
				}
				mMiniThumbFilesMap.clear();
             } catch (IOException ex) {
                 // ignore exception
             }
@@ -205,18 +256,20 @@ public class MiniThumbFile {
         // check the mini thumb file for the right data.  Right is
         // defined as having the right magic number at the offset
         // reserved for this "id".
        RandomAccessFile r = miniThumbDataFile();
        final long miniThumbDataFileId=getMiniThumbFileId(id);
        RandomAccessFile r = miniThumbDataFile(miniThumbDataFileId,true);
        if (r != null) {
            long pos = id * BYTES_PER_MINTHUMB;
            FileChannel channel=r.getChannel();
            long pos = getPositionInMiniThumbFile(id);
            FileLock lock = null;
            try {
                mBuffer.clear();
                mBuffer.limit(1 + 8);
                lock = mChannel.lock(pos, 1 + 8, true);
                lock = channel.lock(pos, 1 + 8, true);
                // check that we can read the following 9 bytes
                // (1 for the "status" and 8 for the long)
                if (mChannel.read(mBuffer, pos) == 9) {
                if (channel.read(mBuffer, pos) == 9) {
                    mBuffer.position(0);
                    if (mBuffer.get() == 1) {
                        return mBuffer.getLong();
@@ -242,10 +295,12 @@ public class MiniThumbFile {
     public synchronized void saveMiniThumbToFile(byte[] data, long id, long magic)
            throws IOException {
        RandomAccessFile r = miniThumbDataFile();
       final long miniThumbDataFileId=getMiniThumbFileId(id);
        RandomAccessFile r = miniThumbDataFile(miniThumbDataFileId);
        if (r == null) return;
        long pos = id * BYTES_PER_MINTHUMB;
        final long pos = getPositionInMiniThumbFile(id);
        FileChannel channel=r.getChannel();
        FileLock lock = null;
        try {
            if (data != null) {
@@ -266,14 +321,13 @@ public class MiniThumbFile {
					check = sChecker.getValue();
                }
                mBuffer.putLong(check);
                if (LOG) Log.i(TAG, "saveMiniThumbToFile(" + id + ") flag=1, magic="
                        + magic + ", length=" + data.length + ", check=" + check);
                
                mBuffer.put(data);
                mBuffer.flip();
                lock = mChannel.lock(pos, BYTES_PER_MINTHUMB, false);
                mChannel.write(mBuffer, pos);
                lock = channel.lock(pos, BYTES_PER_MINTHUMB, false);
                channel.write(mBuffer, pos);
                if (LOG) Log.i(TAG, "saveMiniThumbToFile(" + id + ") flag=1, magic="
                        + magic + ", length=" + data.length + ", check=" + check);
            }
        } catch (IOException ex) {
            Log.e(TAG, "couldn't save mini thumbnail data for "
@@ -319,27 +373,29 @@ public class MiniThumbFile {
      * @return
      */
     public synchronized byte[] getMiniThumbFromFile(long id, byte [] data, ThumbResult result) {
        RandomAccessFile r = miniThumbDataFile();
        final long miniThumbDataFileId=getMiniThumbFileId(id);
        RandomAccessFile r = miniThumbDataFile(miniThumbDataFileId,true);
        if (r == null) return null;
        long pos = id * BYTES_PER_MINTHUMB;
        long pos = getPositionInMiniThumbFile(id);
        FileChannel channel=r.getChannel();
        FileLock lock = null;
        try {
            mBuffer.clear();
            lock = mChannel.lock(pos, BYTES_PER_MINTHUMB, true);
            int size = mChannel.read(mBuffer, pos);
            lock = channel.lock(pos, BYTES_PER_MINTHUMB, true);
            int size = channel.read(mBuffer, pos);
            if (size > 1 + 8 + 4 + 8) { // flag, magic, length, check code
                mBuffer.position(0);
                byte flag = mBuffer.get();
                long magic = mBuffer.getLong();
                int length = mBuffer.getInt();
                long check = mBuffer.getLong();
                if (LOG) Log.i(TAG, "getMiniThumbFromFile(" + id + ") flag=" + flag
                        + ", magic=" + magic + ", length=" + length + ", check=" + check);
               
                long newCheck = UNKNOWN_CHECK_CODE;
                if (size >= 1 + 8 + 4 + 8 + length && data.length >= length) {
                    mBuffer.get(data, 0, length);
                    Log.i(TAG, " success to getMiniThumbFromFile(" + id + ") flag=" + flag
                            + ", magic=" + magic + ", length=" + length + ", check=" + check);
                    synchronized (sChecker) {
                        sChecker.reset();
                        sChecker.update(data, 0, length);





 
 
 
 

   MediaScanner.java文件的修改如下： 
 
 
 
 
  
@@ -1224,14 +1224,14 @@ public class MediaScanner
                c.close();
             }
            if (videoCount != 0) {
            /*if (videoCount != 0) {
                 String fullPathString = MiniThumbFile.getThumbdataPath(mVideoThumbsUri);
                 existingFiles.remove(fullPathString);
             }
             if (imageCount != 0) {
                 String fullPathString = MiniThumbFile.getThumbdataPath(mThumbsUri);
                 existingFiles.remove(fullPathString);
            }
            }*/
             for (String fileToDelete : existingFiles) {
                 if (LOG)
                     Log.v(TAG, "fileToDelete is " + fileToDelete);
@@ -1247,7 +1247,163 @@ public class MediaScanner
             e.printStackTrace();
         }
     }
    /*[robin_20120511*/
    private void pruneDeadMiniThumbnailFiles() {
        HashSet<String> existingFiles = new HashSet<String>();
        String directory = Environment.getExternalStorageDirectory().toString() + "/DCIM/.thumbnails";
        File file=new File(directory);
        String [] files = (file).list();
        if (files == null) {
            files = new String[0];
        }
        for (int i=0; i < files.length; i++) {
            String fullPathString = directory + "/" + files[i];
            existingFiles.add(fullPathString);
        }
        try {
            Cursor c = mMediaProvider.query(
                    mThumbsUri,
                    new String [] { "_data" },
                    null,
                    null,
                    null);
             if (null != c) {
                if (c.moveToFirst()) {
                    do {
                        String fullPathString = c.getString(0);
                        existingFiles.remove(fullPathString);
                    } while (c.moveToNext());
                }
                c.close();
            }
            c = mMediaProvider.query(
                    mVideoThumbsUri,
                    new String [] { "_data" },
                    null,
                    null,
                    null);
            if (null != c) {
                if (c.moveToFirst()) {
                    do {
                        String fullPathString = c.getString(0);
                        existingFiles.remove(fullPathString);
                    } while (c.moveToNext());
                }
                c.close();
            }
            String strs[];
            long fileSN;
            long id0;
            long id1;
            int blockNum=MiniThumbFile.getMiniThumbDataFileBlockNum();
            final String selection_IMAGE=" "+Images.Thumbnails.IMAGE_ID+">=? AND "+Images.Thumbnails.IMAGE_ID+"<?";
            final String sortOrder_IMAGE=Images.Thumbnails.IMAGE_ID;
            final String selection_VIDEO=" "+Video.Thumbnails.VIDEO_ID+">=? AND "+Video.Thumbnails.VIDEO_ID+"<?";
            final String sortOrder_VIDEO=Video.Thumbnails.VIDEO_ID;
            HashSet<String> fileSet=new HashSet<String>(existingFiles);
            for (String fileToDelete : fileSet) {
              strs=MiniThumbFile.parseFileName(fileToDelete);
                if(strs==null||strs.length!=4)
                {
                      existingFiles.remove(fileToDelete);
                      continue;
                }
                if("images".equals(strs[2])||"video".equals(strs[2]))
                {
                    fileSN=Long.parseLong(strs[3]);
                    id0=blockNum*fileSN;
                    id1=blockNum*(fileSN+1);
                    final String[] selectionArgs= new String[]{id0+"",id1+""};
                    if("images".equals(strs[2]))
                    {
                       
                        c = mMediaProvider.query(
                                mThumbsUri,
                               new String [] { Images.Thumbnails.IMAGE_ID },
                               selection_IMAGE,
                                selectionArgs,
                                sortOrder_IMAGE);
                        if (null != c) {
                            if (c.getCount()>0) {
                             
                              existingFiles.remove(fileToDelete);
                                   }
                            c.close();
                        }
                    }
                    else if ("video".equals(strs[2]))
                    {
                        c = mMediaProvider.query(
                                mVideoThumbsUri,
                                new String [] { Video.Thumbnails.VIDEO_ID },
                                selection_VIDEO,
                                selectionArgs,
                                sortOrder_VIDEO);
                        if (null != c) {
                            if (c.getCount()>0) {
                              existingFiles.remove(fileToDelete);
                            }
                            c.close();
                        }                   
                    }
                }
                else
                {
                      existingFiles.remove(fileToDelete);
                }
            }
            for (String fileToDelete : existingFiles) {
                if (LOG)
                    Log.v(TAG, "fileToDelete is " + fileToDelete);
                try {
                    (new File(fileToDelete)).delete();
                } catch (SecurityException ex) {
                    ex.printStackTrace();
                }
            }
            file=new File(directory);
            long freeDiskSpape=(file.getUsableSpace()>>20);
            /*
             * when the free Disk is very low(<100M),delete all MiniThumbFile
             */
            if(freeDiskSpape<100)
            {
				files = (file).list();
                if (files == null) {
                    files = new String[0];
                }
                for (int i=0; i < files.length; i++) {
                    String fullPathString = directory + "/" + files[i];
                    existingFiles.add(fullPathString);
                }
                fileSet=new HashSet<String>(existingFiles);
                for (String fileToDelete : fileSet) {
                      strs=MiniThumbFile.parseFileName(fileToDelete);
                    if(strs==null||strs.length!=4)
                    {
						existingFiles.remove(fileToDelete);
						continue;
                    }
                }
                for (String fileToDelete : existingFiles) {
                    if (LOG)
                        Log.v(TAG, "Memeroy is very Low.delete MiniThumbFile:" + fileToDelete);
                    try {
                        (new File(fileToDelete)).delete();
                    } catch (SecurityException ex) {
                        ex.printStackTrace();
                    }
                }
               
            }
            Log.v(TAG, "pruneDeadMiniThumbnailFiles... " + c);
        } catch (RemoteException e) {
            /* We will soon be killed...*/
            e.printStackTrace();
        }
    }
    /*robin_20120511]*/
     private void postscan(String[] directories) throws RemoteException {
         Iterator<FileCacheEntry> iterator = mFileCache.values().iterator();
@@ -1306,8 +1462,12 @@ public class MediaScanner
         if ((mOriginalCount == 0 || mOriginalVideoCount == 0)
                 && mImagesUri.equals(Images.Media.getContentUri("external"))) {
            pruneDeadThumbnailFiles();
        }/*[robin_20120511*/
        else if (mImagesUri.equals(Images.Media.getContentUri("external")))
        {
            pruneDeadMiniThumbnailFiles();
        }

        /*robin_20120511]*/
        /* allow GC to clean up*/
        mPlayLists = null;
        mFileCache = null;
@@ -1399,7 +1559,12 @@ public class MediaScanner
             long prune = System.currentTimeMillis();
             pruneDeadThumbnailFiles();
             if (LOG) Log.d(TAG, "mtkPostscan: pruneDeadThumbnailFiles takes " + (System.currentTimeMillis() - prune) + "ms.");
        }/*[robin_20120511*/
        else if (mImagesUri.equals(Images.Media.getContentUri("external")))
        {
             pruneDeadMiniThumbnailFiles();
        }
        /*robin_20120511]*/
      
         // allow GC to clean up
         mPlayLists = null;


 
 
 
 
 
  
 
 
 
 

    结束！ 
 
 


                

        

        

    




    

      

        

            

              
                
                  叶飘飘
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
JS原生带缩略图的图片切换效果

				
			

			

				

					01-19
				

			

		

		

			
				
左边是banner图，右边是缩略图，当鼠标滑入缩略图时，也会切换图片。 一、这段是html代码，可以直接拷贝，需要自己准备相同大小的banner图，例中图片都是500×300  <!DOCTYPE html> <html lang=en> <...

			
		

	



                

              
                



	

		

			

				
					
【Android】从内部存储说起，你的手机里的文件都是些什么？

					
最新发布

				
			

			

				

					silencef_sin的博客
				

				

					10-28
					
					1000
					
				

			

		

		

			
				
安卓内部存储文件介绍。

			
		

	



                


  
              

                


	

		

			

				
					
thumbdata4删除后果_安卓手机上巨大的.thumbdata4图片预读缓存清理方法

				
			

			

				

					weixin_33765959的博客
				

				

					12-23
					
					6362
					
				

			

		

		

			
				
以下是目前找到比较有效的帮 .thumbdata4-文件瘦身的好方法.下面的一大堆废话的核心就是进手机设置>应用程序>显示系统程序>媒体存储器>存储>清除数据/缓存.重启后会发现thumbdata还会出现但是没有数GB那么大了.How do I Reset the AndroidMedia Scan Database?Android has a system-leve...

			
		

	





	

		

			

				
					
Android系统如何扫描手机SD卡中的视频文件

				
			

			

				

					u011206077的专栏
				

				

					08-29
					
					3303
					
				

			

		

		

			
				
android系统启动时会去扫描系统文件，并将系统支持的视频文件（mp4,3gp,wmv）扫描到媒体库（MediaStore）中，下面代码演示如何获得这些文件的信息：





[java] view
 plaincopy






public static List sysVideoList = null;// 视频信息集合  
sysVideoList = n

			
		

	



		

			
		



	

		

			

				
					
VitamioBanner_原生_android视频图片混合轮播_

				
			

			

				

					10-01
				

			

		

		

			
				
用原生的mediaplayer+viewpage实现 视频 图片 混合轮播

			
		

	





	

		

			

				
					
原生js焦点图3屏带缩略图选项卡图片切换代码   

				
			

			

				

					11-23
				

			

		

		

			
				
原生js焦点图3屏带缩略图选项卡图片切换代码 原生js焦点图3屏带缩略图选项卡图片切换代码 原生js焦点图3屏带缩略图选项卡图片切换代码 

			
		

	





	

		

			

				
					
原生js实现带缩略图文字简介幻灯轮播图js插件.zip

				
			

			

				

					07-11
				

			

		

		

			
				
原生js实现带缩略图文字简介幻灯轮播图js插件下载。支持自动轮播。

			
		

	





	

		

			

				
					
android sd 视频文件,Android 扫描SD卡中的所有视频文件

				
			

			

				

					weixin_35275073的博客
				

				

					05-27
					
					604
					
				

			

		

		

			
				
Android应该是已经把所有的视频文件音频都在开机时，扫描完毕然后存在本地SQLite数据库了，因此，我们“扫描”的最简单方法是读取这个已经存储好的数据库。但是这样做，在程序开启过程中，用户添加或删除了音频视频文件，此时需要重新mount相关设备，才能保证程序的正确性。另外一种方法是判断文件后缀，不如以上方法来的简单。下面简单介绍如何使用第一种方法读取SD卡中的所有视频文件布局文件：自动生成的即...

			
		

	





	

		

			

				
					
2019最新原生js实现带缩略图文字说明左右轮播切换相册插件.zip

				
			

			

				

					07-11
				

			

		

		

			
				
简单实用原生js实现带缩略图文字说明左右轮播切换相册插件下载。一款基于原生JavaScript实现图片相册幻灯轮播图特效插件，没有引入任何jQuery库，短短数行原生php中文网实现。
             

			
		

	





	

		

			

				
					
系统源码分析-系统缩略图小文件系统MiniThumbFile

				
			

			

				

					佳朗的专栏
				

				

					04-28
					
					316
					
				

			

		

		

			
				
前些日子看张绍文的高手课 / IO优化（中）时，里面提到了微信的一个小文件系统，但是没有细说，在评论区回答学员的问题时大概说了下原理：

作者回复: 这个小文件系统是应用层的方案，只是把一大堆的小文件组织成一个超大文件。并没有
替换原生的文件系统

笔者看到这块，突然想到很早之前看过的系统缩略图相关源码时，了解到的一个知识点跟其描述的很像，猜测大概就是类似的东西，随重新温习一下。

			
		

	





	

		

			

				
					
thumbdata3--1967290299

				
			

			

				

					xxMix的专栏
				

				

					10-02
					
					2241
					
				

			

		

		

			
				
.thumbdata3--1967290299和·thumbnails是安卓系统中相机和图片的缓存文件，该文件一般会占用内存很大，小的几百M，大的话则会有1.5G~7.5G左右，而且此文件还会无限制的扩大，删除后还是死灰复燃。的确是比较困扰用户的一个问题。




目录

1简介

2功能

3解决方案
▪ 
1文件替换法 ▪ 
2屏蔽扫描法 ▪ 
3相机，图库替换法

			
		

	





	

		

			

				
					
sdcard/DCIM/.thumbnails文件夹里的庞然大物 是这样来的

				
			

			

				

					MaximusKiang的专栏
				

				

					06-20
					
					7188
					
				

			

		

		

			
				
From:http://bbs.anzhi.com/thread-5961340-1-1.html
/mnt/sdcard/DCIM/.thumbnails/.thumbdata3--1967290299  都知道这里的都是缓存  但是
 这个文件小则几百MB，大则几个GB，你sd卡+手机

里的图片总共也没这么大吧  

，是不是很郁闷？！


这个文件的一些细节介绍如下：


			
		

	





	

		

			

				
					
Android外部存储(/storage/emulated/0)无法创建文件夹

					
热门推荐

				
			

			

				

					Death Note
				

				

					04-17
					
					7万+
					
				

			

		

		

			
				
程序：
//获取外部存储路径
String storage = Environment.getExternalStorageDirectory().getPath() + "/smallIcon2";
File dirFile = new File(storage);
Log.d("dirFile", "" + dirFile);
if (!dirFile.exists()) {
    bool...

			
		

	





	

		

			

				
					
android thumbnail获取图片,系统获取视频缩略图的getThumbnail()真的那么快吗？

				
			

			

				

					weixin_36318506的博客
				

				

					05-29
					
					953
					
				

			

		

		

			
				
一：系统提供的一个从数据库中获得缩略图的方法我在这篇使用七牛云存储上传android本地视频并播放博客中使用了下面的android系统提供的api来获取视频的缩略图bitmap = MediaStore.Video.Thumbnails.getThumbnail(mContentResolver, anInt, MediaStore.Video.Thumbnails.MICRO_KIND, nul...

			
		

	





	

		

			

				
					
帮我用原生JS写一个带缩略图的轮播图

				
			

			

				

					03-07
				

			

		

		

			
				
好的，以下是一个使用原生JS实现带缩略图的轮播图的示例代码：

HTML部分：
```
<div class="slider">
  <div class="slides">
    <div class="slide"><img src="image1.jpg"></div>
    <div class="slide"><img src="image2.jpg"></div>
    <div class="slide"><img src="image3.jpg"></div>
    <div class="slide"><img src="image4.jpg"></div>
  </div>
  <div class="thumbnails"></div>
</div>
```

CSS部分：
```
.slider {
  position: relative;
  overflow: hidden;
}

.slides {
  display: flex;
  transition: transform 0.3s ease-in-out;
}

.slide {
  flex: 0 0 100%;
}

.slide img {
  width: 100%;
  height: auto;
}

.thumbnails {
  display: flex;
  justify-content: center;
  margin-top: 10px;
}

.thumbnail {
  flex: 0 0 auto;
  margin-right: 10px;
}

.thumbnail img {
  width: 100%;
  height: auto;
  opacity: 0.5;
  cursor: pointer;
}

.thumbnail img.active {
  opacity: 1;
}
```

JS部分：
```
const slider = document.querySelector('.slider');
const slides = slider.querySelector('.slides');
const slideWidth = slider.clientWidth;
const thumbnails = slider.querySelector('.thumbnails');

let slideIndex = 0;

function showSlide(index) {
  slides.style.transform = `translateX(-${slideWidth * index}px)`;
  thumbnails.querySelector('.active').classList.remove('active');
  thumbnails.querySelectorAll('.thumbnail')[index].querySelector('img').classList.add('active');
}

function nextSlide() {
  slideIndex = (slideIndex + 1) % slides.children.length;
  showSlide(slideIndex);
}

function initThumbnails() {
  for (let i = 0; i < slides.children.length; i++) {
    const thumbnail = document.createElement('div');
    thumbnail.classList.add('thumbnail');
    const thumbnailImg = document.createElement('img');
    thumbnailImg.src = slides.children[i].querySelector('img').src;
    thumbnailImg.addEventListener('click', () => {
      slideIndex = i;
      showSlide(slideIndex);
    });
    thumbnail.appendChild(thumbnailImg);
    thumbnails.appendChild(thumbnail);
  }
  thumbnails.querySelectorAll('.thumbnail')[slideIndex].querySelector('img').classList.add('active');
}

initThumbnails();
setInterval(nextSlide, 5000);
```

这段代码实现了一个基本的轮播图，其中每张图片都有一个对应的缩略图，点击缩略图可以切换到对应的图片。轮播图会自动切换，每5秒自动播放下一张图片。请注意，这只是一个简单的示例代码，可能需要根据实际需求进行修改和调整。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值