/** * Returns progress in this node. get() would give overall progress of the * root node(not just given current node). */ public synchronized float getProgress() { return getInternal(); }
/** Returns the overall progress of the root. */ // this method probably does not need to be synchronized as getInternal() is // synchronized and the node's parent never changes. Still, it doesn't hurt. public synchronized float get() { Progress node = this; while (node.getParent() != null) { // find the root node = parent; } return node.getInternal(); }
/** Computes progress in this node. */ private synchronized float getInternal() { int phaseCount = phases.size(); if (phaseCount != 0) { float subProgress = 0.0f; float progressFromCurrentPhase = 0.0f; if (currentPhase < phaseCount) { subProgress = phase().getInternal(); progressFromCurrentPhase = getProgressWeightage(currentPhase) * subProgress; } float progressFromCompletedPhases = 0.0f; if (fixedWeightageForAllPhases) { // same progress weightage for each phase progressFromCompletedPhases = progressPerPhase * currentPhase; } else { for (int i = 0; i < currentPhase; i++) { // progress weightages of phases could be different. Add them progressFromCompletedPhases += getProgressWeightage(i); } } return progressFromCompletedPhases + progressFromCurrentPhase; } else { return progress; } }
/** Returns the overall progress of the root. */ // this method probably does not need to be synchronized as getINternal() is synchronized // and the node's parent never changes. Still, it doesn't hurt. public synchronized float get() { Progress node = this; while (node.parent != null) { // find the root node = parent; } return node.getInternal(); }
/** * Returns progress in this node. get() would give overall progress of the * root node(not just given current node). */ public synchronized float getProgress() { return getInternal(); }
/** Returns the overall progress of the root. */ // this method probably does not need to be synchronized as getINternal() is synchronized // and the node's parent never changes. Still, it doesn't hurt. public synchronized float get() { Progress node = this; while (node.parent != null) { // find the root node = parent; } return node.getInternal(); }
/** * Returns progress in this node. get() would give overall progress of the * root node(not just given current node). */ public synchronized float getProgress() { return getInternal(); }
/** * Returns progress in this node. get() would give overall progress of the * root node(not just given current node). */ public synchronized float getProgress() { return getInternal(); }
/** * Returns progress in this node. get() would give overall progress of the * root node(not just given current node). */ public synchronized float getProgress() { return getInternal(); }
/** Returns the overall progress of the root. */ // this method probably does not need to be synchronized as getInternal() is // synchronized and the node's parent never changes. Still, it doesn't hurt. public synchronized float get() { Progress node = this; while (node.getParent() != null) { // find the root node = parent; } return node.getInternal(); }
/** Returns the overall progress of the root. */ // this method probably does not need to be synchronized as getInternal() is // synchronized and the node's parent never changes. Still, it doesn't hurt. public synchronized float get() { Progress node = this; while (node.getParent() != null) { // find the root node = parent; } return node.getInternal(); }
/** Computes progress in this node. */ private synchronized float getInternal() { int phaseCount = phases.size(); if (phaseCount != 0) { float subProgress = currentPhase < phaseCount ? phase().getInternal() : 0.0f; return progressPerPhase*(currentPhase + subProgress); } else { return progress; } }
/** Returns the overall progress of the root. */ // this method probably does not need to be synchronized as getInternal() is // synchronized and the node's parent never changes. Still, it doesn't hurt. public synchronized float get() { Progress node = this; while (node.getParent() != null) { // find the root node = parent; } return node.getInternal(); }
/** Returns the overall progress of the root. */ // this method probably does not need to be synchronized as getInternal() is // synchronized and the node's parent never changes. Still, it doesn't hurt. public synchronized float get() { Progress node = this; while (node.getParent() != null) { // find the root node = parent; } return node.getInternal(); }
/** Computes progress in this node. */ private synchronized float getInternal() { int phaseCount = phases.size(); if (phaseCount != 0) { float subProgress = currentPhase < phaseCount ? phase().getInternal() : 0.0f; return progressPerPhase*(currentPhase + subProgress); } else { return progress; } }
/** Computes progress in this node. */ private synchronized float getInternal() { int phaseCount = phases.size(); if (phaseCount != 0) { float subProgress = 0.0f; float progressFromCurrentPhase = 0.0f; if (currentPhase < phaseCount) { subProgress = phase().getInternal(); progressFromCurrentPhase = getProgressWeightage(currentPhase) * subProgress; } float progressFromCompletedPhases = 0.0f; if (fixedWeightageForAllPhases) { // same progress weightage for each phase progressFromCompletedPhases = progressPerPhase * currentPhase; } else { for (int i = 0; i < currentPhase; i++) { // progress weightages of phases could be different. Add them progressFromCompletedPhases += getProgressWeightage(i); } } return progressFromCompletedPhases + progressFromCurrentPhase; } else { return progress; } }
/** Computes progress in this node. */ private synchronized float getInternal() { int phaseCount = phases.size(); if (phaseCount != 0) { float subProgress = 0.0f; float progressFromCurrentPhase = 0.0f; if (currentPhase < phaseCount) { subProgress = phase().getInternal(); progressFromCurrentPhase = getProgressWeightage(currentPhase) * subProgress; } float progressFromCompletedPhases = 0.0f; if (fixedWeightageForAllPhases) { // same progress weightage for each phase progressFromCompletedPhases = progressPerPhase * currentPhase; } else { for (int i = 0; i < currentPhase; i++) { // progress weightages of phases could be different. Add them progressFromCompletedPhases += getProgressWeightage(i); } } return progressFromCompletedPhases + progressFromCurrentPhase; } else { return progress; } }
/** Computes progress in this node. */ private synchronized float getInternal() { int phaseCount = phases.size(); if (phaseCount != 0) { float subProgress = 0.0f; float progressFromCurrentPhase = 0.0f; if (currentPhase < phaseCount) { subProgress = phase().getInternal(); progressFromCurrentPhase = getProgressWeightage(currentPhase) * subProgress; } float progressFromCompletedPhases = 0.0f; if (fixedWeightageForAllPhases) { // same progress weightage for each phase progressFromCompletedPhases = progressPerPhase * currentPhase; } else { for (int i = 0; i < currentPhase; i++) { // progress weightages of phases could be different. Add them progressFromCompletedPhases += getProgressWeightage(i); } } return progressFromCompletedPhases + progressFromCurrentPhase; } else { return progress; } }
/** Computes progress in this node. */ private synchronized float getInternal() { int phaseCount = phases.size(); if (phaseCount != 0) { float subProgress = 0.0f; float progressFromCurrentPhase = 0.0f; if (currentPhase < phaseCount) { subProgress = phase().getInternal(); progressFromCurrentPhase = getProgressWeightage(currentPhase) * subProgress; } float progressFromCompletedPhases = 0.0f; if (fixedWeightageForAllPhases) { // same progress weightage for each phase progressFromCompletedPhases = progressPerPhase * currentPhase; } else { for (int i = 0; i < currentPhase; i++) { // progress weightages of phases could be different. Add them progressFromCompletedPhases += getProgressWeightage(i); } } return progressFromCompletedPhases + progressFromCurrentPhase; } else { return progress; } }