tree 90a8f2279dcfe31c3aac81764b573874b3c91e3e
parent bae5e49bc2a867403c43b2aae2de8f8c33b037e4
author flutteractionsbot <154381524+flutteractionsbot@users.noreply.github.com> 1708468505 -0800
committer GitHub <noreply@github.com> 1708468505 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJl1SkZCRC1aQ7uu5UhlAAAiFAQAGb0SQHVTnjCUgYSk+brqNoz
 PpXWKSv/Fsr+V9futRr47x5NWy/Avr3yBTw/vvVOWnesq/9GthdZFe4oULomrWG4
 YabPWMOPsDAIKuLr/I3z8uOPgwjvHeWVuhmq5B/5dBS8qfGdasgSwQqyhv8n7W/g
 SsWjodSacHVvpWvPfeAhOoStziKt2NmwBdPLcZbJVwE+NogiFFrkJn8Xa3lOBz0i
 ftkhNSgVU+OeUoWo4mWPuNeI0KV66zRs7KMvaD/+a1NfCKOnzpfvbhALl4ZsQ+mj
 iw/acgh6rxYimlDjYZv4H/LNy+uNWiH4gBmBA7iWKGJSrhh3CKwGlEK2JkUh7VXL
 /L+vc5HB3t+uprwShlFBN9GqbVVJJ3hvEXQ9Nh8u34gCh8Ngu/FicxmD/DjohrHV
 Y6SLLrMEdn/xlok+VSnIOKzbPSU1mIe+x3UfXBvvx0S+6ejxbQfBYizG6RSc8baw
 WFQlcj4G6ZJoOWmFajaLVOrjWF8JVTjfHfqEXKVxCHmMJF0YTNXs1axBc8Jvq7cn
 bPfbjgDbePpyQP8IMTpFL2RZ/tbyfv/v1Fpdt1EQeun2vrlFW0LmbfXqoIhm8jBy
 nD3VsuRH66R0zp5ccWCLuj3Jfcy8UFrzklPdyofCaF++s8eOR3v6A//RypC0Xf2M
 Llgr+Qx3um04uD6CiUWQ
 =45MS
 -----END PGP SIGNATURE-----
 

[CP-stable]instead of exiting the tool, print a warning when using --flavor with an incompatible device (#143785)

**This pull request is opened against a release branch.<br>
To request a cherry pick of a commit, please fill in the form below.** (Questions with an asterisk are required.)<br>

**To fill in the form, you can edit this PR description and type your answers after the 'My Answer' keywords. <br>
A flutter domain expert will evaluate this cherry pick request shortly after ALL questions are answered.**

* Issue Link: What is the link to the issue this cherry-pick is addressing?<br>

<pre>
  <b>My Answer:</b>
https://github.com/flutter/flutter/issues/143574

</pre>

* Changelog Description: Explain this cherry pick in one line that is accessible to most Flutter developers
        See https://github.com/flutter/flutter/wiki/Hotfix-Documentation-Best-Practices for examples (Bug fix, feature, docs update, ...)<br>

<pre>
  <b>My Answer:</b>

Instead of exiting, the `flutter` CLI tool now prints a warning when the `--flavor` option is used with a target platform that doesn't have flavors support.
</pre>

* impact_description: What is the impact (ex. visual jank on Samsung phones, app crash, cannot ship an iOS app)? Does it impact development (ex. flutter doctor crashes when Android Studio is installed), or the shipping production app (the app crashes on launch)<br>

<pre>
  <b>My Answer:</b>
All Flutter devs using the Flavors feature that use their IDE to select a target device.

</pre>

* Workaround: Is there a workaround for this issue?<br>

<pre>
  <b>My Answer:</b> Users can create duplicate debug launch configurations for target platforms that do not support the flavors feature.
</pre>

* Risk: What is the risk level of this cherry-pick?<br>

<pre>
  <b>My Answer:</b>

</pre>

* Test Coverage: Are you confident that your fix is well-tested by automated tests?<br>

<pre>
  <b>My Answer:</b>

</pre>

* Validation Steps: What are the steps to validate that this fix works?<br>

<pre>
  <b>My Answer:</b>

Set up a flutter project and configure at least one flavor for it. In VSCode, create a launch configuration that uses `--flavor` to select the flavor you configured (see https://github.com/flutter/flutter/issues/143574#issuecomment-1948284087 for an example). In VSCode, select chrome as the target device and try running the application using the configured launch configuration.

</pre>