fcm-ruby-push-notifications 1.2.0

data/lib/ruby-push-notifications/fcm/fcm_result.rb

@@ -0,0 +1,52 @@
+
+module RubyPushNotifications
+  module FCM
+    # Class that encapsulates the result of a single sent notification to a single
+    # Registration ID
+    # (https://developer.android.com/google/gcm/server-ref.html#table4)
+    # @author Carlos Alonso
+    class FCMResult ; end
+
+    # Indicates that the notification was successfully sent to the corresponding
+    # registration ID
+    class FCMResultOK < FCMResult
+
+      def ==(other)
+        other.is_a?(FCMResultOK) || super(other)
+      end
+    end
+
+    # Indicates that the notification was successfully sent to the corresponding
+    # registration ID but GCM sent a canonical ID for it, so the received canonical
+    # ID should be used as registration ID ASAP.
+    class FCMCanonicalIDResult < FCMResult
+
+      # @return [String]. The suggested canonical ID from GCM
+      attr_reader :canonical_id
+
+      def initialize(canonical_id)
+        @canonical_id = canonical_id
+      end
+
+      def ==(other)
+        (other.is_a?(FCMCanonicalIDResult) && @canonical_id == other.canonical_id) ||
+        super(other)
+      end
+    end
+
+    # An error occurred sending the notification to the registration ID.
+    class FCMResultError < FCMResult
+
+      # @return [String]. The error sent by GCM
+      attr_accessor :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def ==(other)
+        (other.is_a?(FCMResultError) && @error == other.error) || super(other)
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm.rb

@@ -0,0 +1,6 @@
+require 'ruby-push-notifications/gcm/gcm_connection'
+require 'ruby-push-notifications/gcm/gcm_notification'
+require 'ruby-push-notifications/gcm/gcm_pusher'
+require 'ruby-push-notifications/gcm/gcm_response'
+require 'ruby-push-notifications/gcm/gcm_error'
+require 'ruby-push-notifications/gcm/gcm_result'

data/lib/ruby-push-notifications/gcm/gcm_connection.rb

@@ -0,0 +1,54 @@
+require 'uri'
+require 'net/https'
+
+module RubyPushNotifications
+  module GCM
+    # Encapsulates a connection to the GCM service
+    # Responsible for final connection with the service.
+    #
+    # @author Carlos Alonso
+    class GCMConnection
+
+      # @private The URL of the Android GCM endpoint
+      GCM_URL = 'https://android.googleapis.com/gcm/send'
+
+      # @private Content-Type HTTP Header string
+      CONTENT_TYPE_HEADER  = 'Content-Type'
+
+      # @private Application/JSON content type
+      JSON_CONTENT_TYPE    = 'application/json'
+
+      # @private Authorization HTTP Header String
+      AUTHORIZATION_HEADER = 'Authorization'
+
+      # Issues a POST request to the GCM send endpoint to
+      # submit the given notifications.
+      #
+      # @param notification [String]. The text to POST
+      # @param key [String]. The GCM sender id to use
+      #    (https://developer.android.com/google/gcm/gcm.html#senderid)
+      # @param options [Hash] optional. Options for #post. Currently supports:
+      #   * url [String]: URL of the GCM endpoint. Defaults to the official GCM URL.
+      #   * open_timeout [Integer]: Number of seconds to wait for the connection to open. Defaults to 30.
+      #   * read_timeout [Integer]: Number of seconds to wait for one block to be read. Defaults to 30.
+      # @return [GCMResponse]. The GCMResponse that encapsulates the received response
+      def self.post(notification, key, options = {})
+        headers = {
+            CONTENT_TYPE_HEADER => JSON_CONTENT_TYPE,
+            AUTHORIZATION_HEADER => "key=#{key}"
+        }
+
+        url = URI.parse options.fetch(:url, GCM_URL)
+        http = Net::HTTP.new url.host, url.port
+        http.use_ssl = url.scheme == 'https'
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http.open_timeout = options.fetch(:open_timeout, 30)
+        http.read_timeout = options.fetch(:read_timeout, 30)
+
+        response = http.post url.path, notification, headers
+
+        GCMResponse.new response.code.to_i, response.body
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_error.rb

@@ -0,0 +1,17 @@
+
+module RubyPushNotifications
+  module GCM
+    # Base class for all GCM related errors
+    #
+    # @author Carlos Alonso
+    class GCMError < StandardError ; end
+
+    class MalformedGCMJSONError < GCMError ; end
+
+    class GCMAuthError < GCMError ; end
+
+    class GCMInternalError < GCMError ; end
+
+    class UnexpectedGCMResponseError < GCMError ; end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_notification.rb

