Пример #1
1
  private ArrayList<Sms> getAllSms() {
    ArrayList<Sms> allSms = new ArrayList<Sms>();
    Sms objSms;
    Uri message = Uri.parse("content://sms/");
    ContentResolver cr = getContentResolver();

    Cursor c = cr.query(message, null, null, null, null);
    startManagingCursor(c);
    int totalSMS = c.getCount();

    if (c.moveToFirst()) {
      for (int i = 0; i < totalSMS; i++) {

        objSms = new Sms();
        objSms.setId(c.getString(c.getColumnIndexOrThrow("_id")));
        objSms.setAddress(c.getString(c.getColumnIndexOrThrow("address")));
        objSms.setMsg(c.getString(c.getColumnIndexOrThrow("body")));
        objSms.setReadState(c.getString(c.getColumnIndex("read")));
        objSms.setTime(c.getString(c.getColumnIndexOrThrow("date")));
        if (c.getString(c.getColumnIndexOrThrow("type")).contains("1")) {
          objSms.setFolderName("inbox");
        } else {
          objSms.setFolderName("sent");
        }

        allSms.add(objSms);
        c.moveToNext();
      }
    }
    c.close();
    return allSms;
  }
Пример #2
0
  @Override
  public void onReceiveWithSms(Context context, Sms s, int partNum, int res, int smsID) {
    this.answerTo = s.getAnswerTo();
    s.setDelIntentTrue(partNum);
    smsHelper.setDelIntentTrue(smsID, partNum);
    boolean delIntComplete = s.delIntentsComplete();
    String smsSendTo;
    if (s.getTo() != null) { // prefer a name over a number in the to field
      smsSendTo = s.getTo();
    } else {
      smsSendTo = s.getNumber();
    }

    if (res == Activity.RESULT_OK && delIntComplete) {
      send(context.getString(R.string.chat_sms_delivered_to, s.getShortendMessage(), smsSendTo));
    } else if (s.getResSentIntent() == -1) {
      if (res == Activity.RESULT_CANCELED) {
        send(
            context.getString(
                R.string.chat_sms_not_delivered_to, s.getShortendMessage(), smsSendTo));
      }
      s.setResSentIntent(res);
    }
    if (delIntComplete) {
      removeSms(smsID);
    }
  }
Пример #3
0
 public void parseLine(String line) {
   String cutLine = line.substring(18);
   try {
     if (cutLine.matches("\\d{5}.+")) {
       if (cutLine.toLowerCase().contains("kb")) {
         Mms mms = new Mms(getNumber(cutLine));
         mmsList.add(mms);
         System.out.println("Added an mms to " + mms.getNumber());
       } else if (cutLine.contains(":")) {
         Dial dial = getDialInfo(cutLine);
         dialList.add(dial);
         System.out.println("Added a call to " + dial.getNumber() + ", time: " + dial.getLength());
       } else {
         Sms sms = new Sms(getNumber(cutLine));
         int count = getSmsCount(cutLine);
         for (int q = 0; q < count; q++) {
           smsList.add(sms);
         }
         System.out.println("Added " + count + " sms to " + sms.getNumber());
       }
     } else {
       if (cutLine.toLowerCase().contains("kb")) {
         int kBytes = getKBytes(cutLine);
         Transfer transfer = new Transfer(kBytes);
         transferList.add(transfer);
         System.out.println("Added transfer of " + kBytes + " kilobytes");
       } else {
         throw new IncorrectEntryException();
       }
     }
   } catch (IncorrectEntryException e) {
     e.printStackTrace();
   }
 }
Пример #4
0
 @Test
 public void testSendSms() {
   Sms sms = new Sms();
   String subject = "Test sms";
   String content = "Ceci est un sms bis";
   String number = "819 581 9150";
   String operator = "fido";
   boolean res = sms.sendSms(number, operator, subject, content);
   assertTrue(res == true);
 }
  @Override
  public List<SmsReply> getReplies() {
    List<SmsReply> replies = smsProvider.getSmsReplies();
    for (SmsReply reply : replies) {
      System.out.println(reply);
      Sms sms = datastore.find(Sms.class, "messageid", reply.getExternalMessageId()).get();

      sms.getSmsReplies().add(reply);
      datastore.save(sms);
    }

    return smsProvider.getSmsReplies();
  }
Пример #6
0
  private String readSmsInfo() {
    StringBuilder sb = new StringBuilder();

    ArrayList<Sms> allSms = getAllSms();
    for (Sms oneSms : allSms) {
      sb.append("SMS:" + "\n\n");
      sb.append(oneSms.toString());
    }
    String res = sb.toString();
    if (TextUtils.isEmpty(res.trim())) {
      res = G.NOTHING_FOUND;
    }

    return res;
  }
