Java Native Interface und "mp3player"

[Wang]

Hallo,

ich bin mit dem folgenden Code in Berührung gekommen und war erstmal ziemlich ratlos, was es damit auf sich hat. Nach etwas Suchen habe ich gesehen, dass es um das Java Native Interface geht:

import java.io.*;

public class Mp3Player
{
	static {
		System.loadLibrary("mp3player");
		libinit();
	}

	public enum PlaylistMode {
		NORMAL(0), LOOP(1), RANDOM(2);

		public final int value;

		private PlaylistMode(int value)
		{
			this.value = value;
		}
	};

	public static final int maxFrameSize = 1441;

	public Mp3Player(PlaylistMode mode, String playlist)
	{
		startPlayer(mode.value, playlist);
	}

	protected void finalize()
	{
		cleanup();
	}

	private native static void libinit();

	private native void startPlayer(int mode, String playlist);

	public native int getNextFrame(byte array[], int offset);

	private native void cleanup();
}

Das JNI dient also in erster Linie - grob gesagt - dazu, aus Java heraus Funktionen/Methoden des Betriebssystems aufzurufen. Kann mir bitte jemand verraten, wo ich in Windows 7 die library "mp3player" finde und wo die nativen Methoden beschrieben werden?

Mir kommt das im Moment "magisch" vor... :autsch:

Thanks!

Gruß
Wang

 

[Marco13]

Naja, nicht "des Betriebssystems", sondern eben der Bibliothek - der DLL, in diesem Fall "mp3player.dll". Diese DLL sollte irgendwo bei dir auf der Festplatte rumliegen, ansonsten würde es schon nicht gehen. Eine Beschreibung bekommt man so höchstens von dem, der entweder den Java-Teil oder besser den DLL-Teil geschrieben hat. Waren da vielleicht irgendwelche .c oder .cpp oder .h oder .hpp-Dateien dabei?

 

[Wang]

Mp3Player.c
Mp3Player.h
Makefile

Damit hat sich meine Frage erübrigt (sorry, langsam checke ich das Konzept von JNI). Muss man in der Kommandozeile beim Aufrufen des Java-Programms noch etwas beachten?

 

[JNAJNI]

JNI - Java Native Interface

Eine Möglichkeit von Java nativen Code bzw durch CallBacks von nativen Code Java zu callen.

Allgemeiner Entwicklungsablauf :
1) Schreiben des Java-Source
2) Java-Source compilen
3) "javah -jni" callen um Header-File zu erzeugen
4) Entwicklung der nativen Lib entsprechend des Header-Files
5) Compilen und Linken der Lib
6) Starten der Klasse, laden der Lib und prüfen der Funktionalität

Dabei ist zu beachten das JNI grundsätzlich so geschrieben wird das man die zu verwendene Lib selbst entwickelt.

Das was du da hast ist z.B. JNI


JNA - Java Native Acces

Eine Möglichkeit von Java bereits bestehende (System-)Libs zu callen.

Allgemeiner Entwicklungsablauf
1) Laden der JNA-Lib
2) Schreiben des Java-Source
3) Java-Source compilen
4) Starten der Klasse

JNA verwendet intern auch nur JNI (ist also ein JNI-Framework) und sieht selbst auch so aus wie dein Code. Der Unterschied ist aber das man mit JNA direkt bereits existierende Libs laden und Funktionen aus ihnen callen kann.

Ein Beispiel wäre das erkennen der Windows-Version oder von Admin-Rechten :

import com.sun.jna.*;
import javax.swing.*;
public class AdminTest
{
	public static void main(String[] args) throws Exception
	{
		int ver=Kernel32Lib.INSTANCE.GetVersion();
		int majVer=(ver&0xFF);
		int minVer=((ver>>8)&0xFF);
		int build=(ver>>16);
		if(majVer<6)
		{
			JOptionPane.showMessageDialog(null, "Windows NT "+majVer+"."+minVer+"."+build+" NOT supported !", "ERROR", JOptionPane.ERROR_MESSAGE);
			System.exit(1);
		}
		JOptionPane.showMessageDialog(null, Shell32Lib.INSTANCE.IsUserAnAdmin(), "Admin", JOptionPane.INFORMATION_MESSAGE);
	}
	public interface Shell32Lib extends Library
	{
		Shell32Lib INSTANCE=(Shell32Lib)Native.loadLibrary("Shell32", Shell32Lib.class);
		boolean IsUserAnAdmin();
	}
	public interface Kernel32Lib extends Library
	{
		Kernel32Lib INSTANCE=(Kernel32Lib)Native.loadLibrary("Kernel32", Kernel32Lib.class);
		int GetVersion();
	}
}