Merge pull request #378 from Countly/staging

24.7.2

CHANGELOG.md

@@ -1,3 +1,6 @@
+## 24.7.2
+* Mitigated an issue in the upload plugin that prevented the upload of a symbol file
+
 ## 24.7.1
 * ! Minor breaking change ! Unsupported types for user properties will now be omitted, they won't be converted to strings.
 

gradle.properties

@@ -22,7 +22,7 @@ org.gradle.configureondemand=true
 android.useAndroidX=true
 android.enableJetifier=true
 # RELEASE FIELD SECTION
-VERSION_NAME=24.7.1
+VERSION_NAME=24.7.2
 GROUP=ly.count.android
 POM_URL=https://github.com/Countly/countly-sdk-android
 POM_SCM_URL=https://github.com/Countly/countly-sdk-android

sdk/src/androidTest/java/ly/count/android/sdk/CountlyTimerTests.java

@@ -0,0 +1,104 @@
+package ly.count.android.sdk;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import java.util.concurrent.ExecutorService;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+
+@RunWith(AndroidJUnit4.class)
+public class CountlyTimerTests {
+
+ private CountlyTimer countlyTimer;
+ private ModuleLog mockLog;
+
+ @Before
+ public void setUp() {
+ countlyTimer = new CountlyTimer();
+ mockLog = Mockito.mock(ModuleLog.class);
+ CountlyTimer.TIMER_DELAY_MS = 0;
+ }
+
+ @After
+ public void tearDown() {
+ countlyTimer.stopTimer(mockLog);
+ Assert.assertNull(countlyTimer.timerService);
+ }
+
+ @Test
+ public void validateInitialValues() {
+ Assert.assertNull(countlyTimer.timerService);
+ Assert.assertEquals(0, CountlyTimer.TIMER_DELAY_MS);
+ }
+
+ @Test
+ public void startTimer_validDelay() {
+ Runnable mockRunnable = Mockito.mock(Runnable.class);
+
+ countlyTimer.startTimer(1, mockRunnable, mockLog);
+ Mockito.verify(mockLog).i("[CountlyTimer] startTimer, Starting timer timerDelay: [1000 ms]");
+ }
+
+ @Test
+ public void startTimer_invalidDelay() {
+ Runnable mockRunnable = Mockito.mock(Runnable.class);
+
+ countlyTimer.startTimer(-1, mockRunnable, mockLog);
+ Mockito.verify(mockLog).i("[CountlyTimer] startTimer, Starting timer timerDelay: [1000 ms]");
+ }
+
+ @Test
+ public void startTimer() {
+ Runnable mockRunnable = Mockito.mock(Runnable.class);
+
+ countlyTimer.startTimer(99, mockRunnable, mockLog);
+ Mockito.verify(mockLog).i("[CountlyTimer] startTimer, Starting timer timerDelay: [99000 ms]");
+ }
+
+ @Test
+ public void startTimer_withTimerDelayMS() {
+ CountlyTimer.TIMER_DELAY_MS = 500;
+ Runnable mockRunnable = Mockito.mock(Runnable.class);
+
+ countlyTimer.startTimer(1, mockRunnable, mockLog);
+ Mockito.verify(mockLog).i("[CountlyTimer] startTimer, Starting timer timerDelay: [500 ms]");
+ }
+
+ /**
+ * Test that the timer is stopped when a new timer is started
+ * This is to prevent multiple timers from running at the same time
+ * And it is not reusing the previous timer
+ */
+ @Test
+ public void startTimer_reuseTimer() {
+ countlyTimer.stopTimer(mockLog);
+
+ Assert.assertNull(countlyTimer.timerService);
+
+ Runnable mockRunnable = Mockito.mock(Runnable.class);
+ countlyTimer.startTimer(1, mockRunnable, mockLog);
+
+ Assert.assertNotNull(countlyTimer.timerService);
+ ExecutorService timerService = countlyTimer.timerService;
+
+ countlyTimer.startTimer(2, mockRunnable, mockLog);
+ Assert.assertNotEquals(timerService, countlyTimer.timerService);
+ }
+
+ @Test
+ public void stopTimer() {
+ countlyTimer.startTimer(1, Mockito.mock(Runnable.class), mockLog);
+ countlyTimer.stopTimer(mockLog);
+ Mockito.verify(mockLog).i("[CountlyTimer] stopTimer, Stopping timer");
+ }
+
+ @Test
+ public void stopTimer_nullTimer() {
+ countlyTimer.stopTimer(mockLog);
+ Mockito.verify(mockLog, Mockito.never()).i("[CountlyTimer] stopTimer, Stopping timer");
+ Mockito.verify(mockLog).d("[CountlyTimer] stopTimer, Timer already stopped");
+ }
+}

sdk/src/androidTest/java/ly/count/android/sdk/TestUtils.java

