jam-cloud/lib/jam_ruby/message_factory.rb

  module JamRuby
  # creates messages (implementation: protocol buffer) objects cleanly
  class MessageFactory

    CLIENT_TARGET         = "client"
    SERVER_TARGET         = "server"
    SESSION_TARGET_PREFIX = "session:"
    USER_TARGET_PREFIX    = "user:"
    CLIENT_TARGET_PREFIX  = "client:"

    def initialize()
			@type_values = {}

			Jampb::ClientMessage::Type.constants.each do |constant|
				@type_values[Jampb::ClientMessage::Type.const_get(constant)] = constant
			end

    end

		# given a string (bytes) payload, return a client message
		def parse_client_msg(payload)
			return Jampb::ClientMessage.parse(payload)
		end

    # create a login message using user/pass
    def login_with_user_pass(username, password, options = {})
      login = Jampb::Login.new(:username => username, :password => password, :client_id => options[:client_id])
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN, :route_to => SERVER_TARGET, :login => login)
    end

    # create a login message using token (a cookie or similar)
    def login_with_token(token, options = {})
      login = Jampb::Login.new(:token => token, :client_id => options[:client_id])
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN, :route_to => SERVER_TARGET, :login => login)
    end

    # create a login ack (login was successful)
    def login_ack(public_ip, client_id, token, heartbeat_interval, music_session_id)
      login_ack = Jampb::LoginAck.new(:public_ip => public_ip, :client_id => client_id, :token => token, :heartbeat_interval => heartbeat_interval, :music_session_id => music_session_id)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_ACK, :route_to => CLIENT_TARGET, :login_ack => login_ack)
    end

    # create a music session login message
    def login_music_session(music_session)
      login_music_session = Jampb::LoginMusicSession.new(:music_session => music_session)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION, :route_to => SERVER_TARGET, :login_music_session => login_music_session)
    end

    # create a music session login message ack (success or on failure)
    def login_music_session_ack(error, error_reason)
      login_music_session_ack = Jampb::LoginMusicSessionAck.new(:error => error, :error_reason => error_reason)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION_ACK, :route_to => CLIENT_TARGET, :login_music_session_ack => login_music_session_ack)
    end

    # create a music session 'leave session' message
    def leave_music_session(music_session)
      leave_music_session = Jampb::LeaveMusicSession.new(:music_session => music_session)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION, :route_to => SERVER_TARGET, :leave_music_session => leave_music_session)
    end

    # create a music session leave message ack (success or on failure)
    def leave_music_session_ack(error, error_reason)
      leave_music_session_ack = Jampb::LeaveMusicSessionAck.new(:error => error, :error_reason => error_reason)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION_ACK, :route_to => CLIENT_TARGET, :leave_music_session_ack => leave_music_session_ack)
    end

		# create a server error
    def server_generic_error(error_msg)
      error = Jampb::ServerGenericError.new(:error_msg => error_msg)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_GENERIC_ERROR, :route_to => CLIENT_TARGET, :server_generic_error => error)
    end

		# create a server rejection error
    def server_rejection_error(error_msg)
      error = Jampb::ServerRejectionError.new(:error_msg => error_msg)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_REJECTION_ERROR, :route_to => CLIENT_TARGET, :server_rejection_error => error)
    end

    # create a server rejection error
    def server_permission_error(original_message_id, error_msg)
      error = Jampb::ServerPermissionError.new(:error_msg => error_msg)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_PERMISSION_ERROR, :route_to => CLIENT_TARGET, :server_permission_error => error, :in_reply_to => original_message_id)
    end

    # create a user-joined session message
    def user_joined_music_session(session_id, user_id, username)
      joined = Jampb::UserJoinedMusicSession.new(:session_id => session_id, :user_id => user_id, :username => username)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::USER_JOINED_MUSIC_SESSION, :route_to => CLIENT_TARGET, :user_joined_music_session => joined)
    end

    # create a user-joined session message
    def user_left_music_session(session_id, user_id, username)
      left = Jampb::UserLeftMusicSession.new(:session_id => session_id, :user_id => user_id, :username => username)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::USER_LEFT_MUSIC_SESSION, :route_to => CLIENT_TARGET, :user_left_music_session => left)
    end

    # create a user-joined session message
    def join_request(session_id, join_request_id, username, text)
      join_request = Jampb::JoinRequest.new(:join_request_id => join_request_id, :username => username, :text => text)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::JOIN_REQUEST, :route_to => SESSION_TARGET_PREFIX + session_id, :join_request => join_request)
    end

		# create a test message to send in session
		def test_session_message(session_id, msg)
			test = Jampb::TestSessionMessage.new(:msg => msg)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::TEST_SESSION_MESSAGE, :route_to => SESSION_TARGET_PREFIX + session_id, :test_session_message => test)
		end

    def session_invitation(receiver_id, invitation_id)
      session_invitation = Jampb::SessionInvitation.new(:invitation => invitation_id)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SESSION_INVITATION, :route_to => USER_TARGET_PREFIX + receiver_id, :session_invitation => session_invitation)
    end

    # create a friend request message
    def friend_request(user_id, name, photo_url, friend_id)
      friend_request = Jampb::FriendRequest.new(:user_id => user_id, :name => name, :photo_url => photo_url, :friend_id => friend_id)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::FRIEND_REQUEST, :route_to => USER_TARGET_PREFIX + friend_id, :friend_request => friend_request)
    end

    # create a friend request acceptance message
    def friend_request_accepted(friend_id, name, photo_url, user_id)
      friend_request_accepted = Jampb::FriendRequestAccepted.new(:friend_id => friend_id, :name => name, :photo_url => photo_url, :user_id => user_id)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::FRIEND_REQUEST_ACCEPTED, :route_to => USER_TARGET_PREFIX + user_id, :friend_request_accepted => friend_request_accepted)
    end

    # create a friend update message
    def friend_update(user_id, online)
      friend = Jampb::FriendUpdate.new(:user_id => user_id, :online => online)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::FRIEND_UPDATE, :route_to => USER_TARGET_PREFIX + user_id, :friend_update => friend)
    end
    ############## P2P CLIENT MESSAGES #################

    # send a request to do a ping
    def ping_request(client_id, from)
      ping_request = Jampb::PingRequest.new()
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::PING_REQUEST, :route_to => CLIENT_TARGET_PREFIX + client_id, :from => from, :ping_request => ping_request)
    end

    # respond to a ping_request with an ack
    def ping_ack(client_id, from)
      ping_ack = Jampb::PingAck.new()
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::PING_ACK, :route_to => CLIENT_TARGET_PREFIX + client_id, :from => from, :ping_ack => ping_ack)
    end

    # create a test message to send in session
    def test_client_message(client_id, from, msg)
      test = Jampb::TestClientMessage.new(:msg => msg)
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::TEST_CLIENT_MESSAGE, :route_to => CLIENT_TARGET_PREFIX + client_id, :from => from, :test_client_message => test)
    end

    ####################################################

    # create a heartbeat
    def heartbeat()
      heartbeat = Jampb::Heartbeat.new
      return Jampb::ClientMessage.new(:type => ClientMessage::Type::HEARTBEAT, :route_to => SERVER_TARGET, :heartbeat => heartbeat)
    end

    # is this message directed to the server?
    def server_directed? msg
       return msg.route_to == MessageFactory::SERVER_TARGET
    end

    # is this message directed to the client?
    def client_directed? msg
       return msg.route_to.start_with? MessageFactory::CLIENT_TARGET_PREFIX
    end

    # is this message directed to a (music) session?
    def session_directed? msg
       return msg.route_to.start_with? MessageFactory::SESSION_TARGET_PREFIX
    end

    # is this message directed to a user?
    def user_directed? msg
       return msg.route_to.start_with? MessageFactory::USER_TARGET_PREFIX
    end

    def extract_session(msg)
      return msg.route_to[MessageFactory::SESSION_TARGET_PREFIX..-1]
    end

		def get_message_type msg
			return @type_values[msg.type]
		end
  end
end