/*
* Copyright (C) 2007-2008 Esmertec AG.
* Copyright (C) 2007-2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.im.imps;
import android.os.Parcel;
import com.android.im.engine.Address;
import com.android.im.engine.ImEntity;
/**
* The abstract representation of an IMPS address.
*/
public abstract class ImpsAddress extends Address {
private static final char[] SPECIALS = {'/', '@', '+'};
protected String mUser;
protected String mResource;
protected String mDomain;
private String mFullAddress;
protected ImpsAddress() {
}
protected ImpsAddress(String user, String resource, String domain) {
// build the full address and unify the fields to lower case since imps
// address is case insensitive.
StringBuilder buf = new StringBuilder(ImpsConstants.ADDRESS_PREFIX);
if(user != null) {
buf.append(user.toLowerCase());
}
if(resource != null) {
buf.append('/').append(resource.toLowerCase());
}
if(domain != null) {
buf.append('@').append(domain.toLowerCase());
}
mFullAddress = buf.toString();
mUser = user;
mResource = resource;
mDomain = domain;
verifyAddress();
}
protected ImpsAddress(String full){
this(full, true);
}
protected ImpsAddress(String full, boolean verify) {
if (full == null || full.length() == 0) {
throw new IllegalArgumentException();
}
//TODO: escape reserved characters.
if(!full.startsWith(ImpsConstants.ADDRESS_PREFIX)) {
full = ImpsConstants.ADDRESS_PREFIX + full;
}
parse(full);
mFullAddress = full;
if (verify) {
verifyAddress();
}
}
private void parse(String full) {
mUser = parseUser(full);
mResource = parseResource(full);
mDomain = parseDomain(full);
}
private void verifyAddress() throws IllegalArgumentException {
ImpsLog.log("verifyAddress:" + mUser + ", " + mResource + ", " + mDomain);
if(mUser == null && mResource == null) {
throw new IllegalArgumentException();
}
if(mUser != null) {
if(mUser.length() == 0) {
throw new IllegalArgumentException("Invalid user");
}
if(mUser.charAt(0) == '+') {//mobile number
for(int i = 1; i < mUser.length(); i++) {
if(!Character.isDigit(mUser.charAt(i))) {
throw new IllegalArgumentException("Invalid user");
}
}
} else if(!isAlphaSequence(mUser)) {
throw new IllegalArgumentException("Invalid user");
}
}
if(mResource != null && !isAlphaSequence(mResource)) {
throw new IllegalArgumentException("Invalid resource");
}
if(mDomain != null && !isAlphaSequence(mDomain)) {
throw new IllegalArgumentException("Invalid domain");
}
}
/**
* Gets the User-part of the address which refers to the identification of
* the IMPS user.
*
* @return the User-part of the address.
*/
public String getUser() {
return mUser;
}
/**
* Gets the Resource-part of the address which identifies the referred
* public or private resource.
*
* @return the Resource-part of the address.
*/
public String getResource() {
return mResource;
}
/**
* Gets the Domain-part of the address which identifies the IMPS server
* domain.
*
* @return the Domain-part of the address.
*/
public String getDomain() {
return mDomain;
}
/**
* Gets the full string representation of the address.
*/
@Override
public String getFullName() {
return mFullAddress;
}
@Override
public void writeToParcel(Parcel dest) {
dest.writeString(mFullAddress);
}
@Override
public void readFromParcel(Parcel source) {
mFullAddress = source.readString();
parse(mFullAddress);
}
@Override
public boolean equals(Object other) {
return other instanceof ImpsAddress
&& mFullAddress.equalsIgnoreCase(((ImpsAddress)other).mFullAddress);
}
@Override
public int hashCode() {
return mFullAddress.toLowerCase().hashCode();
}
/**
* Formats the address to a PrimitiveElement which can be used as the
* content of Sender or Recipient.
*
* @return a PrimitiveElement.
*/
public abstract PrimitiveElement toPrimitiveElement();
/**
* Gets the entity this address object refers to.
*
* @param connection
* @return the entity this address refers to or <code>null</code> if the
* entity not found.
*/
abstract ImEntity getEntity(ImpsConnection connection);
/**
* Constructs an ImpsAddress from the Sender or Recipient element in a
* primitive.
*
* @param elem the Sender of Recipient element.
* @return the ImpsAddress object or <code>null</code> if it's not a valid
* element.
*/
public static ImpsAddress fromPrimitiveElement(PrimitiveElement elem) {
String type = elem.getTagName();
if(ImpsTags.User.equals(type)) {
return new ImpsUserAddress(elem.getChildContents(ImpsTags.UserID), false);
} else if(ImpsTags.Group.equals(type)) {
PrimitiveElement child = elem.getFirstChild();
if(child == null) {
throw new IllegalArgumentException();
}
if(ImpsTags.GroupID.equals(child.getTagName())){
return new ImpsGroupAddress(child.getContents());
} else {
String screeName = child.getChildContents(ImpsTags.SName);
String groupId = child.getChildContents(ImpsTags.GroupID);
return new ImpsGroupAddress(groupId, screeName);
}
} else if(ImpsTags.ContactList.equals(type)) {
return new ImpsContactListAddress(elem.getContents(), false);
} else {
throw new IllegalArgumentException();
}
}
private String parseUser(String full) {
int index = full.indexOf('/');
if(index == 3) {
return null;
}
if (index == -1) {
index = full.lastIndexOf('@');
}
if (index == -1) {
index = full.length();
}
return full.substring(3, index);
}
private String parseResource(String full) {
int beginIndex = full.indexOf('/');
if (beginIndex == -1) {
return null;
}
int endIndex = full.lastIndexOf('@');
if (endIndex == -1 || endIndex < beginIndex) {
endIndex = full.length();
}
return full.substring(beginIndex + 1, endIndex);
}
private String parseDomain(String full) {
int beginIndex = full.lastIndexOf('@');
return beginIndex == -1 ? null : full.substring(beginIndex + 1);
}
private boolean isAlphaSequence(String str) {
for(int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if(ch < 32 || ch > 126 || isSpecial(ch)) {
return false;
}
}
return true;
}
private boolean isSpecial(char ch) {
for (char element : SPECIALS) {
if(ch == element) {
return true;
}
}
return false;
}
}
|
