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 发送一个意图时会发生崩溃，当 firebase 给出一个新令牌时会发生崩溃，这总是在重新安装或清除它的应用程序数据后在应用程序启动时发生（我不确定是否有可能让它发生在与启动时间不同）。

但是，RegistrationIntentService 激活了 onHandleIntent，并且在我的 c++ 侦听器 class 初始化时调用 nativeOnTokenReceived 没有任何问题，在应用程序的过程中。有人知道是什么导致了这次崩溃吗？

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

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

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

com.google.firebase.messaging.cpp 只监听 FCM 服务发送的消息并将它们转发到 Android C++ 库 (libmessaging.a)。看起来问题是由于 firebase-messaging aar 未包含在您的应用程序中导致 com.google.firebase.messaging.cpp 包未加载，因为它依赖于 firebase-messaging aar 中的类不存在。

例如，当使用 gradle 构建时，可以使用以下 https://github.com/firebase/quickstart-cpp/blob/master/messaging/testapp/build.gradle#L93

包含 aar

现在，如 https://groups.google.com/d/msg/firebase-talk/eGNr36dpB70/VXVqBfL1BAAJ 中所述，在 Unreal 项目中包含 aars 有点棘手。基本上你需要解压缩（aars 只是 zip 文件）firebase-messaging aar（在 ${ANDROID_HOME}/extras/google/firebase/firebase-messaging 下查看）及其依赖项（你需要阅读每个 *.pom文件以获取依赖项）并包含各种 .jars、AndroidManifest.xml 文件和从虚幻项目中的每个 aar 中提取的资源。确保每个 AndroidManifest.xml 都合并到最终应用程序的 AndroidManifest.xml 中非常重要，这样 Firebase 使用的所有服务和内容提供程序都包含在内。

Answer 2

所以，我想我 post 在这里解决这个问题..

首先，我真的不知道为什么会出现问题，但我感觉这与 Unreal 的构建系统有关。（有趣的事实：当我试图在 Unreal Engine 中使用它们时，我在 Google 的 Protobuf 库中也遇到了无法解释的错误。）

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

基本上，当您使用 Firebase Messaging C++ SDK 时，您的项目中需要包含两个组件：c++ 静态库和 headers，以及 java 库 libmessaging_java.jar jar文件定义了几个class，大部分都很好，但有几个需要编辑，反编译就可以了（我用的是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
   }

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

#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

这些将消息传递给我创建的单例 class。你可以在这里做任何你想做的事，但我将它们传递给 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 中，我几乎找到了一个获取它的好方法，一旦我完成它，我可能 post

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

Firebase C++ Messaging Crashing on Startup

c++

android

firebase

unreal-engine4

firebase-cloud-messaging