JKVideo Bilibili React Native Client
Skill von ara.so — Tägliche 2026 Skills Sammlung.
JKVideo ist ein vollwertiger Drittanbieter-Bilibili-Client, erstellt mit React Native 0.83 + Expo SDK 55. Er unterstützt DASH-adaptives Streaming, Echtzeit-Danmaku (Bullet-Kommentare), WBI-API-Signierung, QR-Code-Login, Live-Streaming mit WebSocket-Danmaku und einen Download-Manager mit LAN-QR-Freigabe.
Installation & Einrichtung
Voraussetzungen
- Node.js 18+
- npm oder yarn
- Für Android: Android Studio + SDK
- Für iOS: macOS + Xcode 15+
Schnellstart (Expo Go — keine Kompilierung)
git clone https://github.com/tiajinsha/JKVideo.git
cd JKVideo
npm install
npx expo start
Scannen Sie den QR-Code mit der Expo Go App. Hinweis: DASH 1080P+ erfordert einen Dev Build.
Dev Build (Volle Funktionen — Empfohlen)
npm install
npx expo run:android # Android
npx expo run:ios # iOS (macOS + Xcode erforderlich)
Web mit Image Proxy
npm install
npx expo start --web
# In einem separaten Terminal:
node scripts/proxy.js # Startet Proxy auf Port 3001, um Bilibili-Referer-Beschränkungen zu umgehen
APK direkt installieren (Android)
Laden Sie von Releases herunter — aktivieren Sie "Installation aus unbekannten Quellen" in den Android-Einstellungen.
Projektstruktur
app/
index.tsx # Startseite (PagerView heiße/live Tabs)
video/[bvid].tsx # Video-Detail (Wiedergabe + Kommentare + Danmaku)
live/[roomId].tsx # Live-Detail (HLS + Echtzeit-Danmaku)
search.tsx # Suchseite
downloads.tsx # Download-Manager
settings.tsx # Einstellungen (Qualität, Abmelden)
components/ # UI: Player, Danmaku-Overlay, Karten
hooks/ # Daten-Hooks: Videoliste, Streams, Danmaku
services/ # Bilibili API (axios + Cookie-Interceptor)
store/ # Zustand-Stores: Authentifizierung, Download, Video, Einstellungen
utils/ # Helfer: Formatierung, Image-Proxy, MPD-Builder
Wichtiger Technologie-Stack
| Ebene | Technologie |
|---|---|
| Framework | React Native 0.83 + Expo SDK 55 |
| Routing | expo-router v4 (Dateisystem, Stack-Navigation) |
| State | Zustand |
| HTTP | Axios |
| Speicher | @react-native-async-storage/async-storage |
| Video | react-native-video (DASH MPD / HLS / MP4) |
| Fallback | react-native-webview (HTML5-Video-Injektion) |
| Seitenwechsel | react-native-pager-view |
| Icons | @expo/vector-icons (Ionicons) |
WBI-Signatur-Implementierung
Bilibili erfordert eine WBI-Signierung für die meisten API-Aufrufe. JKVideo implementiert reines TypeScript MD5 mit 12h Nav-Cache.
// utils/wbi.ts — reines TS MD5, keine externen Crypto-Abhängigkeiten
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 };
// Parameter alphabetisch sortieren, Sonderzeichen filtern
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); // reines TS md5
return { ...signParams, w_rid: wRid };
}
// Nav-Schlüssel abrufen und zwischenspeichern (12h TTL)
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;
}
Bilibili API Service
// 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',
},
});
// SESSDATA-Cookie aus dem Store injizieren
api.interceptors.request.use(async (config) => {
const sessdata = await AsyncStorage.getItem('SESSDATA');
if (sessdata) {
config.headers['Cookie'] = `SESSDATA=${sessdata}`;
}
return config;
});
// Beliebte Videoliste (WBI-signiert)
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;
}
// Videostream-Informationen (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;
}
// Live-Stream-URL
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
}
DASH MPD Builder
ExoPlayer benötigt eine lokale MPD-Datei. JKVideo generiert sie aus Bilibilis DASH-Antwort:
// 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>`;
// In temporäre Datei schreiben, file:// URI für ExoPlayer zurückgeben
const path = `${FileSystem.cacheDirectory}dash_${Date.now()}.mpd`;
FileSystem.writeAsStringAsync(path, mpd);
return path;
}
Video-Player-Komponente
// 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) {
// WebView Fallback für 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 })}
/>
);
}
Danmaku-System
Video-Danmaku (XML-Zeitachsensynchronisation)
// 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',
});
// XML-Danmaku parsen
const xml = new TextDecoder('utf-8').decode(res.data);
const items = parseXmlDanmaku(xml); // parse <d p="time,...">text</d>
setDanmakuList(items);
}
return danmakuList;
}
// components/DanmakuOverlay.tsx — 5-spurige schwebende Anzeige
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>
);
}
Live-Danmaku (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 = () => {
// Raumbeitrittspaket senden
const body = JSON.stringify({ roomid: roomId, uid: 0, protover: 2 });
ws.send(buildPacket(body, 7)); // op=7: Raum betreten
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, // Kapitänsmarkierung
}, ...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;
}
Zustand State Stores
// 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 });
},
}));
QR-Code-Login
// 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) {
// SESSDATA aus Set-Cookie-Header extrahieren
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);
}
}
}, 3000); // Alle 3 Sekunden abfragen
}
return { qrUrl, generateQr };
}
Download-Manager
// utils/downloadManager.ts
import * as FileSystem from 'expo-file-system';
import * as MediaLibrary from 'expo-media-library';
import { useDownloadStore } from '../store/downloadStore';
interface DownloadTask {
id: string;
url: string;
fileName: string;
progress: number;
status: 'queued' | 'downloading' | 'completed' | 'failed';
}
// Fragmentiertes Herunterladen (DASH Audio + Video)
export async function startDashDownload(
dashData: BiliDashData,
fileName: string
): Promise<void> {
const { addTask, updateTask } = useDownloadStore.getState();
const taskId = `dash_${Date.now()}`;
addTask({ id: taskId, fileName, progress: 0, status: 'queued' });
try {
// Höchste Qualität für Audio und Video nehmen
const bestVideo = dashData.video.reduce((a, b) =>
a.bandwidth > b.bandwidth ? a : b
);
const bestAudio = dashData.audio.reduce((a, b) =>
a.bandwidth > b.bandwidth ? a : b
);
const videoPath = `${FileSystem.cacheDirectory}${taskId}_video.mp4`;
const audioPath = `${FileSystem.cacheDirectory}${taskId}_audio.mp4`;
const outputPath = `${FileSystem.documentDirectory}${fileName}.mp4`;
updateTask(taskId, { status: 'downloading', progress: 10 });
// Video herunterladen
const videoDownload = FileSystem.createDownloadResumable(
bestVideo.baseUrl, videoPath, {},
(progress) => {
const pct = 10 + Math.floor(progress.totalBytesWritten / progress.totalBytesExpectedToWrite * 40);
updateTask(taskId, { progress: pct });
}
);
await videoDownload.downloadAsync();
// Audio herunterladen
const audioDownload = FileSystem.createDownloadResumable(
bestAudio.baseUrl, audioPath, {},
(progress) => {
const pct = 50 + Math.floor(progress.totalBytesWritten / progress.totalBytesExpectedToWrite * 30);
updateTask(taskId, { progress: pct });
}
);
await audioDownload.downloadAsync();
// Mit FFmpeg zusammenführen (erfordert installiertes FFmpeg)
await mergeVideoAudio(videoPath, audioPath, outputPath);
// In Mediengalerie speichern (falls Berechtigungen erteilt)
const { status } = await MediaLibrary.requestPermissionsAsync();
if (status === 'granted') {
await MediaLibrary.saveToLibraryAsync(outputPath);
}
updateTask(taskId, { status: 'completed', progress: 100 });
} catch (error) {
updateTask(taskId, { status: 'failed' });
throw error;
}
}
// LAN-QR-Code-Freigabe
export function getLanDownloadUrl(fileName: string): string {
// Startet einen lokalen HTTP-Server auf Port 3000
const serverUrl = `http://${getLocalIp()}:3000`;
return `${serverUrl}/downloads/${encodeURIComponent(fileName)}`;
}
Fehlerbehandlung & Fallbacks
| Komponente | Fallback-Verhalten |
|---|---|
| Videowiedergabe | WebView-Fallback, wenn DASH fehlschlägt |
| API-Aufrufe | Wiederholungslogik (3 Versuche mit exponentiellem Backoff) |
| Bildproxy | Lokaler Image-Proxy für Web-Plattform |
| QR-Code-Login | Manuelle SESSDATA-Eingabe möglich |
| Danmaku-Parsing | Alte XML-Parser-Fallback für inkompatible Formate |
Leistungsoptimierung
Videowiedergabe
- Der DASH-MPD-Builder erstellt lokale MPD-Dateien, um Netzwerklatenz zu reduzieren
- ExoPlayer (Android) verwendet Hardware-Dekodierung für flüssige 4K-Wiedergabe
- WebView-Fallback für Expo Go und Web-Plattformen
- Speicherverwaltung: Entfernt ungenutzte Videodaten aus dem Cache
Danmaku-System
- Nur Danmaku in der aktuellen Zeitspanne rendern (+/- 0,1 s)
- Live-Danmaku-Limit: maximal 200 Nachrichten im Speicher behalten
- Herzschlag-Timer trennt inaktive WebSocket-Verbindungen nach 60 s
Lizenz
Dieses Projekt ist lizenziert unter der MIT-Lizenz. Siehe LICENSE für Details.
Bei Fragen oder Problemen öffnen Sie bitte ein Issue im GitHub-Repository.