glass 0.0.1.1 → 0.0.1.2

data/README.md

@@ -4,6 +4,12 @@ This Gem is meant to help you quickly building application for Google Glass than
 
 This is totally a beginning. Nothing is done.
 
+This gem is using google/api-client.
+
+If you think google/api-client is b***s*** this gem is what you need.
+
+This gem is using Redis to store clients credentials.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -20,7 +26,105 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Setup Credential
+
+```ruby
+require 'glass'
+Glass::Mirror.client_id = ENV['GLASS_CLIENT_ID']
+Glass::Mirror.client_secret = ENV['GLASS_CLIENT_SECRET']
+Glass::Mirror.redirect_uri = ENV['GLASS_REDIRECT_URI']
+Glass::Mirror.scopes = [ Add requested scopes]
+    # Default is 'https://www.googleapis.com/auth/drive.file',
+    #            'https://www.googleapis.com/auth/userinfo.profile',
+```
+
+You are a Glassware Explorer Now !
+Get a way to get the authorization code from user app install. I don't know how for now. If you find let me know !
+And do the OAuth trick
+```ruby
+ok_glass = Glass::Mirror.build_with_code(authorization_code)
+```
+### Token Persistence
+
+As in OAuth2.0, Google API issue a Refresh_Token the first time you Authorize the client, so you can get new token later.
+You need to store this token. Out of the box Glass's Gem use Redis to do it.
+
+Glass use a namespace on your redis. So don't bother about this (even if you can specify one too).
+
+By default, Glass use local redis store (localhost:6379).
+
+You can specify the Redis store this way :
+
+For Heroku/RedisToGo users
+
+```ruby
+Glass::Mirror.redis = ENV["REDISTOGO_URL"]
+```
+
+
+## Overview
+
+### Timeline
+
+Let's say you want to tell "Hi" to the user.
+Build it and send it.
+
+```ruby
+item = Glass::TimelineItem.new()
+item.text="Hi"
+ok_glass.insert(item)
+```
+
+### Subscriptions
+
+Let's say you want to subscribe to location update.
+You need to provide a call_back_url, on wich Google will post the datas.
+
+```ruby
+subscription = Glass::Subscription.new()
+subscription.collection="location"
+subscription.call_back_url="https://glassware.herokuapp.com/location_update"
+ok_glass.insert(subscription)
+```
+
+### Location
+
+There is a quicker way to get Location update
+```ruby
+Glass::Location.subscribe(ok_glass,call_back_url)
+```
+
+
+
+## Going Further
+
+As you are a Glassware Explorer you can explore yourself. Access the google/api-client Client this way :
+```ruby
+ok_glass.client   # Get the discovered Google::API on wich you can make request
+```
+
+Have fun ! And please, show me any use. Just send me a tweet : @TheDamFr
+
+
+### Bypassing Redis
+
+You can bypass Redis. I don't want to know why you would, but you can do it easily.
+
+Just do :
+```ruby
+Glass::Mirror.no_redis = true # Glass are so sad !
+```
+
+Now you need to handle the storage yourself !
+
+```ruby
+credentials = Glass::Mirror.get_credentials(authorization_code)
+
+# Store Credentials !
+
+ok_glass = Glass::Mirror.build_client(credentials)
+```
+That's okay ! (for now)
 
 ## Contributing
 

data/glass.gemspec

@@ -21,4 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_runtime_dependency "google-api-client"
+  spec.add_runtime_dependency "redis"
+  spec.add_runtime_dependency "redis-namespace"
+  spec.add_runtime_dependency "httparty"
 end

data/lib/glass.rb

@@ -1,18 +1,296 @@
 require "glass/version"
+require 'redis'
+require 'redis-namespace'
+require 'glass/config'
+require 'google/api_client'
+require 'json'
 
 module Glass
 
+  MIRROR= "mirror"
+
+  INSERT= "INSERT"
+  UPDATE= "UPDATE"
+  DELETE= "DELETE"
+
+
   class Mirror
-    attr_accessor :scopes, :client_id, :redirect_uri, :cient_secret
-    @@client_id
-    @@cient_secret
-    @@redirect_uri
-    @@scopes  = [
-        'https://www.googleapis.com/auth/drive.file',
-        'https://www.googleapis.com/auth/userinfo.profile',
-    # Add other requested scopes.
-    ]
 
