blob: 50f622a7bcb93d94e91cfa1a0711733da4760907 [file] [log] [blame]
// Copyright 2015 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.
#include "starboard/shared/starboard/application.h"
#include <string>
#include "starboard/atomic.h"
#include "starboard/common/condition_variable.h"
#include "starboard/common/log.h"
#include "starboard/common/scoped_ptr.h"
#include "starboard/common/string.h"
#include "starboard/configuration.h"
#include "starboard/event.h"
#include "starboard/memory.h"
#include "starboard/shared/starboard/command_line.h"
namespace starboard {
namespace shared {
namespace starboard {
namespace {
const char kPreloadSwitch[] = "preload";
const char kLinkSwitch[] = "link";
const char kMinLogLevel[] = "min_log_level";
// Dispatches an event of |type| with |data| to the system event handler,
// calling |destructor| on |data| when finished dispatching. Does all
// appropriate NULL checks so you don't have to.
void Dispatch(SbEventType type, void* data, SbEventDataDestructor destructor) {
SbEvent event;
event.type = type;
event.data = data;
SbEventHandle(&event);
if (destructor) {
destructor(event.data);
}
}
void DeleteStartData(void* data) {
SbEventStartData* start_data = static_cast<SbEventStartData*>(data);
if (start_data) {
delete[] start_data->argument_values;
}
delete start_data;
}
} // namespace
// The next event ID to use for Schedule().
volatile SbAtomic32 g_next_event_id = 0;
Application* Application::g_instance = NULL;
Application::Application()
: error_level_(0),
thread_(SbThreadGetCurrent()),
start_link_(NULL),
state_(kStateUnstarted) {
Application* old_instance =
reinterpret_cast<Application*>(SbAtomicAcquire_CompareAndSwapPtr(
reinterpret_cast<SbAtomicPtr*>(&g_instance),
reinterpret_cast<SbAtomicPtr>(reinterpret_cast<void*>(NULL)),
reinterpret_cast<SbAtomicPtr>(this)));
SB_DCHECK(!old_instance);
}
Application::~Application() {
Application* old_instance =
reinterpret_cast<Application*>(SbAtomicAcquire_CompareAndSwapPtr(
reinterpret_cast<SbAtomicPtr*>(&g_instance),
reinterpret_cast<SbAtomicPtr>(this),
reinterpret_cast<SbAtomicPtr>(reinterpret_cast<void*>(NULL))));
SB_DCHECK(old_instance);
SB_DCHECK(old_instance == this);
SbMemoryDeallocate(start_link_);
}
int Application::Run(CommandLine command_line, const char* link_data) {
Initialize();
command_line_.reset(new CommandLine(command_line));
if (link_data) {
SetStartLink(link_data);
}
return RunLoop();
}
int Application::Run(CommandLine command_line) {
Initialize();
command_line_.reset(new CommandLine(command_line));
if (command_line_->HasSwitch(kLinkSwitch)) {
std::string value = command_line_->GetSwitchValue(kLinkSwitch);
if (!value.empty()) {
SetStartLink(value.c_str());
}
}
#if SB_API_VERSION >= 11
if (command_line_->HasSwitch(kMinLogLevel)) {
::starboard::logging::SetMinLogLevel(::starboard::logging::StringToLogLevel(
command_line_->GetSwitchValue(kMinLogLevel)));
} else {
::starboard::logging::SetMinLogLevel(::starboard::logging::SB_LOG_INFO);
}
#endif // SB_API_VERSION >= 11
return RunLoop();
}
const CommandLine* Application::GetCommandLine() {
return command_line_.get();
}
#if SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION || \
SB_HAS(CONCEALED_STATE)
void Application::Blur(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeBlur, context, callback));
}
void Application::Focus(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeFocus, context, callback));
}
void Application::Conceal(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeConceal, context, callback));
}
void Application::Reveal(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeReveal, context, callback));
}
void Application::Freeze(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeFreeze, context, callback));
}
void Application::Unfreeze(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeUnfreeze, context, callback));
}
#else
void Application::Pause(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypePause, context, callback));
}
void Application::Unpause(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeUnpause, context, callback));
}
void Application::Suspend(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeSuspend, context, callback));
}
void Application::Resume(void* context, EventHandledCallback callback) {
Inject(new Event(kSbEventTypeResume, context, callback));
}
#endif // SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION ||
// SB_HAS(CONCEALED_STATE)
void Application::Stop(int error_level) {
Event* event = new Event(kSbEventTypeStop, NULL, NULL);
event->error_level = error_level;
Inject(event);
}
void Application::Link(const char *link_data) {
SB_DCHECK(link_data) << "You must call Link with link_data.";
Inject(new Event(kSbEventTypeLink, SbStringDuplicate(link_data),
SbMemoryDeallocate));
}
void Application::InjectLowMemoryEvent() {
Inject(new Event(kSbEventTypeLowMemory, NULL, NULL));
}
#if SB_API_VERSION >= 8
void Application::WindowSizeChanged(void* context,
EventHandledCallback callback) {
Inject(new Event(kSbEventTypeWindowSizeChanged, context, callback));
}
#endif // SB_API_VERSION >= 8
SbEventId Application::Schedule(SbEventCallback callback,
void* context,
SbTimeMonotonic delay) {
SbEventId id = SbAtomicNoBarrier_Increment(&g_next_event_id, 1);
InjectTimedEvent(new TimedEvent(id, callback, context, delay));
return id;
}
void Application::Cancel(SbEventId id) {
CancelTimedEvent(id);
}
void Application::HandleFrame(SbPlayer player,
const scoped_refptr<VideoFrame>& frame,
int z_index,
int x,
int y,
int width,
int height) {
AcceptFrame(player, frame, z_index, x, y, width, height);
}
void Application::SetStartLink(const char* start_link) {
SB_DCHECK(IsCurrentThread());
SbMemoryDeallocate(start_link_);
if (start_link) {
start_link_ = SbStringDuplicate(start_link);
} else {
start_link_ = NULL;
}
}
void Application::DispatchStart() {
SB_DCHECK(IsCurrentThread());
#if SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION || \
SB_HAS(CONCEALED_STATE)
SB_DCHECK(state_ == kStateUnstarted);
#else
SB_DCHECK(state_ == kStateUnstarted || state_ == kStatePreloading);
#endif // SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION ||
// SB_HAS(CONCEALED_STATE)
DispatchAndDelete(CreateInitialEvent(kSbEventTypeStart));
}
void Application::DispatchPreload() {
SB_DCHECK(IsCurrentThread());
SB_DCHECK(state_ == kStateUnstarted);
DispatchAndDelete(CreateInitialEvent(kSbEventTypePreload));
}
bool Application::HasPreloadSwitch() {
return command_line_->HasSwitch(kPreloadSwitch);
}
bool Application::DispatchAndDelete(Application::Event* event) {
SB_DCHECK(IsCurrentThread());
if (!event) {
return true;
}
// Ensure the event is deleted unless it is released.
scoped_ptr<Event> scoped_event(event);
#if SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION || \
SB_HAS(CONCEALED_STATE)
// Ensure that we go through the the appropriate lifecycle events based on the
// current state.
switch (scoped_event->event->type) {
case kSbEventTypePreload:
if (state() != kStateUnstarted) {
return true;
}
break;
case kSbEventTypeStart:
if (state() != kStateUnstarted && state() != kStateStarted) {
Inject(new Event(kSbEventTypeFocus, NULL, NULL));
return true;
}
break;
case kSbEventTypeBlur:
if (state() != kStateStarted) {
return true;
}
break;
case kSbEventTypeFocus:
switch (state()) {
case kStateStopped:
return true;
case kStateFrozen:
Inject(new Event(kSbEventTypeUnfreeze, NULL, NULL));
// The fall-through is intentional.
case kStateConcealed:
Inject(new Event(kSbEventTypeReveal, NULL, NULL));
Inject(scoped_event.release());
return true;
case kStateBlurred:
break;
case kStateStarted:
case kStateUnstarted:
return true;
}
break;
case kSbEventTypeConceal:
switch (state()) {
case kStateUnstarted:
return true;
case kStateStarted:
Inject(new Event(kSbEventTypeBlur, NULL, NULL));
Inject(scoped_event.release());
return true;
case kStateBlurred:
break;
case kStateConcealed:
case kStateFrozen:
case kStateStopped:
return true;
}
break;
case kSbEventTypeReveal:
switch (state()) {
case kStateStopped:
return true;
case kStateFrozen:
OnResume();
Inject(new Event(kSbEventTypeUnfreeze, NULL, NULL));
Inject(scoped_event.release());
return true;
case kStateConcealed:
break;
case kStateBlurred:
case kStateStarted:
case kStateUnstarted:
return true;
}
break;
case kSbEventTypeFreeze:
switch (state()) {
case kStateUnstarted:
return true;
case kStateStarted:
Inject(new Event(kSbEventTypeBlur, NULL, NULL));
// The fall-through is intentional
case kStateBlurred:
Inject(new Event(kSbEventTypeConceal, NULL, NULL));
Inject(scoped_event.release());
return true;
case kStateConcealed:
break;
case kStateFrozen:
case kStateStopped:
return true;
}
break;
case kSbEventTypeUnfreeze:
switch (state()) {
case kStateStopped:
return true;
case kStateFrozen:
break;
case kStateConcealed:
case kStateBlurred:
case kStateStarted:
case kStateUnstarted:
return true;
}
break;
case kSbEventTypeStop:
switch (state()) {
case kStateUnstarted:
return true;
case kStateStarted:
Inject(new Event(kSbEventTypeBlur, NULL, NULL));
// The fall-through is intentional.
case kStateBlurred:
Inject(new Event(kSbEventTypeConceal, NULL, NULL));
// The fall-through is intentional.
case kStateConcealed:
Inject(new Event(kSbEventTypeFreeze, NULL, NULL));
Inject(scoped_event.release());
return true;
case kStateFrozen:
break;
case kStateStopped:
return true;
}
error_level_ = scoped_event->error_level;
break;
case kSbEventTypeScheduled: {
TimedEvent* timed_event =
reinterpret_cast<TimedEvent*>(scoped_event->event->data);
timed_event->callback(timed_event->context);
return true;
}
default:
break;
}
#else
// Ensure that we go through the the appropriate lifecycle events based on the
// current state.
switch (scoped_event->event->type) {
case kSbEventTypePreload:
if (state() != kStateUnstarted) {
return true;
}
break;
case kSbEventTypeStart:
if (state() != kStatePreloading && state() != kStateUnstarted) {
return true;
}
break;
case kSbEventTypePause:
if (state() != kStateStarted) {
return true;
}
break;
case kSbEventTypeUnpause:
if (state() == kStateStarted) {
return true;
}
if (state() == kStatePreloading) {
// Convert to Start event and consume.
DispatchStart();
return true;
}
if (state() == kStateSuspended) {
Inject(new Event(kSbEventTypeResume, NULL, NULL));
Inject(scoped_event.release());
return true;
}
break;
case kSbEventTypeSuspend:
if (state() == kStateSuspended) {
return true;
}
if (state() == kStatePreloading) {
return true;
}
if (state() == kStateStarted) {
Inject(new Event(kSbEventTypePause, NULL, NULL));
Inject(scoped_event.release());
return true;
}
break;
case kSbEventTypeResume:
if (state() == kStateStarted || state() == kStatePaused) {
return true;
}
if (state() == kStateSuspended) {
OnResume();
}
break;
case kSbEventTypeStop:
if (state() == kStateStarted) {
Inject(new Event(kSbEventTypePause, NULL, NULL));
Inject(new Event(kSbEventTypeSuspend, NULL, NULL));
Inject(scoped_event.release());
return true;
}
if (state() == kStatePaused || state() == kStatePreloading) {
Inject(new Event(kSbEventTypeSuspend, NULL, NULL));
Inject(scoped_event.release());
return true;
}
error_level_ = scoped_event->error_level;
break;
case kSbEventTypeScheduled: {
TimedEvent* timed_event =
reinterpret_cast<TimedEvent*>(scoped_event->event->data);
timed_event->callback(timed_event->context);
return true;
}
default:
break;
}
#endif // SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION ||
// SB_HAS(CONCEALED_STATE)
SbEventHandle(scoped_event->event);
#if SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION || \
SB_HAS(CONCEALED_STATE)
switch (scoped_event->event->type) {
case kSbEventTypePreload:
SB_DCHECK(state() == kStateUnstarted);
state_ = kStateConcealed;
break;
case kSbEventTypeStart:
SB_DCHECK(state() == kStateUnstarted);
state_ = kStateStarted;
break;
case kSbEventTypeBlur:
SB_DCHECK(state() == kStateStarted);
state_ = kStateBlurred;
break;
case kSbEventTypeFocus:
SB_DCHECK(state() == kStateBlurred);
state_ = kStateStarted;
break;
case kSbEventTypeConceal:
SB_DCHECK(state() == kStateBlurred);
state_ = kStateConcealed;
break;
case kSbEventTypeReveal:
SB_DCHECK(state() == kStateConcealed);
state_ = kStateBlurred;
break;
case kSbEventTypeFreeze:
SB_DCHECK(state() == kStateConcealed);
state_ = kStateFrozen;
OnSuspend();
break;
case kSbEventTypeUnfreeze:
SB_DCHECK(state() == kStateFrozen);
state_ = kStateConcealed;
break;
case kSbEventTypeStop:
SB_DCHECK(state() == kStateFrozen);
state_ = kStateStopped;
return false;
default:
break;
}
#else
switch (scoped_event->event->type) {
case kSbEventTypePreload:
SB_DCHECK(state() == kStateUnstarted);
state_ = kStatePreloading;
break;
case kSbEventTypeStart:
SB_DCHECK(state() == kStatePreloading || state() == kStateUnstarted);
state_ = kStateStarted;
break;
case kSbEventTypePause:
SB_DCHECK(state() == kStateStarted);
state_ = kStatePaused;
break;
case kSbEventTypeUnpause:
SB_DCHECK(state() == kStatePaused);
state_ = kStateStarted;
break;
case kSbEventTypeSuspend:
SB_DCHECK(state() == kStatePreloading || state() == kStatePaused);
state_ = kStateSuspended;
OnSuspend();
break;
case kSbEventTypeResume:
SB_DCHECK(state() == kStateSuspended);
state_ = kStatePaused;
break;
case kSbEventTypeStop:
SB_DCHECK(state() == kStateSuspended);
state_ = kStateStopped;
return false;
default:
break;
}
#endif // SB_API_VERSION >= SB_ADD_CONCEALED_STATE_SUPPORT_VERSION ||
// SB_HAS(CONCEALED_STATE)
// Should not be unstarted after the first event.
SB_DCHECK(state() != kStateUnstarted);
return true;
}
void Application::CallTeardownCallbacks() {
ScopedLock lock(callbacks_lock_);
for (size_t i = 0; i < teardown_callbacks_.size(); ++i) {
teardown_callbacks_[i]();
}
}
Application::Event* Application::CreateInitialEvent(SbEventType type) {
SB_DCHECK(type == kSbEventTypePreload || type == kSbEventTypeStart);
SbEventStartData* start_data = new SbEventStartData();
SbMemorySet(start_data, 0, sizeof(SbEventStartData));
const CommandLine::StringVector& args = command_line_->argv();
start_data->argument_count = static_cast<int>(args.size());
// Cobalt web_platform_tests expect an extra argv[argc] set to NULL.
start_data->argument_values = new char*[start_data->argument_count + 1];
start_data->argument_values[start_data->argument_count] = NULL;
for (int i=0; i < start_data->argument_count; i++) {
start_data->argument_values[i] = const_cast<char*>(args[i].c_str());
}
start_data->link = start_link_;
return new Event(type, start_data, &DeleteStartData);
}
int Application::RunLoop() {
SB_DCHECK(command_line_);
if (IsPreloadImmediate()) {
DispatchPreload();
} else if (IsStartImmediate()) {
DispatchStart();
}
for (;;) {
if (!DispatchNextEvent()) {
break;
}
}
CallTeardownCallbacks();
Teardown();
return error_level_;
}
} // namespace starboard
} // namespace shared
} // namespace starboard