fcm-ruby-push-notifications 1.2.0

data/lib/ruby-push-notifications/apns/apns_notification.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+module RubyPushNotifications
+  module APNS
+    # Represents a APNS Notification.
+    # Manages the conversion of the notification to APNS binary format for
+    # each of the destinations.
+    # By default sets maximum expiration date (4 weeks).
+    #
+    # @author Carlos Alonso
+    class APNSNotification
+      include RubyPushNotifications::NotificationResultsManager
+
+      # @private. 4 weeks in seconds
+      WEEKS_4 = 2419200
+
+      # Initializes the APNS Notification
+      #
+      # @param [Array]. Array containing all destinations for the notification
+      # @param [Hash]. Hash with the data to use as payload.
+      def initialize(tokens, data)
+        @tokens = tokens
+        @data = data
+      end
+
+      # Method that yields the notification's binary for each of the receivers.
+      #
+      # @param starting_id [Integer]. Every notification encodes a unique ID for
+      #   further reference. This parameter represents the first id the first
+      #   notification of this group should use.
+      # @yieldparam [String]. APNS binary's representation of this notification.
+      #   Consisting of:
+      #     Notification = 2(1), FrameLength(4), items(FrameLength)
+      #     Item = ItemID(1), ItemLength(2), data(ItemLength)
+      #     Items:
+      #       Device Token => Id: 1, length: 32, data: binary device token
+      #       Payload => Id: 2, length: ??, data: json formatted payload
+      #       Notification ID => Id: 3, length: 4, data: notif id as int
+      #       Expiration Date => Id: 4, length: 4, data: Unix timestamp as int
+      #       Priority => Id: 5, length: 1, data: 10 as 1 byte int
+      # (https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW4)
+      def each_message(starting_id)
+        @tokens.each_with_index do |token, i|
+          bytes = device_token(token) + payload + notification_id(starting_id + i) + expiration_date + priority
+          yield [2, bytes.bytesize, bytes].pack 'cNa*'
+        end
+      end
+
+      # @return [Integer]. The number of binaries this notification will send.
+      #    One for each receiver.
+      def count
+        @tokens.count
+      end
+
+      private
+
+      # @param [String]. The device token to encode.
+      # @return [String]. Binary representation of the device token field.
+      def device_token(token)
+        [1, 32, token].pack 'cnH64'
+      end
+
+      # Generates the APNS's binary representation of the notification's payload.
+      # Caches the value in an instance variable.
+      #
+      # @return [String]. Binary representation of the notification's payload.
+      def payload
+        @encoded_payload ||= -> {
+            json = (@data.respond_to?(:to_json) ? @data.to_json : JSON.dump(@data)).force_encoding 'ascii-8bit'
+            [2, json.bytesize, json].pack 'cna*'
+          }.call
+      end
+
+      # @param [Integer]. The unique ID for this notification.
+      # @return [String]. Binary representation of the notification id field.
+      def notification_id(id)
+        [3, 4, id].pack 'cnN'
+      end
+
+      # @return [String]. Binary representation of the expiration date field.
+      def expiration_date
+        [4, 4, (Time.now + WEEKS_4).to_i].pack 'cnN'
+      end
+
+      # @return [String]. Binary representation of the priority field.
+      def priority
+        [5, 1, 10].pack 'cnc'
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/apns/apns_pusher.rb

