Figured out out to get the field values of a java/kotlin class object from C/C++

app/src/main/cpp/Demo.cpp

@@ -35,6 +35,9 @@ std::vector<model::Song> retrieveSongs(const model::Token&, const std::string&);
 jobject songToObj(JNIEnv *env, const model::Song&);
 
 model::Song retrieveSong(const std::string&, const std::string&, const int);
+model::Song retrieveSong(const model::Token&, const model::Song&, const std::string&);
+
+model::Token fettchToken(const model::User&, const std::string&);
 
 model::User retrieveCredentials(const std::string&);
 
@@ -50,9 +53,8 @@ std::vector<model::Song> retrieveSongs(const model::Token& token, const std::str
 {
     std::vector<model::Song> songs;
     repository::SongRepository songRepo;
-    songs = songRepo.fetchSongs(token, baseUri);
 
-    return songs;
+    return songRepo.fetchSongs(token, baseUri);
 }
 
 
@@ -96,10 +98,24 @@ model::Song retrieveSong(const std::string& token, const std::string& baseUri, c
     model::Song song(songId, "Smooth", "Amaze", "The Herb", "Blazing",
             420, 420);
 
-    song = songRepo.retrieveSong(token, baseUri, song);
-    auto songs = songRepo.fetchSongs(model::Token(token), baseUri);
+    return songRepo.retrieveSong(token, song, baseUri);
+}
 
-    return song;
+model::Song retrieveSong(const model::Token& token, const model::Song& song,
+        const std::string& baseUri)
+{
+    repository::SongRepository songRepo;
+
+    return songRepo.retrieveSong(token, song, baseUri);
+}
+
+
+model::Token fetchToken(const model::User& user, const std::string& apiUri)
+{
+    manager::Tok tokMgr;
+    auto token = tokMgr.fetchTokenTrans(user, apiUri);
+
+    return token;
 }
 
 
@@ -112,6 +128,7 @@ model::User retrieveCredentials(const std::string& dataPath)
 }
 
 
+[[deprecated("use fetchToken(const model::User, std::string&")]]
 std::string fetchToken(const std::string& username, const std::string& password,
     const std::string& apiUri)
 {
@@ -141,6 +158,7 @@ bool userCredentialExist(const std::string& dataPath)
 }
 
 
