keys.scala, etc.: Make merging public keys have a progress bar.

[tripe-android] / progress.scala

/* -*-scala-*-
 *
 * Reporting progress for long-running jobs
 *
 * (c) 2018 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the Trivial IP Encryption (TrIPE) Android app.
 *
 * TrIPE is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 3 of the License, or (at your
 * option) any later version.
 *
 * TrIPE is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with TrIPE.  If not, see <https://www.gnu.org/licenses/>.
 */

package uk.org.distorted.tripe; package object progress {

/*----- Imports -----------------------------------------------------------*/

import scala.collection.mutable.{Publisher, Subscriber};

import java.lang.System.currentTimeMillis;

/*----- Progress displays -------------------------------------------------*/

trait Model {
  protected val t0 = currentTimeMillis;

  def what: String;
  def max: Long;

  def eta(cur: Long): Double = {
    /* Report the estimated time remaining in seconds, or -1 if no idea.
     *
     * The model here is very stupid.  Weird jobs should override this and
     * do something more sensible.
     */

    val max = this.max;
    val delta = currentTimeMillis - t0
    if (max < 0 || cur <= 0) -1 else delta*(max - cur)/cur.toDouble
  }

  protected def fmt1(n: Long): String = n.toString;

  def format(cur: Long): String = {
    val max = this.max;
    val fc = fmt1(cur);
    if (max >= 0) { val fm = fmt1(max); s"%${fm.length}s/%s".format(fc, fm) }
    else if (cur > 0) fc
    else ""
  }
}

class SimpleModel(val what: String, val max: Long) extends Model;

class DetailedModel(what: String, max: Long) extends SimpleModel(what, max) {
  var detail: String = null;
  override def format(cur: Long): String = {
    val sb = new StringBuilder;
    sb ++= super.format(cur);
    if (detail != null) { sb += ' '; sb ++= detail; }
    sb.result
  }
}

private val UDATA = Seq("kB", "MB", "GB", "TB", "PB", "EB");

trait DataModel extends Model {
  override def fmt1(n: Long): String = {
    val (x, u) = ((n.toDouble, "B ") /: UDATA) { (xu, n) => (xu, n) match {
      case ((x, u), name) if x >= 1024.0 => (x/1024.0, name)
      case (xu, _) => xu
    } }
    f"$x%6.1f$u%s"
  }
}

trait BaseReporter {
  def done();
  def failed(e: Exception);
}

trait JobReporter extends BaseReporter {
  def step(cur: Long);
  def change(model: Model, cur: Long);
}

trait OperationReporter extends BaseReporter {
  def step(detail: String);
}

def withReporter[T, P <: BaseReporter](rep: P, body: P => T): T = {
  val ret = try { body(rep) }
  catch { case e: Exception => rep.failed(e); throw e; }
  rep.done();
  ret
}

trait Eyecandy {
  def note(msg: String);
  def clear();
  def commit();
  def record(msg: String) { note(msg); commit(); }
  def done();
  def cancelled() { failed("cancelled"); }
  def failed(msg: String);

  def beginJob(model: Model): JobReporter
    // = new JobReporter(model);

  def beginOperation(what: String): OperationReporter
    // = new OperationReporter(what);

  def job[T](model: Model)(body: JobReporter => T): T =
    withReporter(beginJob(model), body);

  def operation[T](what: String)(body: OperationReporter => T): T =
    withReporter(beginOperation(what), body);
}

/*----- That's all, folks -------------------------------------------------*/

}