Android源码解析之属性动画详解

objectanimator
 .ofint(mview,"width",100,500)
 .setduration(1000)
 .start();

public static objectanimator ofint(object target, string propertyname, int... values) {
 objectanimator anim = new objectanimator(target, propertyname);
 anim.setintvalues(values);
 return anim;
}

public void setintvalues(int... values) {
 if (mvalues == null || mvalues.length == 0) {
 // no values yet - this animator is being constructed piecemeal. init the values with
 // whatever the current propertyname is
 if (mproperty != null) {
 setvalues(propertyvaluesholder.ofint(mproperty, values));
 } else {
 setvalues(propertyvaluesholder.ofint(mpropertyname, values));
 }
 } else {
 super.setintvalues(values);
 }
}

public static propertyvaluesholder ofint(string propertyname, int... values) {
 return new intpropertyvaluesholder(propertyname, values);
}

public intpropertyvaluesholder(string propertyname, int... values) {
 super(propertyname);
 setintvalues(values);
}

public void setintvalues(int... values) {
 super.setintvalues(values);
 mintkeyframes = (keyframes.intkeyframes) mkeyframes;
}

public static keyframeset ofint(int... values) {
 int numkeyframes = values.length;
 intkeyframe keyframes[] = new intkeyframe[math.max(numkeyframes,2)];
 if (numkeyframes == 1) {
 keyframes[0] = (intkeyframe) keyframe.ofint(0f);
 keyframes[1] = (intkeyframe) keyframe.ofint(1f, values[0]);
 } else {
 keyframes[0] = (intkeyframe) keyframe.ofint(0f, values[0]);
 for (int i = 1; i < numkeyframes; ++i) {
 keyframes[i] =
  (intkeyframe) keyframe.ofint((float) i / (numkeyframes - 1), values[i]);
 }
 }
 return new intkeyframeset(keyframes);
}

public void setvalues(propertyvaluesholder... values) {
 int numvalues = values.length;
 mvalues = values;
 mvaluesmap = new hashmap<string, propertyvaluesholder>(numvalues);
 for (int i = 0; i < numvalues; ++i) {
 propertyvaluesholder valuesholder = values[i];
 mvaluesmap.put(valuesholder.getpropertyname(), valuesholder);
 }
 // new property/values/target should cause re-initialization prior to starting
 minitialized = false;
}

public void start() {
 // see if any of the current active/pending animators need to be canceled
 animationhandler handler = sanimationhandler.get();
 if (handler != null) {
 int numanims = handler.manimations.size();
 for (int i = numanims - 1; i >= 0; i--) {
 if (handler.manimations.get(i) instanceof objectanimator) {
 objectanimator anim = (objectanimator) handler.manimations.get(i);
 if (anim.mautocancel && hassametargetandproperties(anim)) {
  anim.cancel();
 }
 }
 }
 numanims = handler.mpendinganimations.size();
 for (int i = numanims - 1; i >= 0; i--) {
 if (handler.mpendinganimations.get(i) instanceof objectanimator) {
 objectanimator anim = (objectanimator) handler.mpendinganimations.get(i);
 if (anim.mautocancel && hassametargetandproperties(anim)) {
  anim.cancel();
 }
 }
 }
 numanims = handler.mdelayedanims.size();
 for (int i = numanims - 1; i >= 0; i--) {
 if (handler.mdelayedanims.get(i) instanceof objectanimator) {
 objectanimator anim = (objectanimator) handler.mdelayedanims.get(i);
 if (anim.mautocancel && hassametargetandproperties(anim)) {
  anim.cancel();
 }
 }
 }
 }
 if (dbg) {
 log.d(log_tag, "anim target, duration: " + gettarget() + ", " + getduration());
 for (int i = 0; i < mvalues.length; ++i) {
 propertyvaluesholder pvh = mvalues[i];
 log.d(log_tag, " values[" + i + "]: " +
 pvh.getpropertyname() + ", " + pvh.mkeyframes.getvalue(0) + ", " +
 pvh.mkeyframes.getvalue(1));
 }
 }
 super.start();
}

