android - Firebase C++ 消息在启动时崩溃

Question

因此，我尝试在我的虚幻项目中使用 Firebase c++ 库，但我遇到了一些非常一致的崩溃:在新卸载后我第一次运行它时它崩溃了，之后工作正常

这是我从 firebase 崩溃日志记录中获得的堆栈跟踪:

E/art ( 7271): No implementation found for void com.google.firebase.messaging.cpp.RegistrationIntentService.nativeOnTokenReceived(java.lang.String) (tried Java_com_google_firebase_messaging_cpp_RegistrationIntentService_nativeOnTokenReceived and Java_com_google_firebase_messaging_cpp_RegistrationIntentService_nativeOnTokenReceived__Ljava_lang_String_2)

E/UncaughtException( 7271):

E/UncaughtException( 7271): java.lang.UnsatisfiedLinkError: No implementation found for void com.google.firebase.messaging.cpp.RegistrationIntentService.nativeOnTokenReceived(java.lang.String) (tried Java_com_google_firebase_messaging_cpp_RegistrationIntentService_nativeOnTokenReceived and Java_com_google_firebase_messaging_cpp_RegistrationIntentService_nativeOnTokenReceived__Ljava_lang_String_2)

E/UncaughtException( 7271): at com.google.firebase.messaging.cpp.RegistrationIntentService.nativeOnTokenReceived(Native Method)

E/UncaughtException( 7271): at com.google.firebase.messaging.cpp.RegistrationIntentService.onHandleIntent(RegistrationIntentService.java:31)

E/UncaughtException( 7271): at android.app.IntentService$ServiceHandler.handleMessage(IntentService.java:65)

E/UncaughtException( 7271): at android.os.Handler.dispatchMessage(Handler.java:102)

E/UncaughtException( 7271): at android.os.Looper.loop(Looper.java:145)

E/UncaughtException( 7271): at android.os.HandlerThread.run(HandlerThread.java:61)

它说没有 nativeOnTokenReceived 的实现，但它是在 firebase c++ sdk 库中实现的。当 RegistrationIntentService 从 FcmInstanceIDListenerService 发送一个 Intent 时会发生崩溃，当 firebase 给出一个新 token 时会发生崩溃，这总是在重新安装或清除它的应用程序数据后在应用程序启动时发生(我不确定是否有可能让它发生在与启动时间不同)。

但是，RegistrationIntentService 已激活 onHandleIntent，并且在应用程序运行期间初始化我的 c++ 监听器类时调用 nativeOnTokenReceived 没有任何问题。有谁知道可能导致这次崩溃的原因是什么？

在使用 ndk-build 之前，Unreal 的构建过程可能会将 sdk 中的静态 .a 库打包到单个 .so 中，这可能是相关的。

下面是从 sdk 的 libmessaging_java.jar 中提取的 RegistrationIntentService 和 FcmInstanceIDListenerService 的代码

FcmInstanceIDListenerService.java
    package com.google.firebase.messaging.cpp;

     import android.content.Intent;
     import com.google.firebase.iid.FirebaseInstanceIdService;

     public class FcmInstanceIDListenerService
       extends FirebaseInstanceIdService
     {
       public void onTokenRefresh()
      {
        Intent intent = new Intent(this, RegistrationIntentService.class);
         startService(intent);
       }
     }

RegistrationIntentService.java
    package com.google.firebase.messaging.cpp;

    import android.app.IntentService;
    import android.content.Intent;
    import com.google.firebase.iid.FirebaseInstanceId;

    public class RegistrationIntentService
       extends IntentService
     {
       private static final String TAG = "FirebaseRegService";

       public RegistrationIntentService()
       {
         super("FirebaseRegService");
       }

       protected void onHandleIntent(Intent intent)
       {
         DebugLogging.log("FirebaseRegService", String.format("onHandleIntent token=%s", new Object[] {
           FirebaseInstanceId.getInstance().getToken() }));
         String token = FirebaseInstanceId.getInstance().getToken();
         if (token != null) {
           nativeOnTokenReceived(token);
         }
       }

       private static native void nativeOnTokenReceived(String paramString);
     }

Answer 1

所以，我想我在这里发布了我对这个问题的解决方案..

