1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/*
* SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package net.java.sip.communicator.service.protocol;
import java.util.*;
/**
* The AccountID is an account identifier that, uniquely represents a specific
* user account over a specific protocol. The class needs to be extended by
* every protocol implementation because of its protected
* constructor. The reason why this constructor is protected is mostly avoiding
* confusion and letting people (using the protocol provider service) believe
* that they are the ones who are supposed to instantiate the accountid class.
* <p>
* Every instance of the <tt>ProtocolProviderService</tt>, created through the
* ProtocolProviderFactory is assigned an AccountID instance, that uniquely
* represents it and whose string representation (obtainted through the
* getAccountUID() method) can be used for identification of persistently stored
* account details.
* <p>
* Account id's are guaranteed to be different for different accounts and in the
* same time are bound to be equal for multiple installations of the same
* account.
*
* @author Emil Ivov
*/
public abstract class AccountID
{
/**
* Contains all implementation specific properties that define the account.
* The exact names of the keys are protocol (and sometimes implementation)
* specific.
* Currently, only String property keys and values will get properly stored.
* If you need something else, please consider converting it through custom
* accessors (get/set) in your implementation.
*/
protected Map accountProperties = null;
/**
* A String uniquely identifying the user for this particular account.
*/
protected String userID = null;
/**
* A String uniquely identifying this account, that can also be used for
* storing and unambiguously retrieving details concerning it.
*/
protected String accountUID = null;
/**
* The name of the service that defines the context for this account.
*/
protected String serviceName = null;
/**
* Creates an account id for the specified provider userid and
* accountProperties.
* @param userID a String that uniquely identifies the user.
* @param accountProperties a Map containing any other protocol and
* implementation specific account initialization properties
* @param protocolName the name of the protocol implemented by the provider
* that this id is meant for.
* @param serviceName the name of the service (e.g. iptel.org, jabber.org,
* icq.com) that this account is registered with.
*/
protected AccountID( String userID,
Map accountProperties,
String protocolName,
String serviceName)
{
super();
this.userID = userID;
this.accountProperties = new Hashtable(accountProperties);
this.serviceName = serviceName;
//create a unique identifier string
this.accountUID = protocolName + ":" + userID + "@" + serviceName;
}
/**
* Returns the user id associated with this account.
*
* @return A String identyfying the user inside this particular service.
*/
public String getUserID()
{
return userID;
}
/**
* Returns a String uniquely idnetifying this account, guaranteed to remain
* the same accross multiple installations of the same account and to always
* be unique for differing accounts.
* @return String
*/
public String getAccountUniqueID()
{
return accountUID;
}
/**
* Returns a Map containing protocol and implementation account
* initialization propeties.
* @return a Map containing protocol and implementation account
* initialization propeties.
*/
public Map getAccountProperties()
{
return new Hashtable(accountProperties);
}
/**
* Returns a hash code value for the object. This method is
* supported for the benefit of hashtables such as those provided by
* <tt>java.util.Hashtable</tt>.
* <p>
* @return a hash code value for this object.
* @see java.lang.Object#equals(java.lang.Object)
* @see java.util.Hashtable
*/
public int hashCode()
{
return (accountUID == null)? 0 : accountUID.hashCode();
}
/**
* Indicates whether some other object is "equal to" this account id.
* <p>
* @param obj the reference object with which to compare.
* @return <tt>true</tt> if this object is the same as the obj
* argument; <tt>false</tt> otherwise.
* @see #hashCode()
* @see java.util.Hashtable
*/
public boolean equals(Object obj)
{
if (this == obj)
return true;
if( obj == null
|| ! (getClass().isInstance(obj))
|| ! (userID.equals(((AccountID)obj).userID)))
return false;
return true;
}
/**
* Returns a string representation of this account id (same as calling
* getAccountUniqueID()).
*
* @return a string representation of this account id.
*/
public String toString()
{
return getAccountUniqueID();
}
/**
* Returns the name of the service that defines the context for this
* account. Often this name would be an sqdn or even an ipaddress but this
* would not always be the case (e.g. p2p providers may return a name that
* does not directly correspond to an IP address or host name).
* <p>
* @return the name of the service that defines the context for this
* account.
*/
public String getService()
{
return this.serviceName;
}
/**
* Returns a string that could be directly used (or easily converted to) an
* address that other users of the procotol can use to communicate with us.
* By default this string is set to userid@servicename. Protocol
* implementors should override it if they'd need it to respect a different
* syntax.
*
* @return a String in the form of userid@service that other protocol users
* should be able to parse into a meaningful address and use it to
* communicate with us.
*/
public String getAccountAddress()
{
if (getUserID().indexOf('@') > 0)
return getUserID();
else
return getUserID() + "@" + getService();
}
/**
* Set the account properties.
*
* @param accountProperties the properties of the account
*/
public void setAccountProperties(Map accountProperties)
{
this.accountProperties = accountProperties;
}
}
|
