Add Linux Ubuntu Support To Flutter App Enhanced Cross-Platform

Jul 13, 2025 by gitftunila 64 views

Add Linux Ubuntu Support to Your Flutter App for Enhanced Cross-Platform Compatibility

In today's multi-platform world, developing applications that work seamlessly across different operating systems is crucial. Cross-platform compatibility is a key advantage for any application, ensuring a broader reach and user base. Flutter, Google's UI toolkit, excels in this area, allowing developers to build applications for various platforms, including Android and Linux. This article will guide you through the process of adding Linux Ubuntu support to your Flutter application, specifically focusing on Bluetooth Low Energy (BLE) functionality using the flutter_blue_plus package. By following these steps, you can ensure your application runs smoothly on both Android and Linux Ubuntu, providing a consistent user experience.

Step 1: Install Flutter on Ubuntu

To begin, you need to ensure that Flutter is installed and functioning correctly on your Ubuntu system. Installing Flutter on Ubuntu is a straightforward process that involves using the Snap package manager. Snap provides an easy way to install and manage applications on Linux. First, open your terminal and run the following command to install Flutter:

sudo snap install flutter --classic

This command downloads and installs the Flutter SDK along with all necessary dependencies. Once the installation is complete, it’s essential to verify that Flutter is working correctly. Run the flutter doctor command in the terminal:

flutter doctor

The flutter doctor tool checks your environment and displays a report of your Flutter setup. It identifies any missing dependencies or potential issues. Carefully review the output and resolve any problems that appear. Common issues include missing Android SDK components or incorrect environment variables. Addressing these issues ensures a smooth development experience. By completing this step, you've laid the groundwork for developing Flutter applications on Ubuntu, setting the stage for cross-platform development.

Step 2: Create the Flutter Project

With Flutter installed and configured on your Ubuntu system, the next step is to create a new Flutter project. This involves using the flutter create command, which sets up the basic project structure and files. For this guide, we will create a project named bitchat_flutter. Open your terminal and navigate to the directory where you want to create the project, then run the following command:

flutter create bitchat_flutter
cd bitchat_flutter

This command generates a new Flutter project with a default set of files and directories. After creating the project, navigate into the project directory using the cd bitchat_flutter command. Now that the project is created, you need to explicitly enable Linux desktop support. This is done using the flutter config command:

flutter config --enable-linux-desktop

Enabling Linux desktop support configures Flutter to build applications for the Linux platform. This step is crucial for ensuring that your application can run on Ubuntu. To verify that Linux support is enabled, you can use the flutter devices command:

flutter devices

This command lists all connected devices and platforms that Flutter can target. You should see Linux (desktop) in the list, confirming that Linux support is correctly enabled. If Linux (desktop) is not listed, double-check that you have run the flutter config --enable-linux-desktop command and that your environment is set up correctly. This step ensures that your Flutter project is ready for Linux development, allowing you to proceed with adding specific functionalities.

Step 3: Choose the BLE Package

When developing a Flutter application that interacts with Bluetooth Low Energy (BLE) devices, selecting the right package is crucial. For Linux compatibility and active support, the flutter_blue_plus package is highly recommended. Choosing the right BLE package can significantly impact the performance and reliability of your application, especially when targeting multiple platforms like Android and Linux. The flutter_blue_plus package stands out due to its robust support for Linux and its actively maintained codebase.

To install the flutter_blue_plus package, you need to add it as a dependency in your project’s pubspec.yaml file. Open the pubspec.yaml file in your project directory and add the following lines under the dependencies section:

dependencies:
 flutter:
 sdk: flutter
 flutter_blue_plus: ^1.32.5

The flutter_blue_plus: ^1.32.5 line specifies the package and its version. It’s good practice to specify a version to ensure consistency across different development environments. After adding the dependency, you need to fetch the package using the flutter pub get command in your terminal:

flutter pub get

This command downloads the flutter_blue_plus package and its dependencies, making them available for use in your project. The flutter pub get command ensures that all necessary packages are installed, preventing potential errors related to missing dependencies. By selecting and installing the flutter_blue_plus package, you've equipped your Flutter project with the necessary tools for BLE communication on both Android and Linux platforms, setting the stage for implementing BLE functionality.