@@ -42,7 +42,7 @@ public class TestUtils {
  public final static String commonAppKey = "appkey";
  public final static String commonDeviceId = "1234";
  public final static String SDK_NAME = "java-native-android";
- public final static String SDK_VERSION = "24.7.1";
+ public final static String SDK_VERSION = "24.7.2";
  public static final int MAX_THREAD_COUNT_PER_STACK_TRACE = 50;
 
  public static class Activity2 extends Activity {

sdk/src/main/java/ly/count/android/sdk/Countly.java

@@ -47,7 +47,7 @@ of this software and associated documentation files (the "Software"), to deal
  */
 public class Countly {
 
- private final String DEFAULT_COUNTLY_SDK_VERSION_STRING = "24.7.1";
+ private final String DEFAULT_COUNTLY_SDK_VERSION_STRING = "24.7.2";
 
  /**
  * Used as request meta data on every request

sdk/src/main/java/ly/count/android/sdk/CountlyTimer.java

@@ -0,0 +1,54 @@
+package ly.count.android.sdk;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+class CountlyTimer {
+
+ ScheduledExecutorService timerService;
+ protected static int TIMER_DELAY_MS = 0; // for testing purposes
+
+ protected void stopTimer(@NonNull ModuleLog L) {
+ if (timerService != null) {
+ L.i("[CountlyTimer] stopTimer, Stopping timer");
+ try {
+ timerService.shutdown();
+ if (!timerService.awaitTermination(1, TimeUnit.SECONDS)) {
+ timerService.shutdownNow();
+ if (!timerService.awaitTermination(1, TimeUnit.SECONDS)) {
+ L.e("[CountlyTimer] stopTimer, Global timer must be locked");
+ }
+ }
+ } catch (Exception e) {
+ L.e("[CountlyTimer] stopTimer, Error while stopping global timer " + e);
+ }
+ timerService = null;
+ } else {
+ L.d("[CountlyTimer] stopTimer, Timer already stopped");
+ }
+ }
+
+ protected void startTimer(long timerDelay, @NonNull Runnable runnable, @NonNull ModuleLog L) {
+ long timerDelayInternal = timerDelay * 1000;
+
+ if (timerDelayInternal < UtilsTime.ONE_SECOND_IN_MS) {
+ timerDelayInternal = UtilsTime.ONE_SECOND_IN_MS;
+ }
+
+ if (TIMER_DELAY_MS > 0) {
+ timerDelayInternal = TIMER_DELAY_MS;
+ }
+
+ L.i("[CountlyTimer] startTimer, Starting timer timerDelay: [" + timerDelayInternal + " ms]");
+
+ if (timerService != null) {
+ L.d("[CountlyTimer] startTimer, timer was running, stopping it");
+ stopTimer(L);
+ }
+
+ timerService = Executors.newSingleThreadScheduledExecutor();
+ timerService.scheduleWithFixedDelay(runnable, 0, timerDelayInternal, TimeUnit.MILLISECONDS);
+ }
+}

sdk/src/main/java/ly/count/android/sdk/UtilsTime.java

@@ -6,6 +6,7 @@
 import java.util.List;
 
 public class UtilsTime {
+ protected static int ONE_SECOND_IN_MS = 1000;
 
  public static class Instant {
  public final long timestampMs;

upload-plugin/src/main/groovy/ly/count/android/plugins/uploadSymbols.groovy

@@ -36,7 +36,10 @@ class UploadSymbolsPlugin implements Plugin<Project> {
  throw new StopExecutionException("Please specify your server in countly block.")
  }
  String buildVersion = project.android.defaultConfig.versionName
- String url = "${ext.server}/i/crash_symbols/upload_symbol"
+ String url = ext.server;
+ String path = "i/crash_symbols/upload_symbol";
+ // Ensure there is exactly one "/" between the base URL and the path
+ url = url.endsWith("/") ? url + path : url + "/" + path;
  def filePath = "$project.buildDir/$ext.mappingFile"
  logger.debug("uploadJavaSymbols, Version name:[ {} ], Upload symbol url:[ {} ], Mapping file path:[ {} ]", buildVersion, url, filePath)
  File file = new File(filePath)
@@ -55,17 +58,27 @@ class UploadSymbolsPlugin implements Plugin<Project> {
  .build()
  request = new Request.Builder().url(url).post(formBody).build()
  }
- logger.debug("uploadJavaSymbols, Generated request: {}", request.body().toString())
  doLast {
  if (request == null) {
  logger.error("Request not constructed")
  throw new StopActionException("Something happened while constructing the request. Please try again.")
  }
+
+ if (request.body() != null) {
+ logger.debug("uploadJavaSymbols, Generated request: {}", request.body().toString())
+ } else {
+ logger.error("uploadJavaSymbols, Request body is null which should not be the case")
+ }
+
  client = new OkHttpClient()
  Response response = client.newCall(request).execute()
 
  if (response.code() != 200) {
- logger.error("An error occurred while uploading the mapping file: {}", response.body().string())
+ if (response.body() != null) {
+ logger.error("An error occurred while uploading the mapping file: {}", response.body().string())
+ } else {
+ logger.error("An error occurred while uploading the mapping file, response body null")
+ }
  } else {
  logger.debug("File upload successful")
  }