+
+    class << self
+      attr_accessor :scopes, :client_id, :redirect_uri, :client_secret
+      @client_id
+      @client_secret
+      @redirect_uri
+      @scopes = [
+          'https://www.googleapis.com/auth/drive.file',
+          'https://www.googleapis.com/auth/userinfo.profile',
+      # Add other requested scopes.
+      ]
+    end
+
+
+    @@config = Config.new()
+
+    attr_accessor :client
+    @client
+
+    def self.hello_world
+      "Hello World!"
+    end
+
+    # Returns the current Redis connection. If none has been created, will
+    # create a new one.
+    def self.redis
+      @@config.redis
+    end
+
+    def self.redis= val
+      @@config.redis = val
+    end
+
+    def self.redis_id
+      @@config.redis_id
+    end
+
+    def self.no_redis= val
+      @@config.no_redis=val
+    end
+
+    ##
+    # Retrieved stored credentials for the provided user ID.
+    #
+    # @param [String] user_id
+    #   User's ID.
+    # @return [Signet::OAuth2::Client]
+    #  Stored OAuth 2.0 credentials if found, nil otherwise.
+    #
+    def self.get_stored_credentials(user_id)
+      unless @@config.no_redis
+        hash = Redis.get(user_id)
+        client = Google::APIClient.new
+        client.authorization.dup
+        client.update_token!(hash)
+      end
+    end
+
+    ##
+    # Store OAuth 2.0 credentials in the application's database.
+    #
+    # @param [String] user_id
+    #   User's ID.
+    # @param [Signet::OAuth2::Client] credentials
+    #   OAuth 2.0 credentials to store.
+    #
+    def self.store_credentials(user_id, credentials)
+      unless @@config.no_redis
+        hash = Hash.new()
+        hash[:access_token] = credentials.access_token
+        hash[:refresh_token] = credentials.refresh_token
+        hash[:expires_in] = credentials.expires_in
+        hash[:issued_at] = credentials.issued_at
+
+        Redis.set(user_id, hash)
+      end
+    end
+
+    ##
+    # Exchange an authorization code for OAuth 2.0 credentials.
+    #
+    # @param [String] auth_code
+    #   Authorization code to exchange for OAuth 2.0 credentials.
+    # @return [Signet::OAuth2::Client]
+    #  OAuth 2.0 credentials.
+    #
+    def self.exchange_code(authorization_code)
+      client = Google::APIClient.new
+      client.authorization.client_id = client_id
+      client.authorization.client_secret = client_secret
+      client.authorization.code = authorization_code
+      client.authorization.redirect_uri = redirect_uri
+
+      begin
+        client.authorization.fetch_access_token!
+        return client.authorization
+      rescue Signet::AuthorizationError
+        raise CodeExchangeError.new(nil)
+      end
+    end
+
+    ##
+    # Send a request to the UserInfo API to retrieve the user's information.
+    #
+    # @param [Signet::OAuth2::Client] credentials
+    #   OAuth 2.0 credentials to authorize the request.
+    # @return [Google::APIClient::Schema::Oauth2::V2::Userinfo]
+    #   User's information.
+    #
+    def self.get_user_info(credentials)
+      client = Google::APIClient.new
+      client.authorization = credentials
+      oauth2 = client.discovered_api('oauth2', 'v2')
+      result = client.execute!(:api_method => oauth2.userinfo.get)
+      user_info = nil
+      if result.status == 200
+        user_info = result.data
+      else
+        puts "An error occurred: #{result.data['error']['message']}"
+      end
+      if user_info != nil && user_info.id != nil
+        return user_info
+      end
+      raise NoUserIdError, "Unable to retrieve the user's Google ID."
+    end
+
+    ##
+    # Retrieve authorization URL.
+    #
+    # @param [String] user_id
+    #   User's Google ID.
+    # @param [String] state
+    #   State for the authorization URL.
+    # @return [String]
+    #  Authorization URL to redirect the user to.
+    #
+    def self.get_authorization_url(user_id, state)
+      client = Google::APIClient.new
+      client.authorization.client_id = client_id
+      client.authorization.redirect_uri = redirect_uri
+      client.authorization.scope = scopes
+
+      return client.authorization.authorization_uri(
+          :options => {
+              :approval_prompt => :force,
+              :access_type => :offline,
+              :user_id => user_id,
+              :state => state
+          }).to_s
+    end
+
+    ##
+    # Retrieve credentials using the provided authorization code.
+    #
+    #  This function exchanges the authorization code for an access token and queries
+    #  the UserInfo API to retrieve the user's Google ID.
+    #  If a refresh token has been retrieved along with an access token, it is stored
+    #  in the application database using the user's Google ID as key.
+    #  If no refresh token has been retrieved, the function checks in the application
+    #  database for one and returns it if found or raises a NoRefreshTokenError
+    #  with an authorization URL to redirect the user to.
+    #
+    # @param [String] auth_code
+    #   Authorization code to use to retrieve an access token.
+    # @param [String] state
+    #   State to set to the authorization URL in case of error.
+    # @return [Signet::OAuth2::Client]
+    #  OAuth 2.0 credentials containing an access and refresh token.
+    #
+    def self.get_credentials(authorization_code, state="OAuth Failed")
+      user_id = ''
+      begin
+        credentials = exchange_code(authorization_code)
+        user_info = get_user_info(credentials)
+        user_id = user_info.id
+        if credentials.refresh_token != nil
+          store_credentials(user_id, credentials)
+          return credentials
+        else
+          credentials = get_stored_credentials(user_id)
+          if credentials != nil && credentials.refresh_token != nil
+            return credentials
+          end
+        end
+      rescue CodeExchangeError => error
+        print 'An error occurred during code exchange.'
+        # Drive apps should try to retrieve the user and credentials for the current
+        # session.
+        # If none is available, redirect the user to the authorization URL.
+        error.authorization_url = get_authorization_url(user_id, state)
+        raise error
+      rescue NoUserIdError
+        print 'No user ID could be retrieved.'
+      end
+
+      authorization_url = get_authorization_url(user_id, state)
+      raise NoRefreshTokenError.new(authorization_url)
+    end
+
+
+    ##
+    # Build a Mirror client instance.
+    #
+    # @param [Signet::OAuth2::Client] credentials
+    #   OAuth 2.0 credentials.
+    # @return [Google::APIClient]
+    #   Client instance
+    def self.build_client(credentials)
+      m = Mirror.new()
+      m.client = Google::APIClient.new
+      m.client.authorization = credentials
+      m.client = m.client.discovered_api('mirror', 'v1')
+      m
+    end
+
+    def self.build_with_code(authorization_code)
+      return build_client(get_credentials(authorization_code))
+    end
+
+    def insert(item)
+      item.insert(client)
+    end
+
+    def delete(item)
+      item.delete(client)
+    end
+
+  end
+
+##
+# Error raised when an error occurred while retrieving credentials.
+#
+  class GetCredentialsError < StandardError
+    ##
+    # Initialize a NoRefreshTokenError instance.
+    #
+    # @param [String] authorize_url
+    #   Authorization URL to redirect the user to in order to in order to request
+    #   offline access.
+    #
+    def initialize(authorization_url)
+      @authorization_url = authorization_url
+    end
+
+    def authorization_url=(authorization_url)
+      @authorization_url = authorization_url
+    end
+
+    def authorization_url
+      return @authorization_url
+    end
+  end
+
+##
+# Error raised when a code exchange has failed.
+#
+  class CodeExchangeError < GetCredentialsError
+  end
+
+##
+# Error raised when no refresh token has been found.
+#
+  class NoRefreshTokenError < GetCredentialsError
+  end
+
+##
+# Error raised when no user ID could be retrieved.
+#
+  class NoUserIdError < StandardError
   end
 
