APK Dateien dekompilieren

Manchmal ist es doch sehr praktisch eine APK Datei zu dekompilieren, z.B. um ein wenig Reverse Engineering zu betreiben. Nachdem wir die gewünschte APK auf der Festplatte haben laden wir uns dex2jar unter http://code.google.com/p/dex2jar herunter. Mit diesem Tool wandeln wir den Dalvik Intermediate Code in eine JAR (sprich Java) Datei um. Wir wenden dex2jar mittels

dex2jar.sh test.apk

auf unsere APK an. Heraus kommt eine JAR Datei welche wir mit der JD-GUI (zu finden unter http://java.decompiler.free.fr/?q=jdgui) öffnen und uns so anschauen können.

Weitere Informationen gibt es unter:
http://stackoverflow.com/questions/3122635/android-decompile-apk
http://stackoverflow.com/questions/1249973/decompiling-dex-into-java-sourcecode

Mana Mobile (Qt) für Android kompilieren

Da auf Android Anwendungen in Java geschrieben werden, ist das kompilieren von Mana Mobile für Android etwas komplizierter. Schließlich handelt es sich um eine in Qt (und C++) geschriebene Anwendung. Diese Anleitung bezieht sich dabei auf einen Kubuntu 10.10 Rechner. Zuerst muss das entsprechende Qt SDK für Android unter http://sourceforge.net/projects/necessitas/files/ heruntergeladen werden.

Nach dem Download muss der Installer mittels:

chmod +x necessitas-0.1.1-Linux-x86-Install

ausführbar gemacht werden. Dann kann der Installer gestartet werden. Installiert werden sollte das ganze in den Ordner /opt/necessitas/ da dieser vom Entwicklerteam von Necessitas intensiv getestet wurde.

Nun müssen noch das Android SDK sowie das Android NDK installiert werden. Das SDK kann dabei unter http://developer.android.com/sdk/index.html bezogen werden. Nach dem Download des selben wird das SDK entpackt und an eine gewünschte Stelle gelegt. Anschließend geht man dort in den Ordner tools und führt im Terminal

./android update sdk

aus. Dadurch wird das SDK geupdatet. Nun muss nur noch das NDK (zu finden unter http://developer.android.com/sdk/ndk/index.html) herunter geladen werden und an gewünschter Stelle entpackt werden. Bei beiden Developer Kits ist dabei zu achten die jeweils richtige Version (in diesem Fall die Linux Version) herunterzuladen.

Nun kann der Qt Creator for Android gestartet werden. Der Installer hat dazu im Desktop Ordner (im Home Verzeichnis) ein Shortcut angelegt. Nach dem Start der IDE öffnet man die Optionen (Tools -> Options) und geht dort auf den Qt4 Tab. Dort wird bei der Android für QT Version der Pfad für qmake eingetragen (/opt/necessitas/Android/“qtversion“/bin/qmake). Dieser QT Version muss dann noch ein Name zugewiesen werden z.B. android-lighthouse-4.8.0.

Als nächstes wechselt man zu dem Android Tab. Dort wird dann der Pfad zum Android SDK (Minimum android-sdk_r09) und zum Android NDK (Minimum android-ndk_r5) gesetzt. Nun muss der korrekte Toolchain gesetzt werden, in diesem Fall arm-linux-androideabi-4.4.3. Als letztes muss der Pfad für ant gesetzt werden welcher meist /usr/bin/ant sein sollte.

Nun geht man nochmal auf den Qt4 Tab und klickt dort auf Build all, damit alle wichtigen Tools gebaut werden. Anschließend kann der Dialog mit einem Klick auf Apply & OK verlassen werden.

Nun kann es an die Einrichtung von Mana Mobile gehen. Im ersten Schritt sollte das Projekt aus den SVN ausgecheckt werden. Dies funktioniert mittels:

svn checkout https://invertika.googlecode.com/svn/trunk/client-mobile/ invertika

In diesem Projekt befindet sich eine .pro Datei welche mit dem Qt Creator geöffnet werden kann. Beim öffnen fragt der Qt Creator welche Buildziele man compieren möchte. Hier wählt man die Androidvarianten mit an und bestätigt das ganze mit dem Finish Button. Dann kann man das ganze testweise mit dem Build All Button kompilieren. Dabei dürfte es an zwei Stellen zu Problemen kommen. Die erste Stelle ist die Funktion setOrientation (in der Datei qmlapplicationviewer.cpp):

    case ScreenOrientationLockPortrait:
        //attribute = Qt::WA_LockPortraitOrientation;
        break;
    case ScreenOrientationLockLandscape:
        //attribute = Qt::WA_LockLandscapeOrientation;
        break;
    default:
    case ScreenOrientationAuto:
        //attribute = Qt::WA_AutoOrientation;
        break;

Dort müssen die Zuweisungen des Attributes auskommentiert werden. Anschließend dürfte ein Fehler in der Bibliothek enet (enet_address_get_host in der Datei unix.c) auftreten:

    #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
        //gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
    #else
        hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
    #endif
    #else
        in.s_addr = address -> host;

        hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
    #endif

Hier wird dann der Funktionsaufruf gethostbyaddr auskommentiert. Danach sollte das ganz kompilieren. Wenn man dann auf den Run Button drückt liefert ant noch eine Fehlermeldung:

BUILD FAILED
/home//android-sdk-linux_x86/tools/ant/main_rules.xml:306: null returned: 1

Total time: 0 seconds
Packaging Error: Command ‚/usr/bin/ant debug‘ failed.Exit code: 1
Error while building project manamobile (target: Android)
When executing build step ‚Packaging for Android‘

Hier hilft es die minimale SDK Version von android-3 auf android-4 anzuheben. Dazu geht man auf den Tab Projects und dort auf die Run Konfiguration des Androidprojektes. Dort kann man diese Einstellungen dann vornehmen.

Da die OpenGL Bindings für die Android Qt Version noch nicht lauffähig sind muss in der Manamobile.pro die Zeile contains(QT_CONFIG, opengl): QT += opengl auskommentiert werden:

    QT += network
    #contains(QT_CONFIG, opengl): QT += opengl

In der main.cpp müssen folgende Zeilen auskommentiert werden:

    #ifndef QT_NO_OPENGL
    //#include 
    #endif
 
    #ifndef QT_NO_OPENGL
       //viewer.setViewport(new QGLWidget);
    #endif

Außerdem muss noch die Zeile:

    viewer.setMainQmlFile(QLatin1String("qml/main/mobile.qml"));

in

    viewer.setMainQmlFile(QLatin1String("/sdcard/qml/main/mobile.qml"));

abgeändert werden. Der qml Ordner sollte dem entsprechend dann auch auf der SD Karte liegen. Eventuell kann es zu Problemen kommen, wenn bei der Anwendung die falschen bzw. ungenügende Rechte im Manifest gesetzt sind. Normalerweise werden für Mana Mobile folgende Rechte benötigt:

– android.permission.INTERNET
– android.permission.WRITE_EXTERNAL_STORAGE

Ein anderes Problem könnte auftreten wenn nicht alle benötigten Qt Bibliotheken in den Projekteinstellungen aktiviert sind. Dazu geht man in die Projekteigenschaften unter Android -> Run -> Package Configuration -> Libraries und klickt dort auf den Button Read informations from application. Nun muss aus dem Market nur noch Ministro (stellt die OpenGL Bindings unter Android bereit) heruntergeladen werden. Danach sollte Manamobile auf einem Androidgerät laufen. Dabei kommt es im Moment noch zu Einschränkungen, so werden Touchevents noch nicht richtig verarbeitet.

AndEngine und Eclipse unter Ubuntu aufsetzen

Bei AndEngine handelt es sich um eine Gameengine für Androidgeräte. Die Apps für diese Plattform werden ja bekanntlich in Java geschrieben. Und darum soll es hier auch gehen. Im ersten Schritt wird Eclipse aufgesetzt und anschließend nehmen wir die AndEngine in Betrieb. Im ersten Schritt muss also das Paket eclipse installiert werden. Danach sollte das Android SDK für Linux unter http://developer.android.com/sdk/index.html heruntergeladen werden und auf der Festplatte entpackt werden. Dann geht es in den Ordner tools des SDKs und dort wird dann

./android update sdk 

ausgeführt. Nun bestätigt man die Lizenz und installiert die verschiedenen SDK Versionen. Dies kann dabei einige Minuten dauern.

Nun kann man Eclipse starten. Beim ersten Start erscheint ein Begrüßungsbildschirm den man schließen kann. Danach sollte man unter Help -> Install new Software die Android Development Tools installieren. Dazu wird in dem sich öffnenden Dialog die URL http://dl-ssl.google.com/android/eclipse/ eingegeben und durch einen Druck auf den Add… Button hinzugefügt. Dann klicken wir die Checkbox Developer Tools an und betätigen die Installation mit dem Next… Button. Mittels eines Assistenten wird man nun durch die Installation geleitet. Nachdem die Installation beendet ist empfiehlt Eclipse einen Neustart der Umgebung. Diesem sollte Wunsch sollte man Folge leisten.

Nun benötigt Eclipse die Information wo das Android SDK sich auf der Festplatte befindet. Dazu geht man auf Window -> Preferences -> Android. Dort wählt man den Pfad des Android SDKs aus und bestätigt den Dialog mit OK.

Die grundlegende Konfigurationsarbeit ist damit geleistet. Nun kann mit dem ersten Projekt begonnen werden. Dazu gehen wir auf File -> New -> Project und wählen dort Android Project aus und klicken dann auf Next. In dem darauf folgenden Dialog geben wir dem Projekt einen Namen z.B. Hello World. Im Feld Package Name geben wir den Namen des Package an z.B. net.seeseekey.hello_world und bei Activity name z.B. FormMain und bei Application name z.B. Hello World und bestätigen das ganze mit dem Finish Button.

Danach wird automatisch das Grundgerüst für eine Android Applikation erzeugt. Sollte es beim Erzeugen der Anwendung der Fehler

Project ‚RuntimeAndroid‘ is missing required source folder ‚gen‘
The project cannot be built until build errors are resolved 

auftreten so hilft es die R.java Datei zu löschen. Sie wird danach automatisch neu erzeugt. Wenn wir nun auf den grünen Play Knopf (Run) in der Symbolleiste klicken so startet Eclipse das Programm im Android Emulator. Beim ersten Start sollte allerdings ein Dialog erscheinen welcher einem anbietet ein virtuelles Gerät für den Emulator anzulegen. Nachdem dies geschehen ist, wird das Hello World Programm im Emulator geladen und ausgeführt. Und schon ist das erste Hello World Programm geschrieben und die Funktionsfähigkeit der IDE getestet.

Nun geht es an die AndEngine. Erst einmal holen wir uns den Sourcecodes mittels hg (Mercurial) auf die Festplatte:

hg clone https://andengine.googlecode.com/hg/ andengine
hg clone https://andengineexamples.googlecode.com/hg/ andengineexamples 

Anschließend importieren wir das andengineexamples Projekt (File -> Import…) in den Workspace. In dem Projekt AndEngineExamples sind dabei viele Beispiele zur Anwendung der Engine zu finden.

Nun nehmen wir unser bereits angelegtes Hello World Projekt und erzeugen in diesem (mittels New -> Folder) einen Ordner namens lib. In diesen kopieren wir die andengine.jar aus dem AndEngine Examples Projekt. Nun klicken wir mit der rechten Maustaste auf die andengine.jar und wählen dort Build Path -> Add To Build Path… aus. Damit ist die Bibliothek referenziert. Nun gehen wir in unsere Activity, in diesem Fall FormMain und löschen dort alles bis auf die packages Zeile. Nun fügen wir dort folgenden Quelltext ein:

public class FormMain extends BaseGameActivity {
	// Konstanten
	private static final int CAMERA_WIDTH = 720;
	private static final int CAMERA_HEIGHT = 480;

	// Variablen
	private Camera mCamera;

	@Override
	public Engine onLoadEngine() {
		this.mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
		return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), this.mCamera));
	}

	@Override
	public void onLoadResources() {
	}

	@Override
	public Scene onLoadScene() {
		this.mEngine.registerUpdateHandler(new FPSLogger());

		final Scene scene = new Scene(1);
		scene.setBackground(new ColorBackground(0, 0, 0.8784f));

		return scene;
	}

	@Override
	public void onLoadComplete() {

	}
}

