static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz,
jlong nativeObject, jobject parcelObj) {
Parcel* parcel = parcelForJavaObject(env, parcelObj);
if (parcel == NULL) {
doThrowNPE(env);
return 0;
}
sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));
sp<IBinder> binder(parcel->readStrongBinder());
// update the Surface only if the underlying IGraphicBufferProducer
// has changed.
if (self != NULL
&& (self->getIGraphicBufferProducer()->asBinder() == binder)) {
// same IGraphicBufferProducer, return ourselves
return jlong(self.get());
}
sp<Surface> sur;
sp<IGraphicBufferProducer> gbp(interface_cast<IGraphicBufferProducer>(binder));
if (gbp != NULL) {
// we have a new IGraphicBufferProducer, create a new Surface for it
sur = new Surface(gbp, true);
// and keep a reference before passing to java
sur->incStrong(&sRefBaseOwner);
}
if (self != NULL) {
// and loose the java reference to ourselves
self->decStrong(&sRefBaseOwner);
}
return jlong(sur.get());
}
// Atomically advance the cursor, claiming a number of indicies for the local thread to act upon. Returns
// false if all indicies have been claimed, or true if some new indicies have been claimed.
bool GPGC_PopulationArray::atomic_claim_array_chunk(uint64_t& start_cursor, uint64_t& end_cursor, long work_unit)
{
start_cursor = 0;
end_cursor = 0;
uint64_t max_cursor;
uint64_t cursor;
uint64_t new_cursor;
do {
max_cursor = this->max_cursor();
cursor = this->cursor();
if ( cursor >= max_cursor ) {
return false;
}
new_cursor = cursor + work_unit;
if ( new_cursor > max_cursor ) {
new_cursor = max_cursor;
}
} while ( jlong(cursor) != Atomic::cmpxchg(jlong(new_cursor), (jlong*)this->cursor_addr(), jlong(cursor)) );
start_cursor = cursor;
end_cursor = new_cursor;
return true;
}
inline void GPGC_PageInfo::atomic_clear_flag(Flags flag)
{
uint64_t old_flags;
uint64_t new_flags;
do {
old_flags = _flags;
assert0( (old_flags&flag) != 0 );
new_flags=old_flags&~flag;
} while ( jlong(old_flags) != Atomic::cmpxchg(jlong(new_flags), (jlong*)&_flags, jlong(old_flags)) );
}
inline void GPGC_PageInfo::atomic_set_flag(Flags flag, Flags assert_not_flag)
{
uint64_t old_flags;
uint64_t new_flags;
do {
old_flags = _flags;
assert0( (old_flags&assert_not_flag) == 0 );
new_flags=old_flags|flag;
} while ( jlong(old_flags) != Atomic::cmpxchg(jlong(new_flags), (jlong*)&_flags, jlong(old_flags)) );
}
inline uint64_t GPGC_PageInfo::atomic_decrement_flags_count()
{
uint64_t old_flags;
uint64_t new_flags;
do {
old_flags = _flags;
assert( (old_flags>>CountShift) != 0, "GPGC_PageInfo flags count underflow" );
new_flags = old_flags - (1UL << CountShift);
} while ( jlong(old_flags) != Atomic::cmpxchg(jlong(new_flags), (jlong*)&_flags, jlong(old_flags)) );
return (new_flags >> CountShift);
}
inline void GPGC_PageInfo::atomic_increment_flags_count(uint64_t delta)
{
uint64_t old_flags;
uint64_t new_flags;
do {
old_flags = _flags;
assert( delta <= uint64_t(WordsPerGPGCPage), "GPGC_PageInfo flags count delta too large" );
assert( (old_flags>>CountShift) <= uint64_t(WordsPerGPGCPage), "GPGC_PageInfo flags count overflow" );
assert( ((old_flags>>CountShift)+delta) <= uint64_t(WordsPerGPGCPage), "Increment delta causing flags count overflow" );
new_flags = old_flags + (delta << CountShift);
} while ( jlong(old_flags) != Atomic::cmpxchg(jlong(new_flags), (jlong*)&_flags, jlong(old_flags)) );
}
inline void GPGC_PageInfo::reset_unshatter_free_stats()
{
uint64_t old_flags;
uint64_t new_flags;
do {
old_flags = _flags;
assert0( (old_flags&PinnedFlag) == 0 );
new_flags = old_flags & AllButCountMask;
new_flags = new_flags & ~AllFreeStatFlags;
new_flags=new_flags|UnshatterFreeStatsFlag;
} while ( jlong(old_flags) != Atomic::cmpxchg(jlong(new_flags), (jlong*)&_flags, jlong(old_flags)) );
}
inline void GPGC_PageInfo::set_relocate_space(long space)
{
uint64_t old_flags;
uint64_t new_flags;
do {
old_flags = _flags;
new_flags = old_flags & ~(RelocateSpaceMask<<RelocateSpaceShift);
new_flags = new_flags | (uint64_t(space)<<RelocateSpaceShift);
} while ( jlong(old_flags) != Atomic::cmpxchg(jlong(new_flags), (jlong*)&_flags, jlong(old_flags)) );
assert0(relocate_space()==uint64_t(space));
}
inline jlong getCurrentTime() {
DWORD l,h;
__asm rdtsc;
__asm mov h,edx;
__asm mov l,eax;
return (jlong(h)<<32)|l;
}
void
ReposVerifyCallback::onVerifyError(svn_revnum_t revision,
svn_error_t *verify_err,
apr_pool_t *scratch_pool)
{
JNIEnv *env = JNIUtil::getEnv();
// Java method id will not change during the time this library is
// loaded, so it can be cached.
static jmethodID mid = 0;
if (mid == 0)
{
jclass clazz = env->FindClass(JAVAHL_CLASS("/callback/ReposVerifyCallback"));
if (JNIUtil::isJavaExceptionThrown())
return;
mid = env->GetMethodID(clazz, "onVerifyError",
"(J" JAVAHL_ARG("/ClientException;") ")V");
if (JNIUtil::isJavaExceptionThrown() || mid == 0)
return;
env->DeleteLocalRef(clazz);
}
jthrowable jverify_err = NULL;
if (verify_err)
jverify_err = JNIUtil::createClientException(svn_error_dup(verify_err), NULL);
if (JNIUtil::isJavaExceptionThrown())
return;
env->CallVoidMethod(m_jverify_cb, mid, jlong(revision), jverify_err);
if (verify_err)
env->DeleteLocalRef(jverify_err);
}
void GPGC_RemapTargetArray::atomic_add_page(PageNum page, int64_t stripe, GPGC_PageInfo::Gens source_gen)
{
uint64_t old_length;
uint64_t new_length;
do {
old_length = _current_length;
new_length = old_length + 1;
assert0(old_length < _allocated_length);
} while ( jlong(old_length) != Atomic::cmpxchg(jlong(new_length), (jlong*)&_current_length, jlong(old_length)) );
_array[old_length].page = page;
_array[old_length].stripe = stripe;
_array[old_length].source_gen = source_gen;
}
static jlong nativeGetLong(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting long for %d,%d from %p", row, column, window);
CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);
if (!fieldSlot) {
throwExceptionWithRowCol(env, row, column);
return 0;
}
int32_t type = window->getFieldSlotType(fieldSlot);
if (type == CursorWindow::FIELD_TYPE_INTEGER) {
return window->getFieldSlotValueLong(fieldSlot);
} else if (type == CursorWindow::FIELD_TYPE_STRING) {
size_t sizeIncludingNull;
const char* value = window->getFieldSlotValueString(fieldSlot, &sizeIncludingNull);
return sizeIncludingNull > 1 ? strtoll(value, NULL, 0) : 0L;
} else if (type == CursorWindow::FIELD_TYPE_FLOAT) {
return jlong(window->getFieldSlotValueDouble(fieldSlot));
} else if (type == CursorWindow::FIELD_TYPE_NULL) {
return 0;
} else if (type == CursorWindow::FIELD_TYPE_BLOB) {
throw_sqlite3_exception(env, "Unable to convert BLOB to long");
return 0;
} else {
throwUnknownTypeException(env, type);
return 0;
}
}
void VibroWorker::enqueueVibration (int length_ms)
{
if (KITCHENTIMER_USE_VIBRATION) {
if (jni_env && objVibrator && mVibrate)
jni_env->CallVoidMethod (objVibrator, mVibrate, jlong (length_ms));
}
}
void
StdDispatch_Test::PeekPoke()
{
RObject o = (RObject)StdDispatch::New("acdk/tools/aunit/DmiTestClass");
o->poke("pubBool", true);
testAssert(bool(o->peek("pubBool")) == true);
o->poke("pubBool", false);
o->poke("pubChar", char(42));
testAssert(char(o->peek("pubChar")) == 42);
o->poke("pubChar", char(42));
o->poke("pubByte", byte(13));
testAssert(byte(o->peek("pubByte")) == 13);
o->poke("pubByte", 0);
o->poke("pubShort", short(600));
testAssert(short(o->peek("pubShort")) == 600);
o->poke("pubShort", 0);
o->poke("pubInt", short(12345));
testAssert(int(o->peek("pubInt")) == 12345);
o->poke("pubInt", 0);
o->poke("pubLong", jlong(123457890));
testAssert(jlong(o->peek("pubLong")) == 123457890);
o->poke("pubLong", jlong(0));
o->poke("pubFloat", float(2.1));
float tf = o->peek("pubFloat");
//vc6 bug?! testAssert(peekf("pubFloat") == 2.1);
o->poke("pubFloat", float(0));
o->poke("pubDouble", double(1.2345));
testAssert(double(o->peek("pubDouble")) == 1.2345);
o->poke("pubDouble", double(0));
o->poke("pubObject", o);
testAssert(RObject(o->peek("pubObject")) == o);
o->poke("pubObject", Nil);
try {
o->poke("privInt", 2);
testAssert("expect exception" == 0);
} catch (RDmiException ex) {
System::out->println("Expected Exception: \n" + ex->getMessage());
}
}
void
StdDispatch_Test::PeekPokeStatic()
{
//#if defined(__BORLANDC__) &&
// System::out->println("Access to static Member is buggy with Borland C++"); //###
//#else //defined(__BORLANDC__)
const char* cn = "acdk/tools/aunit/DmiTestClass";
RObject o = (RObject)StdDispatch::New("acdk/tools/aunit/DmiTestClass");
StdDispatch::poke_static(cn, "pubStaticBool", true);
testAssert(bool(StdDispatch::peek_static(cn, "pubStaticBool")) == true);
StdDispatch::poke_static(cn, "pubStaticBool", false);
StdDispatch::poke_static(cn, "pubStaticChar", char(42));
testAssert(char(StdDispatch::peek_static(cn, "pubStaticChar")) == 42);
StdDispatch::poke_static(cn, "pubStaticChar", char(0));
StdDispatch::poke_static(cn, "pubStaticByte", byte(212));
testAssert(byte(StdDispatch::peek_static(cn, "pubStaticByte")) == 212);
StdDispatch::poke_static(cn, "pubStaticByte", byte(0));
StdDispatch::poke_static(cn, "pubStaticShort", short(1234));
testAssert(short(StdDispatch::peek_static(cn, "pubStaticShort")) == 1234);
StdDispatch::poke_static(cn, "pubStaticShort", short(0));
StdDispatch::poke_static(cn, "pubStaticInt", int(123456));
testAssert(int(StdDispatch::peek_static(cn, "pubStaticInt")) == 123456);
StdDispatch::poke_static(cn, "pubStaticInt", int(0));
StdDispatch::poke_static(cn, "pubStaticLong", jlong(123456789));
testAssert(jlong(StdDispatch::peek_static(cn, "pubStaticLong")) == 123456789);
StdDispatch::poke_static(cn, "pubStaticLong", jlong(0));
StdDispatch::poke_static(cn, "pubStaticFloat", float(2.5));
float f = StdDispatch::peek_static(cn, "pubStaticFloat");
StdDispatch::poke_static(cn, "pubStaticFloat", float(0));
StdDispatch::poke_static(cn, "pubStaticDouble", double(1.3456));
testAssert(double(StdDispatch::peek_static(cn, "pubStaticDouble")) == 1.3456);
StdDispatch::poke_static(cn, "pubStaticDouble", double(0));
StdDispatch::poke_static(cn, "pubStaticObject", o);
testAssert(RObject(StdDispatch::peek_static(cn, "pubStaticObject")) == o);
StdDispatch::poke_static(cn, "pubStaticObject", Nil);
//#endif //defined(__BORLANDC__)
}
void JNIHelper::callSetHighScore(int64 score, const char* leaderboard)
{
jlong jScore = jlong(score);
jstring jLeaderboardId = g_Env->NewStringUTF(leaderboard);
g_Env->CallVoidMethod(m_Activity, OpenFeintScore, jLeaderboardId, jScore);
g_Env->DeleteLocalRef(jLeaderboardId);
}
JniObjectLinker::JniObjectLinker(void * nativePtr, const char * full_class_name, const JNINativeMethod * methods_list, size_t sizeof_methods_list) :
full_class_name_(full_class_name)
, preloaded_(false)
{
preloadJavaClasses(methods_list, sizeof_methods_list);
// Creating Java object
handler_.reset(new QJniObject(full_class_name, "J", jlong(nativePtr)));
}
static void android_view_TextureView_createNativeWindow(JNIEnv* env, jobject textureView,
jobject surface) {
sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surface));
sp<ANativeWindow> window = new Surface(producer, true);
window->incStrong((void*)android_view_TextureView_createNativeWindow);
SET_LONG(textureView, gTextureViewClassInfo.nativeWindow, jlong(window.get()));
}
QAndroidCompass::QAndroidCompass(QObject * parent /*= 0*/) :
QObject(parent)
{
preloadJavaClasses();
// Creating Java object
handler_.reset(new QJniObject(c_full_class_name_, "J",
jlong(reinterpret_cast<void*>(this))));
}
QLocationManagerProvidersListener::QLocationManagerProvidersListener(QObject * parent /*= 0*/) :
QObject(parent)
{
preloadJavaClasses();
// Creating Java object
handler_.reset(new QJniObject(c_full_class_name_, "J",
jlong(reinterpret_cast<void*>(this))));
}
void tst_QAndroidJniObject::getStaticLongField()
{
QAndroidJniEnvironment env;
jclass cls = env->FindClass("java/lang/Long");
QVERIFY(cls != 0);
jlong i = QAndroidJniObject::getStaticField<jlong>(cls, "MAX_VALUE");
QCOMPARE(i, jlong(9223372036854775807L));
}
void tst_QAndroidJniObject::getStaticDoubleField()
{
QAndroidJniEnvironment env;
jclass cls = env->FindClass("java/lang/Double");
QVERIFY(cls != 0);
jdouble i = QAndroidJniObject::getStaticField<jdouble>(cls, "NaN");
jlong *k = reinterpret_cast<jlong*>(&i);
QCOMPARE(*k, jlong(0x7ff8000000000000L));
}
void tst_QAndroidJniObject::callStaticLongMethodClassName()
{
QString number = QString::number(123);
QAndroidJniObject parameter = QAndroidJniObject::fromString(number);
jlong returnValue = QAndroidJniObject::callStaticMethod<jlong>("java/lang/Long",
"parseLong",
"(Ljava/lang/String;)J",
parameter.object<jstring>());
QCOMPARE(returnValue, jlong(number.toLong()));
}
/*
* Class: de_rwth_0005faachen_techinfo_ltilib_Matrix
* Method: closeTheGate
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_de_rwth_1aachen_techinfo_ltilib_Matrix_closeTheGate
(JNIEnv *env, jobject m) {
jclass cls=env->FindClass("de/rwth_aachen/techinfo/ltilib/Matrix");
jfieldID fid=env->GetFieldID(cls, "nativeObject", "J");
jniMatrix *mat=jlong2matrix(env->GetLongField(m,fid));
_lti_debug("]");
env->SetLongField(m, fid, jlong(0));
delete mat;
}
long long NanoTime()
{
// This should be the same as java's system.nanoTime(), which is what the
// choreographer vsync timestamp is based on.
struct timespec tp;
const int status = clock_gettime(CLOCK_MONOTONIC, &tp);
if ( status != 0 )
{
LOG( "clock_gettime status=%i", status );
}
const long long result = (long long)tp.tv_sec * (jlong)(1000 * 1000 * 1000) + jlong(tp.tv_nsec);
return result;
}
JNIEXPORT
jlong JNICALL
Java_org_mozilla_gecko_mozglue_SharedMemory_map(JNIEnv *env, jobject jobj, jint fd, jint length)
{
void* address = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (address == MAP_FAILED) {
char msg[128];
snprintf(msg, sizeof(msg), "mmap failed. errno=%d", errno);
env->ThrowNew(env->FindClass("java/lang/NullPointerException"), msg);
return 0;
}
return jlong(address);
}
static jlong nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) {
SensorManager& mgr(SensorManager::getInstance());
sp<SensorEventQueue> queue(mgr.createEventQueue());
sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ);
if (messageQueue == NULL) {
jniThrowRuntimeException(env, "MessageQueue is not initialized.");
return 0;
}
sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQ, scratch);
receiver->incStrong((void*)nativeInitSensorEventQueue);
return jlong(receiver.get());
}
jlong
StateReporter::finishReport()
{
//DEBUG:fprintf(stderr, " (n) StateReporter::finishReport()\n");
if (!m_valid) { throw_reporter_inactive(); return SVN_INVALID_REVNUM; }
SVN::Pool subPool(pool);
SVN_JNI_ERR(m_raw_reporter->finish_report(m_report_baton,
subPool.getPool()),
SVN_INVALID_REVNUM);
m_valid = false;
return jlong(m_target_revision);
}
void tst_QAndroidJniObject::callStaticLongMethod()
{
QAndroidJniEnvironment env;
jclass cls = env->FindClass("java/lang/Long");
QVERIFY(cls != 0);
QString number = QString::number(123);
QAndroidJniObject parameter = QAndroidJniObject::fromString(number);
jlong returnValue = QAndroidJniObject::callStaticMethod<jlong>(cls,
"parseLong",
"(Ljava/lang/String;)J",
parameter.object<jstring>());
QCOMPARE(returnValue, jlong(number.toLong()));
}
static jvalue numToJvalue(const T &num)
{
jvalue value;
switch (sig) //a good compiler should simplify out the switch
{
case 'Z': value.z = jboolean(num); return value;
case 'C': value.c = jchar(num); return value;
case 'B': value.b = jbyte(num); return value;
case 'S': value.s = jshort(num); return value;
case 'I': value.i = jint(num); return value;
case 'J': value.j = jlong(num); return value;
case 'F': value.f = jfloat(num); return value;
case 'D': value.d = jdouble(num); return value;
}
poco_bugcheck_msg(std::string(1, sig).c_str()); throw;
}