首先，我真的不知道为什么会出现问题，但我感觉这与 Unreal 的构建系统有关。(有趣的事实:当我尝试在虚幻引擎中使用 Google 的 Protobuf 库时，我也遇到了无法解释的错误。)

因为 JNI 找不到它需要的库定义函数，所以我编写了自己的函数来替换它。

基本上，当您使用 Firebase Messaging C++ SDK 时，您的项目中需要包含两个组件:C++ 静态库和 header ，以及一个 Java 库 libmessaging_java.jarjar文件定义了几个类，大部分都很好，但有几个需要编辑，反编译就可以了(我用了 this tool )

因此，在 RegistrationIntentService 中我声明了

private static native void nativeOnNewToken(String paramString);

并用它替换了对 nativeOnTokenReceived 的调用

在 ListenerService 中声明

private static native void nativeOnNewMessage(String paramString1, String paramString2, String paramString3, Map<String, String> paramMap);

并将其添加到 writeMessageToInternalStorage()

  private void writeMessageToInternalStorage(String from, String msgId, String error, Map<String, String> data)
   {
   //Added code
    nativeOnNewMessage(from, msgId, error, data);

    //I'm passing the message directly to the C++ code, rather than storing
    //it in a buffer, and processing every once in a while
    //like the sdk normally does; so surround this crap with if(false)

    if(false){
    //end added code
         try
         {
           JSONObject json = messageToJson(from, msgId, error, data);
           DebugLogging.log("FIREBASE_LISTENER", json.toString());
           writeStorageFile(json.toString());
         } catch (JSONException e) {
           e.printStackTrace();
         }
     //added code
        }
    ///end added code
   }

现在，消息和 token 正在发送到我的函数，所以我需要声明它们:

#include "FirebaseMessageListener.h"
#include "stdio.h"

#include <string>
#include <map>

