DEV Community: Kouki Badr

Optimizing Performance in Android Apps with Kotlin

Kouki Badr — Thu, 12 Feb 2026 10:08:43 +0000

Optimizing the performance of your Android applications is crucial for providing a smooth and responsive user experience. Kotlin, with its concise syntax and powerful features, offers several ways to enhance the performance of your apps. In this article, we'll explore various techniques and best practices to help you get the most out of your Android applications.

Profiling Your App

Before you can optimize your app, you need to understand where the performance bottlenecks are. Android Studio provides powerful profiling tools that can help you identify issues related to CPU usage, memory allocation, and network activity.

CPU Profiling: Use the CPU profiler to identify methods that are consuming the most CPU resources. Look for methods that are called frequently or take a long time to execute.
Memory Profiling: The memory profiler can help you track memory allocations and identify memory leaks. Pay attention to objects that are being created frequently or not being released properly.
Network Profiling: Use the network profiler to monitor network requests and identify any delays or inefficiencies.

Memory Management

Efficient memory management is essential for preventing memory leaks and reducing the risk of your app being killed by the system due to high memory usage.

Use ViewHolder Pattern: When working with RecyclerView, use the ViewHolder pattern to recycle views and reduce the overhead of view inflation.
Avoid Memory Leaks: Be cautious with anonymous inner classes and non-static inner classes, as they can hold references to their outer class instances, leading to memory leaks.
Use Kotlin's Null Safety: Kotlin's null safety features can help you avoid null pointer exceptions and manage memory more efficiently.

Efficient Coding Practices

Writing efficient code is key to optimizing the performance of your Android apps.

Use Kotlin Coroutines: Coroutines allow you to write asynchronous code in a sequential manner, making it easier to manage and optimize.
Leverage Inline Functions: Inline functions can reduce the overhead of function calls, improving performance in hot code paths.
Optimize Loops: Avoid performing expensive operations inside loops. Instead, precompute values and reuse them when possible.
Use Efficient Data Structures: Choose the right data structures for your use case. For example, use Set for fast lookups and Map for key-value pairs.

Conclusion

By following these techniques and best practices, you can significantly improve the performance of your Android applications. Remember that performance optimization is an ongoing process, and it's important to continuously profile and optimize your app as it evolves.

Happy coding!

Bottom_Picker new Major version

Kouki Badr — Sat, 26 Jul 2025 10:50:26 +0000

🎉 Exciting News for Flutter Devs! 🎉

We're thrilled to announce a major update to our beloved bottom_picker package! We've bumped the version all the way to 4.0.0! 🚀

This release is packed with awesome new features and improvements for your Flutter applications, including:

✨ Filter Options:
Now you can easily add filters to unpickable or blocked days in your date pickers! Say goodbye to those unwanted dates. 🗓️

➕ Year Picker: Selecting a year just got a whole lot easier with the new dedicated year picker. ⚙️

🛠️ Enhanced Title Flexibility: We've transformed the pickerTitle into an optional header builder callback, giving you full control over the picker's header!

But wait, there's more! We've also squashed a pesky bug where selectedItemIndex parameters weren't working correctly for simple pickers. 🐛

⚠️ Breaking Changes Alert! ⚠️

Due to the significant enhancements, especially the title customization via the new callback, this release includes potential breaking changes.
All attributes that are related to the old title, description and closing widget are now deprecated if you're planning to upgrade to 4.0.0 version.

We believe these changes will greatly improve the flexibility and usability of bottom_picker in your Flutter projects.

Check out the full release notes and upgrade guide here: Bottom_Picker

#flutter #dart #bottompicker #mobiledev #opensource

Say "Oui" to Global Users: Localize Your Flutter App with Gemini

Kouki Badr — Sun, 09 Jun 2024 15:09:41 +0000

Why localize your app? Think about it, ignoring international users is like making a fire meme and forgetting to post it online - what's the point? But don't worry, we hear you screaming Fear not, for Gemini is here to be your Yoda in the localization swamp. We'll tackle all your app translation woes, so buckle up and get ready for a smooth ride and dive deep with us in this post!

