FongMi /TV Spider
编写完全指南

plugins {
    id 'com.android.library'
}

android {
    compileSdk 34
    defaultConfig {
        minSdk 21
    }
}

dependencies {
    // 提供 Spider 基类、OkHttp 包装、工具函数
    compileOnly 'com.github.catvod:catvod:最新版本'
    // 常用工具（非必须，catvod 内已有 okhttp）
    compileOnly 'com.squareup.okhttp3:okhttp:4.12.0'
    compileOnly 'org.jsoup:jsoup:1.17.2'
}

// 打包为含 DEX 的 JAR Task
task makeJar(type: Jar, dependsOn: ['assembleRelease']) {
    archiveFileName = "spider.jar"
    from zipTree("build/outputs/aar/${project.name}-release.aar")
    include 'classes.dex', 'classes*.dex'
}

import android.content.Context;
import com.github.catvod.crawler.Spider;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.HashMap;
import java.util.List;

public class csp_DemoSite extends Spider {

    private static final String BASE_URL = "https://api.example.com";
    private OkHttpClient http;
    private String token = "";

    //  初始化（extend = site.ext 字段）
    @Override
    public void init(Context context, String extend) throws Exception {
        http = client();          // 使用基类提供的安全 OkHttp 客户端
        // extend 可以是 URL 或 JSON 字符串，自行解析
        if (extend != null && extend.startsWith("http")) {
            String body = http.newCall(new Request.Builder().url(extend).build())
                              .execute().body().string();
            token = new JSONObject(body).optString("token");
        }
    }

    //  首页：返回分类列表
    @Override
    public String homeContent(boolean filter) throws Exception {
        JSONObject resp = get(BASE_URL + "/home");
        JSONObject result = new JSONObject();
        JSONArray classes = new JSONArray();
        JSONArray cats = resp.getJSONArray("categories");
        for (int i = 0; i < cats.length(); i++) {
            JSONObject item = cats.getJSONObject(i);
            classes.put(new JSONObject()
                .put("type_id",   item.getString("id"))
                .put("type_name", item.getString("name"))
                .put("type_flag", "1"));         // 1=有筛选器
        }
        result.put("class", classes);
        if (filter) result.put("filters", buildFilters(resp));
        return result.toString();
    }

    //  分类页：返回列表 + 总页数
    @Override
    public String categoryContent(
            String tid, String pg, boolean filter,
            HashMap<String, String> extend) throws Exception {
        String area = extend.getOrDefault("area", "");
        String year = extend.getOrDefault("year", "");
        JSONObject resp = get(BASE_URL + "/vod?type=" + tid + "&pg=" + pg
                           + "&area=" + area + "&year=" + year);
        return buildVodList(resp).toString();
    }

    //  详情页：返回完整 Vod（含播放 URL）
    @Override
    public String detailContent(List<String> ids) throws Exception {
        JSONObject resp = get(BASE_URL + "/detail?id=" + ids.get(0));
        JSONObject vod = resp.getJSONObject("vod");
        JSONArray eps = vod.getJSONArray("episodes");
        // 播放信息：多集用 # 分隔，集名$URL 格式
        StringBuilder playUrl = new StringBuilder();
        for (int i = 0; i < eps.length(); i++) {
            if (i > 0) playUrl.append("#");
            JSONObject ep = eps.getJSONObject(i);
            playUrl.append(ep.getString("name")).append("$").append(ep.getString("url"));
        }
        JSONObject item = new JSONObject()
            .put("vod_id",       ids.get(0))
            .put("vod_name",     vod.getString("title"))
            .put("vod_content",  vod.optString("desc"))
            .put("vod_pic",      vod.optString("cover"))
            .put("vod_year",     vod.optString("year"))
            .put("vod_actor",    vod.optString("actors"))
            .put("vod_director", vod.optString("director"))
            .put("vod_play_from", "线路1")
            .put("vod_play_url",  playUrl.toString());
        return new JSONObject().put("list", new JSONArray().put(item)).toString();
    }

