motionscan 0.0.1

data/.gitignore

@@ -0,0 +1,23 @@
+.repl_history
+build
+.build
+libPods.a
+vendor/Pods/Pods.xcodeproj
+tags
+resources/*.nib
+resources/*.momd
+resources/*.storyboardc
+.DS_Store
+nbproject
+.redcar
+#*#
+*~
+*.sw[po]
+.eprj
+pkg/*
+vendor/Pods
+vendor/Podfile.lock
+Gemfile.lock
+wildcard_dev.mobileprovision
+Rakefile
+app/motionscan_config.rb

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 by Joffrey Jaffeux
+
+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/Motionscan.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/motionscan/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "motionscan"
+  s.version     = Motionscan::VERSION
+  s.authors     = ["Joffrey Jaffeux"]
+  s.email       = ["j.jaffeux@gmail.com"]
+  s.homepage    = "https://github.com/jjaffeux/Motionscan"
+  s.summary     = "A RubyMotion Moodstocks SDK image recognition wrapper"
+  s.description = "A RubyMotion Moodstocks SDK image recognition wrapper"
+
+  s.files         = `git ls-files`.split($\)
+  s.require_paths = ["lib"]
+
+  s.add_dependency "motion-cocoapods", ">= 1.2.1"
+  s.add_development_dependency 'rake'
+end

data/README.md

@@ -0,0 +1,174 @@
+<!>Not production ready<!>
+
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/jjaffeux/Motionscan)
+
+
+# Description
+
+Motionscan is a RubyMotion wrapper for the Moodstocks SDK. Moodstocks provide an incredibly fast and easy tool to add image recognition to your app.
+
+Watch the video to see what you will be able to build in few minutes : http://cl.ly/0Q3K163y3b12
+
+
+# Usage
+- Create an account on moodstocks.com
+- Use Moodstocks image uploader to add images to your account
+- Complete your application Rakefile with RakefileExample (most notably pod and credentials)
+- Look at /app to use it in your application
+- Not yet pushed to rubygems, you have to build the gem and link to it from your Gemfile
+
+If you want build this application you need to upload images with json attached to images, for example : 
+http://cl.ly/image/3l331E0K0L2P
+
+# Documentation
+## Motionscan::Sync
+    
+Moodstocks is fast because the image processor is fast but also because it allows you to cache image signature, the Sync class allows you to decide when and how you want to sync the device cache.
+
+-init
+```ruby
+sync = Motionscan::Sync.init
+```
+
+-startWithStatus(syncStarted, success:syncCompleted, error:syncFailed, progress:syncProgressed)
+```ruby
+sync.startWithStatus(
+  lambda {
+    # sync started
+  },
+  success:lambda {|result|
+    # sync finished
+    # Motionscan::Result instance
+  },
+  error:lambda {|error|
+    # an error occured while syncing
+    # NSError
+  },
+  progress:lambda {|progress, total|
+    # progress : current number of cached items
+    # total : number of items to cache
+  }
+)
+```
+
+## Motionscan::Scanner
+
+
+-initWithFrame(frame)
+```ruby
+scanner = Motionscan::Scanner.initWithFrame([[0,0],[320,200]])
+```
+
+-frame=(frame)
+```ruby
+scanner.frame = [[0,0],[320,200]]
+```
+
+-displayScannerInView(view)
+```ruby
+scanner.displayScannerInView(self.view)
+```
+
+-startWithStatus(scanStarted, success:scanCompleted, error:scanError, notFound:scanNotFound)
+```ruby
+scanner.startWithStatus(
+  lambda {
+  	# scan started
+    # will fire once at the beginning
+    # from this point everything captured 
+    # by the video will be scanned
+  },
+  success:lambda {|result|
+  	# scan found and image in the cache
+    # Motionscan::Result instance
+  },
+  error:lambda {|error|
+  	# scan error
+    # NSError 
+  },
+  notFound:lambda {
+  	# scan didn't find the image in the cache
+    # you shouldn't do anything expensive here
+    # as it will fire very frequently
+  }
+)
+```
+
+
+-pause
+
+If you wish to pause the scanner, and prevent current result to change you can use this method. Use scanner.resume to resume scanning process.
+```ruby
+scanner.pause
+```
+
+-stop
+
+Call this method to terminate the scanner, usually in viewWillDisappear(animated). /!\ You have to call it at some point or pushing a new UIViewController and going back to this one, will crash the app.
+```ruby
+scanner.stop
+```
+
+-resume
+
+```ruby
+scanner.resume
+```
+
+-searchWithStatus(searchStarted, success:searchCompleted, error:searchError, notFound:searchNotFound)
+
+If an image is not in the cache, you can trigger an API call to search it on your account.
+
+```ruby
+scanner.searchWithStatus(
+  lambda {
+  	#search in remote started
+  },
+  success:lambda {|result|
+  	#search found and image in remote
+  },
+  error:lambda {|error|
+  	#search error
+  },
+  notFound:lambda {
+  	#search didn't find the image in remote
+  }
+)
+```
+
+## Motionscan::Result
+
+Result is a simple wrapper arround MSResult, every methods that should return a result will give an instance of Motionscan::Result.
+
+-imageId
+
+Returns the imageId of the scanned image.
+
+```ruby
+result.imageId
+```
+
+-msSDKResult
+
+Let you access the raw MSResult
+
+```ruby
+result.msSDKResult
+```
+
+-data
+
+```ruby
+result.data
+```
+
+Returns the string or the hash (json is converted to a hash) saved with the image. For example if the following json is attached to your image :
+```ruby
+{"type":"businessCat", "name":"Carl"}
+```
+
+You will get the following ruby hash :
+```ruby
+result.data
+# {type:"businessCat", name:"Carl"}
+```

data/RakefileExample

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require "bundler/gem_tasks"
+require "bundler/setup"
+Bundler.require :default
+
+$:.unshift("./lib/")
+require './lib/motionscan'
+
+Motion::Project::App.setup do |app|
+  app.name = 'Motionscan'
+
+  app.motionscan.api_key = "xxx"
+  app.motionscan.api_secret = "xxx"
+
+  app.pods do
+    pod 'Moodstocks-iOS-SDK', '~> 3.5'
+  end
+end

data/app/app_delegate.rb

@@ -0,0 +1,14 @@
+class AppDelegate
+
+  attr_accessor :window
+
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    controller = RootViewController.alloc.init
+    navigationController = UINavigationController.alloc.initWithRootViewController(controller)
+    self.window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    self.window.rootViewController = navigationController
+    self.window.makeKeyAndVisible
+
+    true
+  end
+end

data/app/root_view_controller.rb

@@ -0,0 +1,57 @@
+class RootViewController < UIViewController
+
+  attr_accessor :counterLabel
+
+  def loadView
+    super
+    self.counterLabel = UILabel.alloc.initWithFrame([[60,80],[200,40]])
+    self.counterLabel.textAlignment = UITextAlignmentCenter
+    self.counterLabel.backgroundColor = UIColor.darkGrayColor
+    self.counterLabel.font = UIFont.boldSystemFontOfSize(20)
+    self.counterLabel.layer.cornerRadius = 5.0
+    self.counterLabel.text = "Sync will start"
+    self.view.addSubview(self.counterLabel)
+  end
+
+  def viewDidLoad
+    super
+    self.title = "Root"
+    self.view.backgroundColor = UIColor.whiteColor
+
+    @sync = Motionscan::Sync.init
+    @sync.startWithStatus(
+      lambda {
+        NSLog("sync started")
+      },
+      success:lambda {|result|
+        self.counterLabel.removeFromSuperview
+        addScannerViewControllerButton
+      },
+      error:lambda {|error|
+        p error
+      },
+      progress:lambda {|progress, total|
+        self.counterLabel.text = "#{progress} / #{total}"
+      }
+    )
+  end
+
+private
+
+  def addScannerViewControllerButton
+    scanButton = UIButton.buttonWithType(UIButtonTypeCustom)
+    scanButton.frame = [[40,140],[240,40]]
+    scanButton.setTitle("Launch Scanner", forState:UIControlStateNormal)
+    scanButton.backgroundColor = UIColor.darkGrayColor
+    scanButton.addTarget(self,
+      action: :pushScannerViewController,
+      forControlEvents:UIControlEventTouchUpInside)
+    self.view.addSubview(scanButton)
+  end
+
+  def pushScannerViewController
+    scannerController = ScannerViewController.alloc.init
+    self.navigationController.pushViewController(scannerController, animated:true)
+  end
+
+end

data/app/scanner_view_controller.rb

@@ -0,0 +1,33 @@
+class ScannerViewController < UIViewController
+
+  def init
+    super
+    @overlay = UILabel.alloc.initWithFrame([[10,10],[300,40]])
+    @overlay.textAlignment = UITextAlignmentCenter
+    @overlay.alpha = 0.8
+    @overlay.backgroundColor = UIColor.darkGrayColor
+    @overlay.layer.zPosition = 2
+    self.view.addSubview(@overlay)
+    self
+  end
+
+  def viewDidAppear(animated)
+    @scanner = Motionscan::Scanner.initWithFrame(self.view.bounds)
+    @scanner.displayScannerInView(self.view)
+    @scanner.startWithStatus(
+      lambda {
+        @overlay.text = "Will start scanning"
+      },
+      success:lambda {|result|
+        @overlay.text = "#{result.data[:type]}"
+      },
+      error:lambda {|error|},
+      notFound:lambda {}
+    )
+  end
+
+  def viewWillDisappear(animated)
+    @scanner.stop
+  end
+
+end

data/lib/motion/project/motionscan.rb

@@ -0,0 +1,78 @@
+unless defined?(Motion::Project::Config)
+	raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+class MotionscanConfig
+	attr_accessor :api_key
+	attr_accessor :api_secret
+
+	def initialize(config)
+		@config = config
+	end
+
+	def api_secret=(api_secret)
+		@api_secret = api_secret
+		create_code
+	end
+
+private
+
+	def create_code
+		unless @api_key && @api_secret
+			raise "Need to configure `app.motionscan.api_key' and `app.motionscan.api_secret' variables"
+		end
+
+		code = <<EOF
+# Moodstocks SDK launcher
+# This file is automatically generated. Do not edit.
+if MSDeviceCompatibleWithSDK()
+	scanner = MSScanner.sharedInstance
+	error_ptr = Pointer.new(:object)
+	unless scanner.openWithKey("#{@api_key}", secret:"#{@api_secret}", error:error_ptr)
+		errorCode = error_ptr[0].code
+		if errorCode == MS_CREDMISMATCH
+			NSLog("[MOODSTOCKS SDK] There is a problem with your key/secret pair : see https://github.com/Moodstocks/moodstocks-sdk/blob/master/sample/iphone/demo/Demo/MSAppDelegate.m#L65")
+			NSException.exceptionWithName("MSScannerException", reason:"Credentials mismatch", userInfo:nil).raise
+		else
+			errorString = NSString.stringWithCString(ms_errmsg(errorCode), encoding:NSUTF8StringEncoding)
+			NSLog("[MOODSTOCKS SDK] Scanner open error code :" + errorString)
+		end
+	end
+	NSLog("[MOODSTOCKS SDK] Scanner initialized.")
+else
+	NSLog("[MOODSTOCKS SDK] Your device is not compatible with the Moodstocks SDK.")
+end
+EOF
+
+		motionscan_file = './app/motionscan_config.rb'
+		create_stub(motionscan_file, code)
+		add_file(motionscan_file)
+	end
+
+	def create_stub(path, code)
+		if !File.exist?(path) or File.read(path) != code
+			File.open(path, 'w') { |io| io.write(code) }
+		end
+	end
+
+	def add_file(path)
+		files = @config.files.flatten
+		@config.files << path unless files.find { |x| File.expand_path(x) == File.expand_path(path) }
+	end
+end
+
+module Motion
+	module Project
+		class Config
+
+			variable :motionscan
+
+			def motionscan
+				@motionscan ||= MotionscanConfig.new(self)
+				yield @motionscan if block_given?
+				@motionscan
+			end
+
+		end
+	end
+end

data/lib/motionscan/flash.rb

@@ -0,0 +1,18 @@
+module Motionscan
+
+  module Flash
+
+    def flash
+      flashView = UIView.alloc.initWithFrame(@view.bounds)
+      flashView.backgroundColor = UIColor.whiteColor
+      @view.addSubview(flashView)
+
+      UIView.animateWithDuration(0.4,
+        animations:lambda { flashView.alpha = 0.0 },
+        completion:lambda { |finished| flashView.removeFromSuperview }
+      )
+    end
+
+  end
+
+end

data/lib/motionscan/result.rb

@@ -0,0 +1,39 @@
+module Motionscan
+
+  class Result
+
+    attr_reader :msSDKResult
+
+    def initialize(msSDKResult)
+      @msSDKResult = msSDKResult
+    end
+
+    def imageId
+      @msSDKResult.getValue
+    end
+
+    def data
+      error_ptr = Pointer.new(:object)
+
+      options = NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves | NSJSONReadingAllowFragments
+      json = NSJSONSerialization.JSONObjectWithData(base64URLString,
+        options:options,
+        error:error_ptr)
+
+      error = error_ptr[0]
+      error.nil? ? json : decodeImageBase64URLString
+    end
+
+  private
+
+    def decodeImageBase64URLString
+      NSString.alloc.initWithData(base64URLString, encoding:NSUTF8StringEncoding)
+    end
+
+    def base64URLString
+      MSResult.dataFromBase64URLString(@msSDKResult.getValue)
+    end
+
+  end
+
+end

data/lib/motionscan/scanner.rb

@@ -0,0 +1,109 @@
+module Motionscan
+  class Scanner
+    include Flash
+
+    attr_accessor :flashEnabled
+    attr_accessor :frame
+    attr_reader   :session
+    attr_reader   :view
+
+    def self.initWithFrame(frame)
+      instance = allocate
+      instance.scannerInitializer(frame)
+      instance
+    end
+
+    def scannerInitializer(frame)
+      @frame = frame
+      @flashEnabled = true
+      @view = UIView.alloc.initWithFrame(frame)
+    end
+
+    def frame=(frame)
+      @view.frame = frame
+    end
+
+    def displayScannerInView(view)
+      @session = MSScannerSession.alloc.initWithScanner(MSScanner.sharedInstance)
+      @session.scanOptions = MS_RESULT_TYPE_IMAGE
+      @session.delegate = self
+
+      @view.backgroundColor = UIColor.blackColor
+      @view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight
+      @view.autoresizesSubviews = true
+      view.addSubview(@view)
+    end
+
+    # scanner session flow
+    def startWithStatus(scanStarted, success:scanCompleted, 
+      error:scanError, notFound:scanNotFound)
+      scanStarted.call
+      @scanCompleted = scanCompleted
+      @scanError = scanError
+      @scanNotFound = scanNotFound
+
+      viewLayer = @view.layer
+      viewLayer.setMasksToBounds(true)
+
+      captureLayer = @session.previewLayer
+      captureLayer.setFrame(@view.bounds)
+      
+      viewLayer.insertSublayer(captureLayer, below:viewLayer.sublayers)
+
+      @session.startCapture
+    end
+
+    def stop
+      @session.stopCapture
+      @session.cancel
+      @view.removeFromSuperview
+    end
+
+    def resume
+      @session.resume
+    end
+
+    def pause
+      @session.pause
+    end
+
+    def searchWithStatus(searchStarted, success:searchCompleted,error:searchError,notFound:searchNotFound)
+      @searchStarted = searchStarted
+      @searchCompleted = searchCompleted
+      @searchError = searchError
+      @searchNotFound = searchNotFound
+
+      self.flash if @flashEnabled
+      @session.snap
+      @session.pause
+    end
+
+  private
+
+    # delegates
+    def session(session, didScan:result)
+      Dispatch::Queue.main.async { 
+        result.nil? ? @scanNotFound.call : @scanCompleted.call(Result.new(result))
+      }
+    end
+
+    def session(session, failedToScan:error)
+      Dispatch::Queue.main.async { @scanError.call(error) }
+    end
+
+    def scannerWillSearch(scanner)
+      Dispatch::Queue.main.async { @searchStarted.call }
+    end
+
+    def scanner(scanner, didSearchWithResult:result)
+      Dispatch::Queue.main.async { 
+        result.nil? ? @searchNotFound.call : @searchCompleted.call(Result.new(result))
+      }
+    end
+
+    def scanner(scanner, failedToSearchWithError:error)
+      Dispatch::Queue.main.async { @searchError.call(error) }
+    end
+
+  end
+end

data/lib/motionscan/sync.rb

@@ -0,0 +1,49 @@
+module Motionscan
+
+  class Sync
+
+    attr_reader :scanner
+
+    def self.init
+      instance = allocate
+      instance
+    end
+
+    def startWithStatus(syncStarted, success:syncCompleted, 
+      error:syncFailed, progress:syncProgressed)
+      @syncStarted = syncStarted
+      @syncCompleted = syncCompleted
+      @syncFailed = syncFailed
+      @syncProgressed = syncProgressed
+
+      @scanner = MSScanner.sharedInstance
+      @scanner.syncWithDelegate(self) unless @scanner.isSyncing
+    end
+
+  private
+
+    def scannerWillSync(scanner)
+      @syncStarted.call
+    end
+
+    def didSyncWithProgress(progress, total:total)
+      @syncProgressed.call(progress, total)
+    end
+
+    def scannerDidSync(scanner)
+      @lastSync = NSDate.date.timeIntervalSince1970
+      @syncCompleted.call(scanner.count(nil))
+    end
+    
+    def scanner(scanner, failedToSyncWithError:error)
+      errorCode = error.code
+      if errorCode >= 0 and errorCode != MS_BUSY
+        errorString = NSString.stringWithCString(ms_errmsg(errorCode), encoding:NSUTF8StringEncoding)
+        NSLog("[MOODSTOCKS SDK] FAILED TO SYNC WITH ERROR : #{errorString}.")
+      end
+      @syncFailed.call(error)
+    end
+
+  end
+
+end

data/lib/motionscan/version.rb

@@ -0,0 +1,3 @@
+module Motionscan
+  VERSION = "0.0.1"
+end

data/lib/motionscan.rb

@@ -0,0 +1,13 @@
+require 'motion/project/motionscan'
+require 'motionscan/version'
+require 'motion-cocoapods'
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'motionscan/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: motionscan
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joffrey Jaffeux
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A RubyMotion Moodstocks SDK image recognition wrapper
+email:
+- j.jaffeux@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- Motionscan.gemspec
+- README.md
+- RakefileExample
+- app/app_delegate.rb
+- app/root_view_controller.rb
+- app/scanner_view_controller.rb
+- lib/motion/project/motionscan.rb
+- lib/motionscan.rb
+- lib/motionscan/flash.rb
+- lib/motionscan/result.rb
+- lib/motionscan/scanner.rb
+- lib/motionscan/sync.rb
+- lib/motionscan/version.rb
+homepage: https://github.com/jjaffeux/Motionscan
+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.23
+signing_key: 
+specification_version: 3
+summary: A RubyMotion Moodstocks SDK image recognition wrapper
+test_files: []