What is localization and How it's done?
To conquer the globe, you need some serious localization skills.

Think of locales as your app's Rosetta Stone – they unlock the ability to understand different languages, date formats (no more confusing July 4th with 4th of July!), currencies, and all those cultural nuances. So, French users see euros and "dd/mm/yyyy," while Spanish speakers get their pesos and the familiar "dd/mm/aaaa."

Now, managing these locales can feel like herding cats. But fear not, there's a better way than wrestling with JSON files (because, let's be honest, that's a recipe for disaster).
Enter the dynamic duo of flutter_localizations and intl – these packages are your knight in shining armor, recommended by the official Flutter people themselves.

Here's the battle plan:

Recruit your allies: Integrate flutter_localizations and intl into your app.
Set up your command center: Create a l10n.yaml config file.

arb-dir: lib/l10n
template-arb-file: app_en.arb
output-localization-file: app_localizations.dart

Deploy your troops: Create .arb files under the lib/l10n folder (or a location of your choosing, just update the config file accordingly). These .arb files will house all your app's localized strings.

With this battle plan in place, you'll be a localization champion in no time, ready to take your app to a global phenomenon!

With Gemini
Feeling overwhelmed by app localization? Manually translating endless lines for every language can be a daunting task. But fear not, developer! Google Gemini has your back with the arb_translate package.

Think of arb_translate as your personal localization assistant. You simply write the default translations, and then unleash the power of Gemini! With a single arb_translate command, Gemini translates all the other languages you need, taking context (e-commerce, cars, coding?) into account for natural-sounding translations.

Ditch the manual translation grind and let Gemini be your localization hero. It's a much more efficient way to conquer the world with your app! Now that you've got a taste of Gemini's localization magic.

why not jump in and try it for yourself you can finally overcome the language barrier and reach new heights, just like Lara Croft raiding tombs and uncovering hidden treasures across the globe!

EasyDeps : brick-ception

Kouki Badr — Sun, 12 May 2024 16:34:56 +0000

The Flutter ecosystem is abuzz with a new framework – Mason. Boasting over 300 bricks and counting, it's a construction zone of awesome functionality. But what if we could take things a step further? Enter the meta-brick, a brick built specifically for other brick developers.

This isn't your average UI brick. It's about streamlining the workflow for fellow brick builders. Imagine a world without manually managing dependencies in each brick. This innovation offers centralized dependency management through a dedicated package.json file, keeping your code clean and organized.

Picture this: You integrate your brick into a Flutter project, and poof! All necessary dependencies are installed automatically. That's the magic of this brick.
Additionally, it champions project structure, residing within a dedicated hooks directory for a minimalist's dream layout.

Ready to unlock this developer superpower? Buckle up – we'll be diving into EasyDeps, with clear instructions that demystify the process. It's recursion made simple, without the headache of explaining Inception.

How this project work?

Installation:

Get your brick on board with mason add easy_deps (or go global with mason add -g easy_deps).

Generation:

Unleash the magic with mason make easy_deps. This brick is low-maintenance – no pesky questions to slow you down.

Dependency Nirvana:

Boom! You've got yourself a packages.json file nestled within your brick's folder.

But Wait, There's More!

easy_deps doesn't stop at a fancy package.json. It also introduces some undercover heroes:

package_installation_handler: This bad boy parses your package.json, ensuring all the dependencies are listed and ready for action.

post_gen.dart: In the early days, easy_deps might be a little overzealous, replacing your existing post_gen.dart It simply includes the call to the package_installation_handler code, ensuring your dependencies are installed smoothly.

Don't worry the package.json will be deleted once your brick is integrated into the app project, It's all temporary.

Here's the good stuff:

Manual configuration?

More like "manual vacation!" This bad boy handles it all, so you can spend your time on more important things.

Cleanliness

The dependency handler chills in the hooks directory, keeping your project looking like a masterpiece.

