Introduction

This is a continuation of the blog series: "Building a Youtube Clone with Strapi and Flutter". It is suggested that you read Part 1 to understand how we got to this stage.

For reference purposes, here's the outline of this blog series:

• Part 1: Building a Video Streaming Backend with Strapi
• Part 2: Creating Services and State Management
• Part 3: Building the App UI with Flutter

In this Part 2, we'll learn how to set up a new Flutter project, configure permissions, create the app services, and state management to handle real-time functionalities and UI updates.

To get started, let's set up a new Flutter project, configure the development environment, and install the required dependencies for this project.

Creating a New Flutter Project

Create a new flutter project in the terminal by running the commands below.

flutter create youtube_clone
cd youtube_clone
flutter run

Setting up Android and IOS Permissions

First, we need to configure the permissions to grant users access to the internet, read and write external storage, and use the camera.

For Android, open the android/app/src/main/AndroidManifest.xml file and add the necessary permissions to your existing AndroidManifest.xml file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Permission for internet access -->
    <uses-permission android:name="android.permission.INTERNET"/>
    
    <!-- Permissions for accessing external storage -->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    
    <!-- Permission for camera access -->
    <uses-permission android:name="android.permission.CAMERA"/>
    
    <application
    ...
    android:usesCleartextTraffic="true"
    ...>
        ...
    </application>
</manifest>

Then for iOS, open the ios/Runner/Info.plist file and add the necessary permissions into your existing ios/Runner/Info.plist file:

1
2
3
4
5
6
7
8
9
10
11
...
<dict>
    <key>NSPhotoLibraryUsageDescription</key>
    <string>Allow access to photo library</string>
    <key>NSCameraUsageDescription</key>
    <string>Allow access to camera</string>
    <key>NSMicrophoneUsageDescription</key>
    <string>Allow access to microphone</string>
    ...
</dict>
</plist>

After making these changes, rebuild and run your app.

Adding necessary dependencies

Next, add the necessary dependencies for this project. We'll install the following dependencies:

• http: Provides a set of high-level functions and classes for HTTP requests.
• video_player: Flutter plugin for playing video on Android, iOS, and web.
• web_socket_channel: Provides WebSocket support for Dart applications.
• provider: A wrapper around InheritedWidget for easier state management.
• image_picker: Flutter plugin for selecting images from the device's gallery or camera.
• socket_io_client: Dart client for Socket.IO, enabling real-time, bidirectional communication.
• path: Provides common operations for manipulating paths across platforms.

Run the command below on your terminal from the root directory of your Flutter project to install the dependencies:

1
flutter pub add http video_player web_socket_channel provider image_picker socket_io_client path flutter_secure_storage

Configuring Asset files

Finally, configure the project assets files that will be used in this project. Create a new directory named assets in the root directory of your project. In the assets directory, create an images directory to keep the images. Then download the YouTube logo into that directory.

Open the pubspec.yaml file from the root directory of your project, locate the assets section, and add assets to your application:

1
2
assets:
 - assets/images/YouTube_logo.png

Lastly, create a utils folder in the lib folder, inside the utils folder create a new getter.dart file and add the code snippets:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import 'dart:io';
import 'package:flutter/foundation.dart' show kIsWeb;

String getBaseUrl() {
  if (kIsWeb) {
    return 'http://localhost:1337';
  } else if (Platform.isAndroid) {
    return 'http://10.0.2.2:1337';
  } else if (Platform.isIOS) {
    return 'http://localhost:1337';
  } else {
    return 'http://localhost:1337';
  }
}

The getBaseUrl() function checks which device the app is running on and returns the appropriate host for that device. This ensures that our application works on any platform.

Creating App Services

Now that you have set up your Flutter project, configured the permissions, add assets, and installed the required project dependencies, let's proceed to creating the app services to make API requests to your Strapi backend.

Creating a Video Service

Create a new folder named services in the lib directory. In the services directory, create a new file named video_service.dart. Define a VideoService class and add a fetchVideos method to fetch video data from your Strapi backend:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import 'dart:io';
import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:youtube_clone/utils/getter.dart';

class VideoService {
  static const String populateQuery =
      'populate[comments][populate][user][populate][profile_picture]=profile_picture&populate[thumbnail]=*&populate[video_file]=*&populate[likes]=*&populate[views]=*&populate[comments][populate]=*&populate[uploader][populate]=profile_picture&populate[uploader][populate]=subscribers';
  final _storage = const FlutterSecureStorage();

