Set the progress this notification represents.

@see android.app.Notification#setProgress(int, int, boolean)

@param max
@param progress
@param indeterminate
162380
public void setProgress(int max, int progress, boolean indeterminate) {
        this.progressMax = max;
        this.progress = progress;
        this.progressIndeterminate = indeterminate;
    }
868479
public final void setMax(final int max) {
		if (max < 0) {
			throw new IllegalArgumentException(ILLEGAL_MAX);
		}
		if (max != getMax()) {
			getOrCreateComponentModel().max = max;
		}
	}
76722
public boolean notifyIndeterminantProgress() {

    boolean result = true;

    for (ProgressMonitor monitor : this.monitors) {
      if (!monitor.notifyIndeterminantProgress()) {
        result = false;
      }
    }

    return result;

  }
92786
public ProgressStyle setIndeterminate(boolean value){
        if(mProgressStyle == HORIZONTAL) {
            mProgress.setIndeterminate(value);
            mProgressText.setVisibility(value ? View.GONE : View.VISIBLE);
            mProgressMax.setVisibility(value ? View.GONE : View.VISIBLE);
        }
        return this;
    }
217567
protected void updateProgressNotification(@NonNull final NotificationCompat.Builder builder, final int progress) {
		// Add Abort action to the notification
		if (progress != PROGRESS_ABORTED && progress != PROGRESS_COMPLETED) {
			final Intent abortIntent = new Intent(BROADCAST_ACTION);
			abortIntent.putExtra(EXTRA_ACTION, ACTION_ABORT);
			final PendingIntent pendingAbortIntent = PendingIntent.getBroadcast(this, 1, abortIntent, PendingIntent.FLAG_UPDATE_CURRENT);
			builder.addAction(R.drawable.ic_action_notify_cancel, getString(R.string.dfu_action_abort), pendingAbortIntent);
		}
	}
495015
public void setProgressBar(ProgressBar progressBar, int progress){
		if(config.commandLogging){
			Log.d(config.commandLoggingTag, "setProgressBar("+progressBar+", "+progress+")");
		}
		
		progressBar = (ProgressBar) waiter.waitForView(progressBar, Timeout.getSmallTimeout());
		setter.setProgressBar(progressBar, progress);
	}
1056016
@Override
  public synchronized void onProgressUpdate(float progress) {
    if (mIsFinished) {
      return;
    }
    try {
      onProgressUpdateImpl(progress);
    } catch (Exception e) {
      onUnhandledException(e);
    }
  }
1285152
def setTotal( self, amount ):
        
        self._primaryProgressBar.setValue(0)
        self._primaryProgressBar.setMaximum(amount)
        
        if amount:
            self.setCurrentMode(XLoaderWidget.Mode.Progress)
1173227
public SuperActivityToast setProgress(int progress) {
        if (this.mProgressBar == null) {
            Log.e(getClass().getName(), "Could not set SuperActivityToast " +
                    "progress, are you sure you set the type to TYPE_PROGRESS_CIRCLE " +
                    "or TYPE_PROGRESS_BAR?");
            return this;
        }
        this.mStyle.progress = progress;
        this.mProgressBar.setProgress(progress);
        return this;
    }
754238
protected void publishProgress(final Progress progress) {
        if (!isCanceled()) {
            sUiHandler.post(new Runnable() {
                @Override
                public void run() {
                    onProgressUpdate(progress);
                }
            });
        }
    }
1261964
public void updateProgress(int progress, int maxProgress) {
		int increment = (int)((double)(stopValue - startValue) * ((double)maxProgress / (double)progress));
		progressBar.setValue(startValue + increment);
	}
1269067
public void setProgressBar(final ProgressBar progressBar,final int progress) {
		if(progressBar != null){
			Activity activity = activityUtils.getCurrentActivity(false);
			if(activity != null){
				activity.runOnUiThread(new Runnable()
				{
					public void run()
					{
						try{
							progressBar.setProgress(progress);
						}catch (Exception ignored){}
					}
				});
			}
		}
	}
238915
public function progress($progress = file_progress::INDETERMINATE, $max = file_progress::INDETERMINATE) {
        $reporter = $this->get_progress_reporter();

        // Start tracking progress if necessary.
        if (!$this->startedprogress) {
            $reporter->start_progress('extract_file_to_dir',
                    ($max == file_progress::INDETERMINATE) ? \core\progress\base::INDETERMINATE : $max);
            $this->startedprogress = true;
        }

        // Pass progress through to whatever handles it.
        $reporter->progress(
                ($progress == file_progress::INDETERMINATE) ? \core\progress\base::INDETERMINATE : $progress);
    }
76657
public void addProgressListener(ProgressListener pListener) {
        if (pListener == null) {
            return;
        }

        if (listeners == null) {
            listeners = new CopyOnWriteArrayList<ProgressListener>();
        }

        listeners.add(pListener);
    }
1074081
public function start($maxSteps = null): void
    {
        if ($this->started) {
            throw new \LogicException('Progress bar already started.');
        }

        $this->startTime = time();
        $this->step = 0;
        $this->percent = 0.0;
        $this->started = true;

        if (null !== $maxSteps) {
            $this->setMaxSteps($maxSteps);
        }

        $this->display();
    }
1170294
public void updateProgress(final Table table, final int currentRow) {
        final TableProgressInformationPanel tableProgressInformationPanel = getTableProgressInformationPanel(table, -1);
        final boolean greater = tableProgressInformationPanel.setProgress(currentRow);

        if (!greater) {
            // this may happen because of the multithreaded nature of the
            // execution - sometimes a notification can come in later than
            // previous notifications
            return;
        }

        ProgressCounter counter = _progressTimingCounters.get(table);
        if (counter == null) {
            counter = new ProgressCounter();
            final ProgressCounter previous = _progressTimingCounters.put(table, counter);
            if (previous != null) {
                counter = previous;
            }
        }

        final boolean log;
        final int previousCount = counter.get();
        if (currentRow - previousCount > 1000) {
            log = counter.setIfSignificantToUser(currentRow);
        } else {
            log = false;
        }
        if (log) {
            addUserLog("Progress of " + table.getName() + ": " + formatNumber(currentRow) + " rows processed");
        }
    }
572159
void setIsIndeterminate(boolean isIndeterminate) {
        if (mIsIndeterminate != isIndeterminate) {
            mIsIndeterminate = isIndeterminate;
            mInputAdapter.setIndeterminate(isIndeterminate);
            notifyDataSetChanged();
        }
    }