七猫广告sdk激励视频流量优化

前言

目前公司正在搭建广告ADX平台，使用自研的七猫SDK渲染图文、视频广告，用户在阅读器内看书时，为了节省用户流量，视频广告在移动网络下不会播放视频，只会显示封面，但是用户选择看激励视频时，遇到了一些问题。下面分析下几种不同方案各自存在的问题，以及我们最后的解决方案。

第一种方案是不做任何缓存，直接播放，用户每次播放视频素材都会消耗一次流量；

结论：这种方案比较消耗流量。

第二种方案是等待视频下载完成再播放，在视频下载过程中，用户面对着黑屏要一直等待，直到视频下载完成，之前某家联盟广告就是采用的这种方案，线上收到很多用户反馈黑屏时间长、视频无法播放的情况，因为网络不好时，用户等待时间可能超过30s，极大的影响用户体验；

结论：观看视频体验不友好。

第三种方案是边下边播，视频在播放的同时下载资源到本地，视频在播放时需要消耗一次流量，同时视频下载会消耗一次流量，相当于第一次播放下载会消耗两倍流量，后续播放相同素材就从本地读取，不会消耗流量。

结论：这种方案也比较消耗流量。

那么有没有更好的方式，让用户体验友好的同时自始自终只消耗一倍流量呢？请耐心往下看。

最终技术方案

想要实现一倍流量，一种方案是存储播放器加载的数据到本地，下次直接从本地读书数据播放，项目中使用的是系统的mediaPlayer播放器，播放逻辑封装在c层，想要实现缓存，必须要改系统源码，实现起来难度较大，且对系统稳定性有影响。

另一种方案是在播放器与视频源服务器之间加了一层代理服务器，截取视频播放器发送的请求，根据截取的请求，向网络服务器请求数据，然后写到本地，本地代理服务器从文件中读取数据并发送给播放器进行播放。目前市面上使用上述原理的成熟框架主要有两种：AndroidVideoCache和JeffVideoCache，两者都实现了边下边播功能，且消耗一倍流量，技术原理也是一样的，下图是两者的区别。

依上图可知，jeffVideoCache实现的功能更加全面，但是使用的人数少，后期维护风险大，androidVideoCache也能满足节省流量的需求，由于社区活跃、功能更加稳定，因此后者更适合在我们的项目中应用。

AndroidVideoCache的应用

1.基本使用

使用builder模式构建httpProxyCacheServer对象，将服务端的url转为本地的url链接，设置给播放器，开始播放。

HttpProxyCacheServer proxy = new HttpProxyCacheServer.Builder(this).build();
 String proxyUrl = proxy.getProxyUrl(url);
 videoView.setVideoPath(proxyUrl);
 videoView.start();

2.原理简介

主要的实现原理是在本地客户端实现一个代理服务器，客户端将视频链接转为本地host链接给播放器，代理服务器的sockt监听到请求过来时，会再开一个线程，从原始的url读取数据到本地的文件，同时socket读取本地文件的数据写入，mediaPlay通过binder通信读取数据给c层，播放视频。

3.源码分析

在讲源码之前，先了解mediaplayer视频播放来源，可以是文件，也可以是网络url请求，下面是mediaPlayer源码。

private void setDataSource(String path, String[] keys, String[] values,
        List<HttpCookie> cookies)
        throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {
    final Uri uri = Uri.parse(path);
    final String scheme = uri.getScheme();
    if ("file".equals(scheme)) {
      //file开头是本地文件uri,从本地读取
        path = uri.getPath();
    } else if (scheme != null) {
    
        nativeSetDataSource(
          //传递mediaHttpService给c层
            MediaHTTPService.createHttpServiceBinderIfNecessary(path, cookies),
            path,
            keys,
            values);
        return;
    }

    final File file = new File(path);
    try (FileInputStream is = new FileInputStream(file)) {
        setDataSource(is.getFD());
    }
}

nativeSetDataSource是个native方法，通过jni调用创建MediaHTTPConnection对象，内部HttpUrlConnection负责发起真正的网络请求数据。AndroidVideoCache要将请求转为本地的代理服务器的请求，需要将url配置成本地的host和端口号，下面是对url的处理流程图。

