feat():第一次上传

Author: 聂彬

analysis_options_user.yaml

@@ -0,0 +1,81 @@
+# Specify analysis options.
+#
+# Until there are meta linter rules, each desired lint must be explicitly enabled.
+# See: https://github.com/dart-lang/linter/issues/288
+#
+# For a list of lints, see: http://dart-lang.github.io/linter/lints/
+# See the configuration guide for more
+# https://github.com/dart-lang/sdk/tree/master/pkg/analyzer#configuring-the-analyzer
+#
+# There are four similar analysis options files in the flutter repos:
+#   - analysis_options.yaml
+#   - packages/flutter/lib/analysis_options_user.yaml (this file)
+#   - https://github.com/flutter/plugins/blob/master/analysis_options.yaml
+#   - https://github.com/flutter/engine/blob/master/analysis_options.yaml
+#
+# This file contains the analysis options used by "flutter analyze" and the
+# dartanalyzer when analyzing code outside the flutter repository. It isn't named
+# 'analysis_options.yaml' because otherwise editors would use it when analyzing
+# the flutter tool itself.
+#
+# When editing, make sure you keep this and /analysis_options.yaml consistent.
+
+analyzer:
+  errors:
+    # treat missing required parameters as a warning (not a hint)
+    missing_required_param: warning
+
+linter:
+  rules:
+    # these rules are documented on and in the same order as
+    # the Dart Lint rules page to make maintenance easier
+    # https://github.com/dart-lang/linter/blob/master/example/all.yaml
+    # - always_declare_return_types
+    # - always_specify_types
+    # - annotate_overrides
+    # - avoid_as
+    - avoid_empty_else
+    - avoid_init_to_null
+    - avoid_return_types_on_setters
+    - avoid_web_libraries_in_flutter
+    - await_only_futures
+    - camel_case_types
+    - cancel_subscriptions
+    - close_sinks
+    # - comment_references # we do not presume as to what people want to reference in their dartdocs
+    # - constant_identifier_names # https://github.com/dart-lang/linter/issues/204
+    - control_flow_in_finally
+    - empty_constructor_bodies
+    - empty_statements
+    - hash_and_equals
+    - implementation_imports
+    # - invariant_booleans
+    # - iterable_contains_unrelated_type
+    - library_names
+    # - library_prefixes
+    # - list_remove_unrelated_type
+    # - literal_only_boolean_expressions
+    - non_constant_identifier_names
+    # - one_member_abstracts
+    # - only_throw_errors
+    # - overridden_fields
+    - package_api_docs
+    - package_names
+    - package_prefixed_library_names
+    - prefer_is_not_empty
+    # - prefer_mixin # https://github.com/dart-lang/language/issues/32
+    # - public_member_api_docs
+    - slash_for_doc_comments
+    # - sort_constructors_first
+    # - sort_unnamed_constructors_first
+    # - super_goes_last # no longer needed w/ Dart 2
+    - test_types_in_equals
+    - throw_in_finally
+    # - type_annotate_public_apis # subset of always_specify_types
+    - type_init_formals
+    # - unawaited_futures
+    - unnecessary_brace_in_string_interps
+    - unnecessary_getters_setters
+    - unnecessary_statements
+    - unrelated_type_equality_checks
+    - valid_regexps

animation.dart