Step 4: Basic BLE Scan App

With the flutter_blue_plus package installed, you can now implement the basic BLE scanning functionality in your Flutter application. Implementing BLE scanning involves writing Dart code that utilizes the flutter_blue_plus package to scan for nearby Bluetooth devices. This step is crucial for any BLE-enabled application, as it allows the app to discover and connect to other Bluetooth devices. To achieve this, you will replace the default content of your lib/main.dart file with the following code:

import 'package:flutter/material.dart';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';

void main() {
 runApp(const MyApp());
}

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

 @override
 Widget build(BuildContext context) {
 return MaterialApp(
 home: const BLEScanPage(),
 debugShowCheckedModeBanner: false,
 );
 }
}

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

 @override
 State<BLEScanPage> createState() => _BLEScanPageState();
}

class _BLEScanPageState extends State<BLEScanPage> {
 List<ScanResult> devices = [];
 bool scanning = false;

 void startScan() {
 setState(() {
 devices.clear();
 scanning = true;
 });
 FlutterBluePlus.startScan(timeout: const Duration(seconds: 5)).listen(
 (scanResult) {
 setState(() {
 devices.add(scanResult);
 });
 },
 onDone: () => setState(() => scanning = false),
 );
 }

 @override
 void initState() {
 super.initState();
 FlutterBluePlus.adapterState.listen((state) {
 if (state == BluetoothAdapterState.on) {
 startScan();
 }
 });
 }

 @override
 Widget build(BuildContext context) {
 return Scaffold(
 appBar: AppBar(
 title: const Text('BLE Device Scanner'),
 ),
 floatingActionButton: FloatingActionButton(
 onPressed: scanning ? null : startScan,
 child: Icon(scanning ? Icons.bluetooth_searching : Icons.bluetooth),
 ),
 body: devices.isEmpty
 ? const Center(child: Text('No devices found yet'))
 : ListView.builder(
 itemCount: devices.length,
 itemBuilder: (context, i) => ListTile(
 title: Text(devices[i].device.platformName.isNotEmpty
 ? devices[i].device.platformName
 : "Unknown Device"),
 subtitle: Text(devices[i].device.remoteId.toString()),
 trailing: Text('RSSI: ${devices[i].rssi}'),
 ),
 ),
 );
 }
}

This code creates a simple Flutter application with a button to start scanning for BLE devices and a list to display the discovered devices. The startScan function uses FlutterBluePlus.startScan to initiate the scan and listens for scan results. The initState method ensures that scanning starts automatically when Bluetooth is enabled. By implementing this basic scanning functionality, you've created a foundation for your BLE application, allowing it to discover and display nearby Bluetooth devices. This is a crucial step in building any BLE-enabled application, providing the ability to interact with other Bluetooth devices.

Step 5: Linux Dependencies (Important)

To ensure your Flutter application with BLE functionality runs smoothly on Ubuntu, it's crucial to install the necessary Linux dependencies. Installing Linux dependencies involves setting up the required libraries and tools that enable Bluetooth communication on the Ubuntu system. This step is critical for the flutter_blue_plus package to function correctly and for your application to interact with Bluetooth devices.

First, you need to update the package list and install the required packages using the following commands:

sudo apt-get update
sudo apt-get install \
 clang \
 cmake \
 ninja-build \
 pkg-config \
 libgtk-3-dev \
 libbluetooth-dev \
 bluez

These packages include essential tools like clang, cmake, and ninja-build, which are necessary for compiling native code. pkg-config helps in finding and using libraries, libgtk-3-dev provides the GTK 3 development libraries for GUI support, libbluetooth-dev includes the Bluetooth development libraries, and bluez is the official Linux Bluetooth stack. After installing these packages, ensure that the Bluetooth service is running:

sudo systemctl enable bluetooth
sudo systemctl start bluetooth

The sudo systemctl enable bluetooth command ensures that the Bluetooth service starts automatically on boot, and sudo systemctl start bluetooth starts the service immediately. Next, check if your user is in the bluetooth group:

