DEV Community: Idris Idris

[Boost]

Idris Idris — Wed, 14 May 2025 22:23:19 +0000

Destiny Ed

May 14 '25

DocTextExtractor: A Flutter Package to Extract Text from Word, PDF, Google Docs, and Markdown

#programming #flutter #dart #google

Comments 6

4 min read

Step-by-Step Guide to Fixing NDK source.properties File Missing Error in Flutter

Idris Idris — Thu, 03 Apr 2025 12:26:40 +0000

Imagine you’re working on an exciting project, and everything seems to work fine. Then you had a reason to update your Flutter environment and then you hit this annoying build error. You check your console or terminal and see something like this:

Frustrating, right? Don’t worry. In this article, I’ll explain the main reason this happens and walk you through, step-by-step, ways to fix it. By the end, you’ll have your Flutter project running smoothly like nothing happened.

Now that you know why we’re here, let us begin:

What could have caused this issue?

This issue might not have been apparent in Flutter versions below 3.29.0 but, it is more revealed from 3.29.0. I had the same issue when I updated Flutter to 3.29. Initially, I was convinced it was an issue from the Flutter team due to the change made from .gradle to .gradle.kts. I thought a new update would be made to resolve the issue, but, I was mistaken.

This error occurs because the Android NDK (Native Development Kit) installation is either incomplete, corrupted, or missing an essential file like source.properties. This can happen when:

there is an interrupted or failed NDK installation
you manually deleted or modified the NDK directory by mistake
you use an incompatible or unsupported DK version with your project.

To confirm, go into the ndk directory as shown in the error. When you open the ndk version folder, e.g the 26.3.11579264 folder, you’ll see that there’s no source.properties file.

Now, how would you resolve this?

1.⁠ ⁠Delete that folder (i.e. 26.3.xyz)

2.⁠ ⁠⁠Open the project on Android Studio

3.⁠ ⁠⁠In Android Studio, open the Settings from the top left corner

4.⁠ ⁠⁠Search for “sdk” in the search box and click on Android SDK (under Languages & Frameworks)

5.⁠ ⁠⁠Now, under SDK Tools, you’ll see NDK - or NDK (Side by side) - with a list of available NDKs, search for the NDK causing issues, if it’s valid and it’s there, select the checkbox, and click on the download icon. Leave the rest for Android Studio to complete for you. When this is all complete, click on “OK” and “Apply” to complete the configuration process.

6.⁠ ⁠⁠If the NDK is not available, download anyone close or just download the latest. (NB: You can download more than one)

7.⁠ ⁠⁠If the case was 6. above, then you have to go into your project’s android/app/build.gradle.kts and in the android section, add something like - ⁠ ndkVersion = "26.x.yz” ⁠ where 26.x.yz is the version that you were able to download in Android studio.

Finishing Steps

For the final step, you just have to clean and rebuild your project and voila! your project should be up and running again. You can run this in your project’s terminal or just simply click on the play in to debug from console.

flutter clean
flutter pub get 
cd android && ./gradlew clean && cd .. 
flutter run

And that’s all.

Conclusion

In this article, you have learnt, in a step-by-step format, how to easily resolve the common ndk source.properties file missing error. I hope you found this helpful.

See you in my next blog post. 👋

You can connect with me on Twitter and LinkedIn.

Deep Dive Into Null and Null Safety in Dart

Idris Idris — Thu, 25 Aug 2022 10:11:00 +0000

Introduction

You are in a class and a teacher walks in, asks for a student to assign a task but the student is absent. The teacher can either call another student for the task or ask someone to relay the task's message to the student whenever he/she gets back. This is a model for handling a request with absent recipient.

This analogy can also be modelled in our codes where a variable could either be absent at a point of call or assigned to a value at that point. The ability to handle such case effectively is paramount for every developer.

In this article, we'll be looking at Null and Null safety in Dart.

