ExoPlayer架构详解与源码分析（12）——Cache_exoplayer cache

系列文章目录

ExoPlayer架构详解与源码分析（1）——前言
ExoPlayer架构详解与源码分析（2）——Player
ExoPlayer架构详解与源码分析（3）——Timeline
ExoPlayer架构详解与源码分析（4）——整体架构
ExoPlayer架构详解与源码分析（5）——MediaSource
ExoPlayer架构详解与源码分析（6）——MediaPeriod
ExoPlayer架构详解与源码分析（7）——SampleQueue
ExoPlayer架构详解与源码分析（8）——Loader
ExoPlayer架构详解与源码分析（9）——TsExtractor
ExoPlayer架构详解与源码分析（10）——H264Reader
ExoPlayer架构详解与源码分析（11）——DataSource
ExoPlayer架构详解与源码分析（12）——Cache
ExoPlayer架构详解与源码分析（13）——TeeDataSource和CacheDataSource
ExoPlayer架构详解与源码分析（14）——ProgressiveMediaPeriod
ExoPlayer架构详解与源码分析（15）——Renderer

---

---

前言

上篇介绍完基本的DataSource，现在可以开始CacheDataSource和TeeDataSource了。
先看下整体结构：

上图这里假设CacheDataSource原始的上游数据是通过OkHttpDataSource从网络获取

看完上图，是不是感觉非常复杂，没关系我们可以拆解出几个独立的结构一步步了解，可以看到底层的Cache可以作为一个独立的结构，在说CacheDataSource和TeeDataSource前，先把Cache这个基础先了解下。

Cache

可以将资源分段的缓存，资源指的是一个完整的媒体文件（如一个MP4，ts文件），每个资源都有唯一的key，一般使用资源的URI作为Key，有时候同一个资源会有不同的URI（如URI加上了失效时间）这种情况就不适合作为资源的 key了。一个资源由多个CacheSpan组成，CacheSpan包含一个数据起始位置和一个长度，代表了资源中的一段数据，CacheSpan并不一定会被Cache，当没有被Cache时叫做HoleSpan，如果被Cached CacheSpan就会对应一个缓存文件。
下面看下具体方法：

• getUid 返回缓存的非负唯一标识符，如果在确定唯一标识符之前初始化失败，则返回UID_UNSET 。一个缓存目录对应一个UID，SimpleCache会在缓存目录下创建一个UID的文件用于下次读取UID。

• release 释放缓存。当不再需要缓存时必须调用此方法。调用此方法后不得使用缓存。此方法可能很慢，通常不应在主线程上调用。

• getCachedSpans 返回给定资源key的所有CacheSpan。

• getKeys 返回所有有缓存的资源key。

• getCacheSpace 返回所有缓存所占磁盘空间大小。

• startReadWrite 通过传入的资源key获取资源，再通过postion和length获取指定的CacheSpan，当调用DataSource open数据源的时候应该同步调用此方法。

  • 如果指定位置存在已经缓存的数据，也就是CacheSpan.isCached=true，则返回的CacheSpan.file有值，表示当前缓存的文件。
  • 如果没有查询到缓存的CacheSpan则返回一个空的HoleSpan，当调用者从上游获取到数据时可以向当前的HoleSpan指定的范围写入数据，写入完成前此段HoleSpan指定的范围将会锁定，此时再通过startReadWrite会阻塞，当写入完成时，应该通过调用commitFile(File, long)会创建一个已缓存的Span提交到缓存中，此时之前阻塞的startReadWrite将会唤醒，可以获取到一个已缓存的CacheSpan,当调用者完成写入后，必须通过调用releaseHoleSpan来释放锁，此时startReadWrite可以正常获取到已缓存的CacheSpan。此方法可能会阻塞，通常不应在主线程上调用。
  • 入参length表示所请求数据的长度，如果未知则为C.LENGTH_UNSET，如果存在与该postion重叠的缓存条目，则忽略该长度，也就是入参position 的查找优先级高于length，startReadWrite通常被用于后台下载器，当下载器要下载的数据段此时正在被缓存，会等待缓存完成。

• startReadWriteNonBlocking 和startReadWrite类似，不同的是当DataSource被锁定的时候，不会阻塞会直接返回null，startReadWriteNonBlocking主要是播放器使用，因为播放器是不允许阻塞的，在缓存未获取到时会直接跳过缓存。

• startFile 获取可写入数据的缓存文件。必须先调用startReadWrite(String, long, long)获得的相应HoleSpan时才能调用。不应在主线程上调用。

