devtools_extensions 0.1.0 devtools_extensions: ^0.1.0 copied to clipboard

A package for building and supporting extensions for Dart DevTools.

Dart & Flutter DevTools Extensions #

Extend Dart & Flutter's developer tool suite, Dart DevTools , with your own custom tool. DevTools' extension framework allows you to build tools that can leverage existing frameworks and utilities from DevTools (VM service connection, theming, shared widgets, utilities, etc.).

You can add a DevTools extension to an existing pub package, or you can create a new package that provides a DevTools extension only. In both these scenarios, the end-user must list a dependency on the package providing the DevTools extension in order to see the extension in DevTools.

When an app that depends on your package is connected to DevTools, your extension will show up in its own DevTools tab:

Example devtools extension

Follow the instructions below to get started, and use the end-to-end example for reference.

Table of contents #

  • Setup your package hierarchy
  • Where to put your source code
  • Development
  • Publish your package with a DevTools extension
  • Resources and support

Setup your package hierarchy #

Standalone extensions #.

If you are adding a DevTools extension to an existing Dart package, proceed to the instructions for configuring your extension .

If you are creating a standalone DevTools extension as a new package (i.e. not part of an existing pub package), then you can build your extension in the same package that it will be published with. Since the extension must be built as a Flutter web app, you can use the following flutter create template:

Now use the my_new_tool package to configure your extension in the next step.

Configure your extension #

In the Dart package that will provide the DevTools extension to users, add a top-level extension directory:

Under this directory, create the following structure:

The config.yaml file contains metadata that DevTools needs to load the extension.

Copy the config.yaml file content above and paste it into the config.yaml file you just created in your package. It is important that you use the exact file name and field names as shown, or else your extension may fail to load in DevTools.

For each key, fill in the appropriate value for your package.

name : the package name that this DevTools extension belongs to. The value of this field will be used in the extension page title bar. (required)

issueTracker : the url for your issue tracker. When a user clicks the “Report an issue” link in the DevTools UI, they will be directed to this url. (required)

version : the version of your DevTools extension. This version number should evolve over time as you ship new features for your extension. The value of this field will be used in the extension page title bar. (required)

Extension title bar components

materialIconCodePoint : corresponds to the codepoint value of an icon from material/icons.dart . This icon will be used for the extension’s tab in the top-level DevTools tab bar. (required)

Extension tab icon

For the most up-to-date documentation on the config.yaml spec, see extension_config_spec.md

Now it is time to build your extension.

Create a DevTools extension #

DevTools extensions must be written as Flutter web apps. This is because DevTools embeds extensions in an iFrame to display them dynamically in DevTools.

Where to put your source code #

Only the pre-compiled output of your extension needs to be shipped with your pub package in order for DevTools to load it.

Standalone extensions

For a standalone extension (an extension that is not being shipped as part of an existing pub package), it is acceptable to include your source code in the same package that the extension is shipped with. This will simplify development, and since users of your package will add a dependency on your package as a dev_dependency , the size of your package will not affect the user's app size.

Extensions that are part of an existing package

To keep the size of your pub package small, we recommend that you develop your DevTools extension outside of your pub package. Here is the recommended package structure:

Create the extension web app #

Create the Flutter web app

  • Skip this step if you are building a standalone extension, since you already did this when you set up your package hierarchy.