#if PLATFORM_ANDROID
//jni calls from the listener services
    extern "C" void Java_com_google_firebase_messaging_cpp_ListenerService_nativeOnNewMessage(JNIEnv* jenv, jobject thiz, jstring from, jstring mssgID, jstring error, jobject data) {
        UE_LOG(FirebaseLog, Log, TEXT("Entering nativeOnNewMessage *****"));
        printf("Entering nativeOnNewMessage *****");

        std::map<std::string, std::string> data_out;
        std::string messageID;
        std::string fromID;

        //code iterating through map from java, based off code from here:https://android.googlesource.com/platform/frameworks/base.git/+/a3804cf77f0edd93f6247a055cdafb856b117eec/media/jni/android_media_MediaMetadataRetriever.cpp 
        // data is a Map<String, String>.
        if (data) {
            // Get the Map's entry Set.
            jclass mapClass = jenv->FindClass("java/util/Map");
            if (mapClass == NULL) {
                return;
            }
            jmethodID entrySet =
                jenv->GetMethodID(mapClass, "entrySet", "()Ljava/util/Set;");
            if (entrySet == NULL) {
                return;
            }
            jobject set = jenv->CallObjectMethod(data, entrySet);
            if (set == NULL) {
                return;
            }
            // Obtain an iterator over the Set
            jclass setClass = jenv->FindClass("java/util/Set");
            if (setClass == NULL) {
                return;
            }
            jmethodID iterator =
                jenv->GetMethodID(setClass, "iterator", "()Ljava/util/Iterator;");
            if (iterator == NULL) {
                return;
            }
            jobject iter = jenv->CallObjectMethod(set, iterator);
            if (iter == NULL) {
                return;
            }
            // Get the Iterator method IDs
            jclass iteratorClass = jenv->FindClass("java/util/Iterator");
            if (iteratorClass == NULL) {
                return;
            }
            jmethodID hasNext = jenv->GetMethodID(iteratorClass, "hasNext", "()Z");
            if (hasNext == NULL) {
                return;
            }
            jmethodID next =
                jenv->GetMethodID(iteratorClass, "next", "()Ljava/lang/Object;");
            if (next == NULL) {
                return;
            }
            // Get the Entry class method IDs
            jclass entryClass = jenv->FindClass("java/util/Map$Entry");
            if (entryClass == NULL) {
                return;
            }
            jmethodID getKey =
                jenv->GetMethodID(entryClass, "getKey", "()Ljava/lang/Object;");
            if (getKey == NULL) {
                return;
            }
            jmethodID getValue =
                jenv->GetMethodID(entryClass, "getValue", "()Ljava/lang/Object;");
            if (getValue == NULL) {
                return;
            }
            // Iterate over the entry Set
            while (jenv->CallBooleanMethod(iter, hasNext)) {
                jobject entry = jenv->CallObjectMethod(iter, next);
                jstring key = (jstring)jenv->CallObjectMethod(entry, getKey);
                jstring value = (jstring)jenv->CallObjectMethod(entry, getValue);
                const char* keyStr = jenv->GetStringUTFChars(key, NULL);
                if (!keyStr) {  // Out of memory
                    return;
                }
                const char* valueStr = jenv->GetStringUTFChars(value, NULL);
                if (!valueStr) {  // Out of memory
                    jenv->ReleaseStringUTFChars(key, keyStr);
                    return;
                }
                data_out.insert(std::pair<std::string, std::string>(std::string(keyStr), std::string(valueStr)));
                jenv->DeleteLocalRef(entry);
                jenv->ReleaseStringUTFChars(key, keyStr);
                jenv->DeleteLocalRef(key);
                jenv->ReleaseStringUTFChars(value, valueStr);
                jenv->DeleteLocalRef(value);
            }
        }

        if (from != nullptr) {
            const char* valueStr = jenv->GetStringUTFChars(from, NULL);
            if (!valueStr) {  // Out of memory
                return;
            }
            fromID = std::string(valueStr);
            jenv->ReleaseStringUTFChars(from, valueStr);
        }

        if (mssgID != nullptr) {
            const char* valueStr = jenv->GetStringUTFChars(mssgID, NULL);
            if (!valueStr) {  // Out of memory
                return;
            }
            messageID = std::string(valueStr);
            jenv->ReleaseStringUTFChars(mssgID, valueStr);
        }

        FirebaseMessageListener::Get()->onNewMessage(fromID, messageID, data_out);
    }

    extern "C" void Java_com_google_firebase_messaging_cpp_RegistrationIntentService_nativeOnNewToken(JNIEnv* jenv, jobject thiz, jstring inJNIStr) {
        UE_LOG(FirebaseLog, Log, TEXT("Entering nativeOnNewToken *****"));
        printf("Entering nativeOnNewToken *****");
        //first, put the token into a c string
        jboolean isCopy;
        const char* token = jenv->GetStringUTFChars(inJNIStr, &isCopy);
        FirebaseMessageListener::Get()->onNewToken(token);
    }

#endif

这些将消息传递到我创建的单例类。你可以在这里做任何你想做的事，但我将它们传递给 firebase::messaging::Listener reference，以尝试保持与 Firebase SDK 的兼容性(以防我让它正常工作)

class RIFT411_API FirebaseMessageListener
{
private:
    static FirebaseMessageListener* self;

    //private so that new instance can only be made through call to Get()
    FirebaseMessageListener();
#if PLATFORM_ANDROID
    JNIEnv * env = FAndroidApplication::GetJavaEnv();
    jobject activity = FAndroidApplication::GetGameActivityThis();
#endif

    //signals to return the key
    void getToken();

    //send the messages to the firebase sdk implemented listener, so we'll have an easier time if we ever want to move back
    firebase::messaging::Listener *listener = nullptr;

public:
    static FirebaseMessageListener* Get();

    void onNewToken(const char* token);
    void onNewMessage(std::string, std::string, std::map<std::string, std::string> &data);

    void Init(firebase::messaging::Listener *listener);

    ~FirebaseMessageListener();
};

//

FirebaseMessageListener* FirebaseMessageListener::self = nullptr;


FirebaseMessageListener* FirebaseMessageListener::Get()
{
    if (self == nullptr) {
        self = new FirebaseMessageListener();
    }
    return self;
}

