blob: a28939979df2265993e6ca72f68d721d754a7faf [file] [log] [blame]
# Copyright 2016 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Facade to access the video-related functionality."""
import functools
import glob
import os
from autotest_lib.client.bin import utils
from autotest_lib.client.cros.multimedia import display_facade
from autotest_lib.client.cros.video import builtin_html5_player
class VideoFacadeLocalError(Exception):
"""Error in VideoFacadeLocal."""
pass
def check_arc_resource(func):
"""Decorator function for ARC related functions in VideoFacadeLocal."""
@functools.wraps(func)
def wrapper(instance, *args, **kwargs):
"""Wrapper for the methods to check _arc_resource.
@param instance: Object instance.
@raises: VideoFacadeLocalError if there is no ARC resource.
"""
if not instance._arc_resource:
raise VideoFacadeLocalError('There is no ARC resource.')
return func(instance, *args, **kwargs)
return wrapper
class VideoFacadeLocal(object):
"""Facede to access the video-related functionality.
The methods inside this class only accept Python native types.
"""
def __init__(self, resource, arc_resource=None):
"""Initializes an video facade.
@param resource: A FacadeResource object.
@param arc_resource: An ArcResource object.
"""
self._resource = resource
self._player = None
self._arc_resource = arc_resource
self._display_facade = display_facade.DisplayFacadeLocal(
resource)
self.bindir = os.path.dirname(os.path.realpath(__file__))
def cleanup(self):
"""Clean up the temporary files."""
for path in glob.glob('/tmp/playback_*'):
os.unlink(path)
if self._arc_resource:
self._arc_resource.cleanup()
def prepare_playback(self, file_path, fullscreen=True):
"""Copies the html file to /tmp and loads the webpage.
@param file_path: The path to the file.
@param fullscreen: Plays the video in fullscreen.
"""
# Copies the html file to /tmp to make it accessible.
utils.get_file(
os.path.join(self.bindir, 'video.html'),
'/tmp/playback_video.html')
html_path = 'file:///tmp/playback_video.html'
tab = self._resource._browser.tabs.New()
tab.Navigate(html_path)
self._player = builtin_html5_player.BuiltinHtml5Player(
tab=tab,
full_url=html_path,
video_id='video',
video_src_path=file_path)
self._player.load_video()
if fullscreen:
self._display_facade.set_fullscreen(True)
def start_playback(self, blocking=False):
"""Starts video playback on the webpage.
Before calling this method, user should call prepare_playback to
put the files to /tmp and load the webpage.
@param blocking: Blocks this call until playback finishes.
"""
self._player.play()
if blocking:
self._player.wait_video_ended()
def pause_playback(self):
"""Pauses playback on the webpage."""
self._player.pause()
def dropped_frame_count(self):
"""
Gets the number of dropped frames.
@returns: An integer indicates the number of dropped frame.
"""
return self._player.dropped_frame_count()
@check_arc_resource
def prepare_arc_playback(self, file_path, fullscreen=True):
"""Copies the video file to be played into container and starts the app.
User should call this method to put the file into container before
calling start_arc_playback.
@param file_path: Path to the file to be played on Cros host.
@param fullscreen: Plays the video in fullscreen.
"""
self._arc_resource.play_video.prepare_playback(file_path, fullscreen)
@check_arc_resource
def start_arc_playback(self, blocking_secs=None):
"""Starts playback through Play Video app.
Before calling this method, user should call set_arc_playback_file to
put the file into container and start the app.
@param blocking_secs: A positive number indicates the timeout to wait
for the playback is finished. Set None to make
it non-blocking.
"""
self._arc_resource.play_video.start_playback(blocking_secs)
@check_arc_resource
def pause_arc_playback(self):
"""Pauses playback through Play Video app."""
self._arc_resource.play_video.pause_playback()
@check_arc_resource
def stop_arc_playback(self):
"""Stops playback through Play Video app."""
self._arc_resource.play_video.stop_playback()