2D Sprite Animation & 2D Image component

So I wound up figuring this out. Oddly enough there is little to no documentation on how to go about creating Animators via script. So hopefully this helps the next person out some.

The overview is when I create Animator, I also have a script that lives on the same GameObject with the Image component.

 [ExecuteInEditMode]
 public class ImageSprite : MonoBehaviour
 {
     public bool SpriteChanged = false;
 
     /// <summary>
     /// Lates the update.
     /// </summary>
     public void LateUpdate()
     {
         if (SpriteChanged)
             OnSpriteChanged ();
         
     }
 
     /// <summary>
     /// Raises the sprite changed event.
     /// </summary>
     public void OnSpriteChanged()
     {
         Image.rectTransform.pivot = GetCurrentPivot();
         Image.SetNativeSize ();
         SpriteChanged = false;
     }
 
     /// <summary>
     /// Accecssor getter
     /// </summary>
     /// <value>The image.</value>
     private Image Image
     {
         get
         {
             return GetComponent<Image>();
         }
     }
 
     /// <summary>
     /// Gets the current pivot.
     /// </summary>
     /// <returns>The current pivot.</returns>
     private Vector2 GetCurrentPivot()
     {
         var i = Image;
         var pivot = i.sprite.pivot;
         var bounds = i.sprite.bounds;
 
         pivot.x /= bounds.size.x * i.sprite.pixelsPerUnit;
         pivot.y /= bounds.size.y * i.sprite.pixelsPerUnit;
 
         return pivot;
     }
 }

When I create the animator (via script), I have the animator tell the script to update the Image component. I could have done this w/ an event (they are easier to script), however whats not in the documentation is that Animator events are not executed in the editor! However, PPtrCurve bindings are, and for some unknown reason, Image.SetNativeSize () only works in LateUpdate anyway...

         /// <summary>
         /// Creates the sprite animation clip.
         /// </summary>
         /// <returns>The sprite animation clip.</returns>
         /// <param name="raw">Raw.</param>
         /// <param name="sprites">Sprites.</param>
         /// <param name="fps">Fps.</param>
         private static AnimationClip CreateSpriteAnimationClip(RawAnimationData raw, List<Sprite> sprites, int fps)
         {
             AnimationClip clip = new AnimationClip();
 
             // Setup the clip params
             clip.frameRate    = fps;
             clip.name         = raw.name;
             
             AnimationUtility.GetAnimationClipSettings(clip).loopTime = true;
             
             // Addthe initial sprite keyframes
             var frames = AddSpriteKeyframes (clip, raw, sprites);
 
             // Add the sprite changed flags
             AddSpriteChangedKeyframes (clip, frames);
 
             // Set the wrapping mode
             clip.wrapMode = raw.loop?WrapMode.Loop:WrapMode.Once;
             
             return clip;
         }
 
         /// <summary>
         /// Adds the sprite keyframes.
         /// </summary>
         /// <returns>The sprite keyframes.</returns>
         /// <param name="clip">Clip.</param>
         /// <param name="raw">Raw.</param>
         private static ObjectReferenceKeyframe[] AddSpriteKeyframes(AnimationClip clip, RawAnimationData raw, List<Sprite> sprites)
         {
             // Get the number of frames
             var framecount = raw.Frames.Count;
 
             // Init the binding
             EditorCurveBinding curveBinding = new EditorCurveBinding();
             curveBinding.type = typeof(Image);
             curveBinding.propertyName = "m_Sprite";
             
             ObjectReferenceKeyframe[] keyFrames = new ObjectReferenceKeyframe[framecount];
             
             float time = 0.0f;
             for (int i = 0; i < framecount; i++)
             {
                 var frameId = raw.Frames[i].x;
                 var duration = ((float)raw.Frames[i].y)/1000f;
                 
                 ObjectReferenceKeyframe kf = new ObjectReferenceKeyframe();
                 
                 kf.time    = time;
                 kf.value= sprites[frameId];
                 keyFrames[i] = kf;
                 time += duration;
             }
             
             AnimationUtility.SetObjectReferenceCurve(clip, curveBinding, keyFrames);
 
             return keyFrames;
         }
 
         /// <summary>
         /// Adds the sprite changed keyframes.
         /// </summary>
         /// <param name="clip">Clip.</param>
         /// <param name="keyFrames">Key frames.</param>
         private static void AddSpriteChangedKeyframes(AnimationClip clip, ObjectReferenceKeyframe[] keyFrames)
         {
             var props = EditorCurveBinding.PPtrCurve ("", typeof(ImageSprite), "SpriteChanged");
             
             Keyframe [] frames = new Keyframe[keyFrames.Length];
             
             for (var i=0; i<keyFrames.Length; i++)
             {
                 var frame = keyFrames[i];
                 
                 var e = new Keyframe();
                 e.time = frame.time;
                 e.value = 1.0f;
                 
                 frames[i] = e;
             }
             AnimationUtility.SetEditorCurve (clip, props, new AnimationCurve (frames));
         }