private void start(boolean playbackwards) {
 if (looper.mylooper() == null) {
 throw new androidruntimeexception("animators may only be run on looper threads");
 }
 mreversing = playbackwards;
 mplayingbackwards = playbackwards;
 if (playbackwards && mseekfraction != -1) {
 if (mseekfraction == 0 && mcurrentiteration == 0) {
 // special case: reversing from seek-to-0 should act as if not seeked at all
 mseekfraction = 0;
 } else if (mrepeatcount == infinite) {
 mseekfraction = 1 - (mseekfraction % 1);
 } else {
 mseekfraction = 1 + mrepeatcount - (mcurrentiteration + mseekfraction);
 }
 mcurrentiteration = (int) mseekfraction;
 mseekfraction = mseekfraction % 1;
 }
 if (mcurrentiteration > 0 && mrepeatmode == reverse &&
 (mcurrentiteration < (mrepeatcount + 1) || mrepeatcount == infinite)) {
 // if we were seeked to some other iteration in a reversing animator,
 // figure out the correct direction to start playing based on the iteration
 if (playbackwards) {
 mplayingbackwards = (mcurrentiteration % 2) == 0;
 } else {
 mplayingbackwards = (mcurrentiteration % 2) != 0;
 }
 }
 int prevplayingstate = mplayingstate;
 mplayingstate = stopped;
 mstarted = true;
 mstarteddelay = false;
 mpaused = false;
 updatescaledduration(); // in case the scale factor has changed since creation time
 animationhandler animationhandler = getorcreateanimationhandler();
 animationhandler.mpendinganimations.add(this);
 if (mstartdelay == 0) {
 // this sets the initial value of the animation, prior to actually starting it running
 if (prevplayingstate != seeked) {
 setcurrentplaytime(0);
 }
 mplayingstate = stopped;
 mrunning = true;
 notifystartlisteners();
 }
 animationhandler.start();
}

doanimationframe(mchoreographer.getframetime());

void doanimationframe(long frametime) {
 mlastframetime = frametime;
 // mpendinganimations holds any animations that have requested to be started
 // we're going to clear mpendinganimations, but starting animation may
 // cause more to be added to the pending list (for example, if one animation
 // starting triggers another starting). so we loop until mpendinganimations
 // is empty.
 while (mpendinganimations.size() > 0) {
 arraylist<valueanimator> pendingcopy =
 (arraylist<valueanimator>) mpendinganimations.clone();
 mpendinganimations.clear();
 int count = pendingcopy.size();
 for (int i = 0; i < count; ++i) {
 valueanimator anim = pendingcopy.get(i);
 // if the animation has a startdelay, place it on the delayed list
 if (anim.mstartdelay == 0) {
 anim.startanimation(this);
 } else {
 mdelayedanims.add(anim);
 }
 }
 }
 // next, process animations currently sitting on the delayed queue, adding
 // them to the active animations if they are ready
 int numdelayedanims = mdelayedanims.size();
 for (int i = 0; i < numdelayedanims; ++i) {
 valueanimator anim = mdelayedanims.get(i);
 if (anim.delayedanimationframe(frametime)) {
 mreadyanims.add(anim);
 }
 }
 int numreadyanims = mreadyanims.size();
 if (numreadyanims > 0) {
 for (int i = 0; i < numreadyanims; ++i) {
 valueanimator anim = mreadyanims.get(i);
 anim.startanimation(this);
 anim.mrunning = true;
 mdelayedanims.remove(anim);
 }
 mreadyanims.clear();
 }
 // now process all active animations. the return value from animationframe()
 // tells the handler whether it should now be ended
 int numanims = manimations.size();
 for (int i = 0; i < numanims; ++i) {
 mtmpanimations.add(manimations.get(i));
 }
 for (int i = 0; i < numanims; ++i) {
 valueanimator anim = mtmpanimations.get(i);
 if (manimations.contains(anim) && anim.doanimationframe(frametime)) {
 mendinganims.add(anim);
 }
 }
 mtmpanimations.clear();
 if (mendinganims.size() > 0) {
 for (int i = 0; i < mendinganims.size(); ++i) {
 mendinganims.get(i).endanimation(this);
 }
 mendinganims.clear();
 }
 // schedule final commit for the frame.
 mchoreographer.postcallback(choreographer.callback_commit, mcommit, null);
 // if there are still active or delayed animations, schedule a future call to
 // onanimate to process the next frame of the animations.
 if (!manimations.isempty() || !mdelayedanims.isempty()) {
 scheduleanimation();
 }
}

