Wie verwende ich den gleichen C ++ Code für Android und iOS?

Update.

Diese Antwort ist sehr beliebt, auch vier Jahre nach Schreibe ich es, in diesen vier Jahren viele Dinge geändert hat, so habe ich beschlossen, aktualisieren Sie meine Antwort passt besser zu unserer aktuellen Realität. Die Antwort, die Idee ändert sich nicht; die Umsetzung hat sich ein wenig geändert. Mein Englisch hat auch geändert, es hat sich einiges verbessert, so dass die Antwort ist mehr jeder versteht jetzt.

Bitte werfen Sie einen Blick auf der reposo dass Sie herunterladen können und führen Sie den code, werde ich unten zeigen.

Die Antwort

Bevor ich zeige den code, bitte nehmen Sie eine Menge auf der folgenden Abbildung.

Jedes OS hat seine Benutzeroberfläche und Besonderheiten, so wollen wir speziellen code schreiben, um jede Plattform in diesem Zusammenhang. In anderen Händen, die alle Logik-code, business-Regeln, und die Dinge, die geteilt werden können, die wir beabsichtigen, zu schreiben, mit C++, so können wir kompilieren der gleiche code auf jeder Plattform.

In der Abbildung sehen Sie die C++ - Ebene auf der untersten Ebene. Alle freigegebene code ist in diesem segment. Die höchste Ebene ist die regelmäßige Obj-C /Java Kotlin-code, keine Nachrichten hier, der schwierige Teil ist die mittlere Schicht.

Die mittlere Schicht auf iOS-Seite ist einfach; Sie müssen nur konfigurieren Sie Ihr Projekt zu bauen, mit einer Variante von Obj-c wissen, wie Objective-C++ und es ist alles, Sie haben Zugriff auf C++ - code.

Das Ding wurde immer schwerer auf der Android-Seite, die beide Sprachen, Java-und Kotlin, auf Android, laufen unter einer Virtuelle Java Maschine. Also der einzige Weg, um C++ - code ist mit JNInehmen Sie sich bitte Zeit und Lesen die Grundlagen der JNI. Zum Glück, heute ist Android Studio IDE, hat große Verbesserungen auf JNI-Seite, und eine Menge von Problemen, die angezeigt werden, während Sie Sie Bearbeiten code aus.

Den code, indem Sie die Schritte

Unser Beispiel ist eine einfache app, die Sie senden eine text-zu-CPP, und es konvertiert text etwas anderes und gibt es zurück. Die Idee ist, iOS senden "Obj-C" und Android senden "Java" aus Ihrer jeweiligen Sprachen, und der CPP-code erstellen Sie einen text als follow "cpp sagt Hallo zu << text >>".

Gemeinsamen CPP code

Zunächst, wir schaffen die gemeinsame CPP-code, es zu tun, haben wir eine einfache header-Datei mit der Deklaration der Methode erhält, dass der gewünschte text:

#include <iostream>

const char *concatenateMyStringWithCppString(const char *myString);

Und der CPP-Implementierung:

#include <string.h>
#include "Core.h"

const char *CPP_BASE_STRING = "cpp says hello to %s";

const char *concatenateMyStringWithCppString(const char *myString) {
    char *concatenatedString = new char[strlen(CPP_BASE_STRING) + strlen(myString)];
    sprintf(concatenatedString, CPP_BASE_STRING, myString);
    return concatenatedString;
}

Unix

Einen interessanten bonus ist, können wir auch den gleichen code für Linux und Mac als auch andere Unix-Systeme. Diese Möglichkeit ist besonders nützlich, da können wir testen unsere gemeinsamen code schneller, so werden wir zu erstellen Main.cpp wie folgt zu führen, es aus unserer Maschine und sehen, ob die shared code arbeiten.

#include <iostream>
#include <string>
#include "../CPP/Core.h"

int main() {
  std::string textFromCppCore = concatenateMyStringWithCppString("Unix");
  std::cout << textFromCppCore << '\n';
  return 0;
}

Um den code zu erstellen, müssen Sie ausführen:

$ g++ Main.cpp Core.cpp -o main
$ ./main 
cpp says hello to Unix

iOS

Ist es Zeit zu implementieren, die auf die mobile Seite. So weit wie iOS bietet eine einfache integration wir starten mit ihm. Unsere iOS app ist eine typische Obj-c app-mit nur einem Unterschied; die Dateien sind .mm und nicht .m. d.h. Es ist eine Obj-C++ - app, nicht eine Obj-C app.

Um eine bessere Organisation schaffen wir die CoreWrapper.mm wie folgt:

#import "CoreWrapper.h"

@implementation CoreWrapper

+ (NSString*) concatenateMyStringWithCppString:(NSString*)myString {
    const char *utfString = [myString UTF8String];
    const char *textFromCppCore = concatenateMyStringWithCppString(utfString);
    NSString *objcString = [NSString stringWithUTF8String:textFromCppCore];
    return objcString;
}

@end

Diese Klasse hat die Aufgabe, zu konvertieren CPP-Typen und Anrufe zu Obj-C-Typen und Anrufe. Es ist nicht zwingend, wenn du das kannst, anrufen CPP-code auf jeder Datei, die Sie wollen auf Obj-C, aber es hilft, um die organisation, und außerhalb der wrapper-Dateien Sie erhalten eine komplette Obj-C Stil-code, nur die Wrapper-Datei als CPP-Stil.

Sobald Ihre Hülle ist verbunden mit der CPP-code, können Sie es als standard-Obj-C-code, z.B. ViewController"

#import "ViewController.h"
#import "CoreWrapper.h"

@interface ViewController ()

@property (weak, nonatomic) IBOutlet UILabel *label;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    NSString* textFromCppCore = [CoreWrapper concatenateMyStringWithCppString:@"Obj-C++"];
    [_label setText:textFromCppCore];
}

