JKVideo Client React Native pour Bilibili
Compétence par ara.so — Collection de compétences Daily 2026.
JKVideo est un client tiers complet pour Bilibili construit avec React Native 0.83 + Expo SDK 55. Il prend en charge le streaming adaptatif DASH, les commentaires flottants (danmaku) en temps réel, la signature API WBI, la connexion par QR code, le streaming en direct avec WebSocket pour les danmaku, et un gestionnaire de téléchargements avec partage LAN par QR.
Installation & Configuration
Prérequis
- Node.js 18+
- npm ou yarn
- Pour Android : Android Studio + SDK
- Pour iOS : macOS + Xcode 15+
Démarrage rapide (Expo Go — sans compilation)
git clone https://github.com/tiajinsha/JKVideo.git
cd JKVideo
npm install
npx expo start
Scannez le QR avec l'application Expo Go. Note : le DASH 1080P+ nécessite une version compilée (Dev Build).
Version compilée (Fonctionnalités complètes — Recommandé)
npm install
npx expo run:android # Android
npx expo run:ios # iOS (macOS + Xcode requis)
Web avec Proxy d'Image
npm install
npx expo start --web
# Dans un terminal séparé :
node scripts/proxy.js # Démarre un proxy sur le port 3001 pour contourner les restrictions de référent de Bilibili
Installer l'APK Directement (Android)
Téléchargez depuis les Releases — activez "Installer depuis des sources inconnues" dans les paramètres Android.
Structure du Projet
app/
index.tsx # Accueil (onglets PagerView chauds/en direct)
video/[bvid].tsx # Détail vidéo (lecture + commentaires + danmaku)
live/[roomId].tsx # Détail direct (HLS + danmaku en temps réel)
search.tsx # Page de recherche
downloads.tsx # Gestionnaire de téléchargements
settings.tsx # Paramètres (qualité, déconnexion)
components/ # UI : lecteur, superposition danmaku, cartes
hooks/ # Hooks de données : listes vidéo, flux, danmaku
services/ # API Bilibili (axios + intercepteur cookie)
store/ # Stores Zustand : authentification, téléchargement, vidéo, paramètres
utils/ # Utilitaires : formatage, proxy d'image, constructeur MPD
Pile Technologique Clé
| Couche | Technologie |
|---|---|
| Framework | React Native 0.83 + Expo SDK 55 |
| Routage | expo-router v4 (système de fichiers, navigation Stack) |
| État | Zustand |
| HTTP | Axios |
| Stockage | @react-native-async-storage/async-storage |
| Vidéo | react-native-video (DASH MPD / HLS / MP4) |
| Solution de repli | react-native-webview (injection vidéo HTML5) |
| Pagination | react-native-pager-view |
| Icônes | @expo/vector-icons (Ionicons) |
Implémentation de la Signature WBI
Bilibili nécessite une signature WBI pour la plupart des appels API. JKVideo implémente un MD5 TypeScript pur avec un cache de navigation de 12h.
// utils/wbi.ts — MD5 TypeScript pur, aucune dépendance crypto externe
const MIXIN_KEY_ENC_TAB = [
46, 47, 18, 2, 53, 8, 23, 32, 15, 50, 10, 31, 58, 3, 45, 35,
27, 43, 5, 49, 33, 9, 42, 19, 29, 28, 14, 39, 12, 38, 41, 13
];
function getMixinKey(rawKey: string): string {
return MIXIN_KEY_ENC_TAB
.map(i => rawKey[i])
.join('')
.slice(0, 32);
}
export async function signWbi(
params: Record<string, string | number>,
imgKey: string,
subKey: string
): Promise<Record<string, string | number>> {
const mixinKey = getMixinKey(imgKey + subKey);
const wts = Math.floor(Date.now() / 1000);
const signParams = { ...params, wts };
// Trier les paramètres par ordre alphabétique, filtrer les caractères spéciaux
const query = Object.keys(signParams)
.sort()
.map(k => {
const val = String(signParams[k]).replace(/[!'()*]/g, '');
return `${encodeURIComponent(k)}=${encodeURIComponent(val)}`;
})
.join('&');
const wRid = md5(query + mixinKey); // MD5 TypeScript pur
return { ...signParams, w_rid: wRid };
}
// Récupérer et mettre en cache les clés de navigation (TTL 12h)
export async function getWbiKeys(): Promise<{ imgKey: string; subKey: string }> {
const cached = await AsyncStorage.getItem('wbi_keys');
if (cached) {
const { keys, ts } = JSON.parse(cached);
if (Date.now() - ts < 12 * 3600 * 1000) return keys;
}
const res = await api.get('/x/web-interface/nav');
const { img_url, sub_url } = res.data.data.wbi_img;
const imgKey = img_url.split('/').pop()!.replace('.png', '');
const subKey = sub_url.split('/').pop()!.replace('.png', '');
const keys = { imgKey, subKey };
await AsyncStorage.setItem('wbi_keys', JSON.stringify({ keys, ts: Date.now() }));
return keys;
}
Service API Bilibili
// services/api.ts
import axios from 'axios';
import AsyncStorage from '@react-native-async-storage/async-storage';
export const api = axios.create({
baseURL: 'https://api.bilibili.com',
timeout: 15000,
headers: {
'User-Agent': 'Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36',
'Referer': 'https://www.bilibili.com',
},
});
// Injecter le cookie SESSDATA depuis le store
api.interceptors.request.use(async (config) => {
const sessdata = await AsyncStorage.getItem('SESSDATA');
if (sessdata) {
config.headers['Cookie'] = `SESSDATA=${sessdata}`;
}
return config;
});
// Liste des vidéos populaires (signée WBI)
export async function getPopularVideos(pn = 1, ps = 20) {
const { imgKey, subKey } = await getWbiKeys();
const signed = await signWbi({ pn, ps }, imgKey, subKey);
const res = await api.get('/x/web-interface/popular', { params: signed });
return res.data.data.list;
}
// Informations de flux vidéo (DASH)
export async function getVideoStream(bvid: string, cid: number, qn = 80) {
const { imgKey, subKey } = await getWbiKeys();
const signed = await signWbi(
{ bvid, cid, qn, fnval: 4048, fnver: 0, fourk: 1 },
imgKey, subKey
);
const res = await api.get('/x/player/wbi/playurl', { params: signed });
return res.data.data;
}
// URL du flux en direct
export async function getLiveStreamUrl(roomId: number) {
const res = await api.get('/room/v1/Room/playUrl', {
params: { cid: roomId, quality: 4, platform: 'h5' },
baseURL: 'https://api.live.bilibili.com',
});
return res.data.data.durl[0].url; // HLS m3u8
}
Constructeur de Fichier MPD DASH
ExoPlayer a besoin d'un fichier MPD local. JKVideo le génère à partir de la réponse DASH de Bilibili :
// utils/buildDashMpd.ts
export function buildDashMpdUri(dashData: BiliDashData): string {
const { duration, video, audio } = dashData;
const videoAdaptations = video.map((v) => `
<AdaptationSet mimeType="video/mp4" segmentAlignment="true">
<Representation id="${v.id}" bandwidth="${v.bandwidth}"
codecs="${v.codecs}" width="${v.width}" height="${v.height}">
<BaseURL>${escapeXml(v.baseUrl)}</BaseURL>
<SegmentBase indexRange="${v.segmentBase.indexRange}">
<Initialization range="${v.segmentBase.initialization}"/>
</SegmentBase>
</Representation>
</AdaptationSet>`).join('');
const audioAdaptations = audio.map((a) => `
<AdaptationSet mimeType="audio/mp4" segmentAlignment="true">
<Representation id="${a.id}" bandwidth="${a.bandwidth}" codecs="${a.codecs}">
<BaseURL>${escapeXml(a.baseUrl)}</BaseURL>
<SegmentBase indexRange="${a.segmentBase.indexRange}">
<Initialization range="${a.segmentBase.initialization}"/>
</SegmentBase>
</Representation>
</AdaptationSet>`).join('');
const mpd = `<?xml version="1.0" encoding="UTF-8"?>
<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static"
mediaPresentationDuration="PT${duration}S" minBufferTime="PT1.5S">
<Period duration="PT${duration}S">
${videoAdaptations}
${audioAdaptations}
</Period>
</MPD>`;
// Écrire dans un fichier temporaire, retourner l'URI file:// pour ExoPlayer
const path = `${FileSystem.cacheDirectory}dash_${Date.now()}.mpd`;
FileSystem.writeAsStringAsync(path, mpd);
return path;
}
Composant Lecteur Vidéo
// components/VideoPlayer.tsx
import Video from 'react-native-video';
import { WebView } from 'react-native-webview';
import { useVideoStore } from '../store/videoStore';
interface VideoPlayerProps {
bvid: string;
cid: number;
autoPlay?: boolean;
}
export function VideoPlayer({ bvid, cid, autoPlay = false }: VideoPlayerProps) {
const [mpdUri, setMpdUri] = useState<string | null>(null);
const [useFallback, setUseFallback] = useState(false);
const { setCurrentVideo } = useVideoStore();
useEffect(() => {
loadStream();
}, [bvid, cid]);
async function loadStream() {
try {
const stream = await getVideoStream(bvid, cid);
if (stream.dash) {
const uri = await buildDashMpdUri(stream.dash);
setMpdUri(uri);
} else {
setUseFallback(true);
}
} catch {
setUseFallback(true);
}
}
if (useFallback) {
// Solution de repli WebView pour Expo Go / Web
return (
<WebView
source={{ uri: `https://www.bilibili.com/video/${bvid}` }}
allowsInlineMediaPlayback
mediaPlaybackRequiresUserAction={false}
/>
);
}
return (
<Video
source={{ uri: mpdUri! }}
style={{ width: '100%', aspectRatio: 16 / 9 }}
controls
paused={!autoPlay}
resizeMode="contain"
onLoad={() => setCurrentVideo({ bvid, cid })}
/>
);
}
Système Danmaku
Danmaku Vidéo (synchronisation temporelle XML)
// hooks/useDanmaku.ts
export function useDanmaku(cid: number) {
const [danmakuList, setDanmakuList] = useState<Danmaku[]>([]);
useEffect(() => {
fetchDanmaku(cid);
}, [cid]);
async function fetchDanmaku(cid: number) {
const res = await api.get(`/x/v1/dm/list.so?oid=${cid}`, {
responseType: 'arraybuffer',
});
// Analyser le XML danmaku
const xml = new TextDecoder('utf-8').decode(res.data);
const items = parseXmlDanmaku(xml); // analyser <d p="time,...">texte</d>
setDanmakuList(items);
}
return danmakuList;
}
// components/DanmakuOverlay.tsx — Affichage flottant à 5 voies
const LANE_COUNT = 5;
export function DanmakuOverlay({ danmakuList, currentTime }: Props) {
const activeDanmaku = danmakuList.filter(
d => d.time >= currentTime - 0.1 && d.time < currentTime + 0.1
);
return (
<View style={StyleSheet.absoluteFillObject} pointerEvents="none">
{activeDanmaku.map((d, i) => (
<DanmakuItem
key={d.id}
text={d.text}
color={d.color}
lane={i % LANE_COUNT}
/>
))}
</View>
);
}
Danmaku en Direct (WebSocket)
// hooks/useLiveDanmaku.ts
const LIVE_WS = 'wss://broadcastlv.chat.bilibili.com/sub';
export function useLiveDanmaku(roomId: number) {
const [messages, setMessages] = useState<LiveMessage[]>([]);
const wsRef = useRef<WebSocket | null>(null);
useEffect(() => {
const ws = new WebSocket(LIVE_WS);
wsRef.current = ws;
ws.onopen = () => {
// Envoyer un paquet de jointure de salle
const body = JSON.stringify({ roomid: roomId, uid: 0, protover: 2 });
ws.send(buildPacket(body, 7)); // op=7 : entrer dans la salle
startHeartbeat(ws);
};
ws.onmessage = async (event) => {
const packets = await decompressPacket(event.data);
packets.forEach(packet => {
if (packet.op === 5) {
const msg = JSON.parse(packet.body);
handleCommand(msg);
}
});
};
return () => ws.close();
}, [roomId]);
function handleCommand(msg: any) {
switch (msg.cmd) {
case 'DANMU_MSG':
setMessages(prev => [{
type: 'danmaku',
text: msg.info[1],
user: msg.info[2][1],
isGuard: msg.info[7] > 0, // Marqueur de garde
}, ...prev].slice(0, 200));
break;
case 'SEND_GIFT':
setMessages(prev => [{
type: 'gift',
user: msg.data.uname,
gift: msg.data.giftName,
count: msg.data.num,
}, ...prev].slice(0, 200));
break;
}
}
return messages;
}
Stores d'État Zustand
// store/videoStore.ts
import { create } from 'zustand';
interface VideoState {
currentVideo: { bvid: string; cid: number } | null;
isMiniplayer: boolean;
quality: number; // 80=1080P, 112=1080P+, 120=4K
setCurrentVideo: (video: { bvid: string; cid: number }) => void;
setMiniplayer: (val: boolean) => void;
setQuality: (q: number) => void;
}
export const useVideoStore = create<VideoState>((set) => ({
currentVideo: null,
isMiniplayer: false,
quality: 80,
setCurrentVideo: (video) => set({ currentVideo: video }),
setMiniplayer: (val) => set({ isMiniplayer: val }),
setQuality: (q) => set({ quality: q }),
}));
// store/authStore.ts
interface AuthState {
sessdata: string | null;
isLoggedIn: boolean;
login: (sessdata: string) => Promise<void>;
logout: () => Promise<void>;
}
export const useAuthStore = create<AuthState>((set) => ({
sessdata: null,
isLoggedIn: false,
login: async (sessdata) => {
await AsyncStorage.setItem('SESSDATA', sessdata);
set({ sessdata, isLoggedIn: true });
},
logout: async () => {
await AsyncStorage.removeItem('SESSDATA');
set({ sessdata: null, isLoggedIn: false });
},
}));
Connexion par QR Code
// hooks/useQrLogin.ts
export function useQrLogin() {
const { login } = useAuthStore();
const [qrUrl, setQrUrl] = useState('');
const [qrKey, setQrKey] = useState('');
const pollRef = useRef<ReturnType<typeof setInterval>>();
async function generateQr() {
const res = await api.get('/x/passport-login/web/qrcode/generate');
const { url, qrcode_key } = res.data.data;
setQrUrl(url);
setQrKey(qrcode_key);
startPolling(qrcode_key);
}
function startPolling(key: string) {
pollRef.current = setInterval(async () => {
const res = await api.get('/x/passport-login/web/qrcode/poll', {
params: { qrcode_key: key },
});
const { code } = res.data.data;
if (code === 0) {
// Extraire SESSDATA de l'en-tête Set-Cookie
const setCookie = res.headers['set-cookie'] ?? [];
const sessdataCookie = setCookie
.find((c: string) => c.includes('SESSDATA='));
const sessdata = sessdataCookie?.match(/SESSDATA=([^;]+)/)?.[1];
if (sessdata) {
clearInterval(pollRef.current);
await login(sessdata);
}
}
}, 2000);
}
return { qrUrl, qrKey, generateQr };
}
Gestionnaire de Téléchargements
// hooks/useDownload.ts
export function useDownload() {
const [downloads, setDownloads] = useState<DownloadItem[]>([]);
async function startDownload(video: { bvid: string; cid: number }) {
const stream = await getVideoStream(video.bvid, video.cid);
const videoUrl = stream.dash.video[0].baseUrl;
const audioUrl = stream.dash.audio[0].baseUrl;
const downloadId = `dl_${Date.now()}`;
setDownloads(prev => [...prev, {
id: downloadId,
status: 'downloading',
progress: 0,
videoUrl,
audioUrl,
}]);
// Télécharger avec FileSystem.downloadAsync
const videoPath = `${FileSystem.documentDirectory}${downloadId}_video.mp4`;
const audioPath = `${FileSystem.documentDirectory}${downloadId}_audio.m4a`;
const videoResult = await FileSystem.downloadAsync(videoUrl, videoPath);
const audioResult = await FileSystem.downloadAsync(audioUrl, audioPath);
if (videoResult.status === 200 && audioResult.status === 200) {
setDownloads(prev => prev.map(d =>
d.id === downloadId ? { ...d, status: 'completed', videoPath, audioPath } : d
));
}
}
return { downloads, startDownload };
}
Partage LAN par QR
// utils/shareViaLan.ts
import * as FileSystem from 'expo-file-system';
import { Buffer } from 'buffer';
const LAN_SERVER_PORT = 8080;
export async function startLanServer() {
const server = await FileSystem.createHttpServer({
port: LAN_SERVER_PORT,
handler: async (req, res) => {
const filePath = `${FileSystem.documentDirectory}${req.url?.slice(1)}`;
const fileInfo = await FileSystem.getInfoAsync(filePath);
if (fileInfo.exists) {
res.writeHead(200, { 'Content-Type': 'video/mp4' });
res.end(await FileSystem.readAsStringAsync(filePath, {
encoding: FileSystem.EncodingType.Base64,
}), 'base64');
}
},
});
return `http://${getLocalIp()}:${LAN_SERVER_PORT}`;
}
Licence
MIT — Utilisation libre pour l'apprentissage et la contribution open-source.