Merge branch 'master'

nativescript-core/timer/Readme.md

@@ -0,0 +1,34 @@
+Timer module. Functions also can be availble in the global context if you require *globals* module.
+```js
+    require("globals");
+
+	setTimeout(function(){ log("Test"); }, 2000);
+
+	var id = setTimeout(function(){ log("Test"); }, 2000);
+	...
+	clearTimeout(id);
+
+	setInterval(function(){ log("Test"); }, 2000);
+
+	var intervalId = setInterval(function(){ log("Test"); }, 2000);
+	...
+	clearInterval(intervalId)
+```
+OR
+```js
+    var timer = require("timer");
+
+	timer.setTimeout(function(){ log("Test"); }, 2000);
+
+	var id = timer.setTimeout(function(){ log("Test"); }, 2000);
+	...
+	timer.clearTimeout(id);
+
+	timer.setInterval(function(){ log("Test"); }, 2000);
+
+	var intervalId = timer.setInterval(function(){ log("Test"); }, 2000);
+	...
+	timer.clearInterval(intervalId)
+```
+
+The second parameter for setTimeout and setInterval is optional with default value of 0.

nativescript-core/timer/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "timer",
+  "main": "timer",
+  "types": "timer.d.ts",
+  "nativescript": {}
+}

nativescript-core/timer/timer.android.ts

@@ -0,0 +1,80 @@
+/**
+ * Android specific timer functions implementation.
+ */
+let timeoutHandler;
+const timeoutCallbacks = {};
+let timerId = 0;
+
+function createHandlerAndGetId(): number {
+    if (!timeoutHandler) {
+        timeoutHandler = new android.os.Handler(android.os.Looper.myLooper());
+    }
+
+    timerId++;
+
+    return timerId;
+}
+
+export function setTimeout(callback: Function, milliseconds = 0, ...args): number {
+    // Cast to Number
+    milliseconds += 0;
+
+    const id = createHandlerAndGetId();
+    const invoke = () => callback(...args);
+    const zoneBound = zonedCallback(invoke);
+
+    const runnable = new java.lang.Runnable({
+        run: () => {
+            zoneBound();
+
+            if (timeoutCallbacks[id]) {
+                delete timeoutCallbacks[id];
+            }
+        }
+    });
+
+    if (!timeoutCallbacks[id]) {
+        timeoutCallbacks[id] = runnable;
+    }
+
+    timeoutHandler.postDelayed(runnable, long(milliseconds));
+
+    return id;
+}
+
+export function clearTimeout(id: number): void {
+    let index = id;
+    if (timeoutCallbacks[index]) {
+        timeoutHandler.removeCallbacks(timeoutCallbacks[index]);
+        delete timeoutCallbacks[index];
+    }
+}
+
+export function setInterval(callback: Function, milliseconds = 0, ...args): number {
+    // Cast to Number
+    milliseconds += 0;
+
+    const id = createHandlerAndGetId();
+    const handler = timeoutHandler;
+    const invoke = () => callback(...args);
+    const zoneBound = zonedCallback(invoke);
+
+    const runnable = new java.lang.Runnable({
+        run: () => {
+            zoneBound();
+            if (timeoutCallbacks[id]) {
+                handler.postDelayed(runnable, long(milliseconds));
+            }
+        }
+    });
+
+    if (!timeoutCallbacks[id]) {
+        timeoutCallbacks[id] = runnable;
+    }
+
+    timeoutHandler.postDelayed(runnable, long(milliseconds));
+
+    return id;
+}
+
+export const clearInterval = clearTimeout;

nativescript-core/timer/timer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Allows you to create, start, stop and react to timers.
+ * @module "timer"
+ */ /** */
+
+/**
+ * Calls a function after a specified delay.
+ * @param callback The function to be called.
+ * @param milliseconds The time to wait before the function is called. Defaults to 0.
+ * @param args One or more parameter to use once the function is called. Defaults to no parameters.
+ */
+export function setTimeout(callback: Function, milliseconds?: number, ...args: any[]): number;
+
+/**
+ * Clears the delay set by a call to the setTimeout function.
+ * @param id The identifier returned by the previously called setTimeout() method.
+ */
+export function clearTimeout(id: number): void;
+
+/**
+ * Calls a function repeatedly with a delay between each call.
+ * @param callback The function to be called.
+ * @param milliseconds The delay between each function call.
+ * @param args One or more parameter to use once the function is called. Defaults to no parameters.
+ */
+export function setInterval(callback: Function, milliseconds?: number, ...args: any[]): number;
+
+/**
+ * Clears repeated function which was set up by calling setInterval().
+ * @param id The identifier returned by the setInterval() method.
+ */
+export function clearInterval(id: number): void;

nativescript-core/timer/timer.ios.ts

@@ -0,0 +1,87 @@
+//iOS specific timer functions implementation.
+const timeoutCallbacks = new Map<number, KeyValuePair<NSTimer, TimerTargetImpl>>();
+let timerId = 0;
+
+interface KeyValuePair<K, V> {
+    k: K;
+    v: V;
+}
+
+class TimerTargetImpl extends NSObject {
+    private callback: Function;
+    private disposed: boolean;
+    private id: number;
+    private shouldRepeat: boolean;
+
+    public static initWithCallback(callback: Function, id: number, shouldRepeat: boolean): TimerTargetImpl {
+        let handler = <TimerTargetImpl>TimerTargetImpl.new();
+        handler.callback = callback;
+        handler.id = id;
+        handler.shouldRepeat = shouldRepeat;
+
+        return handler;
+    }
+
+    public tick(timer): void {
+        if (!this.disposed) {
+            this.callback();
+        }
+
+        if (!this.shouldRepeat) {
+            this.unregister();
+        }
+    }
+
+    public unregister() {
+        if (!this.disposed) {
+            this.disposed = true;
+
+            let timer = timeoutCallbacks.get(this.id).k;
+            timer.invalidate();
+            timeoutCallbacks.delete(this.id);
+        }
+    }
+
+    public static ObjCExposedMethods = {
+        "tick": { returns: interop.types.void, params: [NSTimer] }
+    };
+}
+
+function createTimerAndGetId(callback: Function, milliseconds: number, shouldRepeat: boolean): number {
+    // Cast to Number
+    milliseconds += 0;
+
+    timerId++;
+    let id = timerId;
+    let timerTarget = TimerTargetImpl.initWithCallback(callback, id, shouldRepeat);
+    let timer = NSTimer.scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeats(milliseconds / 1000, timerTarget, "tick", null, shouldRepeat);
+
+    // https://github.com/NativeScript/NativeScript/issues/2116
+    NSRunLoop.currentRunLoop.addTimerForMode(timer, NSRunLoopCommonModes);
+
+    let pair: KeyValuePair<NSTimer, TimerTargetImpl> = { k: timer, v: timerTarget };
+    timeoutCallbacks.set(id, pair);
+
+    return id;
+}
+
+export function setTimeout(callback: Function, milliseconds = 0, ...args): number {
+    let invoke = () => callback(...args);
+
+    return createTimerAndGetId(zonedCallback(invoke), milliseconds, false);
+}
+
+export function clearTimeout(id: number): void {
+    let pair = timeoutCallbacks.get(<number><any>id);
+    if (pair) {
+        pair.v.unregister();
+    }
+}
+
+export function setInterval(callback: Function, milliseconds = 0, ...args): number {
+    let invoke = () => callback(...args);
+
+    return createTimerAndGetId(zonedCallback(invoke), milliseconds, true);
+}
+
+export const clearInterval = clearTimeout;