Merge branch 'master' into fix-spotbugs-switch-defaults-2790825227576484200

Author: shai-almog

CodenameOne/src/com/codename1/l10n/SimpleDateFormat.java

@@ -118,6 +118,18 @@ public class SimpleDateFormat extends DateFormat {
      * Pattern character for RFC 822-style timezone.
      */
     private static final char TIMEZONE822_LETTER = 'Z';
+    /**
+     * Pattern character for ISO 8601 timezone.
+     */
+    private static final char ISO_TIMEZONE_LETTER = 'X';
+    /**
+     * Pattern character for week year.
+     */
+    private static final char WEEK_YEAR_LETTER = 'Y';
+    /**
+     * Pattern character for day number of week.
+     */
+    private static final char DAY_NUMBER_OF_WEEK_LETTER = 'u';
     /**
      * Internally used character for literal text.
      */
@@ -141,7 +153,7 @@ public class SimpleDateFormat extends DateFormat {
     /**
      * Pattern characters recognized by this implementation (same as JDK 1.6).
      */
-    private static final String PATTERN_LETTERS = "adDEFGHhKkMmsSwWyzZ";
+    private static final String PATTERN_LETTERS = "adDEFGHhKkMmsSwWyzZXYu";
     /**
      * TimeZone ID for Greenwich Mean Time
      */
@@ -371,7 +383,24 @@ String format(Date source, StringBuilder toAppendTo) {
                     toAppendTo.append(leftPad(v / 60, 2));
                     toAppendTo.append(leftPad(v % 60, 2));
                     break;
+                case ISO_TIMEZONE_LETTER:
+                    v = getOffsetInMinutes(calendar, calendar.getTimeZone());
+                    if (v < 0) {
+                        toAppendTo.append(SIGN_NEGATIVE);
+                        v = -v;
+                    } else {
+                        toAppendTo.append(SIGN_POSITIVE);
+                    }
+                    toAppendTo.append(leftPad(v / 60, 2));
+                    if (len >= 2) {
+                        if (len == 3) {
+                            toAppendTo.append(':');
+                        }
+                        toAppendTo.append(leftPad(v % 60, 2));
+                    }
+                    break;
                 case YEAR_LETTER:
+                case WEEK_YEAR_LETTER:
                     v = calendar.get(Calendar.YEAR);
                     if (len == 2) {
                         v %= 100;
@@ -441,6 +470,10 @@ String format(Date source, StringBuilder toAppendTo) {
                     v = calendar.get(DAY_OF_WEEK_IN_MONTH);
                     toAppendTo.append(leftPad(v, len));
                     break;
+                case DAY_NUMBER_OF_WEEK_LETTER:
+                    v = ((calendar.get(Calendar.DAY_OF_WEEK) + 5) % 7) + 1;
+                    toAppendTo.append(leftPad(v, len));
+                    break;
                 default:
                     break;
             }
@@ -517,6 +550,7 @@ public Date parse(String source) throws ParseException {
                     break;
                 case TIMEZONE_LETTER:
                 case TIMEZONE822_LETTER:
+                case ISO_TIMEZONE_LETTER:
                     s = readTimeZone(source, startIndex);
                     TimeZoneResult res = new TimeZoneResult();
                     if (s == null || (v = parseTimeZone(s, startIndex, res)) == -1) {
@@ -527,6 +561,7 @@ public Date parse(String source) throws ParseException {
                     tzMinutes = ((tzMinutes == -1) ? 0 : tzMinutes) + v;
                     break;
                 case YEAR_LETTER:
+                case WEEK_YEAR_LETTER:
                     s = readNumber(source, startIndex, token, adjacent);
                     calendar.set(Calendar.YEAR, parseYear(s, token, startIndex));
                     break;
@@ -574,6 +609,14 @@ public Date parse(String source) throws ParseException {
                     calendar.set(DAY_OF_WEEK_IN_MONTH,
                             parseNumber(s, startIndex, "day of week in month", -5, 5));
                     break;
+                case DAY_NUMBER_OF_WEEK_LETTER:
+                    s = readNumber(source, startIndex, token, adjacent);
+                    v = parseNumber(s, startIndex, "day number of week", 1, 7);
+                    // Map 1(Mon)-7(Sun) to Calendar 2(Mon)..1(Sun)
+                    // Mon=1 -> 2. Tue=2 -> 3. ... Sat=6 -> 7. Sun=7 -> 1.
+                    // v % 7 + 1
+                    calendar.set(Calendar.DAY_OF_WEEK, (v % 7) + 1);
+                    break;
                 default:
                     break;
             }
@@ -1190,14 +1233,27 @@ List<String> parseDatePattern(String pattern) {
             char ch = pattern.charAt(i);
             // Handle literal text enclosed in quotes
             if (ch == EXPLICIT_LITERAL) {
-                int n = pattern.indexOf(EXPLICIT_LITERAL, i + 1);
-                if (n != -1) {
-                    if (tmp != null) {
-                        tokens.add(tmp.charAt(0) + tmp);
-                        tmp = null;
+                if (tmp != null) {
+                    tokens.add(tmp.charAt(0) + tmp);
+                    tmp = null;
+                }
+                StringBuilder sb = new StringBuilder();
+                int n = i + 1;
+                while (n < plen) {
+                    char c = pattern.charAt(n);
+                    if (c == EXPLICIT_LITERAL) {
+                        if (n + 1 < plen && pattern.charAt(n + 1) == EXPLICIT_LITERAL) {
+                            sb.append(EXPLICIT_LITERAL);
+                            n += 2;
+                            continue;
+                        } else {
+                            break;
+                        }
                     }
-                    tokens.add(LITERAL_LETTER + pattern.substring(i + 1, n));
+                    sb.append(c);
+                    n++;
                 }
+                tokens.add(LITERAL_LETTER + sb.toString());
                 i = n;
                 continue;
             }
@@ -1212,7 +1268,7 @@ List<String> parseDatePattern(String pattern) {
                 int n;
                 for (n = i; n < plen; n++) {
                     ch = pattern.charAt(n);
-                    if (PATTERN_LETTERS.indexOf(ch) != -1) {
+                    if (PATTERN_LETTERS.indexOf(ch) != -1 || ch == EXPLICIT_LITERAL) {
                         break;
                     }
                     if (isAlpha(ch)) {

CodenameOne/src/com/codename1/ui/InfiniteContainer.java

@@ -124,8 +124,17 @@ public void run() {
     }
 
     void refreshImpl() {
+        if (requestingResults) {
+            return;
+        }
         requestingResults = true;
-        Component[] components = fetchComponents(0, amount);
+        Component[] components;
+        try {
+            components = fetchComponents(0, amount);
+        } catch(RuntimeException err) {
+            requestingResults = false;
+            throw err;
+        }
         if (components == null) {
             components = new Component[0];
         }

Ports/Android/src/com/codename1/impl/android/AndroidImplementation.java

@@ -6977,6 +6977,7 @@ public void sendMessage(String[] recipients, String subject, Message msg) {
             }
             if (msg.getMimeType().equals(Message.MIME_HTML)) {
                 emailIntent.putExtra(android.content.Intent.EXTRA_TEXT, Html.fromHtml(msg.getContent()));
+                emailIntent.putExtra("android.intent.extra.HTML_TEXT", msg.getContent());
             }else{
                 /*
                 // Attempted this workaround to fix the ClassCastException that occurs on android when

maven/core-unittests/src/test/java/com/codename1/l10n/SimpleDateFormatTest.java

@@ -133,6 +133,58 @@ void cloneCopiesPatternAndSymbols() {
         assertSame(symbols, clone.getDateFormatSymbols());
     }
 
+    @Test
+    void testQuotedStringLiteral() {
+        // "formats like yyyy.MM.dd G 'at' HH:mm:ss z yield illegal argument exception on the t char."
+        assertDoesNotThrow(() -> {
+            new SimpleDateFormat("yyyy.MM.dd G 'at' HH:mm:ss z");
+        }, "Should not throw exception for quoted literal 'at'");
+    }
+
+    @Test
+    void testEscapedSingleQuoteFormat() {
+        // "Also formats like: hh 'o''clock' yield exception for the c char."
+        SimpleDateFormat sdf = new SimpleDateFormat("hh 'o''clock'");
+        Calendar cal = Calendar.getInstance();
+        cal.set(Calendar.HOUR, 5);
+        String result = sdf.format(cal.getTime());
+        // Expected: 05 o'clock
+        assertTrue(result.contains("o'clock"), "Should contain single quote: " + result);
+    }
+
+    @Test
+    void testXXXFormat() {
+        // "yyyy-MM-dd'T'HH:mm:ss.SSSXXX (exception for X char, recent API level prerequisite)"
+        assertDoesNotThrow(() -> {
+            new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
+        }, "Should not throw exception for XXX format");
+
+        SimpleDateFormat sdf = new SimpleDateFormat("XXX");
+        // We cannot reliably test exact timezone string without controlling default timezone,
+        // but we can check it doesn't crash and produces something reasonable.
+        String result = sdf.format(new Date());
+        assertNotNull(result);
+        assertFalse(result.isEmpty());
+    }
+
+    @Test
+    void testYYYYAnduFormat() {
+        // "YYYY-'W'ww-u (exception for Y char)"
+        assertDoesNotThrow(() -> {
+            new SimpleDateFormat("YYYY-'W'ww-u");
+        }, "Should not throw exception for YYYY and u format");
+
+        SimpleDateFormat sdf = new SimpleDateFormat("u");
+        Calendar cal = Calendar.getInstance();
+        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
+        String result = sdf.format(cal.getTime());
+        assertEquals("1", result, "Monday should be 1");
+
+        cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
+        result = sdf.format(cal.getTime());
+        assertEquals("7", result, "Sunday should be 7");
+    }
+
     private static class StubL10NManager extends L10NManager {
         StubL10NManager() {
             super("en", "US");

vm/ByteCodeTranslator/src/cn1_globals.h

@@ -789,6 +789,7 @@ struct ThreadLocalData {
     char* utf8Buffer;
     int utf8BufferSize;
     JAVA_BOOLEAN threadKilled;      // we don't expect to see this in the GC
+    JAVA_BOOLEAN interrupted;
 };
 
 //#define BLOCK_FOR_GC() while(threadStateData->threadBlockedByGC) { usleep(500); }

vm/ByteCodeTranslator/src/nativeMethods.m

@@ -1090,6 +1090,7 @@ JAVA_INT java_lang_Object_hashCode___R_int(CODENAME_ONE_THREAD_STATE, JAVA_OBJEC
         i->threadBlockedByGC = JAVA_FALSE;
         i->threadActive = JAVA_FALSE;
         i->threadKilled = JAVA_FALSE;
+        i->interrupted = JAVA_FALSE;
 
         i->currentThreadObject = 0;
 
@@ -1461,6 +1462,40 @@ JAVA_LONG java_lang_Thread_getNativeThreadId___R_long(CODENAME_ONE_THREAD_STATE)
     return currentThreadId();
 }
 
+JAVA_VOID java_lang_Thread_interrupt0__(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT me) {
+    lockCriticalSection();
+    for(int i=0; i<NUMBER_OF_SUPPORTED_THREADS; i++) {
+        struct ThreadLocalData* d = allThreads[i];
+        if(d && d->currentThreadObject == me) {
+            d->interrupted = JAVA_TRUE;
+            break;
+        }
+    }
+    unlockCriticalSection();
+}
+
+JAVA_BOOLEAN java_lang_Thread_isInterrupted___boolean_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT me, JAVA_BOOLEAN clear) {
+    JAVA_BOOLEAN ret = JAVA_FALSE;
+    // optimization: checking current thread
+    if(threadStateData->currentThreadObject == me) {
+        ret = threadStateData->interrupted;
+        if(clear) threadStateData->interrupted = JAVA_FALSE;
+        return ret;
+    }
+
+    lockCriticalSection();
+    for(int i=0; i<NUMBER_OF_SUPPORTED_THREADS; i++) {
+        struct ThreadLocalData* d = allThreads[i];
+        if(d && d->currentThreadObject == me) {
+            ret = d->interrupted;
+            if(clear) d->interrupted = JAVA_FALSE;
+            break;
+        }
+    }
+    unlockCriticalSection();
+    return ret;
+}
+
 JAVA_DOUBLE java_lang_StringToReal_parseDblImpl___java_lang_String_int_R_double(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT s, JAVA_INT e) {
     int length = java_lang_String_length___R_int(threadStateData, s);
     JAVA_ARRAY arrayData = (JAVA_ARRAY)java_lang_String_toCharNoCopy___R_char_1ARRAY(threadStateData, s);

vm/JavaAPI/src/java/lang/Thread.java

@@ -122,8 +122,21 @@ public final int getPriority(){
      * Interrupts this thread. In an implementation conforming to the CLDC Specification, this operation is not required to cancel or clean up any pending I/O operations that the thread may be waiting for.
      */
     public void interrupt(){
+        interrupt0();
     }
 
+    private native void interrupt0();
+
+    public static boolean interrupted() {
+        return currentThread().isInterrupted(true);
+    }
+
+    public boolean isInterrupted() {
+        return isInterrupted(false);
+    }
+
+    private native boolean isInterrupted(boolean clearInterrupted);
+
     /**
      * Tests if this thread is alive. A thread is alive if it has been started and has not yet died.
      */
@@ -135,12 +148,46 @@ public final boolean isAlive(){
      * Waits for this thread to die.
      */
     public final void join() throws java.lang.InterruptedException{
-        // not very efficient but we don't use this method much...
-        while(alive) {
-            sleep(30);
+        join(0);
+    }
+
+    public final synchronized void join(long millis) throws java.lang.InterruptedException {
+        long base = System.currentTimeMillis();
+        long now = 0;
+
+        if (millis < 0) {
+            throw new IllegalArgumentException("timeout value is negative");
+        }
+
+        if (millis == 0) {
+            while (isAlive()) {
+                wait(0);
+            }
+        } else {
+            while (isAlive()) {
+                long delay = millis - now;
+                if (delay <= 0) {
+                    break;
+                }
+                wait(delay);
+                now = System.currentTimeMillis() - base;
+            }
         }
     }
 
+    public final synchronized void join(long millis, int nanos) throws java.lang.InterruptedException {
+        if (millis < 0) {
+            throw new IllegalArgumentException("timeout value is negative");
+        }
+        if (nanos < 0 || nanos > 999999) {
+            throw new IllegalArgumentException("nanosecond timeout value out of range");
+        }
+        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
+            millis++;
+        }
+        join(millis);
+    }
+
     /**
      * Invoked from native code...
      */
@@ -155,7 +202,10 @@ private void runImpl(long tid) {
             t.printStackTrace();
         }
         activeThreads--;
-        alive = false;
+        synchronized(this) {
+            alive = false;
+            notifyAll();
+        }
     }
 
     /**
@@ -183,6 +233,19 @@ public final void setPriority(int newPriority){
      */
     public static native void sleep(long millis) throws java.lang.InterruptedException;
 
+    public static void sleep(long millis, int nanos) throws java.lang.InterruptedException {
+        if (millis < 0) {
+            throw new IllegalArgumentException("timeout value is negative");
+        }
+        if (nanos < 0 || nanos > 999999) {
+            throw new IllegalArgumentException("nanosecond timeout value out of range");
+        }
+        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
+            millis++;
+        }
+        sleep(millis);
+    }
+
     /**
      * Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
      * The result is that two threads are running concurrently: the current thread (which returns from the call to the start method) and the other thread (which executes its run method).