@end

Schauen, wie die app aussieht:

Android

Nun ist es Zeit für die Android-integration. Android nutzt Gradle als build-system, und C/C++ - code verwendet CMake. Also das erste, was wir tun müssen ist, konfigurieren Sie die CMake auf gradle-Datei:

android {
...
externalNativeBuild {
    cmake {
        path "CMakeLists.txt"
    }
}
...
defaultConfig {
    externalNativeBuild {
        cmake {
            cppFlags "-std=c++14"
        }
    }
...
}

Und der zweite Schritt ist das hinzufügen des CMakeLists.txt Datei:

cmake_minimum_required(VERSION 3.4.1)

include_directories (
    ../../CPP/
)

add_library(
    native-lib
    SHARED
    src/main/cpp/native-lib.cpp
    ../../CPP/Core.h
    ../../CPP/Core.cpp
)

find_library(
    log-lib
    log
)

target_link_libraries(
    native-lib
    ${log-lib}
)

Den CMake-Datei ist, wo Sie hinzufügen müssen, um die CPP-Dateien und header-Ordner, die Sie auf das Projekt, auf unserem Beispiel ergänzen wir die CPP Ordner und die Core.h/.cpp -Dateien. Mehr wissen über C/C++ Konfigurations-bitte Lesen.

Nun den core-code ist Teil unserer app ist es Zeit, um die Brücke, um die Dinge einfacher und organisierten wir eine spezielle Klasse mit dem Namen CoreWrapper werden unsere wrapper zwischen JVM und CPP:

public class CoreWrapper {

    public native String concatenateMyStringWithCppString(String myString);

    static {
        System.loadLibrary("native-lib");
    }

}

Hinweis: diese Klasse hat eine native Methode und ermöglicht das laden einer nativen Bibliothek namens native-lib. Diese Bibliothek ist die, die wir erschaffen, in der das Ende der CPP-code wird zu einem gemeinsamen Objekt .so - Datei einbetten in unserer APK, und die loadLibrary wird es laden. Schließlich, wenn Sie rufen Sie die native Methode, die JVM zu delegieren den Aufruf an die geladene Bibliothek.

Nun die seltsame Teil von Android integration ist die JNI; Wir brauchen eine cpp-Datei, wie folgt, in unserem Fall "native-lib.cpp":

extern "C" {

JNIEXPORT jstring JNICALL Java_ademar_androidioscppexample_CoreWrapper_concatenateMyStringWithCppString(JNIEnv *env, jobject /* this */, jstring myString) {
    const char *utfString = env->GetStringUTFChars(myString, 0);
    const char *textFromCppCore = concatenateMyStringWithCppString(utfString);
    jstring javaString = env->NewStringUTF(textFromCppCore);
    return javaString;
}

}

Das erste, was Ihnen auffallen wird, ist die extern "C" dieser Teil ist notwendig, um JNI funktioniert mit unserer CPP-code und die Methode verbindungen. Sie werden auch sehen, einige Symbole JNI verwendet, um arbeiten mit JVM als JNIEXPORT und JNICALL. Sie verstehen die Bedeutung dieser Dinge, ist es notwendig, ein Zeit-und Lesenfür dieses tutorial Zwecke nur betrachten Sie diese Dinge als boilerplate.

Eine bedeutende Sache und in der Regel die Wurzel für viele Probleme ist der name der Methode; Sie muss dem Muster Folgen "Java_package_class_method". Derzeit, Android studio hat eine hervorragende Unterstützung für die it, so kann es erzeugen, dieses boilerplate automatisch und zeigen dir, wenn es richtig ist, oder nicht benannt. Auf unser Beispiel unsere Methode namens "Java_ademar_androidioscppexample_corewrapper_concatenatemystringwithcppstring" es ist da "ademar.androidioscppexample" ist unser Paket, also ersetzen wir das "." durch "_", CoreWrapper ist die Klasse, wo wir die Verknüpfung der nativen Methode und "concatenateMyStringWithCppString" ist der name der Methode selbst.

Haben wir die Methode richtig erklärt, es ist Zeit, um zu analysieren die Argumente, der erste parameter ist ein Zeiger vom JNIEnv es ist die Art und Weise haben wir Zugang zu JNI Sachen, ist es entscheidend, wir machen unsere Umbauten werden Sie bald sehen. Die zweite ist eine jobject es ist die Instanz des Objekts, das Sie benutzt hatte, um diese Methode aufzurufen. Sie können denken, es als die java "diese", auf unser Beispiel brauchen wir nicht, es zu benutzen, aber wir müssen noch erklären. Nach dieser jobject wir erhalten die Argumente der Methode, denn unsere Methode hat nur ein argument, einen String "myString" wir haben nur ein "jstring" mit dem gleichen Namen. Beachten Sie auch unsere Rückgabe-Typ ist auch ein jstring, es ist, weil unser Java-Methode gibt einen String zurück, für mehr Informationen über Java/JNI-Typen bitte Lesen.

Der Letzte Schritt ist die Konvertierung der JNI-Typen zu den Typen, die wir verwenden, auf CPP Seite. Auf unserem Beispiel verändern wir die jstring zu einem const char * dem senden umgewandelt wird, um die CPP, immer das Ergebnis, und konvertieren Sie zurück zu jstring. Wie alle anderen Schritte, die auf JNI, es ist nicht schwer, es ist nur boilerplated, die ganze Arbeit ist getan durch die JNIEnv* argument, das wir erhalten, wenn wir nennen die GetStringUTFChars und NewStringUTF. Nachdem es unser code ist ready-to-run auf Android-Geräten können sich sehen lassen.

InformationsquelleAutor der Antwort ademar111190