speedy_gcm 0.9.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+.rvmrc

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in speedy_gcm.gemspec
+gemspec
+
+group :development do
+	gem "shoulda"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Amro Mousa, (c) 2011 Brandon Keene, (c) 2012 Sandeep Ghael, (c) 2012 Keith Ballinger
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# Speedy GCM
+
+Speedy GCM sends push notifications to Android devices via Google's [GCM](http://developer.android.com/guide/google/gcm/index.html) (Google Cloud Messaging for Android).
+
+Pull requests are welcome!
+
+# What is this GCM gem more awesome?
+
+- Simple Ruby implementation.
+- No dependencies.
+- Implemented against the JSON based service for GCM.  If you need text/plain support look elsewhere.
+- Validation of your message options.
+- Test coverage
+- Simple way to test your android client from the command line
+
+
+##Installation
+
+    $ gem install speedy_gcm
+
+
+##Requirements
+
+An Android device running 2.2 or newer, its registration token, and a Google account registered for gcm.
+
+Also, make sure 'net/http' and 'net/https' are available:
+
+    require "net/http"
+    require "net/https"
+
+The 'shoulda' gem is required for testing:
+
+    $ gem install 'shoulda'
+
+##Compatibility
+
+Speedy_GCM will work with Rails 3.x & Ruby 1.9x.  It has not been tested on previous versions or Rails or Ruby, and may or may not work with those versions.
+
+
+##Usage
+
+For a Rails app, a good place to put the following would be in config/initializers/speedy_gcm.rb :
+
+    GCM_API_KEY = "YOUR API KEY"
+
+    SpeedyGCM::API.set_account(GCM_API_KEY)
+
+Then, where you want to make a GCM call in your code, create an message_options hash and pass it to send_notification():
+
+    message_options = {
+      :registration_ids => [<array of registration ids>],
+      # optional parameters below.  Read the docs here: http://developer.android.com/guide/google/gcm/gcm.html#send-msg
+      :collapse_key => "foobar",
+      :data => { :score => "3x1" },
+      :delay_while_idle => false,
+      :time_to_live => 1
+    }
+
+    response = SpeedyGCM::API.send_notification(message_options)
+
+    puts response[:code]  # some http response code like 200
+    puts response[:data]  # usually nil is returned
+
+Note:  there are blocking calls in both .set_account() and .send_notification().  You should use an async queue like [Sidekiq](https://github.com/mperham/sidekiq) to ensure a non-blocking code path in your application code, particularly for the .send_notification() call.
+
+
+##Testing
+
+To test, first fill out these variables in test/test_speedy_gcm.rb:
+
+    GCM_API_KEY = "TODO - Fill in with your GCM API Key"
+    TEST_PHONE_GCM_REGISTRATION_ID = "TODO - Fill in with some valid GCM Registration ID"
+
+then run:
+
+    $ ruby test/test_speedy_gcm.rb
+
+##Copyrights
+
+* See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/speedy_gcm/version.rb

@@ -0,0 +1,3 @@
+module SpeedyGCM
+  VERSION = "0.9.0"
+end

data/lib/speedy_gcm.rb

@@ -0,0 +1,85 @@
+require "speedy_gcm/version"
+
+module SpeedyGCM
+
+  # message_options
+  #
+  # :registration_ids
+  #   A string array with the list of devices (registration IDs) receiving the message. It must contain at least 1 and at most 1000 registration IDs. To send a multicast message, you must use JSON. For sending a single message to a single device, you could use a JSON object with just 1 registration id, or plain text (see below). Required.
+  #
+  # :collapse_key
+  #   An arbitrary string (such as "Updates Available") that is used to collapse a group of like messages when the device is offline, so that only the last message gets sent to the client. This is intended to avoid sending too many messages to the phone when it comes back online. Note that since there is no guarantee of the order in which messages get sent, the "last" message may not actually be the last message sent by the application server. See Advanced Topics for more discussion of this topic. Optional, unless you are using the time_to_live parameter—in that case, you must also specify a collapse_key.
+  #
+  # :data
+  #   A JSON object whose fields represents the key-value pairs of the message's payload data. If present, the payload data it will be included in the Intent as application data, with the key being the extra's name. For instance, "data":{"score":"3x1"} would result in an intent extra named score whose value is the string 3x1. There is no limit on the number of key/value pairs, though there is a limit on the total size of the message (4kb). The values could be any JSON object, but we recommend using strings, since the values will be converted to strings in the GCM server anyway. If you want to include objects or other non-string data types (such as integers or booleans), you have to do the conversion to string yourself. Also note that the key cannot be a reserved word (from or any word starting with google.). To complicate things slightly, there are some reserved words (such as collapse_key) that are technically allowed in payload data. However, if the request also contains the word, the value in the request will overwrite the value in the payload data. Hence using words that are defined as field names in this table is not recommended, even in cases where they are technically allowed. Optional.
+  #
+  # :delay_while_idle
+  #   If included, indicates that the message should not be sent immediately if the device is idle. The server will wait for the device to become active, and then only the last message for each collapse_key value will be sent. Optional. The default value is false, and must be a JSON boolean.
+  #
+  # :time_to_live
+  #   How long (in seconds) the message should be kept on GCM storage if the device is offline. Optional (default time-to-live is 4 weeks, and must be set as a JSON number). If you use this parameter, you must also specify a collapse_key.
+
+  class API
+    PUSH_URL = 'https://android.googleapis.com/gcm/send'
+
+    class << self
+
+      def set_account(api_key)
+        @api_key = api_key
+      end
+
+      def send_notification(message_opts)
+        headers = { "Content-Type" => "application/json",
+                    "Authorization" => "key=#{@api_key}" }
+
+        # validate the message options
+        message_validation(message_opts)
+
+        url = URI.parse PUSH_URL
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        resp, dat = http.post(url.path, message_opts.to_json, headers)
+
+        return {:code => resp.code.to_i, :message => dat }
+      end
+
+      private
+      def message_validation(message_opts)
+        # check if message_opts has required info
+        raise ArgumentError, "registration_ids is a required param of the GCM message" unless message_opts.has_key? :registration_ids
+
+        # if you use the delay_while_idle is an included parameter, it must be a boolean
+        if message_opts.has_key? :delay_while_idle
+          raise ArgumentError, "if you include the delay_while_idle parameter, it must be a boolean" unless ( [true, false].include? message_opts[:delay_while_idle])
+        end
+
+        # if you use the time_to_live parameter, you must also include a collapse_key
+        if (message_opts.has_key? :time_to_live) and (!message_opts.has_key? :collapse_key)
+          raise ArgumentError, "if you use the time_to_live parameter, you must also include a collapse_key"
+        end
+
+        # if you use the time_to_live parameter, it should be an integer
+        if message_opts.has_key? :time_to_live
+          raise ArgumentError, "if you use the time_to_live parameter, it should be an integer" unless (message_opts[:time_to_live].is_a? Integer)
+        end
+
+        # registration_ids must contain at least 1 and at most 1000 registration IDs
+        registration_ids = message_opts[:registration_ids]
+        if (registration_ids.length < 1) or (registration_ids.length > 1000)
+          raise ArgumentError, "registration_ids must contain at least 1 and at most 1000 registration IDs"
+        end
+
+        message_opts_json = message_opts.to_json
+
+        if (message_opts_json.to_s.bytesize > 4096)
+          # data must be less than 4kb in length
+          raise StandardError, "the size of the message is over 4kb"
+        end
+      end
+
+    end
+
+  end
+end

data/speedy_gcm.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "speedy_gcm/version"
+
+Gem::Specification.new do |s|
+  s.name        = "speedy_gcm"
+  s.version     = SpeedyGCM::VERSION
+  s.authors     = ["Sandeep Ghael"]
+  s.email       = ["sghael@ravidapp.com"]
+  s.homepage    = "https://github.com/sghael/speedy_gcm"
+  s.summary     = %q{Speedy GCM is an intelligent gem for sending push notifications to Android devices via GCM.}
+  s.description = %q{Speedy GCM efficiently sends push notifications to Android devices via GCM (Google Cloud Messaging).}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'speedy_gcm'
+
+class Test::Unit::TestCase
+end

data/test/test_speedy_gcm.rb

@@ -0,0 +1,178 @@
+current_dir = File.expand_path(File.dirname(__FILE__))
+require File.join(current_dir, 'helper')
+
+require 'json'
+require "net/http"
+require "net/https"
+
+class TestSpeedyGCM < Test::Unit::TestCase
+
+  GCM_API_KEY = "TODO - Fill in with your GCM API Key"
+  TEST_PHONE_GCM_REGISTRATION_ID = "TODO - Fill in with some GCM Registration ID"
+
+  should "not raise an error if the API key is valid" do
+    assert_nothing_raised do
+      SpeedyGCM::API.set_account(GCM_API_KEY)
+    end
+  end
+
+  should "raise an error if the api key is not provided" do
+    assert_raise(ArgumentError) do
+      SpeedyGCM::API.set_account()
+    end
+  end
+
+  should "raise an error if the registration_ids are not provided" do
+    SpeedyGCM::API.set_account(GCM_API_KEY)
+
+    assert_raise(ArgumentError) do
+      message_options = {}
+      # message_options.merge!({ :registration_ids => [1,2] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :delay_while_idle => true })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+  end
+
+  should "raise an error if the time_to_live is provided but collapse_key is not" do
+    SpeedyGCM::API.set_account(GCM_API_KEY)
+
+    assert_raise(ArgumentError) do
+      message_options = {}
+      message_options.merge!({ :registration_ids => [1,2] })
+      # message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :delay_while_idle => true })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+  end
+
+  should "raise an error if the time_to_live is provided but it is not an integer" do
+    SpeedyGCM::API.set_account(GCM_API_KEY)
+
+    assert_raise(ArgumentError) do
+      message_options = {}
+      message_options.merge!({ :registration_ids => [1,2] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :time_to_live => "a" })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+
+    assert_nothing_raised do
+      message_options = {}
+      message_options.merge!({ :registration_ids => [1,2] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+  end
+
+  should "check that delay_while_idle is a boolean if provided" do
+    SpeedyGCM::API.set_account(GCM_API_KEY)
+
+    assert_raise(ArgumentError) do
+      message_options = {}
+      message_options.merge!({ :registration_ids => [1,2] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :delay_while_idle => nil })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+
+    assert_nothing_raised do
+      message_options = {}
+      message_options.merge!({ :registration_ids => [1,2] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :delay_while_idle => true })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+
+    assert_nothing_raised do
+      message_options = {}
+      message_options.merge!({ :registration_ids => [1,2] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :delay_while_idle => false })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+  end
+
+  should "raise error if registration_ids contain no registration IDs" do
+    SpeedyGCM::API.set_account(GCM_API_KEY)
+
+    assert_raise(ArgumentError) do
+      message_options = {}
+      message_options.merge!({ :registration_ids => [] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+  end
+
+  should "raise error if registration_ids contains more than 1000 registration IDs" do
+    assert_raise(ArgumentError) do
+      SpeedyGCM::API.set_account(GCM_API_KEY)
+
+      reg_ids = *(1..1001)
+
+      message_options = {}
+      message_options.merge!({ :registration_ids => reg_ids })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+  end
+
+  should "not raise an error if a send notification call succeeds" do
+    assert_nothing_raised do
+      SpeedyGCM::API.set_account(GCM_API_KEY)
+
+      message_options = {}
+      message_options.merge!({ :registration_ids => [1] })
+      message_options.merge!({ :collapse_key => "foobar" })
+      message_options.merge!({ :data => { :score => "3x1" } })
+      message_options.merge!({ :time_to_live => 1 })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+    end
+  end
+
+  should "not raise an error and send a message with a success response" do
+    assert_nothing_raised do
+      SpeedyGCM::API.set_account(GCM_API_KEY)
+
+      message_options = {}
+      message_options.merge!({ :registration_ids => [TEST_PHONE_GCM_REGISTRATION_ID] })
+      message_options.merge!({ :collapse_key => Time.now.to_s })
+      message_options.merge!({ :data => { :vmr_id => "3" } })
+
+      response = SpeedyGCM::API.send_notification(message_options)
+
+      assert response[:code].eql? 200
+
+      # puts response[:code]
+      # puts response[:message]
+    end
+  end
+
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: speedy_gcm
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- Sandeep Ghael
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-01 00:00:00.000000000 Z
+dependencies: []
+description: Speedy GCM efficiently sends push notifications to Android devices via
+  GCM (Google Cloud Messaging).
+email:
+- sghael@ravidapp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/speedy_gcm.rb
+- lib/speedy_gcm/version.rb
+- speedy_gcm.gemspec
+- test/helper.rb
+- test/test_speedy_gcm.rb
+homepage: https://github.com/sghael/speedy_gcm
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Speedy GCM is an intelligent gem for sending push notifications to Android
+  devices via GCM.
+test_files:
+- test/helper.rb
+- test/test_speedy_gcm.rb