import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private static Serializer getReadSerializer() throws Exception {
	if (readSerializer == null) {
	Log.d("hv", "Begin Creating Serializer");
       RegistryMatcher matcher = new RegistryMatcher();
       matcher.bind(Date.class, new DateFormatTransformer());

       Registry registry = new Registry();
       registry.bind(String.class, SimpleXMLStringConverter.class);
       Strategy strategy = new RegistryStrategy(registry);

       Serializer s = new Persister(strategy, matcher);
	Log.d("hv", "Done Creating Serializer");
	
	readSerializer = s;
	}
       return readSerializer;
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void importRoomGroups(File f) throws Exception {
	log.info("Room import complete, starting room groups import");
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(Group.class, new GroupConverter(groupDao, groupMap));
	registry.bind(Room.class, new RoomConverter(roomDao, roomMap));

	List<RoomGroup> list = readList(serializer, f, "rooms_organisation.xml", "room_organisations", RoomGroup.class);
	for (RoomGroup ro : list) {
		Room r = roomDao.get(ro.getRoom().getId());
		if (r == null || ro.getGroup() == null || ro.getGroup().getId() == null) {
			continue;
		}
		if (r.getGroups() == null) {
			r.setGroups(new ArrayList<>());
		}
		ro.setId(null);
		ro.setRoom(r);
		r.getGroups().add(ro);
		roomDao.update(r, null);
	}
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void importChat(File f) throws Exception {
	log.info("Room groups import complete, starting chat messages import");
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(User.class, new UserConverter(userDao, userMap));
	registry.bind(Room.class, new RoomConverter(roomDao, roomMap));
	registry.bind(Date.class, DateConverter.class);

	List<ChatMessage> list = readList(serializer, f, "chat_messages.xml", "chat_messages", ChatMessage.class);
	for (ChatMessage m : list) {
		m.setId(null);
		if (m.getFromUser() == null || m.getFromUser().getId() == null) {
			continue;
		}
		chatDao.update(m, m.getSent());
	}
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void importContacts(File f) throws Exception {
	log.info("Private message folder import complete, starting user contacts import");
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(User.class, new UserConverter(userDao, userMap));

	List<UserContact> list = readList(serializer, f, "userContacts.xml", "usercontacts", UserContact.class);
	for (UserContact uc : list) {
		Long ucId = uc.getId();
		UserContact storedUC = userContactDao.get(ucId);

		if (storedUC == null && uc.getContact() != null && uc.getContact().getId() != null) {
			uc.setId(null);
			if (uc.getOwner() != null && uc.getOwner().getId() == null) {
				uc.setOwner(null);
			}
			uc = userContactDao.update(uc);
			userContactMap.put(ucId, uc.getId());
		}
	}
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void importRoomFiles(File f) throws Exception {
	log.info("Poll import complete, starting room files import");
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(BaseFileItem.class, new BaseFileItemConverter(fileItemDao, fileItemMap));

	List<RoomFile> list = readList(serializer, f, "roomFiles.xml", "RoomFiles", RoomFile.class, true);
	for (RoomFile rf : list) {
		Room r = roomDao.get(roomMap.get(rf.getRoomId()));
		if (r == null || rf.getFile() == null || rf.getFile().getId() == null) {
			continue;
		}
		if (r.getFiles() == null) {
			r.setFiles(new ArrayList<>());
		}
		rf.setId(null);
		rf.setRoomId(r.getId());
		r.getFiles().add(rf);
		roomDao.update(r, null);
	}
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private Serializer getSerializer() throws AETException {
  Registry registry = new Registry();
  Serializer serializer = new Persister(new RegistryStrategy(registry));
  try {
    registry.bind(Collect.class, new CollectConverter());
    registry.bind(Compare.class, new CompareConverter());
  } catch (Exception e) {
    throw new AETException("Error while serializing test suite.", e);
  }
  return serializer;
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
/**
 * Utility to get a simple framework persister
 * @return a persister
 * @throws Exception when things get tough
 */
private static Serializer getSerializer() throws Exception {
    Registry registry = new Registry();
    registry.bind(String.class, EmptyStringConverter.class);
    Strategy strategy = new AnnotationStrategy(new RegistryStrategy(registry));
    return new Persister(strategy);

}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
public Serializer createSerializer() {
    Registry registry = new Registry();

    try {
        registry.bind(Vector2.class, VectorConverter.class);
    } catch (Exception e) {
        throw new RuntimeException("Error binding converters!");
    }

    Strategy strategy = new RegistryStrategy(registry);
    return new Persister(strategy);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private static <T> void bindDate(Registry registry, List<T> list, Function<T, ?> func) throws Exception {
	if (list != null) {
		for (T e : list) {
			Object d = func.apply(e);
			if (d != null) {
				Class<?> dateClass = d.getClass();
				registry.bind(dateClass, DateConverter.class);
				break;
			}
		}
	}
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportGroups(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer ser = new Persister(strategy);
	List<Group> list = groupDao.get(0, Integer.MAX_VALUE);
	bindDate(registry, list);
	writeList(ser, zos, "organizations.xml", "organisations", list);
	progressHolder.setProgress(5);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportUsers(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer ser = new Persister(strategy);

	registry.bind(Group.class, GroupConverter.class);
	registry.bind(Salutation.class, SalutationConverter.class);
	List<User> list = userDao.getAllBackupUsers();
	bindDate(registry, list);

	writeList(ser, zos, "users.xml", "users", list);
	progressHolder.setProgress(10);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportRoom(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(User.class, UserConverter.class);
	registry.bind(Room.Type.class, RoomTypeConverter.class);
	List<Room> list = roomDao.get();
	bindDate(registry, list);
	writeList(serializer, zos, "rooms.xml", "rooms", list);
	progressHolder.setProgress(15);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportRoomGroup(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(Group.class, GroupConverter.class);
	registry.bind(Room.class, RoomConverter.class);

	writeList(serializer, zos, "rooms_organisation.xml", "room_organisations", roomDao.getGroups());
	progressHolder.setProgress(17);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportRoomFile(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(FileItem.class, BaseFileItemConverter.class);
	registry.bind(Recording.class, BaseFileItemConverter.class);

	writeList(serializer, zos, "roomFiles.xml", "RoomFiles", roomDao.getFiles());
	progressHolder.setProgress(17);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportCalendar(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	List<OmCalendar> list = calendarDao.get();
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);
	registry.bind(User.class, UserConverter.class);

	writeList(serializer, zos, "calendars.xml", "calendars", list);
	progressHolder.setProgress(22);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportAppointment(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	List<Appointment> list = appointmentDao.get();
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(User.class, UserConverter.class);
	registry.bind(Appointment.Reminder.class, AppointmentReminderTypeConverter.class);
	registry.bind(Room.class, RoomConverter.class);
	bindDate(registry, list);

	writeList(serializer, zos, "appointements.xml", "appointments", list);
	progressHolder.setProgress(25);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportMeetingMember(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(User.class, UserConverter.class);
	registry.bind(Appointment.class, AppointmentConverter.class);

	writeList(serializer, zos, "meetingmembers.xml",
			"meetingmembers", meetingMemberDao.getMeetingMembers());
	progressHolder.setProgress(30);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportOauth(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);
	List<OAuthServer> list = auth2Dao.get(0, Integer.MAX_VALUE);
	bindDate(registry, list);
	writeList(serializer, zos, "oauth2servers.xml", "oauth2servers", list);
	progressHolder.setProgress(45);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportPrivateMsg(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	List<PrivateMessage> list = privateMessageDao.get(0, Integer.MAX_VALUE);
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(User.class, UserConverter.class);
	registry.bind(Room.class, RoomConverter.class);
	bindDate(registry, list, PrivateMessage::getInserted);
	writeList(serializer, zos, "privateMessages.xml", "privatemessages", list);
	progressHolder.setProgress(50);
}
 

import org.simpleframework.xml.convert.Registry; //导入依赖的package包/类
private void exportContacts(ZipOutputStream zos, ProgressHolder progressHolder) throws Exception {
	Registry registry = new Registry();
	Strategy strategy = new RegistryStrategy(registry);
	Serializer serializer = new Persister(strategy);

	registry.bind(User.class, UserConverter.class);

	writeList(serializer, zos, "userContacts.xml", "usercontacts", userContactDao.get());
	progressHolder.setProgress(60);
}