@@ -0,0 +1,31 @@
+
+module RubyPushNotifications
+  module GCM
+    # Encapsulates a GCM Notification.
+    # By default only Required fields are set.
+    # (https://developer.android.com/google/gcm/server-ref.html#send-downstream)
+    #
+    # @author Carlos Alonso
+    class GCMNotification
+      include RubyPushNotifications::NotificationResultsManager
+
+      # Initializes the notification
+      #
+      # @param [Array]. Array with the receiver's GCM registration ids.
+      # @param [Hash]. Payload to send.
+      def initialize(registration_ids, data)
+        @registration_ids = registration_ids
+        @data = data
+      end
+
+      # @return [String]. The GCM's JSON format for the payload to send.
+      #    (https://developer.android.com/google/gcm/server-ref.html#send-downstream)
+      def as_gcm_json
+        JSON.dump(
+          registration_ids: @registration_ids,
+          data: @data
+        )
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_pusher.rb

@@ -0,0 +1,35 @@
+
+module RubyPushNotifications
+  module GCM
+
+    # This class is responsible for sending notifications to the GCM service.
+    #
+    # @author Carlos Alonso
+    class GCMPusher
+
+      # Initializes the GCMPusher
+      #
+      # @param key [String]. GCM sender id to use
+      #   ((https://developer.android.com/google/gcm/gcm.html#senderid))
+      # @param options [Hash] optional. Options for GCMPusher. Currently supports:
+      #   * url [String]: URL of the GCM endpoint. Defaults to the official GCM URL.
+      #   * open_timeout [Integer]: Number of seconds to wait for the connection to open. Defaults to 30.
+      #   * read_timeout [Integer]: Number of seconds to wait for one block to be read. Defaults to 30.
+      def initialize(key, options = {})
+        @key = key
+        @options = options
+      end
+
+      # Actually pushes the given notifications.
+      # Assigns every notification an array with the result of each
+      # individual notification.
+      #
+      # @param notifications [Array]. Array of GCMNotification to send.
+      def push(notifications)
+        notifications.each do |notif|
+          notif.results = GCMConnection.post notif.as_gcm_json, @key, @options
+        end
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_response.rb

@@ -0,0 +1,89 @@
+
+module RubyPushNotifications
+  module GCM
+
+    # This class encapsulates a response received from the GCM service
+    # and helps parsing and understanding the received meesages/codes.
+    #
+    # @author Carlos Alonso
+    class GCMResponse
+
+      # @return [Integer] the number of successfully sent notifications
+      attr_reader :success
+
+      # @return [Integer] the number of failed notifications
+      attr_reader :failed
+
+      # @return [Integer] the number of received canonical IDS
+      #    (https://developer.android.com/google/gcm/server-ref.html#table4)
+      attr_reader :canonical_ids
+
+      # @return [Array] Array of a GCMResult for every receiver of the notification
+      #   sent indicating the result of the operation.
+      attr_reader :results
+      alias_method :individual_results, :results
+
+      # Initializes the GCMResponse and runs response parsing
+      #
+      # @param code [Integer]. The HTTP status code received
+      # @param body [String]. The response body received.
+      # @raise MalformedGCMJsonError if code == 400 Bad Request
+      # @raise GCMAuthError if code == 401 Unauthorized
+      # @raise GCMInternalError if code == 5xx
+      # @raise UnexpectedGCMResponseError if code != 200
+      def initialize(code, body)
+        case code
+        when 200
+          parse_response body
+        when 400
+          raise MalformedGCMJSONError, body
+        when 401
+          raise GCMAuthError, body
+        when 500..599
+          raise GCMInternalError, body
+        else
+          raise UnexpectedGCMResponseError, code
+        end
+      end
+
+      def ==(other)
+        (other.is_a?(GCMResponse) &&
+          success == other.success &&
+          failed == other.failed &&
+          canonical_ids == other.canonical_ids &&
+          results == other.results) || super(other)
+      end
+
+      private
+
+      # Parses the response extracting counts for successful, failed and
+      # containing canonical ID messages.
+      # Also creates the results array assigning a GCMResult subclass for each
+      # registration ID the notification was sent to.
+      #
+      # @param body [String]. The response body
+      def parse_response(body)
+        json = JSON.parse body, symbolize_names: true
+        @success = json[:success]
+        @failed = json[:failure]
+        @canonical_ids = json[:canonical_ids]
+        @results = (json[:results] || []).map { |result| gcm_result_for result }
+      end
+
+      # Factory method that, for each GCM result object assigns a GCMResult
+      # subclass.
+      #
+      # @param result [Hash]. GCM Result parsed hash
+      # @return [GCMResult]. Corresponding GCMResult subclass
+      def gcm_result_for(result)
+        if canonical_id = result[:registration_id]
+          GCMCanonicalIDResult.new canonical_id
+        elsif error = result[:error]
+          GCMResultError.new error
+        else
+          GCMResultOK.new
+        end
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_result.rb

