зеркало из https://github.com/mozilla/gecko-dev.git
371 строка
10 KiB
C++
371 строка
10 KiB
C++
/* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
|
|
* 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/. */
|
|
|
|
#ifndef AndroidBridge_h__
|
|
#define AndroidBridge_h__
|
|
|
|
#include <jni.h>
|
|
#include <android/log.h>
|
|
#include <cstdlib>
|
|
#include <unistd.h>
|
|
|
|
#include "APKOpen.h"
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsCOMArray.h"
|
|
|
|
#include "GeneratedJNIWrappers.h"
|
|
|
|
#include "nsIMutableArray.h"
|
|
#include "nsIMIMEInfo.h"
|
|
#include "nsColor.h"
|
|
#include "gfxRect.h"
|
|
|
|
#include "nsIAndroidBridge.h"
|
|
|
|
#include "mozilla/Likely.h"
|
|
#include "mozilla/Mutex.h"
|
|
#include "mozilla/Types.h"
|
|
#include "mozilla/gfx/Point.h"
|
|
#include "mozilla/jni/Utils.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsDataHashtable.h"
|
|
|
|
#include "Units.h"
|
|
|
|
// Some debug #defines
|
|
// #define DEBUG_ANDROID_EVENTS
|
|
// #define DEBUG_ANDROID_WIDGET
|
|
|
|
class nsPIDOMWindowOuter;
|
|
|
|
typedef void* EGLSurface;
|
|
class nsIRunnable;
|
|
|
|
namespace mozilla {
|
|
|
|
class AutoLocalJNIFrame;
|
|
|
|
namespace hal {
|
|
class BatteryInformation;
|
|
class NetworkInformation;
|
|
} // namespace hal
|
|
|
|
// The order and number of the members in this structure must correspond
|
|
// to the attrsAppearance array in GeckoAppShell.getSystemColors()
|
|
typedef struct AndroidSystemColors {
|
|
nscolor textColorPrimary;
|
|
nscolor textColorPrimaryInverse;
|
|
nscolor textColorSecondary;
|
|
nscolor textColorSecondaryInverse;
|
|
nscolor textColorTertiary;
|
|
nscolor textColorTertiaryInverse;
|
|
nscolor textColorHighlight;
|
|
nscolor colorForeground;
|
|
nscolor colorBackground;
|
|
nscolor panelColorForeground;
|
|
nscolor panelColorBackground;
|
|
} AndroidSystemColors;
|
|
|
|
class AndroidBridge final {
|
|
public:
|
|
enum {
|
|
// Values for NotifyIME, in addition to values from the Gecko
|
|
// IMEMessage enum; use negative values here to prevent conflict
|
|
NOTIFY_IME_OPEN_VKB = -2,
|
|
NOTIFY_IME_REPLY_EVENT = -1,
|
|
};
|
|
|
|
enum {
|
|
LAYER_CLIENT_TYPE_NONE = 0,
|
|
LAYER_CLIENT_TYPE_GL = 2 // AndroidGeckoGLLayerClient
|
|
};
|
|
|
|
static bool IsJavaUiThread() {
|
|
return mozilla::jni::GetUIThreadId() == gettid();
|
|
}
|
|
|
|
static void ConstructBridge();
|
|
static void DeconstructBridge();
|
|
|
|
static AndroidBridge* Bridge() { return sBridge; }
|
|
|
|
void ContentDocumentChanged(mozIDOMWindowProxy* aDOMWindow);
|
|
bool IsContentDocumentDisplayed(mozIDOMWindowProxy* aDOMWindow);
|
|
|
|
bool GetHandlersForURL(const nsAString& aURL,
|
|
nsIMutableArray* handlersArray = nullptr,
|
|
nsIHandlerApp** aDefaultApp = nullptr,
|
|
const nsAString& aAction = EmptyString());
|
|
|
|
bool GetHandlersForMimeType(const nsAString& aMimeType,
|
|
nsIMutableArray* handlersArray = nullptr,
|
|
nsIHandlerApp** aDefaultApp = nullptr,
|
|
const nsAString& aAction = EmptyString());
|
|
|
|
bool GetHWEncoderCapability();
|
|
bool GetHWDecoderCapability();
|
|
|
|
void GetMimeTypeFromExtensions(const nsACString& aFileExt,
|
|
nsCString& aMimeType);
|
|
void GetExtensionFromMimeType(const nsACString& aMimeType,
|
|
nsACString& aFileExt);
|
|
|
|
bool GetClipboardText(nsAString& aText);
|
|
|
|
int GetScreenDepth();
|
|
|
|
void Vibrate(const nsTArray<uint32_t>& aPattern);
|
|
|
|
void GetSystemColors(AndroidSystemColors* aColors);
|
|
|
|
void GetIconForExtension(const nsACString& aFileExt, uint32_t aIconSize,
|
|
uint8_t* const aBuf);
|
|
|
|
bool GetStaticStringField(const char* classID, const char* field,
|
|
nsAString& result, JNIEnv* env = nullptr);
|
|
|
|
bool GetStaticIntField(const char* className, const char* fieldName,
|
|
int32_t* aInt, JNIEnv* env = nullptr);
|
|
|
|
// Returns a global reference to the Context for Fennec's Activity. The
|
|
// caller is responsible for ensuring this doesn't leak by calling
|
|
// DeleteGlobalRef() when the context is no longer needed.
|
|
jobject GetGlobalContextRef(void);
|
|
|
|
void GetCurrentBatteryInformation(hal::BatteryInformation* aBatteryInfo);
|
|
|
|
void GetCurrentNetworkInformation(hal::NetworkInformation* aNetworkInfo);
|
|
|
|
// These methods don't use a ScreenOrientation because it's an
|
|
// enum and that would require including the header which requires
|
|
// include IPC headers which requires including basictypes.h which
|
|
// requires a lot of changes...
|
|
uint32_t GetScreenOrientation();
|
|
uint16_t GetScreenAngle();
|
|
|
|
int GetAPIVersion() { return mAPIVersion; }
|
|
|
|
nsresult GetProxyForURI(const nsACString& aSpec, const nsACString& aScheme,
|
|
const nsACString& aHost, const int32_t aPort,
|
|
nsACString& aResult);
|
|
|
|
bool PumpMessageLoop();
|
|
|
|
// Utility methods.
|
|
static jfieldID GetFieldID(JNIEnv* env, jclass jClass, const char* fieldName,
|
|
const char* fieldType);
|
|
static jfieldID GetStaticFieldID(JNIEnv* env, jclass jClass,
|
|
const char* fieldName,
|
|
const char* fieldType);
|
|
static jmethodID GetMethodID(JNIEnv* env, jclass jClass,
|
|
const char* methodName, const char* methodType);
|
|
static jmethodID GetStaticMethodID(JNIEnv* env, jclass jClass,
|
|
const char* methodName,
|
|
const char* methodType);
|
|
|
|
static jni::Object::LocalRef ChannelCreate(jni::Object::Param);
|
|
|
|
static void InputStreamClose(jni::Object::Param obj);
|
|
static uint32_t InputStreamAvailable(jni::Object::Param obj);
|
|
static nsresult InputStreamRead(jni::Object::Param obj, char* aBuf,
|
|
uint32_t aCount, uint32_t* aRead);
|
|
|
|
protected:
|
|
static nsDataHashtable<nsStringHashKey, nsString> sStoragePaths;
|
|
|
|
static AndroidBridge* sBridge;
|
|
|
|
AndroidBridge();
|
|
~AndroidBridge();
|
|
|
|
int mAPIVersion;
|
|
|
|
// intput stream
|
|
jclass jReadableByteChannel;
|
|
jclass jChannels;
|
|
jmethodID jChannelCreate;
|
|
jmethodID jByteBufferRead;
|
|
|
|
jclass jInputStream;
|
|
jmethodID jClose;
|
|
jmethodID jAvailable;
|
|
|
|
jmethodID jCalculateLength;
|
|
|
|
// some convinient types to have around
|
|
jclass jStringClass;
|
|
|
|
jni::Object::GlobalRef mMessageQueue;
|
|
jfieldID mMessageQueueMessages;
|
|
jmethodID mMessageQueueNext;
|
|
};
|
|
|
|
class AutoJNIClass {
|
|
private:
|
|
JNIEnv* const mEnv;
|
|
const jclass mClass;
|
|
|
|
public:
|
|
AutoJNIClass(JNIEnv* jEnv, const char* name)
|
|
: mEnv(jEnv), mClass(jni::GetClassRef(jEnv, name)) {}
|
|
|
|
~AutoJNIClass() { mEnv->DeleteLocalRef(mClass); }
|
|
|
|
jclass getRawRef() const { return mClass; }
|
|
|
|
jclass getGlobalRef() const {
|
|
return static_cast<jclass>(mEnv->NewGlobalRef(mClass));
|
|
}
|
|
|
|
jfieldID getField(const char* name, const char* type) const {
|
|
return AndroidBridge::GetFieldID(mEnv, mClass, name, type);
|
|
}
|
|
|
|
jfieldID getStaticField(const char* name, const char* type) const {
|
|
return AndroidBridge::GetStaticFieldID(mEnv, mClass, name, type);
|
|
}
|
|
|
|
jmethodID getMethod(const char* name, const char* type) const {
|
|
return AndroidBridge::GetMethodID(mEnv, mClass, name, type);
|
|
}
|
|
|
|
jmethodID getStaticMethod(const char* name, const char* type) const {
|
|
return AndroidBridge::GetStaticMethodID(mEnv, mClass, name, type);
|
|
}
|
|
};
|
|
|
|
class AutoJObject {
|
|
public:
|
|
explicit AutoJObject(JNIEnv* aJNIEnv = nullptr) : mObject(nullptr) {
|
|
mJNIEnv = aJNIEnv ? aJNIEnv : jni::GetGeckoThreadEnv();
|
|
}
|
|
|
|
AutoJObject(JNIEnv* aJNIEnv, jobject aObject) {
|
|
mJNIEnv = aJNIEnv ? aJNIEnv : jni::GetGeckoThreadEnv();
|
|
mObject = aObject;
|
|
}
|
|
|
|
~AutoJObject() {
|
|
if (mObject) mJNIEnv->DeleteLocalRef(mObject);
|
|
}
|
|
|
|
jobject operator=(jobject aObject) {
|
|
if (mObject) {
|
|
mJNIEnv->DeleteLocalRef(mObject);
|
|
}
|
|
return mObject = aObject;
|
|
}
|
|
|
|
operator jobject() { return mObject; }
|
|
|
|
private:
|
|
JNIEnv* mJNIEnv;
|
|
jobject mObject;
|
|
};
|
|
|
|
class AutoLocalJNIFrame {
|
|
public:
|
|
explicit AutoLocalJNIFrame(int nEntries = 15)
|
|
: mEntries(nEntries),
|
|
mJNIEnv(jni::GetGeckoThreadEnv()),
|
|
mHasFrameBeenPushed(false) {
|
|
MOZ_ASSERT(mJNIEnv);
|
|
Push();
|
|
}
|
|
|
|
explicit AutoLocalJNIFrame(JNIEnv* aJNIEnv, int nEntries = 15)
|
|
: mEntries(nEntries),
|
|
mJNIEnv(aJNIEnv ? aJNIEnv : jni::GetGeckoThreadEnv()),
|
|
mHasFrameBeenPushed(false) {
|
|
MOZ_ASSERT(mJNIEnv);
|
|
Push();
|
|
}
|
|
|
|
~AutoLocalJNIFrame() {
|
|
if (mHasFrameBeenPushed) {
|
|
Pop();
|
|
}
|
|
}
|
|
|
|
JNIEnv* GetEnv() { return mJNIEnv; }
|
|
|
|
bool CheckForException() {
|
|
if (mJNIEnv->ExceptionCheck()) {
|
|
MOZ_CATCH_JNI_EXCEPTION(mJNIEnv);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Note! Calling Purge makes all previous local refs created in
|
|
// the AutoLocalJNIFrame's scope INVALID; be sure that you locked down
|
|
// any local refs that you need to keep around in global refs!
|
|
void Purge() {
|
|
Pop();
|
|
Push();
|
|
}
|
|
|
|
template <typename ReturnType = jobject>
|
|
ReturnType Pop(ReturnType aResult = nullptr) {
|
|
MOZ_ASSERT(mHasFrameBeenPushed);
|
|
mHasFrameBeenPushed = false;
|
|
return static_cast<ReturnType>(
|
|
mJNIEnv->PopLocalFrame(static_cast<jobject>(aResult)));
|
|
}
|
|
|
|
private:
|
|
void Push() {
|
|
MOZ_ASSERT(!mHasFrameBeenPushed);
|
|
// Make sure there is enough space to store a local ref to the
|
|
// exception. I am not completely sure this is needed, but does
|
|
// not hurt.
|
|
if (mJNIEnv->PushLocalFrame(mEntries + 1) != 0) {
|
|
CheckForException();
|
|
return;
|
|
}
|
|
mHasFrameBeenPushed = true;
|
|
}
|
|
|
|
const int mEntries;
|
|
JNIEnv* const mJNIEnv;
|
|
bool mHasFrameBeenPushed;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#define NS_ANDROIDBRIDGE_CID \
|
|
{ \
|
|
0x0FE2321D, 0xEBD9, 0x467D, { \
|
|
0xA7, 0x43, 0x03, 0xA6, 0x8D, 0x40, 0x59, 0x9E \
|
|
} \
|
|
}
|
|
|
|
class nsAndroidBridge final : public nsIAndroidBridge, public nsIObserver {
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIANDROIDBRIDGE
|
|
NS_DECL_NSIOBSERVER
|
|
|
|
NS_FORWARD_SAFE_NSIANDROIDEVENTDISPATCHER(mEventDispatcher)
|
|
|
|
nsAndroidBridge();
|
|
|
|
private:
|
|
~nsAndroidBridge();
|
|
|
|
void AddObservers();
|
|
void RemoveObservers();
|
|
|
|
void UpdateAudioPlayingWindows(bool aPlaying);
|
|
|
|
int32_t mAudibleWindowsNum;
|
|
nsCOMPtr<nsIAndroidEventDispatcher> mEventDispatcher;
|
|
|
|
protected:
|
|
};
|
|
|
|
#endif /* AndroidBridge_h__ */
|