<itemvalue="The [exitType] indicates what kind of exit to perform. For [ui.AppExitType.cancelable] exits, the application is queried through a call to [handleRequestAppExit], where the application can optionally cancel the request for exit. If the [exitType] is [ui.AppExitType.required], then the application exits immediately without querying the application."/>
<itemvalue="This differs from calling `dart:io`'s [exit] function in that it gives the engine a chance to clean up resources so that it doesn't crash on exit, so calling this is always preferred over calling [exit]. It also optionally gives handlers of [handleRequestAppExit] a chance to cancel the application exit."/>
<itemvalue="Exits the application by calling the native application API method for exiting an application cleanly. This differs from calling `dart:io`'s [exit] function in that it gives the engine a chance to clean up resources so that it doesn't crash on exit, so calling this is always preferred over calling [exit]. It also optionally gives handlers of [handleRequestAppExit] a chance to cancel the application exit."/>
<itemvalue="To listen for changes in the application lifecycle state, define an [onStateChange] callback. See the [AppLifecycleState] enum for details on the various states."/>
<itemvalue="To listen for requests for the application to exit, and to decide whether or not the application should exit when requested, create an [AppLifecycleListener] and set the [onExitRequested] callback."/>
<itemvalue="A listener that can be used to listen to changes in the application lifecycle."/>
<itemvalue="A callback used to ask the application if it will allow exiting the application for cases where the exit is cancelable. Exiting the application isn't always cancelable, but when it is, this function will be called before exit occurs. Responding [AppExitResponse.exit] will continue termination, and responding [AppExitResponse.cancel] will cancel it. If termination is not canceled, the application will immediately exit."/>
<itemvalue="Gemini is a conversational experience in Android Studio that helps you be more productive by answering Android development queries. It is powered by artificial intelligence and can understand natural language, so you can ask development questions in plain English. Gemini can help Android developers generate code, find relevant resources, learn best practices, and save time. Gemini is still an early experiment, and may sometimes provide inaccurate, misleading, or false information while presenting it confidently. Gemini may give you working code that doesn’t produce the expected output, or provide you with code that is not optimal or incomplete. Always double-check Gemini’s responses and carefully test and review code for errors, bugs, and vulnerabilities before relying on it."/>
<itemvalue="The method '_AMToolboxStoryWidgetForGCSState' isn't defined for the type 'AMToolboxStoryWidgetForGCS'. (Documentation) Try correcting the name to the name of an existing method, or defining a method named '_AMToolboxStoryWidgetForGCSState'"/>
<itemvalue="Writes a string to the file using the given [Encoding]. Returns a `Future<RandomAccessFile>` that completes with this random access file when the write completes."/>
<itemvalue="The callback provided to onChanged should update the state of the parent [StatefulWidget] using the [State.setState] method, so that the parent gets rebuilt; for example:"/>
<itemvalue="If null, the slider will be displayed as disabled."/>
<itemvalue="Called during a drag when the user is selecting a new value for the slider by dragging. The slider passes the new value to the callback but does not actually change state until the parent widget rebuilds the slider with the new value."/>
<itemvalue="It is safe to call [moveNext] after it has already returned `false`, but it must keep returning `false` and not have any other effect."/>
<itemvalue="Should be called before reading [current]. If the call to `moveNext` returns `true`, then [current] will contain the next element of the iteration until `moveNext` is called again. If the call returns `false`, there are no further elements and [current] should not be used any more."/>
<itemvalue="Whether the raster cache should be told that this painting is likely to change in the next frame. This hint tells the compositor not to cache the layer containing this widget because the cache will not be used in the future. If this hint is not set, the compositor will apply its own heuristics to decide whether the layer is likely to be reused in the future. This flag can't be set to true if both [painter] and [foregroundPainter] are null because this flag will be ignored in such case."/>
<itemvalue="Whether the painting is complex enough to benefit from caching. The compositor contains a raster cache that holds bitmaps of layers in order to avoid the cost of repeatedly rendering those layers on each frame. If this flag is not set, then the compositor will apply its own heuristics to decide whether the layer containing this widget is complex enough to benefit from caching. This flag can't be set to true if both [painter] and [foregroundPainter] are null because this flag will be ignored in such case."/>
<itemvalue="Synchronously creates a handle to an image of this picture. {@template dart.ui.painting.Picture.toImageSync} The returned image will be `width` pixels wide and `height` pixels high. The picture is rasterized within the 0 (left), 0 (top), `width` (right), `height` (bottom) bounds. Content outside these bounds is clipped. The image object is created and returned synchronously, but is rasterized asynchronously. If the rasterization fails, an exception will be thrown when the image is drawn to a [Canvas]. If a GPU context is available, this image will be created as GPU resident and not copied back to the host. This means the image will be more efficient to draw. If no GPU context is available, the image will be rasterized on the CPU. {@endtemplate}"/>
<itemvalue="Using [ImageByteFormat.rawRgba] on an image in the color space [ColorSpace.extendedSRGB] will result in the gamut being squished to fit into the sRGB gamut, resulting in the loss of wide-gamut colors."/>
<itemvalue="Either the [width] and [height] arguments should be specified, or the widget should be placed in a context that sets tight layout constraints. Otherwise, the image dimensions will change as the image is loaded, which will result in ugly layout changes."/>
<itemvalue="This only accepts compressed image formats (e.g. PNG). Uncompressed formats like rawRgba (the default format of [dart:ui.Image.toByteData]) will lead to exceptions."/>
<itemvalue="Creates a widget that displays an [ImageStream] obtained from a [Uint8List]. The `bytes` argument specifies encoded image bytes, which can be encoded in any of the following supported image formats: {@macro dart.ui.imageFormats}"/>
<itemvalue="Unencoded bytes, in the image's existing format. For example, a grayscale image may use a single 8-bit channel for each pixel."/>
<itemvalue="A loss-less compression format for images. This format is well suited for images with hard edges, such as screenshots or sprites, and images with text. Transparency is supported. The PNG format supports images up to 2,147,483,647 pixels in either dimension, though in practice available memory provides a more immediate limitation on maximum image size."/>
<itemvalue="Raw RGBA format. Unencoded bytes, in RGBA row-primary form with premultiplied alpha, 8 bits per channel."/>
<itemvalue="Parses the [host] as an IP version 4 (IPv4) address, returning the address as a list of 4 bytes in network byte order (big endian). Throws a [FormatException] if [host] is not a valid IPv4 address representation."/>
<itemvalue="The port part of the authority component. The value is the default port if there is no port number in the authority component. That's 80 for http, 443 for https, and 0 for everything else."/>
<itemvalue="Each pixel is 32 bits, with the highest 8 bits encoding red, the next 8 bits encoding green, the next 8 bits encoding blue, and the lowest 8 bits encoding alpha. Premultiplied alpha is used."/>
<itemvalue="Creates an image descriptor from raw image pixels. The `pixels` parameter is the pixel data. They are packed in bytes in the order described by `pixelFormat`, then grouped in rows, from left to right, then top to bottom. The `rowBytes` parameter is the number of bytes consumed by each row of pixels in the data buffer. If unspecified, it defaults to `width` multiplied by the number of bytes per pixel in the provided `format`. Not async because there's no expensive work to do here."/>
