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; }