@@ -0,0 +1,84 @@
+
+module RubyPushNotifications
+  module APNS
+    # This class coordinates the process of sending notifications.
+    # It takes care of reopening closed APNSConnections and seeking back to
+    # the failed notification to keep writing.
+    #
+    # Remember that APNS doesn't confirm successful notification, it just
+    # notifies when one went wrong and closes the connection. Therefore, this
+    # APNSPusher reconnects and rewinds the array until the notification that
+    # Apple rejected.
+    #
+    # @author Carlos Alonso
+    class APNSPusher
+
+      # @param certificate [String]. The PEM encoded APNS certificate.
+      # @param sandbox [Boolean]. Whether the certificate is an APNS sandbox or not.
+      # @param options [Hash] optional. Options for APNSPusher. Currently supports:
+      #   * host [String]: Hostname of the APNS environment. Defaults to the official APNS hostname.
+      #   * connect_timeout [Integer]: Number of seconds to wait for the connection to open. Defaults to 30.
+      def initialize(certificate, sandbox, password = nil, options = {})
+        @certificate = certificate
+        @pass = password
+        @sandbox = sandbox
+        @options = options
+      end
+
+      # Pushes the notifications.
+      # Builds an array with all the binaries (one for each notification and receiver)
+      # and pushes them sequentially to APNS monitoring the response.
+      # If an error is received, the connection is reopened and the process
+      # continues at the next notification after the failed one (pointed by the response error)
+      #
+      # For each notification assigns an array with the results of each submission.
+      #
+      # @param notifications [Array]. All the APNSNotifications to be sent.
+      def push(notifications)
+        conn = APNSConnection.open @certificate, @sandbox, @pass, @options
+
+        binaries = notifications.each_with_object([]) do |notif, binaries|
+          notif.each_message(binaries.count) do |msg|
+            binaries << msg
+          end
+        end
+
+        results = []
+        i = 0
+        while i < binaries.count
+          conn.write binaries[i]
+
+          if i == binaries.count-1
+            conn.flush
+            rs, = IO.select([conn], nil, nil, 2)
+          else
+            rs, = IO.select([conn], [conn])
+          end
+          if rs && rs.any?
+            packed = rs[0].read 6
+            if packed.nil? && i == 0
+              # The connection wasn't properly open
+              # Probably because of wrong certificate/sandbox? combination
+              results << UNKNOWN_ERROR_STATUS_CODE
+            else
+              err = packed.unpack 'ccN'
+              results.slice! err[2]..-1
+              results << err[1]
+              i = err[2]
+              conn = APNSConnection.open @certificate, @sandbox, @pass, @options
+            end
+          else
+            results << NO_ERROR_STATUS_CODE
+          end
+          i += 1
+        end
+
+        conn.close
+
+        notifications.each do |notif|
+          notif.results = APNSResults.new(results.slice! 0, notif.count)
+        end
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/apns/apns_results.rb

@@ -0,0 +1,30 @@
+module RubyPushNotifications
+  module APNS
+    # This class is responsible for holding and
+    # managing result of a pushed notification.
+    #
+    # @author Carlos Alonso
+    class APNSResults
+
+      # @return [Array] of each destination's individual result.
+      attr_reader :individual_results
+
+      # Initializes the result
+      #
+      # @param [Array] containing each destination's individual result.
+      def initialize(results)
+        @individual_results = results
+      end
+
+      # @return [Integer] numer of successfully pushed notifications
+      def success
+        @success ||= individual_results.count { |r| r == NO_ERROR_STATUS_CODE }
+      end
+
+      # @return [Integer] number of failed notifications
+      def failed
+        @failed ||= individual_results.count { |r| r != NO_ERROR_STATUS_CODE }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'ruby-push-notifications/fcm/fcm_request'
+require 'ruby-push-notifications/fcm/fcm_connection'
+require 'ruby-push-notifications/fcm/fcm_notification'
+require 'ruby-push-notifications/fcm/fcm_pusher'
+require 'ruby-push-notifications/fcm/fcm_response'
+require 'ruby-push-notifications/fcm/fcm_error'
+require 'ruby-push-notifications/fcm/fcm_result'
+

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

