changes to placeholder identifier and (de)serialization

2026-10-25 21:43:49 +00:00 · 2014-03-10 15:00:35 +01:00
1 parent 10f0b01576
commit 1ebed6373e
@@ -1,21 +1,37 @@
 package com.sap.sailing.domain.common.racelog.tracking;

-
+/**
+ * Only can provide the service for a single {@code type}, e.g. on smartphones with no OSGi context.
+ * Optionally, a {@link #setFallbackService(Object) fallback} can be set.
+ * @author Fredrik Teschke
+ */
 public class SingleTypeBasedServiceFinderImpl<ServiceType> implements
 TypeBasedServiceFinder<ServiceType> {
    private final ServiceType service;
    private final String type;
+    private ServiceType fallback;

-    public SingleTypeBasedServiceFinderImpl(ServiceType service, String type) {
+    public SingleTypeBasedServiceFinderImpl(ServiceType service, ServiceType fallback, String type) {
        this.service = service;
        this.type = type;
+        this.fallback = fallback;
+    }
+
+    public SingleTypeBasedServiceFinderImpl(ServiceType service, String type) {
+        this(service, null, type);
    }

    @Override
    public ServiceType findService(String type)
            throws NoCorrespondingServiceRegisteredException {
        if (type.equals(this.type)) return service;
+        if (fallback != null) return fallback;
        throw new NoCorrespondingServiceRegisteredException("Only one service registered", type, service.getClass());
    }

+    @Override
+    public void setFallbackService(ServiceType fallback) {
+        this.fallback = fallback;
+    }
+
 }
@@ -12,7 +12,18 @@ public interface TypeBasedServiceFinder<ServiceType> {
     * Find a service that implements the <ServiceType> interface for the specified {@code type}
     * of object (e.g. type of a {@link GPSFix}).
     * @param type A {@link String} that specifies for which type the service should be registered
-     * @throws NoCorrespondingServiceRegisteredException
+     * @throws NoCorrespondingServiceRegisteredException Thrown, if no service is registered for this type.
     */
    ServiceType findService(String type) throws NoCorrespondingServiceRegisteredException;
+    
+    /**
+     * Sets a fallback service (optional), that is used if no service is registered for a {@code type}.
+     * This should be a generic service, that can deal with any {@code type}, and provides a
+     * "better-than-nothing" implementation, which will be returned instead of throwing a
+     * {@link NoCorrespondingServiceRegisteredException}.
+     * <p>
+     * This method does not need to be implemented, but can remain a stub, if no fallback behaviour
+     * is desired.
+     */
+    void setFallbackService(ServiceType fallback);
 }
@@ -11,18 +11,18 @@ import com.sap.sailing.mongodb.MongoDBService;

 public class Activator implements BundleActivator {
    private Set<ServiceRegistration<?>> registrations = new HashSet<>();
-	@Override
-	public void start(BundleContext context) throws Exception {
-	    for (CollectionNames name : CollectionNames.values())
-	        MongoDBService.INSTANCE.registerExclusively(CollectionNames.class, name.name());
-	}
+    @Override
+    public void start(BundleContext context) throws Exception {
+        for (CollectionNames name : CollectionNames.values())
+            MongoDBService.INSTANCE.registerExclusively(CollectionNames.class, name.name());
+    }

-	@Override
-	public void stop(BundleContext context) throws Exception {
-	    for (ServiceRegistration<?> reg : registrations) {
-	        reg.unregister();
-	    }
-	    registrations.clear();
-	}
+    @Override
+    public void stop(BundleContext context) throws Exception {
+        for (ServiceRegistration<?> reg : registrations) {
+            reg.unregister();
+        }
+        registrations.clear();
+    }

 }
@@ -104,6 +104,7 @@ import com.sap.sailing.domain.leaderboard.meta.LeaderboardGroupMetaLeaderboard;
 import com.sap.sailing.domain.persistence.DomainObjectFactory;
 import com.sap.sailing.domain.persistence.MongoRaceLogStoreFactory;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.persistence.racelog.tracking.impl.PlaceHolderDeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.racelog.CompetitorResults;
 import com.sap.sailing.domain.racelog.RaceLog;
 import com.sap.sailing.domain.racelog.RaceLogCourseAreaChangedEvent;
@@ -171,6 +172,7 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
        this.serviceFinderFactory = serviceFinderFactory;
        if (serviceFinderFactory != null) {
            this.deviceIdentifierServiceFinder = serviceFinderFactory.createServiceFinder(DeviceIdentifierMongoHandler.class);
+            this.deviceIdentifierServiceFinder.setFallbackService(new PlaceHolderDeviceIdentifierMongoHandler());
        } else {
            this.deviceIdentifierServiceFinder = null;
        }
@@ -1568,6 +1570,7 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
                    throws TransformationException, NoCorrespondingServiceRegisteredException {
        String deviceType = (String) deviceId.get(FieldNames.DEVICE_TYPE.name());
        Object deviceTypeId = deviceId.get(FieldNames.DEVICE_TYPE_ID.name());
-        return deviceIdentifierServiceFinder.findService(deviceType).transformBack(deviceTypeId);
+        String stringRepresentation = (String) deviceId.get(FieldNames.DEVICE_STRING_REPRESENTATION.name());
+        return deviceIdentifierServiceFinder.findService(deviceType).deserialize(deviceTypeId, deviceType, stringRepresentation);
    }
 }
@@ -90,5 +90,5 @@ public enum FieldNames {
    CONFIGURATION_CONFIG_PROCEDURES,
    
    // GPSFixes
-    DEVICE_TYPE_ID, DEVICE_ID, DEVICE_TYPE, GPSFIX_TYPE, GPSFIX,
+    DEVICE_TYPE_ID, DEVICE_ID, DEVICE_TYPE, GPSFIX_TYPE, GPSFIX, DEVICE_STRING_REPRESENTATION,
 }
@@ -48,6 +48,7 @@ import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.common.impl.Util;
+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegisteredException;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
@@ -62,6 +63,7 @@ import com.sap.sailing.domain.leaderboard.SettableScoreCorrection;
 import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
 import com.sap.sailing.domain.persistence.MongoObjectFactory;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.persistence.racelog.tracking.impl.PlaceHolderDeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.racelog.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
@@ -115,6 +117,7 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
        this.database = database;
        if (serviceFinderFactory != null) {
            this.deviceIdentifierServiceFinder = serviceFinderFactory.createServiceFinder(DeviceIdentifierMongoHandler.class);
+            this.deviceIdentifierServiceFinder.setFallbackService(new PlaceHolderDeviceIdentifierMongoHandler());
        } else {
            this.deviceIdentifierServiceFinder = null;
        }
@@ -1146,9 +1149,12 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
    				throws TransformationException, NoCorrespondingServiceRegisteredException {
        String type = device.getIdentifierType();
        DeviceIdentifierMongoHandler handler = deviceIdentifierServiceFinder.findService(type);
-    	Object deviceTypeId = handler.transformForth(device);
+        Pair<? extends Object, String> pair = handler.serialize(device);
+        type = pair.getB();
+    	Object deviceTypeId = pair.getA();
    	return new BasicDBObjectBuilder()
-    			.add(FieldNames.DEVICE_TYPE.name(), device.getIdentifierType())
-    			.add(FieldNames.DEVICE_TYPE_ID.name(), deviceTypeId).get();
+    			.add(FieldNames.DEVICE_TYPE.name(), type)
+    			.add(FieldNames.DEVICE_TYPE_ID.name(), deviceTypeId)
+    			.add(FieldNames.DEVICE_STRING_REPRESENTATION.name(), device.getStringRepresentation()).get();
    }
 }
@@ -1,29 +1,6 @@
 package com.sap.sailing.domain.persistence.racelog.tracking;

-import com.mongodb.DBObject;
-import com.sap.sailing.domain.common.racelog.tracking.TransformationHandler;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
-import com.sap.sailing.domain.racelog.RaceLog;
-import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifierSerializationHandler;

