com.phloxui
Version:
PhloxUI Ng2+ Framework
97 lines (96 loc) • 10 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
import { Injectable } from '@angular/core';
import { PhloxAppInfo } from '../component/model/PhloxAppInfo';
/**
* <p style="text-indent: 2em;">
* A <code>ng</code> service handles the <code>UI</code> system clock logic. The <code>UI</code> system clock is mainly responsible for periodically
* update the system-wide clock to other components. Using clock provided by <code>this</code> service instead of using <code>setInterval()</code> or
* <code>setTimeout()</code> method may be more benefitial in many circumstances. For example, if you have many <code>UI</code> components needed to
* be periodically updated itself in background, without <code>this</code> service, you may need to use <code>setTimeout()</code> / <code>setInterval()</code>
* method for each component. This leads to having poor <code>application</code>'s performance. In spite of that, you can use the <code>system clock</code>
* provided by <code>this</code> service to let all <code>UI</code> components being updated at the same <code>clock tick</code> rate. Furthermore,
* <code>this</code> service also provides you a capability to configure its <code>interval</code>. So, you can haste up or slow down system-wide <code>UI</code>
* updating rate in a single place.
* </p>
*
* @author shiorin, tee4cute
*/
export class UISystemClock {
constructor() {
this.currentDateTime = new Date();
// ! TODO We should auto load the default value from somewhere else instead of hard-coded static field.
this.timerInterval = PhloxAppInfo.DEFAULT_UI_SYSTEM_CLOCK_INTERVAL;
// if(phloxAppService != null){
// phloxAppService.getAppInfo().then((result) => {
// this.phloxAppInfo = result;
// let setting = this.phloxAppInfo.settings;
//
// if (setting.UI_SYSTEM_CLOCK_INTERVAL !== null && typeof setting.UI_SYSTEM_CLOCK_INTERVAL === 'number') {
// this.updateTimerInterval();
// }
// });
// }
this.updateTimerInterval();
}
/**
* @return {?}
*/
updateTimerInterval() {
// update interval
if (this.delayTimer !== null && typeof this.delayTimer !== 'undefined') {
clearInterval(this.delayTimer);
this.delayTimer = null;
}
this.delayTimer = setInterval(() => {
this.currentDateTime = new Date();
}, this.timerInterval);
}
/**
* <p style="text-indent: 1em;">
* Get current <code>system clock</code> datetime.
* </p>
*
* @return {?} A <code>Date</code> object representing current system datetime.
*/
getCurrentClockDateTime() {
// return as a clone of date
return new Date(this.currentDateTime);
}
/**
* <p style="text-indent: 1em;">
* Get current <code>system clock</code> time in milliseconds.
* </p>
*
* @return {?} A number representing current system datetime in milliseconds.
*/
getCurrentClockTime() {
// return as a millisec
return this.currentDateTime.getTime();
}
}
UISystemClock.decorators = [
{ type: Injectable },
];
/** @nocollapse */
UISystemClock.ctorParameters = () => [];
function UISystemClock_tsickle_Closure_declarations() {
/** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
UISystemClock.decorators;
/**
* @nocollapse
* @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
*/
UISystemClock.ctorParameters;
/** @type {?} */
UISystemClock.prototype.currentDateTime;
/** @type {?} */
UISystemClock.prototype.phloxAppInfo;
/** @type {?} */
UISystemClock.prototype.timerInterval;
/** @type {?} */
UISystemClock.prototype.delayTimer;
}
//# sourceMappingURL=data:application/json;base64,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