Java ChannelService类代码示例

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
/**
 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
 */
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	
	// In the handler for _ah/channel/connected/
	ChannelService channelService = ChannelServiceFactory.getChannelService();
	ChannelPresence presence = channelService.parsePresence(request);
	
	String clientId = presence.clientId();
	boolean connected = presence.isConnected();
	
	log.info("Client = " + clientId + ", connected = " + connected);
	
	if(!connected) {
		// remove them from the datastore
	    Client.remove(clientId);
	}
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@GET
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Path("/token")
public String getToken(@HeaderParam("Authorization") String token)  {
	try {
	if (!validCredentials(token))
		return null;
	UsersDelegator qu = new UsersDelegator(token);
	String myAccount = qu.getCurrentUserAccount();
	
	ChannelService channelService = ChannelServiceFactory.getChannelService();
	return "{ \"token\": \""+channelService.createChannel(myAccount)+"\"}";

	} catch (Exception e) {
		e.printStackTrace();
		return e.getMessage();
	}
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@GET
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Path("/token3m")
public String getToken3m(@HeaderParam("Authorization") String token)  {
	try {
	if (!validCredentials(token))
		return null;
	UsersDelegator qu = new UsersDelegator(token);
	String myAccount = qu.getCurrentUserAccount();
	
	ChannelService channelService = ChannelServiceFactory.getChannelService();
	return "{ \"token\": \""+channelService.createChannel(myAccount,2)+"\"}";

	} catch (Exception e) {
		e.printStackTrace();
		return e.getMessage();
	}
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param channelService service for handling channel communication
 * @param networks used to get a list of networks
 * @param userService the App Engine service for user management
 * @param memcacheService the App Engine caching service
 * @param expirationDelta the cache expiration delta in seconds
 * @param authorizationCodeFlowFactory used to get an OAuth2 flow
 * @param redirectUrl where to direct the user once authorization is done
 */
@Inject
public IndexServlet(ChannelService channelService,
    Networks networks,
    UserService userService,
    MemcacheService memcacheService,
    @Named("expirationDelta") int expirationDelta,
    AuthorizationCodeFlowFactory authorizationCodeFlowFactory,
    @Named("redirectUrl") String redirectUrl) {
  super(authorizationCodeFlowFactory, redirectUrl);
  this.channelService = channelService;
  this.networks = networks;
  this.memcacheService = memcacheService;
  this.userService = userService;
  this.expirationDelta = expirationDelta;
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@ApiMethod(name = "data.create", httpMethod = "post")
public SensorData create(SensorData data, User user) {
	
    // check the user is authenticated and authorised
	if(user == null) {
		log.warning("User is not authenticated");
		throw new RuntimeException("Authentication required!");
		
	} else if(!Constants.EMAIL_ADDRESS.equals(user.getEmail())) {
		
		log.warning("User is not authorised, email: " + user.getEmail());
		throw new RuntimeException("Not authorised!");
	}
	
	data.save();
	
	try {
	    // notify the client channels
	    ChannelService channelService = ChannelServiceFactory.getChannelService();

	    List<Client> clients = Client.findAll();
	    String json = GSON.toJson(data);

	    for(Client client: clients) {
	        channelService.sendMessage(new ChannelMessage(client.getId(), json));
	    }
	    
	} catch(Exception e) {
	    log.log(Level.SEVERE, "Failed to notify connected clients", e);
	}
		
	return data;
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@Inject
public SlobMessageRouter(MemcacheTable.Factory memcacheFactory, ChannelService channelService,
    @SlobChannelExpirationSeconds int expirationSeconds) {
  this.objectListeners = memcacheFactory.create(LISTENER_MEMCACHE_TAG);
  this.clientTokens = memcacheFactory.create(CLIENTS_MEMCACHE_TAG);
  this.channelService = channelService;
  this.expirationSeconds = expirationSeconds;
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@GET
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Path("/token2m")
public String getShortToken(@HeaderParam("Authorization") String token)  {
	if (!validCredentials(token))
		return null;
	UsersDelegator qu = new UsersDelegator(token);
	String myAccount = qu.getCurrentUserAccount();
	
	ChannelService channelService = ChannelServiceFactory.getChannelService();
	return "clientId: "+myAccount+" token2m " + channelService.createChannel(myAccount, 2);

}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@GET
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Path("/run/{account}")
public String getRun(@PathParam("account") String account)  {		
	ChannelService channelService = ChannelServiceFactory.getChannelService();
	Run r = new Run();
	r.setGameId(123l);
	r.setTitle("een game");
	channelService.sendMessage(new ChannelMessage(account, toJson(r)));
	return "sent";
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
public static void sendUpdateToUser(Message  model) {
  if (model.getSendTo() != null && model.getSendTo()!="") {
    
     PubsubJSONSerializer<Message> serialize = new PubsubJSONSerializer<Message>();
     String messagePayload = serialize.POJOSerializer(model);
     ChannelService channelService = ChannelServiceFactory.getChannelService();
     String channelKey = LiveFeedChannel.getChannelKey(model.getSendTo());
     channelService.sendMessage(new ChannelMessage(channelKey, messagePayload));
    
  }
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
public static void pushUpdates(List<User> users, String message, String url) {
	ChannelService channelService = ChannelServiceFactory
			.getChannelService();
	try {
		JSONObject json = new JSONObject();
		json.put("message", message);
		json.put("link", url);
		for (User user : users) {
			channelService.sendMessage(new ChannelMessage(KeyFactory
					.keyToString(user.getKey()), json.toString()));
		}
	} catch (JSONException e) {
		e.printStackTrace();
	}
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@Inject
public SlobMessageRouter(MemcacheTable.Factory memcacheFactory, ChannelService channelService,
    Provider<PresenceEndpoint> presence) {
  this.clientTokens = memcacheFactory.create(CLIENTS_MEMCACHE_TAG);
  this.channelService = channelService;
  this.presence = presence;
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
	ChannelService channelService = ChannelServiceFactory.getChannelService();
	
	//The token must be based on some unique identifier for the client - I am using the current time
	//for demo purposes...
	String clientId = String.valueOf(System.currentTimeMillis());
    String token = channelService.createChannel(clientId);
    
    //Subscribe this client
    MultichannelChatManager.addSub(clientId);
    
    //Reply with the token
	res.setContentType("text/plain");
	res.getWriter().print(token);
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
public static void sendMessage(String body, String source) {
	Iterator<String> it = subs.iterator();
	while (it.hasNext()) {
		String sub = it.next();
		String messageBody = source + ": " + body;

		// We assume an at symbol is an XMPP client...
		if (sub.indexOf("@") >= 0) {
			JID jid = new JID(sub);
			Message msg = new MessageBuilder().withRecipientJids(jid).withBody(messageBody).build();
			XMPPService xmpp = XMPPServiceFactory.getXMPPService();
			xmpp.sendMessage(msg);
		}
		
		// If it starts with a "+" it's an SMS number...
		else if (sub.startsWith("+")) {
			TwilioRestClient client = new TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN");

			Map<String, String> params = new HashMap<String, String>();
			params.put("Body", messageBody);
			params.put("To", sub);
			params.put("From", "+16122948105");

			SmsFactory messageFactory = client.getAccount().getSmsFactory();

			try {
				Sms message = messageFactory.create(params);
				System.out.println(message.getSid());
			} catch (TwilioRestException e) {
				e.printStackTrace();
			}
		}

		// Otherwise, it's a browser-based client
		else {
			ChannelService channelService = ChannelServiceFactory.getChannelService();
			channelService.sendMessage(new ChannelMessage(sub,messageBody));
		}
	}
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	String requestURI = req.getRequestURI();
	if (" /_ah/channel/disconnected/".equals(requestURI)) {
		ChannelService channelService = ChannelServiceFactory.getChannelService();
		ChannelPresence presence = channelService.parsePresence(req);
		String clientId = presence.clientId();
		log.info("disconnected " + clientId);
	}
}
 

import com.google.appengine.api.channel.ChannelService; //导入依赖的package包/类
/**
 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
 */
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    // get the session 
    HttpSession session = request.getSession();
    String clientId = session.getId();

    log.info("Sending data to client " + clientId);

    Client client = Client.findById(clientId);

    String token = null;

    if(client == null) {

        ChannelService channelService = ChannelServiceFactory.getChannelService();
        log.info("Creating channel for clientId " + clientId);
        // open the channel
        token = channelService.createChannel(clientId);

        client = new Client(clientId, token);
        client.save();
    }
    
 // use the session id and the channel id for this client
    Map<String, Object> data = new HashMap<>();
    token = client.getToken();
    data.put("token", token);

    //createTestData();
    int minutes = 1;
    String timeRange = request.getParameter("timeRange");

    try {
        minutes = Integer.parseInt(timeRange);
        
    } catch(NumberFormatException e) {
        log.warning("Failed to parse number " + timeRange);
    }

    Calendar calendar = new GregorianCalendar();
    calendar.add(Calendar.MINUTE, -minutes);
    Date date = calendar.getTime();
    
    List<SensorData> sensorDataList = SensorData.findByDateTime(date);

    data.put("data", sensorDataList);

    response.setContentType(CONTENT_TYPE_JSON);
    response.getWriter().print(GSON.toJson(data));

}