Flutter + bitHuman: Mobile Avatar App

from flask import Flask, request, jsonify
from livekit import api
from datetime import timedelta
import os
from dotenv import load_dotenv

load_dotenv()
app = Flask(__name__)

LIVEKIT_API_KEY = os.getenv("LIVEKIT_API_KEY")
LIVEKIT_API_SECRET = os.getenv("LIVEKIT_API_SECRET")
LIVEKIT_URL = os.getenv("LIVEKIT_URL")

@app.route('/token', methods=['POST'])
def create_token():
    data = request.get_json() or {}
    room = data.get('room', 'flutter-avatar-room')
    identity = data.get('participant', 'Flutter User')

    at = api.AccessToken(LIVEKIT_API_KEY, LIVEKIT_API_SECRET, identity=identity)
    at.add_grant(api.VideoGrant(room_join=True, room=room))
    at.ttl = timedelta(hours=1)

    return jsonify({'token': at.to_jwt(), 'server_url': LIVEKIT_URL})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000)

import os
from dotenv import load_dotenv
from livekit.agents import (
    Agent,
    AgentSession,
    JobContext,
    RoomOutputOptions,
    WorkerOptions,
    WorkerType,
    cli,
)
from livekit.plugins import bithuman, openai, silero

load_dotenv()

async def entrypoint(ctx: JobContext):
    await ctx.connect()
    await ctx.wait_for_participant()

    avatar = bithuman.AvatarSession(
        avatar_id=os.getenv("BITHUMAN_AGENT_ID"),
        api_secret=os.getenv("BITHUMAN_API_SECRET"),
    )

    session = AgentSession(
        llm=openai.realtime.RealtimeModel(
            voice="coral",
            model="gpt-4o-mini-realtime-preview",
        ),
        vad=silero.VAD.load(),
    )

    await avatar.start(session, room=ctx.room)

    await session.start(
        agent=Agent(
            instructions="You are a helpful assistant. Respond concisely."
        ),
        room=ctx.room,
        room_output_options=RoomOutputOptions(audio_enabled=False),
    )

if __name__ == "__main__":
    cli.run_app(WorkerOptions(
        entrypoint_fnc=entrypoint,
        worker_type=WorkerType.ROOM,
        job_memory_warn_mb=2000,
        num_idle_processes=1,
        initialize_process_timeout=180,
    ))

import 'dart:convert';
import 'dart:math';
import 'package:http/http.dart' as http;

class LiveKitConfig {
  static const String serverUrl = 'wss://your-project.livekit.cloud';
  static const String? tokenEndpoint = 'http://localhost:3000/token';

  static String get roomName {
    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
    final random = Random();
    return 'room-${String.fromCharCodes(
      Iterable.generate(12, (_) => chars.codeUnitAt(random.nextInt(chars.length)))
    )}';
  }

  static String get participantName {
    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
    final random = Random();
    return 'user-${String.fromCharCodes(
      Iterable.generate(8, (_) => chars.codeUnitAt(random.nextInt(chars.length)))
    )}';
  }

  static Future<String> getToken() async {
    final response = await http.post(
      Uri.parse(tokenEndpoint!),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'room': roomName,
        'participant': participantName,
      }),
    );
    if (response.statusCode == 200) {
      return jsonDecode(response.body)['token'] as String;
    }
    throw Exception('Token server returned ${response.statusCode}');
  }
}

import 'package:flutter/material.dart';
import 'package:livekit_client/livekit_client.dart' as lk;
import 'package:livekit_components/livekit_components.dart';
import 'config/livekit_config.dart';

void main() => runApp(const BitHumanFlutterApp());

class BitHumanFlutterApp extends StatelessWidget {
  const BitHumanFlutterApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'bitHuman Flutter Integration',
      theme: LiveKitTheme().buildThemeData(context),
      themeMode: ThemeMode.dark,
      home: const ConnectionScreen(),
    );
  }
}

class ConnectionScreen extends StatefulWidget {
  const ConnectionScreen({super.key});

  @override
  State<ConnectionScreen> createState() => _ConnectionScreenState();
}

class _ConnectionScreenState extends State<ConnectionScreen> {
  bool _isConnecting = false;

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addPostFrameCallback((_) => _connect());
  }

  Future<void> _connect() async {
    setState(() => _isConnecting = true);
    final token = await LiveKitConfig.getToken();
    if (!mounted) return;

    Navigator.of(context).pushReplacement(
      MaterialPageRoute(
        builder: (_) => VideoRoomScreen(
          url: LiveKitConfig.serverUrl,
          token: token,
          roomName: LiveKitConfig.roomName,
        ),
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: const Color(0xFF1a1a1a),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            const CircularProgressIndicator(),
            const SizedBox(height: 20),
            Text(
              _isConnecting ? 'Connecting...' : 'Failed',
              style: const TextStyle(color: Colors.white70, fontSize: 18),
            ),
          ],
        ),
      ),
    );
  }
}

class VideoRoomScreen extends StatelessWidget {
  final String url, token, roomName;
  const VideoRoomScreen({
    super.key, required this.url, required this.token, required this.roomName,
  });

  @override
  Widget build(BuildContext context) {
    return LivekitRoom(
      roomContext: RoomContext(
        url: url,
        token: token,
        connect: true,
        roomOptions: lk.RoomOptions(adaptiveStream: true, dynacast: true),
      ),
      builder: (context, roomCtx) {
        return Scaffold(
          appBar: AppBar(title: Text('Room: $roomName')),
          backgroundColor: const Color(0xFF1a1a1a),
          body: const Center(child: Text('AI Avatar Video Here')),
        );
      },
    );
  }
}