  Future<List<dynamic>> fetchVideos() async {
    final response =
        await http.get(Uri.parse('${getBaseUrl()}/api/videos?$populateQuery'));

    if (response.statusCode == 200) {
      final Map<String, dynamic> responseData = json.decode(response.body);

      // Extract the list of videos from the 'data' field
      return responseData['data'] as List<dynamic>;
    } else {
      throw Exception('Failed to load videos');
    }
  }
  
  Future<Map<String, dynamic>> fetchVideo(String documentId) async {
    final response = await http
        .get(Uri.parse('$getBaseUrl()/api/videos/$documentId/$populateQuery'));

    if (response.statusCode == 200) {
      final Map<String, dynamic> responseData = json.decode(response.body);

      // Extract the list of videos from the 'data' field
      return responseData['data'] as Map<String, dynamic>;
    } else {
      throw Exception('Failed to load videos');
    }
  }
}

In the above code VideoService we defined two global variables, populateQuery for all the populate queries we'll use to populate all the relations models in your Video collection. The fetchVideos method sends a GET request to fetch all videos, while fetchVideo retrieves a single video by its documentId. Both methods use the populateQuery for all the required data retrieval, including comments, user information, thumbnails, etc.

Next, update the VideoService to define a new method to handle the video uploading. Also since this is an authenticated action we'll need a JWT token, so we'll define a new method to extract the token from the device's local storage (the logic for saving the token will be handled when implementing authentication):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 //...
  Future<String?> _getAuthToken() async {
    return await _storage.read(key: 'auth_token');
  }

  Future<void> uploadVideoContent(File videoFile, File thumbnailFile,
      String title, String description, String userId) async {
    try {
      final baseUrl = getBaseUrl();

      final videoId = await uploadFile(videoFile, 'video');

      final thumbnailId = await uploadFile(thumbnailFile, 'image');

      await createVideoEntry(
          baseUrl, videoId, thumbnailId, title, description, userId);
    } catch (e) {
      print('Error occurred: $e');
    }
  }

  Future<String> uploadFile(File file, String fileType) async {
    final uri = Uri.parse('${getBaseUrl()}/api/upload');

    var request = http.MultipartRequest('POST', uri);
    request.files.add(await http.MultipartFile.fromPath('files', file.path));

    var response = await request.send();
    if (response.statusCode == 201) {
      final responseBody = await response.stream.bytesToString();
      final jsonResponse = jsonDecode(responseBody);
      return jsonResponse[0]['id'].toString();
    } else {
      throw Exception('Failed to upload $fileType');
    }
  }

  Future<void> createVideoEntry(String baseUrl, String videoId,
      String thumbnailId, String title, String description, userId) async {
    final uri = Uri.parse('$baseUrl/api/videos');
    final token = await _getAuthToken();
    final response = await http.post(
      uri,
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $token',
      },
      body: jsonEncode({
        "data": {
          "title": title,
          "description": description,
          "video_file": videoId,
          "thumbnail": thumbnailId,
          "uploader": userId
        }
      }),
    );

    if (response.statusCode == 201) {
      print('Video entry created successfully');
    } else {
      print('Failed to create video entry: ${response.body}');
      throw Exception('Failed to create video entry');
    }
  }
  //...

In these code snippets, we've added some new methods to our VideoService class to handle uploading videos and creating entries. The _getAuthToken method grabs the auth token from secure storage (we'll need this for some requests).

The uploadVideoContent method is the main player here. It manages the whole process of uploading a video file and its thumbnail, then creates a new entry in the backend. It uses the uploadFile method to send the files to the server and get their IDs back.

Then we have the createVideoEntry method. This takes all the info we've collected, video ID, thumbnail ID, title, description, and user's ID, and creates a new video entry in our Strapi backend. It uses the auth token we retrieved earlier. We've also added error handling throughout to catch and log any problems that might pop up during the upload and creation process.