Anschließend werden mittels Strg + Shift + O alle benötigten Importe in die Datei eingefügt. Wichtig ist es jetzt noch dem Manifest folgende Zeile hinzuzufügen:

<uses-permission android:name="android.permission.WAKE_LOCK"/>

Nun kann man das ganze im Emulator starten. Es dürfte ein blauer Bildschirm angezeigt werden. Nun kann man sich damit beginnen das ganze mit Leben zu erfüllen :)

Weitere Informationen gibt es unter:
http://www.andengine.org/
http://code.google.com/p/andengine/
http://code.google.com/p/andengineexamples/
http://developer.android.com/sdk/installing.html
http://www.andengine.org/forums/tutorials/getting-started-updated-t2198.html
http://www.andengine.org/forums/tutorials/andengine-core-terminology-t316.html
http://www.andengine.org/forums/tutorials/getting-started-with-andengine-t11.html
http://www.andengine.org/forums/tutorials/eclipse-andengine-and-helloworld-t380.html
http://www.andengine.org/forums/tutorials/mimminito-s-tutorial-list-t417.html

ClockworkMod Recovery auf dem Samsung Galaxy Tab

Auf dem Samsung Galaxy Tab (in diesem Fall die Version von o2, nicht gebrandet) ist es mittlerweile möglich das ClockworkMod Recovery laufen zu lassen. Dazu lädt man sich den ROM Manager aus dem Market herunter. Mit diesem kann man das ClockworkMod Recovery anschließend installieren. Ich wählte dabei die T-Mobile Variante. Im Anschluss startete ich in das ClockworkMod Recovery mittels der im ROM Manager angebotenen Funktion. Momentan ist es allerdings so, das das Recovery nicht permanent im Speicher installiert wird. Das Samsung eigene Recovery ist also weiterhin im Gerät enthalten und wird wieder aktiv sobald man das Gerät ausschaltet. Hier ist also noch Bedarf für Verbesserungen ;)

Weitere Informationen gibt es unter:
http://forum.xda-developers.com/showthread.php?p=9770377

Nützliche Tastenkombinationen für das Samsung Galaxy Tab

Beim Samsung Galaxy ist der Akku ja in das Gerät eingebaut. Aus diesem Grund ist es auch nicht zu schlecht zu wissen, wie man das Gerät zum Beispiel zu einem Reset bewegen kann. Da ist erst einmal der Softreset, bei welchem das Gerät einfach neu gestartet wird. Dieser wird ausgelöst, in dem man die Powertaste für zirka acht bis zehn Sekunden gedrückt hält. Für einen Hardreset, welcher alle Einstellungen auf die Fabrikeinstellungen setzt, wird die Volume Down Taste im ausgeschalteten Zustand gedrückt. Mit der gedrückten Taste wird das Tab nun wieder angeschaltet. Um in den Recoverymodus zu kommen muss man im ausgeschaltetem Zustand die Volume Up Taste gedrückt halten und anschließend das Gerät wieder anschalten.

Weitere Informationen gibt es unter:
http://www.hardreset.eu/samsung_galaxy_tab_p1000_hard_reset_soft_reset_en.html