Java SignalServiceSyncMessage类代码示例

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
@Override
public void onRun(MasterSecret masterSecret)
    throws IOException, UntrustedIdentityException
{
  RecipientPreferenceDatabase database      = DatabaseFactory.getRecipientPreferenceDatabase(context);
  SignalServiceMessageSender  messageSender = messageSenderFactory.create();
  BlockedReader               reader        = database.readerForBlocked(database.getBlocked());
  List<String>                blocked       = new LinkedList<>();

  Recipients recipients;

  while ((recipients = reader.getNext()) != null) {
    if (recipients.isSingleRecipient()) {
      try {
        blocked.add(Util.canonicalizeNumber(context, recipients.getPrimaryRecipient().getNumber()));
      } catch (InvalidNumberException e) {
        Log.w(TAG, e);
      }
    }
  }

  messageSender.sendMessage(SignalServiceSyncMessage.forBlocked(new BlockedListMessage(blocked)));
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
private void sendUpdate(SignalServiceMessageSender messageSender, File contactsFile)
    throws IOException, UntrustedIdentityException, NetworkException
{
  if (contactsFile.length() > 0) {
    FileInputStream               contactsFileStream = new FileInputStream(contactsFile);
    SignalServiceAttachmentStream attachmentStream   = SignalServiceAttachment.newStreamBuilder()
                                                                              .withStream(contactsFileStream)
                                                                              .withContentType("application/octet-stream")
                                                                              .withLength(contactsFile.length())
                                                                              .build();

    try {
      messageSender.sendMessage(SignalServiceSyncMessage.forContacts(attachmentStream));
    } catch (IOException ioe) {
      throw new NetworkException(ioe);
    }
  }
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
@Override
public void onRun(MasterSecret masterSecret) throws IOException, UntrustedIdentityException {
  if (!TextSecurePreferences.isMultiDevice(context)) {
    Log.w(TAG, "Not multi device...");
    return;
  }

  List<ReadMessage> readMessages = new LinkedList<>();

  for (SerializableSyncMessageId messageId : messageIds) {
    readMessages.add(new ReadMessage(messageId.sender, messageId.timestamp));
  }

  SignalServiceMessageSender messageSender = messageSenderFactory.create();
  messageSender.sendMessage(SignalServiceSyncMessage.forRead(readMessages));
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
public void sendMessage(SignalServiceSyncMessage message)
    throws IOException, UntrustedIdentityException
{
  byte[] content;

  if (message.getContacts().isPresent()) {
    content = createMultiDeviceContactsContent(message.getContacts().get().asStream());
  } else if (message.getGroups().isPresent()) {
    content = createMultiDeviceGroupsContent(message.getGroups().get().asStream());
  } else if (message.getRead().isPresent()) {
    content = createMultiDeviceReadContent(message.getRead().get());
  } else if (message.getBlockedList().isPresent()) {
    content = createMultiDeviceBlockedContent(message.getBlockedList().get());
  } else {
    throw new IOException("Unsupported sync message!");
  }

  sendMessage(localAddress, System.currentTimeMillis(), content, false, false);
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
private SignalServiceSyncMessage createSynchronizeMessage(SignalServiceEnvelope envelope, SyncMessage content) {
  if (content.hasSent()) {
    SyncMessage.Sent sentContent = content.getSent();
    return SignalServiceSyncMessage.forSentTranscript(new SentTranscriptMessage(sentContent.getDestination(),
                                                                                sentContent.getTimestamp(),
                                                                                createSignalServiceMessage(envelope, sentContent.getMessage()),
                                                                                sentContent.getExpirationStartTimestamp()));
  }

  if (content.hasRequest()) {
    return SignalServiceSyncMessage.forRequest(new RequestMessage(content.getRequest()));
  }

  if (content.getReadList().size() > 0) {
    List<ReadMessage> readMessages = new LinkedList<>();

    for (SyncMessage.Read read : content.getReadList()) {
      readMessages.add(new ReadMessage(read.getSender(), read.getTimestamp()));
    }

    return SignalServiceSyncMessage.forRead(readMessages);
  }

  return SignalServiceSyncMessage.empty();
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
@Override
public void onRun() throws IOException, UntrustedIdentityException {
  try {
    if (!TextSecurePreferences.isMultiDevice(context)) {
      Log.w(TAG, "Not multi device...");
      return;
    }

    if (destination == null) {
      Log.w(TAG, "No destination...");
      return;
    }

    String                        canonicalDestination = Util.canonicalizeNumber(context, destination);
    VerifiedMessage.VerifiedState verifiedState        = getVerifiedState(verifiedStatus);
    SignalServiceMessageSender    messageSender        = messageSenderFactory.create();
    VerifiedMessage               verifiedMessage      = new VerifiedMessage(canonicalDestination, new IdentityKey(identityKey, 0), verifiedState, timestamp);

    messageSender.sendMessage(SignalServiceSyncMessage.forVerified(verifiedMessage));
  } catch (InvalidNumberException | InvalidKeyException e) {
    throw new IOException(e);
  }
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
private void sendUpdate(SignalServiceMessageSender messageSender, File contactsFile, boolean complete)
    throws IOException, UntrustedIdentityException, NetworkException
{
  if (contactsFile.length() > 0) {
    FileInputStream               contactsFileStream = new FileInputStream(contactsFile);
    SignalServiceAttachmentStream attachmentStream   = SignalServiceAttachment.newStreamBuilder()
                                                                              .withStream(contactsFileStream)
                                                                              .withContentType("application/octet-stream")
                                                                              .withLength(contactsFile.length())
                                                                              .build();

    try {
      messageSender.sendMessage(SignalServiceSyncMessage.forContacts(new ContactsMessage(attachmentStream, complete)));
    } catch (IOException ioe) {
      throw new NetworkException(ioe);
    }
  }
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
private void sendUpdate(SignalServiceMessageSender messageSender, File contactsFile)
    throws IOException, UntrustedIdentityException
{
  FileInputStream               contactsFileStream = new FileInputStream(contactsFile);
  SignalServiceAttachmentStream attachmentStream   = SignalServiceAttachment.newStreamBuilder()
                                                                            .withStream(contactsFileStream)
                                                                            .withContentType("application/octet-stream")
                                                                            .withLength(contactsFile.length())
                                                                            .build();

  messageSender.sendMessage(SignalServiceSyncMessage.forGroups(attachmentStream));
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
/**
 * Notify other devices that these messages have been read.
 * @param messages
 * @throws IOException
 */
public void markRead(List<ReadMessage> messages) throws IOException {
	checkRegistered();
	checkMessageSender();
	try {
		SignalServiceSyncMessage syncMessage = SignalServiceSyncMessage.forRead(messages);
		messageSender.sendMessage(syncMessage);
	} catch (UntrustedIdentityException e) {
		fireSecurityException(new SignalServiceAddress(store.getPhoneNumber()), e);
	}
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
/**
 * Request sync messages from primary device. They are received using the listeners
 * @throws IOException
 * @throws UntrustedIdentityException
 */
public void requestSync() throws IOException {
	try {
		checkRegistered();
		checkMessageSender();
		Request.Type[] types = new Request.Type[] {Request.Type.CONTACTS, Request.Type.GROUPS, Request.Type.BLOCKED};
		for(Request.Type type : types) {
			RequestMessage request = new RequestMessage(Request.newBuilder().setType(type).build());
			SignalServiceSyncMessage syncMessage = SignalServiceSyncMessage.forRequest(request);
			messageSender.sendMessage(syncMessage);
		}
	} catch(UntrustedIdentityException e) {
		fireSecurityException(new SignalServiceAddress(store.getPhoneNumber()), e);
	}
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
JsonSyncMessage(SignalServiceSyncMessage syncMessage) {
    if (syncMessage.getSent().isPresent()) {
        this.sentMessage = new JsonDataMessage(syncMessage.getSent().get().getMessage());
    }
    if (syncMessage.getBlockedList().isPresent()) {
        this.blockedNumbers = syncMessage.getBlockedList().get().getNumbers();
    }
    if (syncMessage.getRead().isPresent()) {
        this.readMessages = syncMessage.getRead().get();
    }
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
public SignalServiceContent(SignalServiceSyncMessage synchronizeMessage) {
  this.message            = Optional.absent();
  this.synchronizeMessage = Optional.fromNullable(synchronizeMessage);
  this.callMessage        = Optional.absent();
}
 

import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; //导入依赖的package包/类
public Optional<SignalServiceSyncMessage> getSyncMessage() {
  return synchronizeMessage;
}