From 66e1ee6e7cbc5a4096764ccef96fd3f0ffd3ea71 Mon Sep 17 00:00:00 2001 From: Greyson Parrelli Date: Fri, 19 Apr 2019 10:52:05 -0400 Subject: [PATCH] Add support for stickers --- .../api/SignalServiceMessageReceiver.java | 46 +- .../api/SignalServiceMessageSender.java | 47 + .../crypto/AttachmentCipherInputStream.java | 53 +- .../api/crypto/SignalServiceCipher.java | 44 +- .../messages/SignalServiceDataMessage.java | 49 +- .../SignalServiceStickerManifest.java | 56 + .../multidevice/SignalServiceSyncMessage.java | 99 +- .../StickerPackOperationMessage.java | 32 + .../internal/push/PushServiceSocket.java | 49 +- .../internal/push/SignalServiceProtos.java | 2217 ++++++++++++++++- .../internal/sticker/StickerProtos.java | 1798 +++++++++++++ .../api/crypto/AttachmentCipherTest.java | 244 ++ protobuf/Makefile | 2 +- protobuf/SignalService.proto | 39 +- protobuf/StickerResources.proto | 23 + 15 files changed, 4625 insertions(+), 173 deletions(-) create mode 100644 java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceStickerManifest.java create mode 100644 java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/StickerPackOperationMessage.java create mode 100644 java/src/main/java/org/whispersystems/signalservice/internal/sticker/StickerProtos.java create mode 100644 java/src/test/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherTest.java create mode 100644 protobuf/StickerResources.proto diff --git a/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageReceiver.java b/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageReceiver.java index 7af063c..cf0e9b2 100644 --- a/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageReceiver.java +++ b/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageReceiver.java @@ -15,6 +15,7 @@ import org.whispersystems.signalservice.api.messages.SignalServiceAttachment.Pro import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer; import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage; import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope; +import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifest; import org.whispersystems.signalservice.api.profiles.SignalServiceProfile; import org.whispersystems.signalservice.api.push.SignalServiceAddress; import org.whispersystems.signalservice.api.util.CredentialsProvider; @@ -23,13 +24,18 @@ import org.whispersystems.signalservice.api.websocket.ConnectivityListener; import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration; import org.whispersystems.signalservice.internal.push.PushServiceSocket; import org.whispersystems.signalservice.internal.push.SignalServiceEnvelopeEntity; +import org.whispersystems.signalservice.internal.push.SignalServiceProtos; +import org.whispersystems.signalservice.internal.sticker.StickerProtos; import org.whispersystems.signalservice.internal.util.StaticCredentialsProvider; +import org.whispersystems.signalservice.internal.util.Util; import org.whispersystems.signalservice.internal.websocket.WebSocketConnection; +import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; +import java.util.ArrayList; import java.util.LinkedList; import java.util.List; @@ -133,7 +139,45 @@ public class SignalServiceMessageReceiver { if (!pointer.getDigest().isPresent()) throw new InvalidMessageException("No attachment digest!"); socket.retrieveAttachment(pointer.getId(), destination, maxSizeBytes, listener); - return AttachmentCipherInputStream.createFor(destination, pointer.getSize().or(0), pointer.getKey(), pointer.getDigest().get()); + return AttachmentCipherInputStream.createForAttachment(destination, pointer.getSize().or(0), pointer.getKey(), pointer.getDigest().get()); + } + + public InputStream retrieveSticker(byte[] packId, byte[] packKey, int stickerId) + throws IOException, InvalidMessageException + { + byte[] data = socket.retrieveSticker(packId, stickerId); + return AttachmentCipherInputStream.createForStickerData(data, packKey); + } + + /** + * Retrieves a {@link SignalServiceStickerManifest}. + * + * @param packId The 16-byte packId that identifies the sticker pack. + * @param packKey The 32-byte packKey that decrypts the sticker pack. + * @return The {@link SignalServiceStickerManifest} representing the sticker pack. + * @throws IOException + * @throws InvalidMessageException + */ + public SignalServiceStickerManifest retrieveStickerManifest(byte[] packId, byte[] packKey) + throws IOException, InvalidMessageException + { + byte[] manifestBytes = socket.retrieveStickerManifest(packId); + + InputStream cipherStream = AttachmentCipherInputStream.createForStickerData(manifestBytes, packKey); + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + Util.copy(cipherStream, outputStream); + + StickerProtos.Pack pack = StickerProtos.Pack.parseFrom(outputStream.toByteArray()); + List stickers = new ArrayList<>(pack.getStickersCount()); + SignalServiceStickerManifest.StickerInfo cover = pack.hasCover() ? new SignalServiceStickerManifest.StickerInfo(pack.getCover().getId(), pack.getCover().getEmoji()) + : null; + + for (StickerProtos.Pack.Sticker sticker : pack.getStickersList()) { + stickers.add(new SignalServiceStickerManifest.StickerInfo(sticker.getId(), sticker.getEmoji())); + } + + return new SignalServiceStickerManifest(pack.getTitle(), pack.getAuthor(), cover, stickers); } /** diff --git a/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageSender.java b/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageSender.java index 39ebd35..443ffd6 100644 --- a/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageSender.java +++ b/java/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageSender.java @@ -38,6 +38,7 @@ import org.whispersystems.signalservice.api.messages.multidevice.ConfigurationMe import org.whispersystems.signalservice.api.messages.multidevice.ReadMessage; import org.whispersystems.signalservice.api.messages.multidevice.SentTranscriptMessage; import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; +import org.whispersystems.signalservice.api.messages.multidevice.StickerPackOperationMessage; import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage; import org.whispersystems.signalservice.api.messages.shared.SharedContact; import org.whispersystems.signalservice.api.push.SignalServiceAddress; @@ -284,6 +285,8 @@ public class SignalServiceMessageSender { content = createMultiDeviceConfigurationContent(message.getConfiguration().get()); } else if (message.getSent().isPresent()) { content = createMultiDeviceSentTranscriptContent(message.getSent().get(), unidentifiedAccess); + } else if (message.getStickerPackOperations().isPresent()) { + content = createMultiDeviceStickerPackOperationContent(message.getStickerPackOperations().get()); } else if (message.getVerified().isPresent()) { sendMessage(message.getVerified().get(), unidentifiedAccess); return; @@ -486,6 +489,22 @@ public class SignalServiceMessageSender { } } + if (message.getSticker().isPresent()) { + DataMessage.Sticker.Builder stickerBuilder = DataMessage.Sticker.newBuilder(); + + stickerBuilder.setPackId(ByteString.copyFrom(message.getSticker().get().getPackId())); + stickerBuilder.setPackKey(ByteString.copyFrom(message.getSticker().get().getPackKey())); + stickerBuilder.setStickerId(message.getSticker().get().getStickerId()); + + if (message.getSticker().get().getAttachment().isStream()) { + stickerBuilder.setData(createAttachmentPointer(message.getSticker().get().getAttachment().asStream())); + } else { + stickerBuilder.setData(createAttachmentPointer(message.getSticker().get().getAttachment().asPointer())); + } + + builder.setSticker(stickerBuilder.build()); + } + builder.setTimestamp(message.getTimestamp()); return container.setDataMessage(builder).build().toByteArray(); @@ -639,6 +658,34 @@ public class SignalServiceMessageSender { return container.setSyncMessage(syncMessage.setConfiguration(configurationMessage)).build().toByteArray(); } + private byte[] createMultiDeviceStickerPackOperationContent(List stickerPackOperations) { + Content.Builder container = Content.newBuilder(); + SyncMessage.Builder syncMessage = createSyncMessageBuilder(); + + for (StickerPackOperationMessage stickerPackOperation : stickerPackOperations) { + SyncMessage.StickerPackOperation.Builder builder = SyncMessage.StickerPackOperation.newBuilder(); + + if (stickerPackOperation.getPackId().isPresent()) { + builder.setPackId(ByteString.copyFrom(stickerPackOperation.getPackId().get())); + } + + if (stickerPackOperation.getPackKey().isPresent()) { + builder.setPackKey(ByteString.copyFrom(stickerPackOperation.getPackKey().get())); + } + + if (stickerPackOperation.getType().isPresent()) { + switch (stickerPackOperation.getType().get()) { + case INSTALL: builder.setType(SyncMessage.StickerPackOperation.Type.INSTALL); break; + case REMOVE: builder.setType(SyncMessage.StickerPackOperation.Type.REMOVE); break; + } + } + + syncMessage.addStickerPackOperation(builder); + } + + return container.setSyncMessage(syncMessage).build().toByteArray(); + } + private byte[] createMultiDeviceVerifiedContent(VerifiedMessage verifiedMessage, byte[] nullMessage) { Content.Builder container = Content.newBuilder(); SyncMessage.Builder syncMessage = createSyncMessageBuilder(); diff --git a/java/src/main/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherInputStream.java b/java/src/main/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherInputStream.java index 666872e..0be5761 100644 --- a/java/src/main/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherInputStream.java +++ b/java/src/main/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherInputStream.java @@ -8,12 +8,13 @@ package org.whispersystems.signalservice.api.crypto; import org.whispersystems.libsignal.InvalidMacException; import org.whispersystems.libsignal.InvalidMessageException; +import org.whispersystems.libsignal.kdf.HKDFv3; import org.whispersystems.signalservice.internal.util.ContentLengthInputStream; import org.whispersystems.signalservice.internal.util.Util; +import java.io.ByteArrayInputStream; import java.io.File; import java.io.FileInputStream; -import java.io.FileNotFoundException; import java.io.FilterInputStream; import java.io.IOException; import java.io.InputStream; @@ -50,7 +51,7 @@ public class AttachmentCipherInputStream extends FilterInputStream { private long totalRead; private byte[] overflowBuffer; - public static InputStream createFor(File file, long plaintextLength, byte[] combinedKeyMaterial, byte[] digest) + public static InputStream createForAttachment(File file, long plaintextLength, byte[] combinedKeyMaterial, byte[] digest) throws InvalidMessageException, IOException { try { @@ -62,7 +63,13 @@ public class AttachmentCipherInputStream extends FilterInputStream { throw new InvalidMessageException("Message shorter than crypto overhead!"); } - verifyMac(file, mac, digest); + if (digest == null) { + throw new InvalidMacException("Missing digest!"); + } + + try (FileInputStream fin = new FileInputStream(file)) { + verifyMac(fin, file.length(), mac, digest); + } InputStream inputStream = new AttachmentCipherInputStream(new FileInputStream(file), parts[0], file.length() - BLOCK_SIZE - mac.getMacLength()); @@ -78,6 +85,31 @@ public class AttachmentCipherInputStream extends FilterInputStream { } } + public static InputStream createForStickerData(byte[] data, byte[] packKey) + throws InvalidMessageException, IOException + { + try { + byte[] combinedKeyMaterial = new HKDFv3().deriveSecrets(packKey, "Sticker Pack".getBytes(), 64); + byte[][] parts = Util.split(combinedKeyMaterial, CIPHER_KEY_SIZE, MAC_KEY_SIZE); + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(new SecretKeySpec(parts[1], "HmacSHA256")); + + if (data.length <= BLOCK_SIZE + mac.getMacLength()) { + throw new InvalidMessageException("Message shorter than crypto overhead!"); + } + + try (InputStream inputStream = new ByteArrayInputStream(data)) { + verifyMac(inputStream, data.length, mac, null); + } + + return new AttachmentCipherInputStream(new ByteArrayInputStream(data), parts[0], data.length - BLOCK_SIZE - mac.getMacLength()); + } catch (NoSuchAlgorithmException | InvalidKeyException e) { + throw new AssertionError(e); + } catch (InvalidMacException e) { + throw new InvalidMessageException(e); + } + } + private AttachmentCipherInputStream(InputStream inputStream, byte[] cipherKey, long totalDataSize) throws IOException { @@ -190,17 +222,16 @@ public class AttachmentCipherInputStream extends FilterInputStream { } } - private static void verifyMac(File file, Mac mac, byte[] theirDigest) - throws FileNotFoundException, InvalidMacException + private static void verifyMac(InputStream inputStream, long length, Mac mac, byte[] theirDigest) + throws InvalidMacException { try { MessageDigest digest = MessageDigest.getInstance("SHA256"); - FileInputStream fin = new FileInputStream(file); - int remainingData = Util.toIntExact(file.length()) - mac.getMacLength(); + int remainingData = Util.toIntExact(length) - mac.getMacLength(); byte[] buffer = new byte[4096]; while (remainingData > 0) { - int read = fin.read(buffer, 0, Math.min(buffer.length, remainingData)); + int read = inputStream.read(buffer, 0, Math.min(buffer.length, remainingData)); mac.update(buffer, 0, read); digest.update(buffer, 0, read); remainingData -= read; @@ -208,7 +239,7 @@ public class AttachmentCipherInputStream extends FilterInputStream { byte[] ourMac = mac.doFinal(); byte[] theirMac = new byte[mac.getMacLength()]; - Util.readFully(fin, theirMac); + Util.readFully(inputStream, theirMac); if (!MessageDigest.isEqual(ourMac, theirMac)) { throw new InvalidMacException("MAC doesn't match!"); @@ -216,7 +247,7 @@ public class AttachmentCipherInputStream extends FilterInputStream { byte[] ourDigest = digest.digest(theirMac); - if (!MessageDigest.isEqual(ourDigest, theirDigest)) { + if (theirDigest != null && !MessageDigest.isEqual(ourDigest, theirDigest)) { throw new InvalidMacException("Digest doesn't match!"); } @@ -237,6 +268,4 @@ public class AttachmentCipherInputStream extends FilterInputStream { else return; } } - - } diff --git a/java/src/main/java/org/whispersystems/signalservice/api/crypto/SignalServiceCipher.java b/java/src/main/java/org/whispersystems/signalservice/api/crypto/SignalServiceCipher.java index fb47027..465dbf8 100644 --- a/java/src/main/java/org/whispersystems/signalservice/api/crypto/SignalServiceCipher.java +++ b/java/src/main/java/org/whispersystems/signalservice/api/crypto/SignalServiceCipher.java @@ -43,6 +43,7 @@ import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPoin import org.whispersystems.signalservice.api.messages.SignalServiceContent; import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage; import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage.Preview; +import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage.Sticker; import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope; import org.whispersystems.signalservice.api.messages.SignalServiceGroup; import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage; @@ -57,6 +58,7 @@ import org.whispersystems.signalservice.api.messages.multidevice.ReadMessage; import org.whispersystems.signalservice.api.messages.multidevice.RequestMessage; import org.whispersystems.signalservice.api.messages.multidevice.SentTranscriptMessage; import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; +import org.whispersystems.signalservice.api.messages.multidevice.StickerPackOperationMessage; import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage; import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage.VerifiedState; import org.whispersystems.signalservice.api.messages.shared.SharedContact; @@ -270,6 +272,7 @@ public class SignalServiceCipher { SignalServiceDataMessage.Quote quote = createQuote(content); List sharedContacts = createSharedContacts(content); List previews = createPreviews(content); + Sticker sticker = createSticker(content); for (AttachmentPointer pointer : content.getAttachmentsList()) { attachments.add(createAttachmentPointer(pointer)); @@ -292,7 +295,8 @@ public class SignalServiceCipher { profileKeyUpdate, quote, sharedContacts, - previews); + previews, + sticker); } private SignalServiceSyncMessage createSynchronizeMessage(Metadata metadata, SyncMessage content) @@ -352,6 +356,26 @@ public class SignalServiceCipher { } } + if (content.getStickerPackOperationList().size() > 0) { + List operations = new LinkedList<>(); + + for (SyncMessage.StickerPackOperation operation : content.getStickerPackOperationList()) { + byte[] packId = operation.hasPackId() ? operation.getPackId().toByteArray() : null; + byte[] packKey = operation.hasPackKey() ? operation.getPackKey().toByteArray() : null; + StickerPackOperationMessage.Type type = null; + + if (operation.hasType()) { + switch (operation.getType()) { + case INSTALL: type = StickerPackOperationMessage.Type.INSTALL; break; + case REMOVE: type = StickerPackOperationMessage.Type.REMOVE; break; + } + } + operations.add(new StickerPackOperationMessage(packId, packKey, type)); + } + + return SignalServiceSyncMessage.forStickerPackOperations(operations); + } + return SignalServiceSyncMessage.empty(); } @@ -446,6 +470,24 @@ public class SignalServiceCipher { return results; } + private Sticker createSticker(DataMessage content) { + if (!content.hasSticker() || + !content.getSticker().hasPackId() || + !content.getSticker().hasPackKey() || + !content.getSticker().hasStickerId() || + !content.getSticker().hasData()) + { + return null; + } + + DataMessage.Sticker sticker = content.getSticker(); + + return new Sticker(sticker.getPackId().toByteArray(), + sticker.getPackKey().toByteArray(), + sticker.getStickerId(), + createAttachmentPointer(sticker.getData())); + } + private List createSharedContacts(DataMessage content) { if (content.getContactCount() <= 0) return null; diff --git a/java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceDataMessage.java b/java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceDataMessage.java index 8090131..3472b5b 100644 --- a/java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceDataMessage.java +++ b/java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceDataMessage.java @@ -30,6 +30,7 @@ public class SignalServiceDataMessage { private final Optional quote; private final Optional> contacts; private final Optional> previews; + private final Optional sticker; /** * Construct a SignalServiceDataMessage with a body and no attachments. @@ -103,7 +104,7 @@ public class SignalServiceDataMessage { * @param expiresInSeconds The number of seconds in which a message should disappear after having been seen. */ public SignalServiceDataMessage(long timestamp, SignalServiceGroup group, List attachments, String body, int expiresInSeconds) { - this(timestamp, group, attachments, body, false, expiresInSeconds, false, null, false, null, null, null); + this(timestamp, group, attachments, body, false, expiresInSeconds, false, null, false, null, null, null, null); } /** @@ -120,7 +121,8 @@ public class SignalServiceDataMessage { List attachments, String body, boolean endSession, int expiresInSeconds, boolean expirationUpdate, byte[] profileKey, boolean profileKeyUpdate, - Quote quote, List sharedContacts, List previews) + Quote quote, List sharedContacts, List previews, + Sticker sticker) { this.timestamp = timestamp; this.body = Optional.fromNullable(body); @@ -131,6 +133,7 @@ public class SignalServiceDataMessage { this.profileKey = Optional.fromNullable(profileKey); this.profileKeyUpdate = profileKeyUpdate; this.quote = Optional.fromNullable(quote); + this.sticker = Optional.fromNullable(sticker); if (attachments != null && !attachments.isEmpty()) { this.attachments = Optional.of(attachments); @@ -219,6 +222,10 @@ public class SignalServiceDataMessage { return previews; } + public Optional getSticker() { + return sticker; + } + public static class Builder { private List attachments = new LinkedList<>(); @@ -234,6 +241,7 @@ public class SignalServiceDataMessage { private byte[] profileKey; private boolean profileKeyUpdate; private Quote quote; + private Sticker sticker; private Builder() {} @@ -315,11 +323,17 @@ public class SignalServiceDataMessage { return this; } + public Builder withSticker(Sticker sticker) { + this.sticker = sticker; + return this; + } + public SignalServiceDataMessage build() { if (timestamp == 0) timestamp = System.currentTimeMillis(); return new SignalServiceDataMessage(timestamp, group, attachments, body, endSession, expiresInSeconds, expirationUpdate, profileKey, - profileKeyUpdate, quote, sharedContacts, previews); + profileKeyUpdate, quote, sharedContacts, previews, + sticker); } } @@ -401,4 +415,33 @@ public class SignalServiceDataMessage { } } + public static class Sticker { + private final byte[] packId; + private final byte[] packKey; + private final int stickerId; + private final SignalServiceAttachment attachment; + + public Sticker(byte[] packId, byte[] packKey, int stickerId, SignalServiceAttachment attachment) { + this.packId = packId; + this.packKey = packKey; + this.stickerId = stickerId; + this.attachment = attachment; + } + + public byte[] getPackId() { + return packId; + } + + public byte[] getPackKey() { + return packKey; + } + + public int getStickerId() { + return stickerId; + } + + public SignalServiceAttachment getAttachment() { + return attachment; + } + } } diff --git a/java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceStickerManifest.java b/java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceStickerManifest.java new file mode 100644 index 0000000..419ea4c --- /dev/null +++ b/java/src/main/java/org/whispersystems/signalservice/api/messages/SignalServiceStickerManifest.java @@ -0,0 +1,56 @@ +package org.whispersystems.signalservice.api.messages; + +import org.whispersystems.libsignal.util.guava.Optional; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class SignalServiceStickerManifest { + + private final Optional title; + private final Optional author; + private final Optional cover; + private final List stickers; + + public SignalServiceStickerManifest(String title, String author, StickerInfo cover, List stickers) { + this.title = Optional.of(title); + this.author = Optional.of(author); + this.cover = Optional.of(cover); + this.stickers = (stickers == null) ? Collections.emptyList() : new ArrayList<>(stickers); + } + + public Optional getTitle() { + return title; + } + + public Optional getAuthor() { + return author; + } + + public Optional getCover() { + return cover; + } + + public List getStickers() { + return stickers; + } + + public static final class StickerInfo { + private final int id; + private final String emoji; + + public StickerInfo(int id, String emoji) { + this.id = id; + this.emoji = emoji; + } + + public int getId() { + return id; + } + + public String getEmoji() { + return emoji; + } + } +} diff --git a/java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/SignalServiceSyncMessage.java b/java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/SignalServiceSyncMessage.java index 1f4de9c..a0720f1 100644 --- a/java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/SignalServiceSyncMessage.java +++ b/java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/SignalServiceSyncMessage.java @@ -9,37 +9,42 @@ package org.whispersystems.signalservice.api.messages.multidevice; import org.whispersystems.libsignal.util.guava.Optional; import org.whispersystems.signalservice.api.messages.SignalServiceAttachment; +import java.util.ArrayList; +import java.util.Collections; import java.util.LinkedList; import java.util.List; public class SignalServiceSyncMessage { - private final Optional sent; - private final Optional contacts; - private final Optional groups; - private final Optional blockedList; - private final Optional request; - private final Optional> reads; - private final Optional verified; - private final Optional configuration; + private final Optional sent; + private final Optional contacts; + private final Optional groups; + private final Optional blockedList; + private final Optional request; + private final Optional> reads; + private final Optional verified; + private final Optional configuration; + private final Optional> stickerPackOperations; - private SignalServiceSyncMessage(Optional sent, - Optional contacts, - Optional groups, - Optional blockedList, - Optional request, - Optional> reads, - Optional verified, - Optional configuration) + private SignalServiceSyncMessage(Optional sent, + Optional contacts, + Optional groups, + Optional blockedList, + Optional request, + Optional> reads, + Optional verified, + Optional configuration, + Optional> stickerPackOperations) { - this.sent = sent; - this.contacts = contacts; - this.groups = groups; - this.blockedList = blockedList; - this.request = request; - this.reads = reads; - this.verified = verified; - this.configuration = configuration; + this.sent = sent; + this.contacts = contacts; + this.groups = groups; + this.blockedList = blockedList; + this.request = request; + this.reads = reads; + this.verified = verified; + this.configuration = configuration; + this.stickerPackOperations = stickerPackOperations; } public static SignalServiceSyncMessage forSentTranscript(SentTranscriptMessage sent) { @@ -50,7 +55,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.>absent(), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forContacts(ContactsMessage contacts) { @@ -61,7 +67,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.>absent(), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forGroups(SignalServiceAttachment groups) { @@ -72,7 +79,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.>absent(), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forRequest(RequestMessage request) { @@ -83,7 +91,8 @@ public class SignalServiceSyncMessage { Optional.of(request), Optional.>absent(), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forRead(List reads) { @@ -94,7 +103,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.of(reads), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forRead(ReadMessage read) { @@ -108,7 +118,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.of(reads), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forVerified(VerifiedMessage verifiedMessage) { @@ -119,7 +130,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.>absent(), Optional.of(verifiedMessage), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forBlocked(BlockedListMessage blocked) { @@ -130,7 +142,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.>absent(), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public static SignalServiceSyncMessage forConfiguration(ConfigurationMessage configuration) { @@ -141,7 +154,20 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.>absent(), Optional.absent(), - Optional.of(configuration)); + Optional.of(configuration), + Optional.>absent()); + } + + public static SignalServiceSyncMessage forStickerPackOperations(List stickerPackOperations) { + return new SignalServiceSyncMessage(Optional.absent(), + Optional.absent(), + Optional.absent(), + Optional.absent(), + Optional.absent(), + Optional.>absent(), + Optional.absent(), + Optional.absent(), + Optional.of(stickerPackOperations)); } public static SignalServiceSyncMessage empty() { @@ -152,7 +178,8 @@ public class SignalServiceSyncMessage { Optional.absent(), Optional.>absent(), Optional.absent(), - Optional.absent()); + Optional.absent(), + Optional.>absent()); } public Optional getSent() { @@ -187,4 +214,8 @@ public class SignalServiceSyncMessage { return configuration; } + public Optional> getStickerPackOperations() { + return stickerPackOperations; + } + } diff --git a/java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/StickerPackOperationMessage.java b/java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/StickerPackOperationMessage.java new file mode 100644 index 0000000..8e257f5 --- /dev/null +++ b/java/src/main/java/org/whispersystems/signalservice/api/messages/multidevice/StickerPackOperationMessage.java @@ -0,0 +1,32 @@ +package org.whispersystems.signalservice.api.messages.multidevice; + +import org.whispersystems.libsignal.util.guava.Optional; + +public class StickerPackOperationMessage { + + private final Optional packId; + private final Optional packKey; + private final Optional type; + + public StickerPackOperationMessage(byte[] packId, byte[] packKey, Type type) { + this.packId = Optional.fromNullable(packId); + this.packKey = Optional.fromNullable(packKey); + this.type = Optional.fromNullable(type); + } + + public Optional getPackId() { + return packId; + } + + public Optional getPackKey() { + return packKey; + } + + public Optional getType() { + return type; + } + + public enum Type { + INSTALL, REMOVE + } +} diff --git a/java/src/main/java/org/whispersystems/signalservice/internal/push/PushServiceSocket.java b/java/src/main/java/org/whispersystems/signalservice/internal/push/PushServiceSocket.java index 4afeb91..c19e7f8 100644 --- a/java/src/main/java/org/whispersystems/signalservice/internal/push/PushServiceSocket.java +++ b/java/src/main/java/org/whispersystems/signalservice/internal/push/PushServiceSocket.java @@ -47,9 +47,11 @@ import org.whispersystems.signalservice.internal.push.http.DigestingRequestBody; import org.whispersystems.signalservice.internal.push.http.OutputStreamFactory; import org.whispersystems.signalservice.internal.util.Base64; import org.whispersystems.signalservice.internal.util.BlacklistingTrustManager; +import org.whispersystems.signalservice.internal.util.Hex; import org.whispersystems.signalservice.internal.util.JsonUtil; import org.whispersystems.signalservice.internal.util.Util; +import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; @@ -72,7 +74,9 @@ import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; +import javax.net.ssl.HostnameVerifier; import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLSession; import javax.net.ssl.TrustManager; import javax.net.ssl.TrustManagerFactory; import javax.net.ssl.X509TrustManager; @@ -131,6 +135,9 @@ public class PushServiceSocket { private static final String ATTACHMENT_DOWNLOAD_PATH = "attachments/%d"; private static final String ATTACHMENT_UPLOAD_PATH = "attachments/"; + private static final String STICKER_MANIFEST_PATH = "stickers/%s/manifest.proto"; + private static final String STICKER_PATH = "stickers/%s/full/%d"; + private static final Map NO_HEADERS = Collections.emptyMap(); private static final ResponseCodeHandler NO_HANDLER = new EmptyResponseCodeHandler(); @@ -420,6 +427,35 @@ public class PushServiceSocket { downloadFromCdn(destination, String.format(ATTACHMENT_DOWNLOAD_PATH, attachmentId), maxSizeBytes, listener); } + public void retrieveSticker(File destination, byte[] packId, int stickerId) + throws NonSuccessfulResponseCodeException, PushNetworkException + { + String hexPackId = Hex.toStringCondensed(packId); + downloadFromCdn(destination, String.format(STICKER_PATH, hexPackId, stickerId), 1024 * 1024, null); + } + + public byte[] retrieveSticker(byte[] packId, int stickerId) + throws NonSuccessfulResponseCodeException, PushNetworkException + { + String hexPackId = Hex.toStringCondensed(packId); + ByteArrayOutputStream output = new ByteArrayOutputStream(); + + downloadFromCdn(output, String.format(STICKER_PATH, hexPackId, stickerId), 1024 * 1024, null); + + return output.toByteArray(); + } + + public byte[] retrieveStickerManifest(byte[] packId) + throws NonSuccessfulResponseCodeException, PushNetworkException + { + String hexPackId = Hex.toStringCondensed(packId); + ByteArrayOutputStream output = new ByteArrayOutputStream(); + + downloadFromCdn(output, String.format(STICKER_MANIFEST_PATH, hexPackId), 1024 * 1024, null); + + return output.toByteArray(); + } + public SignalServiceProfile retrieveProfile(SignalServiceAddress target, Optional unidentifiedAccess) throws NonSuccessfulResponseCodeException, PushNetworkException { @@ -599,6 +635,16 @@ public class PushServiceSocket { private void downloadFromCdn(File destination, String path, int maxSizeBytes, ProgressListener listener) throws PushNetworkException, NonSuccessfulResponseCodeException + { + try (FileOutputStream outputStream = new FileOutputStream(destination)) { + downloadFromCdn(outputStream, path, maxSizeBytes, listener); + } catch (IOException e) { + throw new PushNetworkException(e); + } + } + + private void downloadFromCdn(OutputStream outputStream, String path, int maxSizeBytes, ProgressListener listener) + throws PushNetworkException, NonSuccessfulResponseCodeException { ConnectionHolder connectionHolder = getRandom(cdnClients, random); OkHttpClient okHttpClient = connectionHolder.getClient() @@ -631,13 +677,12 @@ public class PushServiceSocket { if (body.contentLength() > maxSizeBytes) throw new PushNetworkException("Response exceeds max size!"); InputStream in = body.byteStream(); - OutputStream out = new FileOutputStream(destination); byte[] buffer = new byte[32768]; int read, totalRead = 0; while ((read = in.read(buffer, 0, buffer.length)) != -1) { - out.write(buffer, 0, read); + outputStream.write(buffer, 0, read); if ((totalRead += read) > maxSizeBytes) throw new PushNetworkException("Response exceeded max size!"); if (listener != null) { diff --git a/java/src/main/java/org/whispersystems/signalservice/internal/push/SignalServiceProtos.java b/java/src/main/java/org/whispersystems/signalservice/internal/push/SignalServiceProtos.java index 47e3e4f..6ed8574 100644 --- a/java/src/main/java/org/whispersystems/signalservice/internal/push/SignalServiceProtos.java +++ b/java/src/main/java/org/whispersystems/signalservice/internal/push/SignalServiceProtos.java @@ -7231,6 +7231,20 @@ public final class SignalServiceProtos { */ org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.PreviewOrBuilder getPreviewOrBuilder( int index); + + // optional .signalservice.DataMessage.Sticker sticker = 11; + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + boolean hasSticker(); + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker getSticker(); + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.StickerOrBuilder getStickerOrBuilder(); } /** * Protobuf type {@code signalservice.DataMessage} @@ -7358,6 +7372,19 @@ public final class SignalServiceProtos { preview_.add(input.readMessage(org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Preview.PARSER, extensionRegistry)); break; } + case 90: { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = sticker_.toBuilder(); + } + sticker_ = input.readMessage(org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(sticker_); + sticker_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + break; + } } } } catch (com.google.protobuf.InvalidProtocolBufferException e) { @@ -17363,6 +17390,762 @@ public final class SignalServiceProtos { // @@protoc_insertion_point(class_scope:signalservice.DataMessage.Preview) } + public interface StickerOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional bytes packId = 1; + /** + * optional bytes packId = 1; + */ + boolean hasPackId(); + /** + * optional bytes packId = 1; + */ + com.google.protobuf.ByteString getPackId(); + + // optional bytes packKey = 2; + /** + * optional bytes packKey = 2; + */ + boolean hasPackKey(); + /** + * optional bytes packKey = 2; + */ + com.google.protobuf.ByteString getPackKey(); + + // optional uint32 stickerId = 3; + /** + * optional uint32 stickerId = 3; + */ + boolean hasStickerId(); + /** + * optional uint32 stickerId = 3; + */ + int getStickerId(); + + // optional .signalservice.AttachmentPointer data = 4; + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + boolean hasData(); + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer getData(); + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointerOrBuilder getDataOrBuilder(); + } + /** + * Protobuf type {@code signalservice.DataMessage.Sticker} + */ + public static final class Sticker extends + com.google.protobuf.GeneratedMessage + implements StickerOrBuilder { + // Use Sticker.newBuilder() to construct. + private Sticker(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Sticker(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final Sticker defaultInstance; + public static Sticker getDefaultInstance() { + return defaultInstance; + } + + public Sticker getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Sticker( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + packId_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + packKey_ = input.readBytes(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + stickerId_ = input.readUInt32(); + break; + } + case 34: { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = data_.toBuilder(); + } + data_ = input.readMessage(org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(data_); + data_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_DataMessage_Sticker_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_DataMessage_Sticker_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.class, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public Sticker parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Sticker(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // optional bytes packId = 1; + public static final int PACKID_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString packId_; + /** + * optional bytes packId = 1; + */ + public boolean hasPackId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional bytes packId = 1; + */ + public com.google.protobuf.ByteString getPackId() { + return packId_; + } + + // optional bytes packKey = 2; + public static final int PACKKEY_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString packKey_; + /** + * optional bytes packKey = 2; + */ + public boolean hasPackKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes packKey = 2; + */ + public com.google.protobuf.ByteString getPackKey() { + return packKey_; + } + + // optional uint32 stickerId = 3; + public static final int STICKERID_FIELD_NUMBER = 3; + private int stickerId_; + /** + * optional uint32 stickerId = 3; + */ + public boolean hasStickerId() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional uint32 stickerId = 3; + */ + public int getStickerId() { + return stickerId_; + } + + // optional .signalservice.AttachmentPointer data = 4; + public static final int DATA_FIELD_NUMBER = 4; + private org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer data_; + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer getData() { + return data_; + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointerOrBuilder getDataOrBuilder() { + return data_; + } + + private void initFields() { + packId_ = com.google.protobuf.ByteString.EMPTY; + packKey_ = com.google.protobuf.ByteString.EMPTY; + stickerId_ = 0; + data_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, packId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, packKey_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeUInt32(3, stickerId_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, packId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, packKey_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(3, stickerId_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code signalservice.DataMessage.Sticker} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.StickerOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_DataMessage_Sticker_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_DataMessage_Sticker_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.class, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder.class); + } + + // Construct using org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getDataFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + packId_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + packKey_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + stickerId_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + if (dataBuilder_ == null) { + data_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.getDefaultInstance(); + } else { + dataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_DataMessage_Sticker_descriptor; + } + + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker getDefaultInstanceForType() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.getDefaultInstance(); + } + + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker build() { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker buildPartial() { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker result = new org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.packId_ = packId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.packKey_ = packKey_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.stickerId_ = stickerId_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + if (dataBuilder_ == null) { + result.data_ = data_; + } else { + result.data_ = dataBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker) { + return mergeFrom((org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker other) { + if (other == org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.getDefaultInstance()) return this; + if (other.hasPackId()) { + setPackId(other.getPackId()); + } + if (other.hasPackKey()) { + setPackKey(other.getPackKey()); + } + if (other.hasStickerId()) { + setStickerId(other.getStickerId()); + } + if (other.hasData()) { + mergeData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional bytes packId = 1; + private com.google.protobuf.ByteString packId_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes packId = 1; + */ + public boolean hasPackId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional bytes packId = 1; + */ + public com.google.protobuf.ByteString getPackId() { + return packId_; + } + /** + * optional bytes packId = 1; + */ + public Builder setPackId(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + packId_ = value; + onChanged(); + return this; + } + /** + * optional bytes packId = 1; + */ + public Builder clearPackId() { + bitField0_ = (bitField0_ & ~0x00000001); + packId_ = getDefaultInstance().getPackId(); + onChanged(); + return this; + } + + // optional bytes packKey = 2; + private com.google.protobuf.ByteString packKey_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes packKey = 2; + */ + public boolean hasPackKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes packKey = 2; + */ + public com.google.protobuf.ByteString getPackKey() { + return packKey_; + } + /** + * optional bytes packKey = 2; + */ + public Builder setPackKey(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + packKey_ = value; + onChanged(); + return this; + } + /** + * optional bytes packKey = 2; + */ + public Builder clearPackKey() { + bitField0_ = (bitField0_ & ~0x00000002); + packKey_ = getDefaultInstance().getPackKey(); + onChanged(); + return this; + } + + // optional uint32 stickerId = 3; + private int stickerId_ ; + /** + * optional uint32 stickerId = 3; + */ + public boolean hasStickerId() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional uint32 stickerId = 3; + */ + public int getStickerId() { + return stickerId_; + } + /** + * optional uint32 stickerId = 3; + */ + public Builder setStickerId(int value) { + bitField0_ |= 0x00000004; + stickerId_ = value; + onChanged(); + return this; + } + /** + * optional uint32 stickerId = 3; + */ + public Builder clearStickerId() { + bitField0_ = (bitField0_ & ~0x00000004); + stickerId_ = 0; + onChanged(); + return this; + } + + // optional .signalservice.AttachmentPointer data = 4; + private org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer data_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer, org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointerOrBuilder> dataBuilder_; + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer getData() { + if (dataBuilder_ == null) { + return data_; + } else { + return dataBuilder_.getMessage(); + } + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public Builder setData(org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer value) { + if (dataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + data_ = value; + onChanged(); + } else { + dataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public Builder setData( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.Builder builderForValue) { + if (dataBuilder_ == null) { + data_ = builderForValue.build(); + onChanged(); + } else { + dataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public Builder mergeData(org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer value) { + if (dataBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + data_ != org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.getDefaultInstance()) { + data_ = + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.newBuilder(data_).mergeFrom(value).buildPartial(); + } else { + data_ = value; + } + onChanged(); + } else { + dataBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public Builder clearData() { + if (dataBuilder_ == null) { + data_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.getDefaultInstance(); + onChanged(); + } else { + dataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.Builder getDataBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getDataFieldBuilder().getBuilder(); + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointerOrBuilder getDataOrBuilder() { + if (dataBuilder_ != null) { + return dataBuilder_.getMessageOrBuilder(); + } else { + return data_; + } + } + /** + * optional .signalservice.AttachmentPointer data = 4; + */ + private com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer, org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointerOrBuilder> + getDataFieldBuilder() { + if (dataBuilder_ == null) { + dataBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer, org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointerOrBuilder>( + data_, + getParentForChildren(), + isClean()); + data_ = null; + } + return dataBuilder_; + } + + // @@protoc_insertion_point(builder_scope:signalservice.DataMessage.Sticker) + } + + static { + defaultInstance = new Sticker(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:signalservice.DataMessage.Sticker) + } + private int bitField0_; // optional string body = 1; public static final int BODY_FIELD_NUMBER = 1; @@ -17623,6 +18406,28 @@ public final class SignalServiceProtos { return preview_.get(index); } + // optional .signalservice.DataMessage.Sticker sticker = 11; + public static final int STICKER_FIELD_NUMBER = 11; + private org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker sticker_; + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public boolean hasSticker() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker getSticker() { + return sticker_; + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.StickerOrBuilder getStickerOrBuilder() { + return sticker_; + } + private void initFields() { body_ = ""; attachments_ = java.util.Collections.emptyList(); @@ -17634,6 +18439,7 @@ public final class SignalServiceProtos { quote_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Quote.getDefaultInstance(); contact_ = java.util.Collections.emptyList(); preview_ = java.util.Collections.emptyList(); + sticker_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -17677,6 +18483,9 @@ public final class SignalServiceProtos { for (int i = 0; i < preview_.size(); i++) { output.writeMessage(10, preview_.get(i)); } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeMessage(11, sticker_); + } getUnknownFields().writeTo(output); } @@ -17726,6 +18535,10 @@ public final class SignalServiceProtos { size += com.google.protobuf.CodedOutputStream .computeMessageSize(10, preview_.get(i)); } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(11, sticker_); + } size += getUnknownFields().getSerializedSize(); memoizedSerializedSize = size; return size; @@ -17839,6 +18652,7 @@ public final class SignalServiceProtos { getQuoteFieldBuilder(); getContactFieldBuilder(); getPreviewFieldBuilder(); + getStickerFieldBuilder(); } } private static Builder create() { @@ -17887,6 +18701,12 @@ public final class SignalServiceProtos { } else { previewBuilder_.clear(); } + if (stickerBuilder_ == null) { + sticker_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.getDefaultInstance(); + } else { + stickerBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000400); return this; } @@ -17978,6 +18798,14 @@ public final class SignalServiceProtos { } else { result.preview_ = previewBuilder_.build(); } + if (((from_bitField0_ & 0x00000400) == 0x00000400)) { + to_bitField0_ |= 0x00000080; + } + if (stickerBuilder_ == null) { + result.sticker_ = sticker_; + } else { + result.sticker_ = stickerBuilder_.build(); + } result.bitField0_ = to_bitField0_; onBuilt(); return result; @@ -18095,6 +18923,9 @@ public final class SignalServiceProtos { } } } + if (other.hasSticker()) { + mergeSticker(other.getSticker()); + } this.mergeUnknownFields(other.getUnknownFields()); return this; } @@ -19285,6 +20116,123 @@ public final class SignalServiceProtos { return previewBuilder_; } + // optional .signalservice.DataMessage.Sticker sticker = 11; + private org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker sticker_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.StickerOrBuilder> stickerBuilder_; + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public boolean hasSticker() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker getSticker() { + if (stickerBuilder_ == null) { + return sticker_; + } else { + return stickerBuilder_.getMessage(); + } + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public Builder setSticker(org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker value) { + if (stickerBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + sticker_ = value; + onChanged(); + } else { + stickerBuilder_.setMessage(value); + } + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public Builder setSticker( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder builderForValue) { + if (stickerBuilder_ == null) { + sticker_ = builderForValue.build(); + onChanged(); + } else { + stickerBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public Builder mergeSticker(org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker value) { + if (stickerBuilder_ == null) { + if (((bitField0_ & 0x00000400) == 0x00000400) && + sticker_ != org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.getDefaultInstance()) { + sticker_ = + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.newBuilder(sticker_).mergeFrom(value).buildPartial(); + } else { + sticker_ = value; + } + onChanged(); + } else { + stickerBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public Builder clearSticker() { + if (stickerBuilder_ == null) { + sticker_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.getDefaultInstance(); + onChanged(); + } else { + stickerBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000400); + return this; + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder getStickerBuilder() { + bitField0_ |= 0x00000400; + onChanged(); + return getStickerFieldBuilder().getBuilder(); + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.StickerOrBuilder getStickerOrBuilder() { + if (stickerBuilder_ != null) { + return stickerBuilder_.getMessageOrBuilder(); + } else { + return sticker_; + } + } + /** + * optional .signalservice.DataMessage.Sticker sticker = 11; + */ + private com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.StickerOrBuilder> + getStickerFieldBuilder() { + if (stickerBuilder_ == null) { + stickerBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.Sticker.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage.StickerOrBuilder>( + sticker_, + getParentForChildren(), + isClean()); + sticker_ = null; + } + return stickerBuilder_; + } + // @@protoc_insertion_point(builder_scope:signalservice.DataMessage) } @@ -21946,6 +22894,31 @@ public final class SignalServiceProtos { * optional bytes padding = 8; */ com.google.protobuf.ByteString getPadding(); + + // repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + java.util.List + getStickerPackOperationList(); + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation getStickerPackOperation(int index); + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + int getStickerPackOperationCount(); + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + java.util.List + getStickerPackOperationOrBuilderList(); + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperationOrBuilder getStickerPackOperationOrBuilder( + int index); } /** * Protobuf type {@code signalservice.SyncMessage} @@ -22102,6 +23075,14 @@ public final class SignalServiceProtos { bitField0_ |= 0x00000040; break; } + case 82: { + if (!((mutable_bitField0_ & 0x00000200) == 0x00000200)) { + stickerPackOperation_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000200; + } + stickerPackOperation_.add(input.readMessage(org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.PARSER, extensionRegistry)); + break; + } } } } catch (com.google.protobuf.InvalidProtocolBufferException e) { @@ -22113,6 +23094,9 @@ public final class SignalServiceProtos { if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) { read_ = java.util.Collections.unmodifiableList(read_); } + if (((mutable_bitField0_ & 0x00000200) == 0x00000200)) { + stickerPackOperation_ = java.util.Collections.unmodifiableList(stickerPackOperation_); + } this.unknownFields = unknownFields.build(); makeExtensionsImmutable(); } @@ -27330,6 +28314,661 @@ public final class SignalServiceProtos { // @@protoc_insertion_point(class_scope:signalservice.SyncMessage.Configuration) } + public interface StickerPackOperationOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional bytes packId = 1; + /** + * optional bytes packId = 1; + */ + boolean hasPackId(); + /** + * optional bytes packId = 1; + */ + com.google.protobuf.ByteString getPackId(); + + // optional bytes packKey = 2; + /** + * optional bytes packKey = 2; + */ + boolean hasPackKey(); + /** + * optional bytes packKey = 2; + */ + com.google.protobuf.ByteString getPackKey(); + + // optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + boolean hasType(); + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type getType(); + } + /** + * Protobuf type {@code signalservice.SyncMessage.StickerPackOperation} + */ + public static final class StickerPackOperation extends + com.google.protobuf.GeneratedMessage + implements StickerPackOperationOrBuilder { + // Use StickerPackOperation.newBuilder() to construct. + private StickerPackOperation(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private StickerPackOperation(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final StickerPackOperation defaultInstance; + public static StickerPackOperation getDefaultInstance() { + return defaultInstance; + } + + public StickerPackOperation getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private StickerPackOperation( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + packId_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + packKey_ = input.readBytes(); + break; + } + case 24: { + int rawValue = input.readEnum(); + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type value = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(3, rawValue); + } else { + bitField0_ |= 0x00000004; + type_ = value; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_SyncMessage_StickerPackOperation_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_SyncMessage_StickerPackOperation_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.class, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public StickerPackOperation parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new StickerPackOperation(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + /** + * Protobuf enum {@code signalservice.SyncMessage.StickerPackOperation.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * INSTALL = 0; + */ + INSTALL(0, 0), + /** + * REMOVE = 1; + */ + REMOVE(1, 1), + ; + + /** + * INSTALL = 0; + */ + public static final int INSTALL_VALUE = 0; + /** + * REMOVE = 1; + */ + public static final int REMOVE_VALUE = 1; + + + public final int getNumber() { return value; } + + public static Type valueOf(int value) { + switch (value) { + case 0: return INSTALL; + case 1: return REMOVE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private Type(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:signalservice.SyncMessage.StickerPackOperation.Type) + } + + private int bitField0_; + // optional bytes packId = 1; + public static final int PACKID_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString packId_; + /** + * optional bytes packId = 1; + */ + public boolean hasPackId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional bytes packId = 1; + */ + public com.google.protobuf.ByteString getPackId() { + return packId_; + } + + // optional bytes packKey = 2; + public static final int PACKKEY_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString packKey_; + /** + * optional bytes packKey = 2; + */ + public boolean hasPackKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes packKey = 2; + */ + public com.google.protobuf.ByteString getPackKey() { + return packKey_; + } + + // optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + public static final int TYPE_FIELD_NUMBER = 3; + private org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type type_; + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type getType() { + return type_; + } + + private void initFields() { + packId_ = com.google.protobuf.ByteString.EMPTY; + packKey_ = com.google.protobuf.ByteString.EMPTY; + type_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type.INSTALL; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, packId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, packKey_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeEnum(3, type_.getNumber()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, packId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, packKey_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, type_.getNumber()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code signalservice.SyncMessage.StickerPackOperation} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperationOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_SyncMessage_StickerPackOperation_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_SyncMessage_StickerPackOperation_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.class, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder.class); + } + + // Construct using org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + packId_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + packKey_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + type_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type.INSTALL; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.internal_static_signalservice_SyncMessage_StickerPackOperation_descriptor; + } + + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation getDefaultInstanceForType() { + return org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.getDefaultInstance(); + } + + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation build() { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation buildPartial() { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation result = new org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.packId_ = packId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.packKey_ = packKey_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.type_ = type_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation) { + return mergeFrom((org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation other) { + if (other == org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.getDefaultInstance()) return this; + if (other.hasPackId()) { + setPackId(other.getPackId()); + } + if (other.hasPackKey()) { + setPackKey(other.getPackKey()); + } + if (other.hasType()) { + setType(other.getType()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional bytes packId = 1; + private com.google.protobuf.ByteString packId_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes packId = 1; + */ + public boolean hasPackId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional bytes packId = 1; + */ + public com.google.protobuf.ByteString getPackId() { + return packId_; + } + /** + * optional bytes packId = 1; + */ + public Builder setPackId(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + packId_ = value; + onChanged(); + return this; + } + /** + * optional bytes packId = 1; + */ + public Builder clearPackId() { + bitField0_ = (bitField0_ & ~0x00000001); + packId_ = getDefaultInstance().getPackId(); + onChanged(); + return this; + } + + // optional bytes packKey = 2; + private com.google.protobuf.ByteString packKey_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes packKey = 2; + */ + public boolean hasPackKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes packKey = 2; + */ + public com.google.protobuf.ByteString getPackKey() { + return packKey_; + } + /** + * optional bytes packKey = 2; + */ + public Builder setPackKey(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + packKey_ = value; + onChanged(); + return this; + } + /** + * optional bytes packKey = 2; + */ + public Builder clearPackKey() { + bitField0_ = (bitField0_ & ~0x00000002); + packKey_ = getDefaultInstance().getPackKey(); + onChanged(); + return this; + } + + // optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + private org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type type_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type.INSTALL; + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type getType() { + return type_; + } + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + public Builder setType(org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + type_ = value; + onChanged(); + return this; + } + /** + * optional .signalservice.SyncMessage.StickerPackOperation.Type type = 3; + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000004); + type_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Type.INSTALL; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:signalservice.SyncMessage.StickerPackOperation) + } + + static { + defaultInstance = new StickerPackOperation(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:signalservice.SyncMessage.StickerPackOperation) + } + private int bitField0_; // optional .signalservice.SyncMessage.Sent sent = 1; public static final int SENT_FIELD_NUMBER = 1; @@ -27537,6 +29176,42 @@ public final class SignalServiceProtos { return padding_; } + // repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + public static final int STICKERPACKOPERATION_FIELD_NUMBER = 10; + private java.util.List stickerPackOperation_; + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public java.util.List getStickerPackOperationList() { + return stickerPackOperation_; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public java.util.List + getStickerPackOperationOrBuilderList() { + return stickerPackOperation_; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public int getStickerPackOperationCount() { + return stickerPackOperation_.size(); + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation getStickerPackOperation(int index) { + return stickerPackOperation_.get(index); + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperationOrBuilder getStickerPackOperationOrBuilder( + int index) { + return stickerPackOperation_.get(index); + } + private void initFields() { sent_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.Sent.getDefaultInstance(); contacts_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.Contacts.getDefaultInstance(); @@ -27547,6 +29222,7 @@ public final class SignalServiceProtos { verified_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.Verified.getDefaultInstance(); configuration_ = org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.Configuration.getDefaultInstance(); padding_ = com.google.protobuf.ByteString.EMPTY; + stickerPackOperation_ = java.util.Collections.emptyList(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -27587,6 +29263,9 @@ public final class SignalServiceProtos { if (((bitField0_ & 0x00000040) == 0x00000040)) { output.writeMessage(9, configuration_); } + for (int i = 0; i < stickerPackOperation_.size(); i++) { + output.writeMessage(10, stickerPackOperation_.get(i)); + } getUnknownFields().writeTo(output); } @@ -27632,6 +29311,10 @@ public final class SignalServiceProtos { size += com.google.protobuf.CodedOutputStream .computeMessageSize(9, configuration_); } + for (int i = 0; i < stickerPackOperation_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(10, stickerPackOperation_.get(i)); + } size += getUnknownFields().getSerializedSize(); memoizedSerializedSize = size; return size; @@ -27748,6 +29431,7 @@ public final class SignalServiceProtos { getBlockedFieldBuilder(); getVerifiedFieldBuilder(); getConfigurationFieldBuilder(); + getStickerPackOperationFieldBuilder(); } } private static Builder create() { @@ -27806,6 +29490,12 @@ public final class SignalServiceProtos { bitField0_ = (bitField0_ & ~0x00000080); padding_ = com.google.protobuf.ByteString.EMPTY; bitField0_ = (bitField0_ & ~0x00000100); + if (stickerPackOperationBuilder_ == null) { + stickerPackOperation_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000200); + } else { + stickerPackOperationBuilder_.clear(); + } return this; } @@ -27903,6 +29593,15 @@ public final class SignalServiceProtos { to_bitField0_ |= 0x00000080; } result.padding_ = padding_; + if (stickerPackOperationBuilder_ == null) { + if (((bitField0_ & 0x00000200) == 0x00000200)) { + stickerPackOperation_ = java.util.Collections.unmodifiableList(stickerPackOperation_); + bitField0_ = (bitField0_ & ~0x00000200); + } + result.stickerPackOperation_ = stickerPackOperation_; + } else { + result.stickerPackOperation_ = stickerPackOperationBuilder_.build(); + } result.bitField0_ = to_bitField0_; onBuilt(); return result; @@ -27969,6 +29668,32 @@ public final class SignalServiceProtos { if (other.hasPadding()) { setPadding(other.getPadding()); } + if (stickerPackOperationBuilder_ == null) { + if (!other.stickerPackOperation_.isEmpty()) { + if (stickerPackOperation_.isEmpty()) { + stickerPackOperation_ = other.stickerPackOperation_; + bitField0_ = (bitField0_ & ~0x00000200); + } else { + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.addAll(other.stickerPackOperation_); + } + onChanged(); + } + } else { + if (!other.stickerPackOperation_.isEmpty()) { + if (stickerPackOperationBuilder_.isEmpty()) { + stickerPackOperationBuilder_.dispose(); + stickerPackOperationBuilder_ = null; + stickerPackOperation_ = other.stickerPackOperation_; + bitField0_ = (bitField0_ & ~0x00000200); + stickerPackOperationBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getStickerPackOperationFieldBuilder() : null; + } else { + stickerPackOperationBuilder_.addAllMessages(other.stickerPackOperation_); + } + } + } this.mergeUnknownFields(other.getUnknownFields()); return this; } @@ -29091,6 +30816,246 @@ public final class SignalServiceProtos { return this; } + // repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + private java.util.List stickerPackOperation_ = + java.util.Collections.emptyList(); + private void ensureStickerPackOperationIsMutable() { + if (!((bitField0_ & 0x00000200) == 0x00000200)) { + stickerPackOperation_ = new java.util.ArrayList(stickerPackOperation_); + bitField0_ |= 0x00000200; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperationOrBuilder> stickerPackOperationBuilder_; + + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public java.util.List getStickerPackOperationList() { + if (stickerPackOperationBuilder_ == null) { + return java.util.Collections.unmodifiableList(stickerPackOperation_); + } else { + return stickerPackOperationBuilder_.getMessageList(); + } + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public int getStickerPackOperationCount() { + if (stickerPackOperationBuilder_ == null) { + return stickerPackOperation_.size(); + } else { + return stickerPackOperationBuilder_.getCount(); + } + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation getStickerPackOperation(int index) { + if (stickerPackOperationBuilder_ == null) { + return stickerPackOperation_.get(index); + } else { + return stickerPackOperationBuilder_.getMessage(index); + } + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder setStickerPackOperation( + int index, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation value) { + if (stickerPackOperationBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.set(index, value); + onChanged(); + } else { + stickerPackOperationBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder setStickerPackOperation( + int index, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder builderForValue) { + if (stickerPackOperationBuilder_ == null) { + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.set(index, builderForValue.build()); + onChanged(); + } else { + stickerPackOperationBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder addStickerPackOperation(org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation value) { + if (stickerPackOperationBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.add(value); + onChanged(); + } else { + stickerPackOperationBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder addStickerPackOperation( + int index, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation value) { + if (stickerPackOperationBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.add(index, value); + onChanged(); + } else { + stickerPackOperationBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder addStickerPackOperation( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder builderForValue) { + if (stickerPackOperationBuilder_ == null) { + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.add(builderForValue.build()); + onChanged(); + } else { + stickerPackOperationBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder addStickerPackOperation( + int index, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder builderForValue) { + if (stickerPackOperationBuilder_ == null) { + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.add(index, builderForValue.build()); + onChanged(); + } else { + stickerPackOperationBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder addAllStickerPackOperation( + java.lang.Iterable values) { + if (stickerPackOperationBuilder_ == null) { + ensureStickerPackOperationIsMutable(); + super.addAll(values, stickerPackOperation_); + onChanged(); + } else { + stickerPackOperationBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder clearStickerPackOperation() { + if (stickerPackOperationBuilder_ == null) { + stickerPackOperation_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000200); + onChanged(); + } else { + stickerPackOperationBuilder_.clear(); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public Builder removeStickerPackOperation(int index) { + if (stickerPackOperationBuilder_ == null) { + ensureStickerPackOperationIsMutable(); + stickerPackOperation_.remove(index); + onChanged(); + } else { + stickerPackOperationBuilder_.remove(index); + } + return this; + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder getStickerPackOperationBuilder( + int index) { + return getStickerPackOperationFieldBuilder().getBuilder(index); + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperationOrBuilder getStickerPackOperationOrBuilder( + int index) { + if (stickerPackOperationBuilder_ == null) { + return stickerPackOperation_.get(index); } else { + return stickerPackOperationBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public java.util.List + getStickerPackOperationOrBuilderList() { + if (stickerPackOperationBuilder_ != null) { + return stickerPackOperationBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(stickerPackOperation_); + } + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder addStickerPackOperationBuilder() { + return getStickerPackOperationFieldBuilder().addBuilder( + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.getDefaultInstance()); + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder addStickerPackOperationBuilder( + int index) { + return getStickerPackOperationFieldBuilder().addBuilder( + index, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.getDefaultInstance()); + } + /** + * repeated .signalservice.SyncMessage.StickerPackOperation stickerPackOperation = 10; + */ + public java.util.List + getStickerPackOperationBuilderList() { + return getStickerPackOperationFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperationOrBuilder> + getStickerPackOperationFieldBuilder() { + if (stickerPackOperationBuilder_ == null) { + stickerPackOperationBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperation.Builder, org.whispersystems.signalservice.internal.push.SignalServiceProtos.SyncMessage.StickerPackOperationOrBuilder>( + stickerPackOperation_, + ((bitField0_ & 0x00000200) == 0x00000200), + getParentForChildren(), + isClean()); + stickerPackOperation_ = null; + } + return stickerPackOperationBuilder_; + } + // @@protoc_insertion_point(builder_scope:signalservice.SyncMessage) } @@ -35684,6 +37649,11 @@ public final class SignalServiceProtos { private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_signalservice_DataMessage_Preview_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_signalservice_DataMessage_Sticker_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_signalservice_DataMessage_Sticker_fieldAccessorTable; private static com.google.protobuf.Descriptors.Descriptor internal_static_signalservice_NullMessage_descriptor; private static @@ -35749,6 +37719,11 @@ public final class SignalServiceProtos { private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_signalservice_SyncMessage_Configuration_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_signalservice_SyncMessage_StickerPackOperation_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_signalservice_SyncMessage_StickerPackOperation_fieldAccessorTable; private static com.google.protobuf.Descriptors.Descriptor internal_static_signalservice_AttachmentPointer_descriptor; private static @@ -35816,7 +37791,7 @@ public final class SignalServiceProtos { "r\022\n\n\002id\030\001 \001(\004\022\023\n\013description\030\002 \001(\t\032K\n\tIc" + "eUpdate\022\n\n\002id\030\001 \001(\004\022\016\n\006sdpMid\030\002 \001(\t\022\025\n\rs" + "dpMLineIndex\030\003 \001(\r\022\013\n\003sdp\030\004 \001(\t\032\022\n\004Busy\022" + - "\n\n\002id\030\001 \001(\004\032\024\n\006Hangup\022\n\n\002id\030\001 \001(\004\"\276\016\n\013Da" + + "\n\n\002id\030\001 \001(\004\032\024\n\006Hangup\022\n\n\002id\030\001 \001(\004\"\342\017\n\013Da" + "taMessage\022\014\n\004body\030\001 \001(\t\0225\n\013attachments\030\002", " \003(\0132 .signalservice.AttachmentPointer\022*" + "\n\005group\030\003 \001(\0132\033.signalservice.GroupConte" + @@ -35825,113 +37800,123 @@ public final class SignalServiceProtos { "\005quote\030\010 \001(\0132 .signalservice.DataMessage" + ".Quote\0223\n\007contact\030\t \003(\0132\".signalservice." + "DataMessage.Contact\0223\n\007preview\030\n \003(\0132\".s" + - "ignalservice.DataMessage.Preview\032\351\001\n\005Quo" + - "te\022\n\n\002id\030\001 \001(\004\022\016\n\006author\030\002 \001(\t\022\014\n\004text\030\003" + - " \001(\t\022F\n\013attachments\030\004 \003(\01321.signalservic", - "e.DataMessage.Quote.QuotedAttachment\032n\n\020" + - "QuotedAttachment\022\023\n\013contentType\030\001 \001(\t\022\020\n" + - "\010fileName\030\002 \001(\t\0223\n\tthumbnail\030\003 \001(\0132 .sig" + - "nalservice.AttachmentPointer\032\304\010\n\007Contact" + - "\0225\n\004name\030\001 \001(\0132\'.signalservice.DataMessa" + - "ge.Contact.Name\0228\n\006number\030\003 \003(\0132(.signal" + - "service.DataMessage.Contact.Phone\0227\n\005ema" + - "il\030\004 \003(\0132(.signalservice.DataMessage.Con" + - "tact.Email\022A\n\007address\030\005 \003(\01320.signalserv" + - "ice.DataMessage.Contact.PostalAddress\0229\n", - "\006avatar\030\006 \001(\0132).signalservice.DataMessag" + - "e.Contact.Avatar\022\024\n\014organization\030\007 \001(\t\032v" + - "\n\004Name\022\021\n\tgivenName\030\001 \001(\t\022\022\n\nfamilyName\030" + - "\002 \001(\t\022\016\n\006prefix\030\003 \001(\t\022\016\n\006suffix\030\004 \001(\t\022\022\n" + - "\nmiddleName\030\005 \001(\t\022\023\n\013displayName\030\006 \001(\t\032\226" + - "\001\n\005Phone\022\r\n\005value\030\001 \001(\t\022;\n\004type\030\002 \001(\0162-." + - "signalservice.DataMessage.Contact.Phone." + - "Type\022\r\n\005label\030\003 \001(\t\"2\n\004Type\022\010\n\004HOME\020\001\022\n\n" + - "\006MOBILE\020\002\022\010\n\004WORK\020\003\022\n\n\006CUSTOM\020\004\032\226\001\n\005Emai" + - "l\022\r\n\005value\030\001 \001(\t\022;\n\004type\030\002 \001(\0162-.signals", - "ervice.DataMessage.Contact.Email.Type\022\r\n" + - "\005label\030\003 \001(\t\"2\n\004Type\022\010\n\004HOME\020\001\022\n\n\006MOBILE" + - "\020\002\022\010\n\004WORK\020\003\022\n\n\006CUSTOM\020\004\032\201\002\n\rPostalAddre" + - "ss\022C\n\004type\030\001 \001(\01625.signalservice.DataMes" + - "sage.Contact.PostalAddress.Type\022\r\n\005label" + - "\030\002 \001(\t\022\016\n\006street\030\003 \001(\t\022\r\n\005pobox\030\004 \001(\t\022\024\n" + - "\014neighborhood\030\005 \001(\t\022\014\n\004city\030\006 \001(\t\022\016\n\006reg" + - "ion\030\007 \001(\t\022\020\n\010postcode\030\010 \001(\t\022\017\n\007country\030\t" + - " \001(\t\"&\n\004Type\022\010\n\004HOME\020\001\022\010\n\004WORK\020\002\022\n\n\006CUST" + - "OM\020\003\032M\n\006Avatar\0220\n\006avatar\030\001 \001(\0132 .signals", - "ervice.AttachmentPointer\022\021\n\tisProfile\030\002 " + - "\001(\010\032V\n\007Preview\022\013\n\003url\030\001 \001(\t\022\r\n\005title\030\002 \001" + - "(\t\022/\n\005image\030\003 \001(\0132 .signalservice.Attach" + - "mentPointer\"M\n\005Flags\022\017\n\013END_SESSION\020\001\022\033\n" + - "\027EXPIRATION_TIMER_UPDATE\020\002\022\026\n\022PROFILE_KE" + - "Y_UPDATE\020\004\"\036\n\013NullMessage\022\017\n\007padding\030\001 \001" + - "(\014\"u\n\016ReceiptMessage\0220\n\004type\030\001 \001(\0162\".sig" + - "nalservice.ReceiptMessage.Type\022\021\n\ttimest" + - "amp\030\002 \003(\004\"\036\n\004Type\022\014\n\010DELIVERY\020\000\022\010\n\004READ\020" + - "\001\"\214\001\n\rTypingMessage\022\021\n\ttimestamp\030\001 \001(\004\0223", - "\n\006action\030\002 \001(\0162#.signalservice.TypingMes" + - "sage.Action\022\017\n\007groupId\030\003 \001(\014\"\"\n\006Action\022\013" + - "\n\007STARTED\020\000\022\013\n\007STOPPED\020\001\"\253\001\n\010Verified\022\023\n" + - "\013destination\030\001 \001(\t\022\023\n\013identityKey\030\002 \001(\014\022" + - ",\n\005state\030\003 \001(\0162\035.signalservice.Verified." + - "State\022\023\n\013nullMessage\030\004 \001(\014\"2\n\005State\022\013\n\007D" + - "EFAULT\020\000\022\014\n\010VERIFIED\020\001\022\016\n\nUNVERIFIED\020\002\"\326" + - "\t\n\013SyncMessage\022-\n\004sent\030\001 \001(\0132\037.signalser" + - "vice.SyncMessage.Sent\0225\n\010contacts\030\002 \001(\0132" + - "#.signalservice.SyncMessage.Contacts\0221\n\006", - "groups\030\003 \001(\0132!.signalservice.SyncMessage" + - ".Groups\0223\n\007request\030\004 \001(\0132\".signalservice" + - ".SyncMessage.Request\022-\n\004read\030\005 \003(\0132\037.sig" + - "nalservice.SyncMessage.Read\0223\n\007blocked\030\006" + - " \001(\0132\".signalservice.SyncMessage.Blocked" + - "\022)\n\010verified\030\007 \001(\0132\027.signalservice.Verif" + - "ied\022?\n\rconfiguration\030\t \001(\0132(.signalservi" + - "ce.SyncMessage.Configuration\022\017\n\007padding\030" + - "\010 \001(\014\032\236\002\n\004Sent\022\023\n\013destination\030\001 \001(\t\022\021\n\tt" + - "imestamp\030\002 \001(\004\022+\n\007message\030\003 \001(\0132\032.signal", - "service.DataMessage\022 \n\030expirationStartTi" + - "mestamp\030\004 \001(\004\022V\n\022unidentifiedStatus\030\005 \003(" + - "\0132:.signalservice.SyncMessage.Sent.Unide" + - "ntifiedDeliveryStatus\032G\n\032UnidentifiedDel" + - "iveryStatus\022\023\n\013destination\030\001 \001(\t\022\024\n\014unid" + - "entified\030\002 \001(\010\032S\n\010Contacts\022.\n\004blob\030\001 \001(\013" + - "2 .signalservice.AttachmentPointer\022\027\n\010co" + - "mplete\030\002 \001(\010:\005false\0328\n\006Groups\022.\n\004blob\030\001 " + - "\001(\0132 .signalservice.AttachmentPointer\032,\n" + - "\007Blocked\022\017\n\007numbers\030\001 \003(\t\022\020\n\010groupIds\030\002 ", - "\003(\014\032\217\001\n\007Request\0225\n\004type\030\001 \001(\0162\'.signalse" + - "rvice.SyncMessage.Request.Type\"M\n\004Type\022\013" + - "\n\007UNKNOWN\020\000\022\014\n\010CONTACTS\020\001\022\n\n\006GROUPS\020\002\022\013\n" + - "\007BLOCKED\020\003\022\021\n\rCONFIGURATION\020\004\032)\n\004Read\022\016\n" + - "\006sender\030\001 \001(\t\022\021\n\ttimestamp\030\002 \001(\004\032}\n\rConf" + - "iguration\022\024\n\014readReceipts\030\001 \001(\010\022&\n\036unide" + - "ntifiedDeliveryIndicators\030\002 \001(\010\022\030\n\020typin" + - "gIndicators\030\003 \001(\010\022\024\n\014linkPreviews\030\004 \001(\010\"" + - "\337\001\n\021AttachmentPointer\022\n\n\002id\030\001 \001(\006\022\023\n\013con" + - "tentType\030\002 \001(\t\022\013\n\003key\030\003 \001(\014\022\014\n\004size\030\004 \001(", - "\r\022\021\n\tthumbnail\030\005 \001(\014\022\016\n\006digest\030\006 \001(\014\022\020\n\010" + - "fileName\030\007 \001(\t\022\r\n\005flags\030\010 \001(\r\022\r\n\005width\030\t" + - " \001(\r\022\016\n\006height\030\n \001(\r\022\017\n\007caption\030\013 \001(\t\"\032\n" + - "\005Flags\022\021\n\rVOICE_MESSAGE\020\001\"\345\001\n\014GroupConte" + - "xt\022\n\n\002id\030\001 \001(\014\022.\n\004type\030\002 \001(\0162 .signalser" + - "vice.GroupContext.Type\022\014\n\004name\030\003 \001(\t\022\017\n\007" + - "members\030\004 \003(\t\0220\n\006avatar\030\005 \001(\0132 .signalse" + - "rvice.AttachmentPointer\"H\n\004Type\022\013\n\007UNKNO" + - "WN\020\000\022\n\n\006UPDATE\020\001\022\013\n\007DELIVER\020\002\022\010\n\004QUIT\020\003\022" + - "\020\n\014REQUEST_INFO\020\004\"\207\002\n\016ContactDetails\022\016\n\006", - "number\030\001 \001(\t\022\014\n\004name\030\002 \001(\t\0224\n\006avatar\030\003 \001" + - "(\0132$.signalservice.ContactDetails.Avatar" + - "\022\r\n\005color\030\004 \001(\t\022)\n\010verified\030\005 \001(\0132\027.sign" + - "alservice.Verified\022\022\n\nprofileKey\030\006 \001(\014\022\017" + - "\n\007blocked\030\007 \001(\010\022\023\n\013expireTimer\030\010 \001(\r\032-\n\006" + - "Avatar\022\023\n\013contentType\030\001 \001(\t\022\016\n\006length\030\002 " + - "\001(\r\"\347\001\n\014GroupDetails\022\n\n\002id\030\001 \001(\014\022\014\n\004name" + - "\030\002 \001(\t\022\017\n\007members\030\003 \003(\t\0222\n\006avatar\030\004 \001(\0132" + - "\".signalservice.GroupDetails.Avatar\022\024\n\006a" + - "ctive\030\005 \001(\010:\004true\022\023\n\013expireTimer\030\006 \001(\r\022\r", - "\n\005color\030\007 \001(\t\022\017\n\007blocked\030\010 \001(\010\032-\n\006Avatar" + - "\022\023\n\013contentType\030\001 \001(\t\022\016\n\006length\030\002 \001(\rBE\n" + - ".org.whispersystems.signalservice.intern" + - "al.pushB\023SignalServiceProtos" + "ignalservice.DataMessage.Preview\0223\n\007stic" + + "ker\030\013 \001(\0132\".signalservice.DataMessage.St" + + "icker\032\351\001\n\005Quote\022\n\n\002id\030\001 \001(\004\022\016\n\006author\030\002 ", + "\001(\t\022\014\n\004text\030\003 \001(\t\022F\n\013attachments\030\004 \003(\01321" + + ".signalservice.DataMessage.Quote.QuotedA" + + "ttachment\032n\n\020QuotedAttachment\022\023\n\013content" + + "Type\030\001 \001(\t\022\020\n\010fileName\030\002 \001(\t\0223\n\tthumbnai" + + "l\030\003 \001(\0132 .signalservice.AttachmentPointe" + + "r\032\304\010\n\007Contact\0225\n\004name\030\001 \001(\0132\'.signalserv" + + "ice.DataMessage.Contact.Name\0228\n\006number\030\003" + + " \003(\0132(.signalservice.DataMessage.Contact" + + ".Phone\0227\n\005email\030\004 \003(\0132(.signalservice.Da" + + "taMessage.Contact.Email\022A\n\007address\030\005 \003(\013", + "20.signalservice.DataMessage.Contact.Pos" + + "talAddress\0229\n\006avatar\030\006 \001(\0132).signalservi" + + "ce.DataMessage.Contact.Avatar\022\024\n\014organiz" + + "ation\030\007 \001(\t\032v\n\004Name\022\021\n\tgivenName\030\001 \001(\t\022\022" + + "\n\nfamilyName\030\002 \001(\t\022\016\n\006prefix\030\003 \001(\t\022\016\n\006su" + + "ffix\030\004 \001(\t\022\022\n\nmiddleName\030\005 \001(\t\022\023\n\013displa" + + "yName\030\006 \001(\t\032\226\001\n\005Phone\022\r\n\005value\030\001 \001(\t\022;\n\004" + + "type\030\002 \001(\0162-.signalservice.DataMessage.C" + + "ontact.Phone.Type\022\r\n\005label\030\003 \001(\t\"2\n\004Type" + + "\022\010\n\004HOME\020\001\022\n\n\006MOBILE\020\002\022\010\n\004WORK\020\003\022\n\n\006CUST", + "OM\020\004\032\226\001\n\005Email\022\r\n\005value\030\001 \001(\t\022;\n\004type\030\002 " + + "\001(\0162-.signalservice.DataMessage.Contact." + + "Email.Type\022\r\n\005label\030\003 \001(\t\"2\n\004Type\022\010\n\004HOM" + + "E\020\001\022\n\n\006MOBILE\020\002\022\010\n\004WORK\020\003\022\n\n\006CUSTOM\020\004\032\201\002" + + "\n\rPostalAddress\022C\n\004type\030\001 \001(\01625.signalse" + + "rvice.DataMessage.Contact.PostalAddress." + + "Type\022\r\n\005label\030\002 \001(\t\022\016\n\006street\030\003 \001(\t\022\r\n\005p" + + "obox\030\004 \001(\t\022\024\n\014neighborhood\030\005 \001(\t\022\014\n\004city" + + "\030\006 \001(\t\022\016\n\006region\030\007 \001(\t\022\020\n\010postcode\030\010 \001(\t" + + "\022\017\n\007country\030\t \001(\t\"&\n\004Type\022\010\n\004HOME\020\001\022\010\n\004W", + "ORK\020\002\022\n\n\006CUSTOM\020\003\032M\n\006Avatar\0220\n\006avatar\030\001 " + + "\001(\0132 .signalservice.AttachmentPointer\022\021\n" + + "\tisProfile\030\002 \001(\010\032V\n\007Preview\022\013\n\003url\030\001 \001(\t" + + "\022\r\n\005title\030\002 \001(\t\022/\n\005image\030\003 \001(\0132 .signals" + + "ervice.AttachmentPointer\032m\n\007Sticker\022\016\n\006p" + + "ackId\030\001 \001(\014\022\017\n\007packKey\030\002 \001(\014\022\021\n\tstickerI" + + "d\030\003 \001(\r\022.\n\004data\030\004 \001(\0132 .signalservice.At" + + "tachmentPointer\"M\n\005Flags\022\017\n\013END_SESSION\020" + + "\001\022\033\n\027EXPIRATION_TIMER_UPDATE\020\002\022\026\n\022PROFIL" + + "E_KEY_UPDATE\020\004\"\036\n\013NullMessage\022\017\n\007padding", + "\030\001 \001(\014\"u\n\016ReceiptMessage\0220\n\004type\030\001 \001(\0162\"" + + ".signalservice.ReceiptMessage.Type\022\021\n\tti" + + "mestamp\030\002 \003(\004\"\036\n\004Type\022\014\n\010DELIVERY\020\000\022\010\n\004R" + + "EAD\020\001\"\214\001\n\rTypingMessage\022\021\n\ttimestamp\030\001 \001" + + "(\004\0223\n\006action\030\002 \001(\0162#.signalservice.Typin" + + "gMessage.Action\022\017\n\007groupId\030\003 \001(\014\"\"\n\006Acti" + + "on\022\013\n\007STARTED\020\000\022\013\n\007STOPPED\020\001\"\253\001\n\010Verifie" + + "d\022\023\n\013destination\030\001 \001(\t\022\023\n\013identityKey\030\002 " + + "\001(\014\022,\n\005state\030\003 \001(\0162\035.signalservice.Verif" + + "ied.State\022\023\n\013nullMessage\030\004 \001(\014\"2\n\005State\022", + "\013\n\007DEFAULT\020\000\022\014\n\010VERIFIED\020\001\022\016\n\nUNVERIFIED" + + "\020\002\"\304\013\n\013SyncMessage\022-\n\004sent\030\001 \001(\0132\037.signa" + + "lservice.SyncMessage.Sent\0225\n\010contacts\030\002 " + + "\001(\0132#.signalservice.SyncMessage.Contacts" + + "\0221\n\006groups\030\003 \001(\0132!.signalservice.SyncMes" + + "sage.Groups\0223\n\007request\030\004 \001(\0132\".signalser" + + "vice.SyncMessage.Request\022-\n\004read\030\005 \003(\0132\037" + + ".signalservice.SyncMessage.Read\0223\n\007block" + + "ed\030\006 \001(\0132\".signalservice.SyncMessage.Blo" + + "cked\022)\n\010verified\030\007 \001(\0132\027.signalservice.V", + "erified\022?\n\rconfiguration\030\t \001(\0132(.signals" + + "ervice.SyncMessage.Configuration\022\017\n\007padd" + + "ing\030\010 \001(\014\022M\n\024stickerPackOperation\030\n \003(\0132" + + "/.signalservice.SyncMessage.StickerPackO" + + "peration\032\236\002\n\004Sent\022\023\n\013destination\030\001 \001(\t\022\021" + + "\n\ttimestamp\030\002 \001(\004\022+\n\007message\030\003 \001(\0132\032.sig" + + "nalservice.DataMessage\022 \n\030expirationStar" + + "tTimestamp\030\004 \001(\004\022V\n\022unidentifiedStatus\030\005" + + " \003(\0132:.signalservice.SyncMessage.Sent.Un" + + "identifiedDeliveryStatus\032G\n\032Unidentified", + "DeliveryStatus\022\023\n\013destination\030\001 \001(\t\022\024\n\014u" + + "nidentified\030\002 \001(\010\032S\n\010Contacts\022.\n\004blob\030\001 " + + "\001(\0132 .signalservice.AttachmentPointer\022\027\n" + + "\010complete\030\002 \001(\010:\005false\0328\n\006Groups\022.\n\004blob" + + "\030\001 \001(\0132 .signalservice.AttachmentPointer" + + "\032,\n\007Blocked\022\017\n\007numbers\030\001 \003(\t\022\020\n\010groupIds" + + "\030\002 \003(\014\032\217\001\n\007Request\0225\n\004type\030\001 \001(\0162\'.signa" + + "lservice.SyncMessage.Request.Type\"M\n\004Typ" + + "e\022\013\n\007UNKNOWN\020\000\022\014\n\010CONTACTS\020\001\022\n\n\006GROUPS\020\002" + + "\022\013\n\007BLOCKED\020\003\022\021\n\rCONFIGURATION\020\004\032)\n\004Read", + "\022\016\n\006sender\030\001 \001(\t\022\021\n\ttimestamp\030\002 \001(\004\032}\n\rC" + + "onfiguration\022\024\n\014readReceipts\030\001 \001(\010\022&\n\036un" + + "identifiedDeliveryIndicators\030\002 \001(\010\022\030\n\020ty" + + "pingIndicators\030\003 \001(\010\022\024\n\014linkPreviews\030\004 \001" + + "(\010\032\234\001\n\024StickerPackOperation\022\016\n\006packId\030\001 " + + "\001(\014\022\017\n\007packKey\030\002 \001(\014\022B\n\004type\030\003 \001(\01624.sig" + + "nalservice.SyncMessage.StickerPackOperat" + + "ion.Type\"\037\n\004Type\022\013\n\007INSTALL\020\000\022\n\n\006REMOVE\020" + + "\001\"\337\001\n\021AttachmentPointer\022\n\n\002id\030\001 \001(\006\022\023\n\013c" + + "ontentType\030\002 \001(\t\022\013\n\003key\030\003 \001(\014\022\014\n\004size\030\004 ", + "\001(\r\022\021\n\tthumbnail\030\005 \001(\014\022\016\n\006digest\030\006 \001(\014\022\020" + + "\n\010fileName\030\007 \001(\t\022\r\n\005flags\030\010 \001(\r\022\r\n\005width" + + "\030\t \001(\r\022\016\n\006height\030\n \001(\r\022\017\n\007caption\030\013 \001(\t\"" + + "\032\n\005Flags\022\021\n\rVOICE_MESSAGE\020\001\"\345\001\n\014GroupCon" + + "text\022\n\n\002id\030\001 \001(\014\022.\n\004type\030\002 \001(\0162 .signals" + + "ervice.GroupContext.Type\022\014\n\004name\030\003 \001(\t\022\017" + + "\n\007members\030\004 \003(\t\0220\n\006avatar\030\005 \001(\0132 .signal" + + "service.AttachmentPointer\"H\n\004Type\022\013\n\007UNK" + + "NOWN\020\000\022\n\n\006UPDATE\020\001\022\013\n\007DELIVER\020\002\022\010\n\004QUIT\020" + + "\003\022\020\n\014REQUEST_INFO\020\004\"\207\002\n\016ContactDetails\022\016", + "\n\006number\030\001 \001(\t\022\014\n\004name\030\002 \001(\t\0224\n\006avatar\030\003" + + " \001(\0132$.signalservice.ContactDetails.Avat" + + "ar\022\r\n\005color\030\004 \001(\t\022)\n\010verified\030\005 \001(\0132\027.si" + + "gnalservice.Verified\022\022\n\nprofileKey\030\006 \001(\014" + + "\022\017\n\007blocked\030\007 \001(\010\022\023\n\013expireTimer\030\010 \001(\r\032-" + + "\n\006Avatar\022\023\n\013contentType\030\001 \001(\t\022\016\n\006length\030" + + "\002 \001(\r\"\347\001\n\014GroupDetails\022\n\n\002id\030\001 \001(\014\022\014\n\004na" + + "me\030\002 \001(\t\022\017\n\007members\030\003 \003(\t\0222\n\006avatar\030\004 \001(" + + "\0132\".signalservice.GroupDetails.Avatar\022\024\n" + + "\006active\030\005 \001(\010:\004true\022\023\n\013expireTimer\030\006 \001(\r", + "\022\r\n\005color\030\007 \001(\t\022\017\n\007blocked\030\010 \001(\010\032-\n\006Avat" + + "ar\022\023\n\013contentType\030\001 \001(\t\022\016\n\006length\030\002 \001(\rB" + + "E\n.org.whispersystems.signalservice.inte" + + "rnal.pushB\023SignalServiceProtos" }; com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @@ -35991,7 +37976,7 @@ public final class SignalServiceProtos { internal_static_signalservice_DataMessage_fieldAccessorTable = new com.google.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_signalservice_DataMessage_descriptor, - new java.lang.String[] { "Body", "Attachments", "Group", "Flags", "ExpireTimer", "ProfileKey", "Timestamp", "Quote", "Contact", "Preview", }); + new java.lang.String[] { "Body", "Attachments", "Group", "Flags", "ExpireTimer", "ProfileKey", "Timestamp", "Quote", "Contact", "Preview", "Sticker", }); internal_static_signalservice_DataMessage_Quote_descriptor = internal_static_signalservice_DataMessage_descriptor.getNestedTypes().get(0); internal_static_signalservice_DataMessage_Quote_fieldAccessorTable = new @@ -36046,6 +38031,12 @@ public final class SignalServiceProtos { com.google.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_signalservice_DataMessage_Preview_descriptor, new java.lang.String[] { "Url", "Title", "Image", }); + internal_static_signalservice_DataMessage_Sticker_descriptor = + internal_static_signalservice_DataMessage_descriptor.getNestedTypes().get(3); + internal_static_signalservice_DataMessage_Sticker_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_signalservice_DataMessage_Sticker_descriptor, + new java.lang.String[] { "PackId", "PackKey", "StickerId", "Data", }); internal_static_signalservice_NullMessage_descriptor = getDescriptor().getMessageTypes().get(4); internal_static_signalservice_NullMessage_fieldAccessorTable = new @@ -36075,7 +38066,7 @@ public final class SignalServiceProtos { internal_static_signalservice_SyncMessage_fieldAccessorTable = new com.google.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_signalservice_SyncMessage_descriptor, - new java.lang.String[] { "Sent", "Contacts", "Groups", "Request", "Read", "Blocked", "Verified", "Configuration", "Padding", }); + new java.lang.String[] { "Sent", "Contacts", "Groups", "Request", "Read", "Blocked", "Verified", "Configuration", "Padding", "StickerPackOperation", }); internal_static_signalservice_SyncMessage_Sent_descriptor = internal_static_signalservice_SyncMessage_descriptor.getNestedTypes().get(0); internal_static_signalservice_SyncMessage_Sent_fieldAccessorTable = new @@ -36124,6 +38115,12 @@ public final class SignalServiceProtos { com.google.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_signalservice_SyncMessage_Configuration_descriptor, new java.lang.String[] { "ReadReceipts", "UnidentifiedDeliveryIndicators", "TypingIndicators", "LinkPreviews", }); + internal_static_signalservice_SyncMessage_StickerPackOperation_descriptor = + internal_static_signalservice_SyncMessage_descriptor.getNestedTypes().get(7); + internal_static_signalservice_SyncMessage_StickerPackOperation_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_signalservice_SyncMessage_StickerPackOperation_descriptor, + new java.lang.String[] { "PackId", "PackKey", "Type", }); internal_static_signalservice_AttachmentPointer_descriptor = getDescriptor().getMessageTypes().get(9); internal_static_signalservice_AttachmentPointer_fieldAccessorTable = new diff --git a/java/src/main/java/org/whispersystems/signalservice/internal/sticker/StickerProtos.java b/java/src/main/java/org/whispersystems/signalservice/internal/sticker/StickerProtos.java new file mode 100644 index 0000000..87cde80 --- /dev/null +++ b/java/src/main/java/org/whispersystems/signalservice/internal/sticker/StickerProtos.java @@ -0,0 +1,1798 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: StickerResources.proto + +package org.whispersystems.signalservice.internal.sticker; + +public final class StickerProtos { + private StickerProtos() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface PackOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional string title = 1; + /** + * optional string title = 1; + */ + boolean hasTitle(); + /** + * optional string title = 1; + */ + java.lang.String getTitle(); + /** + * optional string title = 1; + */ + com.google.protobuf.ByteString + getTitleBytes(); + + // optional string author = 2; + /** + * optional string author = 2; + */ + boolean hasAuthor(); + /** + * optional string author = 2; + */ + java.lang.String getAuthor(); + /** + * optional string author = 2; + */ + com.google.protobuf.ByteString + getAuthorBytes(); + + // optional .signalservice.Pack.Sticker cover = 3; + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + boolean hasCover(); + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker getCover(); + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder getCoverOrBuilder(); + + // repeated .signalservice.Pack.Sticker stickers = 4; + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + java.util.List + getStickersList(); + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker getStickers(int index); + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + int getStickersCount(); + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + java.util.List + getStickersOrBuilderList(); + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder getStickersOrBuilder( + int index); + } + /** + * Protobuf type {@code signalservice.Pack} + */ + public static final class Pack extends + com.google.protobuf.GeneratedMessage + implements PackOrBuilder { + // Use Pack.newBuilder() to construct. + private Pack(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Pack(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final Pack defaultInstance; + public static Pack getDefaultInstance() { + return defaultInstance; + } + + public Pack getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Pack( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + title_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + author_ = input.readBytes(); + break; + } + case 26: { + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = cover_.toBuilder(); + } + cover_ = input.readMessage(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(cover_); + cover_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + stickers_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + stickers_.add(input.readMessage(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.PARSER, extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + stickers_ = java.util.Collections.unmodifiableList(stickers_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.class, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public Pack parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Pack(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public interface StickerOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional uint32 id = 1; + /** + * optional uint32 id = 1; + */ + boolean hasId(); + /** + * optional uint32 id = 1; + */ + int getId(); + + // optional string emoji = 2; + /** + * optional string emoji = 2; + */ + boolean hasEmoji(); + /** + * optional string emoji = 2; + */ + java.lang.String getEmoji(); + /** + * optional string emoji = 2; + */ + com.google.protobuf.ByteString + getEmojiBytes(); + } + /** + * Protobuf type {@code signalservice.Pack.Sticker} + */ + public static final class Sticker extends + com.google.protobuf.GeneratedMessage + implements StickerOrBuilder { + // Use Sticker.newBuilder() to construct. + private Sticker(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Sticker(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final Sticker defaultInstance; + public static Sticker getDefaultInstance() { + return defaultInstance; + } + + public Sticker getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Sticker( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + id_ = input.readUInt32(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + emoji_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_Sticker_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_Sticker_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.class, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public Sticker parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Sticker(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // optional uint32 id = 1; + public static final int ID_FIELD_NUMBER = 1; + private int id_; + /** + * optional uint32 id = 1; + */ + public boolean hasId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional uint32 id = 1; + */ + public int getId() { + return id_; + } + + // optional string emoji = 2; + public static final int EMOJI_FIELD_NUMBER = 2; + private java.lang.Object emoji_; + /** + * optional string emoji = 2; + */ + public boolean hasEmoji() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string emoji = 2; + */ + public java.lang.String getEmoji() { + java.lang.Object ref = emoji_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + emoji_ = s; + } + return s; + } + } + /** + * optional string emoji = 2; + */ + public com.google.protobuf.ByteString + getEmojiBytes() { + java.lang.Object ref = emoji_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + emoji_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + id_ = 0; + emoji_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeUInt32(1, id_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getEmojiBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, id_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getEmojiBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code signalservice.Pack.Sticker} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_Sticker_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_Sticker_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.class, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder.class); + } + + // Construct using org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + id_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + emoji_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_Sticker_descriptor; + } + + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker getDefaultInstanceForType() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance(); + } + + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker build() { + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker buildPartial() { + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker result = new org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.id_ = id_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.emoji_ = emoji_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker) { + return mergeFrom((org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker other) { + if (other == org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance()) return this; + if (other.hasId()) { + setId(other.getId()); + } + if (other.hasEmoji()) { + bitField0_ |= 0x00000002; + emoji_ = other.emoji_; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional uint32 id = 1; + private int id_ ; + /** + * optional uint32 id = 1; + */ + public boolean hasId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional uint32 id = 1; + */ + public int getId() { + return id_; + } + /** + * optional uint32 id = 1; + */ + public Builder setId(int value) { + bitField0_ |= 0x00000001; + id_ = value; + onChanged(); + return this; + } + /** + * optional uint32 id = 1; + */ + public Builder clearId() { + bitField0_ = (bitField0_ & ~0x00000001); + id_ = 0; + onChanged(); + return this; + } + + // optional string emoji = 2; + private java.lang.Object emoji_ = ""; + /** + * optional string emoji = 2; + */ + public boolean hasEmoji() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string emoji = 2; + */ + public java.lang.String getEmoji() { + java.lang.Object ref = emoji_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + emoji_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string emoji = 2; + */ + public com.google.protobuf.ByteString + getEmojiBytes() { + java.lang.Object ref = emoji_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + emoji_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string emoji = 2; + */ + public Builder setEmoji( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + emoji_ = value; + onChanged(); + return this; + } + /** + * optional string emoji = 2; + */ + public Builder clearEmoji() { + bitField0_ = (bitField0_ & ~0x00000002); + emoji_ = getDefaultInstance().getEmoji(); + onChanged(); + return this; + } + /** + * optional string emoji = 2; + */ + public Builder setEmojiBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + emoji_ = value; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:signalservice.Pack.Sticker) + } + + static { + defaultInstance = new Sticker(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:signalservice.Pack.Sticker) + } + + private int bitField0_; + // optional string title = 1; + public static final int TITLE_FIELD_NUMBER = 1; + private java.lang.Object title_; + /** + * optional string title = 1; + */ + public boolean hasTitle() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional string title = 1; + */ + public java.lang.String getTitle() { + java.lang.Object ref = title_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + title_ = s; + } + return s; + } + } + /** + * optional string title = 1; + */ + public com.google.protobuf.ByteString + getTitleBytes() { + java.lang.Object ref = title_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + title_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional string author = 2; + public static final int AUTHOR_FIELD_NUMBER = 2; + private java.lang.Object author_; + /** + * optional string author = 2; + */ + public boolean hasAuthor() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string author = 2; + */ + public java.lang.String getAuthor() { + java.lang.Object ref = author_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + author_ = s; + } + return s; + } + } + /** + * optional string author = 2; + */ + public com.google.protobuf.ByteString + getAuthorBytes() { + java.lang.Object ref = author_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + author_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional .signalservice.Pack.Sticker cover = 3; + public static final int COVER_FIELD_NUMBER = 3; + private org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker cover_; + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public boolean hasCover() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker getCover() { + return cover_; + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder getCoverOrBuilder() { + return cover_; + } + + // repeated .signalservice.Pack.Sticker stickers = 4; + public static final int STICKERS_FIELD_NUMBER = 4; + private java.util.List stickers_; + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public java.util.List getStickersList() { + return stickers_; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public java.util.List + getStickersOrBuilderList() { + return stickers_; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public int getStickersCount() { + return stickers_.size(); + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker getStickers(int index) { + return stickers_.get(index); + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder getStickersOrBuilder( + int index) { + return stickers_.get(index); + } + + private void initFields() { + title_ = ""; + author_ = ""; + cover_ = org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance(); + stickers_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getTitleBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getAuthorBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, cover_); + } + for (int i = 0; i < stickers_.size(); i++) { + output.writeMessage(4, stickers_.get(i)); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getTitleBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getAuthorBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, cover_); + } + for (int i = 0; i < stickers_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, stickers_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code signalservice.Pack} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.whispersystems.signalservice.internal.sticker.StickerProtos.PackOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.class, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Builder.class); + } + + // Construct using org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getCoverFieldBuilder(); + getStickersFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + title_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + author_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + if (coverBuilder_ == null) { + cover_ = org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance(); + } else { + coverBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (stickersBuilder_ == null) { + stickers_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + } else { + stickersBuilder_.clear(); + } + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.internal_static_signalservice_Pack_descriptor; + } + + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack getDefaultInstanceForType() { + return org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.getDefaultInstance(); + } + + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack build() { + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack buildPartial() { + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack result = new org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.title_ = title_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.author_ = author_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + if (coverBuilder_ == null) { + result.cover_ = cover_; + } else { + result.cover_ = coverBuilder_.build(); + } + if (stickersBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008)) { + stickers_ = java.util.Collections.unmodifiableList(stickers_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.stickers_ = stickers_; + } else { + result.stickers_ = stickersBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack) { + return mergeFrom((org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack other) { + if (other == org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.getDefaultInstance()) return this; + if (other.hasTitle()) { + bitField0_ |= 0x00000001; + title_ = other.title_; + onChanged(); + } + if (other.hasAuthor()) { + bitField0_ |= 0x00000002; + author_ = other.author_; + onChanged(); + } + if (other.hasCover()) { + mergeCover(other.getCover()); + } + if (stickersBuilder_ == null) { + if (!other.stickers_.isEmpty()) { + if (stickers_.isEmpty()) { + stickers_ = other.stickers_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureStickersIsMutable(); + stickers_.addAll(other.stickers_); + } + onChanged(); + } + } else { + if (!other.stickers_.isEmpty()) { + if (stickersBuilder_.isEmpty()) { + stickersBuilder_.dispose(); + stickersBuilder_ = null; + stickers_ = other.stickers_; + bitField0_ = (bitField0_ & ~0x00000008); + stickersBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getStickersFieldBuilder() : null; + } else { + stickersBuilder_.addAllMessages(other.stickers_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional string title = 1; + private java.lang.Object title_ = ""; + /** + * optional string title = 1; + */ + public boolean hasTitle() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional string title = 1; + */ + public java.lang.String getTitle() { + java.lang.Object ref = title_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + title_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string title = 1; + */ + public com.google.protobuf.ByteString + getTitleBytes() { + java.lang.Object ref = title_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + title_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string title = 1; + */ + public Builder setTitle( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + title_ = value; + onChanged(); + return this; + } + /** + * optional string title = 1; + */ + public Builder clearTitle() { + bitField0_ = (bitField0_ & ~0x00000001); + title_ = getDefaultInstance().getTitle(); + onChanged(); + return this; + } + /** + * optional string title = 1; + */ + public Builder setTitleBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + title_ = value; + onChanged(); + return this; + } + + // optional string author = 2; + private java.lang.Object author_ = ""; + /** + * optional string author = 2; + */ + public boolean hasAuthor() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string author = 2; + */ + public java.lang.String getAuthor() { + java.lang.Object ref = author_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + author_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string author = 2; + */ + public com.google.protobuf.ByteString + getAuthorBytes() { + java.lang.Object ref = author_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + author_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string author = 2; + */ + public Builder setAuthor( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + author_ = value; + onChanged(); + return this; + } + /** + * optional string author = 2; + */ + public Builder clearAuthor() { + bitField0_ = (bitField0_ & ~0x00000002); + author_ = getDefaultInstance().getAuthor(); + onChanged(); + return this; + } + /** + * optional string author = 2; + */ + public Builder setAuthorBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + author_ = value; + onChanged(); + return this; + } + + // optional .signalservice.Pack.Sticker cover = 3; + private org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker cover_ = org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder> coverBuilder_; + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public boolean hasCover() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker getCover() { + if (coverBuilder_ == null) { + return cover_; + } else { + return coverBuilder_.getMessage(); + } + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public Builder setCover(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker value) { + if (coverBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + cover_ = value; + onChanged(); + } else { + coverBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public Builder setCover( + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder builderForValue) { + if (coverBuilder_ == null) { + cover_ = builderForValue.build(); + onChanged(); + } else { + coverBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public Builder mergeCover(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker value) { + if (coverBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + cover_ != org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance()) { + cover_ = + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.newBuilder(cover_).mergeFrom(value).buildPartial(); + } else { + cover_ = value; + } + onChanged(); + } else { + coverBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public Builder clearCover() { + if (coverBuilder_ == null) { + cover_ = org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance(); + onChanged(); + } else { + coverBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder getCoverBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCoverFieldBuilder().getBuilder(); + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder getCoverOrBuilder() { + if (coverBuilder_ != null) { + return coverBuilder_.getMessageOrBuilder(); + } else { + return cover_; + } + } + /** + * optional .signalservice.Pack.Sticker cover = 3; + */ + private com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder> + getCoverFieldBuilder() { + if (coverBuilder_ == null) { + coverBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder>( + cover_, + getParentForChildren(), + isClean()); + cover_ = null; + } + return coverBuilder_; + } + + // repeated .signalservice.Pack.Sticker stickers = 4; + private java.util.List stickers_ = + java.util.Collections.emptyList(); + private void ensureStickersIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + stickers_ = new java.util.ArrayList(stickers_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder> stickersBuilder_; + + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public java.util.List getStickersList() { + if (stickersBuilder_ == null) { + return java.util.Collections.unmodifiableList(stickers_); + } else { + return stickersBuilder_.getMessageList(); + } + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public int getStickersCount() { + if (stickersBuilder_ == null) { + return stickers_.size(); + } else { + return stickersBuilder_.getCount(); + } + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker getStickers(int index) { + if (stickersBuilder_ == null) { + return stickers_.get(index); + } else { + return stickersBuilder_.getMessage(index); + } + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder setStickers( + int index, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker value) { + if (stickersBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStickersIsMutable(); + stickers_.set(index, value); + onChanged(); + } else { + stickersBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder setStickers( + int index, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder builderForValue) { + if (stickersBuilder_ == null) { + ensureStickersIsMutable(); + stickers_.set(index, builderForValue.build()); + onChanged(); + } else { + stickersBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder addStickers(org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker value) { + if (stickersBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStickersIsMutable(); + stickers_.add(value); + onChanged(); + } else { + stickersBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder addStickers( + int index, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker value) { + if (stickersBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStickersIsMutable(); + stickers_.add(index, value); + onChanged(); + } else { + stickersBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder addStickers( + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder builderForValue) { + if (stickersBuilder_ == null) { + ensureStickersIsMutable(); + stickers_.add(builderForValue.build()); + onChanged(); + } else { + stickersBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder addStickers( + int index, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder builderForValue) { + if (stickersBuilder_ == null) { + ensureStickersIsMutable(); + stickers_.add(index, builderForValue.build()); + onChanged(); + } else { + stickersBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder addAllStickers( + java.lang.Iterable values) { + if (stickersBuilder_ == null) { + ensureStickersIsMutable(); + super.addAll(values, stickers_); + onChanged(); + } else { + stickersBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder clearStickers() { + if (stickersBuilder_ == null) { + stickers_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + stickersBuilder_.clear(); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public Builder removeStickers(int index) { + if (stickersBuilder_ == null) { + ensureStickersIsMutable(); + stickers_.remove(index); + onChanged(); + } else { + stickersBuilder_.remove(index); + } + return this; + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder getStickersBuilder( + int index) { + return getStickersFieldBuilder().getBuilder(index); + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder getStickersOrBuilder( + int index) { + if (stickersBuilder_ == null) { + return stickers_.get(index); } else { + return stickersBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public java.util.List + getStickersOrBuilderList() { + if (stickersBuilder_ != null) { + return stickersBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(stickers_); + } + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder addStickersBuilder() { + return getStickersFieldBuilder().addBuilder( + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance()); + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder addStickersBuilder( + int index) { + return getStickersFieldBuilder().addBuilder( + index, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.getDefaultInstance()); + } + /** + * repeated .signalservice.Pack.Sticker stickers = 4; + */ + public java.util.List + getStickersBuilderList() { + return getStickersFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder> + getStickersFieldBuilder() { + if (stickersBuilder_ == null) { + stickersBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.Sticker.Builder, org.whispersystems.signalservice.internal.sticker.StickerProtos.Pack.StickerOrBuilder>( + stickers_, + ((bitField0_ & 0x00000008) == 0x00000008), + getParentForChildren(), + isClean()); + stickers_ = null; + } + return stickersBuilder_; + } + + // @@protoc_insertion_point(builder_scope:signalservice.Pack) + } + + static { + defaultInstance = new Pack(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:signalservice.Pack) + } + + private static com.google.protobuf.Descriptors.Descriptor + internal_static_signalservice_Pack_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_signalservice_Pack_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_signalservice_Pack_Sticker_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_signalservice_Pack_Sticker_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\026StickerResources.proto\022\rsignalservice\"" + + "\246\001\n\004Pack\022\r\n\005title\030\001 \001(\t\022\016\n\006author\030\002 \001(\t\022" + + "*\n\005cover\030\003 \001(\0132\033.signalservice.Pack.Stic" + + "ker\022-\n\010stickers\030\004 \003(\0132\033.signalservice.Pa" + + "ck.Sticker\032$\n\007Sticker\022\n\n\002id\030\001 \001(\r\022\r\n\005emo" + + "ji\030\002 \001(\tBB\n1org.whispersystems.signalser" + + "vice.internal.stickerB\rStickerProtos" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + internal_static_signalservice_Pack_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_signalservice_Pack_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_signalservice_Pack_descriptor, + new java.lang.String[] { "Title", "Author", "Cover", "Stickers", }); + internal_static_signalservice_Pack_Sticker_descriptor = + internal_static_signalservice_Pack_descriptor.getNestedTypes().get(0); + internal_static_signalservice_Pack_Sticker_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_signalservice_Pack_Sticker_descriptor, + new java.lang.String[] { "Id", "Emoji", }); + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/java/src/test/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherTest.java b/java/src/test/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherTest.java new file mode 100644 index 0000000..8c273ed --- /dev/null +++ b/java/src/test/java/org/whispersystems/signalservice/api/crypto/AttachmentCipherTest.java @@ -0,0 +1,244 @@ +package org.whispersystems.signalservice.api.crypto; + +import junit.framework.TestCase; + +import org.conscrypt.Conscrypt; +import org.whispersystems.libsignal.InvalidMessageException; +import org.whispersystems.libsignal.kdf.HKDFv3; +import org.whispersystems.signalservice.internal.util.Util; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.security.Security; +import java.util.Arrays; + +public class AttachmentCipherTest extends TestCase { + + static { + Security.insertProviderAt(Conscrypt.newProvider(), 1); + } + + public void test_attachment_encryptDecrypt() throws IOException, InvalidMessageException { + byte[] key = Util.getSecretBytes(64); + byte[] plaintextInput = "Peter Parker".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, key); + File cipherFile = writeToFile(encryptResult.ciphertext); + InputStream inputStream = AttachmentCipherInputStream.createForAttachment(cipherFile, plaintextInput.length, key, encryptResult.digest); + byte[] plaintextOutput = readInputStreamFully(inputStream); + + assertTrue(Arrays.equals(plaintextInput, plaintextOutput)); + + cipherFile.delete(); + } + + public void test_attachment_encryptDecryptEmpty() throws IOException, InvalidMessageException { + byte[] key = Util.getSecretBytes(64); + byte[] plaintextInput = "".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, key); + File cipherFile = writeToFile(encryptResult.ciphertext); + InputStream inputStream = AttachmentCipherInputStream.createForAttachment(cipherFile, plaintextInput.length, key, encryptResult.digest); + byte[] plaintextOutput = readInputStreamFully(inputStream); + + assertTrue(Arrays.equals(plaintextInput, plaintextOutput)); + + cipherFile.delete(); + } + + public void test_attachment_decryptFailOnBadKey() throws IOException{ + File cipherFile = null; + boolean hitCorrectException = false; + + try { + byte[] key = Util.getSecretBytes(64); + byte[] plaintextInput = "Gwen Stacy".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, key); + byte[] badKey = new byte[64]; + + cipherFile = writeToFile(encryptResult.ciphertext); + + AttachmentCipherInputStream.createForAttachment(cipherFile, plaintextInput.length, badKey, encryptResult.digest); + } catch (InvalidMessageException e) { + hitCorrectException = true; + } finally { + if (cipherFile != null) { + cipherFile.delete(); + } + } + + assertTrue(hitCorrectException); + } + + public void test_attachment_decryptFailOnBadDigest() throws IOException{ + File cipherFile = null; + boolean hitCorrectException = false; + + try { + byte[] key = Util.getSecretBytes(64); + byte[] plaintextInput = "Mary Jane Watson".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, key); + byte[] badDigest = new byte[32]; + + cipherFile = writeToFile(encryptResult.ciphertext); + + AttachmentCipherInputStream.createForAttachment(cipherFile, plaintextInput.length, key, badDigest); + } catch (InvalidMessageException e) { + hitCorrectException = true; + } finally { + if (cipherFile != null) { + cipherFile.delete(); + } + } + + assertTrue(hitCorrectException); + } + + public void test_attachment_decryptFailOnNullDigest() throws IOException{ + File cipherFile = null; + boolean hitCorrectException = false; + + try { + byte[] key = Util.getSecretBytes(64); + byte[] plaintextInput = "Aunt May".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, key); + + cipherFile = writeToFile(encryptResult.ciphertext); + + AttachmentCipherInputStream.createForAttachment(cipherFile, plaintextInput.length, key, null); + } catch (InvalidMessageException e) { + hitCorrectException = true; + } finally { + if (cipherFile != null) { + cipherFile.delete(); + } + } + + assertTrue(hitCorrectException); + } + + public void test_attachment_decryptFailOnBadMac() throws IOException { + File cipherFile = null; + boolean hitCorrectException = false; + + try { + byte[] key = Util.getSecretBytes(64); + byte[] plaintextInput = "Uncle Ben".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, key); + byte[] badMacCiphertext = Arrays.copyOf(encryptResult.ciphertext, encryptResult.ciphertext.length); + + badMacCiphertext[badMacCiphertext.length - 1] = 0; + + cipherFile = writeToFile(badMacCiphertext); + + AttachmentCipherInputStream.createForAttachment(cipherFile, plaintextInput.length, key, encryptResult.digest); + } catch (InvalidMessageException e) { + hitCorrectException = true; + } finally { + if (cipherFile != null) { + cipherFile.delete(); + } + } + + assertTrue(hitCorrectException); + } + + public void test_sticker_encryptDecrypt() throws IOException, InvalidMessageException { + byte[] packKey = Util.getSecretBytes(32); + byte[] plaintextInput = "Peter Parker".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, expandPackKey(packKey)); + InputStream inputStream = AttachmentCipherInputStream.createForStickerData(encryptResult.ciphertext, packKey); + byte[] plaintextOutput = readInputStreamFully(inputStream); + + assertTrue(Arrays.equals(plaintextInput, plaintextOutput)); + } + + public void test_sticker_encryptDecryptEmpty() throws IOException, InvalidMessageException { + byte[] packKey = Util.getSecretBytes(32); + byte[] plaintextInput = "".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, expandPackKey(packKey)); + InputStream inputStream = AttachmentCipherInputStream.createForStickerData(encryptResult.ciphertext, packKey); + byte[] plaintextOutput = readInputStreamFully(inputStream); + + assertTrue(Arrays.equals(plaintextInput, plaintextOutput)); + } + + public void test_sticker_decryptFailOnBadKey() throws IOException{ + boolean hitCorrectException = false; + + try { + byte[] packKey = Util.getSecretBytes(32); + byte[] plaintextInput = "Gwen Stacy".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, expandPackKey(packKey)); + byte[] badPackKey = new byte[32]; + + AttachmentCipherInputStream.createForStickerData(encryptResult.ciphertext, badPackKey); + } catch (InvalidMessageException e) { + hitCorrectException = true; + } + + assertTrue(hitCorrectException); + } + + public void test_sticker_decryptFailOnBadMac() throws IOException { + boolean hitCorrectException = false; + + try { + byte[] packKey = Util.getSecretBytes(32); + byte[] plaintextInput = "Uncle Ben".getBytes(); + EncryptResult encryptResult = encryptData(plaintextInput, expandPackKey(packKey)); + byte[] badMacCiphertext = Arrays.copyOf(encryptResult.ciphertext, encryptResult.ciphertext.length); + + badMacCiphertext[badMacCiphertext.length - 1] = 0; + + AttachmentCipherInputStream.createForStickerData(badMacCiphertext, packKey); + } catch (InvalidMessageException e) { + hitCorrectException = true; + } + + assertTrue(hitCorrectException); + } + + private static EncryptResult encryptData(byte[] data, byte[] keyMaterial) throws IOException { + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + AttachmentCipherOutputStream encryptStream = new AttachmentCipherOutputStream(keyMaterial, outputStream); + + encryptStream.write(data); + encryptStream.flush(); + encryptStream.close(); + + return new EncryptResult(outputStream.toByteArray(), encryptStream.getTransmittedDigest()); + } + + private static File writeToFile(byte[] data) throws IOException { + File file = File.createTempFile("temp", ".data"); + OutputStream outputStream = new FileOutputStream(file); + + outputStream.write(data); + outputStream.close(); + + return file; + } + + private static byte[] readInputStreamFully(InputStream inputStream) throws IOException { + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + Util.copy(inputStream, outputStream); + return outputStream.toByteArray(); + } + + private static byte[] expandPackKey(byte[] shortKey) { + return new HKDFv3().deriveSecrets(shortKey, "Sticker Pack".getBytes(), 64); + } + + private static class EncryptResult { + final byte[] ciphertext; + final byte[] digest; + + private EncryptResult(byte[] ciphertext, byte[] digest) { + this.ciphertext = ciphertext; + this.digest = digest; + } + } +} diff --git a/protobuf/Makefile b/protobuf/Makefile index 843fcac..30c33c4 100644 --- a/protobuf/Makefile +++ b/protobuf/Makefile @@ -1,3 +1,3 @@ all: - protoc --java_out=../java/src/main/java/ SignalService.proto Provisioning.proto WebSocketResources.proto + protoc --java_out=../java/src/main/java/ SignalService.proto Provisioning.proto WebSocketResources.proto StickerResources.proto diff --git a/protobuf/SignalService.proto b/protobuf/SignalService.proto index fda6ff9..6b66d70 100644 --- a/protobuf/SignalService.proto +++ b/protobuf/SignalService.proto @@ -166,6 +166,13 @@ message DataMessage { optional AttachmentPointer image = 3; } + message Sticker { + optional bytes packId = 1; + optional bytes packKey = 2; + optional uint32 stickerId = 3; + optional AttachmentPointer data = 4; + } + optional string body = 1; repeated AttachmentPointer attachments = 2; optional GroupContext group = 3; @@ -176,6 +183,7 @@ message DataMessage { optional Quote quote = 8; repeated Contact contact = 9; repeated Preview preview = 10; + optional Sticker sticker = 11; } message NullMessage { @@ -268,15 +276,28 @@ message SyncMessage { optional bool linkPreviews = 4; } - optional Sent sent = 1; - optional Contacts contacts = 2; - optional Groups groups = 3; - optional Request request = 4; - repeated Read read = 5; - optional Blocked blocked = 6; - optional Verified verified = 7; - optional Configuration configuration = 9; - optional bytes padding = 8; + message StickerPackOperation { + enum Type { + INSTALL = 0; + REMOVE = 1; + } + + optional bytes packId = 1; + optional bytes packKey = 2; + optional Type type = 3; + } + + + optional Sent sent = 1; + optional Contacts contacts = 2; + optional Groups groups = 3; + optional Request request = 4; + repeated Read read = 5; + optional Blocked blocked = 6; + optional Verified verified = 7; + optional Configuration configuration = 9; + optional bytes padding = 8; + repeated StickerPackOperation stickerPackOperation = 10; } message AttachmentPointer { diff --git a/protobuf/StickerResources.proto b/protobuf/StickerResources.proto new file mode 100644 index 0000000..0fe8c64 --- /dev/null +++ b/protobuf/StickerResources.proto @@ -0,0 +1,23 @@ +/** + * Copyright (C) 2019 Open Whisper Systems + * + * Licensed according to the LICENSE file in this repository. + */ + +package signalservice; + +option java_package = "org.whispersystems.signalservice.internal.sticker"; +option java_outer_classname = "StickerProtos"; + +message Pack { + message Sticker { + optional uint32 id = 1; + optional string emoji = 2; + } + + optional string title = 1; + optional string author = 2; + optional Sticker cover = 3; + repeated Sticker stickers = 4; +} +