示例#1
0
 private void normalize(final MultivaluedMap<String, String> data)
     throws IllegalArgumentException {
   final PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
   final String from = data.getFirst("From");
   if (!from.contains("@")) {
     // https://github.com/Mobicents/RestComm/issues/150 Don't complain in case of URIs in the From
     // header
     data.remove("From");
     try {
       data.putSingle(
           "From",
           phoneNumberUtil.format(phoneNumberUtil.parse(from, "US"), PhoneNumberFormat.E164));
     } catch (final NumberParseException exception) {
       throw new IllegalArgumentException(exception);
     }
   }
   final String to = data.getFirst("To");
   // Only try to normalize phone numbers.
   if (to.startsWith("client")) {
     if (to.split(":").length != 2) {
       throw new IllegalArgumentException(to + " is an invalid client identifier.");
     }
   } else if (!to.contains("@")) {
     data.remove("To");
     try {
       data.putSingle(
           "To", phoneNumberUtil.format(phoneNumberUtil.parse(to, "US"), PhoneNumberFormat.E164));
     } catch (final NumberParseException exception) {
       throw new IllegalArgumentException(exception);
     }
   }
   URI.create(data.getFirst("Url"));
 }
 /**
  * Converts the phone number to E164 standard
  *
  * @param phone the phone number to convert
  * @return same number in E164 format
  */
 private String formatToE164(String phone) {
   PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
   Phonenumber.PhoneNumber numberProto = null;
   try {
     numberProto = phoneUtil.parse(phone, getUserCountry());
   } catch (NumberParseException e) {
     System.err.println("NumberParseException was thrown: " + e.toString());
   }
   String formatted = null;
   if (numberProto != null) {
     formatted = phoneUtil.format(numberProto, PhoneNumberUtil.PhoneNumberFormat.E164);
   }
   return (formatted != null ? formatted : phone.replaceAll("[^0-9+]+", ""));
 }
示例#3
0
  public static String isMobile(String mobile) {
    String phone = null;
    try {
      PhoneNumber pn = phoneUtil.parse(mobile, "CN");

      if (phoneUtil.isValidNumber(pn)) {
        phone = phoneUtil.format(pn, PhoneNumberFormat.E164).replace("+86", "");
        LOGGER.debug("phone util parse into cn : " + phone);
      }
    } catch (Exception e) {
      LOGGER.error("check mobile error! ", e);
    }

    return phone;
  }
  private boolean checkInput() {
    mPhoneNumber = null;
    String phoneStr = null;

    // check name first
    mName = mNameText.getText().toString().trim();
    if (mName.length() == 0) {
      error(R.string.title_no_name, R.string.msg_no_name);
      return false;
    }

    PhoneNumberUtil util = PhoneNumberUtil.getInstance();
    CountryCode cc = (CountryCode) mCountryCode.getSelectedItem();
    if (!BuildConfig.DEBUG) {
      PhoneNumber phone;
      try {
        phone = util.parse(mPhone.getText().toString(), cc.regionCode);
        if (!util.isValidNumberForRegion(phone, cc.regionCode)) {
          throw new NumberParseException(
              ErrorType.INVALID_COUNTRY_CODE, "invalid number for region " + cc.regionCode);
        }
      } catch (NumberParseException e1) {
        error(R.string.title_invalid_number, R.string.msg_invalid_number);
        return false;
      }

      // check phone number format
      if (phone != null) {
        phoneStr = util.format(phone, PhoneNumberFormat.E164);
        if (!PhoneNumberUtils.isWellFormedSmsAddress(phoneStr)) {
          Log.i(TAG, "not a well formed SMS address");
        }
      }
    } else {
      phoneStr = String.format(Locale.US, "+%d%s", cc.countryCode, mPhone.getText().toString());
    }

    // phone is null - invalid number
    if (phoneStr == null) {
      Toast.makeText(this, R.string.warn_invalid_number, Toast.LENGTH_SHORT).show();
      return false;
    }

    Log.v(TAG, "Using phone number to register: " + phoneStr);
    mPhoneNumber = phoneStr;
    return true;
  }
示例#5
0
  public static String isPhoneNumber(String mobile) {
    String phone = null;
    try {
      LOGGER.debug("test phone number : " + mobile);
      PhoneNumber pn = phoneUtil.parse(mobile, "CN");

      if (phoneUtil.isValidNumber(pn)) {
        phone = phoneUtil.format(pn, PhoneNumberFormat.E164).replace("+86", "");
        LOGGER.debug("phone util parse into cn : " + phone);
      }
    } catch (NumberParseException e) {
      LOGGER.error("parse valid number! ", e);
    }

    if (phone == null) phone = mobile.replace("+", "");

    return phone;
  }