文件缓存不支持.m3u8格式的视频素材，因为它是多文件格式返回，无法做客户缓存，rtmp/rtsp开头是直播类的请求也不支持，然后对url做md5加密作为文件名，如果本地已缓存成功，播放器从本地读取数据播放，不存在则ping本地连接，成功则说明本地代理服务器可用。第一行代码使用建造者模式，配置参数。

    private static final long DEFAULT_MAX_SIZE = 512 * 1024 * 1024;
    //文件默认保存路径，有外置存储权限会保存在外置卡中，没有会保存在cache文件夹下
    private File cacheRoot;
  //文件名生成器，默认是对url进行md5加密
    private FileNameGenerator fileNameGenerator;
  //缓存清除策略，默认是LRU清理算法
    private DiskUsage diskUsage;
  //资源信息存储策略，存储url,length,mimetype，默认存储数据库
    private SourceInfoStorage sourceInfoStorage;
  //为url添加请求头，默认不添加
    private HeaderInjector headerInjector;

    public Builder(Context context) {
        this.sourceInfoStorage = SourceInfoStorageFactory.newSourceInfoStorage(context);
        this.cacheRoot = StorageUtils.getIndividualCacheDirectory(context);
        this.diskUsage = new TotalSizeLruDiskUsage(DEFAULT_MAX_SIZE);
        this.fileNameGenerator = new Md5FileNameGenerator();
        this.headerInjector = new EmptyHeadersInjector();
    }
   
   public HttpProxyCacheServer build() {
            Config config = buildConfig();
     //构建代理服务器对象
            return new HttpProxyCacheServer(config);
        }
}

创建本地代理服务器ServerSocket，最多允许8个客户端并发连接读取数据，然后创建一个线程一直等待客户端连接，这里用了CountDownLatch线程同步锁，因为创建线程耗时操作，防止服务端没有创建好就走了下面代码，出现异常情况。Sokect通信原理见下图。

public class HttpProxyCacheServer {
    
    private static final String PROXY_HOST = "127.0.0.1";
    private ExecutorService socketProcessor=Executors.newFixedThreadPool(8);

private HttpProxyCacheServer(Config config) {
    this.config = checkNotNull(config);
    try {
        InetAddress inetAddress = InetAddress.getByName(PROXY_HOST);
        this.serverSocket = new ServerSocket(0, 8, inetAddress);
        this.port = serverSocket.getLocalPort();
        IgnoreHostProxySelector.install(PROXY_HOST, port);
        CountDownLatch startSignal = new CountDownLatch(1);
        this.waitConnectionThread = new Thread(new WaitRequestsRunnable(startSignal));
        this.waitConnectionThread.start();
        startSignal.await(); 
        this.pinger = new Pinger(PROXY_HOST, port);
        HttpProxyCacheDebuger.printfLog("Proxy cache server started. Is it alive? " + isAlive());
    } catch (IOException | InterruptedException e) {
        socketProcessor.shutdown();
        throw new IllegalStateException("Error starting local proxy server", e);
    }
}
  
    private void waitForRequest() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
              //此方法一直阻塞...,有请求过来时会往下走
                Socket socket = serverSocket.accept();
                socketProcessor.submit(new SocketProcessorRunnable(socket));
            }
        } catch (IOException e) {
            onError(new ProxyCacheException("Error during waiting connection", e));
        }
    }
  
  //客户端socket处理任务
    private void processSocket(Socket socket) {
        try {
            GetRequest request = GetRequest.read(socket.getInputStream());
            String url = ProxyCacheUtils.decode(request.uri);
            if (pinger.isPingRequest(url)) {
                pinger.responseToPing(socket);
            } else {
                HttpProxyCacheServerClients clients = getClients(url);
                clients.processRequest(request, socket);
            }
        } catch (SocketException e) {
        } catch (ProxyCacheException | IOException e) {
            onError(new ProxyCacheException("Error processing request", e));
        } finally {
            releaseSocket(socket);
            HttpProxyCacheDebuger.printfLog("Opened connections: " + getClientsCount());
        }
    }
  
}

