import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
public void broadcast(JSONObject notification, String account) {
        try {
            Iterator<String> it = notification.keys();
            HashMap<String, Object> valueMap = new HashMap<String, Object>();
            while (it.hasNext()) {
                String key = it.next();
                if (!(notification.get(key) instanceof JSONObject))
                    valueMap.put(key, notification.get(key));

            }
            sendGCMNotification(account, valueMap);
            sendiOSNotificationAsJson(account, valueMap); //TODO rename
//            sendGlassNotification(account, valueMap);
            log.log(Level.WARNING, "about to send channel message to "+account);

            channelService.sendMessage(new ChannelMessage(account, notification.toString()));
            log.log(Level.WARNING, "channel message sent to ");
        } catch (Exception e) {

            log.log(Level.SEVERE, e.getMessage(), e);
        }

    }
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * Test method for {@link Channels#sendObjects}.
 */
@Test
public void testSendObjects_noResults() {
  ArgumentCaptor<ChannelMessage> messageCapture = ArgumentCaptor.forClass(ChannelMessage.class);

  channels.sendObjects(CHANNEL_KEY, Lists.newArrayList(), TAG, REQUEST_ID);

  verify(channelService).sendMessage(messageCapture.capture());

  assertEquals(CHANNEL_KEY, messageCapture.getValue().getClientId());
  @SuppressWarnings("unchecked") // That's the defined message format.
  Map<String, Map<String, String>> message =
      gson.fromJson(messageCapture.getValue().getMessage(), Map.class);
  assertTrue(message.containsKey(Channels.INFO_TAG));
  assertEquals(TAG, message.get(Channels.INFO_TAG).get(Channels.TAG));
  assertTrue(message.get(Channels.INFO_TAG).containsKey(Channels.MESSAGE));
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * Test method for {@link Channels#sendPage}.
 */
@Test
public void testSendPage()
    throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
  Page page = new Page();
  List<Object> list = Lists.newArrayList(new Object());
  page.getResults().addAll(list);
  ArgumentCaptor<ChannelMessage> messageCapture = ArgumentCaptor.forClass(ChannelMessage.class);

  channels.sendPage(CHANNEL_KEY, page, TAG, REQUEST_ID);

  verify(channelService).sendMessage(messageCapture.capture());

  assertEquals(CHANNEL_KEY, messageCapture.getValue().getClientId());
  assertEquals(jsonFromList(REQUEST_ID, list), messageCapture.getValue().getMessage());
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * Test method for {@link Channels#sendInfoMessage}.
 */
@Test
public void testSendInfoMessage() {
  ArgumentCaptor<ChannelMessage> messageCapture = ArgumentCaptor.forClass(ChannelMessage.class);

  channels.sendInfoMessage(CHANNEL_KEY, TAG, REQUEST_ID, MY_MESSAGE);

  verify(channelService).sendMessage(messageCapture.capture());

  assertEquals(CHANNEL_KEY, messageCapture.getValue().getClientId());
  @SuppressWarnings("unchecked") // That's the defined message format.
  Map<String, Map<String, String>> message =
      gson.fromJson(messageCapture.getValue().getMessage(), Map.class);
  assertTrue(message.containsKey(Channels.INFO_TAG));
  assertEquals(TAG, message.get(Channels.INFO_TAG).get(Channels.TAG));
  assertEquals(MY_MESSAGE, message.get(Channels.INFO_TAG).get(Channels.MESSAGE));
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * Test method for {@link Channels#sendErrorChannelMessage}.
 */
@Test
public void testSendErrorChannelMessage() {
  ArgumentCaptor<ChannelMessage> messageCapture = ArgumentCaptor.forClass(ChannelMessage.class);

  channels.sendErrorChannelMessage(CHANNEL_KEY, TAG, REQUEST_ID, MY_MESSAGE);

  verify(channelService).sendMessage(messageCapture.capture());

  assertEquals(CHANNEL_KEY, messageCapture.getValue().getClientId());
  @SuppressWarnings("unchecked") // That's the defined message format.
  Map<String, Map<String, String>> message =
      gson.fromJson(messageCapture.getValue().getMessage(), Map.class);
  assertTrue(message.containsKey(Channels.ERROR_TAG));
  assertEquals(TAG, message.get(Channels.ERROR_TAG).get(Channels.TAG));
  assertEquals(MY_MESSAGE, message.get(Channels.ERROR_TAG).get(Channels.MESSAGE));
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的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.ChannelMessage; //导入依赖的package包/类
private void sendData(ClientId clientId, String data) {
  log.info("Sending to " + clientId + ", " + Util.abbrev(data, 50));
  try {
    channelService.sendMessage(new ChannelMessage(clientId.getId(), data));
  } catch (ChannelFailureException e) {
    // Channel service is best-effort anyway, so it's safe to discard the
    // exception after taking note of it.
    log.log(Level.SEVERE, "Channel service failed for " + clientId, e);
  }
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * broadcast PresenceRoom over all user connected to this room.
 * @param p_room
 */
protected static void broadcast(PresenceRoom p_room)
{
  AppRoot.logger.fine( "ChannelManager.broadcast room "+ p_room.getGameId() );
  
  String response = Serializer.toClient( p_room );

  if( response != null )
  {
    for( Presence presence : p_room )
    {
      if( presence.getClientType() == ClientType.XMPP )
      {
        if( presence.getJabberId() != null )
        {
          // send presence to xmpp clients
          XMPPProbeServlet.sendPresence( new JID( presence.getJabberId() ) );
        }
        else
        {
          AppRoot.logger.severe( "Send a PresenceRoom, but his XMPP presence have a JabberId null !" );
        }
      }
      else
      {
        // send presence to web client
        try
        {
          AppRoot.logger.finer( "ChannelManager.sendMessage "+ presence.getChannelId() );
          s_channelService.sendMessage( new ChannelMessage( presence.getChannelId(), response ) );
        } catch( Exception e )
        {
          AppRoot.logger.severe( e.getMessage() );
        }
      }
    }
  }
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的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.ChannelMessage; //导入依赖的package包/类
/**
 * Test method for {@link Channels#sendSingleObject}.
 */
@Test
public void testSendObject() {
  Object object = new Object();
  ArgumentCaptor<ChannelMessage> messageCapture = ArgumentCaptor.forClass(ChannelMessage.class);

  channels.sendSingleObject(CHANNEL_KEY, object, TAG, REQUEST_ID);

  verify(channelService).sendMessage(messageCapture.capture());

  assertEquals(CHANNEL_KEY, messageCapture.getValue().getClientId());
  assertEquals(jsonFromList(REQUEST_ID, Lists.newArrayList(object)),
      messageCapture.getValue().getMessage());
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * Test method for {@link Channels#sendObjects}.
 */
@Test
public void testSendObjects_singleBatch() {
  List<Object> list = makeList(Channels.BATCH_SIZE);
  ArgumentCaptor<ChannelMessage> messageCapture = ArgumentCaptor.forClass(ChannelMessage.class);

  channels.sendObjects(CHANNEL_KEY, list, TAG, REQUEST_ID);

  verify(channelService).sendMessage(messageCapture.capture());

  assertEquals(jsonFromList(REQUEST_ID, list), messageCapture.getValue().getMessage());
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * Test method for {@link Channels#sendObjects}.
 */
@Test
public void testSendObjects_multipleBatches() {
  List<Object> list = makeList(Channels.BATCH_SIZE + 1);

  channels.sendObjects(CHANNEL_KEY, list, TAG, REQUEST_ID);

  verify(channelService, times(2)).sendMessage(any(ChannelMessage.class));
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的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.ChannelMessage; //导入依赖的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.ChannelMessage; //导入依赖的package包/类
@Override
@ApiMethod(path = "pushToAppEngineChannel")
public void push(@Named("subscribeId") String subscribeId,
    @Nullable @Named("messageType") String messageType, @Named("message") String msg) {
  try {
    channelService.sendMessage(new ChannelMessage(subscribeId, msg));
  } catch (ChannelFailureException e) {
    // Channel service is best-effort anyway, so it's safe to discard the
    // exception after taking note of it.
    log.log(Level.SEVERE, "Channel service failed for " + subscribeId, e);
  }
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的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.ChannelMessage; //导入依赖的package包/类
public static void disconnect(Presence p_presence)
{
  if( p_presence == null )
  {
    return;
  }
  AppRoot.logger.fine( "ChannelManager.disconnect "+ p_presence.getGameId()+" - "+p_presence.getChannelId() );
  
  PresenceRoom room = getRoom( p_presence.getGameId() );
  room.remove( p_presence );
  
  // ask all other presence with similar pseudo to send a presence empty
  // message
  String response = Serializer.toClient( new ChatMessage() );
  for(Presence presence : room)
  {
    if( presence.getClientType() != ClientType.XMPP
        && presence.getPseudo().equalsIgnoreCase( p_presence.getPseudo() ) )
    {
      try
      {
        // client have 4 seconds to answer
        presence.getLastConnexion().setTime(
            System.currentTimeMillis() - CACHE_PRESENCE_TTL_MS + 4000 );
        s_channelService.sendMessage( new ChannelMessage( presence.getChannelId(), response ) );
      } catch( Exception e )
      {
        AppRoot.logger.severe( e.getMessage() );
      }
    }
  }
  
  if( room.isEmpty() )
  {
    // room empty: clear cache
    getCache().delete( p_presence.getGameId() );
  }
  else
  {
    // room was updated: update cache
    getCache()
        .put( p_presence.getGameId(), room, Expiration.byDeltaSeconds( CACHE_ROOM_TTL_SEC ) );

    // then broadcast connection to all connected users
    broadcast( room );
  }
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
public void notify(String account, String message) {
    if (account != null) channelService.sendMessage(new ChannelMessage(account, message));
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
public static void sendUpdate(String channelKey) {
	ChannelService channelService = ChannelServiceFactory.getChannelService();
	channelService.sendMessage(new ChannelMessage(channelKey, "hallo"));
}
 

import com.google.appengine.api.channel.ChannelMessage; //导入依赖的package包/类
/**
 * Creates a {@link ChannelMessage} with the JSON representation of the data map.
 *
 * @param channelKey the key to send a message via the Channel API
 * @param data the data map
 * @return a {@link ChannelMessage}
 */
private ChannelMessage createMessage(String channelKey, Map<String, ?> data) {
  return new ChannelMessage(channelKey, gson.toJson(data));
}