shinnonoir / likelines-player Goto Github PK

Trigger-happy users who click the Like button too often will get a lot of overlapping like stars, which are not very useful and also hard to differentiate. It might be a nice idea to cluster them or something :)

Environment: Firefox, latest version / IE 10

The 'Like' markers are not vertically aligned with the seek bar. They align only at the middle of the video. It looks to me like the width of the 'Like' bar is larger than the width of the seek bar.

Steps to reproduce: click the 'Like' button just after the video starts or just before the video ends.

The function updateHeatmap() creates an initial playback array of length d (duration) filled with zeros. This array represents how often each second is played. The bins in this array are incremented by iterating through the collection of intervals that the LikeLines server returns.

A problem arises when there is an [x, d] interval. In this particular case, updateHeatmap() tries to increment playback[d], which is undefined.

At the moment several manual steps are needed to install the reference backend server. It'd be nice if you could easily install the server using pip, e.g.

pip install git+https://github.com/ShinNoNoir/likelines-player.git

Outstanding heat-map requests should be ignored when loading a new video.

Example trace:

• Load video 1.
• Heat-map 1 gets requested.
• Load video 2.
• Heat-map 2 gets requested.
• Receive heat-map 2 and paint it.
• Receive heat-map 1 and paint it.

A classical example that is covered by e.g. Rx combinators, so it shouldn't be too difficult to solve.

When a page is zoomed in IE10 (both desktop and metro), the clicked time-point is incorrectly computed.

Possibly related:
IE10: window.pageYOffset incorrect value when page zoomed - breaks jQuery etc.

Currently, the LikeLines component sends the collected feedback to a remote server. The LikeLines player can be more versatile if it would support different kinds of backends. The following two backend types should be considered as new features:

• Null backend
• Form backend

The null backend is useful when the collected feedback is not important, e.g., for testing purposes.

The form backend is useful when the LikeLines player is embedded in a form. Example applications include using the LikeLines player in Amazon Mechanical Turk HITs.

Cookies set by the LikeLines server are not sent by IE for subsequent requests when the server is running on a different domain than the page that embeds the LikeLines player.

The cookie is used by the LikeLines server for tracking the session across different HTTP requests. If a browser does not include this session cookie (or an incorrect one), sendInteractions requests are denied by the server.

Heat maps for videos with few interactions look rough. Introducing smoothing based on the number of (non-zero) interaction sessions would make the heat maps more visually appealing.

LikeLines.Util.scaleArray(xs, 0) gives incorrect results when the input array contains 1 or 2 elements.

Expected output: []
Actual output: [xs[xs.length-1]]

The LikeLines player currently sends two concurrent AJAX calls to the backend server during initialization:

• createSession
• aggregate

The first call is to create a new session for recording interactions. The second call is needed for drawing the heat map.

A problem arises when a user has not contacted the backend server before. In this case, both calls will be without a cookie and in both cases the server will create a new user ID. Interactions sessions are tied to a user ID. If the cookie from the aggregate wins (i.e., arrives last), then subsequent calls to the server will contain a user ID that does not match the interactions session.

The function LikeLines.Util.scaleArray() does not correctly downscale an array. The "smoothing" performed in this function reduces each value in the scaled array to the mean value of the original array.

Currently dragging on the heat-map will freeze the current frame in the video until the dragging operation ends.

Request: Show a preview (by e.g. performing seeks) when the user briefly stops moving the mouse cursor.

It would be nice to have a context menu displayed when right clicking the star icons of the favorites, which would allow the user to fetch the time of any likes, for example.

Sometimes when the LikeLines player has been loaded, the heatmap is completely painted black.

Workaround:
Call player.updateHeatmap() again manually

Current hypothesis:
Some racing condition causing the heatmap code to be run at the wrong moment.

It would be nice to have an overlay in full screen mode, which displays the LikeLines seek bar, the favorites and the 'Favorite' button.

Currently, if the LikeLines back-end server is down (or the URL is incorrect), "Likes" cannot be stored, yet this is not communicated to the user at all.

Example scenario:

• Load a video with 0 interactions;
• Play the video;
• Press END;
• Update the heat map by reloading the video.

Expected result:

• The updated heat map should only contain a "hot" region for the beginning of the video.

Actual result:

• The whole heat map is considered to be "hot" (i.e., fully painted red with the default palette).

Bug location: server/LikeLines/api.py

Running the demo now requires 3 processes:

• mongod for storage;
• SimpleHTTPServer (or another web server of choice) to serve the demo page;
• The LikeLines back-end reference server.

It would be more user-friendly if the LikeLines back-end server can also serve the demo page, eliminating the need for a separate HTTP server.

The YouTube internal player currently shows related videos after normal playback has ended. Clicking a related video will start playback, but this event is not handled correctly: No new LikeLines session is created.

Either related videos should not be shown at all (?rel=0) or this particular event needs to be detected and handled (UNSTARTED==-1).