    //  播放：返回真实直链
    @Override
    public String playerContent(String flag, String id, List<String> vipFlags) throws Exception {
        // 如果 id 已经是 m3u8/mp4 直链，直接返回
        if (id.contains(".m3u8") || id.contains(".mp4")) {
            return new JSONObject()
                .put("parse", 0)
                .put("url", id)
                .toString();
        }
        // 否则通过 API 解析
        JSONObject resp = get(BASE_URL + "/play?id=" + id);
        return new JSONObject()
            .put("parse",  0)
            .put("url",    resp.getString("url"))
            .put("header", new JSONObject().put("Referer", BASE_URL))
            .toString();
    }

    //  搜索
    @Override
    public String searchContent(String key, boolean quick) throws Exception {
        JSONObject resp = get(BASE_URL + "/search?q=" + key);
        return buildVodList(resp).toString();
    }

    //  工具函数
    private JSONObject get(String url) throws Exception {
        Request req = new Request.Builder().url(url)
            .header("Authorization", "Bearer " + token)
            .build();
        return new JSONObject(http.newCall(req).execute().body().string());
    }

    private JSONObject buildVodList(JSONObject resp) throws Exception {
        JSONArray items = resp.getJSONArray("list");
        JSONArray list = new JSONArray();
        for (int i = 0; i < items.length(); i++) {
            JSONObject item = items.getJSONObject(i);
            list.put(new JSONObject()
                .put("vod_id",      item.getString("id"))
                .put("vod_name",    item.getString("title"))
                .put("vod_pic",     item.optString("cover"))
                .put("vod_remarks", item.optString("tag")));
        }
        return new JSONObject()
            .put("list",      list)
            .put("pagecount", resp.optInt("totalPage", 1));
    }
}

// ── Spider 类（命名与配置中的 api 字段一致）
var csp_DemoSite = {

    // ── 内部状态
    baseUrl: '',
    token:   '',


    // ── init：接收 extend（site.ext 的内容）
    init: async function(ext) {
        // ext 可以是 URL（已自动 fetch）或 JSON 字符串
        var config = typeof ext === 'string' ? JSON.parse(ext) : ext;
        this.baseUrl = config.url || 'https://api.example.com';
        this.token   = config.token || '';
    },


    // ── 首页：返回分类列表 + 可选首页推荐
    homeContent: async function(filter) {
        var resp = await req(this.baseUrl + '/home', {headers: this.headers()});
        var data = JSON.parse(resp.content);

        var classes = data.categories.map(c => ({
            type_id:   c.id,
            type_name: c.name,
            type_flag: '1',     // 1 = 有筛选器
        }));

        var filters = {};
        if (filter) {
            classes.forEach(c => {
                filters[c.type_id] = [
                    { key: 'area', name: '地区', value: [
                        {n:'全部',v:''}, {n:'大陆',v:'1'}, {n:'欧美',v:'2'}
                    ]},
                    { key: 'year', name: '年份', value: [
                        {n:'全部',v:''}, {n:'2025',v:'2025'}, {n:'2024',v:'2024'}
                    ]}
                ];
            });
        }
        return JSON.stringify({ class: classes, filters });
    },


    // ── 分类页
    categoryContent: async function(tid, pg, filter, extend) {
        var url = `${this.baseUrl}/vod?type=${tid}&pg=${pg}&area=${extend.area||''}&year=${extend.year||''}`;
        var resp = await req(url, {headers: this.headers()});
        var data = JSON.parse(resp.content);
        return JSON.stringify({
            list:      data.list.map(this.mapVod),
            pagecount: data.totalPage,
        });
    },


    // ── 详情页
    detailContent: async function(ids) {
        var resp = await req(this.baseUrl + `/detail?id=${ids[0]}`, {headers: this.headers()});
        var vod  = JSON.parse(resp.content).vod;
        var playUrl = vod.episodes.map(ep => `${ep.name}$${ep.url}`).join('#');
        return JSON.stringify({ list: [{
            vod_id:       ids[0],
            vod_name:     vod.title,
            vod_pic:      vod.cover,
            vod_content:  vod.desc,
            vod_year:     vod.year,
            vod_actor:    vod.actors,
            vod_director: vod.director,
            vod_remarks:  vod.remarks,
            vod_play_from: '线路1',
            vod_play_url:  playUrl,
        }]});
    },


    // ── 播放
    playerContent: async function(flag, id, vipFlags) {
        if (id.includes('.m3u8') || id.includes('.mp4')) {
            return JSON.stringify({ parse: 0, url: id });
        }
        var resp = await req(this.baseUrl + `/play?id=${id}`, {headers: this.headers()});
        var data = JSON.parse(resp.content);
        return JSON.stringify({
            parse: 0,
            url:  data.url,
            header: { Referer: this.baseUrl },
        });
    },


    // ── 搜索
    searchContent: async function(key, quick) {
        var resp = await req(this.baseUrl + `/search?q=${encodeURIComponent(key)}`, {headers: this.headers()});
        var data = JSON.parse(resp.content);
        return JSON.stringify({ list: data.list.map(this.mapVod) });
    },


    // ── 内部工具
    headers: function() {
        return { Authorization: `Bearer ${this.token}`, 'User-Agent': 'TV/1.0' };
    },
    mapVod: function(item) {
        return {
            vod_id:      item.id,
            vod_name:    item.title,
            vod_pic:     item.cover,
            vod_remarks: item.tag,
        };
    },
};

