Android中使用Rust实现HLS本地代理

24 阅读5分钟

看到这个标题可能大家会有点懵,不急,让我慢慢道来

  1. Rust:一种原生语言,可以用来开发NDK,Android系统平台一等公民语言,Google说 Rust比C或C++更安全,可用于开发关键系统组件,提供更高的安全性和稳定性
  2. HLS:一种HTTP自适应流媒体协议,后缀一般是m3u8,包含了小段视频ts切片的索引,可以用ExoPlayer播放器播放
  3. 本地代理:运行在本地的转发服务,App把请求发给它,它再转发到服务器去,收到服务器的响应,它再转给App(类似抓包)

背景介绍

一般在视频类APK中,播放直播时,java/kotlin层会根据用户选择的频道ID、用户token等信息,从后台拿到相应的播放地址,然后将播放地址丢给播放器,由播放器进行拉流播放。

但在某些场景下(出于安全等目的),可能会希望将播放地址的构建、拉流请求等,放在Native层去处理。

由于我已经忘记了C怎么写,担心写出内存泄露的代码,谷歌也用Rust,关注的大佬也提过Rust,故而本项目就学习Rust来实现,在此记录一下。

整体架构设计

image.png

完整播放流程

0ac14ba1-e7ce-485e-8186-c2730011c284.png

在这个过程中:

  1. ExoPlayer完全不需要知道真实播放地址的拼接规则,只需要用Jni返回的本地地址去播放即可
  2. Rust使用Axum开启本地http服务,使用reqwest发起请求。请求m3u8文件索引和ts切片的地址都是由rust代码自行组装处理的
  3. 拿到m3u8文件后,要根据自己实际情况,对文件内容进行相应处理
  4. 拿到ts流这种二进制数据后,不要转换类型,不能直接存内存,而是使用流式传输bytes_steam
  5. 代理请求过程中,http状态码、请求头、响应头等内容都要尽量转发,不能随便丢弃

简要代码

Session、SessionManager数据结构

#[derive(Clone)] //自动帮实现clone的trait方法
pub struct Session {
    stream_id: String,
    token: String,
}

#[derive(Clone)]
pub struct SessionManager {
    // sessions: HashMap<String, Session>,//并发的,这样不行
    sessions: Arc<RwLock<HashMap<String, Session>>>,//Arc多个异步任务共享;RwLock多个请求同时读,写独占,写的时候其他的不能读不能写
}

impl SessionManager {
    pub fn new() -> Self {
        Self {
            sessions: Arc::new(RwLock::new(HashMap::new())),
        }
    }
}

impl SessionManager {
    pub fn create_session(&self, stream_id: String, token: String) -> String {
        let session_id = Uuid::new_v4().to_string();
        let session = Session { stream_id: stream_id, token };
        //修改hashmap,先获取write lock
        let mut sessions = self.sessions.write().unwrap();
        sessions.insert(session_id.clone(), session);
        session_id
    }
}

使用Axum创建本地代理

fn build_app(
    manager: SessionManager,
) -> Router {
    //Tokio: Rust 的异步运行时,负责异步任务、网络 IO 等
    //Axum:HTTP Server 框架,我们用它接收 HTTP 请求。
    //reqwest: 发起网络请求的client

    let client = Client::new();

    let app_state = AppState { manager, client };

    Router::new()
        .route("/proxy/{session_id}", get(proxy_handler))
        .route("/proxy/{session_id}/resource/{segment_id}", get(proxy_segment_handler))
        .with_state(app_state)//只能调一次with_state,要复用多个参数就需要用struct把它们都包起来

}

播放器请求本地地址,Rust请求真实地址并重写m3u8中的ts切片地址,然后返回

async fn proxy_handler(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
) -> Response {
    use axum::body::Body;//要引入axum的body,不然就会用错外面reqwest的body

    let session = match state.manager.get_session(&session_id) {
        Some(session) => session,
        None => {
            android_log::error(
                &"session not found".to_string()
            );
            return (StatusCode::NOT_FOUND,
                    "session not found".to_string()).into_response();
        }
    };

    android_log::info(
        &format!("proxy_handler session={},{},{}", session_id, session.stream_id, session.token)
    );

    let remote_url = real_build_remote_url(&session);

    let response = match state.client.get(remote_url).send().await {
        Ok(response) => response,
        Err(e) => {
            eprintln!("remote request failed: {e}");
            return (
                StatusCode::BAD_GATEWAY,
                "remote request failed".to_string(),
            ).into_response();
        }
    };
    //reqwest::get() 返回 Ok(response),只表示 HTTP 请求成功完成了通信,不代表远程 HTTP 状态码一定是 200。
    //例如远程服务器返回 404,仍然可能进入 Ok(response) 分支。当前代码会将这个状态码继续返回给本地客户端

    android_log::info(
        &format!("upstream status={}", response.status())
    );

    let status = StatusCode::from_u16(
        response.status().as_u16()
    ).unwrap_or(StatusCode::BAD_GATEWAY);

    let content_type = response
        .headers()
        .get("content-type")
        .and_then(|value| value.to_str().ok())
        .unwrap_or("")
        .to_owned();

    // 获取经过重定向后的最终 URL。
    // 用它解析 M3U8 中的相对分片地址。
    let base_url = response.url().clone();
    let is_m3u8 = content_type.contains("mpegurl")
        || base_url.path().ends_with(".m3u8");

    if is_m3u8 && status.is_success() {
        let content = match response.text().await {
            Ok(content) => content,
            Err(error) => {
                eprintln!("read m3u8 failed: {error}");

                return (
                    StatusCode::BAD_GATEWAY,
                    "failed to read m3u8",
                ).into_response();
            }
        };

        let rewritten = m3u8::rewrite_m3u8(&content, &base_url, &session_id);//重写
        return Response::builder()
            .status(status)
            .header(
                axum::http::header::CONTENT_TYPE,
                "application/vnd.apple.mpegurl",
            )
            .body(Body::from(rewritten))
            .unwrap_or_else(|_| {
                Response::new(Body::from("internal server error"))
            });
    }

    ……
}

逻辑基本都在流程图中了,代码展示了一个简单的定义和请求响应感觉就够了

后续改造

上面展示的主要是整个本地代理播放功能的实现,有一些逻辑还是需要后续完善:

  • 像关于流地址的拼接规则,是一个基础版本,后续可以自行改造,比如与后台约定增加鉴权参数,不走拼接Rust直接请求后台接口拿播放地址等等
  • 端口也要动态绑定,不能固定写死
  • 对rust发起的请求做校验,只有特定域名才能发起请求
  • 对其他进程访问本地代理做拦截

感谢阅读😀,送大家一个🦀