Dedicated package.json for dependencies?

Think of it as your own personal spice rack – everything neatly organized and ready to flavor your app just right. No more hunting for that elusive sprinkle of unicorn dust dependency.

Well, that's just next-level meta, who are we to judge brick-ception dreams?

Feel like to contribute to this project? head to github and send me your PRs and Issues https://github.com/koukibadr/B-Bricks.

Also head to brickhub page to learn more about easy_deps
https://brickhub.dev/bricks/easy_deps/0.1.0+1

Internationalization? More Like International-WIN-ization with Flutter Mason! (Effortless Internationalization)

Kouki Badr — Sun, 05 May 2024 10:42:47 +0000

Flutter devs, ever feel like you're stuck in a loop localization drudgery?

Fear not, weary coder! Even if you're not a Flutter master (yet!), this article will have you saying "I'm beginning to see the pattern...".

We all know Flutter is fast compared to native development (looking at you, Android Studio!), but buckle up because Flutter Mason is about to blow your development speed right out of the water. ️ This article will be your guide to the specific Flutter Mason trick that'll make ARB localization a breeze.

Localiz

As it's description mentioned "Ease and Speed up Internationalizing Flutter Apps" this brick integrate all the arb dependencies, configuration and arb files for you.

How ? 🤔

Alright, installation time! But before we dive in, here's a friendly reminder:

We've got two options for getting Mason and mason_cli on your machine. For the command-line cowboys,there's the classic
dart pub global activate mason_cli.
But if you're a true programmer of culture (and a Homebrew user), you can unleash the power of
brew tap felangel/mason; brew install mason.

Finally, the moment we've all been waiting for: installing the localiz brick.
You can do this locally with mason add localiz or go full global dominance with mason add -g localiz. The choice is yours, but choose wisely!

Use it

All you need to do now it to use it on your project
mason make localiz
this will trigger the brick, and it will ask you:

Choose language to include in your app?
  ◯  English (en)
  ◯  Arabic (ar)
  ◯  Chinese (zh-CN)
  ◯  Spanish (es)
  ◯  French (fr-FR)

it's a multiple selection so use the spacebar to select the languages you want to include when localizing your app

after this the brick will ask you which language of those you select it's the default and will act like the arb template reference.

That's it! Now you can high-five yourself, commit your changes, push it to the repo, mark your Jira ticket as "DONE" with the smug satisfaction of a champion.

The localiz brick takes care of everything: installing those pesky packages (intl, flutter_localizations), generating the l10n.yaml config file with your default language, and even creates the l10n folder within your lib directory pre-populated with all the languages you selected.

Basically, it saves you a ton of time on tedious setup, freeing you up to focus on the real coding magic. Because, let's be honest, life is way too short to be wrangling ARB files manually.

Searchable Listview

Kouki Badr — Wed, 24 Apr 2024 21:53:08 +0000

In Flutter app development, creating a seamless search experience within list views is crucial for enhancing user navigation and data exploration. The searchable_listview package emerges as a robust and customizable solution, empowering you to implement search functionality effortlessly.

Key Features and Advantages:

Effortless Filtering: Filter your list view based on user input, providing real-time search results that dynamically adjust as the user types.
Asynchronous Support: Load data asynchronously, making your list view suitable for handling large datasets or data fetched from remote sources.
Expansion List Integration: Seamlessly incorporate search functionality within expansion lists, catering to scenarios where your list items contain hierarchical data.
Sorting Capabilities: Allow users to sort their search results, offering them additional control over how they view and interact with the list.
Pagination Management: Implement pagination for extensive lists, ensuring smooth scrolling and data loading as users navigate through numerous items.
Pull-to-Refresh: Integrate pull-to-refresh functionality, enabling users to easily refresh the list view and retrieve the latest data.
Sliver Scroll Effects: Leverage various sliver scroll animation effects to beautify your list view and enhance the user experience.
Customizable Search Field: Tailor the search text field to your app's design aesthetics by adjusting its styling, keyboard input type, and behavior.
Empty List Handling: Display a custom widget when the search yields no results, providing informative feedback to users.
Error Handling: Craft an appropriate error widget to gracefully handle situations where loading or processing data encounters issues.