detailContent: async function(ids) {
    var resp = await req(`https://site.example.com/movie/${ids[0]}.html`);
    var html = resp.content;
    var base = resp.url;           // 最终 URL（可能经过跳转）

    // pdfh：提取单个节点的内容（CSS 选择器 + 属性）
    var title = pdfh(html, 'h1.title&&Text');
    var cover = pdfh(html, 'img.cover&&src');

    // pdfa：提取多个节点列表（返回 HTML 片段数组）
    var epItems = pdfa(html, '.episodes&&a');
    var playUrl = epItems.map(ep => {
        var name = pdfh(ep, 'a&&Text');
        var href = pdfh(ep, 'a&&href');
        // pd：把相对 URL 拼成绝对 URL
        return `${name}$${pd(ep, 'a&&href', base)}`;
    }).join('#');

    return JSON.stringify({ list: [{
        vod_id:        ids[0],
        vod_name:      title,
        vod_pic:       cover,
        vod_play_from: '来源一',
        vod_play_url:  playUrl,
    }]});
},

playerContent: async function(flag, id, vipFlags) {
    var resp = await req(`https://api.example.com/enc_play?id=${id}`);
    var data = JSON.parse(resp.content);

    // AES-CBC 解密示例
    var key = CryptoJS.enc.Utf8.parse('your_16_byte_key');
    var iv  = CryptoJS.enc.Utf8.parse('your_16_byte_ivv');
    var decrypted = CryptoJS.AES.decrypt(data.enc_url, key, {
        iv:   iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7,
    });
    var url = decrypted.toString(CryptoJS.enc.Utf8);
    return JSON.stringify({ parse: 0, url });
},

// GET
var r1 = await req('https://api.example.com/list', {
    headers:  { 'Cookie': 'sess=abc' },
    timeout:  15000,       // ms
    redirect: true,         // 跟随重定向
    withRedirectUrl: true,  // 在 content 中附加最终 URL
});
print(r1.code);      // HTTP 状态码
print(r1.content);   // 响应体字符串
print(r1.headers);   // 响应头 JSON 对象
print(r1.url);       // 最终 URL（经过重定向后）

// POST（表单）
var r2 = await req('https://api.example.com/login', {
    method: 'post',
    data:   { username: 'admin', password: '123456' },
});

// POST（JSON body）
var r3 = await req('https://api.example.com/api', {
    method:  'post',
    body:    JSON.stringify({ id: '123' }),
    headers: { 'Content-Type': 'application/json' },
});

# -*- coding: utf-8 -*-
import json
import requests
from bs4 import BeautifulSoup


