Datasets:
Ekhlass
/
flutter_docs

Dataset card Data Studio Files
xet
 Community
1
text
stringlengths
1
372
<topic_start>
more information
you can learn more at the following link:
<topic_end>
<topic_start>
details tree
select the widget details tree tab to display the details tree for the
selected widget. from here, you can gather useful information about a
widget’s properties, render object, and children.
<topic_end>
<topic_start>
track widget creation
part of the functionality of the flutter inspector is based on
instrumenting the application code in order to better understand
the source locations where widgets are created. the source
instrumentation allows the flutter inspector to present the
widget tree in a manner similar to how the UI was defined
in your source code. without it, the tree of nodes in the
widget tree are much deeper, and it can be more difficult to
understand how the runtime widget hierarchy corresponds to
your application’s UI.
you can disable this feature by passing --no-track-widget-creation to
the flutter run command.
here are examples of what your widget tree might look like
with and without track widget creation enabled.
track widget creation enabled (default):
track widget creation disabled (not recommended):
this feature prevents otherwise-identical const widgets from
being considered equal in debug builds. for more details, see
the discussion on common problems when debugging.
<topic_end>
<topic_start>
inspector settings
<topic_end>
<topic_start>
enable hover inspection
hovering over any widget displays its properties and values.
toggling this value enables or disables the hover inspection functionality.
<topic_end>
<topic_start>
package directories
by default, DevTools limits the widgets displayed in the widget tree
to those from the project’s root directory, and those from flutter. this
filtering only applies to the widgets in the inspector widget tree (left side
of the inspector) – not the widget details tree (right side of the inspector
in the same tab view as the layout explorer). in the widget details tree, you
will be able to see all widgets in the tree from all packages.
in order to show other widgets, a parent directory of theirs must be added to the package directories.
for example, consider the following directory structure:
running your app from project_foo_app displays only widgets from
project_foo/pkgs/project_foo_app in the widget inspector tree.
to show widgets from widgets_A in the widget tree,
add project_foo/pkgs/widgets_A to the package directories.
to display all widgets from your project root in the widget tree,
add project_foo to the package directories.
changes to your package directories persist the next time the
widget inspector is opened for the app.
<topic_end>
<topic_start>
other resources
for a demonstration of what’s generally possible with the inspector,
see the DartConf 2018 talk demonstrating the IntelliJ version
of the flutter inspector.
to learn how to visually debug layout issues
using DevTools, check out a guided
flutter inspector tutorial.
<topic_end>
<topic_start>
using the performance view
info note
the DevTools performance view works for flutter mobile and desktop apps.
for web apps, flutter adds timeline events to the
performance panel of chrome DevTools instead.
to learn about profiling web apps, check out debugging web performance.
the performance page can help you diagnose performance
problems and UI jank in your application.
this page offers timing and performance information
for activity in your application.
it consists of several tools to help you identify
the cause of poor performance in your app:
use a profile build of your application to analyze performance.
frame rendering times aren’t indicative of release performance
when running in debug mode. run your app in profile mode,
which still preserves useful debugging information.
the performance view also supports importing and exporting of
data snapshots. for more information,
check out the import and export section.
<topic_end>
<topic_start>
what is a frame in flutter?
flutter is designed to render its UI at 60 frames per second
(fps), or 120 fps on devices capable of 120hz updates.
each render is called a frame.
this means that, approximately every 16ms, the UI updates
to reflect animations or other changes to the UI. a frame
that takes longer than 16ms to render causes jank
(jerky motion) on the display device.
<topic_end>
<topic_start>
flutter frames chart