We will specifically cover the following:

Introduction to Null and Null safety in Dart
Nullable and Non-nullable Dart datatypes
Null-aware operators
The late keyword

Having mentioned that, let's start:

Null and Null safety in Dart

Null, as a programming concept, simply mean “absence of value”. Having a data type to denote this absence is useful. Let's take a scenario where people are asked to fill their full names in a form. It is possible for some of these people not to have middle names. In a case like this, we want to make an expression that this field could contain a value of String, or it may have no data at all.

The Null class in Dart provides this null value. Imagine there’s no option for null values, we could simply assign an empty string ( “” ) to represent the absence of a middle name. But then, we would need to specify this with a comment for our colleagues to understand.

String middleName = “”;

Using an empty String such as this works but we would have to tell other colleagues about it. What if we can actually set middleName to the null that it is?

String middleName = null;

This is very clear to everyone that there is no value for middleName, and based on this, we can easily decide what should happen when the value of the middleName is null.

The code above will work just fine in versions of Dart prior to 2.12. However for versions above this, an error will be thrown (at compile time).

A value of type ‘Null’ can’t be assigned to a variable of type ‘String’

Before the introduction of Null safety, Dart allows us to pass in values that could be null, calling a method on it on compile time (i.e while typing the code) without throwing an error. This could be dangerous at some point because if that value is eventually null, then our code breaks at runtime. We don’t want our users to see our flaws, right?

Let’s take an example:

Assuming we wish to check the length of our middleName variable, we can define a function:

int capitalize(String middleName){
  return middleName.toUpperCase();
}

Let’s try this code in our main.dart file, in the main function.

void main(){
    print (capitalize(‘Adeyemi’)); // ‘ADEYEMI’
    print(capitalize(‘learning flutter’)); // 'LEARNING FLUTTER’
        }

This works just fine as long as we do not pass null as a value in the capitalize function. Once we pass null as a parameter to capitalize, in Dart <2.12 (before null safety), the code doesn’t throw an error on compile time but if we run it, the code breaks with an error.

NoSuchMethodError: The getter ‘length’ was called on null.

As much as possible we do not want our users to see this, and we might not be able to catch it since it doesn’t appear before running the code. This is why we need null safety. If the same code as above is written in Dart version >2.12 (i.e null safe version), an error is thrown instantly when null is passed as an argument to capitalize.

print(capitalize(null));
Error shown:

The argument type ‘Null’ can’t be assigned to the parameter type ‘String’

This change eliminates the possibility of being surprised by null, hence prevents a number of errors. In short, Null safety help keep us safe from the problems of forgotten null occurrence.

Nullable and Non-nullable Data Types

With the advent of Dart null safety, Dart guarantees us that all its data types are non-null by default. This means that all the data types must have a value, unless we want it to be otherwise (i.e we want it to be null).

Non-nullable types are the common easy-to-understand types that we know, they are declared without using the ? (question mark) at the end.

Examples of non-nullable types:

String: “Flutter”, “Dart”, ‘Google’
int: 2, 35, 7, 22, 100
double: 0.003, 22.7, 3.142
bool: true, false
Sport: basketball, football

This means that all these values are acceptable. For example, we can write in our editor.

int myAge = 20;
bool userRegistered = true;
String myWord = “I love Flutter”;
Sport football = Sport(name: “Football”, players: 11);

All these would work fine as they are not null. But when we try:

String myName = null; //A red underline shows on compile time

A compile-time error is shown immediately.

A value of type 'Null' can’t be assigned to a variable of type ‘String’.
But how then do we assign null to a variable?

Picture Reference: express.co.uk

This is where Dart nullable types comes in.

To make a type nullable, all we have to do is to add a ‘?’ in front of the type.

int? myAge = null; //This works

A nullable type allows null value in addition to its original type. This means that the type ‘double?’ can take values such as 1.42, 23.5, null, 0.005 amongst others.