-/**
- * {@link DeviceIdentifier} objects need to be stored in the database, e.g., for
- * {@link RaceLog} persistence, when writing an object of type
- * {@link DeviceCompetitorMappingEvent}. In conjunction with a
- * {@link TypeBasedServiceFinder} it is possible to extend the set of device
- * types whose device identifiers can be stored to and loaded from the database
- * by providing specific implementations of this handler interface. In an OSGi
- * context, bundles can register implementations of this handler interface with
- * the OSGi service registry to extend the set of supported device types without
- * modifications to the existing code base.
- * 
- * The resulting {@link Object} is expected to be either a simple {@link Object}
- * that can serialized, or a structured {@link DBObject}.
- * 
- * @author Fredrik Teschke
- * 
- */
-public interface DeviceIdentifierMongoHandler extends
-TransformationHandler<DeviceIdentifier, Object> {
+public interface DeviceIdentifierMongoHandler extends DeviceIdentifierSerializationHandler<Object> {
 }
@@ -0,0 +1,9 @@
+package com.sap.sailing.domain.persistence.racelog.tracking.impl;
+
+import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelog.tracking.impl.PlaceHolderDeviceIdentifierSerializationHandler;
+
+public class PlaceHolderDeviceIdentifierMongoHandler extends PlaceHolderDeviceIdentifierSerializationHandler
+implements DeviceIdentifierMongoHandler {
+
+}
@@ -24,7 +24,7 @@ import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
 import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
 import com.sap.sailing.domain.racelog.tracking.test.mock.MockDeviceAndSessioinIdentifierWithGPSFixesDeserializer;
-import com.sap.sailing.domain.racelog.tracking.test.mock.MockServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.Track;
 import com.sap.sailing.domain.tracking.impl.GPSFixMovingImpl;
@@ -34,7 +34,7 @@ import com.sap.sailing.server.impl.RacingEventServiceImpl;

 public class AbstractGPSFixStoreTest {
    protected RacingEventService service;
-    protected final  MockServiceFinderFactory serviceFinderFactory = new MockServiceFinderFactory();
+    protected final  MockSmartphoneImeiServiceFinderFactory serviceFinderFactory = new MockSmartphoneImeiServiceFinderFactory();
    DeviceAndSessionIdentifierWithGPSFixesDeserializer deserializer =
            new MockDeviceAndSessioinIdentifierWithGPSFixesDeserializer();
    protected final DeviceIdentifier device = new SmartphoneImeiIdentifier("a");
@@ -46,7 +46,7 @@ import com.sap.sailing.domain.racelog.RaceLogEventFactory;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
 import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
-import com.sap.sailing.domain.racelog.tracking.test.mock.MockServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
 import com.sap.sailing.domain.racelogtracking.RaceLogTrackingAdapter;
 import com.sap.sailing.domain.racelogtracking.impl.RaceLogTrackingAdapterFactoryImpl;
 import com.sap.sailing.domain.tracking.RacesHandle;
@@ -73,7 +73,7 @@ public class CreateAndTrackWithRaceLogTest {

    @Before
    public void setup() {
-        service = new RacingEventServiceImpl(true, new MockServiceFinderFactory());
+        service = new RacingEventServiceImpl(true, new MockSmartphoneImeiServiceFinderFactory());
        gpsFixStore = service.getGPSFixStore();
        service.getMongoObjectFactory().getDatabase().dropDatabase();
        author = service.getServerAuthor();
@@ -145,6 +145,7 @@ public class CreateAndTrackWithRaceLogTest {
        CourseBase course = new CourseDataImpl("test");
        course.addWaypoint(0, new WaypointImpl(new MarkImpl("mark")));
        raceLog.add(factory.createCourseDesignChangedEvent(t(), author, 0, course));
+        raceLog.add(factory.createRegisterCompetitorEvent(t(), author, 0, comp1));

        //start tracking
        raceLog.add(factory.createStartTrackingEvent(t(), author, 0));
@@ -24,14 +24,16 @@ import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.impl.GPSFixImpl;
 import com.sap.sailing.domain.tracking.impl.GPSFixMovingImpl;
 import com.sap.sailing.server.gateway.serialization.impl.DeviceAndSessionIdentifierWithGPSFixesSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.DeviceIdentifierJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.GPSFixMovingNmeaDTOJsonSerializer;
-import com.sap.sailing.server.gateway.serialization.impl.SmartphoneImeiIdentifierJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandler;

 public class PostFixes extends AbstractJsonOverHttpTest {
    protected static final SmartphoneImeiIdentifier device = new SmartphoneImeiIdentifier("a");

    private final DeviceAndSessionIdentifierWithGPSFixesSerializer<SmartphoneImeiIdentifier, GPSFixMoving> fixSerializer =
-            new DeviceAndSessionIdentifierWithGPSFixesSerializer<>(new SmartphoneImeiIdentifierJsonSerializer(), new GPSFixMovingNmeaDTOJsonSerializer());
+            new DeviceAndSessionIdentifierWithGPSFixesSerializer<>(DeviceIdentifierJsonSerializer.create(
+                    new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE), new GPSFixMovingNmeaDTOJsonSerializer());

            private void recordFix(GPSFixMoving... fix) throws IOException {
                String request = fixSerializer.serialize(
@@ -1,13 +1,16 @@
 package com.sap.sailing.domain.racelog.tracking.test.mock;

+import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
 import com.sap.sailing.server.gateway.deserialization.impl.DeviceAndSessionIdentifierWithGPSFixesDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.DeviceIdentifierJsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandler;

 public class MockDeviceAndSessioinIdentifierWithGPSFixesDeserializer extends
 DeviceAndSessionIdentifierWithGPSFixesDeserializer {

    public MockDeviceAndSessioinIdentifierWithGPSFixesDeserializer() {
        super(new MockGPSFixJsonServiceFinder(),
-                new MockSmartphoneImeiJsonServiceFinder());
+                DeviceIdentifierJsonDeserializer.create(new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE));
    }

 }
@@ -0,0 +1,19 @@
+package com.sap.sailing.domain.racelog.tracking.test.mock;
+
+import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegisteredException;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
+
+public class MockEmptyServiceFinder<ServiceType> implements TypeBasedServiceFinder<ServiceType> {
+    private ServiceType fallback;
+
+    @Override
+    public ServiceType findService(String type) throws NoCorrespondingServiceRegisteredException {
+        return fallback;
+    }
+
+    @Override
+    public void setFallbackService(ServiceType fallback) {
+        this.fallback = fallback;
+    }
+
+}
@@ -0,0 +1,20 @@
+package com.sap.sailing.domain.racelog.tracking.test.mock;
+
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
+
+/**
+ * A simplified implementation of the {@link TypeBasedServiceFinder} interface that, when the device type
+ * {@link SmartphoneImeiIdentifier#TYPE} is requested, returns a specific handler that was passed to this object's
+ * constructor.
+ * 
+ * @author Fredrik Teschke
+ *
+ */
+public class MockEmptyServiceFinderFactory implements TypeBasedServiceFinderFactory {
+    @Override
+    public <ServiceT> TypeBasedServiceFinder<ServiceT> createServiceFinder(Class<ServiceT> clazz) {
+        return new MockEmptyServiceFinder<ServiceT>();
+    }
+}
@@ -14,4 +14,8 @@ public class MockGPSFixJsonServiceFinder implements TypeBasedServiceFinder<GPSFi
        }
        return null;
    }
+
+    @Override
+    public void setFallbackService(GPSFixJsonHandler fallback) {
+    }
 }
@@ -19,4 +19,8 @@ public class MockGPSFixMongoServiceFinder implements TypeBasedServiceFinder<GPSF
        if (fixType.equals(GPSFixImpl.class.getName())) return new GPSFixMongoHandlerImpl(mof, dof);
        return null;
    }
+
+    @Override
+    public void setFallbackService(GPSFixMongoHandler fallback) {
+    }
 }
@@ -3,7 +3,7 @@ package com.sap.sailing.domain.racelog.tracking.test.mock;
 import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandlerImpl;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandler;

 /**
 * A simplified implementation of the {@link TypeBasedServiceFinder} interface that, when the device type
@@ -14,10 +14,17 @@ import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.Smartp
 *
 */
 public class MockSmartphoneImeiJsonServiceFinder implements TypeBasedServiceFinder<DeviceIdentifierJsonHandler> {
-    private final SmartphoneImeiJsonHandlerImpl handler = new SmartphoneImeiJsonHandlerImpl();
+    private final SmartphoneImeiJsonHandler handler = new SmartphoneImeiJsonHandler();
+    private DeviceIdentifierJsonHandler fallback;

    @Override
    public DeviceIdentifierJsonHandler findService(String deviceType) {
-        return handler;
+        if (deviceType.equals(SmartphoneImeiIdentifier.TYPE)) return handler;
+        return fallback;
+    }
+
+    @Override
+    public void setFallbackService(DeviceIdentifierJsonHandler fallback) {
+        this.fallback = fallback;
    }
 }
@@ -3,7 +3,7 @@ package com.sap.sailing.domain.racelog.tracking.test.mock;
 import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
-import com.sap.sailing.domain.racelogtracking.impl.SmartphoneImeiMongoHandlerImpl;
+import com.sap.sailing.domain.racelogtracking.impl.SmartphoneImeiMongoHandler;

 /**
 * A simplified implementation of the {@link TypeBasedServiceFinder} interface that, when the device type
@@ -14,10 +14,17 @@ import com.sap.sailing.domain.racelogtracking.impl.SmartphoneImeiMongoHandlerImp
 *
 */
 public class MockSmartphoneImeiMongoServiceFinder implements TypeBasedServiceFinder<DeviceIdentifierMongoHandler> {
-    private final SmartphoneImeiMongoHandlerImpl handler = new SmartphoneImeiMongoHandlerImpl();
+    private final SmartphoneImeiMongoHandler handler = new SmartphoneImeiMongoHandler();
+    private DeviceIdentifierMongoHandler fallback;

    @Override
    public DeviceIdentifierMongoHandler findService(String deviceType) {
-        return handler;
+        if (deviceType.equals(SmartphoneImeiIdentifier.TYPE)) return handler;
+        return fallback;
+    }
+
+    @Override
+    public void setFallbackService(DeviceIdentifierMongoHandler fallback) {
+        this.fallback = fallback;
    }
 }
@@ -19,10 +19,10 @@ import com.sap.sailing.server.gateway.serialization.racelog.tracking.GPSFixJsonH
 * @author Fredrik Teschke
 *
 */
-public class MockServiceFinderFactory implements TypeBasedServiceFinderFactory {
+public class MockSmartphoneImeiServiceFinderFactory implements TypeBasedServiceFinderFactory {
    Map<Class<?>, TypeBasedServiceFinder<?>> serviceFinders = new HashMap<Class<?>, TypeBasedServiceFinder<?>>();

-    public MockServiceFinderFactory() {
+    public MockSmartphoneImeiServiceFinderFactory() {
        serviceFinders.put(DeviceIdentifierMongoHandler.class, new MockSmartphoneImeiMongoServiceFinder());
        serviceFinders.put(DeviceIdentifierJsonHandler.class, new MockSmartphoneImeiJsonServiceFinder());
        serviceFinders.put(GPSFixMongoHandler.class, new MockGPSFixMongoServiceFinder());
@@ -12,5 +12,6 @@ import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 *
 */
 public interface PingDeviceIdentifier extends DeviceIdentifier {
+    public static final String TYPE = "PING";
    UUID getId();
 }
@@ -8,7 +8,6 @@ import com.sap.sailing.domain.base.SharedDomainFactory;
 public class PingDeviceIdentifierImpl implements PingDeviceIdentifier {
    private static final long serialVersionUID = -4049961972156611640L;

-    public static final String TYPE = "PING";
    
    private final UUID id;
    
@@ -29,7 +29,8 @@ import com.sap.sailing.server.gateway.serialization.impl.GPSFixMovingNmeaDTOJson
 import com.sap.sailing.server.gateway.serialization.impl.GPSFixNmeaDTOJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.GPSFixJsonHandler;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandlerImpl;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.GPSFixJsonHandlerImpl;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandler;

 public class Activator implements BundleActivator {
 	private static final Logger logger = Logger.getLogger(Activator.class.getName());
@@ -50,10 +51,11 @@ public class Activator implements BundleActivator {
    
    @Override
    public void start(BundleContext context) throws Exception {
-        registrations.add(context.registerService(DeviceIdentifierMongoHandler.class, new SmartphoneImeiMongoHandlerImpl(), getDict(SmartphoneImeiIdentifier.TYPE)));
-        registrations.add(context.registerService(DeviceIdentifierJsonHandler.class, new SmartphoneImeiJsonHandlerImpl(), getDict(SmartphoneImeiIdentifier.TYPE)));
+        registrations.add(context.registerService(DeviceIdentifierMongoHandler.class, new SmartphoneImeiMongoHandler(), getDict(SmartphoneImeiIdentifier.TYPE)));
+        registrations.add(context.registerService(DeviceIdentifierJsonHandler.class, new SmartphoneImeiJsonHandler(), getDict(SmartphoneImeiIdentifier.TYPE)));
        
-        registrations.add(context.registerService(DeviceIdentifierMongoHandler.class, new PingDeviceMongoHandlerImpl(), getDict(PingDeviceIdentifierImpl.TYPE)));
+        registrations.add(context.registerService(DeviceIdentifierMongoHandler.class, new PingDeviceIdentifierMongoHandler(), getDict(PingDeviceIdentifierImpl.TYPE)));
+        registrations.add(context.registerService(DeviceIdentifierJsonHandler.class, new PingDeviceIdentifierJsonHandler(), getDict(PingDeviceIdentifierImpl.TYPE)));
        
        registerGPSFixJsonService(context, new GPSFixJsonDeserializer(), new GPSFixJsonSerializer(), GPSFixJsonDeserializer.TYPE);
        registerGPSFixJsonService(context, new GPSFixMovingJsonDeserializer(), new GPSFixMovingJsonSerializer(), GPSFixMovingJsonDeserializer.TYPE);
@@ -0,0 +1,8 @@
+package com.sap.sailing.domain.racelogtracking.impl;
+
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
+
+public class PingDeviceIdentifierJsonHandler extends PingDeviceIdentifierSerializationHandler 
+implements DeviceIdentifierJsonHandler {
+
+}
@@ -0,0 +1,8 @@
+package com.sap.sailing.domain.racelogtracking.impl;
+
+import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+
+public class PingDeviceIdentifierMongoHandler extends PingDeviceIdentifierSerializationHandler
+implements DeviceIdentifierMongoHandler {
+
+}
@@ -2,13 +2,14 @@ package com.sap.sailing.domain.racelogtracking.impl;

 import java.util.UUID;

+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
-import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifierSerializationHandler;
 import com.sap.sailing.domain.racelogtracking.PingDeviceIdentifier;
 import com.sap.sailing.domain.racelogtracking.PingDeviceIdentifierImpl;

-public class PingDeviceMongoHandlerImpl implements DeviceIdentifierMongoHandler {
+public class PingDeviceIdentifierSerializationHandler implements DeviceIdentifierSerializationHandler<Object> {
    private PingDeviceIdentifier castIdentifier(DeviceIdentifier identifier) throws TransformationException {
        if (!(identifier instanceof PingDeviceIdentifier))
            throw new TransformationException("Expected a PingDeviceIdentifier, got instead: " + identifier);
@@ -16,12 +17,12 @@ public class PingDeviceMongoHandlerImpl implements DeviceIdentifierMongoHandler
    }

    @Override
-    public Object transformForth(DeviceIdentifier deviceIdentifier) throws TransformationException {
-        return castIdentifier(deviceIdentifier).getId().toString();
+    public Pair<String, String> serialize(DeviceIdentifier deviceIdentifier) throws TransformationException {
+        return new Pair<String, String>(castIdentifier(deviceIdentifier).getId().toString(), PingDeviceIdentifier.TYPE);
    }

    @Override
-    public DeviceIdentifier transformBack(Object input) {
+    public DeviceIdentifier deserialize(Object input, String type, String stringRep) {
        return new PingDeviceIdentifierImpl(UUID.fromString((String) input));
    }
 }
@@ -0,0 +1,9 @@
+package com.sap.sailing.domain.racelogtracking.impl;
+
+import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelog.tracking.impl.SmartphoneImeiSerializationHandler;
+
+public class SmartphoneImeiMongoHandler extends SmartphoneImeiSerializationHandler
+implements DeviceIdentifierMongoHandler {
+
+}
@@ -15,6 +15,7 @@ import com.sap.sailing.server.gateway.AbstractJsonPostServlet;
 import com.sap.sailing.server.gateway.HttpExceptionWithMessage;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.impl.DeviceAndSessionIdentifierWithGPSFixesDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.DeviceIdentifierJsonDeserializer;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.GPSFixJsonHandler;
@@ -31,7 +32,8 @@ public class RecordFixesPostServlet extends
                GPSFixJsonHandler.class);
        TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder = getServiceFinderFactory()
                .createServiceFinder(DeviceIdentifierJsonHandler.class);
-        deserializer = new DeviceAndSessionIdentifierWithGPSFixesDeserializer(fixServiceFinder, deviceServiceFinder);
+        deserializer = new DeviceAndSessionIdentifierWithGPSFixesDeserializer(fixServiceFinder,
+                new DeviceIdentifierJsonDeserializer(deviceServiceFinder));
    }

    @Override
@@ -0,0 +1,29 @@
+package com.sap.sailing.domain.racelog.tracking;
+
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+
+/**
+ * Handles serialization and deserialization of {@link DeviceIdentifier}s.
+ * Additional information is passed around to enable fallback mechanisms (see {@link PlaceHolderDeviceIdentifier})
+ * in case no appropriate handler for a {@code type} is registered.
+ * 
+ * @author Fredrik Teschke
+ * 
+ */
+public interface DeviceIdentifierSerializationHandler<T> {
+    /**
+     * Serialize the identifier. Also returns additional information, in case this is a fallback
+     * serializer, that actually returns some generic serializiation (e.g. {@link PlaceHolderDeviceIdentifier}).
+     * 
+     * @param deviceIdentifier
+     * @return A pair consisting of the {@code serialized identifier} and the {@code device type}.
+     */
+    Pair<? extends T, String> serialize(DeviceIdentifier deviceIdentifier) throws TransformationException;
+    
+    /**
+     * Deserialize the identifier. In case this is a fallback deserializer (e.g. for {@link PlaceHolderDeviceIdentifier}),
+     * additional information such as {@code type} and {@code stringRepresentation} is passed in.
+     */
+    DeviceIdentifier deserialize(T serialized, String type, String stringRepresentation) throws TransformationException;
+}
@@ -3,6 +3,7 @@ package com.sap.sailing.domain.racelog.tracking;
 import com.sap.sailing.domain.base.IsManagedBySharedDomainFactory;
 import com.sap.sailing.domain.base.SharedDomainFactory;

+
 /**
 * If the proper identifier cannot be resolved, for example because the OSGi context is not available
 * on the smartphone receiving the {@code DevicieIdentifier} via its {@code RaceLog}, then this
@@ -14,6 +15,7 @@ import com.sap.sailing.domain.base.SharedDomainFactory;
 */
 public class PlaceHolderDeviceIdentifier implements DeviceIdentifier {
    private static final long serialVersionUID = 8642469389180406246L;
+    public static final String TYPE = "PLACEHOLDER";
    
    private final String type;
    private final String stringRepresentation;
@@ -38,4 +40,13 @@ public class PlaceHolderDeviceIdentifier implements DeviceIdentifier {
        return stringRepresentation;
    }

+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof DeviceIdentifier) {
+            DeviceIdentifier other = (DeviceIdentifier) obj;
+            return type.equals(other.getIdentifierType()) &&
+                    stringRepresentation.equals(other.getStringRepresentation());
+        }
+        return false;
+    }
 }
@@ -0,0 +1,34 @@
+package com.sap.sailing.domain.racelog.tracking.impl;
+
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifierSerializationHandler;
+import com.sap.sailing.domain.racelog.tracking.PlaceHolderDeviceIdentifier;
+
+/**
+ * Can be used as the last option, if no other service is available when trying to load an identifier
+ * from, or save it to the database.
+ * The handler itself doesn't do much, but relies on the {@code type} and {@code stringRepresentation}
+ * to be saved and loaded. This way, the {@code stringRepresentation} is always available, even if the
+ * appropriate persistence service was available when writing, and is now unavailable when loading.
+ * 
+ * @author Fredrik Teschke
+ *
+ */
+public class PlaceHolderDeviceIdentifierSerializationHandler implements DeviceIdentifierSerializationHandler<Object> {
+
+    @Override
+    public DeviceIdentifier deserialize(Object object, String type, String stringRepresentation) throws TransformationException {
+        if (type.equals(PlaceHolderDeviceIdentifier.TYPE)) {
+            type = (String) object;
+        }
+        return new PlaceHolderDeviceIdentifier(type, stringRepresentation);
+    }
+
+    @Override
+    public Pair<String, String> serialize(DeviceIdentifier object) throws TransformationException {
+        return new Pair<String, String>(object.getIdentifierType(), PlaceHolderDeviceIdentifier.TYPE);
+    }
+
+}
@@ -1,11 +1,12 @@
-package com.sap.sailing.domain.racelogtracking.impl;
+package com.sap.sailing.domain.racelog.tracking.impl;

+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
-import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifierSerializationHandler;
 import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;

-public class SmartphoneImeiMongoHandlerImpl implements DeviceIdentifierMongoHandler {
+public class SmartphoneImeiSerializationHandler implements DeviceIdentifierSerializationHandler<Object> {
    private SmartphoneImeiIdentifier castIdentifier(DeviceIdentifier identifier) throws TransformationException {
        if (!(identifier instanceof SmartphoneImeiIdentifier))
            throw new TransformationException("Expected a SmartphoneImeiIdentifier, got instead: " + identifier);
@@ -13,12 +14,12 @@ public class SmartphoneImeiMongoHandlerImpl implements DeviceIdentifierMongoHand
    }

    @Override
-    public Object transformForth(DeviceIdentifier deviceIdentifier) throws TransformationException {
-        return castIdentifier(deviceIdentifier).getImei();
+    public Pair<String, String> serialize(DeviceIdentifier deviceIdentifier) throws TransformationException {
+        return new Pair<String, String>(castIdentifier(deviceIdentifier).getImei(), SmartphoneImeiIdentifier.TYPE);
    }

    @Override
-    public DeviceIdentifier transformBack(Object input) {
+    public DeviceIdentifier deserialize(Object input, String type, String stringRep) {
        return new SmartphoneImeiIdentifier((String) input);
    }
 }
@@ -16,7 +16,7 @@ import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.common.RegattaIdentifier;
 import com.sap.sailing.domain.common.ScoreCorrectionProvider;
 import com.sap.sailing.domain.racelog.RaceLogStore;
-import com.sap.sailing.domain.racelog.tracking.test.mock.MockServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
 import com.sap.sailing.domain.racelogtracking.RaceLogTrackingAdapterFactory;
 import com.sap.sailing.domain.racelogtracking.impl.RaceLogTrackingAdapterFactoryImpl;
 import com.sap.sailing.domain.swisstimingadapter.RaceSpecificMessageLoader;
@@ -41,7 +41,7 @@ public class SailingServiceImplMock extends SailingServiceImpl {
    
    public SailingServiceImplMock() {
        super();
-        service = new RacingEventServiceImpl(true, new MockServiceFinderFactory());
+        service = new RacingEventServiceImpl(true, new MockSmartphoneImeiServiceFinderFactory());
    }

    @Override
@@ -0,0 +1,135 @@
+package com.sap.sailing.mongodb.test;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.net.UnknownHostException;
+import java.util.UUID;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.mongodb.MongoException;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.DomainFactory;
+import com.sap.sailing.domain.base.impl.CompetitorImpl;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.impl.Util;
+import com.sap.sailing.domain.common.impl.Util.Triple;
+import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegisteredException;
+import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinderFactory;
+import com.sap.sailing.domain.persistence.PersistenceFactory;
+import com.sap.sailing.domain.persistence.impl.DomainObjectFactoryImpl;
+import com.sap.sailing.domain.persistence.impl.MongoObjectFactoryImpl;
+import com.sap.sailing.domain.persistence.impl.MongoRaceLogStoreImpl;
+import com.sap.sailing.domain.racelog.RaceLog;
+import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
+import com.sap.sailing.domain.racelog.RaceLogEventFactory;
+import com.sap.sailing.domain.racelog.RaceLogIdentifier;
+import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
+import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.PlaceHolderDeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockEmptyServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
+
+public class StoreAndLoadDeviceIdentifierTest extends AbstractMongoDBTest {
+    public StoreAndLoadDeviceIdentifierTest() throws UnknownHostException, MongoException {
+        super();
+    }
+
+    protected static final String group = "group";
+    protected static final String column = "column";
+    protected static final String fleet = "fleet";
+    protected final RaceLogEventAuthor author = new RaceLogEventAuthorImpl("author", 0);
+    protected RaceLogIdentifier logIdentifier;
+
+    protected MongoObjectFactoryImpl mongoFactory;
+    protected DomainObjectFactoryImpl domainFactory;
+    protected RaceLog raceLog;
+    
+    private TimePoint now() {
+        return MillisecondsTimePoint.now();
+    }
+    
+    @Before
+    public void setup() throws UnknownHostException, MongoException, InterruptedException {
+        dropTestDB();
+
+        logIdentifier = mock(RaceLogIdentifier.class);
+        Triple<String, String, String> triple = new Triple<String, String, String>("a", "b", UUID.randomUUID().toString());
+        when(logIdentifier.getIdentifier()).thenReturn(triple);
+        when(logIdentifier.getDeprecatedIdentifier()).thenReturn("");
+    }
+    
+    private RaceLog loadRaceLog() {        
+        return new MongoRaceLogStoreImpl(mongoFactory, domainFactory).getRaceLog(logIdentifier, true);
+    }
+    
+    private void createFactories(TypeBasedServiceFinderFactory factory) {
+        mongoFactory = (MongoObjectFactoryImpl) PersistenceFactory.INSTANCE
+                .getMongoObjectFactory(getMongoService(), factory);
+        domainFactory = (DomainObjectFactoryImpl) PersistenceFactory.INSTANCE
+                .getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE, factory);
+
+        raceLog = loadRaceLog();
+    }
+    
+    private DeviceIdentifier storeAndLoad(DeviceIdentifier device, TypeBasedServiceFinderFactory forStoring, TypeBasedServiceFinderFactory forLoading) {
+        createFactories(forStoring);
+        Competitor c = new CompetitorImpl("a", "a", null, null, null);
+        
+        raceLog.add(RaceLogEventFactory.INSTANCE.createDeviceCompetitorMappingEvent(now(), author, device,
+                c, 0, now(), now()));
+        
+        createFactories(forLoading);
+        
+        RaceLog loadedRaceLog = loadRaceLog();
+        loadedRaceLog.lockForRead();
+        assertEquals(1, Util.size(loadedRaceLog.getRawFixes()));
+        DeviceCompetitorMappingEvent mapping = (DeviceCompetitorMappingEvent) loadedRaceLog.getRawFixes().iterator().next();
+        loadedRaceLog.unlockAfterRead();
+        
+        return mapping.getDevice();
+    }
+    
+    @Test
+    public void testNormal() throws TransformationException, NoCorrespondingServiceRegisteredException {
+        TypeBasedServiceFinderFactory factory = new MockSmartphoneImeiServiceFinderFactory();
+
+        DeviceIdentifier smartphone = new SmartphoneImeiIdentifier("abc");
+        DeviceIdentifier loaded = storeAndLoad(smartphone, factory, factory);
+        
+        assertEquals(smartphone, loaded);
+    }
+    
+    @Test
+    public void testNoAppropriateDeserializer() throws TransformationException, NoCorrespondingServiceRegisteredException {
+        TypeBasedServiceFinderFactory forStoring = new MockSmartphoneImeiServiceFinderFactory();
+        TypeBasedServiceFinderFactory forLoading = new MockEmptyServiceFinderFactory();
+
+        DeviceIdentifier smartphone = new SmartphoneImeiIdentifier("abc");
+        DeviceIdentifier loaded = storeAndLoad(smartphone, forStoring, forLoading);
+        
+        assertTrue(loaded instanceof PlaceHolderDeviceIdentifier);
+        assertEquals(smartphone.getIdentifierType(), loaded.getIdentifierType());
+        assertEquals(smartphone.getStringRepresentation(), loaded.getStringRepresentation());
+    }
+    
+    @Test
+    public void testNoAppropriateSerializer() throws TransformationException, NoCorrespondingServiceRegisteredException {
+        TypeBasedServiceFinderFactory forLoading = new MockSmartphoneImeiServiceFinderFactory();
+        TypeBasedServiceFinderFactory forStoring = new MockEmptyServiceFinderFactory();
+
+        DeviceIdentifier smartphone = new SmartphoneImeiIdentifier("abc");
+        DeviceIdentifier loaded = storeAndLoad(smartphone, forStoring, forLoading);
+        
+        assertTrue(loaded instanceof PlaceHolderDeviceIdentifier);
+        assertEquals(smartphone.getIdentifierType(), loaded.getIdentifierType());
+        assertEquals(smartphone.getStringRepresentation(), loaded.getStringRepresentation());
+    }
+}
@@ -50,15 +50,15 @@ import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
 import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
-import com.sap.sailing.domain.racelog.tracking.test.mock.MockServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;

 public class StoreAndLoadRaceLogEventsTest extends AbstractMongoDBTest {

    protected MongoObjectFactoryImpl mongoFactory = (MongoObjectFactoryImpl) PersistenceFactory.INSTANCE
-            .getMongoObjectFactory(getMongoService(), new MockServiceFinderFactory());
+            .getMongoObjectFactory(getMongoService(), new MockSmartphoneImeiServiceFinderFactory());
    protected DomainObjectFactoryImpl domainFactory = (DomainObjectFactoryImpl) PersistenceFactory.INSTANCE
            .getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE,
-            		new MockServiceFinderFactory());
+            		new MockSmartphoneImeiServiceFinderFactory());
    protected RaceLogEventRestoreFactory eventFactory = RaceLogEventRestoreFactory.INSTANCE;

    protected RaceLogIdentifier logIdentifier;
@@ -35,7 +35,7 @@ import com.sap.sailing.domain.racelog.impl.RaceLogImpl;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
 import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
-import com.sap.sailing.domain.racelog.tracking.test.mock.MockServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.impl.DynamicGPSFixMovingTrackImpl;
@@ -56,7 +56,7 @@ public class StoreGPSFixTrackTest extends AbstractMongoDBTest {
    
    @Test
    public void testStoreAndLoadFixes() throws TransformationException, NoCorrespondingServiceRegisteredException {
-    	TypeBasedServiceFinderFactory factory = new MockServiceFinderFactory();
+    	TypeBasedServiceFinderFactory factory = new MockSmartphoneImeiServiceFinderFactory();
    	RaceLogEventAuthor author = new RaceLogEventAuthorImpl("author", 0);
    	Competitor comp = DomainFactory.INSTANCE.getOrCreateCompetitor("comp", "comp", null, null, null);
    	Mark mark = DomainFactory.INSTANCE.getOrCreateMark("mark");
@@ -15,50 +15,44 @@ import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.TypeBasedJsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.GPSFixJsonHandler;

 public class DeviceAndSessionIdentifierWithGPSFixesDeserializer
-    implements JsonDeserializer<Triple<DeviceIdentifier, Serializable, List<GPSFix>>> {
+implements JsonDeserializer<Triple<DeviceIdentifier, Serializable, List<GPSFix>>> {

-    public static final String FIELD_DEVICE_ID = "deviceId";
+    public static final String FIELD_DEVICE = "device";
    public static final String FIELD_SESSION_UUID = "sessionId";
    public static final String FIELD_FIXES = "fixes";

    private final TypeBasedServiceFinder<GPSFixJsonHandler> fixServiceFinder;
-    private final TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder;
+    private final JsonDeserializer<DeviceIdentifier> deviceDeserializer;

    public DeviceAndSessionIdentifierWithGPSFixesDeserializer(
            TypeBasedServiceFinder<GPSFixJsonHandler> fixServiceFinder,
-            TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
+            JsonDeserializer<DeviceIdentifier> deviceDeserializer) {
        this.fixServiceFinder = fixServiceFinder;
-        this.deviceServiceFinder = deviceServiceFinder;
+        this.deviceDeserializer = deviceDeserializer;
    }

    @Override
    public Triple<DeviceIdentifier, Serializable, List<GPSFix>> deserialize(JSONObject object) throws JsonDeserializationException {
-        JSONObject deviceIdJson = Helpers.getNestedObjectSafe(object, FIELD_DEVICE_ID);
-        DeviceIdentifier deviceId;
-		try {
-			deviceId = TypeBasedJsonDeserializer.deserialize(deviceServiceFinder, deviceIdJson);
-		} catch (TransformationException e) {
-			throw new JsonDeserializationException(e);
-		}
+        JSONObject deviceIdObject = Helpers.toJSONObjectSafe(object.get(FIELD_DEVICE));
+        DeviceIdentifier deviceId = deviceDeserializer.deserialize(deviceIdObject);

        Object sessionObject = object.get(FIELD_SESSION_UUID);
        Serializable sessionId = sessionObject == null ?
-        		null : Helpers.tryUuidConversion(((Serializable) sessionObject));
+                null : Helpers.tryUuidConversion(((Serializable) sessionObject));

        JSONArray fixesJson = Helpers.getNestedArraySafe(object, FIELD_FIXES);
        List<GPSFix> fixes = new ArrayList<GPSFix>();
        for (Object fixObject : fixesJson) {
            JSONObject fixJson = (JSONObject) fixObject;
            GPSFix fix;
-			try {
-				fix = TypeBasedJsonDeserializer.deserialize(fixServiceFinder, fixJson);
-			} catch (TransformationException e) {
-				throw new JsonDeserializationException(e);
-			}
+            try {
+                fix = TypeBasedJsonDeserializer.deserialize(fixServiceFinder, fixJson);
+            } catch (TransformationException e) {
+                throw new JsonDeserializationException(e);
+            }
            fixes.add(fix);
        }

@@ -0,0 +1,47 @@
+package com.sap.sailing.server.gateway.deserialization.impl;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.common.racelog.tracking.SingleTypeBasedServiceFinderImpl;
+import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.PlaceHolderDeviceIdentifier;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.PlaceHolderDeviceIdentifierJsonHandler;
+
+public class DeviceIdentifierJsonDeserializer implements JsonDeserializer<DeviceIdentifier> {
+
+    public static final String FIELD_DEVICE_ID = "id";
+    public static final String FIELD_DEVICE_TYPE = "type";
+    public static final String FIELD_STRING_REPRESENTATION = "stringRepresentation";
+
+    private final TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder;
+    
+    /**
+     * Create a deserializer for a single type, with fallback to {@link PlaceHolderDeviceIdentifier}.
+     */
+    public static DeviceIdentifierJsonDeserializer create(DeviceIdentifierJsonHandler singleHandler, String type) {
+        return new DeviceIdentifierJsonDeserializer(new SingleTypeBasedServiceFinderImpl<DeviceIdentifierJsonHandler>(singleHandler,
+                new PlaceHolderDeviceIdentifierJsonHandler(), type));
+    }
+
+    public DeviceIdentifierJsonDeserializer(TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
+        this.deviceServiceFinder = deviceServiceFinder;
+    }
+
+    @Override
+    public DeviceIdentifier deserialize(JSONObject object) throws JsonDeserializationException {
+        Object deviceIdObject = object.get(FIELD_DEVICE_ID);
+        String deviceType = (String) object.get(FIELD_DEVICE_TYPE);
+        String deviceStringRep = (String) object.get(FIELD_STRING_REPRESENTATION);
+        try {
+            return deviceServiceFinder.findService(deviceType).deserialize(deviceIdObject, deviceType, deviceStringRep);
+        } catch (TransformationException e) {
+            throw new JsonDeserializationException(e);
+        }
+    }
+
+}
@@ -1,20 +0,0 @@
-package com.sap.sailing.server.gateway.deserialization.impl;
-
-import org.json.simple.JSONObject;
-
-import com.sap.sailing.domain.racelog.tracking.PlaceHolderDeviceIdentifier;
-import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
-import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
-import com.sap.sailing.server.gateway.deserialization.TypeBasedJsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.impl.DeviceIdentifierBaseJsonSerializer;
-
-public class PlaceHolderDeviceIdentifierJsonDeserializer implements JsonDeserializer<PlaceHolderDeviceIdentifier> {
-    @Override
-    public PlaceHolderDeviceIdentifier deserialize(JSONObject object) throws JsonDeserializationException {
-        String type = (String) object.get(TypeBasedJsonDeserializer.FIELD_TYPE);
-        String stringRepresentation = (String) object.get(DeviceIdentifierBaseJsonSerializer.FIELD_STRING_REPRESENTATION);
-        
-        return new PlaceHolderDeviceIdentifier(type, stringRepresentation);
-    }
-
-}
@@ -6,20 +6,18 @@ import org.json.simple.JSONObject;

 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.common.TimePoint;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
 import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public class RaceLogDeviceCompetitorMappingEventDeserializer extends
 		RaceLogDeviceMappingEventDeserializer<Competitor> {
 	public RaceLogDeviceCompetitorMappingEventDeserializer(
 			JsonDeserializer<Competitor> competitorDeserializer,
-			TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
-		super(competitorDeserializer, deviceServiceFinder);
+			JsonDeserializer<DeviceIdentifier> deviceDeserializer) {
+		super(competitorDeserializer, deviceDeserializer);
 	}

 	@Override
@@ -9,7 +9,6 @@ import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.WithID;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
 import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
@@ -17,41 +16,34 @@ import com.sap.sailing.server.gateway.deserialization.JsonDeserializationExcepti
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.impl.Helpers;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogDeviceMappingEventSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public abstract class RaceLogDeviceMappingEventDeserializer<ItemT extends WithID>
-	extends BaseRaceLogEventDeserializer {
-	protected final TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder;
+extends BaseRaceLogEventDeserializer {
+    protected final JsonDeserializer<DeviceIdentifier> deviceDeserializer;

-	public RaceLogDeviceMappingEventDeserializer(
-			JsonDeserializer<Competitor> competitorDeserializer,
-			TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
-		super(competitorDeserializer);
-		this.deviceServiceFinder = deviceServiceFinder;
-	}
-	
-	protected abstract RaceLogEvent furtherDeserialize(JSONObject itemObject, TimePoint from, TimePoint to,
-			DeviceIdentifier device, Serializable id, TimePoint createdAt, RaceLogEventAuthor author,
-			TimePoint timePoint, int passId) throws JsonDeserializationException;
-	
-	@Override
-	protected RaceLogEvent deserialize(JSONObject object, Serializable id,
-			TimePoint createdAt, RaceLogEventAuthor author,
-			TimePoint timePoint, int passId, List<Competitor> competitors)
-			throws JsonDeserializationException {
-		String deviceType = (String) object.get(RaceLogDeviceMappingEventSerializer.FIELD_DEVICE_TYPE);
-		DeviceIdentifier device;
-		try {
-			device = deviceServiceFinder.findService(deviceType).transformBack(
-					(JSONObject) object.get(RaceLogDeviceMappingEventSerializer.FIELD_DEVICE));
-		} catch (Exception e) {
-			throw new JsonDeserializationException(e);
-		}
-		JSONObject itemObject = Helpers.getNestedObjectSafe(object, RaceLogDeviceMappingEventSerializer.FIELD_ITEM);
-		long fromMillis = (Long) object.get(RaceLogDeviceMappingEventSerializer.FIELD_FROM_MILLIS);
-		long toMillis = (Long) object.get(RaceLogDeviceMappingEventSerializer.FIELD_TO_MILLIS);
-		TimePoint from = new MillisecondsTimePoint(fromMillis);
-		TimePoint to = new MillisecondsTimePoint(toMillis);
-		return furtherDeserialize(itemObject, from, to, device, id, createdAt, author, timePoint, passId);
-	}
+    public RaceLogDeviceMappingEventDeserializer(
+            JsonDeserializer<Competitor> competitorDeserializer,
+            JsonDeserializer<DeviceIdentifier> deviceDeserializer) {
+        super(competitorDeserializer);
+        this.deviceDeserializer = deviceDeserializer;
+    }
+
+    protected abstract RaceLogEvent furtherDeserialize(JSONObject itemObject, TimePoint from, TimePoint to,
+            DeviceIdentifier device, Serializable id, TimePoint createdAt, RaceLogEventAuthor author,
+            TimePoint timePoint, int passId) throws JsonDeserializationException;
+
+    @Override
+    protected RaceLogEvent deserialize(JSONObject object, Serializable id,
+            TimePoint createdAt, RaceLogEventAuthor author,
+            TimePoint timePoint, int passId, List<Competitor> competitors)
+                    throws JsonDeserializationException {
+        JSONObject deviceJson = Helpers.toJSONObjectSafe(object.get(RaceLogDeviceMappingEventSerializer.FIELD_DEVICE));
+        DeviceIdentifier device = deviceDeserializer.deserialize(deviceJson);
+        JSONObject itemObject = Helpers.getNestedObjectSafe(object, RaceLogDeviceMappingEventSerializer.FIELD_ITEM);
+        long fromMillis = (Long) object.get(RaceLogDeviceMappingEventSerializer.FIELD_FROM_MILLIS);
+        long toMillis = (Long) object.get(RaceLogDeviceMappingEventSerializer.FIELD_TO_MILLIS);
+        TimePoint from = new MillisecondsTimePoint(fromMillis);
+        TimePoint to = new MillisecondsTimePoint(toMillis);
+        return furtherDeserialize(itemObject, from, to, device, id, createdAt, author, timePoint, passId);
+    }
 }
@@ -7,13 +7,11 @@ import org.json.simple.JSONObject;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Mark;
 import com.sap.sailing.domain.common.TimePoint;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
 import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public class RaceLogDeviceMarkMappingEventDeserializer extends
 		RaceLogDeviceMappingEventDeserializer<Mark> {
@@ -21,8 +19,8 @@ public class RaceLogDeviceMarkMappingEventDeserializer extends
 	
 	public RaceLogDeviceMarkMappingEventDeserializer(
 			JsonDeserializer<Competitor> competitorDeserializer, JsonDeserializer<Mark> markDeserializer,
-			TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
-		super(competitorDeserializer, deviceServiceFinder);
+			JsonDeserializer<DeviceIdentifier> deviceDeserializer) {
+		super(competitorDeserializer, deviceDeserializer);
 		this.markDeserializer = markDeserializer;
 	}

@@ -4,8 +4,9 @@ import org.json.simple.JSONObject;

 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.SharedDomainFactory;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.coursedata.impl.ControlPointDeserializer;
@@ -14,6 +15,7 @@ import com.sap.sailing.server.gateway.deserialization.coursedata.impl.GateDeseri
 import com.sap.sailing.server.gateway.deserialization.coursedata.impl.MarkDeserializer;
 import com.sap.sailing.server.gateway.deserialization.coursedata.impl.WaypointDeserializer;
 import com.sap.sailing.server.gateway.deserialization.impl.CompetitorJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.DeviceIdentifierJsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.impl.PositionJsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.impl.WindJsonDeserializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.BaseRaceLogEventSerializer;
@@ -37,18 +39,18 @@ import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogStartPro
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogStartTimeEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogStartTrackingEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogWindFixEventSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandlerFactoryDefaultingToPlaceHolder;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandler;

 public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent> {
 	
-	public static RaceLogEventDeserializer create(SharedDomainFactory domainFactory) {
-		return create(domainFactory,
-				new SmartphoneImeiJsonHandlerFactoryDefaultingToPlaceHolder());
-	}
+    public static RaceLogEventDeserializer create(SharedDomainFactory domainFactory) {
+        JsonDeserializer<DeviceIdentifier> deviceDeserializer = DeviceIdentifierJsonDeserializer.create(
+                new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE);
+        return create(domainFactory, deviceDeserializer);
+    }
 	
    public static RaceLogEventDeserializer create(SharedDomainFactory domainFactory,
-    		TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
+            JsonDeserializer<DeviceIdentifier> deviceDeserializer) {
    	JsonDeserializer<Competitor> competitorDeserializer = CompetitorJsonDeserializer.create(domainFactory);
        return new RaceLogEventDeserializer(
                new RaceLogFlagEventDeserializer(competitorDeserializer),
@@ -70,8 +72,8 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
                new RaceLogWindFixEventDeserializer(competitorDeserializer,
                        new WindJsonDeserializer(
                                new PositionJsonDeserializer())),
-                new RaceLogDeviceCompetitorMappingEventDeserializer(competitorDeserializer, deviceServiceFinder),
-                new RaceLogDeviceMarkMappingEventDeserializer(competitorDeserializer, new MarkDeserializer(domainFactory), deviceServiceFinder),
+                new RaceLogDeviceCompetitorMappingEventDeserializer(competitorDeserializer, deviceDeserializer),
+                new RaceLogDeviceMarkMappingEventDeserializer(competitorDeserializer, new MarkDeserializer(domainFactory), deviceDeserializer),
                new RaceLogDenoteForTrackingEventDeserializer(competitorDeserializer),
                new RaceLogStartTrackingEventDeserializer(competitorDeserializer),
                new RaceLogRevokeEventDeserializer(competitorDeserializer),
@@ -15,10 +15,10 @@ import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 public class DeviceAndSessionIdentifierWithGPSFixesSerializer<D extends DeviceIdentifier, F extends GPSFix> implements
        JsonSerializer<Triple<D, Serializable, List<F>>> {
    
-    private final JsonSerializer<D> deviceSerializer;
-    private  JsonSerializer<F> fixSerializer;
+    private final JsonSerializer<DeviceIdentifier> deviceSerializer;
+    private final JsonSerializer<F> fixSerializer;

-    public DeviceAndSessionIdentifierWithGPSFixesSerializer(JsonSerializer<D> deviceSerializer,
+    public DeviceAndSessionIdentifierWithGPSFixesSerializer(JsonSerializer<DeviceIdentifier> deviceSerializer,
            JsonSerializer<F> fixSerializer) {
        this.deviceSerializer = deviceSerializer;
        this.fixSerializer = fixSerializer;
@@ -34,7 +34,7 @@ public class DeviceAndSessionIdentifierWithGPSFixesSerializer<D extends DeviceId
            fixesJson.add(fixSerializer.serialize(fix));
        }
        
-        result.put(DeviceAndSessionIdentifierWithGPSFixesDeserializer.FIELD_DEVICE_ID, deviceIdJson);
+        result.put(DeviceAndSessionIdentifierWithGPSFixesDeserializer.FIELD_DEVICE, deviceIdJson);
        if (data.getB() != null) {
            result.put(DeviceAndSessionIdentifierWithGPSFixesDeserializer.FIELD_SESSION_UUID, data.getB().toString());            
        }
@@ -1,22 +0,0 @@
-package com.sap.sailing.server.gateway.serialization.impl;
-
-import org.json.simple.JSONObject;
-
-import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
-import com.sap.sailing.server.gateway.deserialization.TypeBasedJsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.JsonSerializer;
-
-public abstract class DeviceIdentifierBaseJsonSerializer<T extends DeviceIdentifier> implements JsonSerializer<T> {
-    public static final String FIELD_STRING_REPRESENTATION = "stringRepresentation";
-    
-    protected abstract JSONObject furtherSerialize(T object, JSONObject result);
-
-    @Override
-    public JSONObject serialize(T object) {
-        JSONObject result = new JSONObject();
-        result.put(TypeBasedJsonDeserializer.FIELD_TYPE, object.getIdentifierType());
-        result.put(FIELD_STRING_REPRESENTATION, object.getStringRepresentation());
-        return furtherSerialize(object, result);
-    }
-
-}
@@ -0,0 +1,55 @@
+package com.sap.sailing.server.gateway.serialization.impl;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.racelog.tracking.SingleTypeBasedServiceFinderImpl;
+import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.PlaceHolderDeviceIdentifier;
+import com.sap.sailing.server.gateway.deserialization.impl.DeviceIdentifierJsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.PlaceHolderDeviceIdentifierJsonHandler;
+
+public class DeviceIdentifierJsonSerializer implements JsonSerializer<DeviceIdentifier> {
+    private static final Logger logger = Logger.getLogger(DeviceIdentifierJsonSerializer.class.getName());
+    
+    private final TypeBasedServiceFinder<DeviceIdentifierJsonHandler> serviceFinder;
+    
+    /**
+     * Create serializer for a single device type, with additional fallback to {@link PlaceHolderDeviceIdentifier}.
+     */
+    public static DeviceIdentifierJsonSerializer create(DeviceIdentifierJsonHandler singleHandler, String type) {
+        return new DeviceIdentifierJsonSerializer(new SingleTypeBasedServiceFinderImpl<DeviceIdentifierJsonHandler>(
+                singleHandler, new PlaceHolderDeviceIdentifierJsonHandler(),
+                type));
+    }
+    
+    public DeviceIdentifierJsonSerializer(TypeBasedServiceFinder<DeviceIdentifierJsonHandler> serviceFinder) {
+        this.serviceFinder = serviceFinder;
+    }
+
+    @Override
+    public JSONObject serialize(DeviceIdentifier object) {
+        JSONObject result = new JSONObject();
+        DeviceIdentifierJsonHandler handler = serviceFinder.findService(object.getIdentifierType());
+        Pair<? extends Object, String> pair;
+        try {
+            pair = handler.serialize(object);
+            result.put(DeviceIdentifierJsonDeserializer.FIELD_DEVICE_ID, pair.getA());
+            result.put(DeviceIdentifierJsonDeserializer.FIELD_DEVICE_TYPE, pair.getB());
+            result.put(DeviceIdentifierJsonDeserializer.FIELD_STRING_REPRESENTATION, object.getStringRepresentation());
+            return result;
+        } catch (TransformationException e) {
+            logger.log(Level.WARNING, "Could not serialize device identifier, consider adding a fallback serialization handler");
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+}
@@ -1,16 +0,0 @@
-package com.sap.sailing.server.gateway.serialization.impl;
-
-import org.json.simple.JSONObject;
-
-import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
-import com.sap.sailing.server.gateway.deserialization.impl.SmartphoneImeiIdentifierJsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.JsonSerializer;
-
-public class SmartphoneImeiIdentifierJsonSerializer extends DeviceIdentifierBaseJsonSerializer<SmartphoneImeiIdentifier>
-implements JsonSerializer<SmartphoneImeiIdentifier> {
-    @Override
-    protected JSONObject furtherSerialize(SmartphoneImeiIdentifier object, JSONObject result) {
-        result.put(SmartphoneImeiIdentifierJsonDeserializer.FIELD_IMEI, object.getImei());
-        return result;
-    }
-}
@@ -3,18 +3,17 @@ package com.sap.sailing.server.gateway.serialization.racelog.impl;
 import org.json.simple.JSONObject;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public class RaceLogDeviceCompetitorMappingEventSerializer extends RaceLogDeviceMappingEventSerializer<Competitor> {
 	public static final String VALUE_CLASS = DeviceCompetitorMappingEvent.class.getSimpleName();

 	public RaceLogDeviceCompetitorMappingEventSerializer(
 			JsonSerializer<Competitor> competitorSerializer,
-			TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
-		super(competitorSerializer, deviceServiceFinder);
+			JsonSerializer<DeviceIdentifier> deviceSerializer) {
+		super(competitorSerializer, deviceSerializer);
 	}
 	
    @Override
@@ -4,43 +4,35 @@ import org.json.simple.JSONObject;

 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.common.WithID;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.DeviceMappingEvent;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public abstract class RaceLogDeviceMappingEventSerializer<ItemT extends WithID> extends BaseRaceLogEventSerializer {
-	private final TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder;
+    private final JsonSerializer<DeviceIdentifier> deviceSerializer;
    public static final String FIELD_ITEM = "item";
    public static final String FIELD_DEVICE = "device";
-    public static final String FIELD_DEVICE_TYPE = "deviceType";
    public static final String FIELD_FROM_MILLIS = "fromMillis";
    public static final String FIELD_TO_MILLIS = "toMillis";

    public RaceLogDeviceMappingEventSerializer(JsonSerializer<Competitor> competitorSerializer,
-    		TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
+            JsonSerializer<DeviceIdentifier> deviceSerializer) {
        super(competitorSerializer);
-        this.deviceServiceFinder = deviceServiceFinder;
+        this.deviceSerializer = deviceSerializer;
    }
-    
+
    protected abstract JSONObject serializeItem(ItemT item);

    @Override
    public JSONObject serialize(RaceLogEvent object) {
        @SuppressWarnings("unchecked")
-		DeviceMappingEvent<ItemT> event = (DeviceMappingEvent<ItemT>) object;
+        DeviceMappingEvent<ItemT> event = (DeviceMappingEvent<ItemT>) object;
        JSONObject result = super.serialize(event);
-        String deviceType = event.getDevice().getIdentifierType();
        result.put(FIELD_FROM_MILLIS, event.getFrom().asMillis());
        result.put(FIELD_TO_MILLIS, event.getTo().asMillis());
        result.put(FIELD_ITEM, serializeItem(event.getMappedTo()));
-        result.put(FIELD_DEVICE_TYPE, deviceType);        
-        try {
-			result.put(FIELD_DEVICE, deviceServiceFinder.findService(deviceType).transformForth(event.getDevice()));
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
+        result.put(FIELD_DEVICE, deviceSerializer.serialize(event.getDevice()));
        return result;
    }

@@ -5,10 +5,9 @@ import org.json.simple.JSONObject;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
 import com.sap.sailing.domain.base.Mark;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public class RaceLogDeviceMarkMappingEventSerializer extends RaceLogDeviceMappingEventSerializer<Mark> {
 	public static final String VALUE_CLASS = DeviceMarkMappingEvent.class.getSimpleName();
@@ -16,8 +15,8 @@ public class RaceLogDeviceMarkMappingEventSerializer extends RaceLogDeviceMappin
 	
 	public RaceLogDeviceMarkMappingEventSerializer(
 			JsonSerializer<Competitor> competitorSerializer, JsonSerializer<ControlPoint> markSerializer,
-			TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
-		super(competitorSerializer, deviceServiceFinder);
+			JsonSerializer<DeviceIdentifier> deviceSerializer) {
+		super(competitorSerializer, deviceSerializer);
 		this.markSerializer = markSerializer;
 	}
 	
@@ -3,7 +3,6 @@ package com.sap.sailing.server.gateway.serialization.racelog.impl;
 import org.json.simple.JSONObject;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.racelog.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
@@ -23,8 +22,10 @@ import com.sap.sailing.domain.racelog.RevokeEvent;
 import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
+import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
 import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 import com.sap.sailing.server.gateway.serialization.coursedata.impl.ControlPointJsonSerializer;
@@ -32,17 +33,19 @@ import com.sap.sailing.server.gateway.serialization.coursedata.impl.CourseBaseJs
 import com.sap.sailing.server.gateway.serialization.coursedata.impl.GateJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.coursedata.impl.MarkJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.coursedata.impl.WaypointJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.DeviceIdentifierJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PositionJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.WindJsonSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandlerFactoryDefaultingToPlaceHolder;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandler;

 public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, RaceLogEventVisitor {
-	public static JsonSerializer<RaceLogEvent> create(JsonSerializer<Competitor> competitorSerializer) {
-		return create(competitorSerializer, new SmartphoneImeiJsonHandlerFactoryDefaultingToPlaceHolder());
-	}
+    public static JsonSerializer<RaceLogEvent> create(JsonSerializer<Competitor> competitorSerializer) {
+        return create(competitorSerializer, DeviceIdentifierJsonSerializer.create(
+                new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE));
+    }
+    
    public static JsonSerializer<RaceLogEvent> create(JsonSerializer<Competitor> competitorSerializer,
-    		TypeBasedServiceFinder<DeviceIdentifierJsonHandler> deviceServiceFinder) {
+    		JsonSerializer<DeviceIdentifier> deviceSerializer) {
        return new RaceLogEventSerializer(
                new RaceLogFlagEventSerializer(competitorSerializer), 
                new RaceLogStartTimeEventSerializer(competitorSerializer), 
@@ -64,8 +67,8 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
                new RaceLogWindFixEventSerializer(competitorSerializer, 
                        new WindJsonSerializer(
                                new PositionJsonSerializer())),
-                new RaceLogDeviceCompetitorMappingEventSerializer(competitorSerializer, deviceServiceFinder),
-                new RaceLogDeviceMarkMappingEventSerializer(competitorSerializer, new MarkJsonSerializer(), deviceServiceFinder),
+                new RaceLogDeviceCompetitorMappingEventSerializer(competitorSerializer, deviceSerializer),
+                new RaceLogDeviceMarkMappingEventSerializer(competitorSerializer, new MarkJsonSerializer(), deviceSerializer),
                new RaceLogDenoteForTrackingEventSerializer(competitorSerializer),
                new RaceLogStartTrackingEventSerializer(competitorSerializer),
                new RaceLogRevokeEventSerializer(competitorSerializer),
@@ -1,9 +1,6 @@
 package com.sap.sailing.server.gateway.serialization.racelog.tracking;

-import org.json.simple.JSONObject;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifierSerializationHandler;

-import com.sap.sailing.domain.common.racelog.tracking.TransformationHandler;
-import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
-
-public interface DeviceIdentifierJsonHandler extends TransformationHandler<DeviceIdentifier, JSONObject> {
+public interface DeviceIdentifierJsonHandler extends DeviceIdentifierSerializationHandler<Object> {
 }
@@ -1,52 +0,0 @@
-package com.sap.sailing.server.gateway.serialization.racelog.tracking.impl;
-
-import org.json.simple.JSONObject;
-
-import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegisteredException;
-import com.sap.sailing.domain.common.racelog.tracking.SingleTypeBasedServiceFinderImpl;
-import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
-import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
-import com.sap.sailing.server.gateway.deserialization.impl.PlaceHolderDeviceIdentifierJsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.impl.DeviceIdentifierBaseJsonSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
-
-public class DeviceIdentifierJsonHandlerFactoryDefaultingToPlaceHolder extends
-        SingleTypeBasedServiceFinderImpl<DeviceIdentifierJsonHandler> {
-    private final DeviceIdentifierJsonHandler placeHolderHandler;
-    
-
-    public DeviceIdentifierJsonHandlerFactoryDefaultingToPlaceHolder(DeviceIdentifierJsonHandler service, String type) {
-        super(service, type);
-        final PlaceHolderDeviceIdentifierJsonDeserializer placeHolderDeserializer =
-                new PlaceHolderDeviceIdentifierJsonDeserializer();
-        final DeviceIdentifierBaseJsonSerializer<DeviceIdentifier> placeHolderSerializer =
-                new DeviceIdentifierBaseJsonSerializer<DeviceIdentifier>() {
-            @Override
-            protected JSONObject furtherSerialize(DeviceIdentifier object, JSONObject result) {
-                return result;
-            }
-        };
-        
-        placeHolderHandler = new DeviceIdentifierJsonHandler() {
-            
-            @Override
-            public JSONObject transformForth(DeviceIdentifier object) throws TransformationException {
-                return placeHolderSerializer.serialize(object);
-            }
-            
-            @Override
-            public DeviceIdentifier transformBack(JSONObject object) throws TransformationException {
-                return placeHolderDeserializer.deserialize(object);
-            }
-        };
-    }
-
-    @Override
-    public DeviceIdentifierJsonHandler findService(String type) {
-        try {
-            return super.findService(type);
-        } catch (NoCorrespondingServiceRegisteredException e) {
-            return placeHolderHandler;
-        }
-    }
-}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.racelogtracking.impl;
+package com.sap.sailing.server.gateway.serialization.racelog.tracking.impl;

 import org.json.simple.JSONObject;

@@ -0,0 +1,45 @@
+package com.sap.sailing.server.gateway.serialization.racelog.tracking.impl;
+
+import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegisteredException;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
+import com.sap.sailing.domain.tracking.GPSFix;
+import com.sap.sailing.domain.tracking.GPSFixMoving;
+import com.sap.sailing.server.gateway.deserialization.impl.GPSFixJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.GPSFixMovingJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.GPSFixMovingNmeaDTOJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.GPSFixNmeaDTOJsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.impl.GPSFixJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.GPSFixMovingJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.GPSFixMovingNmeaDTOJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.GPSFixNmeaDTOJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.GPSFixJsonHandler;
+
+public class GPSFixJsonServiceFinder implements TypeBasedServiceFinder<GPSFixJsonHandler> {
+    private final GPSFixJsonHandler gpsFixHandler = new GPSFixJsonHandlerImpl<GPSFix>(new GPSFixJsonDeserializer(), new GPSFixJsonSerializer());
+    private final GPSFixJsonHandler gpsFixMovingHandler = new GPSFixJsonHandlerImpl<GPSFixMoving>(new GPSFixMovingJsonDeserializer(), new GPSFixMovingJsonSerializer());
+    private final GPSFixJsonHandler gpsFixNmeaDTOHandler = new GPSFixJsonHandlerImpl<GPSFix>(new GPSFixNmeaDTOJsonDeserializer(), new GPSFixNmeaDTOJsonSerializer());
+    private final GPSFixJsonHandler gpsFixMovingNmeaDTOHandler = new GPSFixJsonHandlerImpl<GPSFixMoving>(new GPSFixMovingNmeaDTOJsonDeserializer(), new GPSFixMovingNmeaDTOJsonSerializer());
+    
+
+    @Override
+    public GPSFixJsonHandler findService(String type) throws NoCorrespondingServiceRegisteredException {
+        if (type.equals(GPSFixJsonDeserializer.TYPE)) {
+            return gpsFixHandler;
+        } else if (type.equals(GPSFixMovingJsonDeserializer.TYPE)) {
+            return gpsFixMovingHandler;
+        } else if (type.equals(GPSFixNmeaDTOJsonDeserializer.TYPE)) {
+            return gpsFixNmeaDTOHandler;
+        } else if (type.equals(GPSFixMovingNmeaDTOJsonDeserializer.TYPE)) {
+            return gpsFixMovingNmeaDTOHandler;
+        }
+        throw new NoCorrespondingServiceRegisteredException(
+                "Only handlers for GPSFix, GPSFixMoving, GPSFixNmeaDTO, GPSFixMovingNmeaDTO are registered",
+                type, GPSFixJsonHandler.class);
+    }
+
+    @Override
+    public void setFallbackService(GPSFixJsonHandler fallback) {
+        
+    }
+
+}
@@ -0,0 +1,9 @@
+package com.sap.sailing.server.gateway.serialization.racelog.tracking.impl;
+
+import com.sap.sailing.domain.racelog.tracking.impl.PlaceHolderDeviceIdentifierSerializationHandler;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
+
+public class PlaceHolderDeviceIdentifierJsonHandler extends PlaceHolderDeviceIdentifierSerializationHandler
+implements DeviceIdentifierJsonHandler {
+
+}
@@ -0,0 +1,9 @@
+package com.sap.sailing.server.gateway.serialization.racelog.tracking.impl;
+
+import com.sap.sailing.domain.racelog.tracking.impl.SmartphoneImeiSerializationHandler;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
+
+public class SmartphoneImeiJsonHandler extends SmartphoneImeiSerializationHandler
+implements DeviceIdentifierJsonHandler {
+
+}
@@ -1,12 +0,0 @@
-package com.sap.sailing.server.gateway.serialization.racelog.tracking.impl;
-
-import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
-
-public class SmartphoneImeiJsonHandlerFactoryDefaultingToPlaceHolder extends
-        DeviceIdentifierJsonHandlerFactoryDefaultingToPlaceHolder {
-
-    public SmartphoneImeiJsonHandlerFactoryDefaultingToPlaceHolder() {
-        super(new SmartphoneImeiJsonHandlerImpl(), SmartphoneImeiIdentifier.TYPE);
-    }
-
-}
@@ -1,26 +0,0 @@
-package com.sap.sailing.server.gateway.serialization.racelog.tracking.impl;
-
-import org.json.simple.JSONObject;
-
-import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
-import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
-import com.sap.sailing.server.gateway.deserialization.impl.SmartphoneImeiIdentifierJsonDeserializer;
-import com.sap.sailing.server.gateway.serialization.impl.SmartphoneImeiIdentifierJsonSerializer;
-import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
-
-public class SmartphoneImeiJsonHandlerImpl implements DeviceIdentifierJsonHandler {
-	private final SmartphoneImeiIdentifierJsonSerializer serializer = new SmartphoneImeiIdentifierJsonSerializer();
-	private final SmartphoneImeiIdentifierJsonDeserializer deserializer = new SmartphoneImeiIdentifierJsonDeserializer();
-
-	@Override
-	public JSONObject transformForth(DeviceIdentifier object) {
-		return serializer.serialize((SmartphoneImeiIdentifier) object);
-	}
-
-	@Override
-	public DeviceIdentifier transformBack(JSONObject json) throws JsonDeserializationException {
-		return deserializer.deserialize(json);
-	}
-
-}
@@ -10,6 +10,7 @@ Require-Bundle: org.mockito.mockito-core;bundle-version="1.9.5",
 com.sap.sailing.domain.test,
 org.hamcrest;bundle-version="1.1.0",
 org.objenesis;bundle-version="1.3.0",
- org.junit4;bundle-version="4.8.2"
+ org.junit4;bundle-version="4.8.2",
+ com.sap.sailing.domain.racelogtrackingadapter.testsupport;bundle-version="1.0.0"
 Import-Package: com.sap.sailing.domain.persistence.impl,
 com.sap.sailing.server.impl
@@ -0,0 +1,127 @@
+package com.sap.sailing.server.gateway.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collections;
+import java.util.Date;
+
+import org.json.simple.JSONObject;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.DomainFactory;
+import com.sap.sailing.domain.base.impl.BoatClassImpl;
+import com.sap.sailing.domain.base.impl.BoatImpl;
+import com.sap.sailing.domain.base.impl.CompetitorImpl;
+import com.sap.sailing.domain.base.impl.NationalityImpl;
+import com.sap.sailing.domain.base.impl.PersonImpl;
+import com.sap.sailing.domain.base.impl.TeamImpl;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
+import com.sap.sailing.domain.racelog.RaceLogEventFactory;
+import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
+import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.PlaceHolderDeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockEmptyServiceFinder;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.DeviceIdentifierJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.racelog.impl.RaceLogEventDeserializer;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.DeviceIdentifierJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogEventSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.PlaceHolderDeviceIdentifierJsonHandler;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.SmartphoneImeiJsonHandler;
+
+public class RaceLogSerializationTest {
+    private JsonSerializer<RaceLogEvent> serializer;
+    private JsonDeserializer<RaceLogEvent> deserializer;
+    private final RaceLogEventAuthor author = new RaceLogEventAuthorImpl("test", 0);
+    private static final Competitor competitor = new CompetitorImpl("a", "b", null,
+            new TeamImpl("a", Collections.singletonList(new PersonImpl("a", new NationalityImpl("GER"), new Date(), "abc")), null),
+            new BoatImpl("a", new BoatClassImpl("a", true), "abc"));
+    
+    @Before
+    public void setup() {
+    }
+    
+    private void setup(JsonDeserializer<DeviceIdentifier> deviceDeserializer, JsonSerializer<DeviceIdentifier> deviceSerializer) {
+        JsonSerializer<Competitor> cSer = CompetitorJsonSerializer.create();
+        serializer = RaceLogEventSerializer.create(cSer, deviceSerializer);
+        deserializer = RaceLogEventDeserializer.create(DomainFactory.INSTANCE, deviceDeserializer);
+    }
+    
+    private TimePoint t() {
+        return MillisecondsTimePoint.now();
+    }
+    
+    @Test
+    public void testSerializationOfDeviceIdentifier() throws JsonDeserializationException {
+        setup(DeviceIdentifierJsonDeserializer.create(new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE),
+                DeviceIdentifierJsonSerializer.create(new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE));
+        DeviceIdentifier device = new SmartphoneImeiIdentifier("abc");
+        DeviceCompetitorMappingEvent event = RaceLogEventFactory.INSTANCE.createDeviceCompetitorMappingEvent(
+                t(), author, device, competitor, 0, t(), t());
+        
+        JSONObject json = serializer.serialize(event);
+        
+        RaceLogEvent deserialized = deserializer.deserialize(json);
+        
+        assertTrue(deserialized instanceof DeviceCompetitorMappingEvent);
+        DeviceCompetitorMappingEvent deserializedMapping = (DeviceCompetitorMappingEvent) deserialized;
+        assertEquals(event.getDevice(), deserializedMapping.getDevice());
+    }
+    
+    @Test
+    public void testSerializationOfDeviceIdentifierWithNoSerializer() throws JsonDeserializationException {
+        TypeBasedServiceFinder<DeviceIdentifierJsonHandler> onlyFallback = new MockEmptyServiceFinder<>();
+        onlyFallback.setFallbackService(new PlaceHolderDeviceIdentifierJsonHandler());
+        
+        setup(new DeviceIdentifierJsonDeserializer(onlyFallback),
+                DeviceIdentifierJsonSerializer.create(new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE));
+        DeviceIdentifier device = new SmartphoneImeiIdentifier("abc");
+        DeviceCompetitorMappingEvent event = RaceLogEventFactory.INSTANCE.createDeviceCompetitorMappingEvent(
+                t(), author, device, competitor, 0, t(), t());
+        
+        JSONObject json = serializer.serialize(event);
+        
+        RaceLogEvent deserialized = deserializer.deserialize(json);
+        
+        assertTrue(deserialized instanceof DeviceCompetitorMappingEvent);
+        DeviceCompetitorMappingEvent deserializedMapping = (DeviceCompetitorMappingEvent) deserialized;
+        assertTrue(deserializedMapping.getDevice() instanceof PlaceHolderDeviceIdentifier);
+        assertEquals(event.getDevice().getStringRepresentation(), deserializedMapping.getDevice().getStringRepresentation());
+        assertEquals(event.getDevice().getIdentifierType(), deserializedMapping.getDevice().getIdentifierType());
+    }
+    
+    @Test
+    public void testSerializationOfDeviceIdentifierWithNoDeserializer() throws JsonDeserializationException {
+        TypeBasedServiceFinder<DeviceIdentifierJsonHandler> onlyFallback = new MockEmptyServiceFinder<>();
+        onlyFallback.setFallbackService(new PlaceHolderDeviceIdentifierJsonHandler());
+        
+        setup(DeviceIdentifierJsonDeserializer.create(new SmartphoneImeiJsonHandler(), SmartphoneImeiIdentifier.TYPE),
+                new DeviceIdentifierJsonSerializer(onlyFallback));
+        DeviceIdentifier device = new SmartphoneImeiIdentifier("abc");
+        DeviceCompetitorMappingEvent event = RaceLogEventFactory.INSTANCE.createDeviceCompetitorMappingEvent(
+                t(), author, device, competitor, 0, t(), t());
+        
+        JSONObject json = serializer.serialize(event);
+        
+        RaceLogEvent deserialized = deserializer.deserialize(json);
+        
+        assertTrue(deserialized instanceof DeviceCompetitorMappingEvent);
+        DeviceCompetitorMappingEvent deserializedMapping = (DeviceCompetitorMappingEvent) deserialized;
+        assertTrue(deserializedMapping.getDevice() instanceof PlaceHolderDeviceIdentifier);
+        assertEquals(event.getDevice().getStringRepresentation(), deserializedMapping.getDevice().getStringRepresentation());
+        assertEquals(event.getDevice().getIdentifierType(), deserializedMapping.getDevice().getIdentifierType());
+    }
+}
@@ -25,12 +25,14 @@ import com.sap.sailing.domain.racelog.RaceLogServletConstants;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sailing.server.gateway.AbstractJsonHttpServlet;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.DeviceIdentifierJsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.impl.Helpers;
 import com.sap.sailing.server.gateway.deserialization.racelog.impl.RaceLogEventDeserializer;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
+import com.sap.sailing.server.gateway.serialization.racelog.tracking.impl.PlaceHolderDeviceIdentifierJsonHandler;

 public class AddEntryToRaceLogJsonPostServlet extends AbstractJsonHttpServlet {
    private static final long serialVersionUID = 7704668926551060433L;
@@ -44,6 +46,7 @@ public class AddEntryToRaceLogJsonPostServlet extends AbstractJsonHttpServlet {
    	super.init(config);
    	deviceJsonServiceFinder = getServiceFinderFactory()
    			.createServiceFinder(DeviceIdentifierJsonHandler.class);
+    	deviceJsonServiceFinder.setFallbackService(new PlaceHolderDeviceIdentifierJsonHandler());
    }

    @Override
@@ -121,7 +124,7 @@ public class AddEntryToRaceLogJsonPostServlet extends AbstractJsonHttpServlet {
            try {
                logger.fine("Client wants to add a race log event");
                JsonDeserializer<RaceLogEvent> deserializer = RaceLogEventDeserializer.create(
-                		getService().getBaseDomainFactory(), deviceJsonServiceFinder);
+                		getService().getBaseDomainFactory(), new DeviceIdentifierJsonDeserializer(deviceJsonServiceFinder));
                Object requestObject = JSONValue.parseWithException(requestBody.toString());
                JSONObject requestJsonObject = Helpers.toJSONObjectSafe(requestObject);
                logger.fine("JSON requestObject is: " + requestObject.toString());
@@ -25,6 +25,7 @@ public class CachedOsgiTypeBasedServiceFinder<ServiceT> implements ServiceTracke
    private final Map<String, ServiceT> services = new HashMap<>();
    private final BundleContext context;
    private Class<ServiceT> serviceType;
+    private ServiceT fallback;

    public CachedOsgiTypeBasedServiceFinder(Class<ServiceT> serviceType, BundleContext context) {
    	this.serviceType = serviceType;
@@ -35,8 +36,13 @@ public class CachedOsgiTypeBasedServiceFinder<ServiceT> implements ServiceTracke
    public ServiceT findService(String type) {
        ServiceT service = services.get(type);

-        if (service == null)
-            throw new NoCorrespondingServiceRegisteredException("Could not find service", type, serviceType);
+        if (service == null) {
+            if (fallback != null) {
+                return fallback;
+            } else {
+                throw new NoCorrespondingServiceRegisteredException("Could not find service", type, serviceType);       
+            }
+        }

        return service;
    }
@@ -60,4 +66,9 @@ public class CachedOsgiTypeBasedServiceFinder<ServiceT> implements ServiceTracke
        String type = (String) reference.getProperty(TypeBasedServiceFinder.TYPE);
        services.remove(type);
    }
+
+    @Override
+    public void setFallbackService(ServiceT fallback) {
+        this.fallback = fallback;
+    }
 }