I'm working on a Pomodoro-esque timer. The timer must be able to do the following:
When 'Start' button is pressed:
Start 5 second timer. Times will change, of course)
After timer expires, send AJAX event with start and end timestamp
Start a 3 second timer.
After timer expires, start a new 5 second timer. (Loop step 1 to 3 a total of FOUR times)
At the end of the fourth loop, start a 7 second timer.
After the 7 second timer expires, start the 5-3 loop again.
When 'Stop' button is pressed:
Cancel the timer, reset it back to the default state.
This is the code I have now:
HTML
<html>
<head>
<meta charset="UTF-8">
<title>Pomodoro Test</title>
<link rel="stylesheet" type="text/css" href="main.css">
</head>
<body>
<div id="test"></div>
<div id="timer">5</div>
<button id="start">Start</button>
<button id="reset">Reset</button>
<div id="startTime"></div>
<div id="endTime"></div>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>
<script src="functions.js"></script>
</body>
</html>
JavaScript:
var timer = 5;
var flag = 0;
var startTime;
var endTime;
var intervalTimer;
function update() {
if (timer-- > 0) {
$("#timer").html(timer); // retrieve value from html
} else {
endTime = new Date();
//alert("Start Time = " + startTime + "\nEnd Time = " + endTime);
$("#endTime").html("End time: " + endTime.toTimeString());
resetTimer();
// TODO: send ajax call to server, sending startTime and endTime
// so that these can be saved to database
}
}
function loopingTimer() {
while(flag === 0) {
startTime = new Date();
$("#startTime").html("Start time: " + startTime.toTimeString());
startTimer();
i++;
setTimeout(function() {
if(i < 5) {
loopingTimer();
}
}, 3001)}};
$("#start").click(function() {
loopingTimer();
});
$("#reset").click(function() {
flag = 1;
});
function startTimer() {
intervalTimer = window.setInterval(update, 500);
}
function resetTimer() {
stopTimer();
timer = 5;
$("#timer").text(timer);
}
function stopTimer() {
window.clearInterval(intervalTimer);
}
I find it extremely difficult to get the desired functionality, I've been tinkering with this code for 2 days. I sincerely hope you guys can help me out.
Cake.
The while loop, in the loopingTimer function, does (simplified):
while (userDidntStop) {
startTimer();
}
The break condition is that the user clicks on a button. If the user does so after 500 loopings (a very very very short time), then this loop will have created about 500 timers. The biggest issue is here: avoid running timers (or intervals the same) within loops.
Another issue is that startTime is reset in the almost-infinite loop. You could merge loopingTimer with startTimer, as they do basically a single thing, which is starting the timer, and thus preventing
Also, you use the timer variable to check for the elapsed time. Browsers do not have the obligation to provide the specified delays (at least for setTimeout, according to the MDN documentation. I think it is also the case for setInterval). Therefore, it is safer to instantiate a new Date(), in order to always have the right time.
Also, it is posible to store the sequence of timers somewhere (ie, in an array), to allow modifying this sequence at any time, and also looping easily through it.
Following these points, I would have written something like the following code. Remember that this is an illustration, it might not produce your desired behavior.
var timeLoop = [5, 3, 5, 3, 5, 3, 5, 3, 7]; // seconds
var timeIterator = timeLoop.length;
var startTime;
var endTime;
var intervalTimer;
function sendTimer() { // once the timer ends, send it
// send AJAX request with startTime and endTime here
}
function updateTimer() { // main timer loop
var now = Date.now(); // make sure you have the right time
var diff = endTime - now;
if (diff <= 0) { // if endTime is past, stop and send the timer
diff = 0;
clearInterval(intervalTimer);
sendTimer();
}
// Update the displayed time using diff (ms)
}
function resetTimer() { // to call on $("#reset").click
if (endTime > Date.now()) {
endTime = Date.now();
updateTimer(); // reset the displayed time, and stop updateTimer
// note that this will call sendTimer() with the _aborted_ time
}
}
function startTimer() { // to call on $("#start").click
resetTimer();
// We will loop throught the timeLoop every time we start the timer
if (timeLoop.length < ++timeIterator) {
timeIterator = 0;
}
startTime = Date.now();
endTime = startTime + 1000 * timeLoop[timeIterator];
intervalTimer = setInterval(updateTimer, 500);
}
Related
I am currently working with a javascript that is supposed to remove some unwanted cookies, but for some reason aren't they removed when told to?..
only after certain amount of times trying to remove them, they seem to be removed.. some sort of delayed effect?
here is the code:
const name = 'test_u';
const name1 = 'test_te_s';
function eraseCookie(name) {
document.cookie = name+'=; Max-Age=-99999999;';
}
function removeCookies(cookieA, cookieB) {
setInterval(function() {
if (document.cookie.includes(cookieA) || document.cookie.includes(cookieB))
{
eraseCookie(cookieA);
eraseCookie(cookieB);
var date = new Date();
var timestamp = date.getTime();
console.log(timestamp)
}
},10000);
}
removeCookies(name, name1);
example from console log output:
1555420706478
1555420716477
1555420726487
1555420736487
1555420746497
1555420756487
It runs 6 times before its removed? but why though?
why aren't they removed immediately?
Because you have setInterval which means that that code will be run after some time that you provide, and keep repeating it by that interval. So just remove that setInterval:
function removeCookies(cookieA, cookieB) {
if (document.cookie.includes(cookieA) || document.cookie.includes(cookieB)) {
eraseCookie(cookieA);
eraseCookie(cookieB);
var date = new Date();
var timestamp = date.getTime();
console.log(timestamp)
}
}
And if you want to keep repeating it try this one:
removeCookies(name, name1);
setInterval(() => {
removeCookies(name, name1);
}, 10000);
or
function removeCookies(cookieA, cookieB) {
if (document.cookie.includes(cookieA) || document.cookie.includes(cookieB)) {
eraseCookie(cookieA);
eraseCookie(cookieB);
var date = new Date();
var timestamp = date.getTime();
console.log(timestamp)
}
setInterval(() => {
removeCookies()
}, 10000);
}
removeCookies(name, name1);
so it will first call removeCookies, and then it will keep repeating.
Is there any default way in JavaScript to check user activity. If not how to address this issue.
There is no default way of doing this in java script. One way to address this issue is using JavaScript events.
this.lastActiveTime = new Date();
window.onclick = function () {
this.lastActiveTime= new Date();
};
window.onmousemove = function () {
this.lastActiveTime= new Date();
};
window.onkeypress = function () {
this.lastActiveTime= new Date();
};
window.onscroll = function () {
this.lastActiveTime= new Date();
};
let idleTimer_k = window.setInterval(CheckIdleTime, 10000);
function CheckIdleTime() {
//returns idle time every 10 seconds
let dateNowTime = new Date().getTime();
let lastActiveTime = new Date(this.lastActiveTime).getTime();
let remTime = Math.floor((dateNowTime-lastActiveTime)/ 1000);
// converting from milliseconds to seconds
console.log("Idle since "+remTime+" Seconds Last active at "+this.lastActiveTime)
}
<div> APP Here <br/><br/><br/><br/><br/><br/>make activity here<br/><br/><br/><br/><br/>Till here </div>
Here is the short example of the functionality where something will happen if user was inactive for around 10 minutes.
Upon init of the app:
window.lastActivity = Date.now();
document.addEventListener('click', function(){
window.lastActivity = Date.now();
})
Somewhere in particular service:
var TIMEOUT = 600000 //10 mins
var activityChecker = setInterval(check, 3000);
function check() {
var currentTime = Date.now();
if (currentTime - window.lastActivity > TIMEOUT) {
// do something useful, for example logout or whatever
}
}
This approach is nice because it doesn't depend on some timers which are working incorrectly if user minimize browser or switch to another tab, etc.
We just check current timestamp with the lastActivity timestamp every few seconds.
You can change 'click' event in my code with any other type of event you need or with any other condition which is suitable for you to consider user as active.
It's actually a follow up to this question I want to display elements from json based on their time and duration and interval is interupted by settimeout - I accepted the answer there made by #Daniel Flint - his code is quite clear and can be found here http://jsfiddle.net/nauzilus/rqctam5r/
However, there's one more thing that I wanted to add - a simple div <div id="time"></div> that would contain a new date time object initialized during opening the page and then it being incremented every second just to show the current time constantly. I thought about writing there a javascript:
var actualTime = new Date(substractedDate); // taken from the server
function updateTimeBasedOnServer(timestamp) {
var calculatedTime = moment(timestamp);
var dateString = calculatedTime.format('h:mm:ss A');
$('#time').html(dateString + ", ");
};
var timestamp = actualTime.getTime();
updateTimeBasedOnServer(timestamp);
setInterval(function () {
timestamp += 1000; // Increment the timestamp at every call.
updateTimeBasedOnServer(timestamp);
}, 1000);
(I provide the time of the server as a timestamp there).
I just noticed that there is a slight mismatch between displaying the time in my div and between the text appearing on the screen, possibly because I increment both of the values in two different places.
So my question is - how can I "merge" #Daniel Flint's code with mine and increment both values only in one place?
One thing that jumps out here:
timestamp += 1000;
setTimeout/setInterval aren't guaranteed to run at precisely the delay you've entered. Run this in your browsers console:
var last = Date.now(),
time = function() {
var now = Date.now();
console.log(now - last);
last = now;
},
id = setInterval(time, 1000);
On my Mac at home (Chrome/FireFox) it was anywhere from 990 to 1015. Windows machine at work is a bit better (995-1002), but IE was getting up to 1020. It's not a huge difference, but it's not nothing.
So code needs to be able to handle not running exactly every 1000ms. That's why I was running the timer at 500ms intervals, and checking if the start time was less-than-equal to the current time.
I've rejigged the demo to show the time and message in sync:
(function() {
var messages = [];
var time = document.getElementById("current-time");
var display = document.getElementById("message");
function check() {
showMessage(currentMessage());
showTime();
}
function currentMessage() {
var message = null;
if (messages.length) {
var now = toTheSecond(new Date());
var start = toTheSecond(new Date(messages[0].start_time));
var end = toTheSecond(new Date(start.getTime() + ( messages[0].text_duration * 1000 )));
if (start <= now) {
if (end <= now) {
// done with the current message...
messages = messages.slice(1);
// ...but check if there's another one ready to go right now
message = currentMessage();
}
else {
message = messages[0];
}
}
}
return message;
}
function toTheSecond(date) {
date.setMilliseconds(0);
return date;
}
function showMessage(message) {
if (message) {
display.textContent = message.text_content;
}
else {
display.textContent = "no messages";
}
}
function showTime() {
time.textContent = new Date().toLocaleString()
}
function getMessages() {
setTimeout(function() {
var now = new Date();
messages.push(
{"text_content":"aaaaa","text_duration":5,"start_time": new Date(now.getTime() + 3000).toISOString()},
{"text_content":"aawwaaaaa","text_duration":5,"start_time": new Date(now.getTime() + 10000).toISOString()},
{"text_content":"bbaawwaaaaa","text_duration":5,"start_time": new Date(now.getTime() + 15000).toISOString()}
);
}, 1000);
}
setInterval(check, 500);
getMessages();
})();
<span id="current-time"></span> <span id="message">Hello there!</span>
(Putting the code here as well because I recall SO want code in the answers so it's controlled, but there's a demo here: http://jsfiddle.net/nauzilus/ymp0615g/).
This probably isn't as efficient as it could be; the message text is being set every iteration which might cause repaints/reflow. But then again setting the time stamp is going to do that anyway, so meh :)
I'm developing an app and I'm interested in ways to achive a Candy Crush Saga Type countdown life system.
My app is developed in phonegap (so html, css jquery and jquery mobile) and untill now I havn't figured out how to work with an external file as I'm thinking it's needed in this algorithm.
I want therefore to have 5 lives and each of them dissapears when the user fail or quit the lvl and regenerates after, lets say, 10 minutes. How can I keep the counter active if the app is closed?
Or a date substraction algorithm...
If somebody have knowledge in Phonegap I would be very grateful if he could help me with a jsfiddle wich I'll implement further in my app.
I'm also not sure what to use: localstorage vs DB
I'll give 50 of my bounty for the one who can help me with a jsfiddle example for this issue.
Thank you!
Edit: Sorry this is some pseudo code based off PHP - but you don't need crazy algorithms or anything
I don't write phone apps, but I know what you're trying to do and you're thinking about it too hard. You don't need to run the counter while the app is closed. You can save a timestamp from when the game is over, and reference it the next time the app is opened.
start_game();
if($lives > 0){ //run game
if($death === true){
$lives = $lives - 1;
$timer_value = date(Y-m-d h:i:s);
end_game($timer_value); //save starting time locally in "end_game" function
}
} else {
//buy more lives
}
Now let's say the user closes it and opens up. You can reference the current time versus the saved time. For every 10 minutes past then, add a life.
$old_time = strtotime($timer_value); //635393400
$cur_time = strtotime(date(Y-m-d h:i:s)); //635394600
if( $cur_time - $old time > 600 ) { $lives = $lives + 1; }
if( $cur_time - $old time > 1200 ) { $lives = $lives + 2; }
if( $cur_time - $old time > 1800 ) { $lives = $lives + 3; }
if( $cur_time - $old time > 2400 ) { $lives = $lives + 4; }
if( $cur_time - $old time > 3000 ) { $lives = $lives + 5; }
if( $lives > 5 ) { $lives = 5; }
That's some awful code lol, but you gut the idea. You don't need to run a timer in the background (you can't really with the app being closed, without doing some sort of server checks online, which is basically the same thing, but hosting all that personal life records in the cloud instead of on the phone.
In this code I use the localStorage since they are available on all platforms and web.
Using local storage you will get better cross platform compatibility:
WebStorage (localStorage & sessionStorage)
IndexedDB
SQL-Storage
Localstorage is array, but every element can only have string in it (using JSON we can store anything, that is not recursive). It is about 5MB for web. I guess it is limitless for mobile app. SessionStorage is deleted when user close browser and I am not sure how it will do on mobile.
Just a small date validator...
Date.prototype.isValid = function(first_argument) {
if ( Object.prototype.toString.call(this) !== "[object Date]" )
return false;
return !isNaN(this.getTime());
}
The main var declaration among retrieving variables from localStorage
var timeout = null;
var maxlife = 5;
if (undefined === localStorage.life) {
localStorage.life = maxlife;
}
if (undefined === localStorage.date||localStorage.date=="") {
localStorage.date = "";
var date = null;
}else{
var date = new Date(Number(localStorage.date));
if(!date.isValid()){
date = null;
}
}
var timeoutTime = 5 * 60000;
var life = Number(localStorage.life);
Lose life, set date if none exist yet. Set a timeout too and subtract life (& write it into localstorage).
function loseLife() {
if (null === date) {
date = new Date();
localStorage.date = date.getTime();
timeout = setTimeout(function(){addLife()}, timeoutTime);
}
life--;
localStorage.life = life;
lives.innerHTML = life;
console.log(life);
}
Add life, set date new date or reset the date completely. Set a timeout, if needed, and add a life (& write it into localstorage).
function addLife() {
life++;
localStorage.life = life;
if (life < maxlife) {
date = new Date();
localStorage.date = date.getTime();
timeout = setTimeout(function(){addLife()}, timeoutTime);
} else {
date = null;
localStorage.date = "";
}
lives.innerHTML = life;
}
Here you may need to change the hooks for blur (window not visible) and focus (window visible once again). Blur just clear timeout so it don't mess with us.
window.addEventListener('blur', function () {
clearTimeout(timeout);
});
This function check how many time it can subtract our time needed to get life from difference of now and the date we lost a life.
function tillNow(){
if (life < maxlife&&date!=null) {
var d = new Date();
var diff = d - date;
while (diff - timeoutTime > 0) {
diff = diff - timeoutTime;
if (life < maxlife) {
life++;
console.log("add");
}else{
date = null;
localStorage.date = "";
break;
}
}
localStorage.life = life;
if (life < maxlife) {
date = new Date((new Date()).getTime()-diff);
localStorage.date = date.getTime();
timeout = setTimeout(function(){addLife()}, timeoutTime-diff);
}
}
lives.innerHTML = life;
}
Focus just call tillNow()
window.addEventListener('focus', function () {
tillNow();
});
Onload do the same as focus, but fills the div with a value initially...
window.onload=function(){
var lives = document.getElementById("lives");
lives.innerHTML = life;
tillNow();
}
Demo sorry couldn't do jsFiddle of codepen since they don't like local storage. (the demo use 15sec as timer to get new life ;) I am impatient )
I would use logic similar to what Xhynk suggested. I would use a variable like milisecondsUntilYouGainALife and when you lose the first life, set this variable = 1000ms*60sec*10min = 600000. Then first line (or so) in main loop, record the current time. next time it hits the loop also record the time and subtract the difference from milisecondsUntilYouGainALife. If < 0, lives++. Also make sure in your "close the app" function you record the time and check that time in the main loop.
pseudocode:
function game(){
...
while(mainLoop){
oldTime = curTime
curTime = GetTime() //I Forget the exact code to get the miliseconds
deltaTime = curTime - oldTime
if(deltaTime > milisectionsUntilYouGainALife){
if(lives < MAX_LIVES){
lives++
milisecondsUntilYouGainALife - deltaTime
}
}
}
}
function AppClosing(){
curTime = GetTime()
}
function LoseALife(){
milisecondsUntilYouGainALife += 600000
}
There may be something im missing, but this should get you on the right track!
I want to start a timer when the user clicks on a object, and stop it when the user releases the click. All using javascript/jquery.
The following should get you started
var start_time;
function start() {
start_time = new Date();
}
function end() {
var now = new Date();
alert(now-start_time);
}
$('#element_id').mousedown(start);
$('#element_id').mouseup(end);
the mousedown event will run the start function which sets the start time. the mouseup event will substract the start time from the current time. The result is in milliseconds
$("#element").mousedown(); will let you record when the user clicks, and similarly $("#element").mouseup();will let you record when the button is released.
var start = 0;
$("#element").mousedown(function() { start = new Date(); });
$("#element").mouseup(function() {
var cur = new Date();
alert(cur-start);
}
function myTimer() {
doSomething();
}
$('#thing').mousedown(function() {
$(this).data('timerHandle', setTimeout(myTimer));
});
$('#thing').mouseup(function() {
clearTimeout($(this).data('timerHandle'));
}