For more intricate search requirements, searchable_listview offers further customization options:

Custom Search Logic: Implement custom search logic to filter items based on specific criteria beyond simple text matching.
Separator Builder: Designate a custom widget to be built between list items, offering visual separation and potentially additional information.
Search Text Field Placement: Position the search text field strategically within your layout, aligning it with your app's overall design flow.
Scrollable Direction Control: Decide on the scrolling direction (vertical or horizontal) depending on your list view's content and user interaction preferences.

Getting Started and Beyond

To leverage the searchable_listview package in your Flutter project, follow these steps:

Installation: Add the package to your pubspec.yaml file and run flutter pub get to install it.

Import the searchable_listview package in your Dart code and utilize its widgets within your list view implementation.

Refer to the package's documentation on Pub.dev: https://pub.dev/packages/searchable_listview for in-depth guidance, examples, and advanced customization options, explore the provided examples to get a head start on implementing search functionality in your Flutter app.

In Conclusion
The searchable_listview package empowers you to create robust and user-friendly search experiences for your Flutter applications. With its rich feature set and extensive customization capabilities, it streamlines the process of adding search functionality to your list views, saving you development time and effort. By effectively integrating this package, you can significantly enhance the navigability and discoverability of data within your apps.

Flutter Elegant Notification

Kouki Badr — Sun, 14 Apr 2024 11:09:32 +0000

Level Up Your App's Notifications:
A Guide (from the owner himself 🤯) to elegant_notification

In today's competitive mobile landscape, every detail matters, and that includes how you communicate with your users. Enter elegant_notification, a powerful Flutter package that injects a touch of class into your app's notification system.

This article dives deep into elegant_notification, exploring its core features, exciting new additions, and how to seamlessly integrate it into your Flutter project.

Core Features that Make Your Notifications Shine

Built-in Themes: Out of the box, elegant_notification provides pre-designed themes for success, error, and info messages.
Customization: Don't like the pre-built themes? elegant_notification empowers you to fully customize the look and feel of your notifications. From background colors and animation styles to notification position and even adding a progress bar, the possibilities are endless.
Animations: Make your notifications stand out with a variety of animation options.
Action Stations! Engage your users by adding clickable buttons or widgets to your notifications.
Stacked notifications The package offer the possiblity to display notifications in stacked way.

Latest version updates

What elegant notification brings to you with the latest 2.1.1 version:

Customizable borders style (color, radius, stroke...)
Customizable notification shadow

Step-by-Step Guide

Here's a quick guide to get you started:

Add the package to your pubspec.yaml:

dependencies:
  elegant_notification: ^latest_version  # Replace with the latest version number

Import the package in your Dart file:

import 'package:elegant_notification/elegant_notification.dart';

Display a notification with ease:

ElegantNotification.success(
  title: Text('Success!'),
  description: Text('Your data has been updated'),
  animation: AnimationType.fromTop,
)
.show(context);

Custom notification with stacked options:

ElegantNotification(
  title: Text('Success!'),
  description: Text('Your data has been updated'),
  animation: AnimationType.fromTop,
  stackedOptions: StackedOptions(
    key: 'top',
    type: StackedType.same,
    itemOffset: Offset(-5, -5),
  ),
  border: Border(
    bottom: BorderSide(
    color: Colors.green,
    width: 2,
  ),
 ),
 icon: Icon(
   Icons.access_alarm,
   color: Colors.orange,
 ),
 progressIndicatorColor: Colors.orange,
 background: Colors.white,
)
.show(context);

You can imagine what you can do with all this customizations and other attributes (I'll let you unleash your creativity with it)

Head to https://pub.dev/packages/elegant_notification for more in-depth documentation about this package and let me know if you have any questions, issues or suggestions