socketProcessor线程池的作用是并发处理客户端请求，如果是ping请求，会向ping回写ping ok字段，socket收到之后会比对字段，相同则表示连接成功。正常请求会创建HttpProxyCacheServerClients代理客户端管理类，它主要做的是客户端代理HttpProxyCache生命周期管理和回调监听。

  
public void processRequest(GetRequest request, Socket socket) throws ProxyCacheException, IOException {
    startProcessRequest();
    try {
        clientsCount.incrementAndGet();
        proxyCache.processRequest(request, socket);
    } finally {
        finishProcessRequest();
    }
}
//创建客户端代理对象
private synchronized void startProcessRequest() throws ProxyCacheException {
    proxyCache = proxyCache == null ? newHttpProxyCache() : proxyCache;
}
//关闭客户端代理线程
private synchronized void finishProcessRequest() {
    if (clientsCount.decrementAndGet() <= 0) {
        proxyCache.shutdown();
        proxyCache = null;
    }
}
}

HtttpProxyCache是处理请求的核心类，首先会写响应头，包括content-length，accept-range,content-type等键值对，然后判断是否从文件读取缓存，从文件缓存读的条件是文件长度为0，或者request.partial为false，其实就是没有ranage字段，或者有请求头range字段，但值小于缓存文件已读取的长度加上总长度的20%，然后太大也不走文件缓存。

public void processRequest(GetRequest request, Socket socket) throws IOException, ProxyCacheException {
    OutputStream out = new BufferedOutputStream(socket.getOutputStream());
    String responseHeaders = newResponseHeaders(request);
    out.write(responseHeaders.getBytes("UTF-8"));

    long offset = request.rangeOffset;
    if (isUseCache(request)) {
        responseWithCache(out, offset);
    } else {
        responseWithoutCache(out, offset);
    }
}

private boolean isUseCache(GetRequest request) throws ProxyCacheException {
    long sourceLength = source.length();
    boolean sourceLengthKnown = sourceLength > 0;
    long cacheAvailable = cache.available();
    /**
    *Content-Length的值要大于0
    *range字段值要大于0
    *range值要比缓存偏移值大，但不能超过总长度的20%
    *NO_CACHE_BARRIER：0.2f
    **/
    return !sourceLengthKnown || !request.partial || request.rangeOffset <= cacheAvailable + sourceLength * NO_CACHE_BARRIER;
}

先看读取文件缓存的实现逻辑，我们知道一开始文件里面肯定是空的，所以要先从远程服务器里面读到文件，然后再从文件读取，先看文件的读写操作类，用的是RandomAccessFile对象，因为它既可以读，也可以写，同时还可以seek到某个位置，一般用于分段下载场景。需要注意的是，在创建文件时是在原文件名中添加了.download的后缀名，表示文件正在下载中，然后在下载完成时会重新命名成原来的名字。

public FileCache(File file, DiskUsage diskUsage) throws ProxyCacheException {
    try {
        if (diskUsage == null) {
            throw new NullPointerException();
        }
        this.diskUsage = diskUsage;
        File directory = file.getParentFile();
        Files.makeDir(directory);
        boolean completed = file.exists();
        this.file = completed ? file : new File(file.getParentFile(), file.getName() + TEMP_POSTFIX);
        this.dataFile = new RandomAccessFile(this.file, completed ? "r" : "rw");
    } catch (IOException e) {
        throw new ProxyCacheException("Error using file " + file + " as disc cache", e);
    }
}
    public synchronized int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
        try {
            dataFile.seek(offset);
            return dataFile.read(buffer, 0, length);
        } catch (IOException e) {
            String format = "Error reading %d bytes with offset %d from file[%d bytes] to buffer[%d bytes]";
            throw new ProxyCacheException(String.format(format, length, offset, available(), buffer.length), e);
        }
    }
public synchronized void append(byte[] data, int length) throws ProxyCacheException {
        try {
            if (isCompleted()) {
                throw new ProxyCacheException("Error append cache: cache file " + file + " is completed!");
            }
            dataFile.seek(available());
            dataFile.write(data, 0, length);
        } catch (IOException e) {
            String format = "Error writing %d bytes to %s from buffer with size %d";
            throw new ProxyCacheException(String.format(format, length, dataFile, data.length), e);
        }
    }

读取远程数据是readSourceAsync方法，它又开启了新的线程，每次读8192个字节，一次性写完，然后socket线程每次从文件读8192个字节，然后写入到socket中，如果文件读比文件写快的话，有设置1s的同步线程锁，当文件写完一个buffer，通知这边读一个buffer，从而保证有序进行读取。