• commitFile 将文件提交到缓存中。必须先调用startReadWrite(String, long, long)获得的相应HoleSpan时才能调用。不应在主线程上调用。

• releaseHoleSpan 释放从startReadWrite(String, long, long)获得的 HoleSpan。

• removeResource 删除资源的所有CacheSpans ，同时删除底层文件。

• removeSpan 从缓存中删除缓存的CacheSpan ，从而删除底层文件。不应在主线程上调用。

• isCached 返回资源中指定范围的数据是否已完全缓存。

• getCachedLength 返回从资源的position开始，直到最大maxLength的连续缓存数据的长度。如果未缓存position ，则返回-holeLength ，其中holeLength是从position开始，直到最大值maxLength的连续未缓存数据的长度。

• getCachedBytes 返回资源position （包含）和(position + length) （不包含）之间的缓存字节总数。

• applyContentMetadataMutations 存储资源相关的Meta信息如资源的总长度 。不应在主线程上调用。

• getContentMetadata 获取资源的Meta信息。

一个新的缓存添加时，Cache的一般执行顺序是：

1. startReadWrite获取HoleSpan，同时锁定这段HoleSpan，防止其他线程再次获取这段HoleSpan。
2. startFile获取CacheSpan对应的文件。
3. 对2获取的文件进行写入操作。
4. commitFile提交写入的文件,并创建与HoleSpan一致的已缓存的CacheSpan提交到Span索引，此时其他线程startReadWrite唤醒可以获取到一个CacheSpan供读取。
5. releaseHoleSpan释放startReadWrite获取HoleSpan，此时其他线程可以再次startReadWrite获取到一个HoleSpan，并再次写入数据。

继续深挖，在讲Cache实现前说下其他几个类

DataSink

这是一个用来向其中写入数据的组件，概念上是和DataSource完全相反，提供了write供外部写入数据
看下主要方法：

• open 打开一个数据源，以用来写入指定的数据，同样传入一个DataSpec参照DataSource。
• write 消费掉传入的数据，用法上和DataSource的read类型，不过这里传入的buffer是用来读取的。
• close 关闭源。即使open调用抛出IOException 时，也必须调用此方法关闭源。

CacheDataSink