From the directory where you want your extension source code to live, run the following command, replacing some_pkg_devtools_extension with `<your_package_name>_devtools_extension``:

Add the devtools_extensions dependency to your Flutter web app.

Add the DevToolsExtension widget at the root of your Fluter web app.

In lib/main.dart , add the following:

The DevToolsExtension widget automatically performs all extension initialization required to interact with DevTools. From anywhere in your extension web app, you can access the globals:

  • extensionManager : a manager for interacting with DevTools or the extensions framework
  • serviceManager : a manager for interacting with the connected vm service, if present
  • dtdManager : a manager for interacting with the Dart Tooling Daemon, if present

Utilize helper packages

Use package:devtools_app_shared for access to service managers, common widgets, DevTools theming, utilities, and more. See devtools_app_shared/example for sample usages.

Debug the extension web app #

Use the simulated devtools environment (recommended for development).

For debugging purposes, you will likely want to use the "simulated DevTools environment". This is a simulated environment that allows you to build your extension without having to develop it as an embedded iFrame in DevTools. Running your extension this way will wrap your extension with an environment that simulates the DevTools-to-extension connection. It also gives you access to hot restart and a faster development cycle.

Simulated devtools environment

  • Your DevTools extension.
  • The VM service URI for a test app that your DevTools extension will interact with. This app should depend on your extension’s parent package.
  • Buttons to perform actions that a user may trigger from DevTools.
  • Logs showing the messages that will be sent between your extension and DevTools.

The simulated environment is enabled by an environment parameter use_simulated_environment . To run your extension web app with this flag enabled, add a configuration to your launch.json file in VS code:

or launch your app from the command line with the added flag:

Use a real DevTools Environment

To use a real DevTools environment, you will need to perform a series of setup steps:

Develop your extension to a point where you are ready to test your changes in a real DevTools environment. Build your flutter web app and copy the built assets from your_extension_web_app/build/web to your pub package's extension/devtools/build directory.

Use the build_and_copy command from package:devtools_extensions to help with this step.

To ensure that your extension is setup properly for loading in DevTools, run the validate command from package:devtools_extensions . The --package argument should point to the root of the Dart package that this extension will be published with.

Prepare and run a test application that depends on your pub package that is providing the extension. You'll need to change the pubspec.yaml dependency to be a path dependency that points to your local pub package source code. Once you have done this, run pub get on the test app, and then run the application.

Start DevTools:

  • As long as you are using Dart SDK >= todo or Flutter SDK >= todo , you can launch the DevTools instance that was just started by running your app (either from a url printed to command line or from the IDE where you ran your test app). You can also run dart devtools from the command line.
  • If you need local or unreleased changes from DevTools , you'll need to build and run DevTools from source. See the DevTools CONTRIBUTING.md for a guide on how to do this. You'll need to build DevTools with the server and the front end to test extensions - see instructions .

Connect your test app to DevTools if it is not connected already, and you should see a tab in the DevTools app bar for your extension. The enabled or disabled state of your extension is managed by DevTools, which is exposed from an "Extensions" menu in DevTools, available from the action buttons in the upper right corner of the screen.

Publish your package with a DevTools extension #

In order for a package to provide a DevTools extension to its users, it must be published with the expected content in the your_package/extension/devtools/ directory (see the setup instructions above).

  • Ensure the extension/devtools/config.yaml file exists and is configured per the specifications above .
  • Use the build_and_copy command provided by package:devtools_extensions to build your extension and copy the output to the extension/devtools directory:

Then publish your package. When running pub publish , you will see a warning if you do not have the config.yaml file and a non-empty build directory as required.

What if I don't want the extension/devtools/build/ contents checked into source control? #

As a package author, the content that you check into your git repository is completely up to you. If you want the contents of extension/devtools/build/ to be git ignored, then you'll just need to ensure that the extension web app is always built and included in extension/devtools/build/ when you publish your package. To do so, add the following to a .pubignore file in the extension/devtools/ directory:

This will ensure that, even if the extension/devtools/build directory has been been git ignored, the directory will still be included when publishing the package on pub.

To verify the published extension contents are always up to date, consider adding a tool script to your repo that looks something like this:

Resources and support #

Please join the Flutter Discord server and then check out the #devtools-extension-authors channel to connect with other DevTools extension authors and the DevTools team.

For feature requests or bugs, please file an issue on the DevTools Github repository.

Repository (GitHub) View/report issues Contributing

Documentation

API reference

Dependencies

args , devtools_app_shared , devtools_shared , flutter , io , logging , path , vm_service , web , yaml

Packages that depend on devtools_extensions

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

  • Notifications

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

shows blank page in safari! #29

@nabi009

nabi009 commented Dec 29, 2022

@nabi009

No branches or pull requests

@nabi009

The global deployment platform for Dart & Flutter applications.

An online Dart & Flutter sandbox in the browser.

Instant Open Source documentation with zero configuration.

A tool for managing Dart projects with multiple packages.

Case Studies →

Open source →, blog →, how to: extending the flutter devtool.

Remi Rousselet

Flutter Engineer & Open source maintainer

Need a custom tool? Invertase can help

Tired of investing in off-the-shelf software that doesn't quite fit your business? Invertase can build solutions tailored to your exact needs. Tell us what you're looking for here and we'll be in touch.

Very recently, the Flutter devtool got extended to include a screen that integrates with provider to allow you to inspect and edit the state of your applications.

Let’s explain how you can do the same yourself.

Getting started: Setting up the project

First, let us setup everything. Interestingly, the Flutter devtool is itself implemented using Flutter. So our new screen will be but another Widget. No need to learn a new technology to get started.

It is worth noting that, at the moment, the devtool does not have a plugin mechanism (but there is a design document for it). That means that we will have to contribute directly to the devtool repository. So rather than a new project, we will start by forking the devtool:

  • Head to the devtool repository: https://github.com/flutter/devtools
  • Clone the created project: git clone https://github.com/my-user-name/devtools/
  • Run flutter pub get in the different packages.

The project structure

The devtool is a fairly big project. But for writing new screens, we only care about two things:

  • _packages/devtools app This is the source code of the Flutter application that powers the devtool.
  • _packages/devtool testing This package is where we will write some of our integration tests. More about that later.

Starting the project in debug mode

The devtool is pre-setup with everything necessary to debug the application using VS Code .

To start the devtool, press F5 , and the IDE will start devtools_app , at which point you should see:

At this stage, the devtool asks us to connect it to a Flutter application.

To do so, start any other Flutter project separately. When starting the project, Flutter should output something similar to:

We will need to copy and paste that ws://127.0.0.1:12345/whatever=/ws in the devtool page:

Click connect and you should now see:

Nice job! We can now start writing our plugin.

Adding a new screen

Let’s add a new screen.

To create a screen, we first need to define a subclass of Screen . Often, we will want a screen that is visible only if a specific package in the inspected application exists.

In this case, our Screen subclass will look like:

From there, we need to insert our screen in the list of screens. For that, head to the file packages/devtools_app/src/app.dart . You should see a variable named defaultScreens which contains the list of all screens. Simply add our new class in the list like so:

Hot-restart the devtool, and you should now see your new screen in the list of screens. At this stage, you should be able to write the UI code for your plugin as you would usually do in Flutter.

Interacting with the inspected application

Adding a new screen to the devtool is great, but this isn’t very useful if we cannot interact with the debugged application.

Fortunately, using the package vm_service , it is possible for our new screen to both read and edit variables from the inspected application.

The devtool comes with vm_service pre-installed and setup for us. That is concretized by:

  • The global variable serviceManager , from devtools_app/src/globals.dart . It contains numerous information useful to connect with the inspected application.
  • The class EvalOnDartLibrary , from devtools_app/src/eval_on_dart_library.dart . This class allows us to execute dart code dynamically.

Example: Reading a global variable from the inspected application.

Assume that the inspected application defined a global variable like so:

We can then use EvalOnDartLibrary to read this variable like so:

Note : You are not limited to inspecting variables. Any valid dart expression is accepted:

You aren’t limited to receiving strings either. InstanceRef exposes numerous properties for reading more complex objects

Defining a “Binding” in the package we interact with.

As you may have noticed, using EvalOnDartLibrary requires knowing the dart file we want to inspect.

If you are interacting with a package (like trying to inspect the state of providers), one solution to this is to add debug utilities in the package that the application imports.

For example, provider defines an internal ProviderBinding class that contains a list of all the providers created by the inspected application:

This allows us to use EvalOnDartLibrary like so:

Evaluating expressions from other variables

A common use-case for evaluations is to try and evaluate something from a variable obtained by a previous evaluation. For example, we may first get a variable in our application. And then we would like to mutate a property of that variable.

To do so, we can reuse a previously obtained InstanceRef , combined with the scope parameter of evaluations:

Avoiding expression results from being garbage collected

By default, results of evaluation queries are not kept in memory.

That can be problematic sometimes, as it can make further evaluations fail because we are trying to manipulate an object that is no longer in memory. Sadly vm_service doesn’t include a way to preserve objects in memory by default. Fortunately, Flutter comes with some utilities that allow us to work around the issue: WidgetInspectorService .

Assuming that we first perform an evaluation that creates a variable we want to keep in memory:

We can use WidgetInspectorService by making a separate evaluation to tell Flutter to keep this variable in memory:

Then, when we later want to re-access our variable, we can do:

And finally, when we no longer need the variable, we can allow it to be garbage collected with:

Receiving events from the inspected application

In some cases, you may want your devtool to react to events from the inspected application. For example, the Provider devtool wants to listen to when providers are added/removed/updated, so that the devtool can refresh to show the changes.

For this, the inspected application can use dart:developer ‘s postEvent to emit events that the devtool can then listen to.

In the case of Provider, it uses this function inside the initState of a provider to do:

Then the devtool plugin subscribes to this event with:

Supporting hot-restart on the inspected application

One thing to keep in mind is that the inspected application may be hot-restarted at any time. The devtool need to handle those cases to avoid situations where the UI shows outdated content.

One way to support hot-restarts is to listen to changes on the inspected isolate:

Inspected application change

It is possible that the inspected application will change over time, without the devtool being restarted.

In this case, serviceManager.service will be replaced with a new instance. But this means that the devtool needs to recompute everything that depended on serviceManager.service , including re-creating instances of EvalOnDartLibrary .

You can listen to changes of serviceManager.service with:

Aborting pending evaluations when no longer needed

For performance reasons, we may want to cancel pending evaluations.

That can be done using the isAlive parameter that was mentioned in the previous snippets, combined with the Disposable class.

First, we need to create an instance of that Disposable class:

Then, when making evaluations, we can pass this variable:

Then, if we want to cancel the expression, we can do:

That will automatically abort all pending requests associated with this isAlive variable.

Writing e2e tests

Last but not least, we will want to write tests.

Since the devtool is implemented using Flutter, you can write unit and widget tests as usual. But unit/widget tests will not be able to test anything that uses serviceManager , since there is no inspected application during tests.

Writing tests for logic that interact with the inspected application could be tricky as we need to interact with both the devtool, and the inspected application at the same time. Luckily, the devtool comes with everything you need for this.

That is where _devtool testing becomes useful.

This package defines testing applications, later used by integration tests. You can open packages/devtools_testing/fixtures to see the list of built-in testing applications and potentially add your own there.

For our example, our tests will use the provider_app , an application that uses provider.

Now let’s add an e2e test. Adding an e2e test is a two-step process.

We first need to declare a Dart file in packages/devtools_testing/my_test.dart . This file should export a function (not a main ) that defines our tests:

Then, we need to tell _devtools app to run this test. For this, we need to add a dart file in packages/devtools_app/my_test.dart :

We can then execute our test with:

Note : You will not need an emulator for this to work

Our test is then able to interact with vm_service / EvalOnDartLibrary . We can then update our runMyTests function to test the full flow:

That’s it! You should have all the keys in your hand to be able to extend the Flutter devtool.

Thanks for reading~

And while you’re here, I would like to give a shout out to the Flutter team and especially Jacob . The journey of implementing the Provider devtool would have been a lot harder if not for their help.

If you are facing issues too, I am sure they would be glad to help.

THE 5 BEST Moscow Safaris

Safaris in moscow.

  • Adrenaline & Extreme Tours
  • Gear Rentals
  • Nature & Wildlife Tours
  • 5.0 of 5 bubbles
  • District Central (TsAO)
  • 3rd Transport Ring (TTK)
  • District North-Eastern (SVAO)
  • District Eastern (VAO)
  • District South-Western (YuZAO)
  • Lomonosovskiy
  • Ostankinskiy
  • Meshchanskiy
  • Krasnoselskiy
  • Maryina Roshcha (Jewish Quarter)
  • Good for Couples
  • Good for Kids
  • Good for Big Groups
  • Adventurous
  • Budget-friendly
  • Good for a Rainy Day
  • Hidden Gems
  • Honeymoon spot
  • Good for Adrenaline Seekers
  • Things to do ranked using Tripadvisor data including reviews, ratings, photos, and popularity.

flutter devtools safari

1. Rybokhotsoyuz

flutter devtools safari

2. Easy Russia Tour Guide

alizain1985

3. UTS GROUP

flutter devtools safari

4. 365AltaiMongolia

flutter devtools safari

5. #1 Russia -Tanzania | Zanzibar, Serengeti Safari & Kilimanjaro Agency | BURIGI CHATO SAFARIS CO LTD

flutter devtools safari

6. Aviashop.Ru

flutter devtools safari

7. Transsib Moscow

flutter devtools safari

8. BASK TOUR

  • Easy Russia Tour Guide
  • #1 Russia -Tanzania | Zanzibar, Serengeti Safari & Kilimanjaro Agency | BURIGI CHATO SAFARIS CO LTD
  • 365AltaiMongolia

Watch CBS News

Massive Ukrainian effort underway to clear millions of landmines spread across country

By Scott Pelley

April 7, 2024 / 7:00 PM EDT / CBS News

No matter how Russia's war in Ukraine ends, Dr. Yuriy Kuznetzov will be battling Vladimir Putin's madness for years. Kuznetzov is a Ukrainian surgeon and a national hero who stayed beside his patients as they were attacked. Now, heroism is a virtue that must endure. His city was liberated, but Dr. Kuznetzov sees victims every week or so -- civilians who step on one of the millions of Russian landmines across about a third of Ukraine. There's a massive effort to clear the mines but that will take a generation or more. Until then, there will be Dr. Kuznetzov with healing hands and eyes that have seen too much.

Half his life he's devoted to Central Hospital and here in its basement, with Putin's bombs overhead, all he'd become in 52 years was laid down in service to his home. 

Dr. Yuriy Kuznetzov (translation): We didn't imagine, until the end, that Russia would attack our country. When you're sitting in a basement at night and a plane is flying over you, it was impossible to predict whether you would wake up to see another day.

In 2022, the basement became Dr. Kuznetzov's operating room. That's him dressed in white. The wounded were endless—a close friend's wife he could not save and this man, who was shot, and lived. 

Scott Pelley: Did you save more patients than you lost?

Dr. Yuriy Kuznetzov (translation): We saved significantly more people, definitely.

Dr. Yuriy Kuznetzov

Scott Pelley: Many of your colleagues evacuated and you did not. I wonder why you stayed. 

Dr. Yuriy Kuznetzov (translation): When you have patients and you're the only doctor or the only person who can treat them, I didn't understand how you could leave.

He could not leave Izium. His city of 40,000 was occupied for six months. The Russians laid landmines here as they ran from Ukraine's counterattack. Putin's unprovoked war on an innocent people destroyed 80% of Izium and killed 1,000, leaving apartment buildings cleaved in two and this school, built in 1882, a hollow corpse.  

The people of Izium clothe themselves in liberation and yet, they are not entirely free. 

Demining teams are still fighting Russia here. Izium, 20 miles from the front, is one of the worst areas for mines and unexploded ordnance. Throughout Ukraine, more than 1,000 civilians have been wounded by mines. Lidia Borova, a 70-year-old widow, was picking mushrooms in a forest. 

Lidia Borova (translation): I turned by the tree and then there was an explosion. I looked [down] at myself and I was bleeding, my arm was injured, my leg was injured. I was losing strength.

Her right foot and ankle were ripped away.

Lidia Borova

Dr. Yuriy Kuznetzov (translation): First of all, the most difficult thing, is to persuade a patient that their leg needs to be amputated. It's very difficult to explain to them that the leg is no good, no good to use 

He told us a prosthetic is ultimately easier to live with.  

Lidia Borova (translation): Dr. Kuznetzov saved me. I didn't realize how much blood I lost. I don't know how I managed to survive.

Ihor Bogoraz was with his wife in their garden. They found 12 mines. But there were 13. 

Ihor Bogoraz (translation): I decided to mow the weeds. And one [mine] was under my foot. I stepped on it and it exploded instantly. And that's it – no leg. 

Serhii Nikolaiv was walking in leaves from the autumn while uncovering grapevines for the spring. 

Serhii Nikolaiv (translation): If it had been green, I would have noticed it. But it was brown – I didn't see it. It blended in with the leaves. I stepped on it. And I knew right away.

Prosthetic after landmine injury in Ukraine

Dr. Yuriy Kuznetzov (translation): The majority are those who stepped on "Petal" [mines] or anti-personnel mines - the person who invented them was an evil genius because they only weigh [two ounces] but what they can do when triggered is terrifying.

Petal mines, 5 inches long, flutter from aircraft by the thousands, like flower petals. Eleven pounds of pressure will set them off. 

Vasyl Solyanik found them on his roof and in his garden. 

Vasyl Solyanik (translation): There's 18 here,  but in all, there were over 50. 

He showed us his video. That's a petal mine right there. They are so common that we were told the story of a 70-year-old woman who gathered them in a basket and took them to a police station. 

Vasyl Solyanik (translation): There's some left in the bushes over here, so don't walk around there.

He dialed 101 and emergency services sent deminers Ivan Shepelev and Ihor Ovcharuk.

Ihor Ovcharuk (translation): We encounter every type of munition – anti-infantry and anti-tank mines, mortars, artillery shells, [rockets]. It's all here.

At Solyanik's home, a sweep revealed an unexploded cluster bomb. Those are tricky. So they blew it in place.

Ivan Shepelev and Ihor Ovcharuk

Ivan Shepelev told us, as the Russians fled, they also left boobytraps. 

Ivan Shepelev (translation): We have seen cases, unfortunately, where explosives were found in civilian homes. 

Ihor Ovcharuk (translation): My [team] also had to work on removing our dead Ukrainian soldiers whose bodies had been mined. 

In 2022, Ihor Ovcharuk's kneecap was shattered when a fellow deminer stepped on a mine and lost his foot.  

Ivan Shepelev (translation): We know every explosive we remove means that someone's life is saved. 

A few weeks after our visit, a Russian missile wrecked the fire station where they're based. Some were injured but not Shepelev or Ovcharuk.

Scott Pelley: What is the scope of the mine threat in Ukraine?

Pete Smith: I think the scope is unrecognizable in modern times.

Pete Smith heads demining here for the HALO Trust , a charity founded in 1988 to demine warzones. Smith was 33 years in the British army and awarded by Queen Elizabeth for disarming an IRA timebomb in a train station. Today, he says, Ukraine is the most heavily mined country.

Pete Smith: In some areas, the minefields are three or four mines deep, in areas, maybe a dozen mines deep. But that's just the first line of defense. Then, several kilometers behind that, there are other layers of-- of minefields, as well.

Smith took us to a farm sown with Russian anti-tank mines. You have to step carefully. Right there, in the center, is a mine packed with 17 pounds of high explosive. With three weeks of training behind her, Yulia Yaroshchuk was probing for any tripwire that would detonate a mine near her. She threaded the grass… feeling for the slightest resistance. Only the day before, a HALO deminer was killed and two were wounded in another part of Ukraine. 

Deminer Yulia Yaroshchuk in Ukraine

Scott Pelley: Doing this by hand with that wand, it seems to me that you have an awfully big field to cover. 

Yulia Yaroshchuk (translation): Well, of course. It will be a very long process.  As far as I know, it will take many, many years. Each day [of war] means years of de-mining.   

Scott Pelley: Why do you do this work?

Yulia Yaroshchuk (translation): I didn't have to do it. I wanted to do it. this is my contribution to victory. 

Scott Pelley: Will Ukraine ever be without mines?

Pete Smith: I think what I have seen in my time in Ukraine is the innovation, the patriotism, and just the sheer will of the people, that I'm confident that they will be able to remove the last mine from Ukraine.

Scott Pelley: Does this war make any sense to you?

Serhii Nikolaiv (translation): Not to a single person here, or anywhere. What kind of mind? What kind of moron or idiot do you have to be to even wish something like this on your enemies? You can't. Even now, someone could drop a fork or a spoon and it makes a loud noise. And in your soul, you feel pain, and bitterness, and fear. It's a real horror. [my sister-in-law] was ripped apart by a mine in front of her children. In front of their eyes. 

Of all of Vladimir Putin's war crimes in Ukraine, one was the bombing of Izium's Central Hospital. 

Dr. Yuriy Kuznetzov (translation): After this part of the hospital was damaged, a lot of medical services simply became unavailable. Here we had both intensive care and three operating rooms.  

When Yuriy Kuznetzov was 14 years old, his grandmother died in his arms. He told us that's why he became a doctor. And we suspect that's why he stayed through the bombardment and occupation and the battle of the mines. 

Scott Pelley: When a town loses its hospital, it doesn't just lose the medical care - it loses hope. 

Dr. Yuriy Kuznetzov (translation): The best praise for me was when a woman told me in April of 2022 that "when we heard the hospital was still open, we realized that our town had hope, it could withstand, survive, and [have a] future."

The future of Ukraine will demand devotion and heroic patience. On this day, Yulia Yaroshchuk slowly teased out one Russian mine, with millions more receding from its edge. 

Produced by Maria Gavrilovic. Associate producer, Alex Ortiz. Broadcast associate, Michelle Karim. Edited by Sean Kelly.

Scott Pelley

Scott Pelley, one of the most experienced and awarded journalists today, has been reporting stories for "60 Minutes" since 2004. The 2023-24 season is his 20th on the broadcast. Scott has won half of all major awards earned by "60 Minutes" during his tenure at the venerable CBS newsmagazine.

More from CBS News

Ukraine's landmine crisis

AI-powered mental health bots developed as a therapy support tool

Russian missile strikes on Ukrainian city of Kharkiv leaves at least 6 dead

A lesson in forgiveness from Yogi Berra

Google uses cookies to deliver its services, to personalize ads, and to analyze traffic. You can adjust your privacy controls anytime in your Google settings . Learn more .

  • Install Flutter
  • Write your first app
  • Flutter for Android devs
  • Flutter for SwiftUI devs
  • Flutter for UIKit devs
  • Flutter for React Native devs
  • Flutter for web devs
  • Flutter for Xamarin.Forms devs
  • Introduction to declarative UI
  • Flutter versus Swift concurrency
  • Dart language overview
  • SDK archive
  • Release notes
  • Breaking changes
  • Compatibility policy
  • Samples and demos
  • Add achievements and leaderboards
  • Add advertising
  • Add multiplayer support
  • Add in-app purchases
  • Add user authentication
  • Debug using Crashlytics
  • Build a news app
  • Add maps to your app
  • User interface
  • Introduction
  • Widget catalog
  • Build a layout
  • Create and use lists
  • Create a horizontal list
  • Create a grid view
  • Create lists with different types of items
  • Create lists with spaced items
  • Work with long lists
  • Use slivers to achieve fancy scrolling
  • Place a floating app bar above a list
  • Create a scrolling parallax effect
  • Adaptive and responsive app design
  • Build an adaptive app
  • Update app UI based on orientation
  • Share styles with themes
  • Material design
  • Migrate to Material 3
  • Fonts & typography
  • Use a custom font
  • Export fonts from a package
  • Google Fonts package
  • Use custom fragment shaders
  • Add interactivity to your app
  • Handle taps
  • Drag an object outside an app
  • Drag a UI element within an app
  • Add Material touch ripples
  • Implement swipe to dismiss
  • Create and style a text field
  • Retrieve the value of a text field
  • Handle changes to a text field
  • Manage focus in text fields
  • Build a form with validation
  • Display a snackbar
  • Implement actions & shortcuts
  • Manage keyboard focus
  • Add assets and images
  • Display images from the internet
  • Fade in images with a placeholder
  • Play and pause a video
  • Add tabs to your app
  • Navigate to a new screen and back
  • Send data to a new screen
  • Return data from a screen
  • Add a drawer to a screen
  • Setup deep linking
  • Setup app links for Android
  • Setup universal links for iOS
  • Configure web URL strategies
  • Implicit animations
  • Animate the properties of a container
  • Fade a widget in and out
  • Hero animations
  • Animate a page route transition
  • Animate using a physic simulation
  • Staggered animations
  • Create a staggered menu animation
  • API overview
  • Accessibility
  • Internationalization
  • Think declaratively
  • Ephemeral vs app state
  • Simple app state management
  • Fetch data from the internet
  • Make authenticated requests
  • Send data to the internet
  • Update data over the internet
  • Delete data on the internet
  • Communicate with WebSockets
  • JSON serialization
  • Parse JSON in the background
  • Store key-value data on disk
  • Read and write files
  • Persist data with SQLite
  • Google APIs
  • Supported platforms
  • Build desktop apps with Flutter
  • Write platform-specific code
  • Automatic platform adaptations
  • Add Android as build target
  • Add a splash screen
  • Bind to native code
  • Host a native Android view
  • Restore state on Android
  • Target ChromeOS with Android
  • Add iOS as build target
  • Leverage Apple's system libraries
  • Add a launch screen
  • Add iOS App Clip support
  • Add iOS app extensions
  • Host a native iOS view
  • Enable debugging on iOS
  • Restore state on iOS
  • Add Linux as build target
  • Build a Linux app
  • Add macOS as build target
  • Build a macOS app
  • Add web as build target
  • Build a web app
  • Web renderers
  • Custom app initialization
  • Display images on the web
  • Add Windows as build target
  • Build a Windows app
  • Use packages & plugins
  • Develop packages & plugins
  • Flutter Favorites
  • Package repository
  • Mock dependencies
  • Find widgets
  • Simulate scrolling
  • Simulate user interaction
  • Write and run an integration test
  • Profile an integration test
  • Test a plugin
  • Handle plugin code in tests
  • Debugging tools
  • Debug your app programmatically
  • Use a native language debugger
  • Flutter's build modes
  • Common Flutter errors
  • Handle errors
  • Report errors to a service
  • Performance best practices
  • Deferred components
  • Rendering performance
  • Performance profiling
  • Performance profiling for web
  • Shader compilation jank
  • Performance metrics
  • Concurrency and isolates
  • Performance FAQ
  • Obfuscate Dart code
  • Create flavors of an app
  • Build and release an Android app
  • Build and release an iOS app
  • Build and release a macOS app
  • Build and release a Linux app
  • Build and release a Windows app
  • Build and release a web app
  • Set up continuous deployment
  • Set up Android project
  • Add a single Flutter screen
  • Add a Flutter Fragment
  • Add a Flutter View
  • Use a Flutter plugin
  • Set up iOS project
  • Debug embedded Flutter module
  • Add multiple Flutter instances
  • Loading sequence and performance
  • Android Studio & IntelliJ
  • Visual Studio Code
  • Install from Android Studio & IntelliJ
  • Install from VS Code
  • Install from command line
  • Flutter inspector
  • Performance view
  • CPU Profiler view
  • Memory view
  • Debug console view
  • Network view
  • Logging view
  • App size tool
  • DevTools extensions
  • SDK overview
  • Flutter's pubspec options
  • Automated fixes
  • Code formatting
  • Architectural overview
  • Inside Flutter
  • Understanding constraints
  • Contributing
  • Create useful bug reports
  • Contribute to Flutter
  • Design documents
  • Who is Dash?
  • Widget index
  • API reference
  • flutter CLI reference

Install the Flutter plugin

Start an app to debug, launch devtools from the toolbar/menu, launch devtools from an action, install and run devtools from android studio.

Install the Flutter plugin if you don't already have it installed. This can be done using the normal Plugins page in the IntelliJ and Android Studio settings. Once that page is open, you can search the marketplace for the Flutter plugin.

To open DevTools, you first need to run a Flutter app. This can be accomplished by opening a Flutter project, ensuring that you have a device connected, and clicking the Run or Debug toolbar buttons.

Once an app is running, you can start DevTools using one of the following:

  • Select the Open DevTools toolbar action in the Run view.
  • Select the Open DevTools toolbar action in the Debug view. (if debugging)
  • Select the Open DevTools action from the More Actions menu in the Flutter Inspector view.

screenshot of Open DevTools button

You can also open DevTools from an IntelliJ action. Open the Find Action... dialog (on macOS, press Cmd + Shift + A ), and search for the Open DevTools action. When you select that action, DevTools is installed (if it isn't already), the DevTools server launches, and a browser instance opens pointing to the DevTools app.

When opened with an IntelliJ action, DevTools is not connected to a Flutter app. You'll need to provide a service protocol port for a currently running app. You can do this using the inline Connect to a running app dialog.

IMAGES

  1. Flutter

    flutter devtools safari

  2. Designing Flutter DevTools

    flutter devtools safari

  3. DevTools

    flutter devtools safari

  4. How to use Devtools for Safari Mobile View ?

    flutter devtools safari

  5. Debugging Flutter App Using DevTools

    flutter devtools safari

  6. Installing DevTools to Debug Apps for Flutter Developers

    flutter devtools safari

VIDEO

  1. Flutter 3

  2. Flutter for iOS devs

  3. Инструменты разработчика, вкладка Application

  4. #binturong #animal #wildlife #nature #creatures #animalfact #habitats #amazingfact #short #zoo

  5. United States Wildlife Adventure

  6. #bluemorphobutterfly #animawe #animal #wildlife #nature #creatures #habitats #biodiversity #short

COMMENTS

  1. DevTools

    Here are some of the things you can do with DevTools: Inspect the UI layout and state of a Flutter app. Diagnose UI jank performance issues in a Flutter app. CPU profiling for a Flutter or Dart app. Network profiling for a Flutter app. Source-level debugging of a Flutter or Dart app. Debug memory issues in a Flutter or Dart command-line app.

  2. How to change Flutter DevTools default browser?

    In my case, my computers default browser is set to Safari but Safari doesn't work well with Flutters Dev Tools at the moment. So.. how can you keep your computers default browser and specify a browser you want to use when starting dev tools? In Android Studio open up your Preferences and in the top left there is a search bar. Type in "Web ...

  3. Support Safari as a browser in flutter run #55323

    If this works, we might be able to provide a 1st class flutter run -d safari experience. The text was updated successfully, but these errors were encountered: 👍 37 jlubeck, adeolaex, LiveLikeCounter, nwparker, aarajput, jonbhanson, konkontos, marcin-jelenski, maheshmnj, temoki, and 27 more reacted with thumbs up emoji

  4. Dart & Flutter DevTools Extensions

    Flutter SDK >= 3.17.0-0.0.pre& Dart SDK >= 3.2. A Pubpackage (existing or new) to add a DevTools extension to. It is recommended to develop your extension from the Flutter master channel in ...

  5. devtools_extensions

    To use a real DevTools environment, you will need to perform a series of setup steps: Develop your extension to a point where you are ready to test your changes in a real DevTools environment. Build your flutter web app and copy the built assets from your_extension_web_app/build/web to your pub package's extension/devtools/build directory.

  6. Dive into DevTools

    In this video, we're going to see different ways to make your Flutter app faster and more reliable. Chapters:0:00 - Introduction0:42 - Getting up and running...

  7. Releases · flutter/devtools · GitHub

    Releases: flutter/devtools. Releases Tags. Releases · flutter/devtools. v0.9.2. 14 Sep 16:56 . bkonyi. v0.9.2 43db4f4. This commit was created on GitHub.com and signed with GitHub's verified signature. The key has expired. GPG key ID: 4AEE18F83AFDEB23. Expired. Learn about vigilant ...

  8. Install and run DevTools from VS Code

    Flutter and Dart's latest releases are helping to define the future of app development. Read the blog to learn more. Get started. Install Flutter; Test drive; ... Once the debug session is active and the application has started, the Open DevTools commands become available in the VS Code command palette (F1):

  9. shows blank page in safari! · Issue #29 · Flutter-DevTools ...

    Hi, I am using safari, it does not show anything in safari but with chrome works fine. Hi, I am using safari, it does not show anything in safari but with chrome works fine. ... Flutter-DevTools / flutter_devtools Public. Notifications Fork 0; Star 3. Code; Issues 9; Pull requests 0; Actions; Projects 0; Security; Insights New issue ...

  10. DevTools extensions

    What are DevTools extensions? DevTools extensions are developer tools provided by third-party packages that are tightly integrated into the DevTools tooling suite. Extensions are distributed as part of a pub package, and they are dynamically loaded into DevTools when a user is debugging their app.

  11. How to: Extending the Flutter devtool

    To start the devtool, press F5, and the IDE will start devtools_app, at which point you should see: At this stage, the devtool asks us to connect it to a Flutter application. To do so, start any other Flutter project separately. When starting the project, Flutter should output something similar to:

  12. [4K] Walking Streets Moscow. Moscow-City

    Walking tour around Moscow-City.Thanks for watching!MY GEAR THAT I USEMinimalist Handheld SetupiPhone 11 128GB https://amzn.to/3zfqbboMic for Street https://...

  13. Crocus City Hall attack

    On 22 March 2024, a terrorist attack carried out by the Islamic State occurred at the Crocus City Hall music venue in Krasnogorsk, Moscow Oblast, Russia. The attack began at around 20:00 MSK ( UTC+3 ), shortly before the Russian band Picnic was scheduled to play a sold-out show at the venue. Four gunmen carried out a mass shooting, as well as ...

  14. How do I open Flutter DevTools in a separate window in VSC?

    To do this, go to VS Code settings ( ctrl + ,) and type embed devtools : Unchecking this will result in DevTools being opened in Chrome. answered Mar 7, 2022 at 9:52. davdog00. 83 2 16. 1. The name of the setting changed to "Dev Tools Location" and the desired option is "external". - MoonKillCZ. Aug 30, 2023 at 20:06.

  15. THE 5 BEST Moscow Safaris (Updated 2024)

    Hotels near Moscow P. I. Tchaikovsky Conservatory Hotels near Russian Academy of Theatre Arts Hotels near Institute for the Economy in Transition Hotels near Gnesins Russian Academy of Music Hotels near Moscow International Higher Business School (MIRBIS) Hotels near Turo Moskovskiy Universitet, NOU Hotels near Maxim Gorky Literature Institute Hotels near Moscow State University of Railway ...

  16. Massive Ukrainian effort underway to clear millions of landmines spread

    His city was liberated, but Dr. Kuznetzov sees victims every week or so -- civilians who step on one of the millions of Russian landmines across about a third of Ukraine. There's a massive effort ...

  17. Flutter DevTools open a blank screen

    11. I'm running Android Studio 4.1.1 with Flutter 2 plugin, but I couldn't get DevTools to open by pressing its icon in the run window or by choosing Open DevTools from the more actions popup in flutter inspector, the result is always a blank web page. I have a running mobile app on an iOS simulator, but I don't know if that makes a difference.

  18. How live in Russia 2023? Moscow City Walk Tour: New ...

    Embark on a captivating journey through the heart of Moscow with our immersive City Walk. ⚠️ Follow for more: https://www.youtube.com/@Real-Russia-4K-Walks F...

  19. Web FAQ

    In general, Flutter is geared towards dynamic application experiences. Flutter's web support is no exception. Flutter web prioritizes performance, fidelity, and consistency. This means application output does not align with what search engines need to properly index. For web content that is static or document-like, we recommend using HTML ...

  20. Tools

    Content covering Tools that support developing Flutter apps. Google uses cookies to deliver its services, to personalize ads, and to analyze traffic. ... What's new Editor support Hot reload Profiling Install Flutter DevTools Cookbook Codelabs. Get started. Flutter and Dart's latest releases are helping to define the future of app development ...

  21. Install and run DevTools from Android Studio

    Launch DevTools from the toolbar/menu. Once an app is running, you can start DevTools using one of the following: Select the Open DevTools toolbar action in the Run view. Select the Open DevTools toolbar action in the Debug view. (if debugging) Select the Open DevTools action from the More Actions menu in the Flutter Inspector view.