@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
byte[] data = getIntent().getExtras().getByteArray(SHOW_ROUTE_EXTRA_PROTO);
if (data == null) {
Log.v(TAG, "Intent Data is null");
finish();
}
try {
route = Route.parseFrom(data);
} catch (InvalidProtocolBufferException e) {
Log.v(TAG, "Intent Data does not parse");
e.printStackTrace();
finish();
}
storage = new PlaceStorage(this);
// Ug, this is unfortunate.
if (route.getRoutePointCount() == 0) {
place = Place.newBuilder().setLatitude(0).setLongitude(0).build();
} else {
place = storage.getPlaceForRoute(RouteUtils.getLastRoutePoint(route));
}
setTitle(RouteCursorAdapter.getRouteTime(route));
setContentView(R.layout.activity_show_route_map);
RouteCursorAdapter.setupListView(findViewById(R.id.routeDetails), route, storage, null);
map = ((MapFragment) getFragmentManager().findFragmentById(R.id.bigMap)).getMap();
map.setMapType(GoogleMap.MAP_TYPE_NORMAL);
Point size = new Point();
getWindowManager().getDefaultDisplay().getSize(size);
CameraUpdate cameraUpdate =
CameraUpdateFactory.newLatLngBounds(getBounds(), size.x, size.y, 50);
map.moveCamera(cameraUpdate);
showRoute();
}
@Override
public void read(ByteBuffer bb) {
try {
openChestRequestProto = OpenChestRequestProto.parseFrom(ByteString.copyFrom(bb));
playerId = openChestRequestProto.getMup().getUserID();
} catch (InvalidProtocolBufferException e) {
e.printStackTrace();
}
}
@Benchmark
// @BenchmarkMode(Mode.AverageTime)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(1)
public AddressBookJson JSONDeserialization() throws IOException {
try {
return mapper.readValue(msgJson, AddressBookJson.class);
} catch (InvalidProtocolBufferException e) {
e.printStackTrace();
}
return null;
}
@Override
public void run() {
Log.i(TAG, "Connection started");
MessageWriter writer = null;
MessageRouter router = null;
try {
MessageReader reader = new MessageReader(socket.getInputStream());
writer = new MessageWriter(socket.getOutputStream());
writers.add(writer);
router = new MessageRouter(writer);
router.register(Wire.MessageType.DO_IDENTIFY, new DoIdentifyResponder(getBaseContext()));
router.register(
Wire.MessageType.DO_ADD_ACCOUNT_MENU,
new DoAddAccountMenuResponder(getBaseContext()));
router.register(
Wire.MessageType.DO_REMOVE_ACCOUNT, new DoRemoveAccountResponder(getBaseContext()));
router.register(
Wire.MessageType.GET_ACCOUNTS, new GetAccountsResponder(getBaseContext()));
router.register(
Wire.MessageType.GET_BROWSERS, new GetBrowsersResponder(getBaseContext()));
router.register(
Wire.MessageType.GET_CLIPBOARD, new GetClipboardResponder(getBaseContext()));
router.register(Wire.MessageType.GET_DISPLAY, new GetDisplayResponder(getBaseContext()));
router.register(
Wire.MessageType.GET_PROPERTIES, new GetPropertiesResponder(getBaseContext()));
router.register(
Wire.MessageType.GET_RINGER_MODE, new GetRingerModeResponder(getBaseContext()));
router.register(
Wire.MessageType.GET_SD_STATUS, new GetSdStatusResponder(getBaseContext()));
router.register(Wire.MessageType.GET_VERSION, new GetVersionResponder(getBaseContext()));
router.register(
Wire.MessageType.GET_WIFI_STATUS, new GetWifiStatusResponder(getBaseContext()));
router.register(
Wire.MessageType.SET_CLIPBOARD, new SetClipboardResponder(getBaseContext()));
router.register(
Wire.MessageType.SET_KEYGUARD_STATE, new SetKeyguardStateResponder(getBaseContext()));
router.register(
Wire.MessageType.SET_RINGER_MODE, new SetRingerModeResponder(getBaseContext()));
router.register(
Wire.MessageType.SET_WAKE_LOCK, new SetWakeLockResponder(getBaseContext()));
router.register(
Wire.MessageType.SET_WIFI_ENABLED, new SetWifiEnabledResponder(getBaseContext()));
router.register(
Wire.MessageType.SET_MASTER_MUTE, new SetMasterMuteResponder(getBaseContext()));
for (AbstractMonitor monitor : monitors) {
monitor.peek(writer);
}
while (!isInterrupted()) {
Wire.Envelope envelope = reader.read();
if (envelope == null) {
break;
}
router.route(envelope);
}
} catch (InvalidProtocolBufferException e) {
Log.e(TAG, e.getMessage());
e.printStackTrace();
} catch (IOException e) {
} catch (Exception e) {
e.printStackTrace();
} finally {
Log.i(TAG, "Connection stopping");
writers.remove(writer);
if (router != null) {
router.cleanup();
}
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Override
public Boolean call() {
if (serverSocket.isClosed()) {
log.warn("Server socket is closed. Aborting.");
return false;
} else {
try {
// Wait for a client connection
log.debug("Await client connection to SSLSocket");
SSLSocket socket = (SSLSocket) serverSocket.accept();
socket.startHandshake();
log.debug("Sending PaymentACK");
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();
// Read the inputStream - this is expected to be a header followed by a serialised Payment
Reader reader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(reader);
String line;
int contentLength = -1;
StringBuilder builder = new StringBuilder();
while (!"".equals((line = bufferedReader.readLine()))) {
builder.append(line).append("\n");
log.debug("Read line: {}", line);
if (line.startsWith("Content-Length")) {
String[] tokens = line.replaceAll(" ", "").split(":");
if (tokens.length >= 2) {
contentLength = Integer.parseInt(tokens[1]);
}
}
}
log.debug("Calculated contentLength: {}", contentLength);
log.debug("Read the header:\n{}\n", builder.toString());
// Get the Content-Length and read those - this is expected to be the serialised Payment
if (contentLength > -1) {
byte buffer[] = new byte[contentLength];
for (int i = 0; i < contentLength; i++) {
buffer[i] = (byte) inputStream.read();
}
log.debug("Read:\n", HexUtils.toHexBytes(buffer));
try {
Protos.Payment payment = Protos.Payment.parseFrom(buffer);
log.debug("Successfully parsed a payment {}", payment);
// Create a PaymentACK for the payment
Protos.PaymentACK paymentAck =
PaymentProtocol.createPaymentAck(payment, "You sent: '" + payment.getMemo() + "'");
log.debug("Sending paymentACK as a response: {}", paymentAck);
// Write the HTTP header
outputStream.write("HTTP/1.0 200 OK\n".getBytes(Charsets.UTF_8));
outputStream.write("Content-Type: ".getBytes(Charsets.UTF_8));
outputStream.write(contentType.getBytes(Charsets.UTF_8));
outputStream.write("\n\n".getBytes(Charsets.UTF_8));
// Write the protobuf response
paymentAck.writeTo(outputStream);
// ByteArrayInputStream responseInputStream = new ByteArrayInputStream(paymentAckBytes);
// ByteStreams.copy(responseInputStream, outputStream);
} catch (com.google.protobuf.InvalidProtocolBufferException ipbe) {
log.error("Was expecting a Payment on the socket but saw something else");
ipbe.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
// Release resources
log.debug("Flush then close client socket...");
socket.getOutputStream().flush();
socket.close();
}
} else {
log.debug("Could not find a Content-Length in the header so not reading payment");
}
return true;
} catch (IOException e) {
throw new IllegalStateException("Unexpected IOException", e);
}
}
}
/**
* 处理连接认证
*
* @param ctx
* @param bodyData
*/
void ShakeHand(ChannelHandlerContext ctx, byte[] bodyData, short reqSeqnum) {
try {
XFileProtocol.ShakeHand shakeHand = XFileProtocol.ShakeHand.parseFrom(bodyData);
int step = shakeHand.getStep();
switch (step) {
case 1:
// 验证服务端是否需要验证,是否需要输入密码
if (SysConstant.VERIFY) {
// 提示客户端输入密码
XFileProtocol.ShakeHand.Builder rspShakeHand = XFileProtocol.ShakeHand.newBuilder();
rspShakeHand.setStep(1);
rspShakeHand.setVerify(true);
short sid = SysConstant.SERVICE_DEFAULT;
short cid = SysConstant.CMD_SHAKE_HAND;
sendMessage(ctx, sid, cid, rspShakeHand.build(), null, reqSeqnum);
} else {
// 保存认证的连接
this.setAuthChannelHandlerContext(ctx);
// 提示客户端连接成功
XFileProtocol.ShakeHand.Builder rspShakeHand = XFileProtocol.ShakeHand.newBuilder();
rspShakeHand.setStep(1);
rspShakeHand.setVerify(false);
rspShakeHand.setToken(SysConstant.TOKEN);
short sid = SysConstant.SERVICE_DEFAULT;
short cid = SysConstant.CMD_SHAKE_HAND;
logger.e("****ServerMessage-Response1111");
sendMessage(ctx, sid, cid, rspShakeHand.build(), null, reqSeqnum);
logger.e("****ServerMessage-Response2222");
}
break;
case 2:
String reqPassword = shakeHand.getPassword();
if (SysConstant.PASS_WORD.equals(reqPassword)) {
// 保存认证的连接
this.setAuthChannelHandlerContext(ctx);
// 生成服务器生成服务器token通知客户端
IMServerFileManager.getInstance().setToken(SysConstant.TOKEN);
// 发送消息提示客户端
XFileProtocol.ShakeHand.Builder rspShakeHand = XFileProtocol.ShakeHand.newBuilder();
rspShakeHand.setStep(2);
rspShakeHand.setResult(true);
rspShakeHand.setToken(SysConstant.TOKEN);
short sid = SysConstant.SERVICE_DEFAULT;
short cid = SysConstant.CMD_SHAKE_HAND;
sendMessage(sid, cid, rspShakeHand.build());
} else {
// 认证失败
XFileProtocol.ShakeHand.Builder rspShakeHand = XFileProtocol.ShakeHand.newBuilder();
rspShakeHand.setStep(2);
rspShakeHand.setResult(false);
short sid = SysConstant.SERVICE_DEFAULT;
short cid = SysConstant.CMD_SHAKE_HAND;
sendMessage(ctx, sid, cid, rspShakeHand.build(), null, reqSeqnum);
ctx.close();
}
break;
}
} catch (InvalidProtocolBufferException e) {
e.printStackTrace();
}
}