private void responseWithCache(OutputStream out, long offset) throws ProxyCacheException, IOException {
    byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
    int readBytes;
    
    while ((readBytes = read(buffer, offset, buffer.length)) != -1) {
        out.write(buffer, 0, readBytes);
        offset += readBytes;
    }
    out.flush();
}

  public int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
        ProxyCacheUtils.assertBuffer(buffer, offset, length);
    
        while (!cache.isCompleted() && cache.available() < (offset + length) && !stopped) {
            readSourceAsync();
            waitForSourceData();//等待1s
            checkReadSourceErrorsCount();
        }
        int read = cache.read(buffer, offset, length);
        if (cache.isCompleted() && percentsAvailable != 100) {
            percentsAvailable = 100;
            onCachePercentsAvailableChanged(100);
        }
        return read;
    }
 private void waitForSourceData() throws ProxyCacheException {
        synchronized (wc) {
            try {
                wc.wait(1000);
            } catch (InterruptedException e) {
                throw new ProxyCacheException("Waiting source data is interrupted!", e);
            }
        }
    }

    private void notifyNewCacheDataAvailable(long cacheAvailable, long sourceAvailable) {
        onCacheAvailable(cacheAvailable, sourceAvailable);

        synchronized (wc) {
            wc.notifyAll();
        }
    }

大概的源码分析完了，总结一下就是将播放地址转为本地host和port给mediaPlayer，客户端开启serverSocket监听请求，mediaplayer发送请求时，socket解析请求，判断是否需要走文件缓存，还是走直接下载方式，文件下载成功存储到本地，下次同一url请求时直接从本地文件读取，不消耗流量。

4.结果分析

测试结果符合预期，边下边播只消耗了一倍的流量，后续播放从本地文件读取，不消耗流量，如图所示，使用charles抓包看到发起了两次网络请求，第一次只请求了很小的数据量，第二次才请求了完整的数据，为什么会请求两次呢？这和mp4的格式有关系，下图是用mediaParser工具查看到的mp4文件结构

其中 moov 记录 MP4 视频的元信息，特别是 trak记录着视频播放数据的时间和空间信息。而 mdat 则是保存着视频音频信息。而视频的拖动，快进，都是需要根据 moov 和拖动至的时间，来计算要 seek 到的文件位置。 但是 MP4 文件，不一定 moov 就在文件开头，也有可能在文件末尾。

在发起http请求时，会先读取moov头部信息（moov 一般都比较小），获取到视频的总长度，再接着往下读取；如果发现开头没有，立马 RESET 这个连接，节省流量，通过 Range 头读取文件末尾数据，因为前面一个 HTTP 请求已经获取到了 Content-Length ，知道了 MP4 文件的整个大小，通过 Range 头读取部分文件尾部数据也是可以读取到的。

思考总结

在分析源码的过程中，发现了androidVideoCache的一些不足之处：

1.视频预加载

框架不支持视频预加载功能，客户端需要手动实现预缓存，后续可以将这个功能封装到框架中。

2.线程管理

线程池创建不合理，客户端响应线程用固定线程池的方式，会增多项目线程数，引发oom，可以根据cpu的核心数创建线程个数，节约资源；new Thread方式可以改用线程池方式创建。

//客户端响应线程池
private ExecutorService socketProcessor = Executors.newFixedThreadPool(8);

//本地服务器监听线程
 this.waitConnectionThread = new Thread(new WaitRequestsRunnable(startSignal));
            this.waitConnectionThread.start();
  //读取网络数据线程
 sourceReaderThread = new Thread(new SourceReaderRunnable(), "Source reader for " + source);
            sourceReaderThread.start();

3.AndroidVideoCache采用数据库进行存储缓存的信息，可以不使用，减少IO操作。

       public Builder(Context context) {
        this.sourceInfoStorage = SourceInfoStorageFactory.newSourceInfoStorage(context);
          
        }

数据库缓存了素材的url,长度和类型，以便于下次使用时直接从数据库中查询，其实是没有必要的，因为每次请求都会创建新的对象，不需要缓存。

4.支持m3u8视频格式，视频分片下载，节省流量。

mp4格式是整段视频，每次开启下载时，都会把整个视频下载下来，m3u8格式是数据返回是分片的，视频可以一段一段下载，节省流量。

参考文献：

1.https://juejin.cn/post/6844903773521838087

2.https://zhuanlan.zhihu.com/p/395181238

3.https://blog.qiusuo.im/blog/2015/02/05/play-mp4-using-http/