hjs-future
Version:
Future classes of Hubrijs framework
572 lines (519 loc) • 22.4 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.AsyncTask = exports.AsyncTaskListener = exports.AsyncTaskResult = exports.AsyncRunnable = exports.AsyncTaskStatus = undefined;
var _promise = require('babel-runtime/core-js/promise');
var _promise2 = _interopRequireDefault(_promise);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _time = require('hjs-core/lib/time');
var _handler = require('hjs-message/lib/handler');
var _queue = require('hjs-collection/lib/queue');
var _executor = require('./executor');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/** @babel */
var AsyncTaskStatus = exports.AsyncTaskStatus = {
NONE: -1,
PENDING: 0,
RUNNING: 1,
FINISHED: 2
};
var AsyncRunnable = exports.AsyncRunnable = function (_Runnable) {
(0, _inherits3.default)(AsyncRunnable, _Runnable);
function AsyncRunnable() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$run = _ref.run,
run = _ref$run === undefined ? null : _ref$run,
_ref$task = _ref.task,
task = _ref$task === undefined ? null : _ref$task,
_ref$params = _ref.params,
params = _ref$params === undefined ? null : _ref$params;
(0, _classCallCheck3.default)(this, AsyncRunnable);
var _this = (0, _possibleConstructorReturn3.default)(this, (AsyncRunnable.__proto__ || (0, _getPrototypeOf2.default)(AsyncRunnable)).call(this, { run: run }));
if (task !== null) {
_this.mTask = task;
}
if (params !== null) {
_this.mParams = params;
}
return _this;
}
return AsyncRunnable;
}(_handler.Runnable);
var AsyncTaskResult = exports.AsyncTaskResult = function AsyncTaskResult() {
var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref2$task = _ref2.task,
task = _ref2$task === undefined ? null : _ref2$task,
_ref2$data = _ref2.data,
data = _ref2$data === undefined ? null : _ref2$data;
(0, _classCallCheck3.default)(this, AsyncTaskResult);
if (task !== null) {
this.mTask = task;
}
if (data !== null) {
this.mData = data;
}
};
var AsyncTaskListener = exports.AsyncTaskListener = function () {
function AsyncTaskListener() {
var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref3$task = _ref3.task,
task = _ref3$task === undefined ? null : _ref3$task,
_ref3$onFinished = _ref3.onFinished,
onFinished = _ref3$onFinished === undefined ? null : _ref3$onFinished;
(0, _classCallCheck3.default)(this, AsyncTaskListener);
if (task !== null) {
this.mTask = task;
}
if (onFinished !== null) {
this.onFinished = onFinished;
}
}
(0, _createClass3.default)(AsyncTaskListener, [{
key: 'onFinished',
value: function onFinished(result) {}
}]);
return AsyncTaskListener;
}();
var MESSAGE_POST_RESULT = 0x1;
var MESSAGE_POST_PROGRESS = 0x2;
var sDefaultHandler = _handler.MessageHandler.create({
handleMessage: function handleMessage(msg) {
var result = msg.getObj();
switch (msg.getWhat()) {
case MESSAGE_POST_RESULT:
result.mTask.finish(result.mData);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
});
var sDefaultExecutor = _executor.Executors.newSerialExecutor({ capacity: 128 });
var AsyncTask = exports.AsyncTask = function () {
function AsyncTask() {
var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref4$executor = _ref4.executor,
executor = _ref4$executor === undefined ? null : _ref4$executor,
_ref4$handler = _ref4.handler,
handler = _ref4$handler === undefined ? null : _ref4$handler,
_ref4$doInBackground = _ref4.doInBackground,
doInBackground = _ref4$doInBackground === undefined ? null : _ref4$doInBackground,
_ref4$onCancelled = _ref4.onCancelled,
onCancelled = _ref4$onCancelled === undefined ? null : _ref4$onCancelled,
_ref4$onPostExecute = _ref4.onPostExecute,
onPostExecute = _ref4$onPostExecute === undefined ? null : _ref4$onPostExecute,
_ref4$onPreExecute = _ref4.onPreExecute,
onPreExecute = _ref4$onPreExecute === undefined ? null : _ref4$onPreExecute,
_ref4$onProgressUpdat = _ref4.onProgressUpdate,
onProgressUpdate = _ref4$onProgressUpdat === undefined ? null : _ref4$onProgressUpdat,
_ref4$reuse = _ref4.reuse,
reuse = _ref4$reuse === undefined ? true : _ref4$reuse;
(0, _classCallCheck3.default)(this, AsyncTask);
this.init({
executor: executor,
handler: handler,
doInBackground: doInBackground,
onCancelled: onCancelled,
onPostExecute: onPostExecute,
onPreExecute: onPreExecute,
onProgressUpdate: onProgressUpdate,
reuse: reuse
});
}
(0, _createClass3.default)(AsyncTask, [{
key: 'addTaskListener',
value: function addTaskListener(listener) {
this.mTaskListener = listener;
}
}, {
key: 'cancel',
value: function cancel() {
return this.mIsCancelled = !(this.mStatus === AsyncTaskStatus.FINISHED);
}
}, {
key: 'doInBackground',
value: function doInBackground(params) {}
}, {
key: 'execute',
value: function execute(params) {
var uptimeMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
if (this.mReuse && this.mStatus === AsyncTaskStatus.RUNNING) {
if (this.mPendingTasks.offer({ params: params, uptimeMillis: uptimeMillis, token: token })) {
return this;
}
}
return this.internalExecute(params, uptimeMillis, token);
}
}, {
key: 'executeOnExecutor',
value: function executeOnExecutor(executor, params) {
if (this.mStatus !== AsyncTaskStatus.PENDING) {
switch (this.mStatus) {
case AsyncTaskStatus.RUNNING:
throw new Error("IllegalStateException Cannot execute task:" + " a task not recyclable is already running.");
case AsyncTaskStatus.FINISHED:
throw new Error("IllegalStateException Cannot execute task:" + " the task has already been executed " + "(a task not recyclable can be executed only once)");
}
}
this.mStatus = AsyncTaskStatus.RUNNING;
this.onPreExecute();
var ar = new AsyncRunnable({
task: this,
params: params,
run: function run() {
var t = ar.mTask;
var listener = new AsyncTaskListener({
task: t,
onFinished: function onFinished(result) {
t.mTaskInvoked = true;
t.postResult(result);
t.removeTaskListener(listener);
}
});
ar.mTask.addTaskListener(listener);
try {
t.doInBackground(ar.mParams);
} catch (e) {
t.mTaskInvoked = false;
t.postResultIfNotInvoked(e);
t.removeTaskListener(listener);
}
}
});
executor.execute(ar);
return this;
}
}, {
key: 'finalize',
value: function finalize() {
if (this.mStatus === AsyncTaskStatus.FINISHED) {
this.mStatus = AsyncTaskStatus.NONE;
this.mUseExecutor = false;
this.mTaskInvoked = false;
this.mIsCancelled = false;
this.mReuse = false;
this.mTaskListener = null;
this.mPendingTasks = null;
this.mExecutor = null;
this.mHandler = null;
this.mResult = null;
}
}
}, {
key: 'finish',
value: function finish(result) {
this.mStatus = AsyncTaskStatus.FINISHED;
if (this.isCancelled()) {
this.onCancelled(result);
} else {
this.onPostExecute(result);
}
if (this.mExecutor instanceof _executor.BlockingExecutor) {
this.mExecutor.scheduleNext();
}
if (!this.mReuse) {
this.finalize();
} else {
this.recycle();
var task = this.mPendingTasks.poll();
if (task !== null) {
this.execute(task.params, task.uptimeMillis, task.token);
}
}
}
}, {
key: 'get',
value: function get() {
var _this2 = this;
var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_onComplete = _ref5.onComplete,
_ref5$timeout = _ref5.timeout,
timeout = _ref5$timeout === undefined ? 0 : _ref5$timeout,
_ref5$unit = _ref5.unit,
unit = _ref5$unit === undefined ? _time.MILLISECONDS : _ref5$unit;
if (!(this.isInvoked() || this.isCancelled())) {
this.wait({
timeout: timeout,
unit: unit,
onComplete: function onComplete() {
var done = _this2.isInvoked() || _this2.isCancelled();
if (done) {
_onComplete(_this2.mResult);
}
return done;
},
uncaughtExceptionHandler: new _time.UncaughtExceptionHandler({
uncaughtException: function uncaughtException(e) {
var done = _this2.isInvoked() || _this2.isCancelled();
if (!done) {
_this2.cancel();
}
_onComplete(e);
}
})
});
return null;
}
return this.mResult;
}
}, {
key: 'getExecutor',
value: function getExecutor() {
return this.mExecutor;
}
}, {
key: 'getHandler',
value: function getHandler() {
return this.mHandler;
}
}, {
key: 'getStatus',
value: function getStatus() {
return this.mStatus;
}
}, {
key: 'init',
value: function init() {
var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref6$executor = _ref6.executor,
executor = _ref6$executor === undefined ? null : _ref6$executor,
_ref6$handler = _ref6.handler,
handler = _ref6$handler === undefined ? null : _ref6$handler,
_ref6$doInBackground = _ref6.doInBackground,
doInBackground = _ref6$doInBackground === undefined ? null : _ref6$doInBackground,
_ref6$onCancelled = _ref6.onCancelled,
onCancelled = _ref6$onCancelled === undefined ? null : _ref6$onCancelled,
_ref6$onPostExecute = _ref6.onPostExecute,
onPostExecute = _ref6$onPostExecute === undefined ? null : _ref6$onPostExecute,
_ref6$onPreExecute = _ref6.onPreExecute,
onPreExecute = _ref6$onPreExecute === undefined ? null : _ref6$onPreExecute,
_ref6$onProgressUpdat = _ref6.onProgressUpdate,
onProgressUpdate = _ref6$onProgressUpdat === undefined ? null : _ref6$onProgressUpdat,
_ref6$reuse = _ref6.reuse,
reuse = _ref6$reuse === undefined ? true : _ref6$reuse;
this.mStatus = AsyncTaskStatus.NONE;
this.mPendingTasks = new _queue.Queue(126);
this.mUseExecutor = executor !== null;
this.mExecutor = executor || sDefaultExecutor;
this.mHandler = handler || sDefaultHandler;
this.mReuse = reuse;
if (doInBackground) {
this.doInBackground = doInBackground;
}
if (onCancelled) {
this.onCancelled = onCancelled;
}
if (onPostExecute) {
this.onPostExecute = onPostExecute;
}
if (onPreExecute) {
this.onPreExecute = onPreExecute;
}
if (onProgressUpdate) {
this.onProgressUpdate = onProgressUpdate;
}
this.mIsCancelled = false;
this.mTaskInvoked = false;
}
}, {
key: 'internalExecute',
value: function internalExecute(params) {
var uptimeMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
var executor = null;
if (uptimeMillis > 0) {
if (!this.mUseExecutor) {
executor = token !== null ? _executor.Executors.newPostAtTimeExecutor(this.mHandler, token, uptimeMillis) : _executor.Executors.newPostDelayedExecutor(this.mHandler, uptimeMillis);
} else {
executor = token !== null ? _executor.Executors.postExecutorAtTime(this.mHandler, this.mExecutor, token, uptimeMillis) : _executor.Executors.postExecutorDelayed(this.mHandler, this.mExecutor, uptimeMillis);
}
} else {
executor = !this.mUseExecutor ? _executor.Executors.newPostExecutor(this.mHandler) : this.mExecutor;
}
return this.executeOnExecutor(executor, params);
}
}, {
key: 'isCancelled',
value: function isCancelled() {
return this.mIsCancelled;
}
}, {
key: 'isInvoked',
value: function isInvoked() {
return this.mTaskInvoked;
}
}, {
key: 'isUsingExecutor',
value: function isUsingExecutor() {
return this.mUseExecutor;
}
}, {
key: 'join',
value: function join() {
var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
onComplete = _ref7.onComplete,
_ref7$timeout = _ref7.timeout,
timeout = _ref7$timeout === undefined ? 0 : _ref7$timeout,
_ref7$unit = _ref7.unit,
unit = _ref7$unit === undefined ? _time.MILLISECONDS : _ref7$unit,
_ref7$uncaughtExcepti = _ref7.uncaughtExceptionHandler,
uncaughtExceptionHandler = _ref7$uncaughtExcepti === undefined ? null : _ref7$uncaughtExcepti;
unit.timedJoin(onComplete, timeout, uncaughtExceptionHandler);
}
}, {
key: 'notify',
value: function notify(result) {
this.mResult = result;
if (this.mTaskListener !== null) {
this.mTaskListener.onFinished(result);
} else {
this.mTaskInvoked = true;
this.postResult(result);
}
}
}, {
key: 'onCancelled',
value: function onCancelled(result) {}
}, {
key: 'onPostExecute',
value: function onPostExecute(result) {}
}, {
key: 'onPreExecute',
value: function onPreExecute() {}
}, {
key: 'onProgressUpdate',
value: function onProgressUpdate(values) {}
}, {
key: 'postResult',
value: function postResult(result) {
this.mHandler.obtainMessage({
what: MESSAGE_POST_RESULT,
obj: new AsyncTaskResult({ task: this, data: result }),
target: this.mHandler
}).sendToTarget();
return result;
}
}, {
key: 'postResultIfNotInvoked',
value: function postResultIfNotInvoked(result) {
var wasTaskInvoked = this.mTaskInvoked;
if (!wasTaskInvoked) {
this.postResult(result);
}
}
}, {
key: 'publishProgress',
value: function publishProgress(values) {
if (!this.isCancelled()) {
this.mHandler.obtainMessage({
what: MESSAGE_POST_PROGRESS,
obj: new AsyncTaskResult({ task: this, data: values }),
target: this.mHandler
}).sendToTarget();
}
}
}, {
key: 'recycle',
value: function recycle() {
if (this.mStatus === AsyncTaskStatus.NONE || this.mStatus === AsyncTaskStatus.FINISHED) {
this.mStatus = AsyncTaskStatus.PENDING;
}
}
}, {
key: 'removeTaskListener',
value: function removeTaskListener(listener) {
if (this.mTaskListener === listener) {
this.mTaskListener = null;
}
}
}, {
key: 'setExecutor',
value: function setExecutor(executor) {
this.mExecutor = executor;
}
}, {
key: 'setHandler',
value: function setHandler(handler) {
this.mHandler = handler;
}
}, {
key: 'sleep',
value: function sleep() {
var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
onComplete = _ref8.onComplete,
_ref8$timeout = _ref8.timeout,
timeout = _ref8$timeout === undefined ? 0 : _ref8$timeout,
_ref8$unit = _ref8.unit,
unit = _ref8$unit === undefined ? _time.MILLISECONDS : _ref8$unit,
_ref8$uncaughtExcepti = _ref8.uncaughtExceptionHandler,
uncaughtExceptionHandler = _ref8$uncaughtExcepti === undefined ? null : _ref8$uncaughtExcepti;
unit.sleep(onComplete, timeout, uncaughtExceptionHandler);
}
}, {
key: 'wait',
value: function wait() {
var _ref9 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
onComplete = _ref9.onComplete,
_ref9$timeout = _ref9.timeout,
timeout = _ref9$timeout === undefined ? 0 : _ref9$timeout,
_ref9$unit = _ref9.unit,
unit = _ref9$unit === undefined ? _time.MILLISECONDS : _ref9$unit,
_ref9$uncaughtExcepti = _ref9.uncaughtExceptionHandler,
uncaughtExceptionHandler = _ref9$uncaughtExcepti === undefined ? null : _ref9$uncaughtExcepti;
unit.timedWait(onComplete, timeout, uncaughtExceptionHandler);
}
}], [{
key: 'executeOnPromise',
value: function executeOnPromise() {
var _ref10 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref10$executor = _ref10.executor,
executor = _ref10$executor === undefined ? null : _ref10$executor,
_ref10$handler = _ref10.handler,
handler = _ref10$handler === undefined ? null : _ref10$handler,
_ref10$doInBackground = _ref10.doInBackground,
doInBackground = _ref10$doInBackground === undefined ? null : _ref10$doInBackground,
_ref10$onPreExecute = _ref10.onPreExecute,
onPreExecute = _ref10$onPreExecute === undefined ? null : _ref10$onPreExecute,
_ref10$onProgressUpda = _ref10.onProgressUpdate,
onProgressUpdate = _ref10$onProgressUpda === undefined ? null : _ref10$onProgressUpda,
_ref10$reuse = _ref10.reuse,
reuse = _ref10$reuse === undefined ? true : _ref10$reuse,
_ref10$params = _ref10.params,
params = _ref10$params === undefined ? null : _ref10$params,
_ref10$uptimeMillis = _ref10.uptimeMillis,
uptimeMillis = _ref10$uptimeMillis === undefined ? 0 : _ref10$uptimeMillis,
_ref10$token = _ref10.token,
token = _ref10$token === undefined ? null : _ref10$token;
return new _promise2.default(function (resolve, reject) {
new AsyncTask({
executor: executor,
handler: handler,
doInBackground: doInBackground,
onCancelled: reject,
onPostExecute: resolve,
onPreExecute: onPreExecute,
onProgressUpdate: onProgressUpdate,
reuse: reuse
}).execute(params, uptimeMillis, token);
});
}
}, {
key: 'setDefaultExecutor',
value: function setDefaultExecutor(executor) {
sDefaultExecutor = executor;
}
}]);
return AsyncTask;
}();