Module: Meglish

Defined in:
lib/meglish.rb

Constant Summary collapse

MELGISH_CONDITIONS = 
{
    clear_text: true,
    scroll_to_element: true,
    include_all: true,
    timeout: 30,
    confirm_alert: true
}

Instance Method Summary collapse

Instance Method Details

#clear_text_element(_query, _options = {}) ⇒ Object 



10
11
12
13
 
# File 'lib/meglish.rb', line 10

def clear_text_element(_query, _options = {})
    touch_element(_query.strip, _options)
    clear_text
end

#element_enabled?(_query, _options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


15
16
17
 
# File 'lib/meglish.rb', line 15

def element_enabled?(_query, _options = {})
    get_element['enabled']
end

#element_visible?(_query, _options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


19
20
21
 
# File 'lib/meglish.rb', line 19

def element_visible?(_query, _options = {})
    get_element['visible']
end

#find_coordinate_element(_query, _options = {}) ⇒ Object 



23
24
25
26
 
# File 'lib/meglish.rb', line 23

def find_coordinate_element(_query, _options = {})
    find_element_on_screen(_query, _options)
    find_coordinate(_query, _options)
end

#find_element_on_screen(_query, _options = {}) ⇒ Object 



28
29
30
31
32
33
34
 
# File 'lib/meglish.rb', line 28

def find_element_on_screen(_query, _options = {})
    _query = include_all(_query, _options)
    MeglishLog.new.log(_query)
    wait_for_element_exists(_query, get_option(:timeout, _options))
    sleep 0.5
    scroll_to_element(_query, _options)
end

#find_elements(_query, _options = {}) ⇒ Object 



36
37
38
 
# File 'lib/meglish.rb', line 36

def find_elements(_query, _options = {})
    query(include_all(_query, _options))
end

#get_device_size ⇒ Object 



40
41
42
43
44
45
46
47
 
# File 'lib/meglish.rb', line 40

def get_device_size
    size = `adb shell dumpsys input | grep 'deviceSize' | awk '{ print $10 , $11 }'`
    size = size[0..size.length - 3]
    w, h = size.split(', ')
    w = w.to_i
    h = h.to_i
    [w, h]
end

#get_element(_query, _options = {}) ⇒ Object 



49
50
51
52
 
# File 'lib/meglish.rb', line 49

def get_element(_query, _options = {})
    find_element_on_screen(_query, _options)
    query(include_all(_query, _options)).first
end

#get_element_by_index(_query, _index, _options = {}) ⇒ Object 



54
55
56
57
58
 
# File 'lib/meglish.rb', line 54

def get_element_by_index(_query, _index, _options = {})
    new_query = _query + ' index:' + _index
    find_element_on_screen(_query, _options)
    query(new_query).first
end

#get_elements(_query, _options = {}) ⇒ Object 



60
61
62
63
64
 
# File 'lib/meglish.rb', line 60

def get_elements(_query, _options = {})
    query(_query)
rescue
    return []
end

#keyboard_enter_text_element(_text, _options = {}) ⇒ Object 



66
67
68
69
70
 
# File 'lib/meglish.rb', line 66

def keyboard_enter_text_element(_text, _options = {})
    wait_for_keyboard
    keyboard_enter_text _text
    hide_soft_keyboard
end

#long_press_and_touch_element(_query, _touch_element_query, _options = {}) ⇒ Object 



88
89
90
91
 
# File 'lib/meglish.rb', line 88

def long_press_and_touch_element(_query, _touch_element_query, _options = {})
    long_press_element(_query, _options)
    touch_element(_touch_element_query, _options)
end

#long_press_element(_query, _options = {}) ⇒ Object 



72
73
74
75
76
77
78
 
# File 'lib/meglish.rb', line 72

def long_press_element(_query, _options = {})
    start_monkey
    find_element_on_screen(_query, _options)
    x, y = find_coordinate(_query, _options)
    monkey_touch(:down, x, y)
    kill_existing_monkey_processes
end

#long_press_release_element(_query, _options = {}) ⇒ Object 



80
81
82
83
84
85
86
 
# File 'lib/meglish.rb', line 80

def long_press_release_element(_query, _options = {})
    start_monkey
    find_element_on_screen(_query, _options)
    x, y = find_coordinate(_query, _options)
    monkey_touch(:up, x, y)
    kill_existing_monkey_processes
end

#scroll_to_element(_query, _to_top_first = false, _options = {}) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/meglish.rb', line 104

def scroll_to_element(_query, _to_top_first = false, _options = {})
    return unless get_option(:scroll_to_element, _options)
    hide_soft_keyboard
    unless (query(_query).first['rect']['height']).zero? && (query(_query).first['rect']['width']).zero?
        w, h = get_device_size
        x, y = find_coordinate(include_all(_query, _options))

        scroll_until_find_element(_query, h, y, w, x)
        swipe_until_find_element(_query, w, x, h, y)
    end
rescue
    MeglishLog.new.log('Scroll to element was ignored')
    query(_query)
