2021SC@SDUSC
上一篇文章结束了db模块下util目录的分析，又对entity的user目录进行了分析。进一步发现，其实在entity目录下的大部分子目录都是在通过实体来定义数据库的表，java文件的结构都是相同的，因此我们不需要特别地进行重新分析，只需弄清楚其含义即可。对于这样的java文件，我们直接略过。而对于起到其他作用的java文件，则停下来分析一下。
目录
entity/basic目录
basic目录的结构如下：
其中ChatMessage.java、Configuration.java和MailMessage.java都是定义数据库表的文件，而Client.java和IClient.java则有些不同，因此来分析一下这两个文件。
IClient.java
IClient.java实现了IClient接口，Client.java中实现了该接口。看接口引入的内容：
只引入了两个类，分别是之前分析过的IDataProviderEntity和room下的Room。前面提到过，IDataProviderEntity是一个可序列化的接口，其定义如下：
而Room类显然是一个房间，不多深究。
继续看源码：
实现了IDataProviderEntity接口后，IClient也就带有了可序列化的特点。在接口内，定义了枚举类型，还有下面的一系列get和set方法，都是之前分析过许多次的思路，所以都可以略过了。
附上IClient.java的源码：
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.openmeetings.db.entity.basic;
import org.apache.openmeetings.db.entity.IDataProviderEntity;
import org.apache.openmeetings.db.entity.room.Room;
/**
* Temporary interface, will be removed after 2 types of cliens will be merged
* {@link org.apache.openmeetings.db.entity.room.StreamClient}
* {@link org.apache.openmeetings.db.entity.basic.Client}
* @author solomax
*
*/
public interface IClient extends IDataProviderEntity {
enum Type {
video
, room // room flash client
, sip
, mobile
, sharing
}
String getUid();
String getSid();
Long getUserId();
String getLogin();
String getFirstname();
String getLastname();
String getRemoteAddress();
Long getRoomId();
Room.Type getRoomType();
int getWidth();
int getHeight();
void setRecordingStarted(boolean recordingStarted);
Long getRecordingId();
void setRecordingId(Long recordingId);
String getServerId();
}
Client.java
Client,java定义了Client类，也就是客户类。同样，首先看其引入的内容：
其中引入的java.util下面的类和最后两个关于json的类都已经分析过。
中间的部分，首先引入了org.apache.mina.util.ConcurrentHashSet。ConcurrentHashSet类的字面意思是并发的HashSet，由于网络的相关资料太少，因此只能认为它是一个线程安全的并发集合。紧接着，引入了db模块的dao/user目录下的UserDao类，由于还没有分析到它，就留个坑，认为它是用户的数据访问对象。再下面，是entity目录下的类、manager目录下的IStreamClientManager类、util目录下的RoomHelper类。最后面的两个分别是与网络协议相关的IKey和字符串处理相关的Strings。
然后看类的定义：
首先定义了private static final的long类型数据serialVersionUID，其值为1L，用来标识序列化的id。然后，定义了枚举类型Activity，包含了若干字段。接着又定义了sessionId、pageId等一系列字段。再后面，定义了元素为Room.Right枚举类型的集合rights，初始化为一个ConcurrentHashSet类，用来存储客户的right。下面是同样的两个集合activities和streams， 类型分别是Activity和String。还有一个Date类型的connectedSince，应该是指建立某种连接的日期。然后紧接着是四个int类型的变量和两个id。字段的意思都比较通俗，因此不难理解。
然后接着是两个构造器：
这两个构造器不像之前分析的源码一样，存在互相调用，而是简单的两个重载。第一个构造器，传入的参数是String sessionId、int pageId、Long userId、UserDao dao；第二个构造器，传入的参数是StreamClient rcl、User user，在方法体内对字段进行了初始化。
再向下，就是一系列getters和setters，以及一些逻辑非常简单的方法，都没有特别的难度，直到clear方法的出现：
在clear方法内部，清空了activities、rights和streams三个集合。这个方法的作用就是如代码展示，将三个集合清空。
再下面是hasRight方法：
根据方法名，应该是判断客户是否有某个权利。因此，hasRight的形参是一个Right类型的right，方法体内首先判断right是否等于Right.superModerator（Right是一个枚举类型），如果相等，则判断集合rights中是否包含right；否则，判断rights要么包含Right.superModerator，要么包含Right.moderator，要么包含right，三个布尔值的逻辑为或，即只要包含一个就为true。总结来看，hasRight方法的目的就是判断当前客户的rights集合内是否包含传入的right或者Right枚举类的两个字段。
再下面是两个allow方法：
第一个allow调用了重载的第二个allow，因此先看第二个allow方法。它的形参是可迭代的类_rights，元素的类型是Right。方法体内，遍历_rights，对每个right都调用hasRight判断rights是否含有right，如果没有就把right加入rights。它的作用显然是为客户的rights集合添加权利。而第一个allow方法就是利用了这一点，形参是若干个Right对象，然后调用第二个allow为rights添加这些对象，最终返回当前Client对象。
对应地，deny方法就是在rights中移除这些Right对象。接下来的方法是关于Activity的，先看前四个：
第一个是clearActivities方法，将activities集合清空。然后是hasAnyActivity方法，传入若干Activity对象，然后判断activities中是否含有这些对象中的任意一个。在这里用到了我很少见到的|=运算符，其意思：a|=b等价于a=a|b，也就是把a或b赋给a。下一个方法是hasActivity方法，简单地判断activities中是否含有传入的Activity对象即可。
toggle方法中，对于传入的Activity对象a，如果activities中含有a，则调用remove(a)，否则调用set(a)。关于这两个方法，在下面出现了：
首先看set方法：
传入的参数Activity a。方法体内，首先在activities中加入a。然后判断a的值：当a等于Activity枚举类型的字段broadcastV或broadcastA时，如果activities中同时包含了broadcastV和broadcastA，则在activities中添加broadcastAV，结束if判断后break。当a等于Activity枚举类型的字段broadcastAV时，在activities中添加broadcastV和broadcastA，然后break。最终返回当前Client对象。这样看，set方法的含义就是将a加入activities中，然后对broadcastV、broadcastA与broadcastAV进行补充。
再看remove方法：
与set相对应，先在activities中移除a，然后对三个字段进行对应地移除。逻辑相近，不再多说。
分析到这里，前面的toggle方法就明了了——如果activities含有a，则移除a；如果没有，则添加a。
再向下，是一系列的getters和setters，直到下面的toJson方法：
在这里总之就是将当前的Client对象整理成了一个json格式的对象，具体逻辑不再详述。再下面，是merge方法：
merge的意思是合并、归并。形参是Client对象c，因此方法的含义可能就是把c的相关参数赋给当前的Client对象。方法体内，先后把user、room、cam等字段都赋给c的相应字段。此外，使用了三个同步代码块，分别更新三个集合。以第一个为例，首先初始化一个Right类型的集合rr，使用c的rights填充rr；然后使用同步语句，互斥地将rights清空，并把rr的所有元素加入rights，也就是把用c的rights所有元素替换到rights中。其他两个也类似。所以，merge方法的目的就是用c的信息更新当前Client对象的信息。
接下来是两个方法：
第一个方法是hashCode，方法体内通过某些方式获取了uid相关的hashCode。在下面的equals方法中，判断的是当前Client对象与传入形参obj的关系，进行不同标准的判断是否相等。
最后的方法是toString方法，即规定输出当前对象时的格式。
至此，Client.java分析完毕，它定义了描述客户的Client类。此外这也意味着entity/basic目录分析完毕，可以开展下一个目录的分析了。附上Client.java的源码：
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.openmeetings.db.entity.basic;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.apache.mina.util.ConcurrentHashSet;
import org.apache.openmeetings.db.dao.user.UserDao;
import org.apache.openmeetings.db.entity.room.Room;
import org.apache.openmeetings.db.entity.room.Room.Right;
import org.apache.openmeetings.db.entity.room.StreamClient;
import org.apache.openmeetings.db.entity.user.User;
import org.apache.openmeetings.db.manager.IStreamClientManager;
import org.apache.openmeetings.db.util.RoomHelper;
import org.apache.wicket.protocol.ws.api.registry.IKey;
import org.apache.wicket.util.string.Strings;
import com.github.openjson.JSONArray;
import com.github.openjson.JSONObject;
/**
* Temporary class, later will be merged with {@link org.apache.openmeetings.db.entity.room.StreamClient}
* @author solomax
*
*/
public class Client implements IClient {
private static final long serialVersionUID = 1L;
public enum Activity {
broadcastA //sends Audio to the room
, broadcastV //sends Video to the room
, broadcastAV //sends Audio+Video to the room
, share
, record
, publish //sends A/V to external server
}
private final String sessionId;
private int pageId;
private User user;
private Room room;
private final String uid;
private final String sid;
private String remoteAddress;
private final Set<Right> rights = new ConcurrentHashSet<>();
private final Set<Activity> activities = new ConcurrentHashSet<>();
private final Set<String> streams = new ConcurrentHashSet<>();
private final Date connectedSince;
private int cam = -1;
private int mic = -1;
private int width = 0;
private int height = 0;
private String serverId = null;
private Long recordingId;
public Client(String sessionId, int pageId, Long userId, UserDao dao) {
this.sessionId = sessionId;
this.pageId = pageId;
this.user = dao.get(userId);
this.connectedSince = new Date();
uid = UUID.randomUUID().toString();
sid = UUID.randomUUID().toString();
}
public Client(StreamClient rcl, User user) {
this.sessionId = UUID.randomUUID().toString();
this.pageId = 0;
this.user = user;
this.connectedSince = new Date();
uid = rcl.getUid();
sid = rcl.getSid();
this.remoteAddress = rcl.getRemoteAddress();
}
public String getSessionId() {
return sessionId;
}
public int getPageId() {
return pageId;
}
public Client setPageId(IKey key) {
this.pageId = key.hashCode();
return this;
}
public void setPageId(int pageId) {
this.pageId = pageId;
}
public User getUser() {
return user;
}
public Client updateUser(UserDao dao) {
user = dao.get(user.getId());
return this;
}
@Override
public Long getUserId() {
return user.getId();
}
@Override
public String getLogin() {
return user.getLogin();
}
@Override
public String getFirstname() {
return user.getFirstname();
}
@Override
public String getLastname() {
return user.getLastname();
}
@Override
public String getUid() {
return uid;
}
@Override
public String getSid() {
return sid;
}
public void clear() {
activities.clear();
rights.clear();
streams.clear();
}
public boolean hasRight(Right right) {
if (Right.superModerator == right) {
return rights.contains(right);
}
return rights.contains(Right.superModerator) || rights.contains(Right.moderator) || rights.contains(right);
}
public Client allow(Right... _rights) {
allow(Arrays.asList(_rights));
return this;
}
public void allow(Iterable<Right> _rights) {
for (Right right : _rights) {
if (!hasRight(right)) {
rights.add(right);
}
}
}
public void deny(Right... _rights) {
for (Right right : _rights) {
rights.remove(right);
}
}
public void clearActivities() {
activities.clear();
}
public boolean hasAnyActivity(Activity... aa) {
boolean res = false;
if (aa != null) {
for (Activity a : aa) {
res |= activities.contains(a);
}
}
return res;
}
public boolean hasActivity(Activity a) {
return activities.contains(a);
}
public void toggle(Activity a) {
if (hasActivity(a)) {
remove(a);
} else {
set(a);
}
}
public Client set(Activity a) {
activities.add(a);
switch (a) {
case broadcastV:
case broadcastA:
if (hasActivity(Activity.broadcastA) && hasActivity(Activity.broadcastV)) {
activities.add(Activity.broadcastAV);
}
break;
case broadcastAV:
activities.add(Activity.broadcastA);
activities.add(Activity.broadcastV);
break;
default:
}
return this;
}
public Client remove(Activity a) {
activities.remove(a);
switch (a) {
case broadcastV:
case broadcastA:
activities.remove(Activity.broadcastAV);
break;
case broadcastAV:
activities.remove(Activity.broadcastA);
activities.remove(Activity.broadcastV);
break;
default:
}
return this;
}
public Client addStream(String _uid) {
streams.add(_uid);
return this;
}
public Client removeStream(String _uid) {
streams.remove(_uid);
return this;
}
public List<String> getStreams() {
return new ArrayList<>(streams);
}
public Date getConnectedSince() {
return connectedSince;
}
@Override
public Long getId() {
return null;
}
@Override
public void setId(Long id) {
//no-op
}
public Room getRoom() {
return room;
}
public Client setRoom(Room room) {
this.room = room;
return this;
}
public boolean isCamEnabled() {
return cam > -1;
}
public int getCam() {
return cam;
}
public Client setCam(int cam) {
this.cam = cam;
return this;
}
public boolean isMicEnabled() {
return mic > -1;
}
public int getMic() {
return mic;
}
public Client setMic(int mic) {
this.mic = mic;
return this;
}
@Override
public int getWidth() {
return width;
}
public Client setWidth(int width) {
this.width = width;
return this;
}
@Override
public int getHeight() {
return height;
}
public Client setHeight(int height) {
this.height = height;
return this;
}
@Override
public String getRemoteAddress() {
return remoteAddress;
}
public Client setRemoteAddress(String remoteAddress) {
this.remoteAddress = remoteAddress;
return this;
}
@Override
public String getServerId() {
return serverId;
}
public void setServerId(String serverId) {
this.serverId = serverId;
}
@Override
public void setRecordingStarted(boolean recordingStarted) {
if (recordingStarted) {
activities.add(Activity.record);
} else {
activities.remove(Activity.record);
}
}
@Override
public Long getRecordingId() {
return recordingId;
}
@Override
public void setRecordingId(Long recordingId) {
this.recordingId = recordingId;
}
@Override
public Long getRoomId() {
return room == null ? null : room.getId();
}
@Override
public Room.Type getRoomType() {
return room == null ? null : room.getType();
}
public JSONObject toJson(boolean self) {
JSONObject u = new JSONObject();
if (user != null) {
JSONObject a = new JSONObject();
u.put("id", user.getId())
.put("firstName", user.getFirstname())
.put("lastName", user.getLastname())
.put("address", a);
if (user.getAddress() != null) {
if (Strings.isEmpty(user.getFirstname()) && Strings.isEmpty(user.getLastname())) {
a.put("email", user.getAddress().getEmail());
}
a.put("country", user.getAddress().getCountry());
}
}
JSONObject json = new JSONObject()
.put("user", u)
.put("cuid", uid)
.put("uid", uid)
.put("rights", new JSONArray(rights))
.put("activities", new JSONArray(activities))
.put("width", width)
.put("height", height)
.put("self", self);
if (self) {
json.put("cam", cam).put("mic", mic);
}
return json;
}
public JSONObject streamJson(String _sid, boolean self, IStreamClientManager mgr) {
JSONArray _streams = new JSONArray();
boolean avFound = false;
for (String _uid : streams) {
StreamClient rc = mgr.get(_uid);
if (rc == null) {
continue;
}
Type t = rc.getType();
if (Type.room == t) {
avFound = true;
}
_streams.put(RoomHelper.addScreenActivities(
new JSONObject()
.put("type", t.name())
// stream `uid` is unknown at the time of self stream creation
// so we will replace stream `uid` with client `uid` for self
.put("uid", self && Type.room == t ? uid : rc.getUid())
.put("broadcastId", rc.getBroadcastId())
.put("width", rc.getWidth())
.put("height", rc.getHeight())
, rc
));
}
if (self && !avFound && hasAnyActivity(Activity.broadcastA, Activity.broadcastV)) {
_streams.put(new JSONObject()
.put("type", Type.room.name())
// stream `uid` is unknown at the time of self stream creation
// so we will replace stream `uid` with client `uid` for self
.put("uid", uid)
.put("width", width)
.put("height", height)
);
}
return toJson(self).put("sid", _sid).put("streams", _streams);
}
public void merge(Client c) {
user = c.user;
room = c.room;
Set<Right> rr = new HashSet<>(c.rights);
synchronized (rights) {
rights.clear();
rights.addAll(rr);
}
Set<Activity> aa = new HashSet<>(c.activities);
synchronized (activities) {
activities.clear();
activities.addAll(aa);
}
Set<String> ss = new HashSet<>(c.streams);
synchronized (streams) {
streams.clear();
streams.addAll(ss);
}
cam = c.cam;
mic = c.mic;
width = c.width;
height = c.height;
recordingId = c.recordingId;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((uid == null) ? 0 : uid.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Client)) {
return false;
}
Client other = (Client) obj;
if (uid == null) {
if (other.uid != null) {
return false;
}
} else if (!uid.equals(other.uid)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Client [uid=" + uid + ", sessionId=" + sessionId + ", pageId=" + pageId + ", userId=" + user.getId() + ", room=" + (room == null ? null : room.getId())
+ ", rights=" + rights + ", activities=" + activities + ", connectedSince=" + connectedSince + "]";
}
}
entity/calendar目录
在calendar目录下含有三个java文件，三个文件都是对数据库的表进行实体的定义，可以跳过了。
entity/file目录
在file目录下的三个java文件同样可以跳过。
entity/log目录
log目录下的一个java文件同样可以跳过。
entity/record目录
record目录下的三个java文件可以跳过。
entity/server目录
server目录下的五个java文件可以跳过。
entity/label目录
label目录下包含两个java文件，分别是OmLanguage.java和StringLabel.java，这两个文件不同于定义实体的java文件，因此需要详细分析。
OmLanguage.java
先看其引入的内容：
引入的内容均为老面孔，分别是Serializable、Locale和FormatHelper，它们的作用已经不用多说了。再看类的定义：
OmLanguage类实现了Serializable接口，说明它是可序列化的。首先有三个字段，分别是见过多次的serialVersionUID、locale和布尔变量rtl。在构造器中，locale通过形参初始化，而rtl通过调用FormateHelper的方法确定为是否符合该正则表达式的规范。
附上OmLanguage.java的源码：
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.openmeetings.db.entity.label;
import java.io.Serializable;
import java.util.Locale;
import org.apache.openmeetings.db.util.FormatHelper;
public class OmLanguage implements Serializable {
private static final long serialVersionUID = 1L;
private final Locale locale;
private final boolean rtl;
public OmLanguage(Locale locale) {
this.locale = locale;
this.rtl = FormatHelper.isRtlLanguage(locale.toLanguageTag());
}
public Locale getLocale() {
return locale;
}
public boolean isRtl() {
return rtl;
}
}
StringLabel.java
StringLabel.java的代码量也不大。先看引入的内容：
首先引入的java.util.AbstractMap.SimpleEntry类，用来维护键和值的条目。它似乎只能存储一个键值对，并且可以调用getKey()、getValue()、setValue()等方法。然后引入的就是Map和IDataProviderEntity类了。
然后看类体：
StringLabel类继承自SimpleEntry，并且实现了IDataProviderEntity接口。
定义的字段就不再多说了。直接看两个构造器：第一个构造器传入了两个字符串key和value，在方法体内直接调用super即SimpleEntry的构造器来构造；第二个构造器传入了一个StringLabel对象l，使用l的信息来初始化自己。紧接着两个构造器的是之前分析过的hashCode方法和equals方法，都没有什么可说的。最后就是继承自接口的id属性的getter和setter。
至此，StringLabel类分析完毕，同样label目录也分析完毕。附上StringLabel类的源码：
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.openmeetings.db.entity.label;
import java.util.AbstractMap.SimpleEntry;
import java.util.Map;
import org.apache.openmeetings.db.entity.IDataProviderEntity;
public class StringLabel extends SimpleEntry<String, String> implements IDataProviderEntity {
private static final long serialVersionUID = 1L;
public StringLabel(String key, String value) {
super(key, value);
}
public StringLabel(StringLabel l) {
super(l.getKey(), l.getValue());
}
@Override
public int hashCode() {
return getKey() == null ? 0 : getKey().hashCode();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return getKey() == null ? e.getKey() == null : getKey().equals(e.getKey());
}
@Override
public Long getId() {
return null;
}
@Override
public void setId(Long id) {
//no-op
}
}
entity/room目录
room目录结构如下：
查看源码后可知，在room目录下，除了StreamClient.java外，其余的java文件均可以跳过，因此我们就着重分析一下StreamClient.java。
StreamClient.java
StreamClient类在之前的源码分析中也遇到过了，因此在这里也需要分析一下。首先看其引入的内容：
引入的内容只有三个。第一个是Date类，第二个是刚才分析过的IClient接口，第三个是与字符串处理相关的StringValue类，都不陌生了。看类的定义：
首先实现了IClient接口，从IClient接口继承了可序列化的特点以及一些字段和方法。然后定义了许多字段，包括了serialVersionUID、scope、width等，其含义基本上就是当前客户的基本信息和行为信息。除了这些字段之外，类体内的方法就只有getters和setters以及toString方法了。因此，整个类的内容非常简单，没有什么可说的。
至此，StreamClient.java分析完毕。附上其源码：
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.openmeetings.db.entity.room;
import java.util.Date;
import org.apache.openmeetings.db.entity.basic.IClient;
import org.apache.wicket.util.string.StringValue;
/**
* Can be configured to be stored in memory or in database
*
* @author sebawagner
*/
public class StreamClient implements IClient {
private static final long serialVersionUID = 1L;
private String scope = "";
private int width = 0;
private int height = 0;
private String uid = null;
private String sid = null;
private boolean mod = false;
private boolean superMod = false;
private Date connectedSince;
private String remoteAddress;
private int userport;
private Date roomEnter = null;
private String broadcastId = null;
@SuppressWarnings("unused") private String broadCastID = null; //required for mobile only
private String login = "";
private Long userId = null;
private String firstname = "";
private String lastname = "";
private String email;
private String lastLogin;
private String language = "";
private String avsettings = "";
private String swfurl;
private String tcUrl;
private boolean nativeSsl = false;
private boolean recordingStarted = false;
private boolean sharingStarted = false;
private boolean publishStarted = false;
private boolean broadcasting = false;
private Long recordingId;
private Long metaId;
private String externalUserId;
private String externalUserType;
private boolean allowRecording = true;
private boolean micMuted = false;
private String serverId;
private Long roomId;
private Room.Type roomType;
private Type type = Type.video;
@Override
public Long getId() {
return null;
}
@Override
public void setId(Long id) {
//no-op
}
public String getScope() {
return scope;
}
public void setScope(String scope) {
this.scope = scope;
StringValue scn = StringValue.valueOf(scope);
long rId = scn.toLong(Long.MIN_VALUE);
if (rId > 0) {
this.roomId = rId;
}
}
@Override
public int getWidth() {
return width;
}
public StreamClient setWidth(int width) {
this.width = width;
return this;
}
@Override
public int getHeight() {
return height;
}
public StreamClient setHeight(int height) {
this.height = height;
return this;
}
@Override
public String getUid() {
return uid;
}
public void setUid(String uid) {
this.uid = uid;
}
@Override
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public boolean isMod() {
return mod;
}
public void setMod(boolean mod) {
this.mod = mod;
}
public boolean isSuperMod() {
return superMod;
}
public void setSuperMod(boolean superMod) {
this.superMod = superMod;
}
public Date getConnectedSince() {
return connectedSince;
}
public void setConnectedSince(Date connectedSince) {
this.connectedSince = connectedSince;
}
@Override
public String getRemoteAddress() {
return remoteAddress;
}
public void setRemoteAddress(String remoteAddress) {
this.remoteAddress = remoteAddress;
}
public int getUserport() {
return userport;
}
public void setUserport(int userport) {
this.userport = userport;
}
public Date getRoomEnter() {
return roomEnter;
}
public void setRoomEnter(Date roomEnter) {
this.roomEnter = roomEnter;
}
public String getBroadcastId() {
return broadcastId;
}
public void setBroadcastId(String broadcastId) {
this.broadcastId = broadcastId;
this.broadCastID = broadcastId;
}
public String getBroadCastID() {
return broadCastID;
}
@Override
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
@Override
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
@Override
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
@Override
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getLastLogin() {
return lastLogin;
}
public void setLastLogin(String lastLogin) {
this.lastLogin = lastLogin;
}
public String getLanguage() {
return language;
}
public void setLanguage(String language) {
this.language = language;
}
public String getAvsettings() {
return avsettings;
}
public void setAvsettings(String avsettings) {
this.avsettings = avsettings;
}
public String getSwfurl() {
return swfurl;
}
public void setSwfurl(String swfurl) {
this.swfurl = swfurl;
}
public String getTcUrl() {
return tcUrl;
}
public void setTcUrl(String tcUrl) {
this.tcUrl = tcUrl;
}
public boolean isNativeSsl() {
return nativeSsl;
}
public void setNativeSsl(boolean nativeSsl) {
this.nativeSsl = nativeSsl;
}
public boolean isRecordingStarted() {
return recordingStarted;
}
@Override
public void setRecordingStarted(boolean recordingStarted) {
this.recordingStarted = recordingStarted;
}
public boolean isSharingStarted() {
return sharingStarted;
}
public void setSharingStarted(boolean sharingStarted) {
this.sharingStarted = sharingStarted;
}
public boolean isPublishStarted() {
return publishStarted;
}
public void setPublishStarted(boolean publishStarted) {
this.publishStarted = publishStarted;
}
public boolean isBroadcasting() {
return broadcasting;
}
public void setBroadcasting(boolean isBroadcasting) {
this.broadcasting = isBroadcasting;
}
@Override
public Long getRecordingId() {
return recordingId;
}
@Override
public void setRecordingId(Long recordingId) {
this.recordingId = recordingId;
}
public Long getMetaId() {
return metaId;
}
public void setMetaId(Long metaId) {
this.metaId = metaId;
}
public String getExternalUserId() {
return externalUserId;
}
public void setExternalUserId(String externalUserId) {
this.externalUserId = externalUserId;
}
public String getExternalUserType() {
return externalUserType;
}
public void setExternalUserType(String externalUserType) {
this.externalUserType = externalUserType;
}
public boolean isAllowRecording() {
return allowRecording;
}
public void setAllowRecording(boolean allowRecording) {
this.allowRecording = allowRecording;
}
public boolean isMicMuted() {
return micMuted;
}
public void setMicMuted(boolean micMuted) {
this.micMuted = micMuted;
}
@Override
public String getServerId() {
return serverId;
}
public void setServerId(String serverId) {
this.serverId = serverId;
}
@Override
public Long getRoomId() {
return roomId;
}
@Override
public Room.Type getRoomType() {
return roomType;
}
public void setRoomType(Room.Type roomType) {
this.roomType = roomType;
}
public Type getType() {
return type;
}
public void setType(Type type) {
this.type = type;
}
@Override
public String toString() {
return "StreamClient [scope=" + scope + ", uid=" + uid + ", sid=" + sid + ", broadCastId="
+ broadcastId + ", login=" + login + ", userId=" + userId + ", avsettings=" + avsettings + ", type=" + type
+ ", isBroadcasting=" + broadcasting + "]";
}
}
总结
在把StreamClient.java分析完毕之后，就完成了entity/room目录的分析，这也意味着db模块下entity目录分析的结束。entity目录主要的作用是定义数据库的实体，通过java语言来完成数据库的部署。虽然代码量较大，但由于重复工作非常多，分析起来难度反而小。至此，已经完成了db模块下util和entity两大目录的源码分析。
在之后的文章里，将会逐步完成db模块的源码分析，然后开展core模块的分析工作。
460
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
