DEV Community: Sumeet Sharma

[Boost]

Sumeet Sharma — Wed, 12 Nov 2025 09:04:59 +0000

Sumeet Sharma

Jul 31 '25

Building Dynamic Forms in Flutter Like a Pro

#flutter #programming #mobile #android

Comments

3 min read

Supercharge Your Flutter App with Native Python Execution

Sumeet Sharma — Tue, 05 Aug 2025 13:28:09 +0000

Ever wondered if you could run native Python code directly inside your Flutter app? Yes, you read that right—it’s absolutely possible! As a senior mobile app developer working with both Flutter and hybrid stacks like Ionic, I’ll walk you through how to unlock this power in your next project.

Previously, I published a guide on running Python in native Android using Chaquopy. If you haven't gone through that setup yet, check out my Medium post first:

Bring Python to Your Android App Using Chaquopy | by Sumeet Sharma | Jul, 2025 | Medium

Sumeet Sharma ・ Jul 31, 2025 ・
Medium

That post covers the foundational Chaquopy integration. Once you’ve set up the basic dependencies in your root and app-level Gradle files, you only need a small tweak to make things work smoothly with your Flutter setup.

Step 1: Adjust your root-level build.gradle.kts

buildscript {
    dependencies {
        classpath("com.android.tools.build:gradle:8.8.2")
        classpath("com.chaquo.python:gradle:16.1.0")
    }
}

Keep the rest of your Chaquopy configurations from the Medium guide the same.

Step 2: Set up the Method Channel in Flutter
To bridge communication between Flutter (Dart) and Android native (Kotlin), create a Method Channel service in your Flutter code:

class MyMethodChannelService {
  static const platform = MethodChannel('my_method_channel');

  static Future<String> helloWorld() async {
    try {
      return await platform.invokeMethod('hello_world');
    } on PlatformException catch (e) {
      return 'Failed to invoke Python method: ${e.message}';
    }
  }
}

This service lets you invoke native Android code from your Flutter widgets.

Step 3: Configure Kotlin (MainActivity.kt)
On the Kotlin side, set up the method channel with the same name, initialize Python (if not already started), and define the channel handler. This handler will listen for Flutter invocations and call the desired Python function..

private val CHANNEL = "my_method_channel"
private lateinit var python: Python
private lateinit var pythonModule: com.chaquo.python.PyObject

override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    if (!Python.isStarted()) {
        Python.start(AndroidPlatform(this))
    }
    python = Python.getInstance()
    pythonModule = python.getModule("main")

    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
        when (call.method) {
            "hello_world" -> {
                handleAsyncCall(result) {
                    pythonModule.callAttr("hello_world").toString()
                }
            }
            else -> {
                result.notImplemented()
            }
        }
    }
}

private fun handleAsyncCall(result: MethodChannel.Result, pythonCall: suspend () -> String) {
    CoroutineScope(Dispatchers.IO).launch {
        try {
            val pythonResult = pythonCall()
            withContext(Dispatchers.Main) {
                result.success(pythonResult)
            }
        } catch (e: Exception) {
            withContext(Dispatchers.Main) {
                result.error("PYTHON_ERROR", "Error executing Python function: ${e.message}", e.toString())
            }
        }
    }
}

This setup ensures the async Python call doesn’t block the main thread, and all exceptions are gracefully handled.

Step 4: Call from Your Flutter UI
Now, hook it up to your Flutter UI. For example, in your Home widget:

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

  void helloWorld(BuildContext context) async {
    final result = await MyMethodChannelService.helloWorld();
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text(result)),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: ElevatedButton(
          onPressed: () => helloWorld(context),
          child: const Text("Run Python Function"),
        ),
      ),
    );
  }
}

Check out the code on GitHub.

When the button is pressed, it calls your native Python function and displays the result in a snackbar.

That’s it! You now have a clean, production-ready bridge to execute Python code from Flutter, leveraging native Android with Chaquopy. Perfect for embedding AI, data science, or any Python-powered feature in your cross-platform app.

Building Dynamic Forms in Flutter Like a Pro

Sumeet Sharma — Tue, 05 Aug 2025 11:44:39 +0000

Ever wondered how dynamic forms actually work? Turns out, you can build smart, dynamic forms with just about any tech stack—but today, I’ll walk you through a supercharged way to do this in Flutter. And trust me, once you try it, manual form coding will feel like chiseling on stone!

We’ll leverage the awesome flutter_form_builder package for our form wizardry.

Folder Structure: Laying the Foundation
Clean code = happy dev life! Here’s how I like to organize things, following a “feature-first” structure (which scales great for teams or solo hustle):

widgets/: All your input widgets go here—text fields, radios, dropdowns—you name it.
presentation/: The home for screens and UI logic.
model/: Data models. If it’s shaping your data, it lives here.

Check out a sample setup:

The Heartbeat: Config JSON
The real superpower behind dynamic forms? Your config JSON! Store it on your server, fetch it when needed, and voilà—instantly update your UI without touching the app.

Meet the ConfigJson Class
Our ConfigJson class defines every form field, what type it is, its options, and more:

name: Unique field key (for saving form data).
label: What the user actually sees.
type: Text? Radio? Checkbox? You decide.
required: Simple true/false for validations.
options: Use this for dropdowns, radios, checkboxes—wherever you need choices.

Here's the code for reference:

enum FieldType { text, radio, checkbox, dropdown }

