Creating an Uber Clone - Part XV - Transcript.pdf

Creating an Uber Clone - Part XV
Next we’ll bind the websocket logic and map UI to bring this all together…

public class LocationService {
private static final short MESSAGE_TYPE_LOCATION_UPDATE = 1;
private static final short MESSAGE_TYPE_DRIVER_POSITIONS = 2;
private static final short MESSAGE_TYPE_AVAILBLE_DRIVER_POSITIONS = 3;
private static final long MAX_UPDATE_FREQUENCY = 3000;
private Location lastKnownLocation;
private SocketConnection server;
private CarAdded carCallback;
private SuccessCallback<Location> locationCallback;
private Map<Long, User> cars = new HashMap<>();
private LocationService() {}
public static void bind(CarAdded carCallback,
SuccessCallback<Location> locationUpdate) {
new LocationService().bindImpl(carCallback, locationUpdate);
}
private void bindImpl(CarAdded carCallback,
this.carCallback = carCallback;
locationCallback = locationUpdate;
LocationManager.getLocationManager().
setLocationListener(new LocationListener() {
@Override
LocationService (Client)
We can get started with a LocationService class similarly to the UserService class that would abstract the local location. Unlike the UserService class the LocationService
class should also deal with the physical location of the device.

These are the same constants we have in the server

}
@Override
When sending a location update to the server I don't want to exceed a fixed amount of updates so we won't burden the server or our network

}
@Override
The class has a private constructor so the only way to create the LocationService is via the bind method which in turn invokes the instance method bindImpl. We provide
two callbacks one is for a car being added which we will use to bind a new car to the UI and the other is for location updates so we can position the map

@Override
public void locationUpdated(Location location) {
lastKnownLocation = location;
if(location.getStatus() == LocationManager.AVAILABLE &&
locationCallback != null) {
SuccessCallback<Location> c = locationCallback;
locationCallback = null;
c.onSucess(location);
}
if(server != null) {
server.sendLocationUpdate();
}
}
@Override
public void providerStateChanged(int newState) {
}
});
new SocketConnection().connect();
Location update notifies the server about changes to the location and also invokes the callback once so we can position the map

@Override
}
}
}
@Override
}
});
We invoke the callback with the location so the map can be shifted to our current position

@Override
}
}
}
@Override
}
});
Once the server socket is connected we start sending location updates there

@Override
}
}
}
@Override
}
});
We open the WebSocket connection using the connect() call

}
class SocketConnection extends WebSocket {
private double lat, lon;
private float direction;
private long lastUpdateTime;
private EasyThread et;
public SocketConnection() {
super(Globals.SERVER_SOCKET_URL);
et = EasyThread.start("Websocket");
}
@Override
protected void onOpen() {
server = this;
sendLocationUpdate();
}
public void sendLocationUpdate() {
if(!et.isThisIt()) {
et.run(() -> sendLocationUpdate());
return;
}
if(lastKnownLocation != null) {
double lt = lastKnownLocation.getLatitude();
double ll = lastKnownLocation.getLongitude();
We cache the last set of values so we don't send data to the server unless something changed

}
}
@Override
server = this;
}
return;
}
EasyThread lets us post "jobs" onto a dedicated thread so we don't have to block the main EDT. It also means we don't need to deal with synchronization or any other
complexity related to that as all operations happen on that thread

}
}
@Override
server = this;
}
return;
}
Until onOpen() is invoked the connection isn't ready. That's why the server member field is only initialized here when it's actually ready

}
}
@Override
server = this;
}
return;
}
If we already have a location we should send a user location update one we have the socket connection in place

}
}
@Override
server = this;
}
return;
}
The connection is single threaded as I mentioned before. The isThisIt() method is similar to isEDT() and indicates if the current thread is the one managed by the
EasyThread if not we use run(Runnable) which invokes the target Runnable on the EasyThread similarly to callSerially

return;
}
float dir = lastKnownLocation.getDirection();
if(ll == lon && lt == lat && dir == direction) {
return;
}
long time = System.currentTimeMillis();
if(time - lastUpdateTime < MAX_UPDATE_FREQUENCY) {
return;
}
lastUpdateTime = time;
lon = ll;
lat = lt;
direction = dir;
try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(bos);) {
dos.writeShort(MESSAGE_TYPE_LOCATION_UPDATE);
String token = Preferences.get("token", null);
If the values didn't change since last update so we do nothing

return;
}
return;
}
return;
}
lon = ll;
lat = lt;
direction = dir;
We don't update too much, there is a chance we'll miss an update here but it's probably not a deal breaker if a user didn't move much

