mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-25 05:41:12 +00:00
670b9b1d28
Because we are going to use it for prefers-reduced-motion media feature which is tied to a system setting. Differential Revision: https://phabricator.services.mozilla.com/D5502 --HG-- rename : mobile/android/geckoview/src/main/java/org/mozilla/gecko/GeckoInputDeviceListener.java => mobile/android/geckoview/src/main/java/org/mozilla/gecko/GeckoSystemStateListener.java rename : widget/android/GeckoInputDeviceListener.h => widget/android/GeckoSystemStateListener.h extra : moz-landing-system : lando
857 lines
27 KiB
C++
857 lines
27 KiB
C++
/* -*- Mode: c++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 4; -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsAppShell.h"
|
|
|
|
#include "base/basictypes.h"
|
|
#include "base/message_loop.h"
|
|
#include "base/task.h"
|
|
#include "mozilla/Hal.h"
|
|
#include "nsIScreen.h"
|
|
#include "nsIScreenManager.h"
|
|
#include "nsWindow.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsICommandLineRunner.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsIAppStartup.h"
|
|
#include "nsIGeolocationProvider.h"
|
|
#include "nsCacheService.h"
|
|
#include "nsIDOMEventListener.h"
|
|
#include "nsIDOMWakeLockListener.h"
|
|
#include "nsIPowerManagerService.h"
|
|
#include "nsISpeculativeConnect.h"
|
|
#include "nsITabChild.h"
|
|
#include "nsIURIFixup.h"
|
|
#include "nsCategoryManagerUtils.h"
|
|
#include "nsCDefaultURIFixup.h"
|
|
#include "nsToolkitCompsCID.h"
|
|
#include "nsGeoPosition.h"
|
|
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/Telemetry.h"
|
|
#include "mozilla/Services.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/Hal.h"
|
|
#include "mozilla/dom/TabChild.h"
|
|
#include "mozilla/intl/OSPreferences.h"
|
|
#include "mozilla/widget/ScreenManager.h"
|
|
#include "prenv.h"
|
|
|
|
#include "AndroidBridge.h"
|
|
#include "AndroidBridgeUtilities.h"
|
|
#include "GeneratedJNINatives.h"
|
|
#include <android/log.h>
|
|
#include <pthread.h>
|
|
#include <wchar.h>
|
|
|
|
#include "GeckoProfiler.h"
|
|
#ifdef MOZ_ANDROID_HISTORY
|
|
#include "nsNetUtil.h"
|
|
#include "nsIURI.h"
|
|
#include "IHistory.h"
|
|
#endif
|
|
|
|
#ifdef MOZ_LOGGING
|
|
#include "mozilla/Logging.h"
|
|
#endif
|
|
|
|
#include "AndroidAlerts.h"
|
|
#include "AndroidUiThread.h"
|
|
#include "ANRReporter.h"
|
|
#include "GeckoBatteryManager.h"
|
|
#include "GeckoNetworkManager.h"
|
|
#include "GeckoProcessManager.h"
|
|
#include "GeckoScreenOrientation.h"
|
|
#include "GeckoSystemStateListener.h"
|
|
#include "GeckoVRManager.h"
|
|
#include "PrefsHelper.h"
|
|
#include "fennec/MemoryMonitor.h"
|
|
#include "fennec/Telemetry.h"
|
|
#include "fennec/ThumbnailHelper.h"
|
|
#include "ScreenHelperAndroid.h"
|
|
|
|
#ifdef DEBUG_ANDROID_EVENTS
|
|
#define EVLOG(args...) ALOG(args)
|
|
#else
|
|
#define EVLOG(args...) do { } while (0)
|
|
#endif
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::widget;
|
|
|
|
nsIGeolocationUpdate *gLocationCallback = nullptr;
|
|
|
|
nsAppShell* nsAppShell::sAppShell;
|
|
StaticAutoPtr<Mutex> nsAppShell::sAppShellLock;
|
|
|
|
uint32_t nsAppShell::Queue::sLatencyCount[];
|
|
uint64_t nsAppShell::Queue::sLatencyTime[];
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED(nsAppShell, nsBaseAppShell, nsIObserver)
|
|
|
|
class WakeLockListener final : public nsIDOMMozWakeLockListener {
|
|
private:
|
|
~WakeLockListener() {}
|
|
|
|
public:
|
|
NS_DECL_ISUPPORTS;
|
|
|
|
nsresult Callback(const nsAString& topic, const nsAString& state) override {
|
|
java::GeckoAppShell::NotifyWakeLockChanged(topic, state);
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(WakeLockListener, nsIDOMMozWakeLockListener)
|
|
nsCOMPtr<nsIPowerManagerService> sPowerManagerService = nullptr;
|
|
StaticRefPtr<WakeLockListener> sWakeLockListener;
|
|
|
|
|
|
class GeckoThreadSupport final
|
|
: public java::GeckoThread::Natives<GeckoThreadSupport>
|
|
{
|
|
// When this number goes above 0, the app is paused. When less than or
|
|
// equal to zero, the app is resumed.
|
|
static int32_t sPauseCount;
|
|
|
|
public:
|
|
static void SpeculativeConnect(jni::String::Param aUriStr)
|
|
{
|
|
if (!NS_IsMainThread()) {
|
|
// We will be on the main thread if the call was queued on the Java
|
|
// side during startup. Otherwise, the call was not queued, which
|
|
// means Gecko is already sufficiently loaded, and we don't really
|
|
// care about speculative connections at this point.
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIIOService> ioServ = do_GetIOService();
|
|
nsCOMPtr<nsISpeculativeConnect> specConn = do_QueryInterface(ioServ);
|
|
if (!specConn) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> uri = nsAppShell::ResolveURI(aUriStr->ToCString());
|
|
if (!uri) {
|
|
return;
|
|
}
|
|
|
|
OriginAttributes attrs;
|
|
nsCOMPtr<nsIPrincipal> principal = BasePrincipal::CreateCodebasePrincipal(uri, attrs);
|
|
specConn->SpeculativeConnect2(uri, principal, nullptr);
|
|
}
|
|
|
|
static void WaitOnGecko()
|
|
{
|
|
struct NoOpRunnable : Runnable
|
|
{
|
|
NoOpRunnable() : Runnable("NoOpRunnable") {}
|
|
NS_IMETHOD Run() override { return NS_OK; }
|
|
};
|
|
|
|
struct NoOpEvent : nsAppShell::Event
|
|
{
|
|
void Run() override
|
|
{
|
|
// We cannot call NS_DispatchToMainThread from within
|
|
// WaitOnGecko itself because the thread that is calling
|
|
// WaitOnGecko may not be an nsThread, and may not be able to do
|
|
// a sync dispatch.
|
|
NS_DispatchToMainThread(do_AddRef(new NoOpRunnable()),
|
|
NS_DISPATCH_SYNC);
|
|
}
|
|
};
|
|
nsAppShell::SyncRunEvent(NoOpEvent());
|
|
}
|
|
|
|
static void OnPause()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
sPauseCount++;
|
|
// If sPauseCount is now 1, we just crossed the threshold from "resumed"
|
|
// "paused". so we should notify observers and so on.
|
|
if (sPauseCount != 1) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIObserverService> obsServ =
|
|
mozilla::services::GetObserverService();
|
|
obsServ->NotifyObservers(nullptr, "application-background", nullptr);
|
|
|
|
obsServ->NotifyObservers(nullptr, "memory-pressure", u"heap-minimize");
|
|
|
|
// If we are OOM killed with the disk cache enabled, the entire
|
|
// cache will be cleared (bug 105843), so shut down the cache here
|
|
// and re-init on foregrounding
|
|
if (nsCacheService::GlobalInstance()) {
|
|
nsCacheService::GlobalInstance()->Shutdown();
|
|
}
|
|
|
|
// We really want to send a notification like profile-before-change,
|
|
// but profile-before-change ends up shutting some things down instead
|
|
// of flushing data
|
|
Preferences* prefs = static_cast<Preferences *>(Preferences::GetService());
|
|
if (prefs) {
|
|
// Force a main thread blocking save
|
|
prefs->SavePrefFileBlocking();
|
|
}
|
|
}
|
|
|
|
static void OnResume()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
sPauseCount--;
|
|
// If sPauseCount is now 0, we just crossed the threshold from "paused"
|
|
// to "resumed", so we should notify observers and so on.
|
|
if (sPauseCount != 0) {
|
|
return;
|
|
}
|
|
|
|
// If we are OOM killed with the disk cache enabled, the entire
|
|
// cache will be cleared (bug 105843), so shut down cache on backgrounding
|
|
// and re-init here
|
|
if (nsCacheService::GlobalInstance()) {
|
|
nsCacheService::GlobalInstance()->Init();
|
|
}
|
|
|
|
// We didn't return from one of our own activities, so restore
|
|
// to foreground status
|
|
nsCOMPtr<nsIObserverService> obsServ =
|
|
mozilla::services::GetObserverService();
|
|
obsServ->NotifyObservers(nullptr, "application-foreground", nullptr);
|
|
}
|
|
|
|
static void CreateServices(jni::String::Param aCategory, jni::String::Param aData)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsCString category(aCategory->ToCString());
|
|
|
|
NS_CreateServicesFromCategory(
|
|
category.get(),
|
|
nullptr, // aOrigin
|
|
category.get(),
|
|
aData ? aData->ToString().get() : nullptr);
|
|
}
|
|
|
|
static int64_t RunUiThreadCallback()
|
|
{
|
|
return RunAndroidUiTasks();
|
|
}
|
|
|
|
static void ForceQuit()
|
|
{
|
|
nsCOMPtr<nsIAppStartup> appStartup =
|
|
do_GetService(NS_APPSTARTUP_CONTRACTID);
|
|
|
|
if (appStartup) {
|
|
appStartup->Quit(nsIAppStartup::eForceQuit);
|
|
}
|
|
|
|
}
|
|
|
|
static void Crash()
|
|
{
|
|
printf_stderr("Intentionally crashing...\n");
|
|
MOZ_CRASH("intentional crash");
|
|
}
|
|
};
|
|
|
|
int32_t GeckoThreadSupport::sPauseCount;
|
|
|
|
|
|
class GeckoAppShellSupport final
|
|
: public java::GeckoAppShell::Natives<GeckoAppShellSupport>
|
|
{
|
|
public:
|
|
static void ReportJavaCrash(const jni::Class::LocalRef& aCls,
|
|
jni::Throwable::Param aException,
|
|
jni::String::Param aStack)
|
|
{
|
|
if (!jni::ReportException(aCls.Env(), aException.Get(), aStack.Get())) {
|
|
// Only crash below if crash reporter is initialized and annotation
|
|
// succeeded. Otherwise try other means of reporting the crash in
|
|
// Java.
|
|
return;
|
|
}
|
|
|
|
MOZ_CRASH("Uncaught Java exception");
|
|
}
|
|
|
|
static void NotifyObservers(jni::String::Param aTopic,
|
|
jni::String::Param aData)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(aTopic);
|
|
|
|
nsCOMPtr<nsIObserverService> obsServ = services::GetObserverService();
|
|
if (!obsServ) {
|
|
return;
|
|
}
|
|
|
|
obsServ->NotifyObservers(nullptr, aTopic->ToCString().get(),
|
|
aData ? aData->ToString().get() : nullptr);
|
|
}
|
|
|
|
static void OnSensorChanged(int32_t aType, float aX, float aY, float aZ,
|
|
float aW, int64_t aTime)
|
|
{
|
|
AutoTArray<float, 4> values;
|
|
|
|
switch (aType) {
|
|
// Bug 938035, transfer HAL data for orientation sensor to meet w3c
|
|
// spec, ex: HAL report alpha=90 means East but alpha=90 means West
|
|
// in w3c spec
|
|
case hal::SENSOR_ORIENTATION:
|
|
values.AppendElement(360.0f - aX);
|
|
values.AppendElement(-aY);
|
|
values.AppendElement(-aZ);
|
|
break;
|
|
|
|
case hal::SENSOR_LINEAR_ACCELERATION:
|
|
case hal::SENSOR_ACCELERATION:
|
|
case hal::SENSOR_GYROSCOPE:
|
|
case hal::SENSOR_PROXIMITY:
|
|
values.AppendElement(aX);
|
|
values.AppendElement(aY);
|
|
values.AppendElement(aZ);
|
|
break;
|
|
|
|
case hal::SENSOR_LIGHT:
|
|
values.AppendElement(aX);
|
|
break;
|
|
|
|
case hal::SENSOR_ROTATION_VECTOR:
|
|
case hal::SENSOR_GAME_ROTATION_VECTOR:
|
|
values.AppendElement(aX);
|
|
values.AppendElement(aY);
|
|
values.AppendElement(aZ);
|
|
values.AppendElement(aW);
|
|
break;
|
|
|
|
default:
|
|
__android_log_print(ANDROID_LOG_ERROR, "Gecko",
|
|
"Unknown sensor type %d", aType);
|
|
}
|
|
|
|
hal::SensorData sdata(hal::SensorType(aType), aTime, values);
|
|
hal::NotifySensorChange(sdata);
|
|
}
|
|
|
|
static void OnLocationChanged(double aLatitude, double aLongitude,
|
|
double aAltitude, float aAccuracy,
|
|
float aAltitudeAccuracy,
|
|
float aHeading, float aSpeed, int64_t aTime)
|
|
{
|
|
if (!gLocationCallback) {
|
|
return;
|
|
}
|
|
|
|
RefPtr<nsIDOMGeoPosition> geoPosition(
|
|
new nsGeoPosition(aLatitude, aLongitude, aAltitude, aAccuracy,
|
|
aAltitudeAccuracy, aHeading, aSpeed, aTime));
|
|
gLocationCallback->Update(geoPosition);
|
|
}
|
|
|
|
static void NotifyUriVisited(jni::String::Param aUri)
|
|
{
|
|
#ifdef MOZ_ANDROID_HISTORY
|
|
nsCOMPtr<IHistory> history = services::GetHistoryService();
|
|
nsCOMPtr<nsIURI> visitedURI;
|
|
if (history &&
|
|
NS_SUCCEEDED(NS_NewURI(getter_AddRefs(visitedURI),
|
|
aUri->ToString()))) {
|
|
history->NotifyVisited(visitedURI);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void NotifyAlertListener(jni::String::Param aName,
|
|
jni::String::Param aTopic,
|
|
jni::String::Param aCookie)
|
|
{
|
|
if (!aName || !aTopic || !aCookie) {
|
|
return;
|
|
}
|
|
|
|
widget::AndroidAlerts::NotifyListener(
|
|
aName->ToString(), aTopic->ToCString().get(),
|
|
aCookie->ToString().get());
|
|
}
|
|
};
|
|
|
|
|
|
class BrowserLocaleManagerSupport final
|
|
: public java::BrowserLocaleManager::Natives<BrowserLocaleManagerSupport>
|
|
{
|
|
public:
|
|
static void RefreshLocales()
|
|
{
|
|
intl::OSPreferences::GetInstance()->Refresh();
|
|
}
|
|
};
|
|
|
|
|
|
nsAppShell::nsAppShell()
|
|
: mSyncRunFinished(*(sAppShellLock = new Mutex("nsAppShell")),
|
|
"nsAppShell.SyncRun")
|
|
, mSyncRunQuit(false)
|
|
{
|
|
{
|
|
MutexAutoLock lock(*sAppShellLock);
|
|
sAppShell = this;
|
|
}
|
|
|
|
hal::Init();
|
|
|
|
if (!XRE_IsParentProcess()) {
|
|
if (jni::IsAvailable()) {
|
|
GeckoThreadSupport::Init();
|
|
GeckoAppShellSupport::Init();
|
|
|
|
// Set the corresponding state in GeckoThread.
|
|
java::GeckoThread::SetState(java::GeckoThread::State::RUNNING());
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (jni::IsAvailable()) {
|
|
ScreenManager& screenManager = ScreenManager::GetSingleton();
|
|
screenManager.SetHelper(mozilla::MakeUnique<ScreenHelperAndroid>());
|
|
|
|
// Initialize JNI and Set the corresponding state in GeckoThread.
|
|
AndroidBridge::ConstructBridge();
|
|
GeckoAppShellSupport::Init();
|
|
GeckoThreadSupport::Init();
|
|
mozilla::GeckoBatteryManager::Init();
|
|
mozilla::GeckoNetworkManager::Init();
|
|
mozilla::GeckoProcessManager::Init();
|
|
mozilla::GeckoScreenOrientation::Init();
|
|
mozilla::GeckoSystemStateListener::Init();
|
|
mozilla::PrefsHelper::Init();
|
|
nsWindow::InitNatives();
|
|
|
|
if (jni::IsFennec()) {
|
|
BrowserLocaleManagerSupport::Init();
|
|
mozilla::ANRReporter::Init();
|
|
mozilla::MemoryMonitor::Init();
|
|
mozilla::widget::Telemetry::Init();
|
|
mozilla::ThumbnailHelper::Init();
|
|
}
|
|
|
|
java::GeckoThread::SetState(java::GeckoThread::State::JNI_READY());
|
|
|
|
CreateAndroidUiThread();
|
|
}
|
|
|
|
sPowerManagerService = do_GetService(POWERMANAGERSERVICE_CONTRACTID);
|
|
|
|
if (sPowerManagerService) {
|
|
sWakeLockListener = new WakeLockListener();
|
|
} else {
|
|
NS_WARNING("Failed to retrieve PowerManagerService, wakelocks will be broken!");
|
|
}
|
|
}
|
|
|
|
nsAppShell::~nsAppShell()
|
|
{
|
|
{
|
|
// Release any thread waiting for a sync call to finish.
|
|
MutexAutoLock lock(*sAppShellLock);
|
|
sAppShell = nullptr;
|
|
mSyncRunFinished.NotifyAll();
|
|
}
|
|
|
|
while (mEventQueue.Pop(/* mayWait */ false)) {
|
|
NS_WARNING("Discarded event on shutdown");
|
|
}
|
|
|
|
if (sPowerManagerService) {
|
|
sPowerManagerService->RemoveWakeLockListener(sWakeLockListener);
|
|
|
|
sPowerManagerService = nullptr;
|
|
sWakeLockListener = nullptr;
|
|
}
|
|
|
|
hal::Shutdown();
|
|
|
|
if (jni::IsAvailable() && XRE_IsParentProcess()) {
|
|
DestroyAndroidUiThread();
|
|
AndroidBridge::DeconstructBridge();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsAppShell::NotifyNativeEvent()
|
|
{
|
|
mEventQueue.Signal();
|
|
}
|
|
|
|
void
|
|
nsAppShell::RecordLatencies()
|
|
{
|
|
if (!mozilla::Telemetry::CanRecordExtended()) {
|
|
return;
|
|
}
|
|
|
|
const mozilla::Telemetry::HistogramID timeIDs[] = {
|
|
mozilla::Telemetry::HistogramID::FENNEC_LOOP_UI_LATENCY,
|
|
mozilla::Telemetry::HistogramID::FENNEC_LOOP_OTHER_LATENCY
|
|
};
|
|
|
|
static_assert(ArrayLength(Queue::sLatencyCount) == Queue::LATENCY_COUNT,
|
|
"Count array length mismatch");
|
|
static_assert(ArrayLength(Queue::sLatencyTime) == Queue::LATENCY_COUNT,
|
|
"Time array length mismatch");
|
|
static_assert(ArrayLength(timeIDs) == Queue::LATENCY_COUNT,
|
|
"Time ID array length mismatch");
|
|
|
|
for (size_t i = 0; i < Queue::LATENCY_COUNT; i++) {
|
|
if (!Queue::sLatencyCount[i]) {
|
|
continue;
|
|
}
|
|
|
|
const uint64_t time = Queue::sLatencyTime[i] / 1000ull /
|
|
Queue::sLatencyCount[i];
|
|
if (time) {
|
|
mozilla::Telemetry::Accumulate(
|
|
timeIDs[i], uint32_t(std::min<uint64_t>(UINT32_MAX, time)));
|
|
}
|
|
|
|
// Reset latency counts.
|
|
Queue::sLatencyCount[i] = 0;
|
|
Queue::sLatencyTime[i] = 0;
|
|
}
|
|
}
|
|
|
|
#define PREFNAME_COALESCE_TOUCHES "dom.event.touch.coalescing.enabled"
|
|
static const char* kObservedPrefs[] = {
|
|
PREFNAME_COALESCE_TOUCHES,
|
|
nullptr
|
|
};
|
|
|
|
nsresult
|
|
nsAppShell::Init()
|
|
{
|
|
nsresult rv = nsBaseAppShell::Init();
|
|
nsCOMPtr<nsIObserverService> obsServ =
|
|
mozilla::services::GetObserverService();
|
|
if (obsServ) {
|
|
obsServ->AddObserver(this, "browser-delayed-startup-finished", false);
|
|
obsServ->AddObserver(this, "profile-after-change", false);
|
|
obsServ->AddObserver(this, "quit-application", false);
|
|
obsServ->AddObserver(this, "quit-application-granted", false);
|
|
obsServ->AddObserver(this, "xpcom-shutdown", false);
|
|
|
|
if (XRE_IsParentProcess()) {
|
|
obsServ->AddObserver(this, "chrome-document-loaded", false);
|
|
} else {
|
|
obsServ->AddObserver(this, "content-document-global-created", false);
|
|
}
|
|
}
|
|
|
|
if (sPowerManagerService)
|
|
sPowerManagerService->AddWakeLockListener(sWakeLockListener);
|
|
|
|
Preferences::AddStrongObservers(this, kObservedPrefs);
|
|
mAllowCoalescingTouches = Preferences::GetBool(PREFNAME_COALESCE_TOUCHES, true);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsAppShell::Observe(nsISupports* aSubject,
|
|
const char* aTopic,
|
|
const char16_t* aData)
|
|
{
|
|
bool removeObserver = false;
|
|
|
|
if (!strcmp(aTopic, "xpcom-shutdown")) {
|
|
{
|
|
// Release any thread waiting for a sync call to finish.
|
|
mozilla::MutexAutoLock shellLock(*sAppShellLock);
|
|
mSyncRunQuit = true;
|
|
mSyncRunFinished.NotifyAll();
|
|
}
|
|
// We need to ensure no observers stick around after XPCOM shuts down
|
|
// or we'll see crashes, as the app shell outlives XPConnect.
|
|
mObserversHash.Clear();
|
|
return nsBaseAppShell::Observe(aSubject, aTopic, aData);
|
|
|
|
} else if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) &&
|
|
aData &&
|
|
nsDependentString(aData).Equals(NS_LITERAL_STRING(PREFNAME_COALESCE_TOUCHES))) {
|
|
mAllowCoalescingTouches = Preferences::GetBool(PREFNAME_COALESCE_TOUCHES, true);
|
|
return NS_OK;
|
|
|
|
} else if (!strcmp(aTopic, "browser-delayed-startup-finished")) {
|
|
NS_CreateServicesFromCategory("browser-delayed-startup-finished", nullptr,
|
|
"browser-delayed-startup-finished");
|
|
|
|
} else if (!strcmp(aTopic, "profile-after-change")) {
|
|
if (jni::IsAvailable()) {
|
|
java::GeckoThread::SetState(
|
|
java::GeckoThread::State::PROFILE_READY());
|
|
|
|
// Gecko on Android follows the Android app model where it never
|
|
// stops until it is killed by the system or told explicitly to
|
|
// quit. Therefore, we should *not* exit Gecko when there is no
|
|
// window or the last window is closed. nsIAppStartup::Quit will
|
|
// still force Gecko to exit.
|
|
nsCOMPtr<nsIAppStartup> appStartup =
|
|
do_GetService(NS_APPSTARTUP_CONTRACTID);
|
|
if (appStartup) {
|
|
appStartup->EnterLastWindowClosingSurvivalArea();
|
|
}
|
|
}
|
|
removeObserver = true;
|
|
|
|
} else if (!strcmp(aTopic, "chrome-document-loaded")) {
|
|
// Set the global ready state and enable the window event dispatcher
|
|
// for this particular GeckoView.
|
|
nsCOMPtr<nsIDocument> doc = do_QueryInterface(aSubject);
|
|
MOZ_ASSERT(doc);
|
|
nsCOMPtr<nsIWidget> widget =
|
|
widget::WidgetUtils::DOMWindowToWidget(doc->GetWindow());
|
|
|
|
// `widget` may be one of several different types in the parent
|
|
// process, including the Android nsWindow, PuppetWidget, etc. To
|
|
// ensure that we only accept the Android nsWindow, we check that the
|
|
// widget is a top-level window and that its NS_NATIVE_WIDGET value is
|
|
// non-null, which is not the case for non-native widgets like
|
|
// PuppetWidget.
|
|
if (widget &&
|
|
widget->WindowType() == nsWindowType::eWindowType_toplevel &&
|
|
widget->GetNativeData(NS_NATIVE_WIDGET) == widget) {
|
|
if (jni::IsAvailable()) {
|
|
// When our first window has loaded, assume any JS
|
|
// initialization has run and set Gecko to ready.
|
|
java::GeckoThread::CheckAndSetState(
|
|
java::GeckoThread::State::PROFILE_READY(),
|
|
java::GeckoThread::State::RUNNING());
|
|
}
|
|
const auto window = static_cast<nsWindow*>(widget.get());
|
|
window->OnGeckoViewReady();
|
|
}
|
|
} else if (!strcmp(aTopic, "quit-application")) {
|
|
if (jni::IsAvailable()) {
|
|
const bool restarting =
|
|
aData && NS_LITERAL_STRING("restart").Equals(aData);
|
|
java::GeckoThread::SetState(
|
|
restarting ?
|
|
java::GeckoThread::State::RESTARTING() :
|
|
java::GeckoThread::State::EXITING());
|
|
}
|
|
removeObserver = true;
|
|
|
|
} else if (!strcmp(aTopic, "quit-application-granted")) {
|
|
if (jni::IsAvailable()) {
|
|
// We are told explicitly to quit, perhaps due to
|
|
// nsIAppStartup::Quit being called. We should release our hold on
|
|
// nsIAppStartup and let it continue to quit.
|
|
nsCOMPtr<nsIAppStartup> appStartup =
|
|
do_GetService(NS_APPSTARTUP_CONTRACTID);
|
|
if (appStartup) {
|
|
appStartup->ExitLastWindowClosingSurvivalArea();
|
|
}
|
|
}
|
|
removeObserver = true;
|
|
|
|
} else if (!strcmp(aTopic, "nsPref:changed")) {
|
|
if (jni::IsAvailable()) {
|
|
mozilla::PrefsHelper::OnPrefChange(aData);
|
|
}
|
|
|
|
} else if (!strcmp(aTopic, "content-document-global-created")) {
|
|
// Associate the PuppetWidget of the newly-created TabChild with a
|
|
// GeckoEditableChild instance.
|
|
MOZ_ASSERT(!XRE_IsParentProcess());
|
|
|
|
nsCOMPtr<mozIDOMWindowProxy> domWindow = do_QueryInterface(aSubject);
|
|
MOZ_ASSERT(domWindow);
|
|
nsCOMPtr<nsIWidget> domWidget = widget::WidgetUtils::DOMWindowToWidget(
|
|
nsPIDOMWindowOuter::From(domWindow));
|
|
NS_ENSURE_TRUE(domWidget, NS_OK);
|
|
|
|
dom::ContentChild* contentChild = dom::ContentChild::GetSingleton();
|
|
dom::TabChild* tabChild = domWidget->GetOwningTabChild();
|
|
RefPtr<widget::PuppetWidget> widget(tabChild->WebWidget());
|
|
NS_ENSURE_TRUE(contentChild && tabChild && widget, NS_OK);
|
|
|
|
widget::TextEventDispatcherListener* listener =
|
|
widget->GetNativeTextEventDispatcherListener();
|
|
if (listener && listener !=
|
|
static_cast<widget::TextEventDispatcherListener*>(widget)) {
|
|
// We already set a listener before.
|
|
return NS_OK;
|
|
}
|
|
|
|
// Get the content/tab ID in order to get the correct
|
|
// IGeckoEditableParent object, which GeckoEditableChild uses to
|
|
// communicate with the parent process.
|
|
const uint64_t contentId = contentChild->GetID();
|
|
const uint64_t tabId = tabChild->GetTabId();
|
|
NS_ENSURE_TRUE(contentId && tabId, NS_OK);
|
|
|
|
auto editableParent = java::GeckoServiceChildProcess::GetEditableParent(
|
|
contentId, tabId);
|
|
NS_ENSURE_TRUE(editableParent, NS_OK);
|
|
|
|
auto editableChild = java::GeckoEditableChild::New(editableParent);
|
|
NS_ENSURE_TRUE(editableChild, NS_OK);
|
|
|
|
RefPtr<widget::GeckoEditableSupport> editableSupport =
|
|
new widget::GeckoEditableSupport(editableChild);
|
|
|
|
// Tell PuppetWidget to use our listener for IME operations.
|
|
widget->SetNativeTextEventDispatcherListener(editableSupport);
|
|
}
|
|
|
|
if (removeObserver) {
|
|
nsCOMPtr<nsIObserverService> obsServ =
|
|
mozilla::services::GetObserverService();
|
|
if (obsServ) {
|
|
obsServ->RemoveObserver(this, aTopic);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
nsAppShell::ProcessNextNativeEvent(bool mayWait)
|
|
{
|
|
EVLOG("nsAppShell::ProcessNextNativeEvent %d", mayWait);
|
|
|
|
AUTO_PROFILER_LABEL("nsAppShell::ProcessNextNativeEvent", OTHER);
|
|
|
|
mozilla::UniquePtr<Event> curEvent;
|
|
|
|
{
|
|
curEvent = mEventQueue.Pop(/* mayWait */ false);
|
|
|
|
if (!curEvent && mayWait) {
|
|
// This processes messages in the Android Looper. Note that we only
|
|
// get here if the normal Gecko event loop has been awoken
|
|
// (bug 750713). Looper messages effectively have the lowest
|
|
// priority because we only process them before we're about to
|
|
// wait for new events.
|
|
if (jni::IsAvailable() && XRE_IsParentProcess() &&
|
|
AndroidBridge::Bridge()->PumpMessageLoop()) {
|
|
return true;
|
|
}
|
|
|
|
AUTO_PROFILER_LABEL("nsAppShell::ProcessNextNativeEvent:Wait",
|
|
IDLE);
|
|
mozilla::BackgroundHangMonitor().NotifyWait();
|
|
|
|
curEvent = mEventQueue.Pop(/* mayWait */ true);
|
|
}
|
|
}
|
|
|
|
if (!curEvent)
|
|
return false;
|
|
|
|
mozilla::BackgroundHangMonitor().NotifyActivity();
|
|
|
|
curEvent->Run();
|
|
return true;
|
|
}
|
|
|
|
void
|
|
nsAppShell::SyncRunEvent(Event&& event,
|
|
UniquePtr<Event>(*eventFactory)(UniquePtr<Event>&&))
|
|
{
|
|
// Perform the call on the Gecko thread in a separate lambda, and wait
|
|
// on the monitor on the current thread.
|
|
MOZ_ASSERT(!NS_IsMainThread());
|
|
|
|
// This is the lock to check that app shell is still alive,
|
|
// and to wait on for the sync call to complete.
|
|
mozilla::MutexAutoLock shellLock(*sAppShellLock);
|
|
nsAppShell* const appShell = sAppShell;
|
|
|
|
if (MOZ_UNLIKELY(!appShell)) {
|
|
// Post-shutdown.
|
|
return;
|
|
}
|
|
|
|
bool finished = false;
|
|
auto runAndNotify = [&event, &finished] {
|
|
nsAppShell* const appShell = nsAppShell::Get();
|
|
if (MOZ_UNLIKELY(!appShell || appShell->mSyncRunQuit)) {
|
|
return;
|
|
}
|
|
event.Run();
|
|
finished = true;
|
|
mozilla::MutexAutoLock shellLock(*sAppShellLock);
|
|
appShell->mSyncRunFinished.NotifyAll();
|
|
};
|
|
|
|
UniquePtr<Event> runAndNotifyEvent = mozilla::MakeUnique<
|
|
LambdaEvent<decltype(runAndNotify)>>(std::move(runAndNotify));
|
|
|
|
if (eventFactory) {
|
|
runAndNotifyEvent = (*eventFactory)(std::move(runAndNotifyEvent));
|
|
}
|
|
|
|
appShell->mEventQueue.Post(std::move(runAndNotifyEvent));
|
|
|
|
while (!finished && MOZ_LIKELY(sAppShell && !sAppShell->mSyncRunQuit)) {
|
|
appShell->mSyncRunFinished.Wait();
|
|
}
|
|
}
|
|
|
|
already_AddRefed<nsIURI>
|
|
nsAppShell::ResolveURI(const nsCString& aUriStr)
|
|
{
|
|
nsCOMPtr<nsIIOService> ioServ = do_GetIOService();
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
if (NS_SUCCEEDED(ioServ->NewURI(aUriStr, nullptr,
|
|
nullptr, getter_AddRefs(uri)))) {
|
|
return uri.forget();
|
|
}
|
|
|
|
nsCOMPtr<nsIURIFixup> fixup = do_GetService(NS_URIFIXUP_CONTRACTID);
|
|
if (fixup && NS_SUCCEEDED(
|
|
fixup->CreateFixupURI(aUriStr, 0, nullptr, getter_AddRefs(uri)))) {
|
|
return uri.forget();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult
|
|
nsAppShell::AddObserver(const nsAString &aObserverKey, nsIObserver *aObserver)
|
|
{
|
|
NS_ASSERTION(aObserver != nullptr, "nsAppShell::AddObserver: aObserver is null!");
|
|
mObserversHash.Put(aObserverKey, aObserver);
|
|
return NS_OK;
|
|
}
|
|
|
|
// Used by IPC code
|
|
namespace mozilla {
|
|
|
|
bool ProcessNextEvent()
|
|
{
|
|
nsAppShell* const appShell = nsAppShell::Get();
|
|
if (!appShell) {
|
|
return false;
|
|
}
|
|
|
|
return appShell->ProcessNextNativeEvent(true) ? true : false;
|
|
}
|
|
|
|
void NotifyEvent()
|
|
{
|
|
nsAppShell* const appShell = nsAppShell::Get();
|
|
if (!appShell) {
|
|
return;
|
|
}
|
|
appShell->NotifyNativeEvent();
|
|
}
|
|
|
|
}
|