sudo usermod -a -G bluetooth $USER

This command adds your user to the bluetooth group, granting the necessary permissions to access Bluetooth devices. It is crucial to reboot your system after this step to apply the changes. Rebooting ensures that the new group membership and service configurations are correctly loaded. By installing these dependencies and configuring the Bluetooth service, you've prepared your Ubuntu system for BLE communication, allowing your Flutter application to interact with Bluetooth devices seamlessly.

Step 6: Run Your Flutter App

With the necessary Linux dependencies installed and Bluetooth configured, you are now ready to run your Flutter application on Ubuntu. Running your Flutter app on Linux involves using the flutter run command with the -d linux flag, which specifies the target device as Linux. This command compiles your Flutter code and launches the application on your Ubuntu desktop. To run your app, open your terminal, navigate to your project directory (if you're not already there), and execute the following command:

flutter run -d linux

This command initiates the build process, which may take a few moments depending on your system's performance and the complexity of your application. Once the build is complete, your Flutter application will launch, displaying a graphical user interface (GUI). In this case, you should see the basic GUI of your BLE scanner application, which includes a scan button. The scan button is typically represented by a FloatingActionButton in Flutter applications. By running your application, you can visually verify that the UI is rendering correctly and that the basic structure of your application is functioning as expected. This step is crucial for ensuring that your Flutter application is correctly set up to run on Linux, paving the way for testing the BLE functionality.

Step 7: Verify Functionality

Once your Flutter application is running on Ubuntu, it's essential to verify that the BLE functionality is working as expected. Verifying BLE functionality involves testing the application's ability to scan for and discover nearby Bluetooth devices. This step ensures that the flutter_blue_plus package is correctly integrated and that the application can interact with Bluetooth devices on the Linux platform. To begin, ensure that any nearby BLE devices you want to discover are in discoverable mode. This usually involves putting the devices in pairing mode or ensuring they are broadcasting their presence. Next, click the FloatingActionButton in your application's GUI to start scanning for devices. The application should initiate a scan for BLE devices in the vicinity. If the scan is successful, you should see the discovered devices listed in the UI. The list typically displays the device names, MAC addresses, and RSSI (Received Signal Strength Indication) values. Confirm that the devices appear correctly in the UI, with accurate names and addresses. If no devices are appearing, double-check that Bluetooth is enabled on your Ubuntu system and that the nearby devices are discoverable. Also, ensure that your application has the necessary permissions to access Bluetooth. By verifying the functionality, you can confirm that your Flutter application is correctly scanning for and displaying BLE devices on Ubuntu, indicating that the core BLE functionality is working as expected. This is a critical step in ensuring the reliability and effectiveness of your application.

Step 8: Troubleshooting Tips

Even with careful setup, you may encounter issues when running a Flutter application with BLE functionality on Linux. Troubleshooting BLE issues is a crucial skill for developers, as Bluetooth communication can be affected by various factors, including hardware compatibility, driver problems, and permission settings. If you face problems, there are several steps you can take to diagnose and resolve them.

First, check the Bluetooth status on your system using the rfkill list bluetooth command:

rfkill list bluetooth

This command lists any Bluetooth devices that are blocked by rfkill, a tool for managing hardware switches. If Bluetooth is blocked, unblock it using the following command:

rfkill unblock bluetooth

Next, verify that BLE scanning works from the terminal using the bluetoothctl command-line tool. Start by entering the bluetoothctl interface:

bluetoothctl

Then, turn on the controller and start scanning:

power on
scan on

If this doesn't work, your hardware or drivers may have compatibility issues. Check for any error messages in the terminal and consult your system's documentation or online forums for solutions. If bluetoothctl can scan for devices but your Flutter application cannot, the issue may be related to the flutter_blue_plus package or your application's code. Double-check that you have correctly implemented the BLE scanning logic and that all necessary permissions are granted. By systematically troubleshooting these potential issues, you can identify and resolve the root cause of the problem, ensuring that your Flutter application with BLE functionality runs smoothly on Ubuntu.