CacheDataSink是DataSink主要实现，主要目的是将数据写入文件缓存，通过Cache获取文件打开写入文件，当达到指定分段大小就获取下个文件继续写入，可以设置数据分段的长度和写入缓冲区的大小。

  /** 默认文件的最大大小为5M */
  public static final long DEFAULT_FRAGMENT_SIZE = 5 * 1024 * 1024;
  /** 默认的写入流缓冲为20kb */
  public static final int DEFAULT_BUFFER_SIZE = 20 * 1024;
  @Override
  public void open(DataSpec dataSpec) throws CacheDataSinkException {
   
    ...
    try {
   
      openNextOutputStream(dataSpec);
    } catch (IOException e) {
   
      throw new CacheDataSinkException(e);
    }
  }
  //打开下一个文件
  private void openNextOutputStream(DataSpec dataSpec) throws IOException {
   
    long length =
        dataSpec.length == C.LENGTH_UNSET
            ? C.LENGTH_UNSET
            : min(dataSpec.length - dataSpecBytesWritten, dataSpecFragmentSize);
    file =//通过cache获取文件的路径
        cache.startFile(
            castNonNull(dataSpec.key), dataSpec.position + dataSpecBytesWritten, length);
    FileOutputStream underlyingFileOutputStream = new FileOutputStream(file);
    if (bufferSize > 0) {
   
      if (bufferedOutputStream == null) {
   
        bufferedOutputStream =//设置写入流缓冲大小
            new ReusableBufferedOutputStream(underlyingFileOutputStream, bufferSize);
      } else {
   
        bufferedOutputStream.reset(underlyingFileOutputStream);
      }
      outputStream = bufferedOutputStream;
    } else {
   
      outputStream = underlyingFileOutputStream;
    }
    outputStreamBytesWritten = 0;
  }
  //写入文件
  @Override
  public void write(byte[] buffer, int offset, int length) throws CacheDataSinkException {
   
    @Nullable DataSpec dataSpec = this.dataSpec;
    if (dataSpec == null) {
   
      return;
    }
    try {
   
      int bytesWritten = 0;
      while (bytesWritten < length) {
   
        if (outputStreamBytesWritten == dataSpecFragmentSize) {
   //是否已经达到文件的分段大小
          closeCurrentOutputStream();//关闭当前
          openNextOutputStream(dataSpec);//获取下个文件
        }
        int bytesToWrite =//继续写入文件数据
            (int) min(length - bytesWritten, dataSpecFragmentSize - outputStreamBytesWritten);
        castNonNull(outputStream).write(buffer, offset + bytesWritten, bytesToWrite);
        bytesWritten += bytesToWrite;
        outputStreamBytesWritten += bytesToWrite;
        dataSpecBytesWritten += bytesToWrite;
      }
    } catch (IOException e) {
   
      throw new CacheDataSinkException(e);
    }
  }
  
  private void openNextOutputStream(DataSpec dataSpec) throws IOException {
   
    long length =
        dataSpec.length == C.LENGTH_UNSET
            ? C.LENGTH_UNSET
            : min(dataSpec.length - dataSpecBytesWritten, dataSpecFragmentSize);
    file =
        cache.startFile(//这里调用了cache的startFile方法开始向文件中写入数据
            castNonNull(dataSpec.key), dataSpec.position + dataSpecBytesWritten, length);
    FileOutputStream underlyingFileOutputStream = new FileOutputStream(file);
    if (bufferSize > 0) {
   
      if (bufferedOutputStream == null) {
   
        bufferedOutputStream =
            new ReusableBufferedOutputStream(underlyingFileOutputStream, bufferSize);
      } else {
   
        bufferedOutputStream.reset(underlyingFileOutputStream);
      }
      outputStream = bufferedOutputStream;
    } else {
   
      outputStream = underlyingFileOutputStream;
    }
    outputStreamBytesWritten = 0;
  }

  private void closeCurrentOutputStream() throws IOException {
   
    if (outputStream == null) {
   
      return;
    }

    boolean success = false;
    try {
   
      outputStream.flush();
      success = true;
    } finally {
   
      Util.closeQuietly(outputStream);
      outputStream = null;
      File fileToCommit = castNonNull(file);
      file = null;
      if (success) {
   
        //写入完成后，提交缓存，会将当前的分段的CacheSpan添加入索引
        cache.commitFile(fileToCommit, outputStreamBytesWritten);
      } else {
   
        fileToCommit.delete();
      }
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

可以看到CacheDataSink主要作用是控制文件分段写入，至于文件是如何获取的则交给Cache实现。

CacheEvictor

主要用来删除缓存的CacheSpan，根据实现的移除策略调用CacheSpan.removeSpan。
这个直接看实现

LeastRecentlyUsedCacheEvictor

当缓存达到设定的最大值有限，会将最近最少使用的CacheSpan删除。

  public LeastRecentlyUsedCacheEvictor(long maxBytes) {
   
    this.maxBytes = maxBytes;
    //将CacheSpan放入到TreeSet管理排序
    this.leastRecentlyUsed = new TreeSet<>(LeastRecentlyUsedCacheEvictor::compare);
  }

 //指定排序规则
  private static int compare(CacheSpan lhs, CacheSpan rhs) {
   
    //比较CacheSpan最后使用时间
    long lastTouchTimestampDelta = lhs.lastTouchTimestamp - rhs.lastTouchTimestamp;
    if (lastTouchTimestampDelta == 0) {
   
      // Use the standard compareTo method as a tie-break.
      return lhs.compareTo(rhs);
    }
    return lhs.lastTouchTimestamp < rhs.lastTouchTimestamp ? -1 : 1;
  }
  
  @Override
  //CacheSpan添加后会回调
  public void onSpanAdded(Cache cache, CacheSpan span) {
   
    leastRecentlyUsed.add(span);
    currentSize += span.length;//更新当前的总大小
    evictCache(cache, 0);
  }

  private void evictCache(Cache cache, long requiredSpace) {
   
  //如果超出最大值则开始cache.removeSpan超出的CacheSpan
    while (currentSize + requiredSpace > maxBytes && !leastRecentlyUsed.isEmpty()) {
   
      cache.removeSpan(leastRecentlyUsed.first());
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

可以看出CacheEvictor很简单，主要作用就是管理CacheSpan，决定哪个CacheSpan优先被移除。

CachedContentIndex

主要用于保存缓存资源的索引信息，其中包含了多个资源的信息，通过资源key查询CachedContentIndex获取到CachedContent，CachedContent又包含很多的CacheSpan，最后通过position、length查询到指定的CacheSpan。

 public CachedContentIndex(
      @Nullable DatabaseProvider databaseProvider,
      @Nullable File legacyStorageDir,
      @Nullable byte[] legacyStorageSecretKey,
      
1
2
3
4