headshot 0.1.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Diwa del Mundo (diwadm@gmail.com)
+
+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,37 @@
+Headshot
+========
+
+Headshot is a gem that provides a quick and easy way for Ruby on Rails applications to capture users' photos via a web camera without touching ActionScript or JavaScript code. It works by embedding a Flash component in your page's view to access the user's camera and capture the user's photo. Headshot takes care of the configuration and initialization of the Flash component and other support code in your Rails application simplifying the web cam integration process.
+
+Sample Code
+========
+
+Below is some sample code to setup Headshot:
+
+<b>Controller</b>
+
+`class HeadshotDemoController < ApplicationController`
+
+`helper :headshot`
+
+`end`
+
+
+<b>View</b>
+
+`<%= headshot_default_config(Rails.application.config.session_options[:key], headshot_capture_path) %>`
+
+`<%= headshot_camera %>`
+
+`<%= headshot_snap_button('Shoot') %>`
+
+Demo
+========
+
+Demo and complete documentation are available here:
+
+[http://headshot.hypermediasoft.com](http://headshot.hypermediasoft.com)
+
+Copyright and Author
+=======
+Copyright (c) 2013 Diwa del Mundo (diwadm@gmail.com), released under the MIT license

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Headshot'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/middlewares/flash_session_cookie_middleware.rb

@@ -0,0 +1,18 @@
+require 'rack/utils'
+
+class FlashSessionCookieMiddleware
+  def initialize(app, session_key = '_session_id')
+    @app = app
+    @session_key = session_key
+  end
+
+  def call(env)
+    if env['HTTP_USER_AGENT'] =~ /^(Adobe|Shockwave) Flash/
+      req = Rack::Request.new(env)
+      env['HTTP_COOKIE'] = [ @session_key, ::Rack::Utils.escape(req.params[@session_key]) ].join('=').freeze unless req.params[@session_key].nil?
+      env['HTTP_ACCEPT'] = "#{req.params['_http_accept']}".freeze unless req.params['_http_accept'].nil?
+    end
+
+    @app.call(env)
+  end
+end

data/lib/app/controllers/headshot_controller.rb

@@ -0,0 +1,59 @@
+class HeadshotController < ApplicationController
+  include HeadshotSupport
+  def capture
+    file_path = ''
+    begin
+      file_path = method(:headshot_custom_file_path).call
+    rescue
+      file_path = headshot_file_path
+    end
+
+    # Pre save hook.
+    begin
+      method(:headshot_pre_save).call(file_path)
+    rescue
+      # No pre save hook.
+    end
+
+    # Method for saving the JPEG file.
+    begin
+      method(:headshot_custom_save_image).call(file_path, request.raw_post)
+
+    # Only catch the error if method is undefined.
+    rescue NameError => e
+      saving_result = headshot_save_image(file_path, request.raw_post)
+
+      unless saving_result
+        render :json => {
+          :status => 'Error',
+          :message => 'Saving of headshot failed.'
+        }
+        return
+      end
+    end
+
+    # Post save hook.
+    begin
+      method(:headshot_post_save).call(file_path)
+    rescue
+      @headshot_photo = HeadshotPhoto.create(
+        :image_file_name => File.basename(file_path),
+        :image_content_type => 'image/jpeg',
+        :image_updated_at => Time.now
+      )
+    end
+
+    headshot_url = ""
+    begin
+      headshot_url = method(:headshot_custom_image_url).call(File.basename(file_path))
+    rescue
+      headshot_url = "#{headshot_image_url(File.basename(file_path))}"
+    end
+
+    render :json => {
+      :status => 'Success',
+      :message => 'Headshot saved.',
+      :url => headshot_url
+    }
+  end
+end

data/lib/app/helpers/headshot_helper.rb

@@ -0,0 +1,63 @@
+module HeadshotHelper
+  def headshot_snap_button(label = 'Snap', options = {})
+    options.reverse_merge!({
+      :onclick => 'headshotHandlers.snap()'
+    })
+
+    button_tag(label, options)
+  end
+
+  def headshot_config_button(label = 'Configure', options = {})
+    options.reverse_merge!({
+      :onclick => 'headshot.configure()'
+    })
+
+    button_tag(label, options)
+  end
+
+  def headshot_camera(width = 400, height = 300)
+    raw(%{
+    <script language="JavaScript">
+      headshotInitializer.setup(#{width}, #{height}, params);
+    </script>
+    })
+  end
+
+  def headshot_default_config(session_key, capture_path, options = {})
+    options.reverse_merge!(headshot_default_options)
+    session_value = u(cookies[session_key])
+    raw(%{
+    <script language="JavaScript">
+        var params = {
+            session_key_name: encodeURIComponent('#{session_value}'),
+            csrf_token: encodeURI(encodeURI(headshotUtils.getPageMetaValue('csrf-token')))
+        };
+
+        var headshotHandlers = {
+            onComplete: function(msg) {
+                headshot.reset();
+            },
+            snap: function() {
+                headshot.snap();
+            }
+        }
+
+        headshot.set_swf_url('#{options[:swf_url]}');
+        headshot.set_api_url('#{capture_path}');
+        headshot.set_quality(#{options[:quality]});
+        headshot.set_shutter_sound(#{options[:shutter_sound]}, '#{options[:shutter_sound_url]}');
+        headshot.set_hook('onComplete', '#{options[:on_complete]}');
+    </script>
+    })
+  end
+
+  def headshot_default_options
+    {
+        :swf_url => '/swfs/headshot.swf',
+        :quality => 90,
+        :shutter_sound => true,
+        :shutter_sound_url => '/audio/shutter.mp3',
+        :on_complete => 'headshotHandlers.onComplete'
+    }
+  end
+end

data/lib/app/lib/headshot_support.rb

@@ -0,0 +1,30 @@
+module HeadshotSupport
+  def headshot_file_path
+    file_name = "headshot_capture_#{headshot_file_timestamp}.jpg"
+    File.join(Rails.root, 'public', 'headshots', file_name)
+  end
+
+  def headshot_image_url(file_name)
+    'http://' + request.host_with_port + '/headshots/' + file_name
+  end
+
+  def headshot_save_image(file_path, raw_jpeg_data)
+    if raw_jpeg_data
+      begin
+        File.open(file_path, 'wb') do |file|
+          file.write raw_jpeg_data
+        end
+      rescue
+        raise "Headshot: cannot save headshot on #{file_path}. Please check file permissions."
+      end
+    else
+      return nil
+    end
+
+    true
+  end
+
+  def headshot_file_timestamp
+    "#{rand(10000)}_#{Time.now.to_i}"
+  end
+end

data/lib/app/models/headshot_photo.rb

@@ -0,0 +1,7 @@
+class HeadshotPhoto < ActiveRecord::Base
+  attr_accessible :description, :image_content_type, :image_file_name, :image_file_size, :image_updated_at
+
+  belongs_to :capturable, :polymorphic => true
+
+  #has_attached_file :image, :styles => { :medium => "300x300>", :thumb => "100x100>" }
+end

data/lib/assets/javascripts/headshot.js

@@ -0,0 +1,206 @@
+/* headshot */
+/* Easily capture webcam images on Rails applications. */
+/* Initially based on JPEGCam v1.0.9 by Joseph Huckaby. */
+/* Copyright 2012 - Diwa del Mundo <diwadm@gmail.com> */
+/* Licensed under the GNU Lesser Public License */
+/* http://www.gnu.org/licenses/lgpl.html */
+
+/* Usage:
+	<script language="JavaScript">
+		document.write( headshot.get_html(320, 240) );
+		headshot.set_api_url( 'test.php' );
+		headshot.set_hook( 'onComplete', 'my_callback_function' );
+		function my_callback_function(response) {
+			console.log("Server responded: " + response);
+		}
+	</script>
+	<a href="javascript:void(headshot.snap())">Take Snapshot</a>
+*/
+
+window.headshot = {
+	version: '0.1.0',
+	
+	// globals
+	ie: !!navigator.userAgent.match(/MSIE/),
+	protocol: location.protocol.match(/https/i) ? 'https' : 'http',
+	callback: null, // user callback for completed uploads
+	swf_url: 'headshot.swf', // URI to headshot.swf movie (defaults to cwd)
+	shutter_url: 'shutter.mp3', // URI to shutter.mp3 sound
+	api_url: '', // URL to upload script
+	loaded: false, // true when headshot movie finishes loading
+	quality: 90, // JPEG quality (1 - 100)
+	shutter_sound: true, // shutter sound effect on/off
+	stealth: false, // stealth mode (do not freeze image upon capture)
+	hooks: {
+		onLoad: null,
+		onComplete: null,
+		onError: null
+	}, // callback hook functions
+	
+	set_hook: function(name, callback) {
+		// set callback hook
+		// supported hooks: onLoad, onComplete, onError
+		if (typeof(this.hooks[name]) == 'undefined')
+			return alert("Hook type not supported: " + name);
+		
+		this.hooks[name] = callback;
+	},
+	
+	fire_hook: function(name, value) {
+		// fire hook callback, passing optional value to it
+		if (this.hooks[name]) {
+			if (typeof(this.hooks[name]) == 'function') {
+				// callback is function reference, call directly
+				this.hooks[name](value);
+			}
+			else if (typeof(this.hooks[name]) == 'array') {
+				// callback is PHP-style object instance method
+				this.hooks[name][0][this.hooks[name][1]](value);
+			}
+			else if (window[this.hooks[name]]) {
+				// callback is global function name
+				window[ this.hooks[name] ](value);
+			}
+            else if (typeof(this.hooks[name]) == 'string') {
+                // callback is a function but has a namespace
+                var funcName = this.hooks[name] + "('" + value + "')";
+                eval(funcName);
+            }
+			return true;
+		}
+		return false; // no hook defined
+	},
+	
+	set_api_url: function(url) {
+		// set location of upload API script
+		this.api_url = url;
+	},
+	
+	set_swf_url: function(url) {
+		// set location of SWF movie (defaults to headshot.swf in cwd)
+		this.swf_url = url;
+	},
+	
+	get_html: function(width, height, params) {
+		// Return HTML for embedding headshot capture movie
+		// Specify pixel width and height (640x480, 320x240, etc.)
+		// Server width and height are optional, and default to movie width/height
+        server_width = params.server_width ? params.server_width : width;
+        server_height = params.server_height ? params.server_height : height;
+        session_key_name = params.session_key_name ? params.session_key_name : '';
+        csrf_token = params.csrf_token ? params.csrf_token : '';
+		
+		var html = '';
+		var flashvars = 'shutter_enabled=' + (this.shutter_sound ? 1 : 0) + 
+			'&shutter_url=' + escape(this.shutter_url) + 
+			'&width=' + width + 
+			'&height=' + height + 
+			'&server_width=' + server_width + 
+			'&server_height=' + server_height +
+            '&session_key_name=' + session_key_name +
+            '&csrf_token=' + csrf_token;
+		
+		if (this.ie) {
+			html += '<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" codebase="'+this.protocol+'://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" width="'+width+'" height="'+height+'" id="headshot_movie" align="middle"><param name="allowScriptAccess" value="always" /><param name="allowFullScreen" value="false" /><param name="movie" value="'+this.swf_url+'" /><param name="loop" value="false" /><param name="menu" value="false" /><param name="quality" value="best" /><param name="bgcolor" value="#ffffff" /><param name="flashvars" value="'+flashvars+'"/></object>';
+		}
+		else {
+			html += '<embed id="headshot_movie" src="'+this.swf_url+'" loop="false" menu="false" quality="best" bgcolor="#ffffff" width="'+width+'" height="'+height+'" name="headshot_movie" align="middle" allowScriptAccess="always" allowFullScreen="false" type="application/x-shockwave-flash" pluginspage="http://www.macromedia.com/go/getflashplayer" flashvars="'+flashvars+'" />';
+		}
+		
+		this.loaded = false;
+		return html;
+	},
+	
+	get_movie: function() {
+		// get reference to movie object/embed in DOM
+		if (!this.loaded) return alert("ERROR: Movie is not loaded yet");
+		var movie = document.getElementById('headshot_movie');
+		if (!movie) alert("ERROR: Cannot locate movie 'headshot_movie' in DOM");
+		return movie;
+	},
+	
+	set_stealth: function(stealth) {
+		// set or disable stealth mode
+		this.stealth = stealth;
+	},
+	
+	snap: function(url, callback, stealth) {
+		// take snapshot and send to server
+		// specify fully-qualified URL to server API script
+		// and callback function (string or function object)
+		if (callback) this.set_hook('onComplete', callback);
+		if (url) this.set_api_url(url);
+		if (typeof(stealth) != 'undefined') this.set_stealth( stealth );
+		
+		this.get_movie()._snap( this.api_url, this.quality, this.shutter_sound ? 1 : 0, this.stealth ? 1 : 0 );
+	},
+	
+	freeze: function() {
+		// freeze headshot image (capture but do not upload)
+		this.get_movie()._snap('', this.quality, this.shutter_sound ? 1 : 0, 0 );
+	},
+	
+	upload: function(url, callback) {
+		// upload image to server after taking snapshot
+		// specify fully-qualified URL to server API script
+		// and callback function (string or function object)
+		if (callback) this.set_hook('onComplete', callback);
+		if (url) this.set_api_url(url);
+		
+		this.get_movie()._upload( this.api_url );
+	},
+	
+	reset: function() {
+		// reset movie after taking snapshot
+		this.get_movie()._reset();
+	},
+	
+	configure: function(panel) {
+		// open flash configuration panel -- specify tab name:
+		// "camera", "privacy", "default", "localStorage", "microphone", "settingsManager"
+		if (!panel) panel = "camera";
+		this.get_movie()._configure(panel);
+	},
+	
+	set_quality: function(new_quality) {
+		// set the JPEG quality (1 - 100)
+		// default is 90
+		this.quality = new_quality;
+	},
+	
+	set_shutter_sound: function(enabled, url) {
+		// enable or disable the shutter sound effect
+		// defaults to enabled
+		this.shutter_sound = enabled;
+		this.shutter_url = url ? url : 'shutter.mp3';
+	},
+	
+	flash_notify: function(type, msg) {
+		// receive notification from flash about event
+		switch (type) {
+			case 'flashLoadComplete':
+				// movie loaded successfully
+				this.loaded = true;
+				this.fire_hook('onLoad');
+				break;
+
+			case 'error':
+				// HTTP POST error most likely
+				if (!this.fire_hook('onError', msg)) {
+					alert("Flash Error: " + msg);
+				}
+				break;
+
+			case 'success':
+				// upload complete, execute user callback function
+				// and pass raw API script results to function
+				this.fire_hook('onComplete', msg.toString());
+				break;
+
+			default:
+				// catch-all, just in case
+				alert("flash_notify: " + type + ": " + msg);
+				break;
+		}
+	}
+};

data/lib/assets/javascripts/headshot_support.js

@@ -0,0 +1,27 @@
+var headshotUtils = {
+    getPageMetaTags:function () {
+        return document.getElementsByTagName('meta');
+    },
+    getPageMetaValue:function (metaName) {
+        var metaValue = '';
+        var pageMetaTags = headshotUtils.getPageMetaTags();
+        if (pageMetaTags.length > 0) {
+            for (var i = 0; i < pageMetaTags.length; i++) {
+                if (pageMetaTags[i]['name'] == metaName) {
+                    metaValue = pageMetaTags[i]['content'];
+                }
+            }
+        }
+
+        return metaValue;
+    }
+};
+
+var headshotInitializer = {
+    setup: function(width, height, railsTokens) {
+        document.write(headshot.get_html(width, height, railsTokens));
+    },
+    setupHTML: function(width, height, railsTokens) {
+        return headshot.get_html(width, height, railsTokens);
+    }
+};

data/lib/db/migrate/create_headshot_photos.rb

@@ -0,0 +1,13 @@
+class CreateHeadshotPhotos < ActiveRecord::Migration
+  def change
+    create_table :headshot_photos do |t|
+      t.string :description
+      t.string :image_file_name
+      t.string :image_content_type
+      t.integer :image_file_size
+      t.references :capturable, :polymorphic => true
+      t.datetime :image_updated_at
+      t.timestamps
+    end
+  end
+end

data/lib/generators/headshot/config/config_generator.rb

@@ -0,0 +1,45 @@
+require 'rails'
+
+module Headshot
+  module Generators
+    class ConfigGenerator < ::Rails::Generators::Base
+      desc "This generator configures the application so it would be able to communicate with the Headshot Flash binary."
+      source_root File.expand_path('../../../../../lib/assets', __FILE__)
+
+      def copy_flash_middleware
+        say_status('copying', 'Copying Flash session cookie middleware ...')
+        copy_file('../middlewares/flash_session_cookie_middleware.rb', 'app/middlewares/flash_session_cookie_middleware.rb')
+      end
+
+      def load_middlewares_in_application_rb
+        application_rb_path = "config/application.rb"
+        code_marker = "class Application < Rails::Application"
+        loading_code = 'config.autoload_paths += %W(#{config.root}/app/middlewares)'
+        say_status('checking', 'Checking if application.rb contains the loading code for the middleware.')
+
+        inject_into_file application_rb_path, :after => "#{code_marker}\n" do
+          "\t\t#{loading_code}\n"
+        end
+      end
+
+      def initialize_session_store
+        session_store_rb_path = "config/initializers/session_store.rb"
+        loading_code = 'config.autoload_paths += %W(#{config.root}/app/middlewares)'
+        say_status('checking', 'Checking if session_store.rb contains the code for initializing for the middleware.')
+        initializer_code = "\n"
+
+        inside(source_paths[0] + '/../initializers', :verbose => true) do
+          initializer_code_lines = IO.readlines('session_store.rb')
+          initializer_code += initializer_code_lines.join('')
+        end
+
+        append_file(session_store_rb_path, initializer_code)
+      end
+
+      def create_default_directories
+        say_status('creating', 'Creating default headshots directory public/headshots.')
+        create_file('public/headshots/empty_file', '')
+      end
+    end
+  end
+end

data/lib/generators/headshot/generate/generate_generator.rb

@@ -0,0 +1,26 @@
+require 'rails'
+require 'rails/generators/migration'
+
+module Headshot
+  module Generators
+    class GenerateGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      desc "This generator creates the template controllers, models, helpers, routes, and migrations."
+      source_root File.expand_path('../../../../../', __FILE__)
+
+      # Copied migration template generator from http://stackoverflow.com/questions/4141739/generators-and-migrations-in-plugins-rails-3
+      def self.next_migration_number(path)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def add_headshot_routes
+        route %{post "headshot/capture" => 'headshot#capture', :as => :headshot_capture}
+      end
+
+      def create_model_file
+        template "lib/app/models/headshot_photo.rb", "app/models/headshot_photo.rb"
+        migration_template "lib/db/migrate/create_headshot_photos.rb", "db/migrate/create_headshot_photos.rb"
+      end
+    end
+  end
+end

data/lib/generators/headshot/install/install_generator.rb

@@ -0,0 +1,37 @@
+require 'rails'
+
+#if ::Rails.version < '3.1' || !::Rails.application.config.assets.enabled
+
+module Headshot
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc "This generator install the Headshot assets (JavaScript, Audio, and Flash application files)."
+      source_root File.expand_path('../../../../../lib/assets', __FILE__)
+
+      def copy_javascripts
+        say_status('copying', 'Copying Javascripts ...')
+        copy_file('javascripts/headshot.js', 'app/assets/javascripts/headshot.js')
+        copy_file('javascripts/headshot_support.js', 'app/assets/javascripts/headshot_support.js')
+      end
+
+      def copy_audio_files
+        say_status('copying', 'Copying Audio files ...')
+        copy_file('audio/shutter.mp3', 'public/audio/shutter.mp3')
+      end
+
+      def copy_flash_app_files
+        say_status('copying', 'Copying Flash application files ...')
+        copy_file('swfs/headshot.swf', 'public/swfs/headshot.swf')
+      end
+
+      def run_other_generators
+        generate("headshot:config")
+        generate("headshot:generate")
+      end
+    end
+  end
+end
+
+# else
+  # TODO: what do we do when app is asset-pipelined?
+# end

data/lib/headshot/version.rb

@@ -0,0 +1,3 @@
+module Headshot
+  VERSION = "0.1.4"
+end

data/lib/headshot.rb

@@ -0,0 +1,11 @@
+require 'active_support/dependencies'
+
+%w{controllers helpers lib}.each do |dir|
+  path = File.join(File.dirname(__FILE__), 'app', dir)
+  $LOAD_PATH << path
+  ActiveSupport::Dependencies.autoload_paths << path
+  ActionController::Base.helper Headshot
+end
+
+module Headshot
+end

data/lib/initializers/session_store.rb

@@ -0,0 +1 @@
+Rails.application.config.middleware.insert_before(Rails.application.config.session_store, FlashSessionCookieMiddleware, Rails.application.config.session_options[:key])