class Spider:
    """FongMi/TV Python Spider 模板"""

    def __init__(self):
        self.base_url = 'https://api.example.com'
        self.session  = requests.Session()
        self.session.headers.update({'User-Agent': 'Mozilla/5.0'})

    def init(self, extend: str):
        """接收 site.ext 字段（字符串，可以是 URL 已 fetch 的内容，或直接 JSON）"""
        try:
            config = json.loads(extend)
            self.base_url = config.get('url', self.base_url)
            token = config.get('token', '')
            if token:
                self.session.headers.update({'Authorization': f'Bearer {token}'})
        except Exception:
            pass

    def homeContent(self, filter: bool) -> str:
        resp = self.session.get(self.base_url + '/home').json()
        classes = [
            {'type_id': c['id'], 'type_name': c['name'], 'type_flag': '1'}
            for c in resp.get('categories', [])
        ]
        result = {'class': classes}
        if filter:
            result['filters'] = self._build_filters()
        return json.dumps(result, ensure_ascii=False)

    def categoryContent(self, tid: str, pg: str, filter: bool,
                          extend: dict) -> str:
        url = self.base_url + f'/vod?type={tid}&pg={pg}'
        url += f'&area={extend.get("area","")}&year={extend.get("year","")}'
        data = self.session.get(url).json()
        return json.dumps({
            'list':      [self._map_vod(v) for v in data.get('list', [])],
            'pagecount': data.get('totalPage', 1),
        }, ensure_ascii=False)

    def detailContent(self, ids: list) -> str:
        data = self.session.get(self.base_url + f'/detail?id={ids[0]}').json()
        vod = data['vod']
        play_url = '#'.join(
            f'{ep["name"]}${ep["url"]}' for ep in vod.get('episodes', [])
        )
        return json.dumps({'list': [{
            'vod_id':        ids[0],
            'vod_name':      vod['title'],
            'vod_pic':       vod.get('cover', ''),
            'vod_content':   vod.get('desc', ''),
            'vod_year':      vod.get('year', ''),
            'vod_actor':     vod.get('actors', ''),
            'vod_director':  vod.get('director', ''),
            'vod_play_from': '线路1',
            'vod_play_url':  play_url,
        }]}, ensure_ascii=False)

    def playerContent(self, flag: str, id_: str,
                        vip_flags: list) -> str:
        if any(id_.endswith(ext) for ext in ['.m3u8', '.mp4']):
            return json.dumps({'parse': 0, 'url': id_})
        data = self.session.get(self.base_url + f'/play?id={id_}').json()
        return json.dumps({
            'parse':  0,
            'url':    data['url'],
            'header': {'Referer': self.base_url},
        }, ensure_ascii=False)

    def searchContent(self, key: str, quick: bool) -> str:
        data = self.session.get(self.base_url + f'/search?q={key}').json()
        return json.dumps({
            'list': [self._map_vod(v) for v in data.get('list', [])]
        }, ensure_ascii=False)

    ### ── 工具函数 ─────────────────────────────────
    def _map_vod(self, item: dict) -> dict:
        return {
            'vod_id':      item.get('id', ''),
            'vod_name':    item.get('title', ''),
            'vod_pic':     item.get('cover', ''),
            'vod_remarks': item.get('tag', ''),
        }

    def _build_filters(self) -> dict:
        common = [
            {'key': 'area', 'name': '地区', 'value': [
                {'n': '全部', 'v': ''}, {'n': '大陆', 'v': '1'}
            ]},
        ]
        return {'1': common, '2': common}

// 基本用法：选择器&&属性名
pdfh(html, 'div.title&&Text')          // 获取文本内容
pdfh(html, 'img.poster&&src')          // 获取 src 属性
pdfh(html, 'a.link&&href')             // 获取 href 属性
pdfh(html, 'div.wrap&&Html')           // 获取 innerHTML

// 多层选择（用空格分隔层级，类似 CSS 后代选择器）
pdfh(html, '.card .title&&Text')
pdfh(html, 'ul.eps li:eq(0) a&&Text')  // :eq(n) 选第 n 个

// 正则提取（使用 ##regex##）
pdfh(html, 'script&&Html##var id="(\\d+)"##')

// pdfa 返回匹配元素的 HTML 字符串列表
var items = pdfa(html, '.vod-list&&.vod-item');
items.forEach(item => {
    var name = pdfh(item, 'a&&Title');  // 或 Text
    var href = pdfh(item, 'a&&href');
    var pic  = pdfh(item, 'img&&src');
    // ...
});

// pd = pdfh + URL 补全（相对路径 → 绝对路径）
var base = 'https://site.example.com/movie/';
var link = pd(html, 'a.page-link&&href', base);
// 例：href="/page/2" → https://site.example.com/page/2

@Override
public String liveContent(String url) throws Exception {
    // url 是配置中直播频道的原始 URL
    // 假设需要把静态 URL 换成带时效 token 的临时地址
    JSONObject body = get(apiBase + "/live/auth?channel=" + Uri.encode(url));
    String tempUrl = body.getString("stream_url");

    // 可以直接返回 URL 字符串
    return tempUrl;

    // 也可以返回播放 JSON（同 playerContent 格式）
    // return new JSONObject()
    //     .put("url", tempUrl)
    //     .put("header", new JSONObject().put("Referer", apiBase))
    //     .toString();
}