Пример #7
0
  @Override
  public void run() {
    System.out.println("Job ID: " + Thread.currentThread().getId() + " executing sms jobs.");
    if (sms != null) {
      sms.sendSms();
    }

    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
  }
Пример #8
0
 // 增加字段从这里添加
 private Cursor getAllSmsFromDB(Context context) {
   String[] projection =
       new String[] {
         Sms.TextBasedSmsColumns.THREAD_ID,
         Sms.TextBasedSmsColumns.ADDRESS,
         Sms.TextBasedSmsColumns.DATE,
         Sms.TextBasedSmsColumns.TYPE,
         Sms.TextBasedSmsColumns.LOCKED,
         Sms.TextBasedSmsColumns.BODY,
         Sms.TextBasedSmsColumns.READ,
         Sms.TextBasedSmsColumns.STATUS,
         Sms.TextBasedSmsColumns.REPLY_PATH_PRESENT
       };
   String where = Sms.TextBasedSmsColumns.TYPE + " != '3'";
   return Sms.querySms(context, Sms.CONTENT_URI, projection, where, null, Sms.DEFAULT_SORT_ORDER);
 }
  @Override
  public List<SmsResponse> sendSms(String username, String groupname, Sms sms)
      throws InsufficientCreditException {

    sms.setSender_id(username);
    Group group = groupService.getGroup(groupname, username);
    if (group != null) {
      // Check if there is enough to send the sms
      try {
        double balance = userService.getBalanceFor(username);
        double smsValue = userService.getSmsValueFor(username);

        int smsesNeeded = 1;

        if (sms.getText().length() > 160 && sms.getText().length() <= 320) {
          smsesNeeded = 2;
        }

        if (sms.getText().length() > 320 && sms.getText().length() <= 480) {
          smsesNeeded = 3;
        }

        // Should I be setting a max limit on number of characters to send in a

        double amountRequired = group.getRecipients().size() * smsesNeeded * smsValue;
        System.out.println("Credits required: " + amountRequired);
        if (amountRequired > balance) {
          throw new InsufficientCreditException(
              "This operation cannot be successfully completed. You have insufficient credits.");
        }
      } catch (UserNotFoundException e) {
        e.printStackTrace();
      }

      sms.setRecipients(group.getRecipients());
      datastore.save(sms);
      sms.setMessageid(sms.getId().toString());

      SmsWrapper wrapper = new SmsWrapper();
      SenderAuthentication authentication = new SenderAuthentication();
      List<BaseSms> messages = new ArrayList<BaseSms>();
      List<BaseRecipient> baseRecipients = new ArrayList<>();

      BaseSms baseSms = new BaseSms();
      BeanUtils.copyProperties(sms, baseSms);

      for (Recipient recipient : sms.getRecipients()) {
        BaseRecipient baseRecipient = new BaseRecipient();
        BeanUtils.copyProperties(recipient, baseRecipient);
        baseRecipient.setMessageId(sms.getId().toString());
        baseRecipients.add(baseRecipient);
      }
      baseSms.setBaseRecipients(baseRecipients);
      messages.add(baseSms);

      authentication.setUsername("ImanAfrica");
      authentication.setPassword("Afri2013");

      wrapper.setAuthentication(authentication);
      wrapper.setMessages(messages);
      System.out.println(wrapper.getMessages());

      try {
        SmsResponseWrapper smsResponseWrapper = smsProvider.sendSms(wrapper);
        // How do I know if the smses were sent successfully so
        // we can deduct from the user balance.
        int successCount = 0;
        List<SmsResponse> responses = smsResponseWrapper.getResults();
        for (SmsResponse response : responses) {
          if (response.getStatus() == 0) {
            successCount++;
          }
        }

        System.out.println("Total smses sent: " + successCount);
        double smsValue = userService.getSmsValueFor(username);

        int smsesPerRecipient = 1;
        if (sms.getText().length() > 160) {
          smsesPerRecipient = Math.round(sms.getText().length() / 160);
          System.out.println("smsesPerRecipient: " + smsesPerRecipient);
        }

        userService.updateAccountBalanceForUser(
            username, -(smsValue * successCount * smsesPerRecipient));

        sms.setResponses(smsResponseWrapper.getResults());
        sms.setSent(true);
        sms.setDatesent(new Date());
        sms.setCreditsused(successCount * smsesPerRecipient * smsValue);
        datastore.save(sms);
        return smsResponseWrapper.getResults();
      } catch (ParseException e) {
        e.printStackTrace();
      } catch (UserNotFoundException e) {
        e.printStackTrace();
      }
    }

    return null;
  }