Lastly, add the following methods to the VideoService class to handle the like, views, comment and subscribe requests to your Strapi backend:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
  //...
  Future<void> likeVideo(String videoId) async {
    final token = await _getAuthToken();
    final response = await http.put(
      Uri.parse('${getBaseUrl()}/api/videos/$videoId/like'),
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $token',
      },
    );

    if (response.statusCode != 200) {
      throw Exception('Failed to like video');
    }
  }

  Future<void> increaseViews(String videoId) async {
    final token = await _getAuthToken();

    final response = await http.put(
      Uri.parse('${getBaseUrl()}/api/videos/$videoId/increment-view'),
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $token',
      },
    );

    if (response.statusCode != 200) {
      throw Exception(
          'Failed to increase views: ${response.reasonPhrase} (${response.statusCode})');
    }
  }

  Future<void> commentOnVideo(
      String videoId, String comment, String userId) async {
    final token = await _getAuthToken();
    final response = await http.post(
      Uri.parse('${getBaseUrl()}/api/comments?populate=*'),
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $token',
      },
      body: jsonEncode({
        "data": {'text': comment, "user": userId, "video": videoId}
      }),
    );

    if (response.statusCode != 200) {
      throw Exception(
          'Failed to post comment: ${response.body}');
    }
  }
  
  Future subscribeToChannel(int userId) async {
    final uri = Uri.parse('${getBaseUrl()}/api/videos/$userId/subscribe');
    final token = await _getAuthToken();
    final response = await http.put(
      uri,
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $token',
      },
    );
    if (response.statusCode == 200) {
      print('Subscription created successfully');
    } else {
      print('Failed to create subscription: ${response.body}');
      throw Exception('Failed to create subscription');
    }
  }
 //...

In this part of the code, we've defined a few more methods to VideoService class to handle some common video interactions such as liking, increasing views, commenting, and subscribing to a channel.

First, we've defined the likeVideo method to send a request to the server to like a specific video. We use the auth token to make sure the user is logged in. Then the increaseViews method to increase the view count for a video. Again, we're using the auth token to keep things secure. Lastly, define the commentOnVideo method to allow users to post comments on videos. It sends the video ID, the comment text, and the user ID to the server.

Creating a User Service

To allow users to sign-up to create a channel and log in. You'll need to create a user service. Create a new user_service.dart file in lib/services directory and add the code snippets below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
import 'dart:io';
import 'package:http/http.dart' as http;
import 'package:youtube_clone/services/video_service.dart';
import 'dart:convert';
import 'package:youtube_clone/utils/getter.dart';

class UserService {
  Future<String?> login(String email, String password) async {
    final response = await http.post(
      Uri.parse('${getBaseUrl()}/api/auth/local'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'identifier': email,
        'password': password,
      }),
    );

    if (response.statusCode == 200) {
      final data = json.decode(response.body);
      return data['jwt'];
    } else {
      return null;
    }
  }

  Future<Map?> me(String jwtToken) async {
    final response = await http.get(
      Uri.parse('${getBaseUrl()}/api/users/me?populate=role,profile_picture,'),
      headers: {
        'Content-Type': 'application/json',
        "Authorization": 'Bearer $jwtToken',
      },
    );
    if (response.statusCode == 200) {
      final data = json.decode(response.body);
      return data;
    } else {
      return null;
    }
  }

  Future<String?> signup(File profilePicturefile, String email, String username,
      String password) async {
    try {
      final profilePictureid =
          await VideoService().uploadFile(profilePicturefile, 'image');

      final response = await http.post(
        Uri.parse('${getBaseUrl()}/api/auth/local/register'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode({
          'username': username,
          'password': password,
          "email": email,
          'profile_picture': profilePictureid
        }),
      );

      if (response.statusCode == 200) {
        final data = json.decode(response.body);
        return data['jwt'];
      } else {
        return null;
      }
    } catch (e) {
      print('Error occurred: $e');
    }
    return null;
  }
}

In the above code snippets, we created a new UserService class to handle user-related operations. We designed a login method that sends a request to the Strapi authentication endpoint to log in to a user using their email and password. If it works, we get back a JWT token that we can use for future requests.

Then we defined a me method that fetches the current user's info from the server, including their role and profile picture. Lastly, we defined a signup method, which takes a profile picture file along with the user's email, username, and password. First, it uploads the profile picture using our VideoService. Then it sends all this info to the server to create a new user account. If everything goes well, we get back a JWT token for the new user.

State Management with Provider

Now that we've created the App services, we need to keep track of the data change over time and make sure all parts of our app stay in sync. We'll be using the Flutter state management package called Provider.

Creating the Socket Provider

