Replace Double.valueOf with parseDouble

48 files changed, 318 insertions, 318 deletions

diff --git a/src/org/traccar/protocol/Ev603ProtocolDecoder.java b/src/org/traccar/protocol/Ev603ProtocolDecoder.java
index 31c0a8208..34e961084 100644
--- a/src/org/traccar/protocol/Ev603ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Ev603ProtocolDecoder.java
@@ -85,14 +85,14 @@ public class Ev603ProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(true);

 

             // Coordinates

-            position.setLatitude(Double.valueOf(parser.group(index++)));

-            position.setLongitude(Double.valueOf(parser.group(index++)));

+            position.setLatitude(Double.parseDouble(parser.group(index++)));

+            position.setLongitude(Double.parseDouble(parser.group(index++)));

 

             // Speed

-            position.setSpeed(Double.valueOf(parser.group(index++)));

+            position.setSpeed(Double.parseDouble(parser.group(index++)));

 

             // Course

-            position.setCourse(Double.valueOf(parser.group(index++)));

+            position.setCourse(Double.parseDouble(parser.group(index++)));

             if (position.getCourse() > 360) {

                 position.setCourse(0);

             }

diff --git a/src/org/traccar/protocol/FreedomProtocolDecoder.java b/src/org/traccar/protocol/FreedomProtocolDecoder.java
index bcb271bf9..2c6accd53 100644
--- a/src/org/traccar/protocol/FreedomProtocolDecoder.java
+++ b/src/org/traccar/protocol/FreedomProtocolDecoder.java
@@ -80,20 +80,20 @@ public class FreedomProtocolDecoder extends BaseProtocolDecoder {
 
         // Latitude
         String hemisphere = parser.group(index++);
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (hemisphere.compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
         hemisphere = parser.group(index++);
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (hemisphere.compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
         return position;
     }
 
diff --git a/src/org/traccar/protocol/Gl100ProtocolDecoder.java b/src/org/traccar/protocol/Gl100ProtocolDecoder.java
index b49f9af9e..3233342c8 100644
--- a/src/org/traccar/protocol/Gl100ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Gl100ProtocolDecoder.java
@@ -87,11 +87,11 @@ public class Gl100ProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(Integer.parseInt(parser.group(index++)) == 0);
 
         // Position info
-        position.setSpeed(Double.valueOf(parser.group(index++)));
-        position.setCourse(Double.valueOf(parser.group(index++)));
-        position.setAltitude(Double.valueOf(parser.group(index++)));
-        position.setLongitude(Double.valueOf(parser.group(index++)));
-        position.setLatitude(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
 
         // Time
         Calendar time = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
diff --git a/src/org/traccar/protocol/Gl200ProtocolDecoder.java b/src/org/traccar/protocol/Gl200ProtocolDecoder.java
index 0a9ff86ea..88b9669c8 100644
--- a/src/org/traccar/protocol/Gl200ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Gl200ProtocolDecoder.java
@@ -138,24 +138,24 @@ public class Gl200ProtocolDecoder extends BaseProtocolDecoder {
         // Speed
         String speed = parser.group(index++);
         if (speed != null) {
-            position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(speed)));
+            position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(speed)));
         }
 
         // Course
         String course = parser.group(index++);
         if (speed != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Altitude
         String altitude = parser.group(index++);
         if (altitude != null) {
-            position.setAltitude(Double.valueOf(altitude));
+            position.setAltitude(Double.parseDouble(altitude));
         }
 
         // Coordinates
-        position.setLongitude(Double.valueOf(parser.group(index++)));
-        position.setLatitude(Double.valueOf(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
 
         // Date
         Calendar time = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
@@ -178,7 +178,7 @@ public class Gl200ProtocolDecoder extends BaseProtocolDecoder {
 
         // Other
         String odometer = parser.group(index++);
-        if (odometer != null && Double.valueOf(odometer) != 0) {
+        if (odometer != null && Double.parseDouble(odometer) != 0) {
             position.set(Event.KEY_ODOMETER, odometer);
         }
         position.set(Event.KEY_BATTERY, parser.group(index++));
diff --git a/src/org/traccar/protocol/GlobalSatProtocolDecoder.java b/src/org/traccar/protocol/GlobalSatProtocolDecoder.java
index ea5e6bcc0..6f55fceef 100644
--- a/src/org/traccar/protocol/GlobalSatProtocolDecoder.java
+++ b/src/org/traccar/protocol/GlobalSatProtocolDecoder.java
@@ -115,47 +115,47 @@ public class GlobalSatProtocolDecoder extends BaseProtocolDecoder {
                     valueIndex += 1;
                     break;
                 case '1':
-                    double longitude = Double.valueOf(value.substring(1));
+                    double longitude = Double.parseDouble(value.substring(1));
                     if (value.charAt(0) == 'W') longitude = -longitude;
                     position.setLongitude(longitude);
                     break;
                 case '2':
-                    longitude = Double.valueOf(value.substring(4)) / 60;
+                    longitude = Double.parseDouble(value.substring(4)) / 60;
                     longitude += Integer.parseInt(value.substring(1, 4));
                     if (value.charAt(0) == 'W') longitude = -longitude;
                     position.setLongitude(longitude);
                     break;
                 case '3':
-                    position.setLongitude(Double.valueOf(value) * 0.000001);
+                    position.setLongitude(Double.parseDouble(value) * 0.000001);
                     break;
                 case '6':
-                    double latitude = Double.valueOf(value.substring(1));
+                    double latitude = Double.parseDouble(value.substring(1));
                     if (value.charAt(0) == 'S') latitude = -latitude;
                     position.setLatitude(latitude);
                     break;
                 case '7':
-                    latitude = Double.valueOf(value.substring(3)) / 60;
+                    latitude = Double.parseDouble(value.substring(3)) / 60;
                     latitude += Integer.parseInt(value.substring(1, 3));
                     if (value.charAt(0) == 'S') latitude = -latitude;
                     position.setLatitude(latitude);
                     break;
                 case '8':
-                    position.setLatitude(Double.valueOf(value) * 0.000001);
+                    position.setLatitude(Double.parseDouble(value) * 0.000001);
                     break;
                 case 'G':
-                    position.setAltitude(Double.valueOf(value));
+                    position.setAltitude(Double.parseDouble(value));
                     break;
                 case 'H':
-                    position.setSpeed(Double.valueOf(value));
+                    position.setSpeed(Double.parseDouble(value));
                     break;
                 case 'I':
-                    position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(value)));
+                    position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(value)));
                     break;
                 case 'J':
-                    position.setSpeed(UnitsConverter.knotsFromMph(Double.valueOf(value)));
+                    position.setSpeed(UnitsConverter.knotsFromMph(Double.parseDouble(value)));
                     break;
                 case 'K':
-                    position.setCourse(Double.valueOf(value));
+                    position.setCourse(Double.parseDouble(value));
                     break;
                 case 'N':
                     position.set(Event.KEY_BATTERY, value);
@@ -222,26 +222,26 @@ public class GlobalSatProtocolDecoder extends BaseProtocolDecoder {
 
         // Longitude
         String hemisphere = parser.group(index++);
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (hemisphere.compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Latitude
         hemisphere = parser.group(index++);
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (hemisphere.compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Altitude
-        position.setAltitude(Double.valueOf(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Satellites
         position.set(Event.KEY_SATELLITES, Integer.parseInt(parser.group(index++)));
diff --git a/src/org/traccar/protocol/GoSafeProtocolDecoder.java b/src/org/traccar/protocol/GoSafeProtocolDecoder.java
index ddb4af6b7..90b2e5bea 100644
--- a/src/org/traccar/protocol/GoSafeProtocolDecoder.java
+++ b/src/org/traccar/protocol/GoSafeProtocolDecoder.java
@@ -92,20 +92,20 @@ public class GoSafeProtocolDecoder extends BaseProtocolDecoder {
 
         // Latitude
         String hemisphere = parser.group(index++);
-        Double latitude = Double.valueOf(parser.group(index++));
+        Double latitude = Double.parseDouble(parser.group(index++));
         if (hemisphere.compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
         hemisphere = parser.group(index++);
-        Double longitude = Double.valueOf(parser.group(index++));
+        Double longitude = Double.parseDouble(parser.group(index++));
         if (hemisphere.compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Other
-        position.setSpeed(Double.valueOf(parser.group(index++)));
-        position.setCourse(Double.valueOf(parser.group(index++)));
-        position.setAltitude(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
         position.set(Event.KEY_HDOP, parser.group(index++));
 
         return position;
diff --git a/src/org/traccar/protocol/GotopProtocolDecoder.java b/src/org/traccar/protocol/GotopProtocolDecoder.java
index 52a864a5a..1f8926bb7 100644
--- a/src/org/traccar/protocol/GotopProtocolDecoder.java
+++ b/src/org/traccar/protocol/GotopProtocolDecoder.java
@@ -85,17 +85,17 @@ public class GotopProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
+        Double latitude = Double.parseDouble(parser.group(index++));
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
+        Double longitude = Double.parseDouble(parser.group(index++));
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(parser.group(index++))));
+        position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(parser.group(index++))));
 
         // Status
         position.set(Event.KEY_STATUS, parser.group(index++));
@@ -103,7 +103,7 @@ public class GotopProtocolDecoder extends BaseProtocolDecoder {
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
         return position;
     }
diff --git a/src/org/traccar/protocol/Gps103ProtocolDecoder.java b/src/org/traccar/protocol/Gps103ProtocolDecoder.java
index 4a576b646..cf3264ea8 100644
--- a/src/org/traccar/protocol/Gps103ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Gps103ProtocolDecoder.java
@@ -156,8 +156,8 @@ public class Gps103ProtocolDecoder extends BaseProtocolDecoder {
 
         // Latitude
         String hemisphere = parser.group(index++);
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index) != null) {
             hemisphere = parser.group(index);
         }
@@ -169,8 +169,8 @@ public class Gps103ProtocolDecoder extends BaseProtocolDecoder {
 
         // Longitude
         hemisphere = parser.group(index++);
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index) != null) {
             hemisphere = parser.group(index);
         }
@@ -183,19 +183,19 @@ public class Gps103ProtocolDecoder extends BaseProtocolDecoder {
         // Speed
         String speed = parser.group(index++);
         if (speed != null) {
-            position.setSpeed(Double.valueOf(speed));
+            position.setSpeed(Double.parseDouble(speed));
         }
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Altitude
         String altitude = parser.group(index++);
         if (altitude != null) {
-            position.setAltitude(Double.valueOf(altitude));
+            position.setAltitude(Double.parseDouble(altitude));
         }
 
         // Additional data
diff --git a/src/org/traccar/protocol/GpsGateProtocolDecoder.java b/src/org/traccar/protocol/GpsGateProtocolDecoder.java
index d45246b0c..04d9e37fa 100644
--- a/src/org/traccar/protocol/GpsGateProtocolDecoder.java
+++ b/src/org/traccar/protocol/GpsGateProtocolDecoder.java
@@ -114,27 +114,27 @@ public class GpsGateProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Speed
             String speed = parser.group(index++);
             if (speed != null) {
-                position.setSpeed(Double.valueOf(speed));
+                position.setSpeed(Double.parseDouble(speed));
             }
 
             // Course
             String course = parser.group(index++);
             if (course != null) {
-                position.setCourse(Double.valueOf(course));
+                position.setCourse(Double.parseDouble(course));
             }
 
             // Date
diff --git a/src/org/traccar/protocol/GpsMarkerProtocolDecoder.java b/src/org/traccar/protocol/GpsMarkerProtocolDecoder.java
index aaab9fecc..801ceef0e 100644
--- a/src/org/traccar/protocol/GpsMarkerProtocolDecoder.java
+++ b/src/org/traccar/protocol/GpsMarkerProtocolDecoder.java
@@ -96,8 +96,8 @@ public class GpsMarkerProtocolDecoder extends BaseProtocolDecoder {
 
         // Latitude
         String hemisphere = parser.group(index++);
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 600000;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 600000;
         if (hemisphere.compareTo("S") == 0) {
             latitude = -latitude;
         }
@@ -105,18 +105,18 @@ public class GpsMarkerProtocolDecoder extends BaseProtocolDecoder {
 
         // Longitude
         hemisphere = parser.group(index++);
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 600000;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 600000;
         if (hemisphere.compareTo("W") == 0) {
             longitude = -longitude;
         }
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Additional data
         position.set(Event.KEY_SATELLITES, parser.group(index++));
diff --git a/src/org/traccar/protocol/H02ProtocolDecoder.java b/src/org/traccar/protocol/H02ProtocolDecoder.java
index 2fd05ad2d..b3b624231 100644
--- a/src/org/traccar/protocol/H02ProtocolDecoder.java
+++ b/src/org/traccar/protocol/H02ProtocolDecoder.java
@@ -157,24 +157,24 @@ public class H02ProtocolDecoder extends BaseProtocolDecoder {
         }
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Date
diff --git a/src/org/traccar/protocol/HaicomProtocolDecoder.java b/src/org/traccar/protocol/HaicomProtocolDecoder.java
index 911479bbb..8b1097a69 100644
--- a/src/org/traccar/protocol/HaicomProtocolDecoder.java
+++ b/src/org/traccar/protocol/HaicomProtocolDecoder.java
@@ -96,22 +96,22 @@ public class HaicomProtocolDecoder extends BaseProtocolDecoder {
         position.setValid((flags & 0x1) != 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60000;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60000;
         if ((flags & 0x4) == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60000;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60000;
         if ((flags & 0x2) == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)) / 10);
+        position.setSpeed(Double.parseDouble(parser.group(index++)) / 10);
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)) / 10);
+        position.setCourse(Double.parseDouble(parser.group(index++)) / 10);
 
         // Additional data
         position.set(Event.KEY_STATUS, parser.group(index++));
@@ -119,7 +119,7 @@ public class HaicomProtocolDecoder extends BaseProtocolDecoder {
         position.set(Event.KEY_GPS, parser.group(index++));
         position.set(Event.KEY_INPUT, parser.group(index++));
         position.set(Event.KEY_OUTPUT, parser.group(index++));
-        position.set(Event.KEY_BATTERY, Double.valueOf(parser.group(index++)) / 10);
+        position.set(Event.KEY_BATTERY, Double.parseDouble(parser.group(index++)) / 10);
 
         return position;
     }
diff --git a/src/org/traccar/protocol/IntellitracProtocolDecoder.java b/src/org/traccar/protocol/IntellitracProtocolDecoder.java
index fd393da45..7d91256b3 100644
--- a/src/org/traccar/protocol/IntellitracProtocolDecoder.java
+++ b/src/org/traccar/protocol/IntellitracProtocolDecoder.java
@@ -97,11 +97,11 @@ public class IntellitracProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Location data
-        position.setLongitude(Double.valueOf(parser.group(index++)));
-        position.setLatitude(Double.valueOf(parser.group(index++)));
-        position.setSpeed(Double.valueOf(parser.group(index++)));
-        position.setCourse(Double.valueOf(parser.group(index++)));
-        position.setAltitude(Double.valueOf(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
 
         // Satellites
         int satellites = Integer.parseInt(parser.group(index++));
diff --git a/src/org/traccar/protocol/Jt600ProtocolDecoder.java b/src/org/traccar/protocol/Jt600ProtocolDecoder.java
index c2d86391e..fd76b888f 100644
--- a/src/org/traccar/protocol/Jt600ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Jt600ProtocolDecoder.java
@@ -163,14 +163,14 @@ public class Jt600ProtocolDecoder extends BaseProtocolDecoder {
         position.setDeviceId(getDeviceId());
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
@@ -189,13 +189,13 @@ public class Jt600ProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Power
-        position.set(Event.KEY_POWER, Double.valueOf(parser.group(index++)));
+        position.set(Event.KEY_POWER, Double.parseDouble(parser.group(index++)));
         return position;
     }
 
diff --git a/src/org/traccar/protocol/LaipacProtocolDecoder.java b/src/org/traccar/protocol/LaipacProtocolDecoder.java
index ad425a865..9962b303d 100644
--- a/src/org/traccar/protocol/LaipacProtocolDecoder.java
+++ b/src/org/traccar/protocol/LaipacProtocolDecoder.java
@@ -91,22 +91,22 @@ public class LaipacProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(status.compareToIgnoreCase("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Date
         time.set(Calendar.DAY_OF_MONTH, Integer.parseInt(parser.group(index++)));
diff --git a/src/org/traccar/protocol/ManPowerProtocolDecoder.java b/src/org/traccar/protocol/ManPowerProtocolDecoder.java
index 5bb7e5be9..33d13e663 100644
--- a/src/org/traccar/protocol/ManPowerProtocolDecoder.java
+++ b/src/org/traccar/protocol/ManPowerProtocolDecoder.java
@@ -92,19 +92,19 @@ public class ManPowerProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         return position;
     }
diff --git a/src/org/traccar/protocol/MaxonProtocolDecoder.java b/src/org/traccar/protocol/MaxonProtocolDecoder.java
index 9e4381ee4..54177af68 100644
--- a/src/org/traccar/protocol/MaxonProtocolDecoder.java
+++ b/src/org/traccar/protocol/MaxonProtocolDecoder.java
@@ -89,27 +89,27 @@ public class MaxonProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Speed
             String speed = parser.group(index++);
             if (speed != null) {
-                position.setSpeed(Double.valueOf(speed));
+                position.setSpeed(Double.parseDouble(speed));
             }
 
             // Course
             String course = parser.group(index++);
             if (course != null) {
-                position.setCourse(Double.valueOf(course));
+                position.setCourse(Double.parseDouble(course));
             }
 
             // Date
diff --git a/src/org/traccar/protocol/MegastekProtocolDecoder.java b/src/org/traccar/protocol/MegastekProtocolDecoder.java
index c7ca41dfb..d3d12dd76 100644
--- a/src/org/traccar/protocol/MegastekProtocolDecoder.java
+++ b/src/org/traccar/protocol/MegastekProtocolDecoder.java
@@ -93,27 +93,27 @@ public class MegastekProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
         String speed = parser.group(index++);
         if (speed != null) {
-            position.setSpeed(Double.valueOf(speed));
+            position.setSpeed(Double.parseDouble(speed));
         }
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Date
@@ -200,10 +200,10 @@ public class MegastekProtocolDecoder extends BaseProtocolDecoder {
 
                 String altitude = parser.group(index++);
                 if (altitude != null) {
-                    position.setAltitude(Double.valueOf(altitude));
+                    position.setAltitude(Double.parseDouble(altitude));
                 }
 
-                position.set(Event.KEY_POWER, Double.valueOf(parser.group(index++)));
+                position.set(Event.KEY_POWER, Double.parseDouble(parser.group(index++)));
 
                 String charger = parser.group(index++);
                 if (charger != null) {
@@ -240,7 +240,7 @@ public class MegastekProtocolDecoder extends BaseProtocolDecoder {
                 position.set(Event.KEY_LAC, parser.group(index++));
                 position.set(Event.KEY_GSM, parser.group(index++));
 
-                position.set(Event.KEY_BATTERY, Double.valueOf(parser.group(index++)));
+                position.set(Event.KEY_BATTERY, Double.parseDouble(parser.group(index++)));
 
                 position.set(Event.KEY_FLAGS, parser.group(index++));
                 position.set(Event.KEY_INPUT, parser.group(index++));
@@ -324,14 +324,14 @@ public class MegastekProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).equals("A"));
 
         // Latitude
-        double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).equals("S")) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).equals("W")) longitude = -longitude;
         position.setLongitude(longitude);
 
diff --git a/src/org/traccar/protocol/MeiligaoProtocolDecoder.java b/src/org/traccar/protocol/MeiligaoProtocolDecoder.java
index 2ef2a388e..17fd0d0d4 100644
--- a/src/org/traccar/protocol/MeiligaoProtocolDecoder.java
+++ b/src/org/traccar/protocol/MeiligaoProtocolDecoder.java
@@ -230,14 +230,14 @@ public class MeiligaoProtocolDecoder extends BaseProtocolDecoder {
             position.setTime(time.getTime());
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
@@ -258,27 +258,27 @@ public class MeiligaoProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Speed
             String speed = parser.group(index++);
             if (speed != null) {
-                position.setSpeed(Double.valueOf(speed));
+                position.setSpeed(Double.parseDouble(speed));
             }
 
             // Course
             String course = parser.group(index++);
             if (course != null) {
-                position.setCourse(Double.valueOf(course));
+                position.setCourse(Double.parseDouble(course));
             }
 
             // Date
@@ -293,7 +293,7 @@ public class MeiligaoProtocolDecoder extends BaseProtocolDecoder {
             // Altitude
             String altitude = parser.group(index++);
             if (altitude != null) {
-                position.setAltitude(Double.valueOf(altitude));
+                position.setAltitude(Double.parseDouble(altitude));
             }
 
             // State
diff --git a/src/org/traccar/protocol/MeitrackProtocolDecoder.java b/src/org/traccar/protocol/MeitrackProtocolDecoder.java
index fc8d67885..6b43d1169 100644
--- a/src/org/traccar/protocol/MeitrackProtocolDecoder.java
+++ b/src/org/traccar/protocol/MeitrackProtocolDecoder.java
@@ -99,8 +99,8 @@ public class MeitrackProtocolDecoder extends BaseProtocolDecoder {
         position.set(Event.KEY_EVENT, event);
 
         // Coordinates
-        position.setLatitude(Double.valueOf(parser.group(index++)));
-        position.setLongitude(Double.valueOf(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
 
         // Time
         Calendar time = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
@@ -123,16 +123,16 @@ public class MeitrackProtocolDecoder extends BaseProtocolDecoder {
         position.set(Event.KEY_GSM, parser.group(index++));
 
         // Speed
-        position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(parser.group(index++))));
+        position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(parser.group(index++))));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // HDOP
         position.set(Event.KEY_HDOP, parser.group(index++));
 
         // Altitude
-        position.setAltitude(Double.valueOf(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
 
         // Other
         position.set(Event.KEY_ODOMETER, parser.group(index++));
diff --git a/src/org/traccar/protocol/MiniFinderProtocolDecoder.java b/src/org/traccar/protocol/MiniFinderProtocolDecoder.java
index 2f2d96306..7cdfab3a8 100644
--- a/src/org/traccar/protocol/MiniFinderProtocolDecoder.java
+++ b/src/org/traccar/protocol/MiniFinderProtocolDecoder.java
@@ -88,10 +88,10 @@ public class MiniFinderProtocolDecoder extends BaseProtocolDecoder {
             position.setTime(time.getTime());
 
             // Location
-            position.setLatitude(Double.valueOf(parser.group(index++)));
-            position.setLongitude(Double.valueOf(parser.group(index++)));
-            position.setSpeed(Double.valueOf(parser.group(index++)));
-            position.setCourse(Double.valueOf(parser.group(index++)));
+            position.setLatitude(Double.parseDouble(parser.group(index++)));
+            position.setLongitude(Double.parseDouble(parser.group(index++)));
+            position.setSpeed(Double.parseDouble(parser.group(index++)));
+            position.setCourse(Double.parseDouble(parser.group(index++)));
 
             // Flags
             String flags = parser.group(index++);
@@ -99,7 +99,7 @@ public class MiniFinderProtocolDecoder extends BaseProtocolDecoder {
             position.setValid((Integer.parseInt(flags, 16) & 0x01) != 0);
 
             // Altitude
-            position.setAltitude(Double.valueOf(parser.group(index++)));
+            position.setAltitude(Double.parseDouble(parser.group(index++)));
 
             // Battery
             position.set(Event.KEY_BATTERY, parser.group(index++));
diff --git a/src/org/traccar/protocol/MtxProtocolDecoder.java b/src/org/traccar/protocol/MtxProtocolDecoder.java
index 3b8620e2c..989d8540c 100644
--- a/src/org/traccar/protocol/MtxProtocolDecoder.java
+++ b/src/org/traccar/protocol/MtxProtocolDecoder.java
@@ -94,13 +94,13 @@ public class MtxProtocolDecoder extends BaseProtocolDecoder {
 
         // Location
         position.setValid(true);
-        position.setLatitude(Double.valueOf(parser.group(index++)));
-        position.setLongitude(Double.valueOf(parser.group(index++)));
-        position.setSpeed(Double.valueOf(parser.group(index++)));
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Other
-        position.set(Event.KEY_ODOMETER, Double.valueOf(parser.group(index++)));
+        position.set(Event.KEY_ODOMETER, Double.parseDouble(parser.group(index++)));
         position.set(Event.KEY_INPUT, parser.group(index++));
         position.set(Event.KEY_OUTPUT, parser.group(index++));
         position.set(Event.PREFIX_ADC + 1, parser.group(index++));
diff --git a/src/org/traccar/protocol/OsmAndProtocolDecoder.java b/src/org/traccar/protocol/OsmAndProtocolDecoder.java
index ecc1e1b18..e7ee74a30 100644
--- a/src/org/traccar/protocol/OsmAndProtocolDecoder.java
+++ b/src/org/traccar/protocol/OsmAndProtocolDecoder.java
@@ -81,22 +81,22 @@ public class OsmAndProtocolDecoder extends BaseProtocolDecoder {
         } else {
             position.setTime(new Date());
         }
-        position.setLatitude(Double.valueOf(params.get("lat").get(0)));
-        position.setLongitude(Double.valueOf(params.get("lon").get(0)));
+        position.setLatitude(Double.parseDouble(params.get("lat").get(0)));
+        position.setLongitude(Double.parseDouble(params.get("lon").get(0)));
 
         // Optional parameters
         if (params.containsKey("speed")) {
-            position.setSpeed(Double.valueOf(params.get("speed").get(0)));
+            position.setSpeed(Double.parseDouble(params.get("speed").get(0)));
         }
 
         if (params.containsKey("bearing")) {
-            position.setCourse(Double.valueOf(params.get("bearing").get(0)));
+            position.setCourse(Double.parseDouble(params.get("bearing").get(0)));
         } else if (params.containsKey("heading")) {
-            position.setCourse(Double.valueOf(params.get("heading").get(0)));
+            position.setCourse(Double.parseDouble(params.get("heading").get(0)));
         }
 
         if (params.containsKey("altitude")) {
-            position.setAltitude(Double.valueOf(params.get("altitude").get(0)));
+            position.setAltitude(Double.parseDouble(params.get("altitude").get(0)));
         }
 
         if (params.containsKey("hdop")) {
diff --git a/src/org/traccar/protocol/Pt3000ProtocolDecoder.java b/src/org/traccar/protocol/Pt3000ProtocolDecoder.java
index 7cf783a6d..59a9a0160 100644
--- a/src/org/traccar/protocol/Pt3000ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Pt3000ProtocolDecoder.java
@@ -82,27 +82,27 @@ public class Pt3000ProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
         String speed = parser.group(index++);
         if (speed != null) {
-            position.setSpeed(Double.valueOf(speed));
+            position.setSpeed(Double.parseDouble(speed));
         }
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Date
diff --git a/src/org/traccar/protocol/Pt502ProtocolDecoder.java b/src/org/traccar/protocol/Pt502ProtocolDecoder.java
index 0349efa59..3bd971d23 100644
--- a/src/org/traccar/protocol/Pt502ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Pt502ProtocolDecoder.java
@@ -91,16 +91,16 @@ public class Pt502ProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);

 

         // Latitude

-        Double latitude = Double.valueOf(parser.group(index++));

-        latitude += Double.valueOf(parser.group(index++)) / 60;

+        Double latitude = Double.parseDouble(parser.group(index++));

+        latitude += Double.parseDouble(parser.group(index++)) / 60;

         if (parser.group(index++).compareTo("S") == 0) {

             latitude = -latitude;

         }

         position.setLatitude(latitude);

 

         // Longitude

-        Double longitude = Double.valueOf(parser.group(index++));

-        longitude += Double.valueOf(parser.group(index++)) / 60;

+        Double longitude = Double.parseDouble(parser.group(index++));

+        longitude += Double.parseDouble(parser.group(index++)) / 60;

         if (parser.group(index++).compareTo("W") == 0) {

             longitude = -longitude;

         }

@@ -109,13 +109,13 @@ public class Pt502ProtocolDecoder extends BaseProtocolDecoder {
         // Speed

         String speed = parser.group(index++);

         if (speed != null) {

-            position.setSpeed(Double.valueOf(speed));

+            position.setSpeed(Double.parseDouble(speed));

         }

 

         // Course

         String course = parser.group(index++);

         if (course != null) {

-            position.setCourse(Double.valueOf(course));

+            position.setCourse(Double.parseDouble(course));

         }

 

         // Date

diff --git a/src/org/traccar/protocol/RitiProtocolDecoder.java b/src/org/traccar/protocol/RitiProtocolDecoder.java
index 1370d0d73..ca7e2a038 100644
--- a/src/org/traccar/protocol/RitiProtocolDecoder.java
+++ b/src/org/traccar/protocol/RitiProtocolDecoder.java
@@ -101,27 +101,27 @@ public class RitiProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
         String speed = parser.group(index++);
         if (speed != null) {
-            position.setSpeed(Double.valueOf(speed));
+            position.setSpeed(Double.parseDouble(speed));
         }
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Date
diff --git a/src/org/traccar/protocol/SanavProtocolDecoder.java b/src/org/traccar/protocol/SanavProtocolDecoder.java
index 9cff7d51c..24f55a165 100644
--- a/src/org/traccar/protocol/SanavProtocolDecoder.java
+++ b/src/org/traccar/protocol/SanavProtocolDecoder.java
@@ -82,24 +82,24 @@ public class SanavProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Date
diff --git a/src/org/traccar/protocol/Stl060ProtocolDecoder.java b/src/org/traccar/protocol/Stl060ProtocolDecoder.java
index 2c9502fae..72952121a 100644
--- a/src/org/traccar/protocol/Stl060ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Stl060ProtocolDecoder.java
@@ -106,22 +106,22 @@ public class Stl060ProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++) + parser.group(index++)) / 600000;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++) + parser.group(index++)) / 600000;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++) + parser.group(index++)) / 600000;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++) + parser.group(index++)) / 600000;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Old format
         if (parser.group(index) != null) {
diff --git a/src/org/traccar/protocol/SuntechProtocolDecoder.java b/src/org/traccar/protocol/SuntechProtocolDecoder.java
index dc77d5750..5ef44fa31 100644
--- a/src/org/traccar/protocol/SuntechProtocolDecoder.java
+++ b/src/org/traccar/protocol/SuntechProtocolDecoder.java
@@ -96,15 +96,15 @@ public class SuntechProtocolDecoder extends BaseProtocolDecoder {
         position.set(Event.KEY_CELL, parser.group(index++));
 
         // Coordinates
-        position.setLatitude(Double.valueOf(parser.group(index++)));
-        position.setLongitude(Double.valueOf(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
         position.setValid(true); // wrong?
 
         // Speed
-        position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(parser.group(index++))));
+        position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(parser.group(index++))));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Battery
         position.set(Event.KEY_BATTERY, parser.group(index++));
diff --git a/src/org/traccar/protocol/T55ProtocolDecoder.java b/src/org/traccar/protocol/T55ProtocolDecoder.java
index ce069878a..989d24820 100644
--- a/src/org/traccar/protocol/T55ProtocolDecoder.java
+++ b/src/org/traccar/protocol/T55ProtocolDecoder.java
@@ -151,27 +151,27 @@ public class T55ProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Speed
             String speed = parser.group(index++);
             if (speed != null) {
-                position.setSpeed(Double.valueOf(speed));
+                position.setSpeed(Double.parseDouble(speed));
             }
 
             // Course
             String course = parser.group(index++);
             if (course != null) {
-                position.setCourse(Double.valueOf(course));
+                position.setCourse(Double.parseDouble(course));
             }
 
             // Date
@@ -210,14 +210,14 @@ public class T55ProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(true);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
             return position;
@@ -246,27 +246,27 @@ public class T55ProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Speed
             String speed = parser.group(index++);
             if (speed != null) {
-                position.setSpeed(Double.valueOf(speed));
+                position.setSpeed(Double.parseDouble(speed));
             }
 
             // Course
             String course = parser.group(index++);
             if (course != null) {
-                position.setCourse(Double.valueOf(course));
+                position.setCourse(Double.parseDouble(course));
             }
             return position;
         }
@@ -302,11 +302,11 @@ public class T55ProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Location
-            position.setLatitude(Double.valueOf(parser.group(index++)));
-            position.setLongitude(Double.valueOf(parser.group(index++)));
-            position.setSpeed(Double.valueOf(parser.group(index++)));
-            position.setCourse(Double.valueOf(parser.group(index++)));
-            position.setAltitude(Double.valueOf(parser.group(index++)));
+            position.setLatitude(Double.parseDouble(parser.group(index++)));
+            position.setLongitude(Double.parseDouble(parser.group(index++)));
+            position.setSpeed(Double.parseDouble(parser.group(index++)));
+            position.setCourse(Double.parseDouble(parser.group(index++)));
+            position.setAltitude(Double.parseDouble(parser.group(index++)));
 
             // Battery
             position.set(Event.KEY_BATTERY, parser.group(index++));
diff --git a/src/org/traccar/protocol/TaipProtocolDecoder.java b/src/org/traccar/protocol/TaipProtocolDecoder.java
index 0953b739a..7545df13e 100644
--- a/src/org/traccar/protocol/TaipProtocolDecoder.java
+++ b/src/org/traccar/protocol/TaipProtocolDecoder.java
@@ -161,16 +161,16 @@ public class TaipProtocolDecoder extends BaseProtocolDecoder {
         // Latitude
         String latitude = parser.group(index) + '.' + parser.group(index + 1);
         index += 2;
-        position.setLatitude(Double.valueOf(latitude));
+        position.setLatitude(Double.parseDouble(latitude));
 
         // Latitude
         String longitude = parser.group(index) + '.' + parser.group(index + 1);
         index += 2;
-        position.setLongitude(Double.valueOf(longitude));
+        position.setLongitude(Double.parseDouble(longitude));
 
         // Speed and Course
-        position.setSpeed(UnitsConverter.knotsFromMph(Double.valueOf(parser.group(index++))));
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setSpeed(UnitsConverter.knotsFromMph(Double.parseDouble(parser.group(index++))));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Validity
         position.setValid(Integer.parseInt(parser.group(index++)) != 0);
diff --git a/src/org/traccar/protocol/TelikProtocolDecoder.java b/src/org/traccar/protocol/TelikProtocolDecoder.java
index f6b5ebf51..28df23999 100644
--- a/src/org/traccar/protocol/TelikProtocolDecoder.java
+++ b/src/org/traccar/protocol/TelikProtocolDecoder.java
@@ -87,17 +87,17 @@ public class TelikProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Location
-        position.setLongitude(Double.valueOf(parser.group(index++)) / 10000);
-        position.setLatitude(Double.valueOf(parser.group(index++)) / 10000);
+        position.setLongitude(Double.parseDouble(parser.group(index++)) / 10000);
+        position.setLatitude(Double.parseDouble(parser.group(index++)) / 10000);
 
         // Validity
         position.setValid(parser.group(index++).compareTo("1") != 0);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Satellites
         position.set(Event.KEY_SATELLITES, parser.group(index++));
diff --git a/src/org/traccar/protocol/Tk102ProtocolDecoder.java b/src/org/traccar/protocol/Tk102ProtocolDecoder.java
index 025d91986..78f436a2f 100644
--- a/src/org/traccar/protocol/Tk102ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Tk102ProtocolDecoder.java
@@ -94,19 +94,19 @@ public class Tk102ProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Speed
-            position.setSpeed(Double.valueOf(parser.group(index++)));
+            position.setSpeed(Double.parseDouble(parser.group(index++)));
 
             // Date
             time.set(Calendar.DAY_OF_MONTH, Integer.parseInt(parser.group(index++)));
diff --git a/src/org/traccar/protocol/Tlt2hProtocolDecoder.java b/src/org/traccar/protocol/Tlt2hProtocolDecoder.java
index 750611f6c..56d8f59ba 100644
--- a/src/org/traccar/protocol/Tlt2hProtocolDecoder.java
+++ b/src/org/traccar/protocol/Tlt2hProtocolDecoder.java
@@ -106,27 +106,27 @@ public class Tlt2hProtocolDecoder extends BaseProtocolDecoder {
                 position.setValid(parser.group(index++).compareTo("A") == 0);
 
                 // Latitude
-                Double latitude = Double.valueOf(parser.group(index++));
-                latitude += Double.valueOf(parser.group(index++)) / 60;
+                Double latitude = Double.parseDouble(parser.group(index++));
+                latitude += Double.parseDouble(parser.group(index++)) / 60;
                 if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
                 position.setLatitude(latitude);
 
                 // Longitude
-                Double longitude = Double.valueOf(parser.group(index++));
-                longitude += Double.valueOf(parser.group(index++)) / 60;
+                Double longitude = Double.parseDouble(parser.group(index++));
+                longitude += Double.parseDouble(parser.group(index++)) / 60;
                 if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
                 position.setLongitude(longitude);
 
                 // Speed
                 String speed = parser.group(index++);
                 if (speed != null) {
-                    position.setSpeed(Double.valueOf(speed));
+                    position.setSpeed(Double.parseDouble(speed));
                 }
 
                 // Course
                 String course = parser.group(index++);
                 if (course != null) {
-                    position.setCourse(Double.valueOf(course));
+                    position.setCourse(Double.parseDouble(course));
                 }
 
                 // Date
diff --git a/src/org/traccar/protocol/TopflytechProtocolDecoder.java b/src/org/traccar/protocol/TopflytechProtocolDecoder.java
index aca44a843..29a31cef1 100644
--- a/src/org/traccar/protocol/TopflytechProtocolDecoder.java
+++ b/src/org/traccar/protocol/TopflytechProtocolDecoder.java
@@ -85,22 +85,22 @@ public class TopflytechProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
         return position;
     }
 
diff --git a/src/org/traccar/protocol/TotemProtocolDecoder.java b/src/org/traccar/protocol/TotemProtocolDecoder.java
index 2d26fdb27..960cd9963 100644
--- a/src/org/traccar/protocol/TotemProtocolDecoder.java
+++ b/src/org/traccar/protocol/TotemProtocolDecoder.java
@@ -181,27 +181,27 @@ public class TotemProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(parser.group(index++).compareTo("A") == 0);
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Speed
             String speed = parser.group(index++);
             if (speed != null) {
-                position.setSpeed(Double.valueOf(speed));
+                position.setSpeed(Double.parseDouble(speed));
             }
 
             // Course
             String course = parser.group(index++);
             if (course != null) {
-                position.setCourse(Double.valueOf(course));
+                position.setCourse(Double.parseDouble(course));
             }
 
             // Date
@@ -224,7 +224,7 @@ public class TotemProtocolDecoder extends BaseProtocolDecoder {
 
             // Power
             position.set(Event.KEY_BATTERY, parser.group(index++));
-            position.set(Event.KEY_POWER, Double.valueOf(parser.group(index++)));
+            position.set(Event.KEY_POWER, Double.parseDouble(parser.group(index++)));
 
             // ADC
             position.set(Event.PREFIX_ADC + 1, parser.group(index++));
@@ -255,8 +255,8 @@ public class TotemProtocolDecoder extends BaseProtocolDecoder {
             position.set(Event.PREFIX_IO + 1, parser.group(index++));
 
             // Power
-            position.set(Event.KEY_BATTERY, Double.valueOf(parser.group(index++)) / 10);
-            position.set(Event.KEY_POWER, Double.valueOf(parser.group(index++)));
+            position.set(Event.KEY_BATTERY, Double.parseDouble(parser.group(index++)) / 10);
+            position.set(Event.KEY_POWER, Double.parseDouble(parser.group(index++)));
 
             // ADC
             position.set(Event.PREFIX_ADC + 1, parser.group(index++));
@@ -276,10 +276,10 @@ public class TotemProtocolDecoder extends BaseProtocolDecoder {
             position.set(Event.KEY_SATELLITES, parser.group(index++));
 
             // Course
-            position.setCourse(Double.valueOf(parser.group(index++)));
+            position.setCourse(Double.parseDouble(parser.group(index++)));
 
             // Speed
-            position.setSpeed(Double.valueOf(parser.group(index++)));
+            position.setSpeed(Double.parseDouble(parser.group(index++)));
 
             // PDOP
             position.set("pdop", parser.group(index++));
@@ -288,14 +288,14 @@ public class TotemProtocolDecoder extends BaseProtocolDecoder {
             position.set(Event.KEY_ODOMETER, parser.group(index++));
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
diff --git a/src/org/traccar/protocol/Tr20ProtocolDecoder.java b/src/org/traccar/protocol/Tr20ProtocolDecoder.java
index 7afd905e4..d097ee3fe 100644
--- a/src/org/traccar/protocol/Tr20ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Tr20ProtocolDecoder.java
@@ -104,22 +104,22 @@ public class Tr20ProtocolDecoder extends BaseProtocolDecoder {
             // Latitude
             int hemisphere = 1;
             if (parser.group(index++).compareTo("S") == 0) hemisphere = -1;
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             position.setLatitude(latitude * hemisphere);
 
             // Longitude
             hemisphere = 1;
             if (parser.group(index++).compareTo("W") == 0) hemisphere = -1;
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             position.setLongitude(longitude * hemisphere);
 
             // Speed
-            position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(parser.group(index++))));
+            position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(parser.group(index++))));
 
             // Course
-            position.setCourse(Double.valueOf(parser.group(index++)));
+            position.setCourse(Double.parseDouble(parser.group(index++)));
 
             return position;
         }
diff --git a/src/org/traccar/protocol/Tr900ProtocolDecoder.java b/src/org/traccar/protocol/Tr900ProtocolDecoder.java
index 3ac627420..96f76a420 100644
--- a/src/org/traccar/protocol/Tr900ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Tr900ProtocolDecoder.java
@@ -93,23 +93,23 @@ public class Tr900ProtocolDecoder extends BaseProtocolDecoder {
 
         // Longitude
         String hemisphere = parser.group(index++);
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (hemisphere.compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Latitude
         hemisphere = parser.group(index++);
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (hemisphere.compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Other
         position.set(Event.KEY_GSM, parser.group(index++));
diff --git a/src/org/traccar/protocol/TrackboxProtocolDecoder.java b/src/org/traccar/protocol/TrackboxProtocolDecoder.java
index a5093ab0e..7db437a6e 100644
--- a/src/org/traccar/protocol/TrackboxProtocolDecoder.java
+++ b/src/org/traccar/protocol/TrackboxProtocolDecoder.java
@@ -90,14 +90,14 @@ public class TrackboxProtocolDecoder extends BaseProtocolDecoder {
             time.set(Calendar.MILLISECOND, Integer.parseInt(parser.group(index++)));
 
             // Latitude
-            Double latitude = Double.valueOf(parser.group(index++));
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = Double.parseDouble(parser.group(index++));
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Longitude
-            Double longitude = Double.valueOf(parser.group(index++));
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = Double.parseDouble(parser.group(index++));
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
@@ -105,7 +105,7 @@ public class TrackboxProtocolDecoder extends BaseProtocolDecoder {
             position.set(Event.KEY_HDOP, parser.group(index++));
 
             // Altitude
-            position.setAltitude(Double.valueOf(parser.group(index++)));
+            position.setAltitude(Double.parseDouble(parser.group(index++)));
 
             // Validity
             int fix = Integer.parseInt(parser.group(index++));
@@ -113,11 +113,11 @@ public class TrackboxProtocolDecoder extends BaseProtocolDecoder {
             position.setValid(fix > 0);
 
             // Course
-            position.setCourse(Double.valueOf(parser.group(index++)));
+            position.setCourse(Double.parseDouble(parser.group(index++)));
 
             // Speed
             index += 1; // speed in kph
-            position.setSpeed(Double.valueOf(parser.group(index++)));
+            position.setSpeed(Double.parseDouble(parser.group(index++)));
 
             // Date
             time.set(Calendar.DAY_OF_MONTH, Integer.parseInt(parser.group(index++)));
diff --git a/src/org/traccar/protocol/TramigoProtocolDecoder.java b/src/org/traccar/protocol/TramigoProtocolDecoder.java
index 4877daa5d..a74db92a7 100644
--- a/src/org/traccar/protocol/TramigoProtocolDecoder.java
+++ b/src/org/traccar/protocol/TramigoProtocolDecoder.java
@@ -113,14 +113,14 @@ public class TramigoProtocolDecoder extends BaseProtocolDecoder {
             if (!matcher.find()) {
                 return null;
             }
-            position.setLatitude(Double.valueOf(matcher.group(1)));
-            position.setLongitude(Double.valueOf(matcher.group(2)));
+            position.setLatitude(Double.parseDouble(matcher.group(1)));
+            position.setLongitude(Double.parseDouble(matcher.group(2)));
 
             // Speed and Course
             pattern = Pattern.compile("([NSWE]{1,2}) with speed (\\d+) km/h");
             matcher = pattern.matcher(sentence);
             if (matcher.find()) {
-                position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(matcher.group(2))));
+                position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(matcher.group(2))));
                 position.setCourse(0); // matcher.group(1) for course
             }
 
diff --git a/src/org/traccar/protocol/V680ProtocolDecoder.java b/src/org/traccar/protocol/V680ProtocolDecoder.java
index f88dea582..abe599754 100644
--- a/src/org/traccar/protocol/V680ProtocolDecoder.java
+++ b/src/org/traccar/protocol/V680ProtocolDecoder.java
@@ -107,23 +107,23 @@ public class V680ProtocolDecoder extends BaseProtocolDecoder {
 
             // Longitude
             String lon = parser.group(index++);
-            Double longitude = (lon != null) ? Double.valueOf(lon) : 0.0;
-            longitude += Double.valueOf(parser.group(index++)) / 60;
+            Double longitude = (lon != null) ? Double.parseDouble(lon) : 0.0;
+            longitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
             position.setLongitude(longitude);
 
             // Latitude
             String lat = parser.group(index++);
-            Double latitude = (lat != null) ? Double.valueOf(lat) : 0.0;
-            latitude += Double.valueOf(parser.group(index++)) / 60;
+            Double latitude = (lat != null) ? Double.parseDouble(lat) : 0.0;
+            latitude += Double.parseDouble(parser.group(index++)) / 60;
             if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
             position.setLatitude(latitude);
 
             // Speed and Course
-            position.setSpeed(Double.valueOf(parser.group(index++)));
+            position.setSpeed(Double.parseDouble(parser.group(index++)));
             String course = parser.group(index++);
             if (course != null) {
-                position.setCourse(Double.valueOf(course));
+                position.setCourse(Double.parseDouble(course));
             }
 
             // Date
diff --git a/src/org/traccar/protocol/VisiontekProtocolDecoder.java b/src/org/traccar/protocol/VisiontekProtocolDecoder.java
index a491e7666..a1a5cf6c9 100644
--- a/src/org/traccar/protocol/VisiontekProtocolDecoder.java
+++ b/src/org/traccar/protocol/VisiontekProtocolDecoder.java
@@ -94,28 +94,28 @@ public class VisiontekProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++).replace(".", "")) / 600000;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++).replace(".", "")) / 600000;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++).replace(".", "")) / 600000;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++).replace(".", "")) / 600000;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(
+        position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(
                 parser.group(index++).replace(".", "")) / 10));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Altitude
         String altitude = parser.group(index++);
         if (altitude != null) {
-            position.setAltitude(Double.valueOf(altitude));
+            position.setAltitude(Double.parseDouble(altitude));
         }
 
         // Additional data
diff --git a/src/org/traccar/protocol/WialonProtocolDecoder.java b/src/org/traccar/protocol/WialonProtocolDecoder.java
index 61748731a..fea00a536 100644
--- a/src/org/traccar/protocol/WialonProtocolDecoder.java
+++ b/src/org/traccar/protocol/WialonProtocolDecoder.java
@@ -94,33 +94,33 @@ public class WialonProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Speed
         String speed = parser.group(index++);
         if (speed != null) {
-            position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(speed)));
+            position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(speed)));
         }
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Altitude
         String altitude = parser.group(index++);
         if (altitude != null) {
-            position.setAltitude(Double.valueOf(altitude));
+            position.setAltitude(Double.parseDouble(altitude));
         }
 
         // Satellites