+
 end
+
+require 'glass/contacts/contact'
+require 'glass/locations/location'
+require 'glass/subscriptions/subscription'
+require 'glass/timeline/timeline_item'

data/lib/glass/config.rb

@@ -0,0 +1,65 @@
+module Glass
+  class Config
+
+
+    attr_accessor :no_redis
+
+    ##
+    # Accepts:
+    #   1. A 'hostname:port' String
+    #   2. A 'hostname:port:db' String (to select the Redis db)
+    #   3. A 'hostname:port/namespace' String (to set the Redis namespace)
+    #   4. A Redis URL String 'redis://host:port'
+    #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+    #      or `Redis::Namespace`.
+    def redis=(server)
+      if @no_redis then return nil end
+      return if server == "" or server.nil?
+
+      @redis = case server
+                 when String
+                   if server['redis://']
+                     redis = Redis.connect(:url => server, :thread_safe => true)
+                   else
+                     server, namespace = server.split('/', 2)
+                     host, port, db = server.split(':')
+
+                     redis = Redis.new(
+                         :host => host,
+                         :port => port,
+                         :db => db,
+                         :thread_safe => true
+                     )
+                   end
+                   Redis::Namespace.new(namespace || :glass, :redis => redis)
+                 when Redis::Namespace, Redis::Distributed
+                   server
+                 when Redis
+                   Redis::Namespace.new(:glass, :redis => server)
+               end
+    end
+
+    def redis
+      if @no_redis then return nil end
+      return @redis if @redis
+      self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
+      self.redis
+    end
+
+    def redis_id
+      if @no_redis then return nil end
+      # support 1.x versions of redis-rb
+      if redis.respond_to?(:server)
+        redis.server
+      elsif redis.respond_to?(:nodes) # distributed
+        redis.nodes.map(&:id).join(', ')
+      else
+        redis.client.id
+      end
+    end
+
+    @no_redis
+
+
+  end
+end

data/lib/glass/contacts/contact.rb

