What does BuildContext do in Flutter?

What does `BuildContext` do, and what information do we get out of it?

[To see links please register here]

is just not clear.

[To see links please register here]

on the 9th instance of the term `BuildContext` there is an example, but it's not clear how it is being used. It's part of a much larger set of code that loses me, and so I am having a hard time understanding just what `BuildContext` is.

Can someone explain this in simple/very basic terms?

`BuildContext` is, like it's name is implying, the context in which a specific widget is built.

If you've ever done some React before, that context is kind of similar to React's context (but much smoother to use) ; with a few bonuses.


Generally speaking, there are 2 use cases for context :

- Interact with your parents (get/post data mostly)
- Once rendered on screen, get your screen size and position


The second point is kinda rare. On the other hand, the first point is used nearly everywhere.

For example, when you want to push a new route, you'll do `Navigator.of(context).pushNamed('myRoute')`.

Notice the context here. It'll be used to get the closest instance of `NavigatorState` widget above in the tree. Then call the method `pushNamed` on that instance.

___

_Cool, but when do **I** want to use it ?_


BuildContext is really useful when you want to pass data downward _without_ having to manually assign it to every widgets' configurations for example ; you'll want to access them everywhere. But you don't want to pass it on every single constructor.

You could potentially make a global or a singleton ; but then when confs change your widgets won't automatically rebuild.


In this case, you use `InheritedWidget`. With it you could potentially write the following :

class Configuration extends InheritedWidget {
final String myConf;

const Configuration({this.myConf, Widget child}): super(child: child);

@override
bool updateShouldNotify(Configuration oldWidget) {
return myConf != oldWidget.myConf;
}
}

And then, use it this way :

void main() {
runApp(
new Configuration(
myConf: "Hello world",
child: new MaterialApp(
// usual stuff here
),
),
);
}


Thanks to that, now **everywhere** inside your app, you can access these configs using the `BuildContext`. By doing

final configuration = context.inheritFromWidgetOfExactType(Configuration);


And even cooler is that _all_ widgets who call `inheritFromWidgetOfExactType(Configuration)` will automatically rebuild when the configurations change.

Awesome right ?

*what is the BuildContext object/context?*

Before we knowing about BuildCotext, We have to know about the Element object.

**What is Element object**

*(note: As a flutter developer we never worked with Element object, but we worked with an object(known as BuildContext object) that's similar to Element object)*

> The Element object is the **build location** of the current widget.

**What's really mean by "build location" ?**

>1. when the framework builds a widget object by calling its constructor will correspondingly need to create an element object for that widget object.

>2. And this element object represents the build location of that widget.

>3. This element object has many useful instance methods.


**Who uses the Element object and its methods ?**

> They are 02 parties that use the Element object and its methods.
> 1. Framework (To create RenderObject tree etc)
> 2. Developers (Like us)

**What is BuildContext object ?**
> BuildContext objects are actually Element objects. The BuildContext interface is used to discourage direct manipulation of Element objects.

So `BuildContext object = discouraged element object` (That contains less number of instance methods compared to the original Element object)

**Why framework discouraged the Element object and pass it to us ?**

> Because Element object has instance methods that must only be needed by the framework itself.
> but what happens when we access these methods by us, It's something that should not be done.
> So that the reason why framework discouraged the Element object and pass it to us
----------------------------------------------------
----------------------------------------------------
***Ok Now let's talk about the topic***

**What does BuildContext object do in Flutter ?**
> BuildContext object has several useful methods to easily perform certain tasks that need to be done in the widget tree.

1. findAncestorWidgetOfExactType<T>().
> Returns the nearest ancestor widget of the given type T.
2. findAncestorStateOfType<T>().
> Returns the State object of the nearest ancestor StatefulWidget.
3. dependOnInheritedWidgetOfExactType<T>().
> Obtains the nearest widget of the given type T, which must be the type of a concrete InheritedWidget subclass, and registers this build context with that widget such that when that widget changes.
[Used by Provider package]

The above methods are mostly used instance methods of BuildContext object if you want to see all the methods of that BuildContext object visit this [LINK][1] + see @remi Rousselot's answer.


[1]:

[To see links please register here]