diff --git a/src/org/traccar/protocol/WondexProtocolDecoder.java b/src/org/traccar/protocol/WondexProtocolDecoder.java
index cd95e8463..dbd15c3d0 100644
--- a/src/org/traccar/protocol/WondexProtocolDecoder.java
+++ b/src/org/traccar/protocol/WondexProtocolDecoder.java
@@ -87,11 +87,11 @@ public class WondexProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Position data
-        position.setLongitude(Double.valueOf(parser.group(index++)));
-        position.setLatitude(Double.valueOf(parser.group(index++)));
-        position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(parser.group(index++))));
-        position.setCourse(Double.valueOf(parser.group(index++)));
-        position.setAltitude(Double.valueOf(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
+        position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(parser.group(index++))));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
 
         // Satellites
         int satellites = Integer.parseInt(parser.group(index++));
diff --git a/src/org/traccar/protocol/XexunProtocolDecoder.java b/src/org/traccar/protocol/XexunProtocolDecoder.java
index 59ac630f1..1a32dbacd 100644
--- a/src/org/traccar/protocol/XexunProtocolDecoder.java
+++ b/src/org/traccar/protocol/XexunProtocolDecoder.java
@@ -96,14 +96,14 @@ public class XexunProtocolDecoder extends BaseProtocolDecoder {
         position.setValid(parser.group(index++).compareTo("A") == 0);
 
         // Latitude
-        Double latitude = Double.valueOf(parser.group(index++));
-        latitude += Double.valueOf(parser.group(index++)) / 60;
+        Double latitude = Double.parseDouble(parser.group(index++));
+        latitude += Double.parseDouble(parser.group(index++)) / 60;
         if (parser.group(index++).compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Longitude
-        Double longitude = Double.valueOf(parser.group(index++));
-        longitude += Double.valueOf(parser.group(index++)) / 60;
+        Double longitude = Double.parseDouble(parser.group(index++));
+        longitude += Double.parseDouble(parser.group(index++)) / 60;
         String hemisphere = parser.group(index++);
         if (hemisphere != null) {
             if (hemisphere.compareTo("W") == 0) longitude = -longitude;
@@ -111,12 +111,12 @@ public class XexunProtocolDecoder extends BaseProtocolDecoder {
         position.setLongitude(longitude);
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
         String course = parser.group(index++);
         if (course != null) {
-            position.setCourse(Double.valueOf(course));
+            position.setCourse(Double.parseDouble(course));
         }
 
         // Date
@@ -145,11 +145,11 @@ public class XexunProtocolDecoder extends BaseProtocolDecoder {
             // Altitude
             String altitude = parser.group(index++);
             if (altitude != null) {
-                position.setAltitude(Double.valueOf(altitude));
+                position.setAltitude(Double.parseDouble(altitude));
             }
 
             // Power
-            position.set(Event.KEY_POWER, Double.valueOf(parser.group(index++)));
+            position.set(Event.KEY_POWER, Double.parseDouble(parser.group(index++)));
         }
 
         return position;
diff --git a/src/org/traccar/protocol/XirgoProtocolDecoder.java b/src/org/traccar/protocol/XirgoProtocolDecoder.java
index f6ae4776b..f58136a21 100644
--- a/src/org/traccar/protocol/XirgoProtocolDecoder.java
+++ b/src/org/traccar/protocol/XirgoProtocolDecoder.java
@@ -90,11 +90,11 @@ public class XirgoProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Location
-        position.setLatitude(Double.valueOf(parser.group(index++)));
-        position.setLongitude(Double.valueOf(parser.group(index++)));
-        position.setAltitude(Double.valueOf(parser.group(index++)));
-        position.setSpeed(UnitsConverter.knotsFromMph(Double.valueOf(parser.group(index++))));
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
+        position.setSpeed(UnitsConverter.knotsFromMph(Double.parseDouble(parser.group(index++))));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Additional data
         position.set(Event.KEY_SATELLITES, parser.group(index++));
diff --git a/src/org/traccar/protocol/Xt013ProtocolDecoder.java b/src/org/traccar/protocol/Xt013ProtocolDecoder.java
index 69b259ba8..a61e8b82b 100644
--- a/src/org/traccar/protocol/Xt013ProtocolDecoder.java
+++ b/src/org/traccar/protocol/Xt013ProtocolDecoder.java
@@ -93,11 +93,11 @@ public class Xt013ProtocolDecoder extends BaseProtocolDecoder {
         position.setTime(time.getTime());
 
         // Location
-        position.setLatitude(Double.valueOf(parser.group(index++)));
-        position.setLongitude(Double.valueOf(parser.group(index++)));
-        position.setSpeed(UnitsConverter.knotsFromKph(Double.valueOf(parser.group(index++))));
-        position.setCourse(Double.valueOf(parser.group(index++)));
-        position.setAltitude(Double.valueOf(parser.group(index++)));
+        position.setLatitude(Double.parseDouble(parser.group(index++)));
+        position.setLongitude(Double.parseDouble(parser.group(index++)));
+        position.setSpeed(UnitsConverter.knotsFromKph(Double.parseDouble(parser.group(index++))));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
+        position.setAltitude(Double.parseDouble(parser.group(index++)));
         position.setValid(parser.group(index++).equals("F"));
 
         // Other
diff --git a/src/org/traccar/protocol/YwtProtocolDecoder.java b/src/org/traccar/protocol/YwtProtocolDecoder.java
index 85c7465e3..9b3d2eb86 100644
--- a/src/org/traccar/protocol/YwtProtocolDecoder.java
+++ b/src/org/traccar/protocol/YwtProtocolDecoder.java
@@ -104,27 +104,27 @@ public class YwtProtocolDecoder extends BaseProtocolDecoder {
 
         // Longitude
         String hemisphere = parser.group(index++);
-        Double longitude = Double.valueOf(parser.group(index++));
+        Double longitude = Double.parseDouble(parser.group(index++));
         if (hemisphere.compareTo("W") == 0) longitude = -longitude;
         position.setLongitude(longitude);
 
         // Latitude
         hemisphere = parser.group(index++);
-        Double latitude = Double.valueOf(parser.group(index++));
+        Double latitude = Double.parseDouble(parser.group(index++));
         if (hemisphere.compareTo("S") == 0) latitude = -latitude;
         position.setLatitude(latitude);
 
         // Altitude
         String altitude = parser.group(index++);
         if (altitude != null) {
-            position.setAltitude(Double.valueOf(altitude));
+            position.setAltitude(Double.parseDouble(altitude));
         }
 
         // Speed
-        position.setSpeed(Double.valueOf(parser.group(index++)));
+        position.setSpeed(Double.parseDouble(parser.group(index++)));
 
         // Course
-        position.setCourse(Double.valueOf(parser.group(index++)));
+        position.setCourse(Double.parseDouble(parser.group(index++)));
 
         // Satellites
         int satellites = Integer.parseInt(parser.group(index++));