To handle the real-time functionalities of the application, like users being able to see uploaded videos, comments, likes, and subscriptions in real-time, we need to create a Socket provider to listen to all the events we defined in your collections and update the UI accordingly. Create a new socket_provider.dart file in the provider's directory and add the code snippets below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import 'package:flutter/material.dart';
import 'package:socket_io_client/socket_io_client.dart' as IO;
import 'package:youtube_clone/utils/getter.dart';

class SocketProvider with ChangeNotifier {
  IO.Socket? _socket;
  bool _isConnected = false;

  bool get isConnected => _isConnected;

  void connect(BuildContext context) {
    _socket = IO.io(getBaseUrl(), {
      'transports': ['websocket'],
      'autoConnect': false,
    });

    _socket?.on('connect', (_) {
      _isConnected = true;
      notifyListeners();
    });

    _socket?.on('disconnect', (_) {
      _isConnected = false;
      notifyListeners();
    });

    // Listen for video events and update the VideoProvider
    _socket?.on('video.created', (_) => notifyListeners());
    _socket?.on('video.updated', (_) => notifyListeners());
    _socket?.on('video.deleted', (_) => notifyListeners());
    _socket?.on('comment.created', (_) => notifyListeners());
    _socket?.on('user.updated', (_) => notifyListeners());
    _socket?.on('user.created', (_) => notifyListeners());
    _socket?.connect();
  }

  void disconnect() {
    _socket?.disconnect();
  }
}

In the above code, we created a SocketProvider class using Flutter's ChangeNotifier to manage a WebSocket connection with the Strapi server. This setup will allow your application to receive real-time updates from the Video, Comment, and User collections.

Creating Video Provider

To manage the state in our app for all the video-related data and operations, create a VideoProvider class. Create a new directory named providers in your lib directory. Then create a video_provider.dart in our providers folder and add the code below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:youtube/providers/socket_provider.dart';
import 'package:youtube/services/video_service.dart';

class VideoProvider with ChangeNotifier {
  List _videos = [];
  Map _video = {};

  List get videos => _videos;

  VideoProvider(BuildContext context) {
    final socketProvider = Provider.of<SocketProvider>(context, listen: false);
    socketProvider.addListener(_handleSocketEvents);
  }

  void _handleSocketEvents() {
    fetchVideos();
  }

  Future fetchVideos() async {
    try {
      _videos = await VideoService().fetchVideos();
      notifyListeners();
    } catch (error) {
      print("Error fetching videos: $error");
    }
  }

  Future fetchVideo(String documentId) async {
    try {
      _video = await VideoService().fetchVideo(documentId);
      notifyListeners();
    } catch (error) {
      print("Error fetching videos: $error");
    }
  }

  Future likeVideo(String videoId) async {
    try {
      await VideoService().likeVideo(videoId);
      notifyListeners();
    } catch (error) {
      print("Error liking video: $error");
    }
  }

  Future increaseViews(String videoId) async {
    try {
      await VideoService().increaseViews(videoId);
      notifyListeners();
    } catch (error) {
      print("Error increasing views: $error");
    }
  }

  Future commentOnVideo(String videoId, String comment, String userId) async {
    try {
      await VideoService().commentOnVideo(videoId, comment, userId);
      notifyListeners();
    } catch (error) {
      print("Error commenting on video: $error");
    }
  }

  Future uploadFile(
      File imageFile, File videoFile, String title, String description, String userId) async {
    try {
      await VideoService().uploadVideoContent(
        videoFile,
        imageFile,
        title,
        description,
        userId
      );
      notifyListeners();
    } catch (error) {
      print("Error uploading file: $error");
    }
  }

  Future subscribeToChannel(int documentId) async {
    try {
      await VideoService().subscribeToChannel(documentId);
      notifyListeners();
    } catch (error) {
      print("Error subscribing to channel: $error");
    }
  }
}

Here the fetchVideos and fetchVideo methods get videos from our VideoService, update the local _videos and _video lists, and then call notifyListeners() which tells the rest of our app that the data has changed and the UI needs to update. Also, the likeVideo, increaseViews,commentOnVideo, uploadFile, and subscribeToChannel methods call their corresponding VideoService methods and updates the UI.

Creating the User Provider

Create a new user_provider.dart file in the providers folder and add the code snippets below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:youtube/services/user_service.dart';

class UserProvider with ChangeNotifier {
  final _storage = const FlutterSecureStorage();
  String? _token;
  String? _message;
  Map<String, dynamic>? _user;

