static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL)
{
jclass npeClazz;
npeClazz = env->FindClass(exc);
LOG_FATAL_IF(npeClazz == NULL, "Unable to find class %s", exc);
env->ThrowNew(npeClazz, msg);
}
static void preloadDexCachesStringsVisitor(void* addr, u4 threadId, RootType type, void* arg) {
StringTable& table = *(StringTable*) arg;
StringObject* strObj = *(StringObject**) addr;
LOG_FATAL_IF(strObj->clazz != gDvm.classJavaLangString, "Unknown class for supposed string");
char* newStr = dvmCreateCstrFromString(strObj);
// ALOGI("VMRuntime.preloadDexCaches interned=%s", newStr);
table[newStr] = strObj;
free(newStr);
}
status_t VirtualDisplaySurface::queueBuffer(int pslot,
const QueueBufferInput& input, QueueBufferOutput* output) {
if (mDisplayId < 0)
return mSource[SOURCE_SINK]->queueBuffer(pslot, input, output);
VDS_LOGW_IF(mDbgState != DBG_STATE_GLES,
"Unexpected queueBuffer(pslot=%d) in %s state", pslot,
dbgStateStr());
mDbgState = DBG_STATE_GLES_DONE;
VDS_LOGV("queueBuffer pslot=%d", pslot);
status_t result;
if (mCompositionType == COMPOSITION_MIXED) {
// Queue the buffer back into the scratch pool
QueueBufferOutput scratchQBO;
int sslot = mapProducer2SourceSlot(SOURCE_SCRATCH, pslot);
result = mSource[SOURCE_SCRATCH]->queueBuffer(sslot, input, &scratchQBO);
if (result != NO_ERROR)
return result;
// Now acquire the buffer from the scratch pool -- should be the same
// slot and fence as we just queued.
Mutex::Autolock lock(mMutex);
BufferQueue::BufferItem item;
result = acquireBufferLocked(&item, 0);
if (result != NO_ERROR)
return result;
VDS_LOGW_IF(item.mBuf != sslot,
"queueBuffer: acquired sslot %d from SCRATCH after queueing sslot %d",
item.mBuf, sslot);
mFbProducerSlot = mapSource2ProducerSlot(SOURCE_SCRATCH, item.mBuf);
mFbFence = mSlots[item.mBuf].mFence;
} else {
LOG_FATAL_IF(mCompositionType != COMPOSITION_GLES,
"Unexpected queueBuffer in state %s for compositionType %s",
dbgStateStr(), dbgCompositionTypeStr(mCompositionType));
// Extract the GLES release fence for HWC to acquire
int64_t timestamp;
bool isAutoTimestamp;
Rect crop;
int scalingMode;
uint32_t transform;
bool async;
input.deflate(×tamp, &isAutoTimestamp, &crop, &scalingMode,
&transform, &async, &mFbFence);
mFbProducerSlot = pslot;
mOutputFence = mFbFence;
}
*output = mQueueBufferOutput;
return NO_ERROR;
}
void doThrow(JNIEnv* env, const char* exc, const char* msg) {
// don't throw a new exception if we already have one pending
if (env->ExceptionCheck() == JNI_FALSE) {
jclass npeClazz;
npeClazz = env->FindClass(exc);
LOG_FATAL_IF(npeClazz == NULL, "Unable to find class %s", exc);
env->ThrowNew(npeClazz, msg);
}
}
int register_android_os_MemoryFile(JNIEnv* env)
{
jclass clazz;
clazz = env->FindClass(kClassPathName);
LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.FileUtils");
return AndroidRuntime::registerNativeMethods(
env, kClassPathName,
methods, NELEM(methods));
}
SimpleBestFitAllocator::chunk_t* SimpleBestFitAllocator::dealloc(size_t start)
{
start = start / kMemoryAlign;
chunk_t* cur = mList.head();
while (cur) {
if (cur->start == start) {
LOG_FATAL_IF(cur->free,
"block at offset 0x%08lX of size 0x%08lX already freed",
cur->start*kMemoryAlign, cur->size*kMemoryAlign);
// merge freed blocks together
chunk_t* freed = cur;
cur->free = 1;
do {
chunk_t* const p = cur->prev;
chunk_t* const n = cur->next;
if (p && (p->free || !cur->size)) {
freed = p;
p->size += cur->size;
mList.remove(cur);
delete cur;
}
cur = n;
} while (cur && cur->free);
#ifndef NDEBUG
if (!freed->free) {
dump_l("dealloc (!freed->free)");
}
#endif
LOG_FATAL_IF(!freed->free,
"freed block at offset 0x%08lX of size 0x%08lX is not free!",
freed->start * kMemoryAlign, freed->size * kMemoryAlign);
return freed;
}
cur = cur->next;
}
return 0;
}
int register_android_os_MessageQueue(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/os/MessageQueue",
gMessageQueueMethods, NELEM(gMessageQueueMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
jclass clazz;
FIND_CLASS(clazz, "android/os/MessageQueue");
GET_FIELD_ID(gMessageQueueClassInfo.mPtr, clazz,
"mPtr", "J");
return 0;
}
int register_android_view_MotionEvent(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/view/MotionEvent",
gMotionEventMethods, NELEM(gMotionEventMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
(void)res;
FIND_CLASS(gMotionEventClassInfo.clazz, "android/view/MotionEvent");
gMotionEventClassInfo.clazz = jclass(env->NewGlobalRef(gMotionEventClassInfo.clazz));
GET_STATIC_METHOD_ID(gMotionEventClassInfo.obtain, gMotionEventClassInfo.clazz,
"obtain", "()Landroid/view/MotionEvent;");
GET_METHOD_ID(gMotionEventClassInfo.recycle, gMotionEventClassInfo.clazz,
"recycle", "()V");
GET_FIELD_ID(gMotionEventClassInfo.mNativePtr, gMotionEventClassInfo.clazz,
"mNativePtr", "J");
jclass clazz;
FIND_CLASS(clazz, "android/view/MotionEvent$PointerCoords");
GET_FIELD_ID(gPointerCoordsClassInfo.mPackedAxisBits, clazz,
"mPackedAxisBits", "J");
GET_FIELD_ID(gPointerCoordsClassInfo.mPackedAxisValues, clazz,
"mPackedAxisValues", "[F");
GET_FIELD_ID(gPointerCoordsClassInfo.x, clazz,
"x", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.y, clazz,
"y", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.pressure, clazz,
"pressure", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.size, clazz,
"size", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.touchMajor, clazz,
"touchMajor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.touchMinor, clazz,
"touchMinor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.toolMajor, clazz,
"toolMajor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.toolMinor, clazz,
"toolMinor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.orientation, clazz,
"orientation", "F");
FIND_CLASS(clazz, "android/view/MotionEvent$PointerProperties");
GET_FIELD_ID(gPointerPropertiesClassInfo.id, clazz,
"id", "I");
GET_FIELD_ID(gPointerPropertiesClassInfo.toolType, clazz,
"toolType", "I");
return 0;
}
int register_android_net_NetworkUtils(JNIEnv* env)
{
jclass dhcpInfoInternalClass = env->FindClass("android/net/DhcpInfoInternal");
LOG_FATAL_IF(dhcpInfoInternalClass == NULL, "Unable to find class android/net/DhcpInfoInternal");
dhcpInfoInternalFieldIds.constructorId = env->GetMethodID(dhcpInfoInternalClass, "<init>", "()V");
dhcpInfoInternalFieldIds.ipaddress = env->GetFieldID(dhcpInfoInternalClass, "ipAddress", "Ljava/lang/String;");
dhcpInfoInternalFieldIds.prefixLength = env->GetFieldID(dhcpInfoInternalClass, "prefixLength", "I");
dhcpInfoInternalFieldIds.dns1 = env->GetFieldID(dhcpInfoInternalClass, "dns1", "Ljava/lang/String;");
dhcpInfoInternalFieldIds.dns2 = env->GetFieldID(dhcpInfoInternalClass, "dns2", "Ljava/lang/String;");
dhcpInfoInternalFieldIds.serverAddress = env->GetFieldID(dhcpInfoInternalClass, "serverAddress", "Ljava/lang/String;");
dhcpInfoInternalFieldIds.leaseDuration = env->GetFieldID(dhcpInfoInternalClass, "leaseDuration", "I");
return AndroidRuntime::registerNativeMethods(env,
NETUTILS_PKG_NAME, gNetworkUtilMethods, NELEM(gNetworkUtilMethods));
}
int register_android_view_DisplayEventReceiver(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/view/DisplayEventReceiver",
gMethods, NELEM(gMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
FIND_CLASS(gDisplayEventReceiverClassInfo.clazz, "android/view/DisplayEventReceiver");
GET_METHOD_ID(gDisplayEventReceiverClassInfo.dispatchVsync,
gDisplayEventReceiverClassInfo.clazz,
"dispatchVsync", "(JII)V");
GET_METHOD_ID(gDisplayEventReceiverClassInfo.dispatchHotplug,
gDisplayEventReceiverClassInfo.clazz,
"dispatchHotplug", "(J*Z)V");
return 0;
}
void FakeHwcEnvironment::SetUp() {
ALOGI("Test env setup");
system("setenforce 0");
system("stop");
property_set("debug.sf.nobootanimation", "1");
{
char value[PROPERTY_VALUE_MAX];
property_get("debug.sf.nobootanimation", value, "0");
LOG_FATAL_IF(atoi(value) != 1, "boot skip not set");
}
// TODO: Try registering the mock as the default service instead.
property_set("debug.sf.hwc_service_name", "mock");
// This allows the SurfaceFlinger to load a HIDL service not listed in manifest files.
property_set("debug.sf.treble_testing_override", "true");
}
int register_android_view_InputChannel(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/view/InputChannel",
gInputChannelMethods, NELEM(gInputChannelMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
FIND_CLASS(gInputChannelClassInfo.clazz, "android/view/InputChannel");
GET_FIELD_ID(gInputChannelClassInfo.mPtr, gInputChannelClassInfo.clazz,
"mPtr", "I");
GET_METHOD_ID(gInputChannelClassInfo.ctor, gInputChannelClassInfo.clazz,
"<init>", "()V");
return 0;
}
int register_com_sqlcrypt_database_CursorWindow(JNIEnv * env)
{
jclass clazz;
FIND_CLASS(clazz, "com/sqlcrypt/database/CharArrayBuffer");
GET_FIELD_ID(gCharArrayBufferClassInfo.data, clazz,
"data", "[C");
GET_FIELD_ID(gCharArrayBufferClassInfo.sizeCopied, clazz,
"sizeCopied", "I");
gEmptyString = jstring(env->NewGlobalRef(env->NewStringUTF("")));
LOG_FATAL_IF(!gEmptyString, "Unable to create empty string");
return AndroidRuntime::registerNativeMethods(env, "com/sqlcrypt/database/CursorWindow",
sMethods, NELEM(sMethods));
}
int register_android_os_Parcel(JNIEnv* env)
{
jclass clazz;
clazz = env->FindClass(kParcelPathName);
LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Parcel");
gParcelOffsets.clazz = (jclass) env->NewGlobalRef(clazz);
gParcelOffsets.mNativePtr = env->GetFieldID(clazz, "mNativePtr", "I");
gParcelOffsets.obtain = env->GetStaticMethodID(clazz, "obtain",
"()Landroid/os/Parcel;");
gParcelOffsets.recycle = env->GetMethodID(clazz, "recycle", "()V");
return AndroidRuntime::registerNativeMethods(
env, kParcelPathName,
gParcelMethods, NELEM(gParcelMethods));
}
int register_android_view_VelocityTracker(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/view/VelocityTracker",
gVelocityTrackerMethods, NELEM(gVelocityTrackerMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
jclass clazz;
FIND_CLASS(clazz, "android/view/VelocityTracker$Estimator");
GET_FIELD_ID(gEstimatorClassInfo.xCoeff, clazz,
"xCoeff", "[F");
GET_FIELD_ID(gEstimatorClassInfo.yCoeff, clazz,
"yCoeff", "[F");
GET_FIELD_ID(gEstimatorClassInfo.degree, clazz,
"degree", "I");
GET_FIELD_ID(gEstimatorClassInfo.confidence, clazz,
"confidence", "F");
return 0;
}
status_t VirtualDisplaySurface::dequeueBuffer(Source source,
uint32_t format, uint32_t usage, int* sslot, sp<Fence>* fence) {
LOG_FATAL_IF(mDisplayId < 0, "mDisplayId=%d but should not be < 0.", mDisplayId);
// Don't let a slow consumer block us
bool async = (source == SOURCE_SINK);
status_t result = mSource[source]->dequeueBuffer(sslot, fence, async,
mSinkBufferWidth, mSinkBufferHeight, format, usage);
if (result < 0)
return result;
int pslot = mapSource2ProducerSlot(source, *sslot);
VDS_LOGV("dequeueBuffer(%s): sslot=%d pslot=%d result=%d",
dbgSourceStr(source), *sslot, pslot, result);
uint64_t sourceBit = static_cast<uint64_t>(source) << pslot;
if ((mProducerSlotSource & (1ULL << pslot)) != sourceBit) {
// This slot was previously dequeued from the other source; must
// re-request the buffer.
result |= BUFFER_NEEDS_REALLOCATION;
mProducerSlotSource &= ~(1ULL << pslot);
mProducerSlotSource |= sourceBit;
}
if (result & RELEASE_ALL_BUFFERS) {
for (uint32_t i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
if ((mProducerSlotSource & (1ULL << i)) == sourceBit)
mProducerBuffers[i].clear();
}
}
if (result & BUFFER_NEEDS_REALLOCATION) {
result = mSource[source]->requestBuffer(*sslot, &mProducerBuffers[pslot]);
if (result < 0) {
mProducerBuffers[pslot].clear();
mSource[source]->cancelBuffer(*sslot, *fence);
return result;
}
VDS_LOGV("dequeueBuffer(%s): buffers[%d]=%p fmt=%d usage=%#x",
dbgSourceStr(source), pslot, mProducerBuffers[pslot].get(),
mProducerBuffers[pslot]->getPixelFormat(),
mProducerBuffers[pslot]->getUsage());
}
return result;
}
int register_android_server_InputApplicationHandle(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/input/InputApplicationHandle",
gInputApplicationHandleMethods, NELEM(gInputApplicationHandleMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
jclass clazz;
FIND_CLASS(clazz, "com/android/server/input/InputApplicationHandle");
GET_FIELD_ID(gInputApplicationHandleClassInfo.ptr, clazz,
"ptr", "I");
GET_FIELD_ID(gInputApplicationHandleClassInfo.name, clazz,
"name", "Ljava/lang/String;");
GET_FIELD_ID(gInputApplicationHandleClassInfo.dispatchingTimeoutNanos,
clazz,
"dispatchingTimeoutNanos", "J");
return 0;
}
int register_android_net_NetworkUtils(JNIEnv* env)
{
jclass netutils = env->FindClass(NETUTILS_PKG_NAME);
LOG_FATAL_IF(netutils == NULL, "Unable to find class " NETUTILS_PKG_NAME);
dhcpInfoFieldIds.dhcpInfoClass = env->FindClass("android/net/DhcpInfo");
if (dhcpInfoFieldIds.dhcpInfoClass != NULL) {
dhcpInfoFieldIds.constructorId = env->GetMethodID(dhcpInfoFieldIds.dhcpInfoClass, "<init>", "()V");
dhcpInfoFieldIds.ipaddress = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "ipAddress", "I");
dhcpInfoFieldIds.gateway = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "gateway", "I");
dhcpInfoFieldIds.netmask = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "netmask", "I");
dhcpInfoFieldIds.dns1 = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns1", "I");
dhcpInfoFieldIds.dns2 = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns2", "I");
dhcpInfoFieldIds.serverAddress = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "serverAddress", "I");
dhcpInfoFieldIds.leaseDuration = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "leaseDuration", "I");
}
return AndroidRuntime::registerNativeMethods(env,
NETUTILS_PKG_NAME, gNetworkUtilMethods, NELEM(gNetworkUtilMethods));
}
int register_android_server_PowerManagerService(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/power/PowerManagerService",
gPowerManagerServiceMethods, NELEM(gPowerManagerServiceMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
// Callbacks
jclass clazz;
FIND_CLASS(clazz, "com/android/server/power/PowerManagerService");
GET_METHOD_ID(gPowerManagerServiceClassInfo.userActivityFromNative, clazz,
"userActivityFromNative", "(JII)V");
// Initialize
for (int i = 0; i <= USER_ACTIVITY_EVENT_LAST; i++) {
gLastEventTime[i] = LLONG_MIN;
}
gPowerManagerServiceObj = NULL;
gPowerModule = NULL;
return 0;
}
void BufferedTextOutput::popBundle()
{
AutoMutex _l(mLock);
BufferState* b = getBuffer();
b->bundle--;
LOG_FATAL_IF(b->bundle < 0,
"TextOutput::popBundle() called more times than pushBundle()");
if (b->bundle < 0) b->bundle = 0;
if (b->bundle == 0) {
// Last bundle, write out data if it is complete. If it is not
// complete, don't write until the last line is done... this may
// or may not be the write thing to do, but it's the easiest.
if (b->bufferPos > 0 && b->atFront) {
struct iovec vec;
vec.iov_base = b->buffer;
vec.iov_len = b->bufferPos;
writeLines(vec, 1);
b->restart();
}
}
}
int register_android_net_ethernet_EthernetManager(JNIEnv* env)
{
jclass eth = env->FindClass(ETH_PKG_NAME);
LOGI("Loading ethernet jni class");
LOG_FATAL_IF(eth == NULL, "Unable to find class " ETH_PKG_NAME);
dhcpInfoFieldIds.dhcpInfoClass =
env->FindClass("android/net/DhcpInfo");
if (dhcpInfoFieldIds.dhcpInfoClass != NULL) {
dhcpInfoFieldIds.constructorId =
env->GetMethodID(dhcpInfoFieldIds.dhcpInfoClass,
"<init>", "()V");
dhcpInfoFieldIds.ipaddress =
env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass,
"ipAddress", "I");
dhcpInfoFieldIds.gateway =
env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass,
"gateway", "I");
dhcpInfoFieldIds.netmask =
env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass,
"netmask", "I");
dhcpInfoFieldIds.dns1 =
env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns1", "I");
dhcpInfoFieldIds.dns2 =
env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns2", "I");
dhcpInfoFieldIds.serverAddress =
env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass,
"serverAddress", "I");
dhcpInfoFieldIds.leaseDuration =
env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass,
"leaseDuration", "I");
}
return AndroidRuntime::registerNativeMethods(env,
ETH_PKG_NAME,
gEthernetMethods,
NELEM(gEthernetMethods));
}
int register_android_server_PowerManagerService(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/power/PowerManagerService",
gPowerManagerServiceMethods, NELEM(gPowerManagerServiceMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
// Callbacks
jclass clazz;
FIND_CLASS(clazz, "com/android/server/power/PowerManagerService");
GET_METHOD_ID(gPowerManagerServiceClassInfo.wakeUpFromNative, clazz,
"wakeUpFromNative", "(J)V");
GET_METHOD_ID(gPowerManagerServiceClassInfo.goToSleepFromNative, clazz,
"goToSleepFromNative", "(JI)V");
GET_METHOD_ID(gPowerManagerServiceClassInfo.userActivityFromNative, clazz,
"userActivityFromNative", "(JII)V");
GET_METHOD_ID(gPowerManagerServiceClassInfo.tempWakeUpFromNative,clazz,
"tempWakeUpFromNative","(J)V");
GET_FIELD_ID(gPowerManagerServiceFieldInfo.isPowered,clazz,
"mIsPowered","Z");
GET_FIELD_ID(gPowerManagerServiceFieldInfo.bootFastStatus,clazz,
"mBootFastStats","Z");
// Initialize
for (int i = 0; i <= USER_ACTIVITY_EVENT_LAST; i++) {
gLastEventTime[i] = LLONG_MIN;
}
gScreenOn = true;
gScreenBright = true;
gPowerManagerServiceObj = NULL;
gPowerModule = NULL;
return 0;
}
int register_android_server_PowerManagerService(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/PowerManagerService",
gPowerManagerServiceMethods, NELEM(gPowerManagerServiceMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
// Callbacks
FIND_CLASS(gPowerManagerServiceClassInfo.clazz, "com/android/server/PowerManagerService");
GET_METHOD_ID(gPowerManagerServiceClassInfo.goToSleep, gPowerManagerServiceClassInfo.clazz,
"goToSleep", "(J)V");
GET_METHOD_ID(gPowerManagerServiceClassInfo.userActivity, gPowerManagerServiceClassInfo.clazz,
"userActivity", "(JZIZ)V");
// Initialize
for (int i = 0; i < POWER_MANAGER_LAST_EVENT; i++) {
gLastEventTime[i] = LLONG_MIN;
}
gScreenOn = true;
gScreenBright = true;
return 0;
}
void* Loader::open(EGLNativeDisplayType display, int impl, egl_connection_t* cnx)
{
/*
* TODO: if we don't find display/0, then use 0/0
* (0/0 should always work)
*/
void* dso;
int index = int(display);
driver_t* hnd = 0;
char const* tag = getTag(index, impl);
if (tag) {
dso = load_driver("GLES", tag, cnx, EGL | GLESv1_CM | GLESv2);
if (dso) {
hnd = new driver_t(dso);
} else {
// Always load EGL first
dso = load_driver("EGL", tag, cnx, EGL);
if (dso) {
hnd = new driver_t(dso);
// TODO: make this more automated
hnd->set( load_driver("GLESv1_CM", tag, cnx, GLESv1_CM), GLESv1_CM );
hnd->set( load_driver("GLESv2", tag, cnx, GLESv2), GLESv2 );
}
}
}
LOG_FATAL_IF(!index && !impl && !hnd,
"couldn't find the default OpenGL ES implementation "
"for default display");
return (void*)hnd;
}
int register_android_server_OppoBatteryService(JNIEnv* env)
{
char path[PATH_MAX];
struct dirent* entry;
DIR* dir = opendir(POWER_SUPPLY_PATH);
if (dir == NULL) {
ALOGE("Could not open %s\n", POWER_SUPPLY_PATH);
} else {
while ((entry = readdir(dir))) {
const char* name = entry->d_name;
// ignore "." and ".."
if (name[0] == '.' && (name[1] == 0 || (name[1] == '.' && name[2] == 0))) {
continue;
}
char buf[20];
// Look for "type" file in each subdirectory
snprintf(path, sizeof(path), "%s/%s/type", POWER_SUPPLY_PATH, name);
int length = readFromFile(path, buf, sizeof(buf));
if (length > 0) {
if (buf[length - 1] == '\n')
buf[length - 1] = 0;
if (strcmp(buf, "Battery") == 0) {
// 10087
snprintf(path, sizeof(path), "%s/%s/ChargerVoltage", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryCharge_NowPath = strdup(path);
} else {
// 10089
snprintf(path, sizeof(path), "%s/%s/charge_now", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryCharge_NowPath = strdup(path);
}
}
// 10087
snprintf(path, sizeof(path), "%s/%s/BatteryAverageCurrent", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryCurrent_NowPath = strdup(path);
} else {
// 10089
snprintf(path, sizeof(path), "%s/%s/current_now", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryCurrent_NowPath = strdup(path);
}
}
snprintf(path, sizeof(path), "%s/%s/charge_timeout", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryChargeTimeoutPath = strdup(path);
}
snprintf(path, sizeof(path), "%s/%s/charge_soc_fall", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryChargeSocFallPath = strdup(path);
}
}
}
}
closedir(dir);
}
if (!gPaths.batteryCharge_NowPath)
ALOGE("batteryCharge_NowPath not found");
if (!gPaths.batteryCurrent_NowPath)
ALOGE("batteryCurrent_NowPath not found");
if (!gPaths.batteryChargeTimeoutPath)
ALOGE("batteryChargeTimeoutPath not found");
if (!gPaths.batteryChargeSocFallPath)
ALOGE("batteryChargeSocFallPath not found");
jclass clazz = env->FindClass("com/android/server/OppoBatteryService");
if (clazz == NULL) {
ALOGE("Can't find com/android/server/OppoBatteryService");
return -1;
}
gFieldIds.mChargerVoltage = env->GetFieldID(clazz, "mChargerVoltage", "I");
gFieldIds.mBatteryCurrent = env->GetFieldID(clazz, "mBatteryCurrent", "I");
gFieldIds.mChargeTimeout= env->GetFieldID(clazz, "mChargeTimeout", "Z");
gFieldIds.mChargeSocFall= env->GetFieldID(clazz, "mChargeSocFall", "Z");
LOG_FATAL_IF(gFieldIds.mChargerVoltage == NULL, "Unable to find BatteryService.CHARGER_VOLTAGE_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryCurrent == NULL, "Unable to find BatteryService.BATTERY_CURRENT_PATH");
LOG_FATAL_IF(gFieldIds.mChargeTimeout== NULL, "Unable to find BatteryService.BATTERY_CHARGETIMEOUT_PATH");
LOG_FATAL_IF(gFieldIds.mChargeSocFall== NULL, "Unable to find BatteryService.BATTERY_CHARGESOCFALL_PATH");
return jniRegisterNativeMethods(env, "com/android/server/OppoBatteryService", sMethods, NELEM(sMethods));
}
void ARMAssembler::MUL(int cc, int s,
int Rd, int Rm, int Rs) {
if (Rd == Rm) { int t = Rm; Rm=Rs; Rs=t; }
LOG_FATAL_IF(Rd==Rm, "MUL(r%u,r%u,r%u)", Rd,Rm,Rs);
*mPC++ = (cc<<28) | (s<<20) | (Rd<<16) | (Rs<<8) | 0x90 | Rm;
}
int register_android_server_tv_TvInputHal(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/tv/TvInputHal",
gTvInputHalMethods, NELEM(gTvInputHalMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
(void)res; // Don't complain about unused variable in the LOG_NDEBUG case
jclass clazz;
FIND_CLASS(clazz, "com/android/server/tv/TvInputHal");
GET_METHOD_ID(
gTvInputHalClassInfo.deviceAvailable, clazz,
"deviceAvailableFromNative", "(Landroid/media/tv/TvInputHardwareInfo;)V");
GET_METHOD_ID(
gTvInputHalClassInfo.deviceUnavailable, clazz, "deviceUnavailableFromNative", "(I)V");
GET_METHOD_ID(
gTvInputHalClassInfo.streamConfigsChanged, clazz,
"streamConfigsChangedFromNative", "(I)V");
GET_METHOD_ID(
gTvInputHalClassInfo.firstFrameCaptured, clazz,
"firstFrameCapturedFromNative", "(II)V");
FIND_CLASS(gTvStreamConfigClassInfo.clazz, "android/media/tv/TvStreamConfig");
gTvStreamConfigClassInfo.clazz = jclass(env->NewGlobalRef(gTvStreamConfigClassInfo.clazz));
FIND_CLASS(gTvStreamConfigBuilderClassInfo.clazz, "android/media/tv/TvStreamConfig$Builder");
gTvStreamConfigBuilderClassInfo.clazz =
jclass(env->NewGlobalRef(gTvStreamConfigBuilderClassInfo.clazz));
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.constructor,
gTvStreamConfigBuilderClassInfo.clazz,
"<init>", "()V");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.streamId,
gTvStreamConfigBuilderClassInfo.clazz,
"streamId", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.type,
gTvStreamConfigBuilderClassInfo.clazz,
"type", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.maxWidth,
gTvStreamConfigBuilderClassInfo.clazz,
"maxWidth", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.maxHeight,
gTvStreamConfigBuilderClassInfo.clazz,
"maxHeight", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.generation,
gTvStreamConfigBuilderClassInfo.clazz,
"generation", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.build,
gTvStreamConfigBuilderClassInfo.clazz,
"build", "()Landroid/media/tv/TvStreamConfig;");
FIND_CLASS(gTvInputHardwareInfoBuilderClassInfo.clazz,
"android/media/tv/TvInputHardwareInfo$Builder");
gTvInputHardwareInfoBuilderClassInfo.clazz =
jclass(env->NewGlobalRef(gTvInputHardwareInfoBuilderClassInfo.clazz));
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.constructor,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"<init>", "()V");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.deviceId,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"deviceId", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.type,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"type", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.hdmiPortId,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"hdmiPortId", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.audioType,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"audioType", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.audioAddress,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"audioAddress", "(Ljava/lang/String;)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.build,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"build", "()Landroid/media/tv/TvInputHardwareInfo;");
return 0;
}
int register_android_server_BatteryService(JNIEnv* env)
{
char path[PATH_MAX];
struct dirent* entry;
DIR* dir = opendir(POWER_SUPPLY_PATH);
if (dir == NULL) {
LOGE("Could not open %s\n", POWER_SUPPLY_PATH);
return -1;
}
while ((entry = readdir(dir))) {
const char* name = entry->d_name;
// ignore "." and ".."
if (name[0] == '.' && (name[1] == 0 || (name[1] == '.' && name[2] == 0))) {
continue;
}
char buf[20];
// Look for "type" file in each subdirectory
snprintf(path, sizeof(path), "%s/%s/type", POWER_SUPPLY_PATH, name);
int length = readFromFile(path, buf, sizeof(buf));
if (length > 0) {
if (buf[length - 1] == '\n')
buf[length - 1] = 0;
if (strcmp(buf, "Mains") == 0) {
snprintf(path, sizeof(path), "%s/%s/online", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.acOnlinePath = strdup(path);
}
else if (strcmp(buf, "USB") == 0) {
snprintf(path, sizeof(path), "%s/%s/online", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.usbOnlinePath = strdup(path);
}
else if (strcmp(buf, "Battery") == 0) {
snprintf(path, sizeof(path), "%s/%s/status", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.batteryStatusPath = strdup(path);
snprintf(path, sizeof(path), "%s/%s/health", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.batteryHealthPath = strdup(path);
snprintf(path, sizeof(path), "%s/%s/present", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.batteryPresentPath = strdup(path);
snprintf(path, sizeof(path), "%s/%s/capacity", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.batteryCapacityPath = strdup(path);
snprintf(path, sizeof(path), "%s/%s/voltage_now", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryVoltagePath = strdup(path);
// voltage_now is in microvolts, not millivolts
gVoltageDivisor = 1000;
} else {
snprintf(path, sizeof(path), "%s/%s/batt_vol", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.batteryVoltagePath = strdup(path);
}
snprintf(path, sizeof(path), "%s/%s/temp", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0) {
gPaths.batteryTemperaturePath = strdup(path);
} else {
snprintf(path, sizeof(path), "%s/%s/batt_temp", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.batteryTemperaturePath = strdup(path);
}
snprintf(path, sizeof(path), "%s/%s/technology", POWER_SUPPLY_PATH, name);
if (access(path, R_OK) == 0)
gPaths.batteryTechnologyPath = strdup(path);
}
}
}
closedir(dir);
if (!gPaths.acOnlinePath)
LOGE("acOnlinePath not found");
if (!gPaths.usbOnlinePath)
LOGE("usbOnlinePath not found");
if (!gPaths.batteryStatusPath)
LOGE("batteryStatusPath not found");
if (!gPaths.batteryHealthPath)
LOGE("batteryHealthPath not found");
if (!gPaths.batteryPresentPath)
LOGE("batteryPresentPath not found");
if (!gPaths.batteryCapacityPath)
LOGE("batteryCapacityPath not found");
if (!gPaths.batteryVoltagePath)
LOGE("batteryVoltagePath not found");
if (!gPaths.batteryTemperaturePath)
LOGE("batteryTemperaturePath not found");
if (!gPaths.batteryTechnologyPath)
LOGE("batteryTechnologyPath not found");
jclass clazz = env->FindClass("com/android/server/BatteryService");
if (clazz == NULL) {
LOGE("Can't find com/android/server/BatteryService");
return -1;
}
gFieldIds.mAcOnline = env->GetFieldID(clazz, "mAcOnline", "Z");
gFieldIds.mUsbOnline = env->GetFieldID(clazz, "mUsbOnline", "Z");
gFieldIds.mBatteryStatus = env->GetFieldID(clazz, "mBatteryStatus", "I");
gFieldIds.mBatteryHealth = env->GetFieldID(clazz, "mBatteryHealth", "I");
gFieldIds.mBatteryPresent = env->GetFieldID(clazz, "mBatteryPresent", "Z");
gFieldIds.mBatteryLevel = env->GetFieldID(clazz, "mBatteryLevel", "I");
gFieldIds.mBatteryTechnology = env->GetFieldID(clazz, "mBatteryTechnology", "Ljava/lang/String;");
gFieldIds.mBatteryVoltage = env->GetFieldID(clazz, "mBatteryVoltage", "I");
gFieldIds.mBatteryTemperature = env->GetFieldID(clazz, "mBatteryTemperature", "I");
LOG_FATAL_IF(gFieldIds.mAcOnline == NULL, "Unable to find BatteryService.AC_ONLINE_PATH");
LOG_FATAL_IF(gFieldIds.mUsbOnline == NULL, "Unable to find BatteryService.USB_ONLINE_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryStatus == NULL, "Unable to find BatteryService.BATTERY_STATUS_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryHealth == NULL, "Unable to find BatteryService.BATTERY_HEALTH_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryPresent == NULL, "Unable to find BatteryService.BATTERY_PRESENT_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryLevel == NULL, "Unable to find BatteryService.BATTERY_CAPACITY_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryVoltage == NULL, "Unable to find BatteryService.BATTERY_VOLTAGE_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryTemperature == NULL, "Unable to find BatteryService.BATTERY_TEMPERATURE_PATH");
LOG_FATAL_IF(gFieldIds.mBatteryTechnology == NULL, "Unable to find BatteryService.BATTERY_TECHNOLOGY_PATH");
clazz = env->FindClass("android/os/BatteryManager");
if (clazz == NULL) {
LOGE("Can't find android/os/BatteryManager");
return -1;
}
gConstants.statusUnknown = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_STATUS_UNKNOWN", "I"));
gConstants.statusCharging = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_STATUS_CHARGING", "I"));
gConstants.statusDischarging = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_STATUS_DISCHARGING", "I"));
gConstants.statusNotCharging = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_STATUS_NOT_CHARGING", "I"));
gConstants.statusFull = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_STATUS_FULL", "I"));
gConstants.healthUnknown = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_HEALTH_UNKNOWN", "I"));
gConstants.healthGood = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_HEALTH_GOOD", "I"));
gConstants.healthOverheat = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_HEALTH_OVERHEAT", "I"));
gConstants.healthDead = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_HEALTH_DEAD", "I"));
gConstants.healthOverVoltage = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_HEALTH_OVER_VOLTAGE", "I"));
gConstants.healthUnspecifiedFailure = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_HEALTH_UNSPECIFIED_FAILURE", "I"));
gConstants.healthCold = env->GetStaticIntField(clazz,
env->GetStaticFieldID(clazz, "BATTERY_HEALTH_COLD", "I"));
return jniRegisterNativeMethods(env, "com/android/server/BatteryService", sMethods, NELEM(sMethods));
}
int register_android_server_hdmi_HdmiCecController(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, CLASS_PATH, sMethods, NELEM(sMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
(void)res; // Don't scream about unused variable in the LOG_NDEBUG case
return 0;
}
int register_android_server_InputWindowHandle(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/input/InputWindowHandle",
gInputWindowHandleMethods, NELEM(gInputWindowHandleMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
jclass clazz;
FIND_CLASS(clazz, "com/android/server/input/InputWindowHandle");
GET_FIELD_ID(gInputWindowHandleClassInfo.ptr, clazz,
"ptr", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.inputApplicationHandle,
clazz,
"inputApplicationHandle", "Lcom/android/server/input/InputApplicationHandle;");
GET_FIELD_ID(gInputWindowHandleClassInfo.inputChannel, clazz,
"inputChannel", "Landroid/view/InputChannel;");
GET_FIELD_ID(gInputWindowHandleClassInfo.name, clazz,
"name", "Ljava/lang/String;");
GET_FIELD_ID(gInputWindowHandleClassInfo.layoutParamsFlags, clazz,
"layoutParamsFlags", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.layoutParamsPrivateFlags, clazz,
"layoutParamsPrivateFlags", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.layoutParamsType, clazz,
"layoutParamsType", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.dispatchingTimeoutNanos, clazz,
"dispatchingTimeoutNanos", "J");
GET_FIELD_ID(gInputWindowHandleClassInfo.frameLeft, clazz,
"frameLeft", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.frameTop, clazz,
"frameTop", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.frameRight, clazz,
"frameRight", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.frameBottom, clazz,
"frameBottom", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.scaleFactor, clazz,
"scaleFactor", "F");
GET_FIELD_ID(gInputWindowHandleClassInfo.touchableRegion, clazz,
"touchableRegion", "Landroid/graphics/Region;");
GET_FIELD_ID(gInputWindowHandleClassInfo.visible, clazz,
"visible", "Z");
GET_FIELD_ID(gInputWindowHandleClassInfo.canReceiveKeys, clazz,
"canReceiveKeys", "Z");
GET_FIELD_ID(gInputWindowHandleClassInfo.hasFocus, clazz,
"hasFocus", "Z");
GET_FIELD_ID(gInputWindowHandleClassInfo.hasWallpaper, clazz,
"hasWallpaper", "Z");
GET_FIELD_ID(gInputWindowHandleClassInfo.paused, clazz,
"paused", "Z");
GET_FIELD_ID(gInputWindowHandleClassInfo.layer, clazz,
"layer", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.ownerPid, clazz,
"ownerPid", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.ownerUid, clazz,
"ownerUid", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.inputFeatures, clazz,
"inputFeatures", "I");
GET_FIELD_ID(gInputWindowHandleClassInfo.displayId, clazz,
"displayId", "I");
return 0;
}
