Analytics windows dll update

.gitignore

@@ -17,6 +17,7 @@ __pycache__/
 
 ### IDE generated files
 .vscode/
+**/.vs/
 
 # Unencrypted secret files
 google-services.json

analytics/generate_windows_stubs.py

@@ -262,7 +262,7 @@ def generate_function_pointers(dll_file_path, header_file_path, output_h_path, o
     )
     parser.add_argument(
         "--windows_dll",
-        default = os.path.join(os.path.dirname(sys.argv[0]), "windows/analytics_win.dll"),
+        default = os.path.join(os.path.dirname(sys.argv[0]), "windows/google_analytics.dll"),
         help="Path to the DLL file to calculate a hash."
     )
     parser.add_argument(

analytics/integration_test/CMakeLists.txt

@@ -211,7 +211,7 @@ else()
     )
   elseif(MSVC)
     set(ADDITIONAL_LIBS advapi32 ws2_32 crypt32)
-    set(ANALYTICS_WINDOWS_DLL "${FIREBASE_CPP_SDK_DIR}/analytics/windows/analytics_win.dll")
+    set(ANALYTICS_WINDOWS_DLL "${FIREBASE_CPP_SDK_DIR}/analytics/windows/google_analytics.dll")
 
     # For Windows, check if the Analytics DLL exists, and copy it in if so.
     if (EXISTS "${ANALYTICS_WINDOWS_DLL}")

analytics/integration_test/src/integration_test.cc

@@ -242,6 +242,29 @@ TEST_F(FirebaseAnalyticsTest, TestSetProperties) {
       InitiateOnDeviceConversionMeasurementWithHashedPhoneNumber(hashed_phone);
 }
 
+#if defined(_WIN32)
+TEST_F(FirebaseAnalyticsTest, TestSetLogCallback) {
+  std::promise<void> finishedPromise;
+  std::future<void> finished Future = readyPromise.get_future();
+  bool log_callback_called = false;
+  firebase::analytics::SetLogCallback(
+      [&](firebase::LogLevel log_level, const char* message) {
+        log_callback_called = true;
+        finishedPromise.set_value();
+      });
+  // Log an event with an invalid parameter to trigger a log message.
+  const firebase::analytics::Parameter kInvalidParameters[] = {
+      firebase::analytics::Parameter("invalid_character_!", 5),
+  };
+  firebase::analytics::LogEvent(
+      "invalid_event", kInvalidParameters,
+      sizeof(kInvalidParameters) / sizeof(kInvalidParameters[0]));
+  readyPromise.set_value();
+  EXPECT_TRUE(log_callback_called);
+  firebase::analytics::SetLogCallback(nullptr);
+}
+#endif  // defined(_WIN32)
+
 TEST_F(FirebaseAnalyticsTest, TestLogEvents) {
   // Log an event with no parameters.
   firebase::analytics::LogEvent(firebase::analytics::kEventLogin);
@@ -259,6 +282,14 @@ TEST_F(FirebaseAnalyticsTest, TestLogEvents) {
                                 "spoon_welders");
 }
 