void FirebaseMessageListener::getToken() {
#if PLATFORM_ANDROID
    //This has to happen in the main thread, or some of the FindClass() calls will fail

    UE_LOG(FirebaseLog, Log, TEXT("Trying to grab token *****"));
    printf("Trying to grab token *****");

    env = FAndroidApplication::GetJavaEnv();
    activity = FAndroidApplication::GetGameActivityThis();

    jclass cls_intent = (env)->FindClass("android/content/Intent");
    if (NULL == cls_intent) { UE_LOG(FirebaseLog, Error, TEXT("Failure getting cls_intent")); return; }

    jclass cls_service = FAndroidApplication::FindJavaClass("com/google/firebase/messaging/cpp/RegistrationIntentService");
    //jclass cls_service = (env)->FindClass("com/google/firebase/messaging/cpp/RegistrationIntentService");
    if (NULL == cls_service) { UE_LOG(FirebaseLog, Error, TEXT("Failure getting cls_service")); }


    // Get the Method ID of the constructor which takes an int
    jmethodID mid_Init = (env)->GetMethodID(cls_intent, "<init>", "(Landroid/content/Context;Ljava/lang/Class;)V");
    if (NULL == mid_Init) { UE_LOG(FirebaseLog, Error, TEXT("Failure getting mid_Init")); return;}

    // Call back constructor to allocate a new instance, with an int argument
    jobject obj_intent = (env)->NewObject(cls_intent, mid_Init, activity, cls_service);
    if (NULL == obj_intent) { UE_LOG(FirebaseLog, Error, TEXT("Failure getting obj_intent")); return; }

    if (NULL == activity) { UE_LOG(FirebaseLog, Error, TEXT("Failure getting activity")); return; }

    jclass cls_activity = (env)->GetObjectClass(activity);
    if (NULL == cls_activity) { UE_LOG(FirebaseLog, Error, TEXT("Failure getting cls_activity")); return; }

    jmethodID mid_start = (env)->GetMethodID(cls_activity, "startService", "(Landroid/content/Intent;)Landroid/content/ComponentName;");
    if (NULL == mid_start) { UE_LOG(FirebaseLog, Error, TEXT("Failure getting mid_start")); return; }


    UE_LOG(FirebaseLog, Log, TEXT("MADE IT TO THE END!"));
    (env)->CallObjectMethod(activity, mid_start, obj_intent);

#endif
}

void FirebaseMessageListener::onNewToken(const char* token) {
    UE_LOG(FirebaseLog, Log, TEXT("Recieving new token in Unreal! Hooray! ***** %s"), *FString(token));
    printf("Recieving new Message in Unreal! Hooray! *****\n");
    if (listener != nullptr) {
        listener->OnTokenReceived(token);
    }
}

void FirebaseMessageListener::onNewMessage(std::string from, std::string MessageID, std::map<std::string, std::string> &data) {
    UE_LOG(FirebaseLog, Log, TEXT("Recieving new Message in Unreal! Hooray! *****"));
    printf("Recieving new Message in Unreal! Hooray! *****\n");
    if (!data.empty()) {
        UE_LOG(FirebaseLog, Log, TEXT("data:"));
        typedef std::map<std::string, std::string>::const_iterator MapIter;
        for (MapIter it = data.begin(); it != data.end(); ++it) {
            FString s1 = FString(it->first.c_str());
            FString s2 = FString(it->second.c_str());
            UE_LOG(FirebaseLog, Log, TEXT("  %s: %s"), *s1, *s2);
        }
    }

    ::firebase::messaging::Message message;

    message.data = data;
    message.from = from;
    message.message_id = MessageID;


    if (listener != nullptr) {
        listener->OnMessage(message);
    }
}

void FirebaseMessageListener::Init(firebase::messaging::Listener *newlistener) {
    this->listener = newlistener;
    FGraphEventRef Task = FFunctionGraphTask::CreateAndDispatchWhenReady([=]()
    {
        getToken();
    }, TStatId(), NULL, ENamedThreads::GameThread);

}

FirebaseMessageListener::FirebaseMessageListener()
{
    self = this;
}

FirebaseMessageListener::~FirebaseMessageListener()
{
}

与此相关的一件事是，您不会从应用关闭时收到的通知中获取数据。这些数据打包在 Intent 中，我几乎找到了获取它的好方法，我可能会在完成后发布