motional 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.repl_history
+build
+.DS_Store

data/.travis.yml

@@ -0,0 +1,5 @@
+language: objective-c
+before_install: rvm use ruby-1.9.3-p392
+script: 
+  - bundle exec rake spec files=spec_helper
+  - bundle exec rake spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in motional.gemspec 
+gemspec

data/Guardfile

@@ -0,0 +1,13 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'motion' do
+  watch(%r{^spec/.+_spec\.rb$})
+
+  # RubyMotion App example
+  watch(%r{^app/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+
+  # RubyMotion gem example
+  watch(%r{^lib/[^/]+/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 akahige
+
+MIT License
+
+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,128 @@
+# MotionAL
+
+AssetLibrary framework wrapper for RubyMotion.
+
+*This gem is a beta quality.*
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motional'
+
+And then execute:
+
+    $ bundle
+
+## Setup
+
+Add this code to your application's Rakefile.
+
+    require 'bundler'
+    Bundler.require(:development)
+
+## Overview
+
+### Library
+
+    # singleton for the lifetime.
+    library = MotionAL.library # should not call `Motional::Library.new` directly.
+
+    library.groups # An alias of MotionAL::Group
+    library.groups.each do |group|
+      # asynchronous
+      # enumerate all groups except Photo Library
+    end
+
+    # open Camera Roll
+    library.groups.find_camera_roll do |group| 
+      # asynchronous    
+      group.assets.each do |asset|
+        # enumerate all assets in the camera roll
+      end
+    end
+
+    # open Photo Library synced from itunes
+    library.groups.find_photo_library {|group| ... # asynchronous }
+
+    library.al_asset_library # An instance of ALAssetLibrary
+
+    MotionAL.authorized? # check permission to access Asset Library. see Settings > Privacy > Photos
+
+### Group
+
+    MotionAL::Group.create('MyAppAlbum') do |group|
+      # asynchronous
+      group.name #=> 'MyAppAlbum'
+      group.url.absoluteString # save this to permanent strage
+    end
+    
+    MotionAL::Group.find_by_url(saved_url_absolute_string) do |group|
+      # accept NSURL or String 
+      # asynchronous
+      p group.name #=> 'MyAppAlbum'
+    end
+
+    group.assets # An instance of MotionAL::Assets
+    group.assets.each {|asset| ... # asynchronous }
+    group.assets.create(image_data, metadata) {|asset| ... # asynchronous } # create asset and add to the group
+    group.assets << some_asset # an asset add to the group.
+
+    group.al_asset_group # An instance of ALAssetGroup
+    
+### Asset
+
+    MotionAL::Asset.create(image_data, metadata) do |asset|
+      asset.url.absoluteString # save this to permanent strage
+    end
+
+    MotionAL::Asset.find_by_url(saved_url_absolute_string) {|asset| ...  # asynchronous }
+
+    asset.representations # An instance of Representations
+    asset.representations.each {|rep| ... # not asynchronous }
+
+    asset.default_representation # An instance of MotionAL::Representation for default representation.
+
+    # properties
+    asset.location
+    asset.media_type # :photo or :video
+    MotionAL.asset_types(asset.media_type) # to get objective-c constant value
+    asset.orientation # :up, :down, :left...
+    MotionAL.asset_orientations(asset.orientation) # to get objective-c constant value
+
+    # default representation properties
+    asset.filename
+    asset.metadata
+    asset.full_resolution_image
+    asset.full_screen_image
+    
+    asset.al_asset # An instance of ALAsset
+
+### Representation
+
+    # properties
+    rep.filename
+    rep.metadata
+    rep.full_resolution_image
+    rep.full_screen_image
+
+    rep.al_asset_representation # An instance of ALAssetRepresentation
+
+## How to run specs
+
+### Preparing test data
+
+    rake spec files=spec_helper
+
+### Run specs
+
+    rake spec
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Check all specs passed on your simurator (`rake spec`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+
+$:.unshift("/Library/RubyMotion/lib")
+$:.unshift("#{File.dirname(__FILE__)}/lib")
+require 'motion/project/template/ios'
+require 'bundler'
+
+Bundler.require(:development)
+
+require 'motional'
+
+Motion::Project::App.setup do |app|
+  app.name = 'MotionAL'
+  app.redgreen_style = :full # :focused, :full
+end

data/app/app_delegate.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+
+# for testing
+class AppDelegate  
+  def application(application, didFinishLaunchingWithOptions: launchOptions)  
+    true  
+  end  
+
+  def test_image
+    @path = "#{NSBundle.mainBundle.resourcePath}/sample.jpg"
+    @url = NSURL.fileURLWithPath(@path)
+    cg_image_source = CGImageSourceCreateWithURL(@url, nil);
+  end
+end

data/lib/motional.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  app.frameworks += ['AssetsLibrary', 'ImageIO']
+  Dir.glob(File.join(File.dirname(__FILE__), 'motional/*rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/lib/motional/asset.rb

@@ -0,0 +1,426 @@
+# -*- encoding : utf-8 -*-
+
+module MotionAL
+  #
+  # A wrapper of ALAsset class.
+  #
+  #   An ALAsset object represents a photo or a video managed by the Photo application.
+  #   Assets can have multiple representations, for example a photo which was captured in RAW and JPG. Different representations of the same asset may have different dimensions.
+  #
+  # And added some convinience methods.
+  #
+  class Asset
+    # An instance of ALAsset.
+    attr_reader :al_asset
+
+    # @param al_asset [ALAsset]
+    def initialize(al_asset)
+      @al_asset = al_asset
+    end
+
+    # @return [MotionAL::Representations] The collection of representations in the asset.
+    def representations
+      @representations ||= Representations.new(self)
+    end
+
+    # Create an asset.
+    #
+    # @param source [CGImage, NSData, NSURL] CGImage and NSData for the photo, NSURL for the video.
+    # @param metadata [Hash] Metadata for the photo.
+    # @return [nil]
+    #
+    # @yield [asset, error]
+    # @yieldparam asset [MotionAL::Asset] A created asset.
+    # @yieldparam error [error]
+    #
+    # @note use `MotionAL::Asset.video_compatible?(video_path_url)` before creating video.
+    #
+    # @example
+    #   MotionAL::Asset.create(data, meta) do |asset, error|
+    #     # asynchronous if a block given
+    #     p asset.url.absoluteString
+    #   end
+    #
+    #   MotionAL::Asset.create(data, meta)
+    #
+    #   if MotionAL::Asset.video_compatible?(video_path_url)
+    #     MotionAL::Asset.create(data, meta)
+    #   else
+    #     p "This video contained incompatible data."
+    #   end
+    def self.create(source, metadata = nil, &block)
+      if source.kind_of?(NSData)
+        self.create_by_image_data(source, metadata, block)
+      elsif source.kind_of?(NSURL)
+        self.create_by_video_path(source, block)
+      else
+        self.create_by_cg_image(source, metadata, block)
+      end
+    end
+
+    # Find an asset by a specified asset_url.
+    #
+    # @param asset_url [NSURL]
+    # @return [nil]
+    #
+    # @yield [asset, error]
+    # @yieldparam asset [MotionAL::Asset] A found asset.
+    # @yieldparam error [error]
+    #
+    # @example
+    #   MotionAL::Asset.find_by_url(url) do |asset, error|
+    #     # asynchronous if a block given
+    #     p asset.url.absoluteString
+    #   end
+    def self.find_by_url(asset_url, &block)
+      url = asset_url.is_a?(String) ? NSURL.alloc.initWithString(asset_url) : asset_url
+      self.origin_find_by_url(url, block)
+    end
+
+    # Find and enumerate assets by options.
+    #
+    # @param options [Hash]
+    # @option options [MotionAL::Group] :group Default is the Camera Roll.
+    # @option options [Symbol] :filter :all, :photo or :video
+    # @option options [Symbol] :order :asc or :desc
+    # @option options [NSIndexSet] :indexset
+    # @return [nil]
+    #
+    # @yield [asset, error]
+    # @yieldparam asset [MotionAL::Asset] A found asset.
+    # @yieldparam error [error]
+    #
+    # @example
+    #   MotionAL::Asset.find_all do |asset, error|
+    #     # asynchronous if a block given
+    #     p asset.url.absoluteString
+    #   end
+    #
+    #   MotionAL::find_by_name('MyAppAlbum') do |group|
+    #     MotionAL::Asset.find_all(group: group, order: :desc, filter: :photo) do |asset|
+    #       p asset.url.absoluteString
+    #     end
+    #   end
+    #
+    #   indexset = NSMutableIndexSet.indexSetWithIndexesInRange(1..3)
+    #   MotionAL::Asset.find_all(indexset: indexset, order: :desc) do |asset|
+    #     p asset.url.absoluteString
+    #   end
+    def self.find_all(options = {}, &block)
+      self.origin_find_all(options, block)
+    end
+    class << self
+      alias_method :each, :find_all
+    end
+
+    # @return [Boolean] false means ALAssetLibrary cannot treat the video file.
+    def self.video_compatible?(video_path_url)
+      MotionAL.library.al_asset_library.videoAtPathIsCompatibleWithSavedPhotosAlbum(video_path_url)
+    end
+
+
+    # @return [CGImageRef] Returns a thumbnail of the asset.
+    def thumbnail
+      self.al_asset.thumbnail
+    end
+
+    # @return [CGImageRef] Returns an aspect ratio thumbnail of the asset.
+    def aspect_ratio_thumbnail
+      self.al_asset.aspectRatioThumbnail
+    end
+
+    # Return true if the app haves write access for the asset.
+    # In other words true means the app can call `#update` for the asset.
+    #
+    # @return [Boolean]
+    def editable?
+      @al_asset.editable?
+    end
+
+    # The original version of the asset.
+    #
+    # @return [MotionAL::Asset]
+    # @return [nil] The asset has no original asset.
+    #
+    # @note The original asset was set when the asset was created by `#save_new`
+    def original_asset
+      original_al_asset = @al_asset.originalAsset
+      Asset.new(original_al_asset) if original_al_asset
+    end
+
+    # @return [MotionAL::Representation] The default representation of the asset. A representation is an actual file.
+    def default_representation
+      @default_representation ||= Representation.new(@asset, @al_asset.defaultRepresentation)
+    end
+    alias_method :rep, :default_representation
+    alias_method :file, :default_representation
+    alias_method :representation, :default_representation
+
+    # wrapper for valueForProperty
+    class << self
+      private
+      # @!macro [attach] make_wrapper
+      #   The asset's $1
+      #   @method $1
+      #   @return [$3] The value for the property $2.
+      #   @return [nil] The property is empty.
+      def make_wrapper_for_property(method_name, property_name, type_of_return)
+        define_method(method_name) do 
+          @al_asset.valueForProperty(property_name)
+        end
+      end
+    end
+    make_wrapper_for_property(:location, ALAssetPropertyLocation, "CLLocation")
+    make_wrapper_for_property(:duration, ALAssetPropertyDuration, "Float")
+    make_wrapper_for_property(:date, ALAssetPropertyDate, "Time")
+    make_wrapper_for_property(:url, ALAssetPropertyAssetURL, "NSURL")
+    make_wrapper_for_property(:representation_utis, ALAssetPropertyRepresentations, "Array")
+    make_wrapper_for_property(:representation_urls, ALAssetPropertyURLs, "Array")
+
+    alias_method :reps, :representations
+    alias_method :files, :representations
+
+    # The type of the asset.
+    #
+    # @return [Symbol] :photo or :video
+    def asset_type
+      MotionAL.asset_types.key(@al_asset.valueForProperty(ALAssetPropertyType))
+    end
+
+    # The orientation of the asset.
+    #
+    # @return [Symbol] :up, :down :left, :right, :up_mirrored, :down_mirrored, :left_mirrored or :right_mirrored
+    def orientation
+      MotionAL.asset_orientations.key(@al_asset.valueForProperty(ALAssetPropertyOrientation))
+    end
+
+    class << self
+      private
+      # wrapper for representation method
+      # @!macro [attach] make_wrapper
+      #   The default representation's $1
+      #   @method $1
+      #   @return [$2] The same as the default representation's $1
+      #   @return [nil] The property is empty.
+      def make_wrapper_for_representation_method(method_name, type_of_return)
+        define_method(method_name) do 
+          default_representation.send(method_name)
+        end
+      end
+    end
+    make_wrapper_for_representation_method(:full_resolution_image, "CGImageRef")
+    make_wrapper_for_representation_method(:full_screen_image, "CGImageRef")
+    make_wrapper_for_representation_method(:scale, "Float")
+    make_wrapper_for_representation_method(:data, "NSConcreteData")
+    make_wrapper_for_representation_method(:cg_image, "CGImageRef")
+    make_wrapper_for_representation_method(:dimensions, "CGSize")
+    make_wrapper_for_representation_method(:filename, "String")
+    make_wrapper_for_representation_method(:size, "Fixnum")
+    make_wrapper_for_representation_method(:metadata, "Hash")
+
+    # Create a new asset forked by the asset.
+    #
+    # @param source [NSData, NSURL] NSData for the photo, NSURL for the video.
+    # @param metadata [Hash] Metadata for the photo.
+    # @return [nil]
+    #
+    # @yield [asset, error]
+    # @yieldparam asset [MotionAL::Asset] A created asset.
+    # @yieldparam error [error]
+    #
+    # @note use `MotionAL::Asset.video_compatible?(video_path_url)` before creating video.
+    #
+    # @example
+    #   asset_a.save_new(imagedata, meta) do |asset, error| do
+    #     # asynchronous if a block given
+    #     p asset.url.absoluteString
+    #     p asset.original_asset.url.absoluteString 
+    #   end
+    #
+    #   asset_a.create(imagedata, meta)
+    def save_new(source, metadata = nil, &block)
+      origin_save_new(source, metadata, block)
+    end
+
+    # Update the asset.
+    # In other words replacing the asset's representation.
+    #
+    # @param source [NSData, NSURL] NSData for the photo, NSURL for the video.
+    # @param metadata [Hash] Metadata for the photo.
+    # @return [nil]
+    #
+    # @yield [asset, error]
+    # @yieldparam asset [MotionAL::Asset] A updated asset.
+    # @yieldparam error [error]
+    #
+    # @note use `MotionAL::Asset.video_compatible?(video_path_url)` before updating video.
+    #
+    # @example
+    #   asset_a.update(imagedata, meta) do |asset, error| do
+    #     # asynchronous if a block given
+    #     p asset.url.absoluteString
+    #   end
+    #
+    #   asset_a.update(imagedata, meta)
+    def update(source, metadata = nil, &block)
+      origin_update(source, metadata, block)
+    end
+
+    private
+    def self.create_by_cg_image(cg_image, meta, callback = nil)
+      if self.only_orientation?(meta)
+        MotionAL.library.al_asset_library.writeImageToSavedPhotosAlbum(
+          cg_image,
+          orientation: MotionAL.asset_orientations[meta[:orientation]],
+          completionBlock: self.completion_block_for_create(callback)
+        )
+      else
+        MotionAL.library.al_asset_library.writeImageToSavedPhotosAlbum(
+          cg_image,
+          metadata: meta,
+          completionBlock: self.completion_block_for_create(callback)
+        )
+      end
+    end
+
+    def self.only_orientation?(meta)
+      meta && meta.size == 1 && meta[:orientation]
+    end
+
+    def self.origin_find_by_url(asset_url, callback = nil)
+
+      MotionAL.library.al_asset_library.assetForURL(
+        asset_url, 
+        resultBlock: lambda {|al_asset|
+          if al_asset
+            found_asset = self.new(al_asset)
+            callback.call(found_asset, nil) if callback
+          end
+        }, 
+        failureBlock: lambda {|error|
+          callback.call(nil, error) if callback
+        }
+      )
+    end
+
+    def self.origin_find_all(options = {}, callback = nil)
+      if options[:group]
+        group_name = options[:group].name
+      else
+        group_name = /Camera Roll|Saved Photos/
+      end
+      options[:order] ||= :asc
+
+      MotionAL::Group.find_by_name(group_name) do |group, error|
+        order = MotionAL.enum_orders[options[:order]]
+        AssetsFilter.set(group, options[:filter]) if options[:filter]
+        if options[:indexset]
+          group.al_asset_group.enumerateAssetsAtIndexes(
+            options[:indexset],
+            options: order, 
+            usingBlock: using_block_for_all(options, callback)
+          )
+        elsif options[:order] == :desc
+          group.al_asset_group.enumerateAssetsWithOptions(order, usingBlock: using_block_for_all(options, callback))
+        else
+          group.al_asset_group.enumerateAssetsUsingBlock(using_block_for_all(options, callback))
+        end
+        AssetsFilter.reset(group) if options[:filter]
+      end
+    end
+
+    def self.using_block_for_all(options, callback = nil)
+      Proc.new do |al_asset, index, stop|
+        if !al_asset.nil?
+          asset = Asset.new(al_asset)
+          callback.call(asset, nil) if callback
+        end
+      end
+    end
+
+    def self.create_by_image_data(image_data, meta, callback = nil)
+      MotionAL.library.al_asset_library.writeImageDataToSavedPhotosAlbum(
+        image_data,
+        metadata: meta,
+        completionBlock: self.completion_block_for_create(callback)
+      )
+    end
+
+    def self.create_by_video_path(video_path_url, callback = nil)
+      MotionAL.library.al_asset_library.writeVideoAtPathToSavedPhotosAlbum(
+        video_path_url,
+        completionBlock: self.completion_block_for_create(callback)
+      )
+    end
+
+    def self.completion_block_for_create(callback = nil)
+      Proc.new do |asset_url, error|
+        MotionAL::Asset.find_by_url(asset_url) do |asset, error|
+          callback.call(asset, error) if callback
+        end
+      end
+    end
+
+    def completion_block_for_save_and_update(callback = nil)
+      Proc.new do |asset_url, error|
+        MotionAL::Asset.find_by_url(asset_url) do |asset, error|
+          @created_asset = asset
+          callback.call(@created_asset, error) if callback
+        end
+      end
+    end
+
+    def origin_save_new(source, metadata, callback = nil) 
+      case self.asset_type
+      when :photo
+        save_new_by_image_data(source, metadata) {|asset, error| callback.call(asset, error) if callback }
+      when :video
+        save_new_by_video_path(source) {|asset, error| callback.call(asset, error) if callback }
+      else
+        raise "ALAssetTypeUnknown"
+      end
+    end
+
+    def save_new_by_image_data(image_data, metadata, &block)
+      @al_asset.writeModifiedImageDataToSavedPhotosAlbum(
+        image_data, 
+        metadata: metadata,
+        completionBlock: completion_block_for_save_and_update(block)
+      )
+    end
+
+    def save_new_by_video_path(video_path, &block)
+      @al_asset.writeModifiedVideoAtPathToSavedPhotosAlbum(
+        video_path,
+        completionBlock: completion_block_for_save_and_update(block)
+      )
+    end
+
+    def origin_update(source, metadata = nil, callback = nil)
+      case self.asset_type
+      when :photo
+        update_by_image_data(source, metadata) {|asset, error| callback.call(asset, error) if callback }
+      when :video
+        update_by_video_path(source) {|asset, error| callback.call(asset, error) if callback}
+      else
+        raise "ALAssetTypeUnknown"
+      end
+    end
+
+    def update_by_image_data(image_data, metadata, &block)
+      @al_asset.setImageData(
+        image_data, 
+        metadata: metadata,
+        completionBlock: completion_block_for_save_and_update(block)
+      )
+    end
+
+    def update_by_video_path(video_path, &block)
+      @al_asset.setVideoAtPath(
+        video_path,
+        completionBlock: completion_block_for_save_and_update(block)
+      )
+    end
+
+  end
+end