The question mark (?) in front of the type is not an operation on the data type, rather it indicates a whole new datatype.

String? is a whole different datatype from String.

Reference: Dart doc

Every non-nullable Dart type has its corresponding nullable type

Also, we can say the non-nullable type is a subtype of its corresponding nullable type. That is, int is a subtype of int? since int? can take a value of int.

Finally, if a nullable variable is not assigned initially, it is given a type of Null.

int? year;
String? middleName;

If this is printed on console:

print(‘Year is $year’);
print(‘Middle name is $middleName’);

We have:

Year is null
Middle name is null

Null Aware Operators

One of the major issues before the introduction of null safety is how easy it is for developers to forget to handle values that might turnout to be null. With null safety now, Dart ensures that developers cannot perform specific operations on nullable values unless they’ve handled the possibility of null.
For example:

int? age;
print(age.isEven);

Instantly, on compile-time, Dart throws an unchecked_use_of_nullable_value error stating:

The property ‘isEven’ can’t be unconditionally accessed because the receiver can be ‘null’
Then it goes ahead to suggest:
Try making the access conditional (using ‘?.’) or adding a null check to the target (‘!’).
We can, with this improvement, easily handle the compile-time error instead of waiting until this crashes our app.

Dart provides a set of operators to help handle the possibility of null values, these are known as the null-aware operators.

The null-aware operators are as follows:

If-null operator (??)
Null-aware access operator (?.)
Null assertion operator(!)
Null-aware assignment operator (??=)
Null-aware cascade operator(?..)
Null-aware index operator (?[ ])

Now let’s see how these operators work

If-null operator (??)

If we have:

int? numberOfYears;
final age = numberOfYears ?? 0;

This is simply read as “If numberOfYears is not null, then set age equals numberOfYears, if it is null, set age equals 0”

It should be noted that using that using ?? ensures that the value of age can never be null. Hence, Dart infers the variable as int, not int?
From above, using the ?? operator is same as writing:

  int? numberOfYears;
  int? age;
  if(numberOfYears != null){
    age = numberOfYears;
  }else{
    age = 0;
  }

That is about 6 additional lines of code instead of the one-liner using the ?? operator.

Null-aware access operator (?.)

Earlier, we tried age.isEven, and we saw that Dart give us an error at compile-time. To by-pass this, one of the suggested way is to use the ?. operator on age. That is, age?.isEven.

This can be explained simply as “If age is null, return null, otherwise if age has a value, return true/false if it’s even or not”.

The operator ?. should be used when we’re not totally sure if the variable will be null or not. Hence, if it turns out to be null, we can easily handle it, if it isn’t null too, we handle it accordingly.

Null assertion operator (!)

Unlike the Null aware access operator (?.), whenever we’re so sure that the variable we’re handling is definitely not null, we could use the ! operator (bang operator).

age!.isEven

In this case, we’re saying that “ Yes, I am sure age is not going to be null, so just check if it’s even”. This comes at a cost though, because if age eventually turns out to be null, our app will crash at runtime.

The ! operator should be treated as a dangerous operator and only used when we’re very sure our variable will not be null. By using this operator, we simply tell Dart that “look, I am going out of null safety on this variable because I’m sure it’s null, so let me handle it myself”.

Null- aware assignment operator (??=)

This works like the if-null operator (??), but we use the ??= when updating the same value.
For example:
String? country;

When it’s time to use the address variable, it will be wise to check if an address has been assigned earlier. This can be done using the ?? operator as:

country = country ?? “Nigeria”;

But since it’s the same variable we want to update, we can simply write:

country ??= “Nigeria”;

In simple terms, the ??= operator simply says “If country is null, set country to “Nigeria”, otherwise, retain the current value of country”.

Null-aware cascade operator (?..)

In Dart, the cascade operator (..) allows us to call multiple method on the same object at a go OR help set multiple properties on the same object.