class LabelValue {
  final String? label;
  final String? value;
}

class ConfigJson {
  final String name;
  final String? label;
  final FieldType type;
  final bool required;
  final List<LabelValue>? options;
}

Boom. Dynamic configs are now a snap! check the code on github.

UI: Making the Magic Happen
Now, let's render the form. In your forms.dart (inside presentation/), here’s a quick peek at our build method. It wraps the dynamic fields inside a stylish, modern Scaffold.

@override 
Widget build(BuildContext context) {
  return Scaffold(
    body: SafeArea(
      child: Column(
        children: [
          Expanded(
            child: FormBuilder(
              key: _formKey,
              child: FormFieldList(formConfig: formConfig),
            ),
          ),
        ],
      ),
    ),
  );
}

final _formKey = GlobalKey();
This gives us full power over form state for validation, submission, and introspection.

Rendering Each Field
Loop over the config using a FormFieldList, and hand each field off to a specialized widget that knows how to render it:

class FormFieldList extends StatelessWidget {
  final List<ConfigJson> formConfig;
  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      itemCount: formConfig.length,
      itemBuilder: (context, index) => Field(field: formConfig[index]),
    );
  }
}

Then, inside your Field widget, switch on field.type and build the correct widget (text, radio, checkbox, or dropdown).

Validations: Mix It (in)!
Nobody likes bad data. I’ve whipped up a FormFieldValidatorsMixin that latches onto each field and injects necessary validation. Required fields? Just mark required: true in your config, and the mixin handles the rest.

mixin FormFieldValidatorsMixin {
  List<FormFieldValidator> bindValidations(ConfigJson field) {
    List<FormFieldValidator> validations = [];
    if (field.required) {
      validations.add(FormBuilderValidators.required());
    }
    return validations;
  }
}

Custom validations? Add them to your JSON and extend the mixin as needed.

Wrapping Up
And there you have it! You're now equipped to build scalable, maintainable, and fully dynamic forms in Flutter like a true pro. Simply update your JSON on the server, and your app's forms will adapt on the fly—no rebuilds, no App Store reviews, no sweat.

Level up your form game and remember: a well-structured dynamic form is a thing of beauty!

For the complete source code and to see it all in action, check out the project on GitHub.

Building Dynamic Forms in Flutter Like a Pro

Sumeet Sharma — Thu, 31 Jul 2025 08:01:47 +0000

We’ll leverage the awesome flutter_form_builder package for our form wizardry.

widgets/: All your input widgets go here—text fields, radios, dropdowns—you name it.
presentation/: The home for screens and UI logic.
model/: Data models. If it’s shaping your data, it lives here.

Check out a sample setup:

Meet the ConfigJson Class
Our ConfigJson class defines every form field, what type it is, its options, and more:

name: Unique field key (for saving form data).
label: What the user actually sees.
type: Text? Radio? Checkbox? You decide.
required: Simple true/false for validations.
options: Use this for dropdowns, radios, checkboxes—wherever you need choices.

Here's the code for reference:

enum FieldType { text, radio, checkbox, dropdown }

class LabelValue {
  final String? label;
  final String? value;
}

class ConfigJson {
  final String name;
  final String? label;
  final FieldType type;
  final bool required;
  final List<LabelValue>? options;
}

Boom. Dynamic configs are now a snap! check the code on github.

@override 
Widget build(BuildContext context) {
  return Scaffold(
    body: SafeArea(
      child: Column(
        children: [
          Expanded(
            child: FormBuilder(
              key: _formKey,
              child: FormFieldList(formConfig: formConfig),
            ),
          ),
        ],
      ),
    ),
  );
}

final _formKey = GlobalKey();
This gives us full power over form state for validation, submission, and introspection.

Rendering Each Field
Loop over the config using a FormFieldList, and hand each field off to a specialized widget that knows how to render it:

class FormFieldList extends StatelessWidget {
  final List<ConfigJson> formConfig;
  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      itemCount: formConfig.length,
      itemBuilder: (context, index) => Field(field: formConfig[index]),
    );
  }
}

Then, inside your Field widget, switch on field.type and build the correct widget (text, radio, checkbox, or dropdown).

mixin FormFieldValidatorsMixin {
  List<FormFieldValidator> bindValidations(ConfigJson field) {
    List<FormFieldValidator> validations = [];
    if (field.required) {
      validations.add(FormBuilderValidators.required());
    }
    return validations;
  }
}

Custom validations? Add them to your JSON and extend the mixin as needed.

Level up your form game and remember: a well-structured dynamic form is a thing of beauty!

For the complete source code and to see it all in action, check out the project on GitHub.

Bring Python to Your Android App Using Chaquopy

Sumeet Sharma — Mon, 28 Jul 2025 09:35:42 +0000

Hi Devs,

I've written a Medium article about integrating a Python script natively into your Android app.
Read here.

DEV Community: Sumeet Sharma

[Boost]

Building Dynamic Forms in Flutter Like a Pro

Supercharge Your Flutter App with Native Python Execution

Bring Python to Your Android App Using Chaquopy | by Sumeet Sharma | Jul, 2025 | Medium

Sumeet Sharma ・ Jul 31, 2025 ・ Medium

Building Dynamic Forms in Flutter Like a Pro

Building Dynamic Forms in Flutter Like a Pro

Bring Python to Your Android App Using Chaquopy

Sumeet Sharma ・ Jul 31, 2025 ・
Medium