boolean animationframe(long currenttime) {
 boolean done = false;
 switch (mplayingstate) {
 case running:
 case seeked:
 float fraction = mduration > 0 ? (float)(currenttime - mstarttime) / mduration : 1f;
 if (mduration == 0 && mrepeatcount != infinite) {
 // skip to the end
 mcurrentiteration = mrepeatcount;
 if (!mreversing) {
  mplayingbackwards = false;
 }
 }
 if (fraction >= 1f) {
 if (mcurrentiteration < mrepeatcount || mrepeatcount == infinite) {
  // time to repeat
  if (mlisteners != null) {
  int numlisteners = mlisteners.size();
  for (int i = 0; i < numlisteners; ++i) {
  mlisteners.get(i).onanimationrepeat(this);
  }
  }
  if (mrepeatmode == reverse) {
  mplayingbackwards = !mplayingbackwards;
  }
  mcurrentiteration += (int) fraction;
  fraction = fraction % 1f;
  mstarttime += mduration;
  // note: we do not need to update the value of mstarttimecommitted here
  // since we just added a duration offset.
 } else {
  done = true;
  fraction = math.min(fraction, 1.0f);
 }
 }
 if (mplayingbackwards) {
 fraction = 1f - fraction;
 }
 animatevalue(fraction);
 break;
 }
 return done;
 }

void animatevalue(float fraction) {
 final object target = gettarget();
 if (mtarget != null && target == null) {
 // we lost the target reference, cancel and clean up.
 cancel();
 return;
 }
 super.animatevalue(fraction);
 int numvalues = mvalues.length;
 for (int i = 0; i < numvalues; ++i) {
 mvalues[i].setanimatedvalue(target);
 }
}

void animatevalue(float fraction) {
 fraction = minterpolator.getinterpolation(fraction);
 mcurrentfraction = fraction;
 int numvalues = mvalues.length;
 for (int i = 0; i < numvalues; ++i) {
 mvalues[i].calculatevalue(fraction);
 }
 if (mupdatelisteners != null) {
 int numlisteners = mupdatelisteners.size();
 for (int i = 0; i < numlisteners; ++i) {
 mupdatelisteners.get(i).onanimationupdate(this);
 }
 }
}

void calculatevalue(float fraction) {
 mintanimatedvalue = mintkeyframes.getintvalue(fraction);
}

void setanimatedvalue(object target) {
 if (mintproperty != null) {
 mintproperty.setvalue(target, mintanimatedvalue);
 return;
 }
 if (mproperty != null) {
 mproperty.set(target, mintanimatedvalue);
 return;
 }
 if (mjnisetter != 0) {
 ncallintmethod(target, mjnisetter, mintanimatedvalue);
 return;
 }
 if (msetter != null) {
 try {
 mtmpvaluearray[0] = mintanimatedvalue;
 msetter.invoke(target, mtmpvaluearray);
 } catch (invocationtargetexception e) {
 log.e("propertyvaluesholder", e.tostring());
 } catch (illegalaccessexception e) {
 log.e("propertyvaluesholder", e.tostring());
 }
 }
}