For example, given a class Sport like this:

class Sport{
  String? name;
  int? players;
}

If Sport class isn’t nullable, we can us the cascade operator like this:

    Sport sport = Sport()
        ..name = "Football"
        ..players = 11;

A common use case of the null-aware cascade operator is on the Path object, during painting in Flutter.

Path? path;
Path
   ?..moveTo(0, 0)
    ..lineTo(0, 4)
    ..lineTo(4, 4)
    ..lineTo(4, 0)
    ..lineTo(0,0);

The null-aware cascade operator can be short-circuited, you only need to use it for the first time in the chain and if the variable (path) is null, all operations in the chain do not get called.

Null-aware Index Operator (?[])

In Dart, indexing is used to access an element of a List

List<String> myColors = [“Blue”, “Green”, “Red”];

The indexes begin at 0, hence to call out “Green”, we do this:

var green = myColors[1];

Now with null-safety, we know that a List might be null, hence, to index an item of that List we have our helper ?[] operator.

Let’s see an example:
List<String>? myColors = [“Blue”, “Green”, “Red”];

Even though, the List is nullable but since we’ve assigned a value to it, it has been promoted.

Setting myColors to null.

myColors = null;

Now, when we try to get the “Green” value again, we use the null-aware index operator as thus:

String? green = myColors?[1];

This, in literal term means “if myColors is null, assign null value to green. If otherwise, assign the 1th index of myColors to green”.
If we try to access a value from a null list before null-safety, it would have resulted in our app crashing. But again, thanks to null-safety.

The `late` keyword

Sometimes, we want to make our variable non-nullable but we do not have the value to initialize it. The late keyword helps us to promise Dart that a value will be green to the variable before its usage, but that will be later. Using the late keyword means that the variable’s value won’t be calculated until we access the variable for the first time. This is called lazy initialization. There are different ways by which we could later assign a value to that variable before using it like using the initState (for a StatefulWidget) or calling a function that returns that value.

Whenever we try to access a variable that we specific with the late keyword without later assigning a value to it, we broke our promise, hence we get a LateInitializationError
Example:

class Sport{
  late String name;
}

And then we have something like this somewhere else.

Sport sport = Sport();
print(sport.name) //an error would be thrown since we have not initialized name.

LateInitializationError: Field ‘name’ has not been initialized

Conclusion

In this article, we have looked at the concept of Null and the beauty of Null safety. If used appropriately, Null safety can help you in writing better and less error-prone codes.

Additional Resources

BEGINNERS' GUIDE TO FLUTTER

Idris Idris — Wed, 30 Dec 2020 08:49:29 +0000

Have you heard Flutter and have no clue what it does? Have you ever wondered what the hype that surrounds Flutter is about? Or perhaps, you have just picked up Flutter and needed a guide on becoming a Pro at Flutter.

This article is a simple introduction to Flutter. It breaks down the various features of Flutter and explains how to get started with it.

Basic Introduction to Flutter and Dart

According to the official Flutter documentation, Flutter SDK is Google's UI toolkit for crafting beautiful, natively compiled applications for mobile, web, and desktop from a single codebase.

In simple terms, this means that you can easily build apps that run on both Android and iOS operating systems with just one codebase. Usually, the normal practice is to write two different codebases for Android and iOS operating systems. However, using a framework like Flutter, you can create cross-platform apps with a single codebase.

Flutter was created by Google and was released officially in May 2017. Flutter uses a programming language called Dart for its development.

Dart is simply a typed object programming language. Google created Dart back in 2011. The later version was released in November 2013. Its syntax is similar to JavaScript’s and it is quite easy to learn.

Asides from Flutter, there are other frameworks for building cross-platform apps, (i.e apps that run across multiple operating systems) such as React Native, Xamarin, Phonegap, Ionic, etc.

Why you should Pick Flutter as your main Mobile Development Framework