@@ -0,0 +1,169 @@
+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/// The Flutter animation system.
+///
+/// To use, import `package:flutter/animation.dart`.
+///
+/// This library provides basic building blocks for implementing animations in
+/// Flutter. Other layers of the framework use these building blocks to provide
+/// advanced animation support for applications. For example, the widget library
+/// includes [ImplicitlyAnimatedWidget]s and [AnimatedWidget]s that make it easy
+/// to animate certain properties of a [Widget]. If those animated widgets are
+/// not sufficient for a given use case, the basic building blocks provided by
+/// this library can be used to implement custom animated effects.
+///
+/// This library depends only on core Dart libraries and the `physics.dart`
+/// library.
+///
+///
+/// ### Foundations: the Animation class
+///
+/// Flutter represents an animation as a value that changes over a given
+/// duration, and that value may be of any type. For example, it could be a
+/// [double] indicating the current opacity of a [Widget] as it fades out. Or,
+/// it could be the current background [Color] of a widget that transitions
+/// smoothly from one color to another. The current value of an animation is
+/// represented by an [Animation] object, which is the central class of the
+/// animation library. In addition to the current animation value, the
+/// [Animation] object also stores the current [AnimationStatus]. The status
+/// indicates whether the animation is currently conceptually running from the
+/// beginning to the end or the other way around. It may also indicate that the
+/// animation is currently stopped at the beginning or the end.
+///
+/// Other objects can register listeners on an [Animation] to be informed
+/// whenever the animation value and/or the animation status changes. A [Widget]
+/// may register such a *value* listener via [Animation.addListener] to rebuild
+/// itself with the current animation value whenever that value changes. For
+/// example, a widget might listen to an animation to update its opacity to the
+/// animation's value every time that value changes. Likewise, registering a
+/// *status* listener via [Animation.addStatusListener] may be useful to trigger
+/// another action when the current animation has ended.
+///
+/// As an example, the following video shows the changes over time in the
+/// current animation status and animation value for the opacity animation of a
+/// widget. This [Animation] is driven by an [AnimationController] (see next
+/// section). Before the animation triggers, the animation status is "dismissed"
+/// and the value is 0.0. As the value runs from 0.0 to 1.0 to fade in the
+/// widget, the status changes to "forward". When the widget is fully faded in
+/// at an animation value of 1.0 the status is "completed". When the animation
+/// triggers again to fade the widget back out, the animation status changes to
+/// "reverse" and the animation value runs back to 0.0. At that point the widget
+/// is fully faded out and the animation status switches back to "dismissed"
+/// until the animation is triggered again.
+///
+/// {@animation 420 100 https://flutter.github.io/assets-for-api-docs/assets/animation/animation_status_value.mp4}
+///
+/// Although you can't instantiate [Animation] directly (it is an abstract
+/// class), you can create one using an [AnimationController].
+///
+///
+/// ### Powering animations: AnimationController
+///
+/// An [AnimationController] is a special kind of [Animation] that advances its
+/// animation value whenever the device running the application is ready to
+/// display a new frame (typically, this rate is around 60 values per second).
+/// An [AnimationController] can be used wherever an [Animation] is expected. As
+/// the name implies, an [AnimationController] also provides control over its
+/// [Animation]: It implements methods to stop the animation at any time and to
+/// run it forward as well as in the reverse direction.
+///
+/// By default, an [AnimationController] increases its animation value linearly
+/// over the given duration from 0.0 to 1.0 when run in the forward direction.
+/// For many use cases you might want the value to be of a different type,
+/// change the range of the animation values, or change how the animation moves
+/// between values. This is achieved by wrapping the animation: Wrapping it in
+/// an [Animatable] (see below) changes the range of animation values to a
+/// different range or type (for example to animate [Color]s or [Rect]s).
+/// Furthermore, a [Curve] can be applied to the animation by wrapping it in a
+/// [CurvedAnimation]. Instead of linearly increasing the animation value, a
+/// curved animation changes its value according to the provided curve. The
+/// framework ships with many built-in curves (see [Curves]). As an example,
+/// [Curves.easeOutCubic] increases the animation value quickly at the beginning
+/// of the animation and then slows down until the target value is reached:
+///
+/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_cubic.mp4}
+///
+///
+/// ### Animating different types: Animatable
+///
+/// An `Animatable<T>` is an object that takes an `Animation<double>` as input
+/// and produces a value of type `T`. Objects of these types can be used to
+/// translate the animation value range of an [AnimationController] (or any
+/// other [Animation] of type [double]) to a different range. That new range
+/// doesn't even have to be of type double anymore. With the help of an
+/// [Animatable] like a [Tween] or a [TweenSequence] (see sections below) an
+/// [AnimationController] can be used to smoothly transition [Color]s, [Rect]s,
+/// [Size]s and many more types from one value to another over a given duration.
+///
+///
+/// ### Interpolating values: Tweens
+///
+/// A [Tween] is applied to an [Animation] of type [double] to change the
+/// range and type of the animation value. For example, to transition the
+/// background of a [Widget] smoothly between two [Color]s, a [ColorTween] can
+/// be used. Each [Tween] specifies a start and an end value. As the animation
+/// value of the [Animation] powering the [Tween] progresses from 0.0 to 1.0 it
+/// produces interpolated values between its start and end value. The values
+/// produced by the [Tween] usually move closer and closer to its end value as
+/// the animation value of the powering [Animation] approaches 1.0.
+///
+/// The following video shows example values produced by an [IntTween], a
+/// `Tween<double>`, and a [ColorTween] as the animation value runs from 0.0 to
+/// 1.0 and back to 0.0:
+///
+/// {@animation 530 150 https://flutter.github.io/assets-for-api-docs/assets/animation/tweens.mp4}
+///
+/// An [Animation] or [AnimationController] can power multiple [Tween]s. For
+/// example, to animate the size and the color of a widget in parallel, create
+/// one [AnimationController] that powers a [SizeTween] and a [ColorTween].
+///
+/// The framework ships with many [Tween] subclasses ([IntTween], [SizeTween],
+/// [RectTween], etc.) to animate common properties.
+///
+///
+/// ### Staggered animations: TweenSequences
+///
+/// A [TweenSequence] can help animate a given property smoothly in stages. Each
+/// [Tween] in the sequence is responsible for a different stage and has an
+/// associated weight. When the animation runs, the stages execute one after
+/// another. For example, let's say you want to animate the background of a
+/// widget from yellow to green and then, after a short pause, to red. For this
+/// you can specify three tweens within a tween sequence: One [ColorTween]
+/// animating from blue to green, one [ConstantTween] that just holds the color
+/// green, and another [ColorTween] animating from green to yellow. For each
+/// tween you need to pick a weight indicating the ratio of time spent on that
+/// tween compared to all other tweens. If we assign a weight of 2 to both of
+/// the [ColorTween]s and a weight of 1 to the [ConstantTween] the transition
+/// described by the [ColorTween]s would take twice as long as the
+/// [ConstantTween]. A [TweenSequence] is driven by an [Animation] just like a
+/// regular [Tween]: As the powering [Animation] runs from 0.0 to 1.0 the
+/// [TweenSequence] runs through all of its stages.
+///
+/// The following video shows the animation described in the previous paragraph:
+///
+/// {@animation 646 250 https://flutter.github.io/assets-for-api-docs/assets/animation/tween_sequence.mp4}
+///
+///
+/// See also:
+///
+///  * [Introduction to animations](https://flutter.dev/docs/development/ui/animations)
+///    on flutter.dev.
+///  * [Animations tutorial](https://flutter.dev/docs/development/ui/animations/tutorial)
+///    on flutter.dev.
+///  * [Sample app](https://github.com/flutter/samples/tree/master/animations),
+///    which showcases Flutter's animation features.
+///  * [ImplicitlyAnimatedWidget] and its subclasses, which are [Widget]s that
+///    implicitly animate changes to their properties.
+///  * [AnimatedWidget] and its subclasses, which are [Widget]s that take an
+///    explicit [Animation] to animate their properties.
+library animation;
+
+export 'src/animation/animation.dart';
+export 'src/animation/animation_controller.dart';
+export 'src/animation/animations.dart';
+export 'src/animation/curves.dart';
+export 'src/animation/listener_helpers.dart';
+export 'src/animation/tween.dart';
+export 'src/animation/tween_sequence.dart';