@@ -0,0 +1,52 @@
+
+module RubyPushNotifications
+  module GCM
+    # Class that encapsulates the result of a single sent notification to a single
+    # Registration ID
+    # (https://developer.android.com/google/gcm/server-ref.html#table4)
+    # @author Carlos Alonso
+    class GCMResult ; end
+
+    # Indicates that the notification was successfully sent to the corresponding
+    # registration ID
+    class GCMResultOK < GCMResult
+
+      def ==(other)
+        other.is_a?(GCMResultOK) || super(other)
+      end
+    end
+
+    # Indicates that the notification was successfully sent to the corresponding
+    # registration ID but GCM sent a canonical ID for it, so the received canonical
+    # ID should be used as registration ID ASAP.
+    class GCMCanonicalIDResult < GCMResult
+
+      # @return [String]. The suggested canonical ID from GCM
+      attr_reader :canonical_id
+
+      def initialize(canonical_id)
+        @canonical_id = canonical_id
+      end
+
+      def ==(other)
+        (other.is_a?(GCMCanonicalIDResult) && @canonical_id == other.canonical_id) ||
+        super(other)
+      end
+    end
+
+    # An error occurred sending the notification to the registration ID.
+    class GCMResultError < GCMResult
+
+      # @return [String]. The error sent by GCM
+      attr_accessor :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def ==(other)
+        (other.is_a?(GCMResultError) && @error == other.error) || super(other)
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/mpns.rb

@@ -0,0 +1,5 @@
+require 'ruby-push-notifications/mpns/mpns_connection'
+require 'ruby-push-notifications/mpns/mpns_notification'
+require 'ruby-push-notifications/mpns/mpns_pusher'
+require 'ruby-push-notifications/mpns/mpns_response'
+require 'ruby-push-notifications/mpns/mpns_result'

data/lib/ruby-push-notifications/mpns/mpns_connection.rb

@@ -0,0 +1,87 @@
+require 'uri'
+require 'net/https'
+
+module RubyPushNotifications
+  module MPNS
+    # Encapsulates a connection to the MPNS service
+    # Responsible for final connection with the service.
+    #
+    class MPNSConnection
+
+      # @private Content-Type HTTP Header string
+      CONTENT_TYPE_HEADER  = 'Content-Type'
+
+      # @private text/xml content type
+      X_NOTIFICATION_CLASS = 'X-NotificationClass'
+
+      # @private Windows Phone Target
+      X_WINDOWSPHONE_TARGET = 'X-WindowsPhone-Target'
+
+      # @private text/xml content type
+      XML_CONTENT_TYPE     = 'text/xml'
+
+      # @private Enumators for notification types
+      BASEBATCH = { tile: 1, toast: 2, raw: 3 }
+
+      # @private Enumators for delay
+      BATCHADDS = { delay450: 10, delay900: 20 }
+
+      # @private Windows Phone Target Types
+      WP_TARGETS = { toast: 'toast', tile: 'token' }
+
+      # Issues a POST request to the MPNS send endpoint to
+      # submit the given notifications.
+      #
+      # @param n [MPNSNotification]. The notification object to POST
+      # @param cert [String] optional. Contents of the PEM encoded certificate.
+      # @param options [Hash] optional. Options for GCMPusher. Currently supports:
+      #   * open_timeout [Integer]: Number of seconds to wait for the connection to open. Defaults to 30.
+      #   * read_timeout [Integer]: Number of seconds to wait for one block to be read. Defaults to 30.
+      # @return [Array]. The response of post
+      # (http://msdn.microsoft.com/pt-br/library/windows/apps/ff941099)
+      def self.post(n, cert = nil, options = {})
+        headers = build_headers(n.data[:type], n.data[:delay])
+        body = n.as_mpns_xml
+        responses = []
+        n.each_device do |url|
+          http = Net::HTTP.new url.host, url.port
+          http.open_timeout = options.fetch(:open_timeout, 30)
+          http.read_timeout = options.fetch(:read_timeout, 30)
+          if cert && url.scheme == 'https'
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = cert
+          end
+          response = http.post url.path, body, headers
+          responses << { device_url: url.to_s, headers: extract_headers(response), code: response.code.to_i }
+        end
+        MPNSResponse.new responses
+      end
+
+      # Build Header based on type and delay
+      #
+      # @param type [Symbol]. The type of notification
+      # @param delay [Symbol]. The delay to be used
+      # @return [Hash]. Correct delay based on notification type
+      def self.build_headers(type, delay)
+        headers = {
+          CONTENT_TYPE_HEADER => XML_CONTENT_TYPE,
+          X_NOTIFICATION_CLASS => "#{(BASEBATCH[type] + (BATCHADDS[delay] || 0))}"
+        }
+        headers[X_WINDOWSPHONE_TARGET] = WP_TARGETS[type] unless type == :raw
+        headers
+      end
+
+      # Extract headers from response
+      # @param response [Net::HTTPResponse]. HTTP response for request
+      #
+      # @return [Hash]. Hash with headers with case-insensitive keys and string values
+      def self.extract_headers(response)
+        headers = {}
+        response.each_header { |k, v| headers[k] = v }
+        headers
+      end
+
+    end
+  end
+end

