termux_ruby_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2083d7b60af05f97608bb5fe8459217d709cd33f046a20f0f17b6cbaf0fa865a
+  data.tar.gz: 5df9f00f6e3e874cb79d57ea1a3b55127f8c7de5b7eb3bf93f072a78191dfec2
+SHA512:
+  metadata.gz: 0c4a4054e2a3b71f8b794fa115ad9158106b02b7d529191d9d1263bed47f1af58ec02e3972a5f463c6c206cfed402484e99f092bbe23b66cb2f56be72042846d
+  data.tar.gz: a16c51668561c314c89cc5249cc739fe6a478ffcfbf4c805f5bcc6156666b5bf86279b44ff93cf1165384e09a8ae571d190e9a4be04ce9f557d03dd4ea829325

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.17.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jes@josepegea.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in termux_ruby_api.gemspec
+gemspec
+
+group :development, :test do
+  gem 'pry'
+  gem 'pry-byebug'
+end

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    termux_ruby_api (0.1.0)
+      activesupport (~> 5.2.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    byebug (10.0.2)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.4)
+    diff-lcs (1.3)
+    i18n (1.5.2)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.2)
+    minitest (5.11.3)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  pry
+  pry-byebug
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  termux_ruby_api!
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Josep Egea
+
+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,77 @@
+# TermuxRubyApi
+
+TermuxRubyApi is a Gem that provides a Ruby interface to a lot of
+Android functionality thanks to [Termux](https://termux.com/) and
+[Termux API](https://wiki.termux.com/wiki/Termux:API).
+
+
+```ruby
+require 'termux_ruby_api'
+
+# Connect to the API
+t_api = TermuxRubyApi::Base.new
+
+# Get a list of the latest 50 calls
+call_log = t_api.call_log.log(limit: 50)
+
+# Get the total seconds spent in outgoing calls
+total_duration = call_log.select { |c| c[:type] == :OUTGOING }.map {|c| c[:duration] }.sum
+
+# Get the result in Text To Speak
+t_api.tts.speak("The total duration is #{total_duration} seconds")
+```
+
+[Termux](https://termux.com/) is a set of Android apps that provide a
+complete Debian-like environment for Android, including Ruby, RubyGems
+and a whole lot of other packages.
+
+Part of that package, Termux API provides a way to invoke specific
+Android functionality, like sending SMS, reading the call log,
+accessing the GPS, initiating a phone call and more.
+
+Termux API offers this connection by means of shell scripts that
+accept command arguments and return data in JSON format.
+
+TermuxRubyApi provides a convenient access to these scripts from the
+confort of a set of Ruby classes that encapsulate all their
+functionality and that allows the user to apply all the power and
+flexibility of Ruby to access and manipulate this data, interacting
+with the Android host.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'termux_ruby_api'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install termux_ruby_api
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/termux_ruby_api. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TermuxRubyApi project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/termux_ruby_api/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "termux_ruby_api"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/termux_ruby_api.rb

@@ -0,0 +1,9 @@
+require 'active_support/all'
+require "termux_ruby_api/version"
+require "termux_ruby_api/base"
+require "termux_ruby_api/sub_systems"
+require "termux_ruby_api/utils"
+
+module TermuxRubyApi
+  class Error < StandardError; end
+end

data/lib/termux_ruby_api/base.rb

@@ -0,0 +1,158 @@
+require 'json'
+require 'date'
+require 'time'
+require_relative 'sub_systems'
+require 'shellwords'
+require 'open3'
+
+require 'pry'
+
+module TermuxRubyApi
+
+  class CommandError < StandardError
+    attr_accessor :status, :stderr
+
+    def initialize(status: nil, stderr: nil)
+      @status = status
+      @stderr = stderr
+    end
+  end
+
+  class Base
+
+    # Returns the `clipboard` subsystem
+    # @return [TermuxRubyApi::SubSystems::Clipboard]
+    def clipboard
+      @clipboard ||= TermuxRubyApi::SubSystems::Clipboard.new(self)
+    end
+
+    # Returns the `tts` subsystem
+    # @return [TermuxRubyApi::SubSystems::Tts]
+    def tts
+      @tts ||= TermuxRubyApi::SubSystems::Tts.new(self)
+    end
+
+    # Returns the `call_log` subsystem
+    # @return [TermuxRubyApi::SubSystems::CallLog]
+    def call_log
+      @call_log ||= TermuxRubyApi::SubSystems::CallLog.new(self)
+    end
+
+    # Returns the `location` subsystem
+    # @return [TermuxRubyApi::SubSystems::Location]
+    def location
+      @location ||= TermuxRubyApi::SubSystems::Location.new(self)
+    end
+
+    # Returns the `sms` subsystem
+    # @return [TermuxRubyApi::SubSystems::Sms]
+    def sms
+      @sms ||= TermuxRubyApi::SubSystems::Sms.new(self)
+    end
+
+    # Returns the `sensor` subsystem
+    # @return [TermuxRubyApi::SubSystems::Sensor]
+    def sensor
+      @sensor ||= TermuxRubyApi::SubSystems::Sensor.new(self)
+    end
+
+    # Returns the `dialog` subsystem
+    # @return [TermuxRubyApi::SubSystems::Dialog]
+    def dialog
+      @dialog ||= TermuxRubyApi::SubSystems::Dialog.new(self)
+    end
+
+    # General executor of Termux API commands
+    # @param command [String] the termux command to execute (except the `termux-` prefix.
+    # @param stdin [String, nil] If not nil, the contents of `stdin` are passed as STDIN to the command
+    # @param args The rest of the arguments are passed verbatim to the executed command.
+    # @return [String] the STDOUT of the executed command
+    def api_command(command, stdin = nil, *args)
+      command, args = prepare_command_args(command, args)
+      stdout, stderr, status = Open3.capture3(command, *args, stdin_data: stdin.to_s)
+      raise CommandError.new(status: status, stderr: stderr) unless status.success?
+      stdout
+    end
+
+    # Executes a Termux API command returning the results parsed as JSON
+    # @param (see #api_command)
+    # @return native Ruby classes parsed from JSON
+    # @note JSON objects are converted to ActiveSupport::HashWithIndifferentAccess
+    def json_api_command(command, stdin = nil, *args)
+      res = api_command(command, stdin, *args)
+      return res if res.nil? || res == ''
+      JSON.parse(res, symbolize_names: true, object_class: ActiveSupport::HashWithIndifferentAccess)
+    end
+
+    # Executes a Termux API command and streams its results, line by line to the provided block
+    # @param (see #api_command)
+    # If a block is given, each new line output by the executed command is yielded to the block
+    # If a block is not given, it returns the output stream and the wait thread.
+    # @return [nil, [Io,Thread]]
+    def streamed_api_command(command, stdin = nil, *args, &block)
+      command, args = prepare_command_args(command, args)
+      i, o, t = Open3.popen2(command, *args)
+      i.puts(stdin) unless stdin.blank? # If we have any input, send it to the child
+      i.close                           # Afterwards we can close child's stdin
+      if block_given?
+        o.each_line do |line|
+          yield line
+        end
+        o.close
+        raise "#{command} failed" unless t.value.success?
+      else
+        return o, t # The caller has to close o and wait for t
+      end
+    end
+
+    # Executes the Termux API command and streams its results as parsed JSON, as soon as JSON structures are complete.
+    # @param (see #streamed_api_command)
+    # Only works if a block is given.
+    # @return [nil]
+    def json_streamed_api_command(command, stdin = nil, *args, &block)
+      partial_out = ''
+      streamed_api_command(command, stdin, *args) do |line|
+        partial_out << line
+        begin
+          parsed_json = JSON.parse(partial_out, symbolize_names: true, object_class: ActiveSupport::HashWithIndifferentAccess)
+          partial_out = ''
+          yield parsed_json
+        rescue
+        end
+      end
+    end
+
+    # Utility method to generate args lists to be passed to `api_command` and the like
+    # @param [Array <Array(String, Object)>]
+    # @return [Array <String>]
+    # The array is expected to contain Arrays as elements. Each of them is passed to #generate_args.
+    # Returns a flattened array with the resulting arguments.
+    # @example
+    #   generate_args_list([['-l', 3], ['-i'], ['-t', nil], ['My text']]) #=> ['-l', 3, '-i', 'My text']
+    def generate_args_list(args_list)
+      args = args_list.map { |args| generate_args(args) }.flatten.compact
+    end
+
+    # Utility method to generate the arguments for a single command option
+    # @param args [Array]
+    # @return [Array, nil]
+    # If the last argument is blank, the whole list is ignored and returns nil
+    # @example Single element
+    #   generate_args(['-h']) #=> ['-h']
+    # @example Two non-nil elements
+    #   generate_args(['-t', "My title"]) #=> ['-t', "My title"]
+    # @example Two elements, with the last being nil
+    #   generate_args(['-t', nil]) #=> nil
+    def generate_args(args)
+      args.empty? || args.last.blank? ? nil : args
+    end
+
+    protected
+
+    def prepare_command_args(command, args)
+      command = "termux-" + Shellwords.escape(command.to_s)
+      args = args.map { |arg| arg.to_s }
+      return command, args
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems.rb

@@ -0,0 +1,8 @@
+require_relative 'sub_systems/base'
+require_relative 'sub_systems/call_log'
+require_relative 'sub_systems/clipboard'
+require_relative 'sub_systems/location'
+require_relative 'sub_systems/sms'
+require_relative 'sub_systems/tts'
+require_relative 'sub_systems/sensor'
+require_relative 'sub_systems/dialog'

data/lib/termux_ruby_api/sub_systems/base.rb

@@ -0,0 +1,11 @@
+module TermuxRubyApi
+  module SubSystems
+    class Base
+      attr_accessor :owner
+      
+      def initialize(owner)
+        @owner = owner
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems/call_log.rb

@@ -0,0 +1,23 @@
+module TermuxRubyApi
+  module SubSystems
+    class CallLog < Base
+      # Gets part of the list of phone calls in the phone
+      # @param limit [Fixnum] Number of messages to return
+      # @param offset [Fixnum] Start from message
+      # @return [Array <Hash>]
+      def log(limit:nil, offset:nil)
+        args = owner.generate_args_list([['-l', limit&.to_s],
+                                         ['-o', offset&.to_s]
+                                        ])
+        res = owner.json_api_command('call-log', nil, *args)
+        TermuxRubyApi::Utils::Xformer.xform(res, date: :time, duration: :duration, type: :symbol)
+      end
+
+      # Gets the whole list of phone calls in the phone, with no pagination
+      # @return (see #log)
+      def log_all
+        log(limit: -1)
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems/clipboard.rb

@@ -0,0 +1,17 @@
+module TermuxRubyApi
+  module SubSystems
+    class Clipboard < TermuxRubyApi::SubSystems::Base
+      # Stores `value` in the Android system clipboard
+      # @param value [String]
+      def set(value)
+        owner.api_command('clipboard-set', value)
+      end
+
+      # Gets the contents of the Android system clipboard
+      # @return value [String]
+      def get
+        owner.api_command('clipboard-get')
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems/dialog.rb

@@ -0,0 +1,126 @@
+module TermuxRubyApi
+  module SubSystems
+    class Dialog < TermuxRubyApi::SubSystems::Base
+      # Shows a dialog asking for a simple text message
+      # @param title [String] the title of the dialog
+      # @param hint [String] aclaratory text
+      # @return [String] the text entered by the user
+      def text(title = nil, hint: nil)
+        args = owner.generate_args_list([['text'],
+                                         ['-t', title],
+                                         ['-i', hint]
+                                        ])
+        single_result(args, :text)
+      end
+
+      # Shows a dialog asking for a Yes/No confirmation
+      # @param title [String] the title of the dialog
+      # @param hint [String] aclaratory text
+      # @param result_type [:boolean, :text, raw] How you want the result
+      #   :boolean #=> true for "Yes" false for "No"
+      #   :text #=> "Yes" or "No"
+      #   :raw #=> A parsed JSON object with the result from Termux API
+      # @return Depends on @result_type
+      def confirm(title = nil, hint: nil, result_type: :boolean)
+        args = owner.generate_args_list([['confirm'],
+                                         ['-t', title],
+                                         ['-i', hint]
+                                        ])
+        single_result(args, result_type)
+      end
+
+      # Shows a dialog asking for a multiple choice question, with checkboxes
+      # @param title [String] the title of the dialog
+      # @param options [Array <String>] the options the user has to select from
+      # @param result_type [:index, :text, raw] How you want the result
+      #   :index #=> The index (0 based) of the selected options
+      #   :text #=> The texts for the selected options
+      #   :raw #=> A parsed JSON object with the result from Termux API
+      # @return [Array]
+      def checkbox(title = nil, result_type: :index, options:)
+        args = owner.generate_args_list([['checkbox'],
+                                         ['-t', title],
+                                         ['-v', options.join(',')]
+                                        ])
+        res = owner.json_api_command('dialog', nil, *args)
+        return res if result_type == :raw
+        res[:values]&.map { |r| extract_result(r, result_type) }
+      end
+
+      # Shows a dialog asking for a multiple choice question, with radio buttons
+      # @param title [String] the title of the dialog
+      # @param options [Array <String>] the options the user has to select from
+      # @param result_type [:index, :text, raw] How you want the result
+      #   :index #=> The index (0 based) of the selected option
+      #   :text #=> The text for the selected option
+      #   :raw #=> A parsed JSON object with the result from Termux API
+      # @return Depends on the result_type
+      def radio(title = nil, result_type: :index, options:)
+        args = owner.generate_args_list([[__callee__.to_s],
+                                         ['-t', title],
+                                         ['-v', options.join(',')]
+                                        ])
+        single_result(args, result_type)
+      end
+
+      # Shows a dialog asking for a multiple choice question, with a spinner
+      # @param (see #radio)
+      # @return (see #radio)
+      alias :spinner :radio
+
+      # Shows a dialog asking for a multiple choice question, with an Android sheet
+      # @param (see #radio)
+      # @return (see #radio)
+      alias :sheet :radio
+
+      # Shows a dialog asking for a calendar date
+      # @param title [String] the title of the dialog
+      # @param result_type [:date, :text, raw] How you want the result
+      #   :date #=> A Ruby Date class instance
+      #   :text #=> The String for the selected date
+      #   :raw #=> A parsed JSON object with the result from Termux API
+      # @return Depends on @result_type
+      def date(title = nil, result_type: :date)
+        args = owner.generate_args_list([['date'],
+                                         ['-t', title]
+                                        ])
+        single_result(args, result_type)
+      end
+
+      # Shows a dialog asking for spoken input, to be converted to text
+      # @param title [String] the title of the dialog
+      # @param hint [String] aclaratory text
+      # @param result_type [:boolean, :text, raw] How you want the result
+      #   :text #=> The recognized text
+      #   :raw #=> A parsed JSON object with the result from Termux API
+      # @return Depends on @result_type
+      def speech(title = nil, hint: nil, result_type: :text)
+        args = owner.generate_args_list([['speech'],
+                                         ['-t', title],
+                                         ['-i', hint]
+                                        ])
+        single_result(args, result_type)
+      end
+
+      private
+
+      def single_result(args, result_type = :raw)
+        res = owner.json_api_command('dialog', nil, *args)
+        extract_result(res, result_type)
+      end
+
+      def extract_result(res, result_type = :text)
+        return case result_type
+        when :raw
+          res
+        when :boolean
+          res.present? && res[:text].present? && res[:text].downcase == 'yes'
+        when :date
+          res && res[:text].presence && Date.parse(res[:text])
+        else
+          res && res[result_type]
+        end
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems/location.rb

@@ -0,0 +1,37 @@
+module TermuxRubyApi
+  module SubSystems
+    class Location < Base
+      # Returns the current location
+      # @param provider [:gps, :network, :passive]
+      #   :gps #=> Use GPS
+      #   :network #=> Use mobile or Wifi network
+      #   :passive #=> Use a low battery method
+      # @param request [:once, :last, :updates]
+      #   :once #=> Return after the location is obtained
+      #   :last #=> Return the last obtained location
+      #   :updates #=> Send repeated updates as location is updated. Doesn't work in current version.
+      # @return [Hash]
+      def get(provider: nil, request: nil)
+        args = owner.generate_args_list([['-p', provider],
+                                         ['-r', request]
+                                        ])
+        res = owner.json_api_command('location', nil, *args)
+        TermuxRubyApi::Utils::Xformer.xform(res, provider: :symbol)
+      end
+
+      # Returns the current location, using GPS
+      # @param request (see #get)
+      # @return (see #get)
+      def gps(request: nil)
+        get(provider: :gps, request: request)
+      end
+
+      # Returns the current location, using Mobile/Wifi network
+      # @param request (see #get)
+      # @return (see #get)
+      def network(request: nil)
+        get(provider: :network, request: request)
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems/sensor.rb

@@ -0,0 +1,55 @@
+module TermuxRubyApi
+  module SubSystems
+    class Sensor < Base
+      # Produces continues updates of the selected sensors
+      # If a block is passed, the results are yielded to the block as soon as they're ready
+      # in the form of an array of hashes, where each element of the array corresponds to one
+      # of the captured sensors.
+      # If no block is passed, the IO object for the output string and the wait Thread
+      # are returned. See {TermuxRubyApi::Base#json_streamed_api_command} for details.
+      # @param delay [Fixnum] time in milliseconds to wait between updates
+      # @param limit [Fixnum] number of updates. If nil, it sends updates forever
+      # @param sensors [Array <String>] names of sensors to capture (as returned from #list)
+      # @note If limit==nil this method never returns.
+      #   In that case is normal to invoke it from inside a thread or
+      #   a child process.
+      def capture(delay: 1000, limit: nil, sensors:, &block)
+        args = []
+        args += ['-n', limit.to_s] unless limit.nil?
+        args += ['-d', delay.to_s] unless delay.nil?
+        args += ['-s', sensors.join(',')]
+        if block_given?
+          owner.json_streamed_api_command('sensor', nil, *args) do |json_result|
+            yield json_result
+          end
+        else
+          return owner.json_streamed_api_command('sensor', nil, *args)
+        end
+      end
+
+      # Gets a single update of the selected sensors
+      # If a block is passed, the results are yielded to the block as soon as they're ready
+      # in the form of an array of hashes, where each element of the array corresponds to one
+      # of the captured sensors.
+      # If no block is passed, the array of hashes is returned.
+      # @param sensors [String] names of sensors to capture (as returned from #list)
+      def capture_once(*sensors, &block)
+        data = nil
+        capture(limit: 1, sensors: sensors) do |json_result|
+          data = json_result
+        end
+        if block_given?
+          yield data
+        else
+          return data
+        end
+      end
+
+      # Returns the list of available sensors
+      # @return [String]
+      def list
+        owner.json_api_command('sensor', nil, '-l')&.fetch(:sensors)
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems/sms.rb

@@ -0,0 +1,91 @@
+module TermuxRubyApi
+  module SubSystems
+    class Sms < TermuxRubyApi::SubSystems::Base
+      # Gets part of the list of SMS messages in the phone
+      # @param limit [Fixnum] Number of messages to return
+      # @param offset [Fixnum] Start from message
+      # @param type [:inbox, :outbox, :sent]
+      # @return [Array <Hash>]
+      def list(limit: nil, offset: nil, type: nil)
+        args = []
+        args = owner.generate_args_list([['-l', limit&.to_s],
+                                         ['-o', offset&.to_s],
+                                         ['-t', type]
+                                        ])
+        res = owner.json_api_command('sms-list', nil, *args)
+        TermuxRubyApi::Utils::Xformer.xform(res, received: :time, type: :symbol)
+      end
+
+      # Lists all the SMS messages in the phone, with no pagination
+      # @param type [:inbox, :outbox, :sent]
+      # @return (see #list)
+      def list_all(type: nil)
+        list(limit: -1, type: type)
+      end
+
+      # Lists the SMS messages in the inbox folder of the phone
+      # @param limit [Fixnum] Number of messages to return
+      # @param offset [Fixnum] Start from message
+      # @return (see #list)
+      def inbox(limit: nil, offset: nil)
+        list(limit: limit, offset: offset, type: :inbox)
+      end
+
+      # Lists all the SMS messages in the inbox folder of the phone, with no pagination
+      # @return (see #list)
+      def inbox_all
+        list_all(type: :inbox)
+      end
+
+      # Lists the SMS messages in the outbox folder of the phone
+      # @param limit [Fixnum] Number of messages to return
+      # @param offset [Fixnum] Start from message
+      # @return (see #list)
+      def outbox(limit: nil, offset: nil)
+        list(limit: limit, offset: offset, type: :outbox)
+      end
+
+      # Lists all the SMS messages in the outbox folder of the phone, with no pagination
+      # @return (see #list)
+      def outbox_all
+        list_all(type: :outbox)
+      end
+
+      # Lists the SMS messages in the sent folder of the phone
+      # @param limit [Fixnum] Number of messages to return
+      # @param offset [Fixnum] Start from message
+      # @return (see #list)
+      def sent(limit: nil, offset: nil)
+        list(limit: limit, offset: offset, type: :sent)
+      end
+
+      # Lists all the SMS messages in the sent folder of the phone, with no pagination
+      # @return (see #list)
+      def sent_all
+        list_all(type: :sent)
+      end
+
+      # Lists the SMS messages in the draft folder of the phone
+      # @param limit [Fixnum] Number of messages to return
+      # @param offset [Fixnum] Start from message
+     # @return (see #list)
+      def draft(limit: nil, offset: nil)
+        list(limit: limit, offset: offset, type: :draft)
+      end
+
+      # Lists all the SMS messages in the draft folder of the phone, with no pagination
+      # @return (see #list)
+      def draft_all
+        list_all(type: :draft)
+      end
+
+      # Sends an SMS message
+      # @param msg [String] the text of the message
+      # @param numbers [String] all subsequent params are interpreted as numbers to send the message to
+      def send(msg, *numbers)
+        args = owner.generate_args(["-n", "#{numbers.join(',')}"])
+        owner.api_command('sms-send', msg, *args)
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/sub_systems/tts.rb

@@ -0,0 +1,33 @@
+module TermuxRubyApi
+  module SubSystems
+    class Tts < TermuxRubyApi::SubSystems::Base
+      # Speaks a text through the TTS system
+      # @param text [String] the text to be spoken
+      # @param engine [String] the engine to use (see #engines)
+      # @param language [String] the string code for the language to use
+      # @param region [String] the string code for the regional variaion of the selected language
+      # @param variant [String] the voice of the selected language
+      # @param pitch [Fixnum] the desired pitch: 1 neutral. <1 more grave. >1 more acute
+      # @param rate [Fixnum] the desired speak rate. 1 neutral. <1 slower. >1 faster
+      # @param stream [String] Android audio stream to use: One of ALARM, MUSIC, NOTIFICATION, RING, SYSTEM, VOICE_CALL
+
+      def speak(text, engine: nil, language: nil, region: nil, variant: nil, pitch: nil, rate: nil, stream: nil)
+        args = owner.generate_args_list([['-e', engine&.to_s],
+                                         ['-l', language&.to_s],
+                                         ['-n', region&.to_s],
+                                         ['-v', variant&.to_s],
+                                         ['-p', pitch&.to_s],
+                                         ['-r', rate&.to_s],
+                                         ['-s', stream&.to_s]
+                                        ])
+        owner.api_command('tts-speak', text, *args)
+      end
+
+      # Returns the list of available engines
+      # @return [Array <Hash>]
+      def engines
+        owner.json_api_command('tts-engines')
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/utils.rb

@@ -0,0 +1 @@
+require_relative 'utils/xformer'

data/lib/termux_ruby_api/utils/xformer.rb

@@ -0,0 +1,53 @@
+module TermuxRubyApi
+  module Utils
+    class Xformer
+      def self.xform(object, args)
+        collection = object.is_a?(Array) ? object : [object]
+        collection.each { |i| xform_item(i, args) }
+        object
+      end
+
+      private
+
+      def self.xform_item(item, args)
+        return unless item.is_a?(Hash)
+        args.each do |arg, type|
+          next unless item.key?(arg)
+          item[arg] = xform_prop(item[arg], type)
+        end
+      end
+
+      def self.xform_prop(value, type)
+        case type
+        when :date
+          Date.parse(value)
+        when :time
+          Time.parse(fix_time(value))
+        when :duration
+          to_duration(value)
+        when :integer
+          value.to_i
+        when :float
+          value.to_f
+        when :symbol
+          value.to_sym
+        else
+          value
+        end
+      end
+
+      def self.to_duration(value)
+        parts = value.split(':')
+        res = parts.pop.to_i
+        res += (parts.pop.to_i * 60) if parts.any?
+        res += (parts.pop.to_i * 60 * 60) if parts.any?
+        res
+      end
+
+      def self.fix_time(time_str)
+        # Termux likes to give hours in 24:xx:xx or 24:xx format instead of 00:xx:xx or 00:xx
+        time_str.gsub(/\ (24)(:\d\d)/, ' 00' + '\2')
+      end
+    end
+  end
+end

data/lib/termux_ruby_api/version.rb

@@ -0,0 +1,3 @@
+module TermuxRubyApi
+  VERSION = "0.1.0"
+end

data/termux_ruby_api.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "termux_ruby_api/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "termux_ruby_api"
+  spec.version       = TermuxRubyApi::VERSION
+  spec.authors       = ["Josep Egea"]
+  spec.email         = ["jes@josepegea.com"]
+
+  spec.summary       = %q{A Ruby interface for the Termux API in Android}
+  spec.description   = %q{Control your Android device from Ruby thanks to Termux, Termux API and these Ruby bindings}
+  spec.homepage      = "https://github.com/josepegea/termux_ruby_api"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 5.2.2"
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: termux_ruby_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josep Egea
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Control your Android device from Ruby thanks to Termux, Termux API and
+  these Ruby bindings
+email:
+- jes@josepegea.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/termux_ruby_api.rb
+- lib/termux_ruby_api/base.rb
+- lib/termux_ruby_api/sub_systems.rb
+- lib/termux_ruby_api/sub_systems/base.rb
+- lib/termux_ruby_api/sub_systems/call_log.rb
+- lib/termux_ruby_api/sub_systems/clipboard.rb
+- lib/termux_ruby_api/sub_systems/dialog.rb
+- lib/termux_ruby_api/sub_systems/location.rb
+- lib/termux_ruby_api/sub_systems/sensor.rb
+- lib/termux_ruby_api/sub_systems/sms.rb
+- lib/termux_ruby_api/sub_systems/tts.rb
+- lib/termux_ruby_api/utils.rb
+- lib/termux_ruby_api/utils/xformer.rb
+- lib/termux_ruby_api/version.rb
+- termux_ruby_api.gemspec
+homepage: https://github.com/josepegea/termux_ruby_api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: A Ruby interface for the Termux API in Android
+test_files: []