public static AnimatorSet CreateMovementAnimation(View view, float canvasX, float canvasY, float offsetStartX, float offsetStartY, float offsetEndX, float offsetEndY, EventHandler animationEndHandler)
{
view.Alpha = INVISIBLE;
var alphaIn = ObjectAnimator.OfFloat(view, ALPHA, INVISIBLE, VISIBLE).SetDuration(500);
var setUpX = ObjectAnimator.OfFloat(view, COORD_X, canvasX + offsetStartX).SetDuration(INSTANT);
var setUpY = ObjectAnimator.OfFloat(view, COORD_Y, canvasY + offsetStartY).SetDuration(INSTANT);
var moveX = ObjectAnimator.OfFloat(view, COORD_X, canvasX + offsetEndX).SetDuration(1000);
var moveY = ObjectAnimator.OfFloat(view, COORD_Y, canvasY + offsetEndY).SetDuration(1000);
moveX.StartDelay = 1000;
moveY.StartDelay = 1000;
var alphaOut = ObjectAnimator.OfFloat(view, ALPHA, INVISIBLE).SetDuration(500);
alphaOut.StartDelay = 2500;
var aset = new AnimatorSet();
aset.Play(setUpX).With(setUpY).Before(alphaIn).Before(moveX).With(moveY).Before(alphaOut);
var handler = new Handler();
handler.PostDelayed(() =>
{
animationEndHandler(view, EventArgs.Empty);
}, 3000);
return aset;
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
//HasOptionsMenu = true;
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.activity_main);
Button botonAnimado = FindViewById <Button>(Resource.Id.botonanimado);
botonAnimado.SetWidth(300);
ObjectAnimator objectAnimator = ObjectAnimator.OfInt(botonAnimado, "width", 400, 250, 400);
objectAnimator.SetDuration(3000);
objectAnimator.SetInterpolator(new LinearInterpolator());
objectAnimator.RepeatCount = 100;
//objectAnimator.Start();
ObjectAnimator objectAnimator1 = ObjectAnimator.OfInt(botonAnimado, "height", 220, 70, 220);
objectAnimator1.SetDuration(3000);
objectAnimator1.SetInterpolator(new LinearInterpolator());
objectAnimator1.RepeatCount = 100;
ObjectAnimator objectAnimator2 = ObjectAnimator.OfFloat(botonAnimado, "rotationY", 0, 360);
objectAnimator2.SetDuration(10000);
objectAnimator2.SetInterpolator(new LinearInterpolator());
objectAnimator2.RepeatCount = 100;
objectAnimator2.Update += (sender, e) => {
if ((float)e.Animation.AnimatedValue >= 90 && (float)e.Animation.AnimatedValue <= 270)
{
botonAnimado.Text = "";
}
else
{
botonAnimado.Text = "Boton animado";
}
};
AnimatorSet ans = new Android.Animation.AnimatorSet();
ans.PlayTogether(objectAnimator, objectAnimator1, objectAnimator2);//,);
ans.Start();
//Animator animator = AnimatorInflater.LoadAnimator(this, Resource.Animator.property);
//animator.SetTarget(botonAnimado);
//animator.Start();
}
void DoAnimation2 (bool really, Action changePic)
{
if (!really)
changePic ();
else {
var fdIn = ObjectAnimator.OfFloat (this, "alpha", new float[] { 0, 1 });
var fdOut = ObjectAnimator.OfFloat (this, "alpha", new float[] { 1, 0 });
fdOut.AnimationEnd += (sender, e) => changePic ();
var animator = new AnimatorSet ();
animator.SetInterpolator (new LinearInterpolator ());
//animator.PlaySequentially (fdOut, fdIn);
animator.Play (fdOut);
animator.Play (fdIn).After (fdOut).After (2000);
animator.Start ();
}
}
public static Animator OfPoints(Java.Lang.Object objects, String xMethod, String yMethod, Point[] values)
{
var set = new AnimatorSet();
var xValues = new int[values.Length];
var yValues = new int[values.Length];
for (int i = 0; i < values.Length; i++)
{
xValues[i] = values[i].X;
yValues[i] = values[i].Y;
}
ObjectAnimator xAnimator = ObjectAnimator.OfInt(objects, xMethod, xValues);
ObjectAnimator yAnimator = ObjectAnimator.OfInt(objects, yMethod, yValues);
set.PlayTogether(xAnimator, yAnimator);
return set;
}
void Initialize ()
{
ScaleX = ScaleY = 1;
var baseDuration = 1000;
animation = new AnimatorSet ();
var rotation = ObjectAnimator.OfFloat (this, "rotation", 0, 60);
rotation.SetDuration (baseDuration);
rotation.RepeatCount = ValueAnimator.Infinite;
var scale = ObjectAnimator.OfPropertyValuesHolder (
this,
PropertyValuesHolder.OfFloat ("scaleX", 1, .9f),
PropertyValuesHolder.OfFloat ("scaleY", 1, .9f)
);
scale.RepeatMode = ValueAnimatorRepeatMode.Reverse;
scale.SetDuration (baseDuration / 2);
scale.RepeatCount = ValueAnimator.Infinite;
animation.PlayTogether (rotation, scale);
animation.Start ();
}
void _fadeOut_AnimationEnd (object sender, EventArgs e)
{
this._Token.Cancel ();
this._Token.Dispose ();
this._Token = null;
_Layout.Touch -= LayoutTouched;
_Layout.Visibility = ViewStates.Gone;
_fadeOut.AnimationEnd -= _fadeOut_AnimationEnd;
_Set.Dispose ();
_Set = null;
_fadeOut.RemoveAllListeners ();
_fadeOut.Dispose ();
_fadeOut = null;
_Layout.Dispose ();
_Layout = null;
}
protected override void OnFinishInflate()
{
base.OnFinishInflate();
label = FindViewById<TextView>(Resource.Id.Label);
circle = FindViewById<CircledImageView>(Resource.Id.Circle);
expandCircleRadius = circle.CircleRadius;
shrinkCircleRadius = expandCircleRadius * ShrinkCricleRatio;
shrinkCircleAnimator = ObjectAnimator.OfFloat(circle, "circleRadius", expandCircleRadius, shrinkCircleRadius);
shrinkLabelAnimator = ObjectAnimator.OfFloat(label, "alpha", ExpandLabelAlpha, ShrinkLabelAlpha);
// FIXME Xamarin: new AnimatorSet().SetDuration(long) should return an AnimatorSet
shrinkAnimator = new AnimatorSet();
shrinkAnimator.SetDuration(AnimationDurationMs);
shrinkAnimator.PlayTogether(shrinkCircleAnimator, shrinkLabelAnimator);
expandCircleAnimator = ObjectAnimator.OfFloat(circle, "circleRadius", shrinkCircleRadius, expandCircleRadius);
expandLabelAnimator = ObjectAnimator.OfFloat(label, "alpha", ShrinkLabelAlpha, ExpandLabelAlpha);
expandAnimator = new AnimatorSet();
expandAnimator.SetDuration(AnimationDurationMs);
expandAnimator.PlayTogether(expandCircleAnimator, expandLabelAnimator);
}
private static IntPtr n_SetDuration_J(IntPtr jnienv, IntPtr native__this, long duration)
{
AnimatorSet @object = Java.Lang.Object.GetObject <AnimatorSet> (native__this, JniHandleOwnership.DoNotTransfer) !;
return(JNIEnv.ToJniHandle(@object.SetDuration(duration)));
}
/**
* Performs the undo animation and restores the original state for given {@link android.view.View}.
*
* @param view the parent {@code View} which contains both primary and undo {@code View}s.
*/
public void undo( View view) {
int position = AdapterViewUtil.getPositionForView(getListViewWrapper(), view);
mUndoPositions.Remove(position);
View primaryView = mCallback.getPrimaryView(view);
View undoView = mCallback.getUndoView(view);
primaryView.Visibility=ViewStates.Visible;
ObjectAnimator undoAlphaAnimator = ObjectAnimator.OfFloat(undoView, ALPHA, 1f, 0f);
ObjectAnimator primaryAlphaAnimator = ObjectAnimator.OfFloat(primaryView, ALPHA, 0f, 1f);
ObjectAnimator primaryXAnimator = ObjectAnimator.OfFloat(primaryView, TRANSLATION_X, primaryView.Width, 0f);
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.PlayTogether(undoAlphaAnimator, primaryAlphaAnimator, primaryXAnimator);
animatorSet.AddListener(new UndoAnimatorListener(undoView,this));
animatorSet.Start();
mCallback.onUndo(view, position);
}
public void SetCount(int count, bool animate)
{
if (!animate) {
Count = count;
return;
}
ValueAnimator outAnimator = null;
if (this.count != 0) {
outAnimator = ValueAnimator.OfInt (255, 0);
outAnimator.SetDuration (250);
outAnimator.Update += (sender, e) => { currentBubbleTransparency = (int)e.Animation.AnimatedValue; Invalidate (); };
outAnimator.AnimationEnd += (sender, e) => { this.count = count; outAnimator.RemoveAllListeners (); };
} else {
this.count = count;
}
var inAnimator = ValueAnimator.OfInt (0, 255);
inAnimator.SetDuration (700);
inAnimator.Update += (sender, e) => { currentBubbleTransparency = (int)e.Animation.AnimatedValue; Invalidate (); };
inAnimator.AnimationEnd += (sender, e) => inAnimator.RemoveAllListeners ();
if (outAnimator != null) {
var set = new AnimatorSet ();
set.PlaySequentially (outAnimator, inAnimator);
set.Start ();
} else {
inAnimator.Start ();
}
}
/**
* A helper method to build scale up animation;
*
* @param target
* @param targetScaleX
* @param targetScaleY
* @return
*/
private AnimatorSet buildScaleUpAnimation(View target, float targetScaleX, float targetScaleY)
{
AnimatorSet scaleUp = new AnimatorSet();
scaleUp.PlayTogether(
ObjectAnimator.OfFloat(target, "scaleX", targetScaleX),
ObjectAnimator.OfFloat(target, "scaleY", targetScaleY)
);
if (mUse3D)
{
scaleUp.PlayTogether(ObjectAnimator.OfFloat(target, "rotationY", 0));
}
scaleUp.SetDuration(250);
return scaleUp;
}
private void Switch (Drawable src, ColorStateList tint, bool withAnimation = false)
{
if (!withAnimation) {
SetImageDrawable (src);
BackgroundTintList = tint;
return;
}
const int ScaleDuration = 200;
const int InitialDelay = 100;
if (switchAnimation != null) {
switchAnimation.Cancel ();
switchAnimation = null;
}
var currentSrc = Drawable;
// Scaling down animation
var circleAnimOutX = ObjectAnimator.OfFloat (this, "scaleX", 1, 0.1f);
var circleAnimOutY = ObjectAnimator.OfFloat (this, "scaleY", 1, 0.1f);
circleAnimOutX.SetDuration (ScaleDuration);
circleAnimOutY.SetDuration (ScaleDuration);
// Alpha out of the icon
//var iconAnimOut = ObjectAnimator.OfInt (currentSrc, "alpha", 255, 0);
//iconAnimOut.SetDuration (AlphaDuration);
var outSet = new AnimatorSet ();
outSet.PlayTogether (circleAnimOutX, circleAnimOutY);
outSet.SetInterpolator (AnimationUtils.LoadInterpolator (Context,
Android.Resource.Animation.AccelerateInterpolator));
outSet.StartDelay = InitialDelay;
outSet.AnimationEnd += (sender, e) => {
BackgroundTintList = tint;
SetImageDrawable (src);
JumpDrawablesToCurrentState ();
((Animator)sender).RemoveAllListeners ();
};
// Scaling up animation
var circleAnimInX = ObjectAnimator.OfFloat (this, "scaleX", 0.1f, 1);
var circleAnimInY = ObjectAnimator.OfFloat (this, "scaleY", 0.1f, 1);
circleAnimInX.SetDuration (ScaleDuration);
circleAnimInY.SetDuration (ScaleDuration);
var inSet = new AnimatorSet ();
inSet.PlayTogether (circleAnimInX, circleAnimInY);
inSet.SetInterpolator (AnimationUtils.LoadInterpolator (Context,
Android.Resource.Animation.DecelerateInterpolator));
switchAnimation = new AnimatorSet ();
switchAnimation.PlaySequentially (outSet, inSet);
switchAnimation.Start ();
}
/**
* Animates the pending {@link android.view.View} back to its original position.
*/
private void restoreCurrentViewTranslation()
{
if (mCurrentView == null)
{
return;
}
ObjectAnimator xAnimator = ObjectAnimator.OfFloat(mSwipingView, TRANSLATION_X, 0);
ObjectAnimator alphaAnimator = ObjectAnimator.OfFloat(mSwipingView, ALPHA, 1);
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.PlayTogether(xAnimator, alphaAnimator);
animatorSet.SetDuration(mAnimationTime);
animatorSet.AddListener(new RestoreAnimatorListener(mCurrentView, mCurrentPosition,this));
animatorSet.Start();
}
public void FreeFall()
{
ObjectAnimator objectAnimator = ObjectAnimator.OfFloat(shapeLoadingView, "translationY", 0, mDistance);
ObjectAnimator scaleIndication = ObjectAnimator.OfFloat(indicationIm, "scaleX", 1, 0.2f);
objectAnimator.SetDuration(ANIMATION_DURATION);
objectAnimator.SetInterpolator(new AccelerateInterpolator());
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.SetDuration(ANIMATION_DURATION);
animatorSet.PlayTogether(objectAnimator, scaleIndication);
animatorSet.AnimationEnd += (e, s) =>
{
shapeLoadingView.ChangeShape();
UpThrow();
};
animatorSet.Start();
}
public async Task Show(TopAlert alert)
{
await Stop ();
this._Token = new CancellationTokenSource ();
this._Delay = alert.Duration;
var activity = Xamarin.Forms.Forms.Context as Android.App.Activity;
IWindowManager windowManager = Xamarin.Forms.Forms.Context.GetSystemService(Android.App.Service.WindowService).JavaCast<IWindowManager>();
this._Layout = (LinearLayout)activity.LayoutInflater.Inflate(Resource.Layout.AlertBox, null, false);
this._Layout.LayoutParameters = new ViewGroup.LayoutParams (ViewGroup.LayoutParams.MatchParent, ViewGroup.LayoutParams.MatchParent);
var submain = this._Layout.FindViewById<LinearLayout> (Resource.Id.linearLayout3);
submain.SetBackgroundColor (alert.BackgroundColor.ToAndroid());
var main = _Layout.FindViewById<LinearLayout> (Resource.Id.linearLayout1);
var id = Xamarin.Forms.Forms.Context.Resources.GetIdentifier ("alertborder", "drawable", Xamarin.Forms.Forms.Context.PackageName);
Android.Graphics.Drawables.GradientDrawable drawable =
Xamarin.Forms.Forms.Context.Resources.GetDrawable (id).JavaCast<Android.Graphics.Drawables.GradientDrawable>();
var text = submain.FindViewById<TextView> (Resource.Id.textView1);
text.SetTextColor (alert.TextColor.ToAndroid ());
text.Text = alert.Text;
if (alert.TextSize > 0) {
text.TextSize = alert.TextSize;
}
drawable.SetColor (alert.BorderColor.ToAndroid ());
drawable.SetCornerRadius (alert.BorderWidth);
main.SetBackground (drawable);
//activity.ActionBar.Hide ();
var actionBarHeight = activity.ActionBar.Height;
var intent = alert.Intent;
var p = new WindowManagerLayoutParams (
windowManager.DefaultDisplay.Width - intent * 2,
(alert.AlertHeight < 0 ? 200 : (int)alert.AlertHeight),
WindowManagerTypes.SystemAlert,
0 | WindowManagerFlags.NotFocusable,
Android.Graphics.Format.Translucent);
var yOffset = alert.TopOffset;
p.Gravity = GravityFlags.Top | GravityFlags.Left;
p.X = intent;
p.Y = alert.TopOffset + yOffset + (activity.ActionBar.IsShowing ? actionBarHeight : 0);
p.Height = (alert.AlertHeight < 0 ? 200 : (int)alert.AlertHeight);
windowManager.AddView (_Layout, p);
this._Layout.Touch += LayoutTouched;
Task.Run (async() => {
await Task.Delay(alert.Duration, this._Token.Token);
if (this._Token != null && this._Token.IsCancellationRequested == false)
{
if(alert.FadeOut)
{
Xamarin.Forms.Device.BeginInvokeOnMainThread( () => {
// this works
this._fadeOut = ObjectAnimator.OfFloat(_Layout, "alpha", 1f, 0f);
this._fadeOut.SetDuration(1000);
this._fadeOut.AnimationEnd += _fadeOut_AnimationEnd;
this._Set = new AnimatorSet();
this._Set.Play(_fadeOut);
this._Set.Start();
});
}
else
{
Stop();
}
}
});
}
private async void OnRequestOnboardingPage(OnboardingViewModel oVm)
{
_viewModel = oVm;
AnimationInitUI();
BindEvents();
var mainAnimatorSet = new AnimatorSet();
var appNameLayoutFinalTopSpace = TypedValue.ApplyDimension(ComplexUnitType.Dip, 55.0f, Application.Context.Resources.DisplayMetrics);
var decelerateInterpolator = new DecelerateInterpolator(1.0f);
var appNameLayoutAnimator = new ValueAnimator();
appNameLayoutAnimator.SetDuration(750);
appNameLayoutAnimator.SetInterpolator(decelerateInterpolator);
appNameLayoutAnimator.SetFloatValues(_appNameLayout.GetY(), appNameLayoutFinalTopSpace);
appNameLayoutAnimator.Update += (o, args) => { _appNameLayout.SetY((float)args.Animation.AnimatedValue); };
var whatAccountsAnimator = new ValueAnimator();
whatAccountsAnimator.SetDuration(750);
whatAccountsAnimator.SetInterpolator(decelerateInterpolator);
whatAccountsAnimator.SetFloatValues(0.0f, 1.0f);
whatAccountsAnimator.Update += (o, args) => { _whatAccounts.Alpha = (float)args.Animation.AnimatedValue; };
var appNameAnimationSet = new AnimatorSet();
appNameAnimationSet.PlayTogether(appNameLayoutAnimator, whatAccountsAnimator);
var socialButtonsAnimatorSet = new AnimatorSet();
var overshootInterpolator = new OvershootInterpolator(3f);
var facebookButtonAnimator = new ValueAnimator();
facebookButtonAnimator.SetDuration(500);
facebookButtonAnimator.SetInterpolator(overshootInterpolator);
facebookButtonAnimator.SetFloatValues(_facebookButton.GetY() + _facebookButton.Height, _facebookButton.GetY());
facebookButtonAnimator.Update += (o, args) =>
{
_facebookButton.SetY((float)args.Animation.AnimatedValue);
_facebookButton.Alpha = args.Animation.AnimatedFraction;
};
var twitterButtonAnimator = new ValueAnimator();
twitterButtonAnimator.SetDuration(500);
twitterButtonAnimator.SetInterpolator(overshootInterpolator);
twitterButtonAnimator.SetFloatValues(_facebookButton.GetY() + _facebookButton.Height, _facebookButton.GetY());
twitterButtonAnimator.Update += (o, args) =>
{
_twitterButton.SetY((float)args.Animation.AnimatedValue);
_twitterButton.Alpha = args.Animation.AnimatedFraction;
};
socialButtonsAnimatorSet.PlaySequentially(facebookButtonAnimator, twitterButtonAnimator);
socialButtonsAnimatorSet.StartDelay = 500;
var letsGoButtonAnimator = new ValueAnimator();
letsGoButtonAnimator.SetDuration(500);
letsGoButtonAnimator.SetInterpolator(decelerateInterpolator);
letsGoButtonAnimator.SetFloatValues(0.0f, 1.0f);
letsGoButtonAnimator.Update += (sender, args) =>
{
_goButton.Alpha = (float)args.Animation.AnimatedValue;
};
mainAnimatorSet.PlaySequentially(appNameAnimationSet, socialButtonsAnimatorSet, letsGoButtonAnimator);
await _viewModel.DidLoad();
await Task.Delay(2000);
mainAnimatorSet.Start();
await _viewModel.DidAppear();
}
/// <summary>
/// Playes a series of animations.
/// </summary>
/// <param name="animations">The series of animations to be played.</param>
protected void PlayAnimations(ObjectAnimator[] animations)
{
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.PlaySequentially(animations);
animatorSet.Start();
//animatorSet.AnimationEnd
//animatorSet.Pause
}
public void SpotAnimateAllPositionsOfANote(Note note)
{
List<ObjectAnimator> animationsList = new List<ObjectAnimator>();
foreach (Position position in note.Positions)
{
//Create a new visual representation of that note.
NoteRepresentation noteRep = new NoteRepresentation(_activity, note);
//Set name on note.
noteRep.SetText(note.Name);
//Create the note's animation, and add that animation to the animations array.
animationsList.Add(noteRep.CreateNoteAnimation_FadeOnly(position));
}
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.PlayTogether(animationsList.ToArray());
animatorSet.Start();
}
private AnimatorSet GetAnimatorSet(int idx, bool expand)
{
AnimatorSet set = null;
var avgRadians = this.ToRadians(360 / (this.ChildCount - 1));
var w = Math.Min(this.MeasuredWidth, this.MeasuredHeight) / 2;
var cx = this.MeasuredWidth / 2;
var cy = this.MeasuredHeight / 2;
var c = this.GetChildAt(idx);
var radians = idx * avgRadians;
var hw = c.MeasuredWidth / 2;
var hy = c.MeasuredHeight / 2;
var tmp = (w - hw);
var l = w + (int)Math.Round(tmp * Math.Cos(radians) - hw);
var t = w + (int)Math.Round(tmp * Math.Sin(radians) - hw);
var duration = new Random(1000).Next(200, 1000);
set = new AnimatorSet();
set.SetInterpolator(new Android.Views.Animations.BounceInterpolator());
set.SetTarget(c);
set.SetDuration(200 * idx + duration);
//set.SetDuration(200);
float[] xs = new float[] { cx - hw, l };
float[] ys = new float[] { cy - hy, t };
float[] ss = new float[] { 0.1f, 1 };
if (!expand) {
Array.Reverse(xs);
Array.Reverse(ys);
Array.Reverse(ss);
}
var aniX = ObjectAnimator.OfFloat(c, "X", xs);
var aniY = ObjectAnimator.OfFloat(c, "Y", ys);
var aniSX = ObjectAnimator.OfFloat(c, "ScaleX", ss);
var aniSY = ObjectAnimator.OfFloat(c, "ScaleY", ss);
aniX.SetAutoCancel(true);
aniY.SetAutoCancel(true);
aniSX.SetAutoCancel(true);
aniSY.SetAutoCancel(true);
set.PlayTogether(aniX, aniY, aniSX, aniSY);
set.AnimationEnd += Set_AnimationEnd;
return set;
}
private void PlayAnimation()
{
var animator = ObjectAnimator.OfFloat (this, "animationSeek", 0.0f, 1.0f);
var animatorSet = new AnimatorSet ();
animatorSet.SetDuration (AnimationDuration);
animatorSet.SetInterpolator (new DecelerateInterpolator ());
animatorSet.SetTarget (this);
animatorSet.Play(animator);
animatorSet.Start();
}
private AnimatorSet buildMenuAnimation(View target, float alpha)
{
AnimatorSet alphaAnimation = new AnimatorSet();
alphaAnimation.PlayTogether(
ObjectAnimator.OfFloat(target, "alpha", alpha)
);
alphaAnimation.SetDuration(250);
return alphaAnimation;
}
public void UpThrow()
{
ObjectAnimator objectAnimator = ObjectAnimator.OfFloat(shapeLoadingView, "translationY", mDistance, 0);
ObjectAnimator scaleIndication = ObjectAnimator.OfFloat(indicationIm, "scaleX", 0.2f, 1);
ObjectAnimator objectAnimator1 = null;
switch(shapeLoadingView.GetShape())
{
case ShapeLoadingView.Shape.RECT:
{
objectAnimator1 = ObjectAnimator.OfFloat(shapeLoadingView, "rotation", 0, -120);
}
break;
case ShapeLoadingView.Shape.CIRCLE:
{
objectAnimator1 = ObjectAnimator.OfFloat(shapeLoadingView, "rotation", 0, 180);
}
break;
case ShapeLoadingView.Shape.TRIANGLE:
{
objectAnimator1 = ObjectAnimator.OfFloat(shapeLoadingView, "rotation", 0, 180);
}
break;
}
objectAnimator.SetDuration(ANIMATION_DURATION);
objectAnimator1.SetDuration(ANIMATION_DURATION);
objectAnimator.SetInterpolator(new DecelerateInterpolator());
objectAnimator1.SetInterpolator(new DecelerateInterpolator());
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.SetDuration(ANIMATION_DURATION);
animatorSet.PlayTogether(objectAnimator, objectAnimator1, scaleIndication);
animatorSet.AnimationEnd += (e, s) =>
{
FreeFall();
};
animatorSet.Start();
}
public void AnimateXAndWidth (Frame newFrame, Action completed)
{
ObjectAnimator xAnim = ObjectAnimator.OfFloat (this, LEFT_MARGIN, (float)Frame.X, (float)newFrame.X);
ObjectAnimator wAnim = ObjectAnimator.OfInt (this, NEW_WIDTH, Frame.W, newFrame.W);
AnimatorSet set = new AnimatorSet ();
set.SetDuration (FRAMEANIMATIONTIME);
set.PlayTogether (new ObjectAnimator[] { xAnim, wAnim });
set.Start ();
set.AnimationEnd += delegate {
completed ();
};
}
public void Reset (SummaryReportView data)
{
this.data = data;
// Cancel old animation
if (currentRevealAnimation != null) {
currentRevealAnimation.Cancel ();
currentRevealAnimation = null;
}
if (currentSelectAnimation != null) {
currentSelectAnimation.Cancel ();
currentSelectAnimation = null;
}
var totalSlices = data == null || data.CollapsedProjects == null ? 0 : data.CollapsedProjects.Count;
SetActiveSlice (-1, updateStats: false);
backgroundView.Visibility = ViewStates.Visible;
backgroundView.Radius = defaultRadius;
ResetSlices (totalSlices);
if (totalSlices > 0) {
var totalTime = data.CollapsedProjects.Sum (x => x.TotalTime);
var startAngle = 0f;
for (var i = 0; i < totalSlices; i++) {
var slice = slices [i];
var project = data.CollapsedProjects [i];
var percentOfAll = (float)project.TotalTime / totalTime;
slice.Visibility = ViewStates.Gone;
slice.Radius = defaultRadius;
if (project.Color == ProjectModel.GroupedProjectColorIndex) {
slice.Color = Color.ParseColor (ProjectModel.GroupedProjectColor);
} else {
slice.Color = Color.ParseColor (ProjectModel.HexColors [project.Color % ProjectModel.HexColors.Length]);
}
slice.StartAngle = startAngle;
startAngle += percentOfAll * 360;
}
}
// Detect state
var isLoading = data == null || data.IsLoading;
var isEmpty = !isLoading && totalSlices == 0;
if (isLoading) {
// Loading state
loadingOverlayView.Visibility = ViewStates.Visible;
loadingOverlayView.Alpha = 1f;
emptyOverlayView.Visibility = ViewStates.Gone;
statsOverlayView.Visibility = ViewStates.Gone;
} else if (isEmpty) {
// Error state
loadingOverlayView.Visibility = ViewStates.Visible;
loadingOverlayView.Alpha = 1f;
emptyOverlayView.Visibility = ViewStates.Visible;
emptyOverlayView.Alpha = 0f;
statsOverlayView.Visibility = ViewStates.Gone;
// Animate overlay in
var scene = new AnimatorSet ();
var fadeIn = ObjectAnimator.OfFloat (emptyOverlayView, "alpha", 0f, 1f).SetDuration (500);
var fadeOut = ObjectAnimator.OfFloat (loadingOverlayView, "alpha", 1f, 0f).SetDuration (500);
fadeOut.AnimationEnd += delegate {
loadingOverlayView.Visibility = ViewStates.Gone;
};
scene.Play (fadeOut);
scene.Play (fadeIn).After (3 * fadeOut.Duration / 4);
currentRevealAnimation = scene;
scene.Start();
} else {
// Normal state
var scene = new AnimatorSet ();
// Fade loading message out
statsOverlayView.Visibility = ViewStates.Visible;
statsOverlayView.Alpha = 0f;
var fadeOverlayOut = ObjectAnimator.OfFloat (loadingOverlayView, "alpha", 1f, 0f).SetDuration (500);
fadeOverlayOut.AnimationEnd += delegate {
loadingOverlayView.Visibility = ViewStates.Gone;
};
scene.Play (fadeOverlayOut);
var fadeOverlayIn = ObjectAnimator.OfFloat (statsOverlayView, "alpha", 0f, 1f).SetDuration (500);
scene.Play (fadeOverlayIn).After (3 * fadeOverlayOut.Duration / 4);
var donutReveal = ValueAnimator.OfFloat (0, 360);
donutReveal.SetDuration (750);
donutReveal.Update += (sender, e) => ShowSlices ((float)e.Animation.AnimatedValue);
scene.Play (donutReveal).After (fadeOverlayOut.Duration / 2);
currentRevealAnimation = scene;
scene.Start();
}
UpdateStats ();
RequestLayout ();
}
public static AnimatorSet CreateMovementAnimation(View view, float x, float y)
{
var alphaIn = ObjectAnimator.OfFloat(view, ALPHA, INVISIBLE, VISIBLE).SetDuration(500);
var setUpX = ObjectAnimator.OfFloat(view, COORD_X, x).SetDuration(INSTANT);
var setUpY = ObjectAnimator.OfFloat(view, COORD_Y, y).SetDuration(INSTANT);
var aset = new AnimatorSet();
aset.Play(setUpX).With(setUpY).Before(alphaIn);
return aset;
}
/**
* Flings given {@link android.view.View} out of sight.
*
* @param view the parent {@link android.view.View}.
* @param position the position of the item in the {@link android.widget.ListAdapter} corresponding to the {@code View}.
* @param flingToRight {@code true} if the {@code View} should be flinged to the right, {@code false} if it should be flinged to the left.
*/
private void flingView(View view, int position, bool flingToRight)
{
if (mViewWidth < 2)
{
mViewWidth = mListViewWrapper.getListView().Width;
}
View swipeView = getSwipeView(view);
ObjectAnimator xAnimator = ObjectAnimator.OfFloat(swipeView, TRANSLATION_X, flingToRight ? mViewWidth : -mViewWidth);
ObjectAnimator alphaAnimator = ObjectAnimator.OfFloat(swipeView, ALPHA, 0);
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.PlayTogether(xAnimator, alphaAnimator);
animatorSet.SetDuration(mAnimationTime);
animatorSet.AddListener(new FlingAnimatorListener(view, position,this));
animatorSet.Start();
}
public void shift(View view) {
if (!mShifted) {
foreach (ImageView imageView in mImageViews) {
ObjectAnimator tx = ObjectAnimator.OfFloat(imageView, View.X, (mRandom.NextFloat() - 0.5f) * 500);
tx.AddUpdateListener(new AnimListener(mBlurringView));
ObjectAnimator ty = ObjectAnimator.OfFloat(imageView, View.Y, (mRandom.NextFloat() - 0.5f) * 500);
ty.AddUpdateListener(new AnimListener(mBlurringView));
AnimatorSet set = new AnimatorSet();
set.PlayTogether(tx, ty);
set.SetDuration(3000);
set.SetInterpolator(new OvershootInterpolator());
set.AddListener(new AnimationEndListener(imageView));
set.Start();
};
mShifted = true;
} else {
foreach (ImageView imageView in mImageViews) {
ObjectAnimator tx = ObjectAnimator.OfFloat(imageView, View.X, 0);
tx.AddUpdateListener(new AnimListener(mBlurringView));
ObjectAnimator ty = ObjectAnimator.OfFloat(imageView, View.Y, 0);
ty.AddUpdateListener(new AnimListener(mBlurringView));
AnimatorSet set = new AnimatorSet();
set.PlayTogether(tx, ty);
set.SetDuration(3000);
set.SetInterpolator(new OvershootInterpolator());
set.AddListener(new AnimationEndListener(imageView));
set.Start();
};
mShifted = false;
}
}
private void PlayAnimatorsTogether(Animator[] animations)
{
var animatorSet = new AnimatorSet();
animatorSet.PlayTogether(animations);
animatorSet.Start();
}
public void Reset (SummaryReportView data)
{
// Cancel old animation
if (currentAnimation != null) {
currentAnimation.Cancel ();
currentAnimation = null;
}
// Not zooming
isZooming = false;
var totalRows = 0;
var hasTime = false;
if (data == null) {
backgroundView.XAxisLabels = null;
ResetRows (totalRows);
} else {
var showEveryYLabel = 1;
var showValueLabels = true;
backgroundView.XAxisLabels = data.ChartTimeLabels.ToArray ();
totalRows = Math.Min (data.Activity.Count, data.ChartRowLabels.Count);
ResetRows (totalRows);
if (totalRows > 25) {
showEveryYLabel = 3;
showValueLabels = false;
}
for (var i = 0; i < totalRows; i++) {
var activity = data.Activity [i];
var yLabel = data.ChartRowLabels [i];
if (activity.TotalTime > 0) {
hasTime = true;
}
var barWidth = (float)activity.TotalTime / (float) (data.MaxTotal * 3600);
var showYAxis = i % showEveryYLabel == 0;
// Bind the data to row
var row = rows [i];
row.RelativeWidth = barWidth;
row.BarView.BillableTime = activity.BillableTime;
row.BarView.TotalTime = activity.TotalTime;
row.ValueTextView.Text = activity.FormattedTotalTime;
row.ValueTextView.Visibility = showValueLabels ? ViewStates.Visible : ViewStates.Gone;
row.YAxisTextView.Text = yLabel;
row.YAxisTextView.Visibility = showYAxis ? ViewStates.Visible : ViewStates.Gone;
}
}
// Detect state
var isLoading = totalRows == 0 || (data != null && data.IsLoading);
var isEmpty = !isLoading && !hasTime;
if (isLoading) {
// Loading state
loadingOverlayView.Visibility = ViewStates.Visible;
loadingOverlayView.Alpha = 1f;
emptyOverlayView.Visibility = ViewStates.Gone;
} else if (isEmpty) {
// Error state
loadingOverlayView.Visibility = ViewStates.Visible;
loadingOverlayView.Alpha = 1f;
emptyOverlayView.Visibility = ViewStates.Visible;
emptyOverlayView.Alpha = 0f;
// Animate overlay in
var scene = new AnimatorSet ();
var fadeIn = ObjectAnimator.OfFloat (emptyOverlayView, "alpha", 0f, 1f).SetDuration (500);
var fadeOut = ObjectAnimator.OfFloat (loadingOverlayView, "alpha", 1f, 0f).SetDuration (500);
fadeOut.AnimationEnd += delegate {
loadingOverlayView.Visibility = ViewStates.Gone;
};
scene.Play (fadeOut);
scene.Play (fadeIn).After (3 * fadeOut.Duration / 4);
currentAnimation = scene;
scene.Start();
} else {
// Normal state
var scene = new AnimatorSet ();
// Fade loading message out
var fadeOverlayOut = ObjectAnimator.OfFloat (loadingOverlayView, "alpha", 1f, 0f).SetDuration (500);
fadeOverlayOut.AnimationEnd += delegate {
loadingOverlayView.Visibility = ViewStates.Gone;
};
scene.Play (fadeOverlayOut);
foreach (var row in rows) {
var axisFadeIn = ObjectAnimator.OfFloat (row.YAxisTextView, "alpha", 0f, 1f).SetDuration (500);
var barScaleUp = ObjectAnimator.OfFloat (row.BarView, "scaleX", 0f, 1f).SetDuration (750);
var valueFadeIn = ObjectAnimator.OfFloat (row.ValueTextView, "alpha", 0f, 1f).SetDuration (400);
scene.Play (axisFadeIn);
scene.Play (barScaleUp).After (axisFadeIn.Duration / 2);
scene.Play (valueFadeIn).After (barScaleUp);
}
currentAnimation = scene;
scene.Start();
}
RequestLayout ();
}
private Animator.IAnimatorListener animationListener;//=new AnimationListenerClass(this);
//private Animator.AnimatorListener animationListener = new Animator.AnimatorListener() {
// @Override
// public void onAnimationStart(Animator animation) {
// if (isOpened()){
// showScrollViewMenu(scrollViewMenu);
// if (menuListener != null)
// menuListener.openMenu();
// }
// }
// @Override
// public void onAnimationEnd(Animator animation) {
// // reset the view;
// if(isOpened()){
// viewActivity.setTouchDisable(true);
// viewActivity.setOnClickListener(viewActivityOnClickListener);
// }else{
// viewActivity.setTouchDisable(false);
// viewActivity.setOnClickListener(null);
// hideScrollViewMenu(scrollViewLeftMenu);
// hideScrollViewMenu(scrollViewRightMenu);
// if (menuListener != null)
// menuListener.closeMenu();
// }
// }
// @Override
// public void onAnimationCancel(Animator animation) {
// }
// @Override
// public void onAnimationRepeat(Animator animation) {
// }
//};
/**
* A helper method to build scale down animation;
*
* @param target
* @param targetScaleX
* @param targetScaleY
* @return
*/
private AnimatorSet buildScaleDownAnimation(View target, float targetScaleX, float targetScaleY)
{
AnimatorSet scaleDown = new AnimatorSet();
scaleDown.PlayTogether(
ObjectAnimator.OfFloat(target, "scaleX", targetScaleX),
ObjectAnimator.OfFloat(target, "scaleY", targetScaleY)
);
if (mUse3D)
{
int angle = scaleDirection == DIRECTION_LEFT ? -ROTATE_Y_ANGLE : ROTATE_Y_ANGLE;
scaleDown.PlayTogether(ObjectAnimator.OfFloat(target, "rotationY", angle));
}
scaleDown.SetInterpolator(AnimationUtils.LoadInterpolator(activity,
Android.Resource.Animation.DecelerateInterpolator));
scaleDown.SetDuration(250);
return scaleDown;
}
private void SetActiveSlice (int value, bool animate = false, bool updateStats = true)
{
if (slices.Count == 1 || value >= slices.Count) {
value = -1;
}
if (value == activeSlice) {
return;
}
activeSlice = value;
Clickable = activeSlice >= 0;
if (updateStats) {
UpdateStats ();
}
if (animate) {
// Finish currently running animations
if (currentSelectAnimation != null) {
currentSelectAnimation.Cancel ();
}
// Animate changes
var scene = new AnimatorSet ();
for (var i = 0; i < slices.Count; i++) {
var slice = slices [i];
if (i == activeSlice) {
// Slice activating animations
if (slice.Alpha < 1) {
var fadeIn = ObjectAnimator.OfFloat (slice, "alpha", slice.Alpha, 1).SetDuration (500);
scene.Play (fadeIn);
}
if (slice.ScaleX != ActiveSliceScale) {
var scaleXUp = ObjectAnimator.OfFloat (slice, "scaleX", slice.ScaleX, ActiveSliceScale).SetDuration (500);
scene.Play (scaleXUp);
}
if (slice.ScaleY != ActiveSliceScale) {
var scaleYUp = ObjectAnimator.OfFloat (slice, "scaleY", slice.ScaleY, ActiveSliceScale).SetDuration (500);
scene.Play (scaleYUp);
}
} else if (activeSlice >= 0) {
// Slice deactivating animations
if (slice.Alpha > 0.5f) {
var fadeOut = ObjectAnimator.OfFloat (slice, "alpha", slice.Alpha, 0.5f).SetDuration (300);
scene.Play (fadeOut);
}
if (slice.ScaleX != NonActiveSliceScale) {
var scaleXDown = ObjectAnimator.OfFloat (slice, "scaleX", slice.ScaleX, NonActiveSliceScale).SetDuration (300);
scene.Play (scaleXDown);
}
if (slice.ScaleY != NonActiveSliceScale) {
var scaleYDown = ObjectAnimator.OfFloat (slice, "scaleY", slice.ScaleY, NonActiveSliceScale).SetDuration (300);
scene.Play (scaleYDown);
}
} else {
// No slice selected animations
if (slice.Alpha < 1) {
var fadeIn = ObjectAnimator.OfFloat (slice, "alpha", slice.Alpha, 1).SetDuration (300);
scene.Play (fadeIn);
}
if (slice.ScaleX != 1) {
var scaleXDown = ObjectAnimator.OfFloat (slice, "scaleX", slice.ScaleX, 1f).SetDuration (300);
scene.Play (scaleXDown);
}
if (slice.ScaleY != 1) {
var scaleYDown = ObjectAnimator.OfFloat (slice, "scaleY", slice.ScaleY, 1f).SetDuration (300);
scene.Play (scaleYDown);
}
}
}
currentSelectAnimation = scene;
scene.Start ();
}
// Notify listeners
if (ActiveSliceChanged != null) {
ActiveSliceChanged (this, EventArgs.Empty);
}
}
private async Task Stop()
{
if (_fadeOut != null && _Set != null && _Set.IsRunning)
{
await Task.Delay(_Delay);
}
if (_Layout != null) {
if (this._Token != null) {
this._Token.Cancel ();
this._Token.Dispose ();
this._Token = null;
}
_Layout.Touch -= LayoutTouched;
Xamarin.Forms.Device.BeginInvokeOnMainThread (() => {
if (this._Layout != null)
{
this._Layout.Visibility = ViewStates.Gone;
this._Layout.Dispose ();
this._Layout = null;
}
});
}
if (_Set != null) {
this._Set.RemoveAllListeners ();
this._Set.End ();
this._Set.Cancel ();
this._Set.Dispose ();
this._Set = null;
}
if (_fadeOut != null) {
this._fadeOut.AnimationEnd -= _fadeOut_AnimationEnd;
this._fadeOut.RemoveAllListeners ();
this._fadeOut.Dispose ();
this._fadeOut = null;
}
}