@@ -0,0 +1,66 @@
+
+module Glass
+  CONTACT="contact"
+
+  # A person or group that can be used as a creator or a contact.
+  #
+  class Contact
+
+    class << self
+      # The type of resource. This is always mirror#contact.
+      #
+      attr_accessor :kind
+    end
+
+    @@kind = MIRROR+"#"+CONTACT
+
+    # The ID of the application that created this contact.
+    # This is populated by the API
+    attr_reader :source
+    @source
+
+    # An ID for this contact.
+    # This is generated by the application and is treated as an opaque token.
+    #
+    attr_reader :id
+    @id
+
+    # The name to display for this contact.
+    #
+    attr_accessor :displayName
+    @displayName
+
+    # Set of image URLs to display for a contact.
+    # Most contacts will have a single image, but a "group" contact may include up to 8 image URLs and they will be resized and cropped into a mosaic on the client.
+    #
+    attr_accessor :imageUrls
+    @imageUrls=[]
+
+    # The type for this contact. This is used for sorting in UIs. Allowed values are:
+    #   INDIVIDUAL - Represents a single person. This is the default.
+    #   GROUP - Represents more than a single person.
+    #
+    attr_accessor :type
+    @type
+
+    # A list of MIME types that a contact supports.
+    # The contact will be shown to the user if any of its acceptTypes matches any of the types of the attachments on the item.
+    # If no acceptTypes are given, the contact will be shown for all items.
+    #
+    attr_accessor :acceptTypes
+    @acceptTypes=[]
+
+    # Primary phone number for the contact.
+    # This can be a fully-qualified number, with country calling code and area code, or a local number.
+    #
+    attr_accessor :phoneNumber
+    @phoneNumber
+
+    # Priority for the contact to determine ordering in a list of contacts.
+    # Contacts with higher priorities will be shown before ones with lower priorities.
+    #
+    attr_accessor :priority
+    @priority
+
+  end
+end

data/lib/glass/locations/location.rb

@@ -0,0 +1,64 @@
+require 'glass/subscriptions/subscription.rb'
+module Glass
+  LOCATION="location"
+
+  # A geographic location that can be associated with a timeline item.
+  #
+  class Location
+
+    class << self
+      # The type of resource. This is always mirror#location.
+      #
+      attr_reader :kind
+
+      def subscribe(mirror, call_back_url)
+        s = Subscription.new()
+        s.mirror=mirror
+        s.callbackUrl=call_back_url
+        s.collection=Subscription::LOCATION
+        s.operation << UPDATE
+        s.insert
+      end
+    end
+
+    @@kind
+
+
+    # The ID of the location.
+    #
+    attr_reader :id
+    @id
+
+    # The time at which this location was captured, formatted according to RFC 3339.
+    #
+    attr_reader :timestamp
+    @timestamp
+
+    # The latitude, in degrees.
+    #
+    attr_accessor :latitude
+    @latitude
+
+    # The longitude, in degrees.
+    attr_accessor :longitude
+    @longitude
+
+    # The accuracy of the location fix in meters.
+    #
+    attr_accessor :accuracy
+    @accuracy
+
+    # The name to be displayed. This may be a business name or a user-defined place, such as "Home".
+    #
+    attr_accessor :displayName
+    @displayName
+
+    # The full address of the location.
+    #
+    attr_accessor :address
+    @address
+
+
+  end
+
+end

data/lib/glass/subscriptions/subscription.rb

