Java InsecureFallbackApprovalException类代码示例

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private byte[] getPduBytes(SendReq message)
    throws IOException, UndeliverableMessageException, InsecureFallbackApprovalException
{
  String number = TelephonyUtil.getManager(context).getLine1Number();

  message.setBody(SmilUtil.getSmilBody(message.getBody()));

  if (!TextUtils.isEmpty(number)) {
    message.setFrom(new EncodedStringValue(number));
  }

  byte[] pduBytes = new PduComposer(context, message).make();

  if (pduBytes == null) {
    throw new UndeliverableMessageException("PDU composition failed, null payload");
  }

  return pduBytes;
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private void fallbackOrAskApproval(MasterSecret masterSecret, SmsMessageRecord smsMessage, String destination)
    throws SecureFallbackApprovalException, InsecureFallbackApprovalException
{
  Recipient    recipient                     = smsMessage.getIndividualRecipient();
  boolean      isSmsFallbackApprovalRequired = isSmsFallbackApprovalRequired(destination, false);
  AxolotlStore axolotlStore                  = new TextSecureAxolotlStore(context, masterSecret);

  if (!isSmsFallbackApprovalRequired) {
    Log.w(TAG, "Falling back to SMS");
    DatabaseFactory.getSmsDatabase(context).markAsForcedSms(smsMessage.getId());
    ApplicationContext.getInstance(context).getJobManager().add(new SmsSendJob(context, messageId, destination));
  } else if (!axolotlStore.containsSession(recipient.getRecipientId(), PushAddress.DEFAULT_DEVICE_ID)) {
    Log.w(TAG, "Marking message as pending insecure fallback.");
    throw new InsecureFallbackApprovalException("Pending user approval for fallback to insecure SMS");
  } else {
    Log.w(TAG, "Marking message as pending secure fallback.");
    throw new SecureFallbackApprovalException("Pending user approval for fallback to secure SMS");
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private void fallbackOrAskApproval(MasterSecret masterSecret, SendReq mediaMessage, String destination)
    throws SecureFallbackApprovalException, InsecureFallbackApprovalException
{
  try {
    Recipient    recipient                     = RecipientFactory.getRecipientsFromString(context, destination, false).getPrimaryRecipient();
    boolean      isSmsFallbackApprovalRequired = isSmsFallbackApprovalRequired(destination, true);
    AxolotlStore axolotlStore                  = new TextSecureAxolotlStore(context, masterSecret);

    if (!isSmsFallbackApprovalRequired) {
      Log.w(TAG, "Falling back to MMS");
      DatabaseFactory.getMmsDatabase(context).markAsForcedSms(mediaMessage.getDatabaseMessageId());
      ApplicationContext.getInstance(context).getJobManager().add(new MmsSendJob(context, messageId));
    } else if (!axolotlStore.containsSession(recipient.getRecipientId(), PushAddress.DEFAULT_DEVICE_ID)) {
      Log.w(TAG, "Marking message as pending insecure SMS fallback");
      throw new InsecureFallbackApprovalException("Pending user approval for fallback to insecure SMS");
    } else {
      Log.w(TAG, "Marking message as pending secure SMS fallback");
      throw new SecureFallbackApprovalException("Pending user approval for fallback secure to SMS");
    }
  } catch (RecipientFormattingException rfe) {
    Log.w(TAG, rfe);
    DatabaseFactory.getMmsDatabase(context).markAsSentFailed(messageId);
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
@Override
public void onRun(MasterSecret masterSecret) throws NoSuchMessageException {
  EncryptingSmsDatabase database = DatabaseFactory.getEncryptingSmsDatabase(context);
  SmsMessageRecord      record   = database.getMessage(masterSecret, messageId);

  try {
    Log.w(TAG, "Sending message: " + messageId);

    deliver(masterSecret, record);
  } catch (UndeliverableMessageException ude) {
    Log.w(TAG, ude);
    DatabaseFactory.getSmsDatabase(context).markAsSentFailed(record.getId());
    MessageNotifier.notifyMessageDeliveryFailed(context, record.getRecipients(), record.getThreadId());
  } catch (InsecureFallbackApprovalException ifae) {
    Log.w(TAG, ifae);
    DatabaseFactory.getSmsDatabase(context).markAsPendingInsecureSmsFallback(record.getId());
    MessageNotifier.notifyMessageDeliveryFailed(context, record.getRecipients(), record.getThreadId());
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
@Override
public void onPushSend(MasterSecret masterSecret)
    throws RetryLaterException, MmsException, NoSuchMessageException,
           UndeliverableMessageException
{
  ExpiringMessageManager expirationManager = ApplicationContext.getInstance(context).getExpiringMessageManager();
  MmsDatabase            database          = DatabaseFactory.getMmsDatabase(context);
  OutgoingMediaMessage   message           = database.getOutgoingMessage(masterSecret, messageId);

  try {
    deliver(masterSecret, message);
    database.markAsSent(messageId, true);
    markAttachmentsUploaded(messageId, message.getAttachments());

    if (message.getExpiresIn() > 0 && !message.isExpirationUpdate()) {
      database.markExpireStarted(messageId);
      expirationManager.scheduleDeletion(messageId, true, message.getExpiresIn());
    }

  } catch (InsecureFallbackApprovalException ifae) {
    Log.w(TAG, ifae);
    database.markAsPendingInsecureSmsFallback(messageId);
    notifyMediaMessageDeliveryFailed(context, messageId);
    ApplicationContext.getInstance(context).getJobManager().add(new DirectoryRefreshJob(context));
  } catch (UntrustedIdentityException uie) {
    Log.w(TAG, uie);
    Recipients recipients  = RecipientFactory.getRecipientsFromString(context, uie.getE164Number(), false);
    long       recipientId = recipients.getPrimaryRecipient().getRecipientId();

    database.addMismatchedIdentity(messageId, recipientId, uie.getIdentityKey());
    database.markAsSentFailed(messageId);
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private byte[] getPduBytes(SendReq message)
    throws IOException, UndeliverableMessageException, InsecureFallbackApprovalException
{
  byte[] pduBytes = new PduComposer(context, message).make();

  if (pduBytes == null) {
    throw new UndeliverableMessageException("PDU composition failed, null payload");
  }

  return pduBytes;
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
@Override
public void onRun(MasterSecret masterSecret)
    throws RetryLaterException, MmsException, NoSuchMessageException
{
  MmsDatabase database = DatabaseFactory.getMmsDatabase(context);
  SendReq     message  = database.getOutgoingMessage(masterSecret, messageId);

  try {
    if (deliver(masterSecret, message)) {
      database.markAsPush(messageId);
      database.markAsSecure(messageId);
      database.markAsSent(messageId, "push".getBytes(), 0);
    }
  } catch (InsecureFallbackApprovalException ifae) {
    Log.w(TAG, ifae);
    database.markAsPendingInsecureSmsFallback(messageId);
    notifyMediaMessageDeliveryFailed(context, messageId);
  } catch (SecureFallbackApprovalException sfae) {
    Log.w(TAG, sfae);
    database.markAsPendingSecureSmsFallback(messageId);
    notifyMediaMessageDeliveryFailed(context, messageId);
  } catch (UntrustedIdentityException uie) {
    IncomingIdentityUpdateMessage identityUpdateMessage = IncomingIdentityUpdateMessage.createFor(message.getTo()[0].getString(), uie.getIdentityKey());
    DatabaseFactory.getEncryptingSmsDatabase(context).insertMessageInbox(masterSecret, identityUpdateMessage);
    database.markAsSentFailed(messageId);
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private void deliver(MasterSecret masterSecret, SmsMessageRecord record)
    throws UndeliverableMessageException, InsecureFallbackApprovalException
{
  if (!NumberUtil.isValidSmsOrEmail(record.getIndividualRecipient().getNumber())) {
    throw new UndeliverableMessageException("Not a valid SMS destination! " + record.getIndividualRecipient().getNumber());
  }

  if (record.isSecure() || record.isKeyExchange() || record.isEndSession()) {
    deliverSecureMessage(masterSecret, record);
  } else {
    deliverPlaintextMessage(record);
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private void deliverSecureMessage(MasterSecret masterSecret, SmsMessageRecord message)
    throws UndeliverableMessageException, InsecureFallbackApprovalException
{
  MultipartSmsMessageHandler multipartMessageHandler = new MultipartSmsMessageHandler();
  OutgoingTextMessage transportMessage               = OutgoingTextMessage.from(message);

  if (message.isSecure() || message.isEndSession()) {
    transportMessage = getAsymmetricEncrypt(masterSecret, transportMessage);
  }

  ArrayList<String> messages                = multipartMessageHandler.divideMessage(transportMessage);
  ArrayList<PendingIntent> sentIntents      = constructSentIntents(message.getId(), message.getType(), messages, message.isSecure());
  ArrayList<PendingIntent> deliveredIntents = constructDeliveredIntents(message.getId(), message.getType(), messages);

  Log.w("SmsTransport", "Secure divide into message parts: " + messages.size());

  for (int i=0;i<messages.size();i++) {
    // NOTE 11/04/14 -- There's apparently a bug where for some unknown recipients
    // and messages, this will throw an NPE.  We have no idea why, so we're just
    // catching it and marking the message as a failure.  That way at least it
    // doesn't repeatedly crash every time you start the app.
    try {
      SmsManager.getDefault().sendTextMessage(message.getIndividualRecipient().getNumber(), null, messages.get(i),
                                              sentIntents.get(i),
                                              deliveredIntents == null ? null : deliveredIntents.get(i));
    } catch (NullPointerException npe) {
      Log.w(TAG, npe);
      Log.w(TAG, "Recipient: " + message.getIndividualRecipient().getNumber());
      Log.w(TAG, "Message Total Parts/Current: " + messages.size() + "/" + i);
      Log.w(TAG, "Message Part Length: " + messages.get(i).getBytes().length);
      throw new UndeliverableMessageException(npe);
    } catch (IllegalArgumentException iae) {
      Log.w(TAG, iae);
      throw new UndeliverableMessageException(iae);
    }
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private OutgoingTextMessage getAsymmetricEncrypt(MasterSecret masterSecret,
                                                 OutgoingTextMessage message)
    throws InsecureFallbackApprovalException
{
  try {
    return new SmsCipher(new TextSecureAxolotlStore(context, masterSecret)).encrypt(message);
  } catch (NoSessionException e) {
    throw new InsecureFallbackApprovalException(e);
  }
}
 

import org.thoughtcrime.securesms.transport.InsecureFallbackApprovalException; //导入依赖的package包/类
private MmsSendResult sendMms(MasterSecret masterSecret, MmsRadio radio, SendReq message,
                              boolean usingMmsRadio, boolean useProxy)
    throws IOException, UndeliverableMessageException, InsecureFallbackApprovalException
{
  String  number         = ((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)).getLine1Number();
  boolean upgradedSecure = false;

  if (MmsDatabase.Types.isSecureType(message.getDatabaseMessageBox())) {
    message        = getEncryptedMessage(masterSecret, message);
    upgradedSecure = true;
  }

  if (number != null && number.trim().length() != 0) {
    message.setFrom(new EncodedStringValue(number));
  }

  try {
    OutgoingMmsConnection connection = new OutgoingMmsConnection(context, radio.getApnInformation(), new PduComposer(context, message).make());
    SendConf conf = connection.send(usingMmsRadio, useProxy);

    for (int i=0;i<message.getBody().getPartsNum();i++) {
      Log.w(TAG, "Sent MMS part of content-type: " + new String(message.getBody().getPart(i).getContentType()));
    }

    if (conf == null) {
      throw new UndeliverableMessageException("No M-Send.conf received in response to send.");
    } else if (conf.getResponseStatus() != PduHeaders.RESPONSE_STATUS_OK) {
      throw new UndeliverableMessageException("Got bad response: " + conf.getResponseStatus());
    } else if (isInconsistentResponse(message, conf)) {
      throw new UndeliverableMessageException("Mismatched response!");
    } else {
      return new MmsSendResult(conf.getMessageId(), conf.getResponseStatus(), upgradedSecure, false);
    }
  } catch (ApnUnavailableException aue) {
    throw new IOException("no APN was retrievable");
  }
}