data/lib/ruby-push-notifications/mpns/mpns_notification.rb

@@ -0,0 +1,94 @@
+require 'builder'
+
+module RubyPushNotifications
+  module MPNS
+    # Encapsulates a MPNS Notification.
+    # Actually support for raw, toast, tiles notifications
+    # (http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh202945)
+    #
+    class MPNSNotification
+      include RubyPushNotifications::NotificationResultsManager
+
+      # @return [Hash]. Payload to send.
+      #   Toast :title => a bold message
+      #     :message => the small message
+      #     :param => a string parameter that is passed to the app
+      #   Tile :image => a new image for the tile
+      #     :count => a number to show on the tile
+      #     :title => the new title of the tile
+      #     :back_image => an image for the back of the tile
+      #     :back_title => a title on the back of the tile
+      #     :back_content => some content (text) for the back
+      #   Raw :message => the full Hash message body
+      attr_reader :data
+
+      # @return [Array]. Array with the receiver's MPNS device URLs.
+      attr_reader :device_urls
+
+      # Initializes the notification
+      #
+      # @param [Array]. Array with the receiver's device urls.
+      # @param [Hash]. Payload to send.
+      #   Toast :title => a bold message
+      #     :message => the small message
+      #     :param => a string parameter that is passed to the app
+      #   Tile :image => a new image for the tile
+      #     :count => a number to show on the tile
+      #     :title => the new title of the tile
+      #     :back_image => an image for the back of the tile
+      #     :back_title => a title on the back of the tile
+      #     :back_content => some content (text) for the back
+      #   Raw :message => the full XML message body
+      def initialize(device_urls, data)
+        @device_urls = device_urls
+        @data = data
+        @data[:type] ||= :raw
+      end
+
+
+      # @return [String]. The GCM's XML format for the payload to send.
+      # (http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh202945)
+      def as_mpns_xml
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        if data[:type] != :raw
+          xml.tag!('wp:Notification', 'xmlns:wp' => 'WPNotification') do
+            case data[:type]
+            when :toast
+              xml.tag!('wp:Toast') do
+                xml.tag!('wp:Text1') { xml.text!(data[:title]) }
+                xml.tag!('wp:Text2') { xml.text!(data[:message]) }
+                xml.tag!('wp:Param') { xml.text!(data[:param]) } if data[:param]
+              end
+            when :tile
+              xml.tag!('wp:Tile') do
+                xml.tag!('wp:BackgroundImage') { xml.text!(data[:image]) } if data[:image]
+                xml.tag!('wp:Count') { xml.text!(data[:count].to_s) } if data[:count]
+                xml.tag!('wp:Title') { xml.text!(data[:title]) } if data[:title]
+                xml.tag!('wp:BackBackgroundImage') { xml.text!(data[:back_image]) } if data[:back_image]
+                xml.tag!('wp:BackTitle') { xml.text!(data[:back_title]) } if data[:back_title]
+                xml.tag!('wp:BackContent') { xml.text!(data[:back_content]) } if data[:back_content]
+              end
+            end
+          end
+        else
+          xml.root { build_hash(xml, data[:message]) }
+        end
+        xml.target!
+      end
+
+      def each_device
+        @device_urls.each do |url|
+          yield(URI.parse url)
+        end
+      end
+
+      def build_hash(xml, options)
+        options.each do |k, v|
+          xml.tag!(k.to_s) { v.is_a?(Hash) ? build_hash(xml, v) : xml.text!(v.to_s) }
+        end
+      end
+
+    end
+  end
+end