end

#scroll_to_top ⇒ Object 



119
120
121
 
# File 'lib/meglish.rb', line 119

def scroll_to_top
    perform_action('drag', 50, 50, 50, 1500, 1)
end

#select_spinner_item_element(_spinner_query, _text, _options = {}) ⇒ Object 



123
124
125
126
 
# File 'lib/meglish.rb', line 123

def (, _text, _options = {})
    touch_element(, _options)
    touch_element("DropDownListView child CustomFontTextView text:'#{_text}'", _options)
end

#set_date_element(_query_input, _date, _options = {}) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
 
# File 'lib/meglish.rb', line 93

def set_date_element(_query_input, _date, _options = {})
    new_date = _date.match(/(^[\d]{4})\/([\d]{1,2})\/([\d]{1,2})/)
    year = new_date[1].to_i
    month = (new_date[2].to_i) - 1
    day = new_date[3].to_i

    touch_element(_query_input, _options)
    query("DatePicker" ,{method_name: :updateDate, arguments: [year, month, day]})
    touch("MDButton id:'md_buttonDefaultPositive'") unless get_option(:confirm_alert, _options)
end

#swipe_left(_query) ⇒ Object 



128
129
130
131
132
 
# File 'lib/meglish.rb', line 128

def swipe_left(_query)
    has_element = query(_query + ' parent HorizontalScrollView')
    _query = has_element.empty? ? _query : _query + ' parent HorizontalScrollView'
    pan_left(query_string: _query)
end

#swipe_right(_query) ⇒ Object 



134
135
136
137
138
 
# File 'lib/meglish.rb', line 134

def swipe_right(_query)
    has_element = query(_query + ' parent HorizontalScrollView')
    _query = has_element.empty? ? _query : _query + ' parent HorizontalScrollView'
    pan_right(query_string: _query)
end

#text_element(_query, _options = {}) ⇒ Object 



140
141
142
 
# File 'lib/meglish.rb', line 140

def text_element(_query, _options = {})
    get_element(_query, _options)['text']
end

#text_spinner_element(_query, _options = {}) ⇒ Object 



144
145
146
147
 
# File 'lib/meglish.rb', line 144

def (_query, _options = {})
    _query += ' child CustomFontTextView'
    get_element(_query, _options)['text']
end

#touch_and_keyboard_text_element(_query, _text, _options = {}) ⇒ Object 



162
163
164
165
166
 
# File 'lib/meglish.rb', line 162

def touch_and_keyboard_text_element(_query, _text, _options = {})
    touch_element(_query.strip, _options)
    clear_text if get_element(:clear_text, _options)
    keyboard_enter_text_element(_text, _options)
end

#touch_element(_query, _options = {}) ⇒ Object 



149
150
151
 
# File 'lib/meglish.rb', line 149

def touch_element(_query, _options = {})
    touch_element(_query.strip, _options)
end

#touch_element_by_text_position(_query, _text, _options = {}) ⇒ Object 



153
154
155
156
157
158
159
160
 
# File 'lib/meglish.rb', line 153

def touch_element_by_text_position(_query, _text, _options = {})
    text_el = get_element(_query, _options)['text']
    text_index = text_el.index(_text) + (_text.length / 2)
    line_for_offset = query(_query, :getLayout, getLineForOffset: text_index)[0]
    vertical = query(_query, :getLayout, getLineBaseline: line_for_offset)[0].to_i
    horizontal = query(_query, :getLayout, getPrimaryHorizontal: text_index)[0].to_i
    touch(_query, x: 0, y: 0, offset: { x: horizontal, y: vertical })
end

#wait_for_or_ignore(_query, _timeout = 3, _options = {}) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/meglish.rb', line 168

def wait_for_or_ignore(_query, _timeout = 3, _options = {})
    _timeout *= 2
    found = false
    while _timeout > 0 && found == false
        if find_elements(_query, _options).empty?
            _timeout -= 1
            sleep 0.5
        else
            found = true
        end
    end
    found
end

#wait_for_text_element(_query, _timeout = 10, _options = {}) ⇒ Object 



182
183
184
185
186
187
188
189
190
191
 
# File 'lib/meglish.rb', line 182

def wait_for_text_element(_query, _timeout = 10, _options = {})
    count = 0
    filled = ''
    while (filled.nil? || filled.empty?)
        return if count >= _timeout
        filled = text_element(_query, _options)
        sleep 1
        count += 1
    end
end

#wait_keyboard_visible?(_timeout = 3) ⇒ Boolean

Returns:

  • (Boolean) 


193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/meglish.rb', line 193

def wait_keyboard_visible?(_timeout = 3)
    visible = 'false'
    _timeout *= 2
    while _timeout > 0 && visible == 'false'
        field, visible = `adb shell dumpsys input_method | grep mInputShown | awk '{ print $4 }'`.split('=')
        if visible == 'false'
            _timeout -= 1
            sleep 0.5
        end
    end
    visible == 'true' ? true : false
end