void android_action_send(char *mimeType, char *filename, char *subject, char *text, char *chooser_title) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Action");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "send",
			"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
        aassert(mid);
    }

	jstring j_mimeType = (*env)->NewStringUTF(env, mimeType);
	jstring j_filename = NULL;
	jstring j_subject = NULL;
	jstring j_text = NULL;
	jstring j_chooser_title = NULL;
	if ( filename != NULL )
		j_filename = (*env)->NewStringUTF(env, filename);
	if ( subject != NULL )
		j_subject = (*env)->NewStringUTF(env, subject);
	if ( text != NULL )
		j_text = (*env)->NewStringUTF(env, text);
	if ( chooser_title != NULL )
		j_chooser_title = (*env)->NewStringUTF(env, text);

    (*env)->CallStaticVoidMethod(
        env, cls, mid,
		j_mimeType, j_filename, j_subject, j_text,
		j_chooser_title);
}
void android_start_service(char *title, char *description, char *arg) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/PythonActivity");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "start_service",
                                       "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
        aassert(mid);
    }

    jstring j_title = NULL;
    jstring j_description = NULL;
    jstring j_arg = NULL;
    if ( title != 0 )
            j_title = (*env)->NewStringUTF(env, title);
    if ( description != 0 )
            j_description = (*env)->NewStringUTF(env, description);
    if ( arg != 0 )
            j_arg = (*env)->NewStringUTF(env, arg);

    (*env)->CallStaticVoidMethod(env, cls, mid, j_title, j_description, j_arg);
}
void android_stop_service() {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        cls = (*env)->FindClass(env, "org/renpy/android/PythonActivity");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "stop_service", "()V");
        aassert(mid);
    }

    (*env)->CallStaticVoidMethod(env, cls, mid);
}
void android_wifi_scanner_enable(void){
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "enableWifiScanner", "()V");
        aassert(mid);
    }

    (*env)->CallStaticVoidMethod(env, cls, mid);
}
void android_get_buildinfo() {
    static JNIEnv *env = NULL;

    if (env == NULL) {
        jclass *cls = NULL;
        jfieldID fid;
        jstring sval;

        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);

        cls = (*env)->FindClass(env, "android/os/Build");

        fid = (*env)->GetStaticFieldID(env, cls, "MANUFACTURER", "Ljava/lang/String;");
        sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
        BUILD_MANUFACTURER = (*env)->GetStringUTFChars(env, sval, 0);

        fid = (*env)->GetStaticFieldID(env, cls, "MODEL", "Ljava/lang/String;");
        sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
        BUILD_MODEL = (*env)->GetStringUTFChars(env, sval, 0);

        fid = (*env)->GetStaticFieldID(env, cls, "PRODUCT", "Ljava/lang/String;");
        sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
        BUILD_PRODUCT = (*env)->GetStringUTFChars(env, sval, 0);

        cls = (*env)->FindClass(env, "android/os/Build$VERSION");

        fid = (*env)->GetStaticFieldID(env, cls, "RELEASE", "Ljava/lang/String;");
        sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
        BUILD_VERSION_RELEASE = (*env)->GetStringUTFChars(env, sval, 0);
    }
}
void android_ackstop(void) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/SDLSurfaceView");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "ackStop", "()I");
        aassert(mid);
    }

    (*env)->CallStaticIntMethod(env, cls, mid);
}
void android_hide_keyboard(void) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "hideKeyboard", "()V");
        aassert(mid);
    }

    (*env)->CallStaticVoidMethod(env, cls, mid);
}
void android_show_keyboard(int input_type) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "showKeyboard", "(I)V");
        aassert(mid);
    }

    (*env)->CallStaticVoidMethod(env, cls, mid, (jint) input_type);
}
int android_get_dpi(void) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "getDPI", "()I");
        aassert(mid);
    }

    return (*env)->CallStaticIntMethod(env, cls, mid);
}
Beispiel #10
0
/** \brief Loads a waveform serialized in pkt. Finds an empty (status=STOP) space in
 * anode.loaded_waveforms and calls the nod_waveform_unserializeTo() function. Then calls
 * nod_waveform_load() which loads the binaries to the rtdal pipelines and then calls
 * nod_waveform_run() which sets all modules as runnable.
 * \returns 0 on successs, -1 on error
 */
static int nod_dispatcher_load(packet_t *pkt) {
	/* @TODO: Error messages */
	int i;
	aassert(pkt);

	for (i=0;i<anode.max_waveforms;i++) {
		if (anode.loaded_waveforms[i].status.cur_status == STOP) {
			break;
		}
	}
	if (i == anode.max_waveforms) {
		aerror("Maximum number of waveforms per node reached\n");
		return -1;
	}
	ndebug("waveform_idx=%d\n",i);
	if (nod_waveform_unserializeTo(pkt,&anode.loaded_waveforms[i])) {
		return -1;
	}
	if (nod_waveform_load(&anode.loaded_waveforms[i])) {
		ndebug("error loading waveform_idx=%d. Removing\n",i);
		nod_waveform_remove(&anode.loaded_waveforms[i]);
		return -1;
	}

	return 0;
}
void android_accelerometer_enable(int enable) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "accelerometerEnable", "(Z)V");
        aassert(mid);
    }

    (*env)->CallStaticVoidMethod(
        env, cls, mid,
        (jboolean) enable);
}
void android_vibrate(double seconds) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "vibrate", "(D)V");
        aassert(mid);
    }

    (*env)->CallStaticVoidMethod(
        env, cls, mid,
        (jdouble) seconds);
}
void android_accelerometer_reading(float *values) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;
    jobject jvalues;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "accelerometerReading", "()[F");
        aassert(mid);
    }

    PUSH_FRAME;

    jvalues = (*env)->CallStaticObjectMethod(env, cls, mid);
    (*env)->GetFloatArrayRegion(env, jvalues, 0, 3, values);

    POP_FRAME;
}
char * android_wifi_scan() {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;
    jobject jreading;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/Hardware");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "scanWifi", "()Ljava/lang/String;");
        aassert(mid);
    }

    PUSH_FRAME;
    jreading = (*env)->CallStaticObjectMethod(env, cls, mid);
    const char * reading = (*env)->GetStringUTFChars(env, jreading, 0);
    POP_FRAME;

    return reading;
}
void android_open_url(char *url) {
    static JNIEnv *env = NULL;
    static jclass *cls = NULL;
    static jmethodID mid = NULL;

    if (env == NULL) {
        env = SDL_ANDROID_GetJNIEnv();
        aassert(env);
        cls = (*env)->FindClass(env, "org/renpy/android/SDLSurfaceView");
        aassert(cls);
        mid = (*env)->GetStaticMethodID(env, cls, "openUrl", "(Ljava/lang/String;)V");
        aassert(mid);
    }

    PUSH_FRAME;

    (*env)->CallStaticVoidMethod(
        env, cls, mid,
        (*env)->NewStringUTF(env, url)
        );

    POP_FRAME;
}