示例#6
0
  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    log.log(Level.INFO, "RegisterServlet.doPOST() : START RegisterServlet.doPOST()");

    resp.setContentType("text/plain");

    GeatteRegisterRequestInfo reqInfo =
        GeatteRegisterRequestInfo.processRequest(req, resp, getServletContext());
    if (reqInfo == null) {
      log.severe("RegisterServlet.doPOST() : can not load RequestInfo!!");
      return;
    }

    // Because the deviceRegistrationId isn't static, we use a static
    // identifier for the device. (Can be null in older clients)
    String deviceId = reqInfo.getParameter(Config.DEVICE_ID_PARAM);

    if (deviceId == null) {
      resp.setStatus(400);
      resp.getWriter().println(ERROR_STATUS + "(Must specify " + Config.DEVICE_ID_PARAM + ")");
      log.severe(
          "RegisterServlet.doPOST() : Missing device id, " + Config.DEVICE_ID_PARAM + " is null");
      return;
    } else {
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : user sent a " + Config.DEVICE_ID_PARAM + " = " + deviceId);
    }

    String phoneNumber = reqInfo.getParameter(Config.DEV_PHONE_NUMBER_PARAM);

    if (phoneNumber == null) {
      resp.setStatus(400);
      resp.getWriter()
          .println(ERROR_STATUS + "(Must specify " + Config.DEV_PHONE_NUMBER_PARAM + ")");
      log.severe(
          "RegisterServlet.doPOST() : Missing phone number, "
              + Config.DEV_PHONE_NUMBER_PARAM
              + " is null");
      return;
    } else {
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : user sent a "
              + Config.DEV_PHONE_NUMBER_PARAM
              + " = "
              + phoneNumber);
    }

    String phoneCountryIso = reqInfo.getParameter(Config.DEV_PHONE_COUNTRY_ISO_PARAM);

    if (phoneCountryIso == null) {
      // default is us
      phoneCountryIso = "us";
      log.severe(
          "RegisterServlet.doPOST() : Missing phone country iso, "
              + Config.DEV_PHONE_COUNTRY_ISO_PARAM
              + " is null");
      return;
    } else {
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : user sent a "
              + Config.DEV_PHONE_COUNTRY_ISO_PARAM
              + " = "
              + phoneCountryIso);
    }

    PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
    PhoneNumber numberProto = null;
    try {
      numberProto = phoneUtil.parse(phoneNumber, phoneCountryIso);
    } catch (NumberParseException npe) {
      log.log(Level.WARNING, "RegisterServlet.doPOST(): NumberParseException was thrown: ", npe);
    }

    if (numberProto != null && phoneUtil.isValidNumber(numberProto)) {
      phoneNumber = phoneUtil.format(numberProto, PhoneNumberFormat.E164);
    } else {
      log.log(
          Level.WARNING,
          "RegisterServlet.doPOST() : Invalid phone number so use passed-in number, "
              + Config.DEV_PHONE_NUMBER_PARAM
              + " = "
              + phoneNumber
              + ", countryIso = "
              + phoneCountryIso);
    }

    if (reqInfo.deviceRegistrationID == null) {
      resp.setStatus(400);
      resp.getWriter().println(ERROR_STATUS + "(Must specify " + Config.DEV_REG_ID_PARAM + ")");
      log.severe(
          "RegisterServlet.doPOST() : Missing registration id, reqInfo.deviceRegistrationID is null");
      return;
    } else {
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : reqInfo.deviceRegistrationID = "
              + reqInfo.deviceRegistrationID);
    }

    String deviceName = reqInfo.getParameter(Config.DEVICE_NAME_PARAM);

    if (deviceName == null) {
      deviceName = "Phone";
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : use default "
              + Config.DEVICE_NAME_PARAM
              + " = "
              + deviceName);
    } else {
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : user sent a "
              + Config.DEVICE_NAME_PARAM
              + " = "
              + deviceName);
    }
    // TODO: generate the device name by adding a number suffix for multiple
    // devices of same type. Change android app to send model/type.

    String deviceType = reqInfo.getParameter(Config.DEVICE_TYPE_PARAM);

    if (deviceType == null) {
      deviceType = DeviceInfo.TYPE_AC2DM;
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : use default "
              + Config.DEVICE_TYPE_PARAM
              + " = "
              + deviceType);
    } else {
      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : user sent a "
              + Config.DEVICE_TYPE_PARAM
              + " = "
              + deviceType);
    }

    // Context-shared PMF.
    PersistenceManager pm = DBHelper.getPMF(getServletContext()).getPersistenceManager();

    try {
      List<DeviceInfo> registrations = reqInfo.devices;

      if (registrations.size() > MAX_DEVICES) {
        log.log(
            Level.INFO,
            "RegisterServlet.doPOST() : user has too many devices, registrations.size = "
                + registrations.size());
        // we could return an error - but user can't handle it yet.
        // we can't let it grow out of bounds.
        // TODO: we should also define a 'ping' message and
        // expire/remove
        // unused registrations
        DeviceInfo oldest = registrations.get(0);
        if (oldest.getRegistrationTimestamp() == null) {
          log.log(
              Level.INFO,
              "RegisterServlet.doPOST() : user has too many devices, trying to remove old one = "
                  + oldest.getDeviceRegistrationID());
          pm.deletePersistent(oldest);
        } else {
          long oldestTime = oldest.getRegistrationTimestamp().getTime();
          for (int i = 1; i < registrations.size(); i++) {
            if (registrations.get(i).getRegistrationTimestamp().getTime() < oldestTime) {
              oldest = registrations.get(i);
              oldestTime = oldest.getRegistrationTimestamp().getTime();
            }
          }
          log.log(
              Level.INFO,
              "RegisterServlet.doPOST() : user has too many devices, trying to remove old one = "
                  + oldest.getDeviceRegistrationID());
          pm.deletePersistent(oldest);
        }
      }

      // Get device if it already exists, else create
      // String suffix = (deviceId != null ? "#" +
      // Long.toHexString(Math.abs(deviceId.hashCode())) : "");
      // Key key = KeyFactory.createKey(DeviceInfo.class.getSimpleName(),
      // reqInfo.userName + suffix);
      Key key = KeyFactory.createKey(DeviceInfo.class.getSimpleName(), deviceId);

      DeviceInfo device = null;
      try {
        device = pm.getObjectById(DeviceInfo.class, key);
      } catch (JDOObjectNotFoundException e) {
      }
      if (device == null) {
        log.log(
            Level.INFO,
            "RegisterServlet.doPOST() : can not find a DeviceInfo by key = "
                + key
                + ", create a new one");

        // clean devices for same phone number, only one device allowed for one phone
        try {
          List<DeviceInfo> devicesForSameNumber =
              DeviceInfo.getDeviceInfoForNumber(pm, phoneNumber, phoneCountryIso);
          for (DeviceInfo deviceSameNumber : devicesForSameNumber) {
            pm.deletePersistent(deviceSameNumber);
          }
        } catch (JDOObjectNotFoundException e) {
        }

        device = new DeviceInfo(key, reqInfo.deviceRegistrationID);
        device.setType(deviceType);
      } else {
        log.log(
            Level.INFO,
            "RegisterServlet.doPOST() : find a DeviceInfo by key = "
                + key
                + ", update deviceRegistrationID to "
                + reqInfo.deviceRegistrationID);

        // update registration id
        device.setDeviceRegistrationID(reqInfo.deviceRegistrationID);
        device.setRegistrationTimestamp(new Date());
      }

      device.setPhoneNumber(phoneNumber); // update phoneNumber
      device.setCountryCode(phoneCountryIso); // update country code
      device.setUserEmail(reqInfo.getUserEmail()); // update user email
      device.setDeviceName(deviceName); // update display name
      // TODO: only need to write if something changed, for chrome nothing
      // changes, we just create a new channel
      pm.makePersistent(device);

      log.log(
          Level.INFO,
          "RegisterServlet.doPOST() : Registered device userEmail = "
              + reqInfo.getUserEmail()
              + ", deviceType = "
              + deviceType
              + ", deviceRegistrationID = "
              + reqInfo.deviceRegistrationID
              + ", key = "
              + key);

      // if type is IOS, register to Urban
      if (device.getType().equalsIgnoreCase(DeviceInfo.TYPE_IOS)) {
        doRegisterIOSToUrban(device);
        resp.getWriter().println(OK_STATUS);
      } else if (device.getType().equalsIgnoreCase(DeviceInfo.TYPE_ANDROID)
          || device.getType().equalsIgnoreCase(DeviceInfo.TYPE_AC2DM)) {
        resp.getWriter().println(OK_STATUS);
      } else {
        resp.getWriter().println(ERROR_STATUS + "(Wrong " + Config.DEVICE_TYPE_PARAM + ")");
      }

      log.log(Level.INFO, "RegisterServlet.doPOST() : END RegisterServlet.doPOST()");
    } catch (Exception e) {
      resp.setStatus(500);
      resp.getWriter().println(ERROR_STATUS + " (Error registering device)");
      log.log(Level.WARNING, "RegisterServlet.doPOST() : Error registering device.", e);
    } finally {
      pm.close();
    }
  }