public void release() { if (message != null) { message.release(); } // release partial data if (data != null) { data.release(); } if (dataMap != null) { for (Data data : dataMap.dataMap().values()) { data.release(); } } if (buffer != null) { buffer.release(); } if (currentTrackerData != null) { currentTrackerData.release(); } if (trackerData != null) { for (Data data : trackerData.peerAddresses().values()) { data.release(); } } }
/* handle a given action/message */ private void doAction(String action, DataMap dataMap) { switch (action) { case ACTION_FEEDBACK: boolean ok = dataMap.getBoolean(EXTRA_STATUS); String toast = ok ? "PATTERN PLAYED (ack)" : "Error on the watch..."; Log.d(getPackageName(), toast); // Toast.makeText( getApplicationContext(), toast, Toast.LENGTH_SHORT // ).show(); break; case ACTION_GET_CONTACTS: SendToWearableService.sendContacts(getContactsList()); break; case ACTION_SEND_MSG: String phone = dataMap.getString(EXTRA_PHONE); long[] pattern = dataMap.getLongArray(EXTRA_PATTERN); String text = dataMap.getString(EXTRA_TEXT); if (phone != null && pattern.length > 0) { GcmSenderService.sendMessage(phone, pattern, text); } break; case ACTION_OPEN: String number = dataMap.getString(EXTRA_PHONE); // don't know why, but the extras are only passed with a pendingIntent... try { Intent intent = new Intent(getApplicationContext(), MainActivity.class); intent.putExtra(GcmConstants.FROM_KEY, number); PendingIntent pendingIntent = PendingIntent.getActivity( getApplicationContext(), 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); pendingIntent.send(getApplicationContext(), 0, new Intent()); } catch (PendingIntent.CanceledException e) { e.printStackTrace(); } break; default: break; } }
@Override public void onDataChanged(DataEventBuffer dataEvents) { DataMap dataMap; for (DataEvent event : dataEvents) { // Check the data type if (event.getType() == DataEvent.TYPE_CHANGED) { // Check the data path dataMap = DataMapItem.fromDataItem(event.getDataItem()).getDataMap(); String path = event.getDataItem().getUri().getPath(); if (path.equals(WEARABLE_TO_PHONE_DATA_PATH) && dataMap.containsKey(ACTION_KEY)) { doAction(dataMap.getString(ACTION_KEY), dataMap); } } } }
private DataMap create(DataItem dataItem) { if ((dataItem.getData() == null) && (dataItem.getAssets().size() > 0)) throw new IllegalArgumentException("Cannot create DataMapItem from an empty DataItem."); if (dataItem.getData() == null) return new DataMap(); try { byte[] data = dataItem.getData(); DataMap dataMap = DataMap.fromByteArray(data); if (dataItem.getAssets() != null) { Iterator<String> iterator = dataItem.getAssets().keySet().iterator(); while (iterator.hasNext()) { String key = (String) iterator.next(); DataItemAsset dataItemAsset = (DataItemAsset) dataItem.getAssets().get(key); String[] pathArray = key.split("_@_"); Log.e("spencer", "key = " + key + " pathArray = " + Arrays.toString(pathArray)); DataMap localDataMap2 = dataMap; for (int i = 0; i < pathArray.length - 1; i++) { String str2 = pathArray[(i + 1)]; String[] indexArray = str2.split("_#_"); if (indexArray.length == 1) { localDataMap2 = localDataMap2.getDataMap(pathArray[i]); } else { int j = Integer.parseInt(indexArray[0]); localDataMap2 = (DataMap) localDataMap2.getDataMapArrayList(pathArray[i]).get(j); pathArray[(i + 1)] = indexArray[1]; } } Log.e( "spencer", "putAsset -> " + pathArray[(pathArray.length - 1)] + " " + dataItemAsset.getId()); localDataMap2.putAsset( pathArray[(pathArray.length - 1)], Asset.createFromRef(dataItemAsset.getId())); } } return dataMap; } catch (Exception e) { Log.e("DataMapItem", "parse a DataItem failed.", e); throw new IllegalStateException("parse a DataItem failed.", e); } }
public boolean decodePayload(final ByteBuf buf) throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException { LOG.debug( "About to pass message {} to {}. Buffer to read: {}.", message, message.senderSocket(), buf.readableBytes()); if (!message.hasContent()) { return true; } // payload comes here int size; PublicKey receivedPublicKey; while (contentTypes.size() > 0) { Content content = contentTypes.peek(); LOG.debug("Parse content: {} in message {}", content, message); switch (content) { case INTEGER: if (buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) { return false; } message.intValue(buf.readInt()); lastContent = contentTypes.poll(); break; case LONG: if (buf.readableBytes() < Utils.LONG_BYTE_SIZE) { return false; } message.longValue(buf.readLong()); lastContent = contentTypes.poll(); break; case KEY: if (buf.readableBytes() < Number160.BYTE_ARRAY_SIZE) { return false; } byte[] me = new byte[Number160.BYTE_ARRAY_SIZE]; buf.readBytes(me); message.key(new Number160(me)); lastContent = contentTypes.poll(); break; case BLOOM_FILTER: if (buf.readableBytes() < Utils.SHORT_BYTE_SIZE) { return false; } size = buf.getUnsignedShort(buf.readerIndex()); if (buf.readableBytes() < size) { return false; } message.bloomFilter(new SimpleBloomFilter<Number160>(buf)); lastContent = contentTypes.poll(); break; case SET_NEIGHBORS: if (neighborSize == -1 && buf.readableBytes() < Utils.BYTE_BYTE_SIZE) { return false; } if (neighborSize == -1) { neighborSize = buf.readUnsignedByte(); } if (neighborSet == null) { neighborSet = new NeighborSet(-1, new ArrayList<PeerAddress>(neighborSize)); } for (int i = neighborSet.size(); i < neighborSize; i++) { if (buf.readableBytes() < Utils.SHORT_BYTE_SIZE) { return false; } int header = buf.getUnsignedShort(buf.readerIndex()); size = PeerAddress.size(header); if (buf.readableBytes() < size) { return false; } PeerAddress pa = new PeerAddress(buf); neighborSet.add(pa); } message.neighborsSet(neighborSet); lastContent = contentTypes.poll(); neighborSize = -1; neighborSet = null; break; case SET_PEER_SOCKET: if (peerSocketAddressSize == -1 && buf.readableBytes() < Utils.BYTE_BYTE_SIZE) { return false; } if (peerSocketAddressSize == -1) { peerSocketAddressSize = buf.readUnsignedByte(); } if (peerSocketAddresses == null) { peerSocketAddresses = new ArrayList<PeerSocketAddress>(peerSocketAddressSize); } for (int i = peerSocketAddresses.size(); i < peerSocketAddressSize; i++) { if (buf.readableBytes() < Utils.BYTE_BYTE_SIZE) { return false; } int header = buf.getUnsignedByte(buf.readerIndex()); boolean isIPv4 = header == 0; size = PeerSocketAddress.size(isIPv4); if (buf.readableBytes() < size + Utils.BYTE_BYTE_SIZE) { return false; } // skip the ipv4/ipv6 header buf.skipBytes(1); peerSocketAddresses.add(PeerSocketAddress.create(buf, isIPv4)); } message.peerSocketAddresses(peerSocketAddresses); lastContent = contentTypes.poll(); peerSocketAddressSize = -1; peerSocketAddresses = null; break; case SET_KEY640: if (keyCollectionSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) { return false; } if (keyCollectionSize == -1) { keyCollectionSize = buf.readInt(); } if (keyCollection == null) { keyCollection = new KeyCollection(new ArrayList<Number640>(keyCollectionSize)); } for (int i = keyCollection.size(); i < keyCollectionSize; i++) { if (buf.readableBytes() < Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE) { return false; } byte[] me2 = new byte[Number160.BYTE_ARRAY_SIZE]; buf.readBytes(me2); Number160 locationKey = new Number160(me2); buf.readBytes(me2); Number160 domainKey = new Number160(me2); buf.readBytes(me2); Number160 contentKey = new Number160(me2); buf.readBytes(me2); Number160 versionKey = new Number160(me2); keyCollection.add(new Number640(locationKey, domainKey, contentKey, versionKey)); } message.keyCollection(keyCollection); lastContent = contentTypes.poll(); keyCollectionSize = -1; keyCollection = null; break; case MAP_KEY640_DATA: if (mapSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) { return false; } if (mapSize == -1) { mapSize = buf.readInt(); } if (dataMap == null) { dataMap = new DataMap(new TreeMap<Number640, Data>()); } if (data != null) { if (!data.decodeBuffer(buf)) { return false; } if (!data.decodeDone(buf, message.publicKey(0), signatureFactory)) { return false; } data = null; key = null; } for (int i = dataMap.size(); i < mapSize; i++) { if (key == null) { if (buf.readableBytes() < Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE) { return false; } byte[] me3 = new byte[Number160.BYTE_ARRAY_SIZE]; buf.readBytes(me3); Number160 locationKey = new Number160(me3); buf.readBytes(me3); Number160 domainKey = new Number160(me3); buf.readBytes(me3); Number160 contentKey = new Number160(me3); buf.readBytes(me3); Number160 versionKey = new Number160(me3); key = new Number640(locationKey, domainKey, contentKey, versionKey); } LOG.debug("Key decoded in message {}, remaining {}", message, buf.readableBytes()); data = Data.decodeHeader(buf, signatureFactory); if (data == null) { return false; } LOG.debug("Header decoded in message {}, remaining {}", message, buf.readableBytes()); dataMap.dataMap().put(key, data); if (!data.decodeBuffer(buf)) { return false; } LOG.debug("Buffer decoded in message {}", message); if (!data.decodeDone(buf, message.publicKey(0), signatureFactory)) { return false; } LOG.debug("Done decoded in message {}", message); // if we have signed the message, set the public key anyway, but only if we indicated so inheritPublicKey(message, data); data = null; key = null; } message.setDataMap(dataMap); lastContent = contentTypes.poll(); mapSize = -1; dataMap = null; break; case MAP_KEY640_KEYS: if (keyMap640KeysSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) { return false; } if (keyMap640KeysSize == -1) { keyMap640KeysSize = buf.readInt(); } if (keyMap640Keys == null) { keyMap640Keys = new KeyMap640Keys(new TreeMap<Number640, Collection<Number160>>()); } final int meta = Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE; for (int i = keyMap640Keys.size(); i < keyMap640KeysSize; i++) { if (buf.readableBytes() < meta + Utils.BYTE_BYTE_SIZE) { return false; } size = buf.getUnsignedByte(buf.readerIndex() + meta); if (buf.readableBytes() < meta + Utils.BYTE_BYTE_SIZE + (size * Number160.BYTE_ARRAY_SIZE)) { return false; } byte[] me3 = new byte[Number160.BYTE_ARRAY_SIZE]; buf.readBytes(me3); Number160 locationKey = new Number160(me3); buf.readBytes(me3); Number160 domainKey = new Number160(me3); buf.readBytes(me3); Number160 contentKey = new Number160(me3); buf.readBytes(me3); Number160 versionKey = new Number160(me3); int numBasedOn = buf.readByte(); Set<Number160> value = new HashSet<Number160>(numBasedOn); for (int j = 0; j < numBasedOn; j++) { buf.readBytes(me3); Number160 basedOnKey = new Number160(me3); value.add(basedOnKey); } keyMap640Keys.put(new Number640(locationKey, domainKey, contentKey, versionKey), value); } message.keyMap640Keys(keyMap640Keys); lastContent = contentTypes.poll(); keyMap640KeysSize = -1; keyMap640Keys = null; break; case MAP_KEY640_BYTE: if (keyMapByteSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) { return false; } if (keyMapByteSize == -1) { keyMapByteSize = buf.readInt(); } if (keyMapByte == null) { keyMapByte = new KeyMapByte(new HashMap<Number640, Byte>(2 * keyMapByteSize)); } for (int i = keyMapByte.size(); i < keyMapByteSize; i++) { if (buf.readableBytes() < Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + Number160.BYTE_ARRAY_SIZE + 1) { return false; } byte[] me3 = new byte[Number160.BYTE_ARRAY_SIZE]; buf.readBytes(me3); Number160 locationKey = new Number160(me3); buf.readBytes(me3); Number160 domainKey = new Number160(me3); buf.readBytes(me3); Number160 contentKey = new Number160(me3); buf.readBytes(me3); Number160 versionKey = new Number160(me3); byte value = buf.readByte(); keyMapByte.put(new Number640(locationKey, domainKey, contentKey, versionKey), value); } message.keyMapByte(keyMapByte); lastContent = contentTypes.poll(); keyMapByteSize = -1; keyMapByte = null; break; case BYTE_BUFFER: if (bufferSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) { return false; } if (bufferSize == -1) { bufferSize = buf.readInt(); } if (buffer == null) { buffer = new DataBuffer(); } final int remaining = bufferSize - bufferTransferred; bufferTransferred += buffer.transferFrom(buf, remaining); if (bufferTransferred < bufferSize) { LOG.debug( "Still looking for data. Indicating that its not finished yet. Already Transferred = {}, Size = {}.", bufferTransferred, bufferSize); return false; } message.buffer(new Buffer(buffer.toByteBuf(), bufferSize)); lastContent = contentTypes.poll(); bufferSize = -1; bufferTransferred = 0; buffer = null; break; case SET_TRACKER_DATA: if (trackerDataSize == -1 && buf.readableBytes() < Utils.BYTE_BYTE_SIZE) { return false; } if (trackerDataSize == -1) { trackerDataSize = buf.readUnsignedByte(); } if (trackerData == null) { trackerData = new TrackerData(new HashMap<PeerAddress, Data>(2 * trackerDataSize)); } if (currentTrackerData != null) { if (!currentTrackerData.decodeBuffer(buf)) { return false; } if (!currentTrackerData.decodeDone(buf, message.publicKey(0), signatureFactory)) { return false; } currentTrackerData = null; } for (int i = trackerData.size(); i < trackerDataSize; i++) { if (buf.readableBytes() < Utils.SHORT_BYTE_SIZE) { return false; } int header = buf.getUnsignedShort(buf.readerIndex()); size = PeerAddress.size(header); if (buf.readableBytes() < size) { return false; } PeerAddress pa = new PeerAddress(buf); currentTrackerData = Data.decodeHeader(buf, signatureFactory); if (currentTrackerData == null) { return false; } trackerData.peerAddresses().put(pa, currentTrackerData); if (message.isSign()) { currentTrackerData.publicKey(message.publicKey(0)); } if (!currentTrackerData.decodeBuffer(buf)) { return false; } if (!currentTrackerData.decodeDone(buf, message.publicKey(0), signatureFactory)) { return false; } currentTrackerData = null; } message.trackerData(trackerData); lastContent = contentTypes.poll(); trackerDataSize = -1; trackerData = null; break; case PUBLIC_KEY: // fall-through case PUBLIC_KEY_SIGNATURE: receivedPublicKey = signatureFactory.decodePublicKey(buf); if (content == Content.PUBLIC_KEY_SIGNATURE) { if (receivedPublicKey == PeerBuilder.EMPTY_PUBLIC_KEY) { throw new InvalidKeyException("The public key cannot be empty."); } } if (receivedPublicKey == null) { return false; } message.publicKey(receivedPublicKey); lastContent = contentTypes.poll(); break; default: break; } } LOG.debug("Parsed content in message {}", message); if (message.isSign()) { size = signatureFactory.signatureSize(); if (buf.readableBytes() < size) { return false; } SignatureCodec signatureEncode = signatureFactory.signatureCodec(buf); message.receivedSignature(signatureEncode); } return true; }