+TEST_F(FirebaseAnalyticsTest, TestNotifyAppLifecycleChange) {
+  // Can't confirm that these do anything but just run them all to ensure the
+  // app doesn't crash.
+  firebase::analytics::NotifyAppLifecycleChange(firebase::analytics::kUnknown);
+  firebase::analytics::NotifyAppLifecycleChange(
+      firebase::analytics::kTermination);
+}
+
 TEST_F(FirebaseAnalyticsTest, TestLogEventWithMultipleParameters) {
   const firebase::analytics::Parameter kLevelUpParameters[] = {
       firebase::analytics::Parameter(firebase::analytics::kParameterLevel, 5),

analytics/src/analytics_android.cc

@@ -666,6 +666,12 @@ void ResetAnalyticsData() {
   util::CheckAndClearJniExceptions(env);
 }
 
+// NO-OP in Android and iOS. Only used in Windows.
+void SetLogCallback(const LogCallback&) {}
+
+// NO-OP in Android and iOS. Only used in Windows.
+void NotifyAppLifecycleChange(AppLifecycleState) {}
+
 Future<std::string> GetAnalyticsInstanceId() {
   FIREBASE_ASSERT_RETURN(GetAnalyticsInstanceIdLastResult(),
                          internal::IsInitialized());

analytics/src/analytics_desktop.cc

@@ -12,7 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <future>
 #include <map>
+#include <mutex>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -25,6 +27,7 @@
 #include "app/src/include/firebase/future.h"
 #include "app/src/include/firebase/variant.h"
 #include "app/src/log.h"
+#include "firebase/log.h"
 
 #if defined(_WIN32)
 #include <windows.h>
@@ -36,14 +39,16 @@ namespace firebase {
 namespace analytics {
 
 #if defined(_WIN32)
-#define ANALYTICS_DLL_FILENAME L"analytics_win.dll"
+#define ANALYTICS_DLL_FILENAME L"google_analytics.dll"
 
 static HMODULE g_analytics_module = 0;
 #endif  // defined(_WIN32)
 
 // Future data for analytics.
 // This is initialized in `Initialize()` and cleaned up in `Terminate()`.
 static bool g_initialized = false;
+static LogCallback g_log_callback;
+static std::mutex g_log_callback_mutex;
 static int g_fake_instance_id = 0;
 static bool g_analytics_collection_enabled = true;
 static std::string g_app_id;
@@ -134,6 +139,10 @@ bool IsInitialized() { return g_initialized; }
 void Terminate() {
 #if defined(_WIN32)
   if (g_analytics_module) {
+    // Make sure to notify the SDK that the analytics is being terminated to
+    // upload any pending data.
+    NotifyAppLifecycleChange(AppLifecycleState::kTermination);
+
     FirebaseAnalytics_UnloadDynamicFunctions();
     FreeLibrary(g_analytics_module);
     g_analytics_module = 0;
@@ -386,6 +395,49 @@ void ResetAnalyticsData() {
   g_fake_instance_id++;
 }
 
+LogLevel ConvertAnalyticsLogLevelToFirebaseLogLevel(
+    GoogleAnalytics_LogLevel log_level) {
+  switch (log_level) {
+    case kDebug:
+      return kLogLevelDebug;
+    case kInfo:
+      return kLogLevelInfo;
+    case kWarning:
+      return kLogLevelWarning;
+    case kError:
+      return kLogLevelError;
+    default:
+      return kLogLevelInfo;
+  }
+}
+
+// C-style callback that will be passed to the Google Analytics C API.
+static void GoogleAnalyticsWraperLogCallback(GoogleAnalytics_LogLevel log_level,
+                                             const char* message) {
+  if (g_log_callback) {
+    LogLevel firebase_log_level =
+        ConvertAnalyticsLogLevelToFirebaseLogLevel(log_level);
+    g_log_callback(firebase_log_level, message);
+  }
+}
+
+// Allows the passing of a callback to be used when the SDK logs any
+// messages regarding its behavior. The callback must be thread-safe.
+void SetLogCallback(const LogCallback& callback) {
+  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
+  // The C API does not support user data, so we must use a global variable.
+  std::lock_guard<std::mutex> lock(g_log_callback_mutex);
+  g_log_callback = callback;
+  GoogleAnalytics_SetLogCallback(GoogleAnalyticsWraperLogCallback);
+}
+
+// Notify the Analytics SDK about the current state of the app's lifecycle.
+void NotifyAppLifecycleChange(AppLifecycleState state) {
+  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
+  GoogleAnalytics_NotifyAppLifecycleChange(
+      static_cast<GoogleAnalytics_AppLifecycleState>(state));
+}
+
 // Overloaded versions of LogEvent for convenience.
 
 void LogEvent(const char* name) {