Several people have different opinions on how ‘efficient’ Flutter is. There are contrasting opinions on whether or not Flutter is the best framework for mobile development.

While I do not necessarily argue that Flutter is the ‘it’ framework, here are the top reasons why Flutter is my go-to framework and why I feel you should learn Flutter.

1. Ability to See Realtime Activities

You can easily check real-time activities on your app(s) with Flutter due to its Hot Reload feature. React Native has this ability as well, but what Flutter provides is arguably better and more consistent.

2. Easy to Learn And Use

If you have built apps using languages such as Java, React Native, C#, Swift, etc, you would notice how relatively easier building with Flutter is. Without much hassle, while using the inbuilt Flutter widgets, you can easily create your mobile apps.

3. Good and Easy-to-understand Documentation

Flutter has one of the best documentations when compared to other frameworks. It also has a step-by-step guide to using the widgets and creating your first app with Flutter.

Other reasons why you should choose Flutter as your main app development framework are:

Rapidly growing community.
Ideal for start-ups to create their MVPs etc.

GETTING STARTED WITH FLUTTER

At this juncture, I believe you have been convinced to learn and start building with Flutter. So, how do you get started?
There are several ways to learn a new concept. I have highlighted three common ways I have seen people get started with a new programming language or framework.
NB: The pathways highlighted were influenced by personal preferences and experiences.

A. Use of Documentation:
Flutter’s documentation is one of the easiest to understand and work with. To get started, go to the flutter official site and visit the getting started page to begin your journey.

B. E-books:
There are numerous published beginner-friendly books to help you get started with developing apps with Flutter and Dart. Some recommendations are:

Practical Flutter_ Improve your Mobile Development with Google’s Latest Open-Source SDK by Frank Zametti
Flutter Projects by Simone Alessandria
Flutter Libraries We Love by CodeMagic
Flutter in Action by Eric Windmill

C. Tutorial Videos:
There are quite a lot of cool, easy-to-follow-and-understand Flutter and Dart tutorial video courses on Udemy, Udacity, Coursera and others. I personally recommend the Complete 2020 Flutter Development Bootcamp with Dart by Dr. Angela Yu, which is available on Udemy.
There are also tons of YouTube Channels that teach building apps with Flutter. Some recommendations are:

The Net Ninja
MTECHVIRAL
Reso Coder
Easy Approach
Marcus Ng
The Flutter Way
FilledStacks

Bonus: There are few subjective roadmaps on Github that people have curated to help beginners in their journey through Flutter. Here are some of them:

Tarikul711 / flutter-development-roadmap

Flutter App Developer Roadmap - A complete roadmap to learn Flutter App Development. I tried to learn flutter using this roadmap. If you want to add something please contribute to the project. Happy Learning

olexale / flutter_roadmap

Highly Subjective Roadmap to Flutter Development

DroidsOnRoids / flutter-roadmap

Roadmap for Flutter developers in 2020

What Next After Learning The Basics?

Build Projects

Learning gives you the knowledge, but practice gives you confidence. Practice what you have learned.
Building projects after learning new concepts is very necessary. Its importance can never be overemphasized.
Project ideas can come from different places - the environment, existing products, personal interests, etc.
Here are some major sources you can get project ideas from:

A github repository for 80+ app ideas by Florin Pop - This repo is excellent for getting project ideas as it classifies the projects based on level.
Design platforms and communities such as Dribbble, Uplabs - These websites house openly-available designs from designers around the world. You can choose to recreate these designs for personal improvements.
Contribute to open source projects.

Show your works

Let people that you do what you do. Make use of the various social media platforms to showcase how amazing you are at what you do. Share projects you have worked on.

Be your own hypeman - GeekTutor

Conclusion

In this article, we have explained what Flutter and Dart are, why you should learn and use Flutter, how to get started, and also the importance of building projects.
If this helped in one way or the other, kindly like and share.

Happy Fluttering.