@@ -0,0 +1,60 @@
+require 'uri'
+require 'net/https'
+
+require 'httparty'
+require 'cgi'
+require 'json'
+
+module RubyPushNotifications
+  module FCM
+    # Encapsulates a connection to the FCM service
+    # Responsible for final connection with the service.
+    #
+    # @author Carlos Alonso
+    class FCMConnection
+
+      # @private The URL of the Android FCM endpoint
+      FCM_URL = 'https://fcm.googleapis.com/fcm'
+
+      # @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'
+      GROUP_NOTIFICATION_BASE_URI = 'https://android.googleapis.com/gcm'
+
+      # Issues a POST request to the FCM send endpoint to
+      # submit the given notifications.
+      #
+      # @param notification [String]. The text to POST
+      # @param key [String]. The FCM sender id to use
+      #    (https://developer.android.com/google/gcm/gcm.html#senderid)
+      # @return [FCMResponse]. The FCMResponse that encapsulates the received response
+      def self.post(notification, key)
+        headers = {
+            CONTENT_TYPE_HEADER => JSON_CONTENT_TYPE,
+            AUTHORIZATION_HEADER => "key=#{key}"
+        }
+        # TODO: remove to_json if causing error
+        params = {
+          body: notification.to_json,
+          headers: {
+            AUTHORIZATION_HEADER => "key=#{key}",
+            CONTENT_TYPE_HEADER => JSON_CONTENT_TYPE
+          }
+        }
+
+        fcm_request = FCMRequest.new(params)
+        response = fcm_request.make_request
+        # puts '*' * 10
+        # puts response
+        # puts '*' * 10
+        FCMResponse.new response.code.to_i, response.body
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+
+module RubyPushNotifications
+  module FCM
+    # Base class for all FCM related errors
+    #
+    # @author Carlos Alonso
+    class FCMError < StandardError ; end
+
+    class MalformedFCMJSONError < FCMError ; end
+
+    class FCMAuthError < FCMError ; end
+
+    class FCMInternalError < FCMError ; end
+
+    class UnexpectedFCMResponseError < FCMError ; end
+  end
+end

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

@@ -0,0 +1,31 @@
+
+module RubyPushNotifications
+  module FCM
+    # 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 FCMNotification
+      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_fcm_json
+        JSON.dump(
+          registration_ids: @registration_ids,
+          data: @data
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+
+module RubyPushNotifications
+  module FCM
+
+    # This class is responsible for sending notifications to the FCM service.
+    #
+    # @author Carlos Alonso
+    class FCMPusher
+
+      # Initializes the FCMPusher
+      #
+      # @param key [String]. FCM sender id to use
+      def initialize(key)
+        @key = key
+      end
+
+      # Actually pushes the given notifications.
+      # Assigns every notification an array with the result of each
+      # individual notification.
+      #
+      # @param notifications [Array]. Array of FCMNotification to send.
+      def push(notifications)
+        notifications.each do |notif|
+          notif.results = FCMConnection.post notif.as_fcm_json, @key
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'httparty'
+require 'cgi'
+require 'json'
+
+module RubyPushNotifications
+  module FCM
+    # Encapsulates a connection to the FCM service
+    # Responsible for final connection with the service.
+    #
+    # @author Carlos Alonso
+    class FCMRequest
+      include HTTParty
+      default_timeout 30
+      format :json
+
+      base_uri 'https://fcm.googleapis.com/fcm'
+
+      def initialize(params = {})
+        @params = params
+      end
+      def make_request
+        puts '********** make_request *************'
+        puts @params
+        response = self.class.post('/send', @params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+
+module RubyPushNotifications
+  module FCM
+
+    # This class encapsulates a response received from the FCM service
+    # and helps parsing and understanding the received meesages/codes.
+    #
+    # @author Carlos Alonso
+    class FCMResponse
+
+      # @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 MalformedFCMJSONError, body
+        when 401
+          raise FCMAuthError, body
+        when 500..599
+          raise FCMInternalError, body
+        else
+          raise UnexpectedFCMResponseError, code
+        end
+      end
+
+      def ==(other)
+        (other.is_a?(FCMResponse) &&
+          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| fcm_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 fcm_result_for(result)
+        if canonical_id = result[:registration_id]
+          FCMCanonicalIDResult.new canonical_id
+        elsif error = result[:error]
+          FCMResultError.new error
+        else
+          FCMResultOK.new
+        end
+      end
+    end
+  end
+end