+[[deprecated("c++ 17 issues")]]
 void iterateDirectory(const std::string& path)
 {
     /**
@@ -178,21 +196,24 @@ void saveCredentials(const model::User& user, const std::string& appDirectory)
 extern "C"
 JNIEXPORT jobjectArray
 JNICALL
-Java_com_example_mear_activities_IcarusSongActivity_retrieveSongs(
+Java_com_example_mear_repositories_TrackRepository_retrieveSongs(
         JNIEnv *env,
-        jobject  thisOnj,
+        jobject thisOnj,
         jobject token,
         jstring baseUri
         ) {
-    jclass songClass = env->FindClass( "com/example/mear/models/Song");
     jclass tokenClass = env->FindClass("com/example/mear/models/Token");
-    jobjectArray songs = env->NewObjectArray(2, songClass, nullptr);
-    auto tok = env->CallObjectMethod(token, env->GetMethodID(tokenClass, "setAccessToken", "(Ljava/lang/String;)V"));
-    std::string tokStr = env->GetStringUTFChars((jstring)tok, nullptr);
+    jclass songClass = env->FindClass( "com/example/mear/models/Song");
+
+    auto tokField = env->GetFieldID(tokenClass, "accessToken", "Ljava/lang/String;");
+    auto tokObj = env->GetObjectField(token, tokField);
+    std::string tokStr = env->GetStringUTFChars((jstring)tokObj, nullptr);
     model::Token tk(tokStr);
+
     const std::string uri = env->GetStringUTFChars(baseUri, nullptr);
 
     auto allSongs = retrieveSongs(tk, uri);
+    jobjectArray songs = env->NewObjectArray(allSongs.size(), songClass, nullptr);
     for (auto i = 0; i != allSongs.size(); ++i) {
         auto song = songToObj(env, allSongs[i]);
         env->SetObjectArrayElement(songs, i, song);
@@ -213,8 +234,8 @@ Java_com_example_mear_activities_LoginActivity_retrieveSong(
         jint idOfSong
 )
 {
-    const std::string tok = env->GetStringUTFChars(token, NULL);
-    const std::string baseUri = env->GetStringUTFChars(apiUri, NULL);
+    const std::string tok = env->GetStringUTFChars(token, nullptr);
+    const std::string baseUri = env->GetStringUTFChars(apiUri, nullptr);
     auto song = retrieveSong(tok, baseUri, idOfSong);
 
     jclass songClass = env->FindClass( "com/example/mear/models/Song");
@@ -248,6 +269,35 @@ Java_com_example_mear_activities_LoginActivity_retrieveSong(
     return songObj;
 }
 
+extern "C"
+JNIEXPORT jobject
+JNICALL
+Java_com_example_mear_repositories_TrackRepository_retrieveSong(
+        JNIEnv *env,
+        jobject thisObj,
+        jobject tokenObj,
+        jobject songObj,
+        jstring uriStr
+        ) {
+    auto tokenClass = env->GetObjectClass(tokenObj);
+    auto songClass = env->GetObjectClass(songObj);
+
+    auto accessTokenField = env->GetFieldID(tokenClass, "accessToken", "Ljava/lang/String;");
+    auto idField = env->GetFieldID(songClass, "id", "I");
+
+    auto accessTokenStr = (jstring)env->GetObjectField(tokenObj, accessTokenField);
+    auto idInt = env->GetIntField(songObj, idField);
+
+    auto uri = env->GetStringUTFChars(uriStr, nullptr);
+    model::Token token(env->GetStringUTFChars(accessTokenStr, nullptr));
+    model::Song song(idInt);
+
+    song = retrieveSong(token, song, uri);
+    auto fetchedSongObj = songToObj(env, song);
+
+    return fetchedSongObj;
+}
+
 extern "C"
 JNIEXPORT jobject
 JNICALL
@@ -284,20 +334,17 @@ Java_com_example_mear_repositories_UserRepository_logUser(
         jobject user,
         jstring apiUri ) {
     jclass userClass = env->GetObjectClass(user);
-    //auto tok = env->CallObjectMethod(token, env->GetMethodID(tokenClass, "setAccessToken", "(Ljava/lang/String;)V"));
-    auto passwordField = env->GetFieldID(userClass, "getPassword", "(Ljava/lang/String;)V");
-    //auto passwordM = env->CallObjectMethod(user, env->GetMethodID(userClass, "password", "(Ljava/lang/String;)V"));
-    //auto passwordMOne = env->CallObjectMethod(user, env->GetMethodID(userClass, "getPassword", "(Ljava/lang/String;)V"));
-    auto password = env->GetObjectField(user, passwordField);
-    //auto username = env->CallObjectMethod(user, env->GetMethodID(userClass, "setUsername", "(Ljava/lang/String;)V"));
-    auto usernameField = env->GetFieldID(userClass, "setUsername", "(Ljava/lang/String;)V");
-    auto username = env->GetObjectField(user, usernameField);
+    auto passwordField = env->GetFieldID(userClass, "password", "Ljava/lang/String;");
+    auto usernameField = env->GetFieldID(userClass, "username", "Ljava/lang/String;");
+
+    auto password = (jstring)env->GetObjectField(user, passwordField);
+    auto username = (jstring)env->GetObjectField(user, usernameField);
 
-    const std::string usr = env->GetStringUTFChars((jstring)username, nullptr);
-    const std::string pass = env->GetStringUTFChars((jstring)password, nullptr);
     const std::string api = env->GetStringUTFChars(apiUri, nullptr);
+    model::User us(env->GetStringUTFChars(username, nullptr),
+            env->GetStringUTFChars(password, nullptr));
 
-    model::Token token(fetchToken(usr, pass, api));
+    auto token = fetchToken(us, api);
 
     jclass tokenClass = env->FindClass( "com/example/mear/models/Token");
     jmethodID jconstructor = env->GetMethodID( tokenClass,  "<init>", "()V" );
@@ -322,10 +369,11 @@ Java_com_example_mear_activities_LoginActivity_logUser(
         jstring username,
         jstring password,
         jstring apiUri ) {
-
-    const std::string usr = env->GetStringUTFChars(username, NULL);
-    const std::string pass = env->GetStringUTFChars(password, NULL);
-    const std::string api = env->GetStringUTFChars(apiUri, NULL);
+    model::User user(env->GetStringUTFChars(username, nullptr),
+            env->GetStringUTFChars(password, nullptr));
+    const std::string usr = env->GetStringUTFChars(username, nullptr);
+    const std::string pass = env->GetStringUTFChars(password, nullptr);
+    const std::string api = env->GetStringUTFChars(apiUri, nullptr);
 
     auto token = fetchToken(usr, pass, api);
 
@@ -341,10 +389,9 @@ Java_com_example_mear_repositories_UserRepository_isUserTableEmpty(
         jobject thisObj,
         jstring dataPath
         ) {
-    const std::string dataPathStr = env->GetStringUTFChars(dataPath, NULL);
-    jboolean result = userCredentialExist(dataPathStr);
+    const std::string dataPathStr = env->GetStringUTFChars(dataPath, nullptr);
 
-    return result;
+    return userCredentialExist(dataPathStr);
 }
 
 extern "C"
@@ -355,7 +402,7 @@ Java_com_example_mear_repositories_BaseRepository_doesDatabaseExist(
         jobject thidObj,
         jstring dataPath
         ) {
-    const std::string dataPathStr = env->GetStringUTFChars(dataPath, NULL);
+    const std::string dataPathStr = env->GetStringUTFChars(dataPath, nullptr);
     jboolean result = doesDatabaseExist(dataPathStr);
 
     return result;
@@ -365,32 +412,24 @@ Java_com_example_mear_repositories_BaseRepository_doesDatabaseExist(
 extern "C"
 JNIEXPORT void
 JNICALL
-Java_com_example_mear_activities_LoginActivity_pathIteratorDemo(
+Java_com_example_mear_repositories_UserRepository_saveUserCredentials(
         JNIEnv *env,
         jobject thisObj,
-        jstring path
-        ) {
-
-    const std::string pathStr = env->GetStringUTFChars(path, NULL);
-    iterateDirectory(pathStr);
-}
-
-
-extern "C"
-JNIEXPORT void
-JNICALL
-Java_com_example_mear_activities_LoginActivity_saveUserCredentials(
-        JNIEnv *env,
-        jobject thisObj,
-        jstring username,
-        jstring password,
+        jobject user,
         jstring appDirectory
 ) {
-    const std::string usernameStr = env->GetStringUTFChars(username, NULL);
-    const std::string passwordStr = env->GetStringUTFChars(password, NULL);
-    const std::string appDirectoryStr = env->GetStringUTFChars(appDirectory, NULL);
+    jclass userClass = env->GetObjectClass(user);
+    auto usernameId = env->GetFieldID(userClass, "username", "Ljava/lang/String;");
+    auto passwordId = env->GetFieldID(userClass, "password", "Ljava/lang/String;");
 
-    model::User user(usernameStr, passwordStr);
+    auto usernameStr = (jstring) env->GetObjectField(user, usernameId);
+    auto passwordStr = (jstring) env->GetObjectField(user, passwordId);
 
-    saveCredentials(user, appDirectoryStr);
+    const std::string username = env->GetStringUTFChars(usernameStr, nullptr);
+    const std::string password = env->GetStringUTFChars(passwordStr, nullptr);
+    const std::string appDirectoryStr = env->GetStringUTFChars(appDirectory, nullptr);
+
+    model::User usr(username, password);
+
+    saveCredentials(usr, appDirectoryStr);
 }

app/src/main/cpp/SongRepository.cpp

@@ -59,6 +59,7 @@ namespace repository {
     }
 
 
+    [[deprecated]]
     model::Song SongRepository::retrieveSong(const std::string& token, const int id) {
         std::string uri("");
         uri.append(std::to_string(id));
@@ -104,6 +105,7 @@ namespace repository {
         return song;
     }
 
+    [[deprecated]]
     model::Song SongRepository::retrieveSong(const std::string& token, const std::string& baseUri,
             const int id) {
         std::string uri(baseUri);
@@ -151,6 +153,7 @@ namespace repository {
         return song;
     }
 
+    [[deprecated]]
     model::Song SongRepository::retrieveSong(const std::string& token, const std::string& baseUri,
                                              const model::Song& sng) {
         std::string uri(baseUri);
@@ -198,6 +201,53 @@ namespace repository {
         return sng;
     }
 
+    model::Song SongRepository::retrieveSong(const model::Token& token, const model::Song& sng,
+            const std::string& baseUri) {
+        std::string uri(baseUri);
+        uri.append("/api/v1/song/");
+        uri.append(std::to_string(sng.id));
+        model::Song song;
+
+        CURL *curl;
+        CURLcode res;
+        struct curl_slist *chunk = NULL;
+        curl = curl_easy_init();
+
+        if (!curl) {
+            return sng;
+        }
+
+        auto resp = std::make_unique<char[]>(10000);
+
+        std::string authInfo("Authorization: Bearer ");
+        authInfo.append(token.accessToken);
+        chunk = curl_slist_append(chunk, authInfo.c_str());
+
+        curl_easy_setopt(curl, CURLOPT_URL, uri.c_str());
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, respBodyRetriever);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, resp.get());
+        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+
+        res = curl_easy_perform(curl);
+        curl_easy_cleanup(curl);
+
+        if (res == CURLE_OK) {
+            auto s = nlohmann::json::parse(resp.get());
+            song.id = s["id"].get<int>();
+            song.title = s["title"].get<std::string>();
+            song.album = s["album"].get<std::string>();
+            song.artist = s["artist"].get<std::string>();
+            song.genre = s["genre"].get<std::string>();
+            song.duration = s["duration"].get<int>();
+            song.year = s["year"].get<int>();
+
+            return song;
+        }
+
+        return sng;
+    }
+
 
     size_t SongRepository::respBodyRetriever(void* ptr, size_t size, size_t nmemb, char *e)
     {

app/src/main/cpp/SongRepository.h

@@ -20,6 +20,7 @@ namespace repository {
         model::Song retrieveSong(const std::string&, const int);
         model::Song retrieveSong(const std::string&, const std::string&, const int);
         model::Song retrieveSong(const std::string&, const std::string&, const model::Song&);
+        model::Song retrieveSong(const model::Token&, const model::Song&, const std::string&);
     private:
         static size_t respBodyRetriever(void*, size_t, size_t, char*);
     };

app/src/main/cpp/Tok.cpp

@@ -11,6 +11,40 @@
 #include <nlohmann/json.hpp>
 
 namespace manager {
+    model::Token Tok::fetchTokenTrans(const model::User &user, const std::string& uri) {
+        CURL *curl;
+        CURLcode res;
+
+        curl = curl_easy_init();
+
+        if (!curl) {
+            return model::Token("none");
+        }
+
+        auto resp = std::make_unique<char[]>(10000);
+
+        const auto loginUri = fetchLoginUri(uri);
+        const auto obj = userJsonString(user);
+
+        curl_easy_setopt(curl, CURLOPT_URL, loginUri.c_str());
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, obj.c_str());
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, respBodyRetriever);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, resp.get());
+        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+
+        res = curl_easy_perform(curl);
+        curl_easy_cleanup(curl);
+
+        if (res == CURLE_OK) {
+            auto s = nlohmann::json::parse(resp.get());
+
+            return model::Token(s["token"].get<std::string>());
+        }
+
+        return model::Token("failure");
+    }
+
+
     std::string Tok::fetchToken(const model::User &user, const std::string& uri) {
         CURL *curl;
         CURLcode res;

app/src/main/cpp/Tok.h

@@ -8,12 +8,15 @@
 #include <memory>
 #include <string>
 
+#include "model/Token.h"
 #include "model/User.h"
 
 namespace manager {
 
     class Tok {
     public:
+        model::Token fetchTokenTrans(const model::User&, const std::string&);
+
         std::string fetchToken(const model::User&, const std::string&);
     private:
         std::string fetchLoginUri(const std::string&);

app/src/main/cpp/model/Song.h

@@ -14,6 +14,7 @@ class Song
 {
 public:
     Song() = default;
+    Song(const int id) : id(id) { }
     Song(const int id, const std::string& title, const std::string& artist,
             const std::string& album, const std::string& genre,
             const int duration, const int year) :

app/src/main/cpp/model/Token.h

@@ -12,6 +12,7 @@ namespace model {
     class Token
     {
     public:
+        Token() = default;
         Token(const std::string& accessToken) : accessToken(accessToken) { }
         Token(const std::string&& accessToken) :
             accessToken(std::move(accessToken)) { }