  String? get token => _token;
  String? get message => _message;
  Map<String, dynamic>? get user => _user;

  Future<void> login(String email, String password) async {
    try {
      _token = await UserService().login(email, password);
      if (_token != null) {
        _user = (await UserService().me(_token!)) as Map<String, dynamic>?;
        await _storage.write(key: 'auth_token', value: _token);
        _message = null;
        notifyListeners();
      } else {
        _message = 'Invalid email or password';
        notifyListeners();
      }
    } catch (e) {
      _message = 'Failed to login. Please try again later.';
      notifyListeners();
    }
  }

  Future<void> signup(File profilePicturefile, String email, String username,
      String password) async {
    try {
      _token = await UserService()
          .signup(profilePicturefile, email, username, password);
      if (_token != null) {
        _user = (await UserService().me(_token!)) as Map<String, dynamic>?;
        await _storage.write(key: 'auth_token', value: _token);
        _message = null;
        notifyListeners();
      } else {
        _message = 'Signup failed. Please check your details and try again.';
        notifyListeners();
      }
    } catch (e) {
      print(e);
      _message = 'Failed to sign up. Please try again later.';
      notifyListeners();
    }
  }

  Future<void> loadToken() async {
    _token = await _storage.read(key: 'auth_token');
    notifyListeners();
  }

  Future<void> logout() async {
    _token = null;
    _user = {};
    await _storage.delete(key: 'auth_token');
    notifyListeners();
  }
}

In the code provided above, we created a UserProvider class using Flutter's ChangeNotifier to manage user authentication and state. It interacts with a UserService to perform login, and signup, and fetch user details.

Now update your main.dart file with the code snippets below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:youtube_clone/providers/socket_provider.dart';
import 'package:youtube_clone/providers/user_provider.dart';
import 'package:youtube_clone/providers/video_provider.dart';

void main() {
  runApp(
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (_) => SocketProvider()),
        ChangeNotifierProvider(create: (_) => UserProvider()),
        ChangeNotifierProvider(
          create: (context) => VideoProvider(context),
        ),
      ],
      child: const MyApp(),
    ),
  );
}

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

  @override
  Widget build(BuildContext context) {
    // Connect to the socket when the app starts
    Provider.of<SocketProvider>(context, listen: false).connect(context);
    
    return MaterialApp(
      title: 'YouTube Clone',
      theme: ThemeData(
        brightness: Brightness.dark,
        primaryColor: Colors.black,
        scaffoldBackgroundColor: Colors.black,
        appBarTheme: const AppBarTheme(
          backgroundColor: Colors.black,
          elevation: 0,
          iconTheme: IconThemeData(color: Colors.white),
          titleTextStyle: TextStyle(
            color: Colors.white,
            fontSize: 20,
            fontWeight: FontWeight.bold,
          ),
        ),
        iconTheme: const IconThemeData(color: Colors.white),
        textTheme: const TextTheme(
          bodyLarge: TextStyle(color: Colors.white),
          bodyMedium: TextStyle(color: Colors.white70),
          titleMedium: TextStyle(color: Colors.white),
          titleSmall: TextStyle(color: Colors.white70),
        ),
        chipTheme: ChipThemeData(
          backgroundColor: Colors.grey[850],
          labelStyle: const TextStyle(color: Colors.white),
          secondaryLabelStyle: const TextStyle(color: Colors.white),
          brightness: Brightness.dark,
          padding: const EdgeInsets.symmetric(horizontal: 8),
        ),
        cardColor: Colors.grey[900],
        dividerColor: Colors.grey[700],
      ),
       home: const Center(child: Text("My YouTube Clone")),
    );
  }
}

In the above code, we integrated the SocketProvider, UserProvider, and VideoProvider using MultiProvider, ensuring these services are available across the app. We also initialized a socket connection at the app launch by invoking the connect method from the SocketProvider in the MyApp widget. We also configured the MaterialApp with a dark theme to create a consistent, YouTube-like UI throughout the application.

We're done with Part 2 of this blog series. Stay tuned for Part 3, where we'll continue this tutorial by building the frontend with Flutter and consuming the APIs to implement a functional YouTube clone application.

Conclusion

In Part 2 of this tutorial series, we've learned how to set up a new Flutter project, configure permissions, create the app services, and configure Flutter state management to handle real-time functionalities and UI updates.

The code for this project is available on Github.

In the last part of this blog series, we will learn how to build the app UI with Flutter.