blob: c28fb0b226b1976cd328fd3c86a85caf2fbedc9b [file] [log] [blame]
// Copyright 2020 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef COBALT_DOM_LOTTIE_PLAYER_H_
#define COBALT_DOM_LOTTIE_PLAYER_H_
#include <string>
#include "base/message_loop/message_loop.h"
#include "cobalt/dom/event_queue.h"
#include "cobalt/dom/html_element.h"
#include "cobalt/loader/image/image_cache.h"
#include "cobalt/render_tree/lottie_animation.h"
#include "cobalt/script/environment_settings.h"
#include "cobalt/script/global_environment.h"
#include "cobalt/script/union_type.h"
namespace cobalt {
namespace dom {
class Document;
typedef render_tree::LottieAnimation LottieAnimation;
// Custom element that represents a Lottie web player, which embeds and plays
// Lottie animations.
// Although LottiePlayer does not inherit from HTMLImageElement, much of its
// functionality is based off that of HTMLImageElement - in particular, loading
// the animation pointed to by the "src" attribute.
// https://lottiefiles.github.io/lottie-player/
class LottiePlayer : public HTMLElement {
public:
static const char kTagName[];
typedef script::UnionType2<double, std::string> FrameType;
explicit LottiePlayer(Document* document);
// Web API: LottiePlayer
//
std::string src() const;
void set_src(const std::string& src);
bool autoplay() const;
void set_autoplay(bool loop);
std::string background() const;
void set_background(std::string background);
int count() const;
void set_count(int count);
int direction() const;
void set_direction(int direction);
bool hover() const;
void set_hover(bool hover);
bool loop() const;
void set_loop(bool loop);
std::string mode() const;
void set_mode(std::string mode);
double speed() const;
void set_speed(double speed);
std::string preserve_aspect_ratio() const;
std::string renderer() const;
void Load(std::string src);
void Play();
void Pause();
void Stop();
void Seek(FrameType frame);
void SetDirection(int direction);
void SetLooping(bool loop);
void SetSpeed(double speed);
void ToggleLooping();
void TogglePlay();
// Custom, not in any spec
//
// From HTMLElement
scoped_refptr<LottiePlayer> AsLottiePlayer() override { return this; }
const scoped_refptr<loader::image::CachedImage>& cached_image() {
return cached_image_;
}
LottieAnimation::LottieProperties GetProperties() const;
// These functions will be called when there is a hover change for the
// element.
void OnHover();
void OnUnHover();
DEFINE_WRAPPABLE_TYPE(LottiePlayer);
private:
~LottiePlayer() override {}
// From Node.
void PurgeCachedBackgroundImagesOfNodeAndDescendants() override;
// From Element.
void OnSetAttribute(const std::string& name,
const std::string& value) override;
void OnRemoveAttribute(const std::string& name) override;
void UpdateAnimationData();
void OnLoadingSuccess();
void OnLoadingError();
void PreventGarbageCollectionUntilEventIsDispatched(base::Token event_name);
void AllowGarbageCollectionAfterEventIsDispatched(
base::Token event_name,
std::unique_ptr<script::GlobalEnvironment::ScopedPreventGarbageCollection>
scoped_prevent_gc);
void DestroyScopedPreventGC(
std::unique_ptr<script::GlobalEnvironment::ScopedPreventGarbageCollection>
scoped_prevent_gc);
void UpdateState(LottieAnimation::LottieState state);
void UpdatePlaybackStateIfAutoplaying();
void SetCount(int count);
void SetMode(std::string mode);
void SetMode(LottieAnimation::LottieMode mode);
void UpdateLottieObjects();
void ScheduleEvent(base::Token event_name);
void SetAnimationEventCallbacks();
// These are callbacks triggered during animation playback.
void OnPlay();
void OnPause();
void OnStop();
void OnComplete();
void OnLoop();
void OnEnterFrame(double frame, double seeker);
static void CallOnEnterFrame(
scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner,
base::Callback<void(double, double)> enter_frame_callback, double frame,
double seeker);
void OnFreeze();
void OnUnfreeze();
scoped_refptr<loader::image::CachedImage> cached_image_;
std::unique_ptr<loader::image::CachedImage::OnLoadedCallbackHandler>
cached_image_loaded_callback_handler_;
std::unique_ptr<script::GlobalEnvironment::ScopedPreventGarbageCollection>
prevent_gc_until_load_complete_;
// Indicates whether playback is dictated by the "autoplay" attributes, or
// if other playback methods have been called.
bool autoplaying_;
LottieAnimation::LottieProperties properties_;
EventQueue event_queue_;
scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner_;
};
} // namespace dom
} // namespace cobalt
#endif // COBALT_DOM_LOTTIE_PLAYER_H_