Class: TD::Client

Inherits:
Object
  • Object
show all
Includes:
Concurrent
Defined in:
lib/tdlib/client.rb

Overview

Simple client for TDLib.

Examples:

TD.configure do |config|
  config.lib_path = 'path_to_tdlibjson'
  config.encryption_key = 'your_encryption_key'

  config.client.api_id = your_api_id
  config.client.api_hash = 'your_api_hash'
end

client = TD::Client.new

begin
  state = nil

  client.on('updateAuthorizationState') do |update|
    next unless update.dig('authorization_state', '@type') == 'authorizationStateWaitPhoneNumber'
    state = :wait_phone
  end

  client.on('updateAuthorizationState') do |update|
    next unless update.dig('authorization_state', '@type') == 'authorizationStateWaitCode'
    state = :wait_code
  end

  client.on('updateAuthorizationState') do |update|
    next unless update.dig('authorization_state', '@type') == 'authorizationStateReady'
    state = :ready
  end

  loop do
    case state
    when :wait_phone
      p 'Please, enter your phone number:'
      phone = STDIN.gets.strip
      params = {
        '@type' => 'setAuthenticationPhoneNumber',
        'phone_number' => phone
      }
      client.broadcast_and_receive(params)
    when :wait_code
      p 'Please, enter code from SMS:'
      code = STDIN.gets.strip
      params = {
        '@type' => 'checkAuthenticationCode',
        'code' => code
      }
      client.broadcast_and_receive(params)
    when :ready
      @me = client.broadcast_and_receive('@type' => 'getMe')
      break
    end
  end

ensure
  client.close
end

p @me

Constant Summary collapse

TIMEOUT = 
10

Instance Method Summary collapse

Constructor Details

#initialize(td_client = TD::Api.client_create, update_manager = TD::UpdateManager.new(td_client), **extra_config) ⇒ Client

Returns a new instance of Client.



65
66
67
68
69
70
71
72
73
 
# File 'lib/tdlib/client.rb', line 65

def initialize(td_client = TD::Api.client_create,
               update_manager = TD::UpdateManager.new(td_client),
               **extra_config)
  @td_client = td_client
  @update_manager = update_manager
  @config = TD.config.client.to_h.merge(extra_config)
  authorize
  @update_manager.run
end

Instance Method Details

#authorization_state ⇒ Hash

Returns current authorization state (it's offline request)

Returns:

  • (Hash) 


120
121
122
 
# File 'lib/tdlib/client.rb', line 120

def authorization_state
  broadcast_and_receive('@type' => 'getAuthorizationState')
end

#broadcast(query) {|update| ... } ⇒ Object

Sends asynchronous request to the TDLib client

Parameters:

  • query (Hash)

Yields:

  • (update) —

    yields update to the block as soon as it's received



78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/tdlib/client.rb', line 78

def broadcast(query)
  if block_given?
    extra = TD::Utils.generate_extra(query)
    handler = ->(update) do
      return unless update['@extra'] == extra
      yield update
      @update_manager.remove_handler(handler)
    end
    @update_manager.add_handler(handler)
    query['@extra'] = extra
  end
  TD::Api.client_send(@td_client, query)
end

#broadcast_and_receive(query, timeout: TIMEOUT) ⇒ Hash

Sends asynchronous request to the TDLib client and returns received update synchronously

Parameters:

  • query (Hash)

Returns:

  • (Hash) 


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/tdlib/client.rb', line 95

def broadcast_and_receive(query, timeout: TIMEOUT)
  result = nil
  extra = TD::Utils.generate_extra(query)
  handler = ->(update) { result = update if update['@extra'] == extra }
  @update_manager.add_handler(handler)
  query['@extra'] = extra
  TD::Api.client_send(@td_client, query)
  time_start = Time.now
  loop do
    sleep 0.1
    break if result
    raise TD::TimeoutError if Time.now - time_start > timeout
  end
  result
end

#close ⇒ Object

Stops update manager and destroys TDLib client



146
147
148
149
 
# File 'lib/tdlib/client.rb', line 146

def close
  @update_manager.stop
  TD::Api.client_destroy(@td_client)
end

#execute(query) ⇒ Object

Synchronously executes TDLib request Only a few requests can be executed synchronously

Parameters:

  • query (Hash) 


114
115
116
 
# File 'lib/tdlib/client.rb', line 114

def execute(query)
  TD::Api.client_execute(@td_client, query)
end

#on(update_type) {|update| ... } ⇒ Object

Binds passed block as a handler for updates with type of update_type

Parameters:

  • update_type (String)

Yields:

  • (update) —

    yields update to the block as soon as it's received



127
128
129
130
131
132
133
 
# File 'lib/tdlib/client.rb', line 127

def on(update_type, &_)
  handler = ->(update) do
    return unless update['@type'] == update_type
    yield update
  end
  @update_manager.add_handler(handler)
end

#on_ready(timeout: TIMEOUT) {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:

  • _self (TD::Client) —

    the object that the method was called on



135
136
137
138
139
140
141
142
143
 
# File 'lib/tdlib/client.rb', line 135

def on_ready(timeout: TIMEOUT, &_)
  time_start = Time.now
  loop do
    sleep 0.1
    break if @ready
    raise TD::TimeoutError if Time.now - time_start > timeout
  end
  yield self
end