@@ -0,0 +1,222 @@
+require 'json'
+module Glass
+  SUBSCRIPTION="subscription"
+
+  # A subscription to events on a collection.
+  #
+  class Subscription
+    class << self
+      # The type of resource. This is always mirror#subscription.
+      #
+      attr_accessor :kind
+
+      ##
+      # Subscribe to notifications for the current user.
+      #
+      # @param [Google::APIClient] client
+      #   Authorized client instance.
+      # @param [String] collection
+      #   Collection to subscribe to (supported values are "timeline" and "locations").
+      # @param [String] user_token
+      #   Opaque token used by the Glassware to identify the user the notification
+      #   pings are sent for (recommended).
+      # @param [String] verify_token
+      #   Opaque token used by the Glassware to verify that the notification pings are
+      #   sent by the API (optional).
+      # @param [String] callback_url
+      #   URL receiving notification pings (must be HTTPS).
+      # @param [Array] operation
+      #   List of operations to subscribe to. Valid values are "UPDATE", "INSERT" and
+      #   "DELETE" or nil to subscribe to all.
+      # @return nil
+      def subscribe(mirror, collection, user_token, verify_token, callback_url, operation)
+        subscription = mirror.subscriptions.insert.request_schema.new({
+                                                                          'collection' => collection,
+                                                                          'userToken' => user_token,
+                                                                          'verifyToken' => verify_token,
+                                                                          'callbackUrl' => callback_url,
+                                                                          'operation' => operation})
+        result = client.execute(
+            :api_method => mirror.subscriptions.insert,
+            :body_object => subscription)
+        if result.error?
+          puts "An error occurred: #{result.data['error']['message']}"
+        end
+      end
+
+      ##
+      # Delete a subscription to a collection.
+      #
+      # @param [Google::APIClient] client
+      #   Authorized client instance.
+      # @param [String] collection
+      #   Collection to unsubscribe from (supported values are "timeline" and
+      #   "locations").
+      # @return nil
+      def unsubscribe_from_notifications(client, collection)
+        mirror = client.discovered_api('mirror', 'v1')
+        result = client.execute(
+            :api_method => mirror.subscriptions.delete,
+            :parameters => { 'id' => collection })
+        if result.error?
+          puts "An error occurred: #{result.data['error']['message']}"
+        end
+      end
+
+    end
+
+    @@kind = MIRROR+"#"+SUBSCRIPTION
+
+    ##
+    # The Mirror Api
+    #
+    attr_accessor :mirror
+    @mirror
+
+    # The ID of the subscription.
+    #
+    attr_accessor :id
+    @id
+
+    # The time at which this subscription was last modified, formatted according to RFC 3339.
+    #
+    attr_accessor :updated
+    @updated
+
+    # The collection to subscribe to. Allowed values are:
+    #   timeline - Changes in the timeline including insertion, deletion, and updates.
+    #   locations - Location updates.
+    attr_accessor :collection
+    @collection
+    TIMELINE="timeline"
+    LOCATIONS="locations"
+
+    # A list of operations that should be subscribed to.
+    # An empty list indicates that all operations on the collection should be subscribed to. Allowed values are:
+    #   UPDATE - The item has been updated.
+    #   INSERT - A new item has been inserted.
+    #   DELETE - The item has been deleted.
+    attr_accessor :operation
+    @operation= []
+
+    # The URL where notifications should be delivered (must start with https://).
+    #
+    attr_accessor :callbackUrl
+    @callbackUrl
+
+    # A secret token sent to the subscriber in notifications
+    # so that it can verify that the notification was generated by Google.
+    #
+    attr_accessor :verifyToken
+    @verifyToken
+
+    # An opaque token sent to the subscriber in notifications so that it can determine the ID of the user.
+    #
+    attr_accessor :userToken
+    @userToken
+
+    # Container object for notifications.
+    # This is not populated in the Subscription resource.
+    #
+    attr_accessor :notification
+    @notification
+
+    class Notification
+      # The collection that generated the notification.
+      #
+      attr_accessor :collection
+      @collection
+
+      # The ID of the item that generated the notification.
+      #
+      attr_accessor :itemId
+      @itemId
+
+      # The type of operation that generated the notification.
+      #
+      attr_accessor :operation
+      @operation
+
+      # The secret verify token provided by the service when it subscribed for notifications.
+      #
+      attr_accessor :verifyToken
+      @verifyToken
+
+      # The user token provided by the service when it subscribed for notifications.
+      #
+      attr_accessor :userToken
+      @userToken
+
+      # A list of actions taken by the user that triggered the notification.
+      #
+      attr_accessor :userActions
+      @userActions=[]
+
+      class Action
+        # The type of action. The value of this can be:
+        #   SHARE - the user shared an item.
+        #   REPLY - the user replied to an item.
+        #   REPLY_ALL - the user replied to all recipients of an item.
+        #   CUSTOM - the user selected a custom menu item on the timeline item.
+        #   DELETE - the user deleted the item.
+        #   PIN - the user pinned the item.
+        #   UNPIN - the user unpinned the item.
+        # In the future, additional types may be added. UserActions with unrecognized types should be ignored.
+        #
+        attr_accessor :type
+        @type
+
+        SHARE="SHARE"
+        REPLY="REPLY"
+        REPLY_ALL="REPLY_ALL"
+        CUSTOM="CUSTOM"
+        DELETE="DELETE"
+        PIN="PIN"
+        UNPIN="UNPIN"
+
+        # An optional payload for the action.
+        #
+        # For actions of type CUSTOM, this is the ID of the custom menu item that was selected.
+        #
+        attr_accessor :payload
+        @payload
+
+      end
+
+      ##
+      # Subscribe to notifications for the current user.
+      #
+      # @param [Google::APIClient] Mirror
+      #   Authorized client instance.
+      #
+      # @return nil
+      def insert(mirror=@mirror)
+        subscription = mirror.subscriptions.insert.request_schema.new(to_json)
+        result = client.execute(
+            :api_method => mirror.subscriptions.insert,
+            :body_object => subscription)
+        if result.error?
+          puts "An error occurred: #{result.data['error']['message']}"
+        end
+      end
+
+      ##
+      # Delete a subscription to a collection.
+      #
+      # @param [Google::APIClient] client
+      #   Authorized client instance.
+      # @return nil
+      def delete(mirror=@mirror)
+        result = client.execute(
+            :api_method => mirror.subscriptions.delete,
+            :parameters => { 'id' => collection })
+        if result.error?
+          puts "An error occurred: #{result.data['error']['message']}"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/glass/timeline/timeline_item.rb