liveContent: async function(url) {
    // 1. 直接返回重写后的 URL（最简单）
    if (url.includes('cdn1.old.com')) {
        return url.replace('cdn1.old.com', 'cdn2.new.com');
    }

    // 2. 通过接口获取临时鉴权 URL
    var resp = await req(this.baseUrl + `/live_auth?url=${encodeURIComponent(url)}`);
    var data = JSON.parse(resp.content);
    return JSON.stringify({
        url:    data.stream_url,
        header: { 'Referer': 'https://live.example.com/' },
    });
},

// proxy() 返回 Object[]：[状态码, Content-Type, 响应体]
@Override
public Object[] proxy(Map<String, String> params) throws Exception {
    String action = params.get("action");            // 自定义标识
    String url    = params.getOrDefault("url", "");

    if ("m3u8_proxy".equals(action)) {
        // 修改 m3u8 内容（如替换 key 请求 URL、添加认证头）
        String body = modifyM3u8(url);
        return new Object[]{200, "application/x-mpegURL", body};
    } else if ("key".equals(action)) {
        // 动态获取 DRM key（从第三方服务）
        byte[] key = fetchDrmKey(params.get("kid"));
        return new Object[]{200, "application/octet-stream", key};
    } else {
        return new Object[]{404, "text/plain", "not found"};
    }
}

var csp_DemoSite = {
    // 启用本地代理（playerContent 中的 url 指向本地地址）
    local_proxy: true,

    playerContent: async function(flag, id, vipFlags) {
        // 构造本地地址，让 App 把请求forwarded 给 proxy()
        return JSON.stringify({
            url: `http://127.0.0.1:9978/proxy?action=m3u8_proxy&url=${encodeURIComponent(id)}&key=${this.key}`,
            parse: 0,
        });
    },

    proxy: async function(params) {
        var url = params.url;
        var resp = await req(url, { headers: { Authorization: `Bearer ${params.key}` } });
        // 修改 m3u8 内容，替换 key URI 为本地地址
        var content = resp.content.replace(
            /URI="(.*?)"/g,
            (_, keyUrl) => `URI="http://127.0.0.1:9978/proxy?action=key&url=${encodeURIComponent(keyUrl)}"`
        );
        return [200, 'application/x-mpegURL', content];
    },
};

// config.json 中
{
    "key": "site_a", "name": "站点A", "type": 1,
    "api": "csp_Universal", "jar": "https://cdn.example.com/universal.js",
    "ext": "{\"url\":\"https://site-a.example.com\",\"token\":\"tok_a\"}"
},
{
    "key": "site_b", "name": "站点B", "type": 1,
    "api": "csp_Universal", "jar": "https://cdn.example.com/universal.js",
    "ext": "{\"url\":\"https://site-b.example.com\",\"token\":\"tok_b\"}"
}

categoryContent: async function(tid, pg, filter, extend) {
    // tid 格式：顶级分类用 "1"，子目录用 "folder_path/xxxxx"
    if (tid.startsWith('folder/')) {
        return await this.listFolder(tid.slice(7));
    }
    // 正常分类...
},

listFolder: async function(path) {
    var resp = await req(`https://api.example.com/dir?path=${path}`);
    var data = JSON.parse(resp.content);
    return JSON.stringify({ list: data.items.map(item => ({
        vod_id:      `folder/${item.path}`,    // 子目录继续用 folder/ 前缀
        vod_name:    item.name,
        vod_tag:     item.isDir ? 'folder' : '',   // 目录项打 folder 标记
        vod_remarks: item.isDir ? '目录' : item.size,
    }))});
},

// App 可以在 UI 中触发自定义 action（如"重新登录"按钮）
action: async function(act) {
    if (act === 'refresh_token') {
        var resp = await req(this.baseUrl + '/refresh', {
            method: 'post',
            body: JSON.stringify({ refresh_token: this.refreshToken }),
            headers: { 'Content-Type': 'application/json' },
        });
        this.token = JSON.parse(resp.content).access_token;
        return JSON.stringify({ msg: 'Token 刷新成功', code: 0 });
    }
    return JSON.stringify({ msg: 'unknown action', code: -1 });
},