return;
}
return;
}
return;
}
lon = ll;
lat = lt;
direction = dir;
We create a ByteArrayOutputStream into which we construct the message that we receive on the server with the header, location etc.

dos.writeShort(token.length());
for(int iter = 0 ; iter < token.length() ; iter++) {
dos.writeByte((byte)token.charAt(iter));
}
dos.writeDouble(lat);
dos.writeDouble(lon);
dos.writeFloat(dir);
dos.writeDouble(1);
dos.writeByte(0);
dos.flush();
send(bos.toByteArray());
} catch(IOException err) {
Log.e(err);
}
}
}
@Override
protected void onClose(int i, String string) {
Log.p("Connection closed! Error... "
I currently hardcoded a 1 kilometer search radius and defined explicitly that we aren't in taxi hailing mode

}
dos.writeDouble(1);
dos.writeByte(0);
dos.flush();
Log.e(err);
}
}
}
@Override
One line to actually send the binary data, it would be similar with text data with the exception of parsing overhead. The IOException isn't likely as this is a RAM based
stream

}
dos.writeDouble(1);
dos.writeByte(0);
dos.flush();
Log.e(err);
}
}
}
@Override
The IOException isn't likely as this is a RAM based stream

@Override
+ "trying to reconnect in 5 seconds");
UITimer.timer(5000, false, () -> connect());
}
@Override
protected void onMessage(String string) {
}
@Override
protected void onMessage(byte[] bytes) {
try {
DataInputStream dis = new DataInputStream(
new ByteArrayInputStream(bytes));
short response = dis.readShort();
int size = dis.readInt();
for(int iter = 0 ; iter < size ; iter++) {
long id = dis.readLong();
User car = cars.get(id);
if(car == null) {
car = new User().
id.set(id).
latitude.set(dis.readDouble()).
longitude.set(dis.readDouble()).
Here we receive the messages sent from the server specifically driver search results

@Override
+ "trying to reconnect in 5 seconds");
UITimer.timer(5000, false, () -> connect());
}
@Override
protected void onMessage(String string) {
}
@Override
protected void onMessage(byte[] bytes) {
try {
DataInputStream dis = new DataInputStream(
new ByteArrayInputStream(bytes));
short response = dis.readShort();
int size = dis.readInt();
for(int iter = 0 ; iter < size ; iter++) {
if(car == null) {
car = new User().
id.set(id).
We store User instances in a Map where the user ID is the key. This saves us from sending duplicate carAdded events and allows us to just mutate the User properties
which other code can observe using the builtin listeners in properties

if(car == null) {
car = new User().
id.set(id).
direction.set(dis.readFloat());
cars.put(id, car);
User finalCar = car;
callSerially(() -> carCallback.carAdded(finalCar));
} else {
car.latitude.set(dis.readDouble()).
}
}
Log.e(err);
}
}
protected void onError(Exception e) {
Log.e(e);
}
Notice that this code is running on the WebSocket thread so events need to go back into the EDT to prevent potential issues

if(car == null) {
car = new User().
id.set(id).
cars.put(id, car);
} else {
}
}
Log.e(err);
}
}
Log.e(e);
}
This is really important, we need handle errors properly in a WebSocket application otherwise a failure can leave us without a connection

cars.put(id, car);
} else {
}
}
Log.e(err);
}
}
Log.e(e);
}
}
public static interface CarAdded {
void carAdded(User driver);
}
}
The callback interface is trivial, it's mostly used as a lambda expression in the code… And that’s it for the location service…

Creating an Uber Clone - Part XV - Transcript.pdf

Recommended

Recommended

More Related Content

Similar to Creating an Uber Clone - Part XV - Transcript.pdf

Similar to Creating an Uber Clone - Part XV - Transcript.pdf (20)

More from ShaiAlmog1

More from ShaiAlmog1 (20)

Recently uploaded

Recently uploaded (20)

Creating an Uber Clone - Part XV - Transcript.pdf