@@ -0,0 +1,400 @@
+require 'json'
+
+module Glass
+  TIMELINE_ITEM="timelineItem"
+
+  # Each item in the user's timeline is represented as a TimelineItem JSON structure, described below.
+  #
+  class TimelineItem
+
+    def initialize(client=nil)
+      @client = client
+    end
+
+    class << self
+
+      # The type of resource. This is always mirror#timelineItem.
+      #
+      attr_reader :kind
+
+
+      def get(client, id)
+        client.exexute(
+            :api_method => client.timeline.get,
+            :parameters => {:id => id}
+        )
+      end
+
+      DISPLAY_TIME="displayTime"
+      WRITE_TIME="writeTime"
+
+      # Retrieves a list of timeline items for the authenticated user.
+      # @param [string] bundleId
+      #   If true, tombstone records for deleted items will be returned.
+      # @param [boolean] includeDeleted
+      #   If true, tombstone records for deleted items will be returned.
+      # @param [integer] maxResults
+      #   The maximum number of items to include in the response, used for paging.
+      # @param [string] orderBy
+      #   Controls the order in which timeline items are returned.
+      #   Acceptable values are:
+      #     "displayTime": Results will be ordered by displayTime (default). This is the same ordering as is used in the timeline on the device.
+      #     "writeTime": Results will be ordered by the time at which they were last written to the data store.
+      # @param [string] pageToken
+      #   Token for the page of results to return.
+      # @param [boolean] pinnedOnly
+      #   If true, only pinned items will be returned.
+      # @param [string] sourceItemId
+      #   If provided, only items with the given sourceItemId will be returned.
+      #
+      def list(client, params={})
+        result=[]
+        parameters = params
+        api_result = client.execute(
+            :api_method => mirror.timeline.list,
+            :parameters => parameters)
+        if api_result.success?
+          data = api_result.data
+          unless data.items.empty?
+            result << data.items
+            parameters[:pageToken]= data.next_page_token
+            result << list(client, parameters)
+          end
+        else
+          puts "An error occurred: #{result.data['error']['message']}"
+        end
+        result
+      end
+
+    end
+
+    ##
+    # The Client
+    #
+    attr_reader :client
+    @client
+
+    # The ID of the timeline item. This is unique within a user's timeline.
+    #
+    attr_accessor :id
+
+    # A URL that can be used to retrieve this item.
+    #
+    attr_accessor :selfLink
+
+    # The time at which this item was created, formatted according to RFC 3339.
+    #
+    attr_reader :created
+
+    # The time at which this item was last modified, formatted according to RFC 3339.
+    #
+    attr_accessor :updated
+
+    # The time that should be displayed when this item is viewed in the timeline,
+    # formatted according to RFC 3339. This user's timeline is sorted chronologically on display time,
+    # so this will also determine where the item is displayed in the timeline.
+    # If not set by the service, the display time defaults to the updated time.
+    #
+    attr_reader :displayTime
+
+    # When true, indicates this item is deleted, and only the ID property is set.
+    #
+    attr_accessor :isDeleted
+
+    # ETag for this item.
+    #
+    attr_reader :etag
+
+    # The user or group that created this item.
+    #
+    attr_accessor :creator
+
+    # If this item was generated as a reply to another item,
+    # this field will be set to the ID of the item being replied to.
+    # This can be used to attach a reply to the appropriate conversation or post.
+    #
+    attr_accessor :inReplyTo
+
+    # Text content of this item.
+    #
+    attr_accessor :text
+
+    # The speakable version of the content of this item.
+    # Along with the READ_ALOUD menu item,
+    # use this field to provide text that would be clearer when read aloud,
+    # or to provide extended information to what is displayed visually on Glass.
+    #
+    attr_accessor :speakableText
+
+    # A list of media attachments associated with this item.
+    #
+    attr_accessor :attachments
+
+    # The geographic location associated with this item.
+    #
+    attr_accessor :location
+
+    # A list of menu items that will be presented to the user when this item is selected in the timeline.
+    #
+    attr_accessor :menuItems
+
+    # Controls how notifications for this item are presented on the device.
+    # If this is missing, no notification will be generated.
+    #
+    attr_accessor :notification
+
+
+    # When true, indicates this item is pinned,
+    # which means it's grouped alongside "active" items like navigation and hangouts,
+    # on the opposite side of the home screen from historical (non-pinned) timeline items.
+    #
+    attr_accessor :isPinned
+
+    # The title of this item.
+    #
+    attr_accessor :title
+
+    # HTML content for this item. If both text and html are provided for an item,
+    # the html will be rendered in the timeline.
+    #
+    attr_accessor :html
+
+    # The bundle ID for this item. Services can specify a bundleId to group many items together.
+    # They appear under a single top-level item on the device.
+    #
+    attr_accessor :bundleId
+
+    # Additional pages of HTML content associated with this item.
+    # If this field is specified, the item will be displayed as a bundle,
+    # with the html field as the cover. It is an error to specify this field without specifying the html field.
+    #
+    attr_accessor :htmlPages
+
+    # Opaque string you can use to map a timeline item to data in your own service.
+    #
+    attr_accessor :sourceItemId
+
+    # A canonical URL pointing to the canonical/high quality version of the data represented by the timeline item.
+    #
+    attr_accessor :canonicalUrl
+
+    # Whether this item is a bundle cover.
+    #
+    # If an item is marked as a bundle cover,
+    # it will be the entry point to the bundle of items that have the same bundleId as that item.
+    # It will be shown only on the main timeline — not within the opened bundle.
+    #
+    # On the main timeline, items that are shown are:
+    #   Items that have isBundleCover set to true
+    #   Items that do not have a bundleId
+    #
+    # Items that do not have a bundleId
+    #   In a bundle sub-timeline, items that are shown are:
+    #   Items that have the bundleId in question AND isBundleCover set to false
+
+    attr_accessor :isBundleCover
+
+    # For pinned items, this determines the order in which the item is displayed in the timeline,
+    # with a higher score appearing closer to the clock. Note: setting this field is currently not supported.
+    #
+    attr_accessor :pinScore
+
+    # A list of contacts or groups that this item has been shared with.
+    #
+    attr_accessor :recipients
+
+    @@kind= MIRROR+"#"+TIMELINE_ITEM
+    @id
+    @selfLink
+    @created
+    @updated
+    @displayTime
+    @isDeleted
+    @etag
+    @creator #Todo User and Group
+    @inReplyTo
+    @text
+    @speakableText
+    @attachments=[]
+    @location
+    @menuItems=[]
+    @notification
+    @isPinned
+    @title
+    @html
+    @bundleId
+    @htmlPages=[]
+    @sourceItemId
+    @canonicalUrl
+    @isBundleCover
+    @pinScore
+    @recipients=[]
+
+    # Represents media content, such as a photo, that can be attached to a timeline item.
+    #
+    class Attachment
+
+      # The ID of the attachment.
+      #
+      attr_reader :id
+      @id
+
+      # The MIME type of the attachment.
+      # (supported content types are 'image/*', 'video/*' and 'audio/*').
+      #
+      attr_accessor :contentType
+      @contentType
+
+      TYPE_IMAGE='image/*'
+      TYPE_VIDEO='video/*'
+      TYPE_AUDIO='audio/*'
+
+      # The URL for the content.
+      #
+      attr_accessor :contentUrl
+      @contentUrl
+
+      # Indicates that the contentUrl is not available because the attachment content is still being processed.
+      # If the caller wishes to retrieve the content, it should try again later.
+      #
+      attr_reader :isProcessingContent
+      @isProcessingContent
+    end
+
+    class Notification
+
+      # Describes how important the notification is. Allowed values are:
+      #   DEFAULT - Notifications of default importance. A chime will be played to alert contacts.
+      attr_accessor :level
+
+      # The time at which the notification should be delivered.
+      #
+      attr_accessor :deliveryTime
+
+      @level
+      @deliveryTime
+    end
+
+    class MenuItems
+
+      # The ID for this menu item. This is generated by the application and is treated as an opaque token.
+      #
+      attr_accessor :id
+
+      # Controls the behavior when the user picks the menu option. Allowed values are:
+      # CUSTOM - Custom action set by the service. When the user selects this menuItem,
+      # the API triggers a notification to your callbackUrl with the userActions.type set to CUSTOM and the userActions.payload set to the ID of this menu item.
+      # This is the default value.
+      # Built-in actions:
+      #   REPLY - Initiate a reply to the timeline item using the voice recording UI. The creator attribute must be set in the timeline item for this menu to be available.
+      #   REPLY_ALL - Same behavior as REPLY. The original timeline item's recipients will be added to the reply item.
+      #   DELETE - Delete the timeline item.
+      #   SHARE - Share the timeline item with the available contacts.
+      #   READ_ALOUD - Read the timeline item's speakableText aloud; if this field is not set, read the text field; if none of those fields are set, this menu item is ignored.
+      #   VOICE_CALL - Initiate a phone call using the timeline item's creator.phone_number attribute as recipient.
+      #   NAVIGATE - Navigate to the timeline item's location.
+      #   TOGGLE_PINNED - Toggle the isPinned state of the timeline item.
+      #
+      attr_accessor :actions
+
+      # For CUSTOM items, a list of values controlling the appearance of the menu item in each of its states.
+      # A value for the DEFAULT state must be provided.
+      # If the PENDING or CONFIRMED states are missing, they will not be shown.
+      #
+      attr_accessor :values
+
+      # If set to true on a CUSTOM menu item, that item will be removed from the menu after it is selected.
+      #
+      attr_accessor :removeWhenSelected
+
+      @id
+      @actions
+      @values=[]
+      @removeWhenSelected
+
+      REPLY="REPLY"
+      REPLY_ALL="REPLY_ALL"
+      DELETE="DELETE"
+      SHARE="SHARE"
+      READ_ALOUD="READ_ALOUD"
+      VOICE_CALL="VOICE_CALL"
+      NAVIGATE="NAVIGATE"
+      TOGGLE_PINNED="TOOGLE_PINNED"
+      CUSTOM="CUSTOM"
+
+      class Values
+
+        # The name to display for the menu item.
+        #
+        attr_accessor :displayName
+
+        # URL of an icon to display with the menu item.
+        #
+        attr_accessor :iconURL
+
+        # The state that this value applies to. Allowed values are:
+        #   DEFAULT - Default value shown when displayed in the menuItems list.
+        #   PENDING - Value shown when the menuItem has been selected by the user but can still be cancelled.
+        #   CONFIRMED - Value shown when the menuItem has been selected by the user and can no longer be cancelled.
+        attr_accessor :state
+
+        @displayName
+        @iconURL
+        @state
+
+        DEFAULT="DEFAULT"
+        PENDING="PENDING"
+        CONFIRMED="CONFIRMED"
+      end
+    end
+
+
+    ##
+    # Insert a new Timeline Item in the user's glass.
+    #
+    # @param [Google::APIClient::API] client
+    #   Authorized client instance.
+    # @return Array[Google::APIClient::Schema::Mirror::V1::TimelineItem]
+    #   Timeline item instance if successful, nil otherwise.
+    def insert!(mirror=@client)
+      timeline_item = self
+      result = []
+      if file_upload?
+        for file in file_to_upload
+          media = Google::APIClient::UploadIO.new(file.contentUrl, file.content_type)
+          result << client.execute!(
+              :api_method => mirror.timeline.insert,
+              :body_object => timeline_item,
+              :media => media,
+              :parameters => {
+                  :uploadType => 'multipart',
+                  :alt => 'json'})
+        end
+      else
+        result << client.execute(
+            :api_method => mirror.timeline.insert,
+            :body_object => timeline_item)
+      end
+      return result.data
+    end
+
+    def file_upload?
+      flag=false
+      @attachments.each { |attachment|
+        flag = true unless attachment.id
+      }
+      return flag
+    end
+
+    def file_to_upload
+      file_to_upload=[]
+      @attachments.each { |attachment|
+        file_to_upload << attachment unless attachment.id
+      }
+      file_to_upload
+    end
+
+
+  end
+
+end

data/lib/glass/version.rb

@@ -1,3 +1,3 @@
 module Glass
-  VERSION = "0.0.1.1"
+  VERSION = "0.0.1.2"
 end

data/rebuild.sh

@@ -0,0 +1,4 @@
+sudo gem uninstall glass
+gem build glass.gemspec
+sudo gem install glass-0.0.1.2.gem
+irb -r 'glass'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glass
 version: !ruby/object:Gem::Version
-  version: 0.0.1.1
+  version: 0.0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-16 00:00:00.000000000 Z
+date: 2013-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -59,6 +59,54 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Glass Gem for Google Glass
 email:
 - dam.cavailles@laposte.net
@@ -73,7 +121,13 @@ files:
 - Rakefile
 - glass.gemspec
 - lib/glass.rb
+- lib/glass/config.rb
+- lib/glass/contacts/contact.rb
+- lib/glass/locations/location.rb
+- lib/glass/subscriptions/subscription.rb
+- lib/glass/timeline/timeline_item.rb
 - lib/glass/version.rb
+- rebuild.sh
 homepage: https://github.com/thedamfr/glass
 licenses:
 - MIT
@@ -95,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: This Gem is meant to allow you to quickly build a Google Glass Application.