Class: TalkService::Processor

Inherits:
Object
  • Object
show all
Includes:
Thrift::Processor
Defined in:
lib/linerb/gen-rb/talk_service.rb

Instance Method Summary collapse

Instance Method Details

#process_acceptChatInvitation(seqid, iprot, oprot) ⇒ Object 



2197
2198
2199
2200
2201
2202
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2197

def process_acceptChatInvitation(seqid, iprot, oprot)
  args = read_args(iprot, AcceptChatInvitation_args)
  result = AcceptChatInvitation_result.new()
  @handler.acceptChatInvitation(args.request)
  write_result(result, oprot, 'acceptChatInvitation', seqid)
end

#process_acceptChatInvitationByTicket(seqid, iprot, oprot) ⇒ Object 



2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2215

def process_acceptChatInvitationByTicket(seqid, iprot, oprot)
  args = read_args(iprot, AcceptChatInvitationByTicket_args)
  result = AcceptChatInvitationByTicket_result.new()
  begin
    result.success = @handler.acceptChatInvitationByTicket(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'acceptChatInvitationByTicket', seqid)
end

#process_acceptProximityMatches(seqid, iprot, oprot) ⇒ Object 



2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2120

def process_acceptProximityMatches(seqid, iprot, oprot)
  args = read_args(iprot, AcceptProximityMatches_args)
  result = AcceptProximityMatches_result.new()
  begin
    @handler.acceptProximityMatches(args.sessionId, args.ids)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'acceptProximityMatches', seqid)
end

#process_acquireEncryptedAccessToken(seqid, iprot, oprot) ⇒ Object 



1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1977

def process_acquireEncryptedAccessToken(seqid, iprot, oprot)
  args = read_args(iprot, AcquireEncryptedAccessToken_args)
  result = AcquireEncryptedAccessToken_result.new()
  begin
    result.success = @handler.acquireEncryptedAccessToken(args.featureType)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'acquireEncryptedAccessToken', seqid)
end

#process_blockContact(seqid, iprot, oprot) ⇒ Object 



2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2054

def process_blockContact(seqid, iprot, oprot)
  args = read_args(iprot, BlockContact_args)
  result = BlockContact_result.new()
  begin
    @handler.blockContact(args.reqSeq, args.id)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'blockContact', seqid)
end

#process_blockRecommendation(seqid, iprot, oprot) ⇒ Object 



2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2109

def process_blockRecommendation(seqid, iprot, oprot)
  args = read_args(iprot, BlockRecommendation_args)
  result = BlockRecommendation_result.new()
  begin
    @handler.blockRecommendation(args.reqSeq, args.id)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'blockRecommendation', seqid)
end

#process_cancelChatInvitation(seqid, iprot, oprot) ⇒ Object 



2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2237

def process_cancelChatInvitation(seqid, iprot, oprot)
  args = read_args(iprot, CancelChatInvitation_args)
  result = CancelChatInvitation_result.new()
  begin
    result.success = @handler.cancelChatInvitation(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'cancelChatInvitation', seqid)
end

#process_closeProximityMatch(seqid, iprot, oprot) ⇒ Object 



2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2142

def process_closeProximityMatch(seqid, iprot, oprot)
  args = read_args(iprot, CloseProximityMatch_args)
  result = CloseProximityMatch_result.new()
  begin
    @handler.closeProximityMatch(args.sessionId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'closeProximityMatch', seqid)
end

#process_createAccountMigrationPincodeSession(seqid, iprot, oprot) ⇒ Object 



2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2021

def process_createAccountMigrationPincodeSession(seqid, iprot, oprot)
  args = read_args(iprot, CreateAccountMigrationPincodeSession_args)
  result = CreateAccountMigrationPincodeSession_result.new()
  begin
    result.success = @handler.createAccountMigrationPincodeSession()
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'createAccountMigrationPincodeSession', seqid)
end

#process_createChat(seqid, iprot, oprot) ⇒ Object 



2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2248

def process_createChat(seqid, iprot, oprot)
  args = read_args(iprot, CreateChat_args)
  result = CreateChat_result.new()
  begin
    result.success = @handler.createChat(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'createChat', seqid)
end

#process_createChatRoomAnnouncement(seqid, iprot, oprot) ⇒ Object 



1604
1605
1606
1607
1608
1609
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1604

def process_createChatRoomAnnouncement(seqid, iprot, oprot)
  args = read_args(iprot, CreateChatRoomAnnouncement_args)
  result = CreateChatRoomAnnouncement_result.new()
  @handler.createChatRoomAnnouncement(args.reqSeq, args.chatRoomMid, args.type, args.contents)
  write_result(result, oprot, 'createChatRoomAnnouncement', seqid)
end

#process_createRoomV2(seqid, iprot, oprot) ⇒ Object 



1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1611

def process_createRoomV2(seqid, iprot, oprot)
  args = read_args(iprot, CreateRoomV2_args)
  result = CreateRoomV2_result.new()
  begin
    result.success = @handler.createRoomV2(args.reqSeq, args.contactIds)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'createRoomV2', seqid)
end

#process_deleteOtherFromChat(seqid, iprot, oprot) ⇒ Object 



2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2259

def process_deleteOtherFromChat(seqid, iprot, oprot)
  args = read_args(iprot, DeleteOtherFromChat_args)
  result = DeleteOtherFromChat_result.new()
  begin
    result.success = @handler.deleteOtherFromChat(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'deleteOtherFromChat', seqid)
end

#process_deleteSelfFromChat(seqid, iprot, oprot) ⇒ Object 



2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2270

def process_deleteSelfFromChat(seqid, iprot, oprot)
  args = read_args(iprot, DeleteSelfFromChat_args)
  result = DeleteSelfFromChat_result.new()
  begin
    result.success = @handler.deleteSelfFromChat(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'deleteSelfFromChat', seqid)
end

#process_disableNearby(seqid, iprot, oprot) ⇒ Object 



1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1582

def process_disableNearby(seqid, iprot, oprot)
  args = read_args(iprot, DisableNearby_args)
  result = DisableNearby_result.new()
  begin
    @handler.disableNearby()
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'disableNearby', seqid)
end

#process_fetchOps(seqid, iprot, oprot) ⇒ Object 



1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1520

def process_fetchOps(seqid, iprot, oprot)
  args = read_args(iprot, FetchOps_args)
  result = FetchOps_result.new()
  begin
    result.success = @handler.fetchOps(args.localRev, args.count, args.globalRev, args.individualRev)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'fetchOps', seqid)
end

#process_findAndAddContactByMetaTag(seqid, iprot, oprot) ⇒ Object 



1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1915

def process_findAndAddContactByMetaTag(seqid, iprot, oprot)
  args = read_args(iprot, FindAndAddContactByMetaTag_args)
  result = FindAndAddContactByMetaTag_result.new()
  begin
    result.success = @handler.findAndAddContactByMetaTag(args.reqSeq, args.searchId, args.reference)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'findAndAddContactByMetaTag', seqid)
end

#process_findAndAddContactsByMid(seqid, iprot, oprot) ⇒ Object 



1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1820

def process_findAndAddContactsByMid(seqid, iprot, oprot)
  args = read_args(iprot, FindAndAddContactsByMid_args)
  result = FindAndAddContactsByMid_result.new()
  begin
    result.success = @handler.findAndAddContactsByMid(args.reqSeq, args.mid, args.type, args.reference)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'findAndAddContactsByMid', seqid)
end

#process_findAndAddContactsByPhone(seqid, iprot, oprot) ⇒ Object 



2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2131

def process_findAndAddContactsByPhone(seqid, iprot, oprot)
  args = read_args(iprot, FindAndAddContactsByPhone_args)
  result = FindAndAddContactsByPhone_result.new()
  begin
    result.success = @handler.findAndAddContactsByPhone(args.reqSeq, args.phones, args.reference)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'findAndAddContactsByPhone', seqid)
end

#process_findAndAddContactsByUserid(seqid, iprot, oprot) ⇒ Object 



1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1849

def process_findAndAddContactsByUserid(seqid, iprot, oprot)
  args = read_args(iprot, FindAndAddContactsByUserid_args)
  result = FindAndAddContactsByUserid_result.new()
  begin
    result.success = @handler.findAndAddContactsByUserid(args.reqSeq, args.searchId, args.reference)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'findAndAddContactsByUserid', seqid)
end

#process_findChatByTicket(seqid, iprot, oprot) ⇒ Object 



2292
2293
2294
2295
2296
2297
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2292

def process_findChatByTicket(seqid, iprot, oprot)
  args = read_args(iprot, FindChatByTicket_args)
  result = FindChatByTicket_result.new()
  @handler.findChatByTicket(args.request)
  write_result(result, oprot, 'findChatByTicket', seqid)
end

#process_findSnsIdUserStatus(seqid, iprot, oprot) ⇒ Object 



1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1553

def process_findSnsIdUserStatus(seqid, iprot, oprot)
  args = read_args(iprot, FindSnsIdUserStatus_args)
  result = FindSnsIdUserStatus_result.new()
  begin
    result.success = @handler.findSnsIdUserStatus(args.snsIdType, args.snsAccessToken, args.udidHash, args.migrationPincodeSessionId, args.oldUdidHash)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'findSnsIdUserStatus', seqid)
end

#process_getAllChatMids(seqid, iprot, oprot) ⇒ Object 



2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2310

def process_getAllChatMids(seqid, iprot, oprot)
  args = read_args(iprot, GetAllChatMids_args)
  result = GetAllChatMids_result.new()
  begin
    result.success = @handler.getAllChatMids(args.request, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getAllChatMids', seqid)
end

#process_getAllContactIds(seqid, iprot, oprot) ⇒ Object 



1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1966

def process_getAllContactIds(seqid, iprot, oprot)
  args = read_args(iprot, GetAllContactIds_args)
  result = GetAllContactIds_result.new()
  begin
    result.success = @handler.getAllContactIds(args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getAllContactIds', seqid)
end

#process_getAnalyticsInfo(seqid, iprot, oprot) ⇒ Object 



2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2164

def process_getAnalyticsInfo(seqid, iprot, oprot)
  args = read_args(iprot, GetAnalyticsInfo_args)
  result = GetAnalyticsInfo_result.new()
  begin
    result.success = @handler.getAnalyticsInfo()
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getAnalyticsInfo', seqid)
end

#process_getBlockedContactIds(seqid, iprot, oprot) ⇒ Object 



1948
1949
1950
1951
1952
1953
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1948

def process_getBlockedContactIds(seqid, iprot, oprot)
  args = read_args(iprot, GetBlockedContactIds_args)
  result = GetBlockedContactIds_result.new()
  @handler.getBlockedContactIds(args.syncReason)
  write_result(result, oprot, 'getBlockedContactIds', seqid)
end

#process_getBlockedRecommendationIds(seqid, iprot, oprot) ⇒ Object 



1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1743

def process_getBlockedRecommendationIds(seqid, iprot, oprot)
  args = read_args(iprot, GetBlockedRecommendationIds_args)
  result = GetBlockedRecommendationIds_result.new()
  begin
    result.success = @handler.getBlockedRecommendationIds(args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getBlockedRecommendationIds', seqid)
end

#process_getChatEffectMetaList(seqid, iprot, oprot) ⇒ Object 



2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2354

def process_getChatEffectMetaList(seqid, iprot, oprot)
  args = read_args(iprot, GetChatEffectMetaList_args)
  result = GetChatEffectMetaList_result.new()
  begin
    result.success = @handler.getChatEffectMetaList(args.categories)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getChatEffectMetaList', seqid)
end

#process_getChatRoomAnnouncements(seqid, iprot, oprot) ⇒ Object 



1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1622

def process_getChatRoomAnnouncements(seqid, iprot, oprot)
  args = read_args(iprot, GetChatRoomAnnouncements_args)
  result = GetChatRoomAnnouncements_result.new()
  begin
    result.success = @handler.getChatRoomAnnouncements(args.chatRoomMid)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getChatRoomAnnouncements', seqid)
end

#process_getChatRoomAnnouncementsBulk(seqid, iprot, oprot) ⇒ Object 



2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2376

def process_getChatRoomAnnouncementsBulk(seqid, iprot, oprot)
  args = read_args(iprot, GetChatRoomAnnouncementsBulk_args)
  result = GetChatRoomAnnouncementsBulk_result.new()
  begin
    result.success = @handler.getChatRoomAnnouncementsBulk(args.chatRoomMids, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getChatRoomAnnouncementsBulk', seqid)
end

#process_getChatRoomBGMs(seqid, iprot, oprot) ⇒ Object 



1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1633

def process_getChatRoomBGMs(seqid, iprot, oprot)
  args = read_args(iprot, GetChatRoomBGMs_args)
  result = GetChatRoomBGMs_result.new()
  begin
    result.success = @handler.getChatRoomBGMs(args.chatRoomMids, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getChatRoomBGMs', seqid)
end

#process_getChats(seqid, iprot, oprot) ⇒ Object 



2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2420

def process_getChats(seqid, iprot, oprot)
  args = read_args(iprot, GetChats_args)
  result = GetChats_result.new()
  begin
    result.success = @handler.getChats(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getChats', seqid)
end

#process_getConfigurations(seqid, iprot, oprot) ⇒ Object 



2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2431

def process_getConfigurations(seqid, iprot, oprot)
  args = read_args(iprot, GetConfigurations_args)
  result = GetConfigurations_result.new()
  begin
    result.success = @handler.getConfigurations(args.revision, args.regionOfUsim, args.regionOfTelephone, args.regionOfLocale, args.carrier, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getConfigurations', seqid)
end

#process_getContact(seqid, iprot, oprot) ⇒ Object 



2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2098

def process_getContact(seqid, iprot, oprot)
  args = read_args(iprot, GetContact_args)
  result = GetContact_result.new()
  begin
    result.success = @handler.getContact(args.id)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getContact', seqid)
end

#process_getContacts(seqid, iprot, oprot) ⇒ Object 



1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1904

def process_getContacts(seqid, iprot, oprot)
  args = read_args(iprot, GetContacts_args)
  result = GetContacts_result.new()
  begin
    result.success = @handler.getContacts(args.ids)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getContacts', seqid)
end

#process_getContactsV2(seqid, iprot, oprot) ⇒ Object 



2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2442

def process_getContactsV2(seqid, iprot, oprot)
  args = read_args(iprot, GetContactsV2_args)
  result = GetContactsV2_result.new()
  begin
    result.success = @handler.getContactsV2(args.request, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getContactsV2', seqid)
end

#process_getCountries(seqid, iprot, oprot) ⇒ Object 



1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1644

def process_getCountries(seqid, iprot, oprot)
  args = read_args(iprot, GetCountries_args)
  result = GetCountries_result.new()
  begin
    result.success = @handler.getCountries(args.countryGroup)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getCountries', seqid)
end

#process_getCountryWithRequestIp(seqid, iprot, oprot) ⇒ Object 



1831
1832
1833
1834
1835
1836
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1831

def process_getCountryWithRequestIp(seqid, iprot, oprot)
  args = read_args(iprot, GetCountryWithRequestIp_args)
  result = GetCountryWithRequestIp_result.new()
  @handler.getCountryWithRequestIp()
  write_result(result, oprot, 'getCountryWithRequestIp', seqid)
end

#process_getEncryptedIdentityV3(seqid, iprot, oprot) ⇒ Object 



2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2175

def process_getEncryptedIdentityV3(seqid, iprot, oprot)
  args = read_args(iprot, GetEncryptedIdentityV3_args)
  result = GetEncryptedIdentityV3_result.new()
  begin
    result.success = @handler.getEncryptedIdentityV3()
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getEncryptedIdentityV3', seqid)
end

#process_getExtendedProfile(seqid, iprot, oprot) ⇒ Object 



2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2409

def process_getExtendedProfile(seqid, iprot, oprot)
  args = read_args(iprot, GetExtendedProfile_args)
  result = GetExtendedProfile_result.new()
  begin
    result.success = @handler.getExtendedProfile(args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getExtendedProfile', seqid)
end

#process_getFriendRequests(seqid, iprot, oprot) ⇒ Object 



1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1476

def process_getFriendRequests(seqid, iprot, oprot)
  args = read_args(iprot, GetFriendRequests_args)
  result = GetFriendRequests_result.new()
  begin
    result.success = @handler.getFriendRequests(args.direction, args.lastSeenSeqId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getFriendRequests', seqid)
end

#process_getInstantNews(seqid, iprot, oprot) ⇒ Object 



1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1655

def process_getInstantNews(seqid, iprot, oprot)
  args = read_args(iprot, GetInstantNews_args)
  result = GetInstantNews_result.new()
  begin
    result.success = @handler.getInstantNews(args.region, args.location)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getInstantNews', seqid)
end

#process_getMessageBoxes(seqid, iprot, oprot) ⇒ Object 



2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2204

def process_getMessageBoxes(seqid, iprot, oprot)
  args = read_args(iprot, GetMessageBoxes_args)
  result = GetMessageBoxes_result.new()
  begin
    result.success = @handler.getMessageBoxes(args.messageBoxListRequest, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getMessageBoxes', seqid)
end

#process_getMessageReadRange(seqid, iprot, oprot) ⇒ Object 



1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1498

def process_getMessageReadRange(seqid, iprot, oprot)
  args = read_args(iprot, GetMessageReadRange_args)
  result = GetMessageReadRange_result.new()
  begin
    result.success = @handler.getMessageReadRange(args.chatIds, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getMessageReadRange', seqid)
end

#process_getPendingAgreements(seqid, iprot, oprot) ⇒ Object 



1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1666

def process_getPendingAgreements(seqid, iprot, oprot)
  args = read_args(iprot, GetPendingAgreements_args)
  result = GetPendingAgreements_result.new()
  begin
    result.success = @handler.getPendingAgreements()
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getPendingAgreements', seqid)
end

#process_getPreviousMessagesV2WithRequest(seqid, iprot, oprot) ⇒ Object 



1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1677

def process_getPreviousMessagesV2WithRequest(seqid, iprot, oprot)
  args = read_args(iprot, GetPreviousMessagesV2WithRequest_args)
  result = GetPreviousMessagesV2WithRequest_result.new()
  begin
    result.success = @handler.getPreviousMessagesV2WithRequest(args.request, args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getPreviousMessagesV2WithRequest', seqid)
end

#process_getProfile(seqid, iprot, oprot) ⇒ Object 



2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2226

def process_getProfile(seqid, iprot, oprot)
  args = read_args(iprot, GetProfile_args)
  result = GetProfile_result.new()
  begin
    result.success = @handler.getProfile(args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getProfile', seqid)
end

#process_getRecentFriendRequests(seqid, iprot, oprot) ⇒ Object 



1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1465

def process_getRecentFriendRequests(seqid, iprot, oprot)
  args = read_args(iprot, GetRecentFriendRequests_args)
  result = GetRecentFriendRequests_result.new()
  begin
    result.success = @handler.getRecentFriendRequests(args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getRecentFriendRequests', seqid)
end

#process_getRecommendationIds(seqid, iprot, oprot) ⇒ Object 



1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1860

def process_getRecommendationIds(seqid, iprot, oprot)
  args = read_args(iprot, GetRecommendationIds_args)
  result = GetRecommendationIds_result.new()
  begin
    result.success = @handler.getRecommendationIds(args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getRecommendationIds', seqid)
end

#process_getRoomsV2(seqid, iprot, oprot) ⇒ Object 



2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2453

def process_getRoomsV2(seqid, iprot, oprot)
  args = read_args(iprot, GetRoomsV2_args)
  result = GetRoomsV2_result.new()
  begin
    result.success = @handler.getRoomsV2(args.roomIds)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getRoomsV2', seqid)
end

#process_getRSAKeyInfo(seqid, iprot, oprot) ⇒ Object 



1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1564

def process_getRSAKeyInfo(seqid, iprot, oprot)
  args = read_args(iprot, GetRSAKeyInfo_args)
  result = GetRSAKeyInfo_result.new()
  begin
    result.success = @handler.getRSAKeyInfo(args.provider)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getRSAKeyInfo', seqid)
end

#process_getSettings(seqid, iprot, oprot) ⇒ Object 



2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2281

def process_getSettings(seqid, iprot, oprot)
  args = read_args(iprot, GetSettings_args)
  result = GetSettings_result.new()
  begin
    result.success = @handler.getSettings(args.syncReason)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getSettings', seqid)
end

#process_getSettingsAttributes2(seqid, iprot, oprot) ⇒ Object 



2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2299

def process_getSettingsAttributes2(seqid, iprot, oprot)
  args = read_args(iprot, GetSettingsAttributes2_args)
  result = GetSettingsAttributes2_result.new()
  begin
    result.success = @handler.getSettingsAttributes2(args.attributesToRetrieve)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'getSettingsAttributes2', seqid)
end

#process_inviteFriendsBySms(seqid, iprot, oprot) ⇒ Object 



1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1838

def process_inviteFriendsBySms(seqid, iprot, oprot)
  args = read_args(iprot, InviteFriendsBySms_args)
  result = InviteFriendsBySms_result.new()
  begin
    @handler.inviteFriendsBySms(args.phoneNumberList)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'inviteFriendsBySms', seqid)
end

#process_inviteIntoChat(seqid, iprot, oprot) ⇒ Object 



2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2321

def process_inviteIntoChat(seqid, iprot, oprot)
  args = read_args(iprot, InviteIntoChat_args)
  result = InviteIntoChat_result.new()
  begin
    result.success = @handler.inviteIntoChat(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'inviteIntoChat', seqid)
end

#process_inviteIntoRoom(seqid, iprot, oprot) ⇒ Object 



1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1809

def process_inviteIntoRoom(seqid, iprot, oprot)
  args = read_args(iprot, InviteIntoRoom_args)
  result = InviteIntoRoom_result.new()
  begin
    @handler.inviteIntoRoom(args.reqSeq, args.roomId, args.contactIds)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'inviteIntoRoom', seqid)
end

#process_leaveRoom(seqid, iprot, oprot) ⇒ Object 



2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2010

def process_leaveRoom(seqid, iprot, oprot)
  args = read_args(iprot, LeaveRoom_args)
  result = LeaveRoom_result.new()
  begin
    @handler.leaveRoom(args.reqSeq, args.roomId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'leaveRoom', seqid)
end

#process_negotiateE2EEPublicKey(seqid, iprot, oprot) ⇒ Object 



1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1754

def process_negotiateE2EEPublicKey(seqid, iprot, oprot)
  args = read_args(iprot, NegotiateE2EEPublicKey_args)
  result = NegotiateE2EEPublicKey_result.new()
  begin
    result.success = @handler.negotiateE2EEPublicKey(args.mid)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'negotiateE2EEPublicKey', seqid)
end

#process_noop(seqid, iprot, oprot) ⇒ Object 



2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2032

def process_noop(seqid, iprot, oprot)
  args = read_args(iprot, Noop_args)
  result = Noop_result.new()
  begin
    @handler.noop()
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'noop', seqid)
end

#process_notifyInstalled(seqid, iprot, oprot) ⇒ Object 



2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2065

def process_notifyInstalled(seqid, iprot, oprot)
  args = read_args(iprot, NotifyInstalled_args)
  result = NotifyInstalled_result.new()
  begin
    @handler.notifyInstalled(args.udidHash, args.applicationTypeWithExtensions)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'notifyInstalled', seqid)
end

#process_notifyRegistrationComplete(seqid, iprot, oprot) ⇒ Object 



1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1955

def process_notifyRegistrationComplete(seqid, iprot, oprot)
  args = read_args(iprot, NotifyRegistrationComplete_args)
  result = NotifyRegistrationComplete_result.new()
  begin
    @handler.notifyRegistrationComplete(args.udidHash, args.applicationTypeWithExtensions)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'notifyRegistrationComplete', seqid)
end

#process_notifySleep(seqid, iprot, oprot) ⇒ Object 



2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2186

def process_notifySleep(seqid, iprot, oprot)
  args = read_args(iprot, NotifySleep_args)
  result = NotifySleep_result.new()
  begin
    @handler.notifySleep(args.lastRev, args.badge)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'notifySleep', seqid)
end

#process_notifyUpdated(seqid, iprot, oprot) ⇒ Object 



1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1999

def process_notifyUpdated(seqid, iprot, oprot)
  args = read_args(iprot, NotifyUpdated_args)
  result = NotifyUpdated_result.new()
  begin
    @handler.notifyUpdated(args.lastRev, args.deviceInfo, args.udidHash, args.oldUdidHash)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'notifyUpdated', seqid)
end

#process_openProximityMatch(seqid, iprot, oprot) ⇒ Object 



1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1893

def process_openProximityMatch(seqid, iprot, oprot)
  args = read_args(iprot, OpenProximityMatch_args)
  result = OpenProximityMatch_result.new()
  begin
    result.success = @handler.openProximityMatch(args.location, args.networkStatus)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'openProximityMatch', seqid)
end

#process_registerE2EEPublicKey(seqid, iprot, oprot) ⇒ Object 



2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2087

def process_registerE2EEPublicKey(seqid, iprot, oprot)
  args = read_args(iprot, RegisterE2EEPublicKey_args)
  result = RegisterE2EEPublicKey_result.new()
  begin
    result.success = @handler.registerE2EEPublicKey(args.reqSeq, args.publicKey)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'registerE2EEPublicKey', seqid)
end

#process_registerUserid(seqid, iprot, oprot) ⇒ Object 



2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2153

def process_registerUserid(seqid, iprot, oprot)
  args = read_args(iprot, RegisterUserid_args)
  result = RegisterUserid_result.new()
  begin
    @handler.registerUserid(args.reqSeq, args.searchId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'registerUserid', seqid)
end

#process_reissueChatTicket(seqid, iprot, oprot) ⇒ Object 



2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2332

def process_reissueChatTicket(seqid, iprot, oprot)
  args = read_args(iprot, ReissueChatTicket_args)
  result = ReissueChatTicket_result.new()
  begin
    result.success = @handler.reissueChatTicket(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'reissueChatTicket', seqid)
end

#process_rejectChatInvitation(seqid, iprot, oprot) ⇒ Object 



2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2343

def process_rejectChatInvitation(seqid, iprot, oprot)
  args = read_args(iprot, RejectChatInvitation_args)
  result = RejectChatInvitation_result.new()
  begin
    result.success = @handler.rejectChatInvitation(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'rejectChatInvitation', seqid)
end

#process_removeAllMessages(seqid, iprot, oprot) ⇒ Object 



1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1787

def process_removeAllMessages(seqid, iprot, oprot)
  args = read_args(iprot, RemoveAllMessages_args)
  result = RemoveAllMessages_result.new()
  begin
    @handler.removeAllMessages(args.seq, args.lastMessageId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'removeAllMessages', seqid)
end

#process_removeChatRoomAnnouncement(seqid, iprot, oprot) ⇒ Object 



1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1688

def process_removeChatRoomAnnouncement(seqid, iprot, oprot)
  args = read_args(iprot, RemoveChatRoomAnnouncement_args)
  result = RemoveChatRoomAnnouncement_result.new()
  begin
    @handler.removeChatRoomAnnouncement(args.reqSeq, args.chatRoomMid, args.announcementSeq)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'removeChatRoomAnnouncement', seqid)
end

#process_removeFriendRequest(seqid, iprot, oprot) ⇒ Object 



1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1487

def process_removeFriendRequest(seqid, iprot, oprot)
  args = read_args(iprot, RemoveFriendRequest_args)
  result = RemoveFriendRequest_result.new()
  begin
    @handler.removeFriendRequest(args.direction, args.midOrEMid)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'removeFriendRequest', seqid)
end

#process_reportAbuse(seqid, iprot, oprot) ⇒ Object 



1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1699

def process_reportAbuse(seqid, iprot, oprot)
  args = read_args(iprot, ReportAbuse_args)
  result = ReportAbuse_result.new()
  begin
    @handler.reportAbuse(args.abuseReport)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'reportAbuse', seqid)
end

#process_reportDeviceState(seqid, iprot, oprot) ⇒ Object 



1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1531

def process_reportDeviceState(seqid, iprot, oprot)
  args = read_args(iprot, ReportDeviceState_args)
  result = ReportDeviceState_result.new()
  begin
    @handler.reportDeviceState(args.booleanState, args.stringState)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'reportDeviceState', seqid)
end

#process_respondE2EEKeyExchange(seqid, iprot, oprot) ⇒ Object 



1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1732

def process_respondE2EEKeyExchange(seqid, iprot, oprot)
  args = read_args(iprot, RespondE2EEKeyExchange_args)
  result = RespondE2EEKeyExchange_result.new()
  begin
    @handler.respondE2EEKeyExchange(args.reqSeq, args.encryptedKeyChain, args.hashKeyChain)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'respondE2EEKeyExchange', seqid)
end

#process_sendChatChecked(seqid, iprot, oprot) ⇒ Object 



1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1542

def process_sendChatChecked(seqid, iprot, oprot)
  args = read_args(iprot, SendChatChecked_args)
  result = SendChatChecked_result.new()
  begin
    @handler.sendChatChecked(args.seq, args.chatMid, args.lastMessageId, args.sessionId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'sendChatChecked', seqid)
end

#process_sendChatRemoved(seqid, iprot, oprot) ⇒ Object 



1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1776

def process_sendChatRemoved(seqid, iprot, oprot)
  args = read_args(iprot, SendChatRemoved_args)
  result = SendChatRemoved_result.new()
  begin
    @handler.sendChatRemoved(args.seq, args.chatMid, args.lastMessageId, args.sessionId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'sendChatRemoved', seqid)
end

#process_sendMessage(seqid, iprot, oprot) ⇒ Object 



1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1765

def process_sendMessage(seqid, iprot, oprot)
  args = read_args(iprot, SendMessage_args)
  result = SendMessage_result.new()
  begin
    result.success = @handler.sendMessage(args.seq, args.message)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'sendMessage', seqid)
end

#process_sendPostback(seqid, iprot, oprot) ⇒ Object 



1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1509

def process_sendPostback(seqid, iprot, oprot)
  args = read_args(iprot, SendPostback_args)
  result = SendPostback_result.new()
  begin
    @handler.sendPostback(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'sendPostback', seqid)
end

#process_setNotificationsEnabled(seqid, iprot, oprot) ⇒ Object 



2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2365

def process_setNotificationsEnabled(seqid, iprot, oprot)
  args = read_args(iprot, SetNotificationsEnabled_args)
  result = SetNotificationsEnabled_result.new()
  begin
    @handler.setNotificationsEnabled(args.reqSeq, args.type, args.target, args.enablement)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'setNotificationsEnabled', seqid)
end

#process_syncContacts(seqid, iprot, oprot) ⇒ Object 



1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1926

def process_syncContacts(seqid, iprot, oprot)
  args = read_args(iprot, SyncContacts_args)
  result = SyncContacts_result.new()
  begin
    result.success = @handler.syncContacts(args.reqSeq, args.localContacts)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'syncContacts', seqid)
end

#process_unblockContact(seqid, iprot, oprot) ⇒ Object 



1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1937

def process_unblockContact(seqid, iprot, oprot)
  args = read_args(iprot, UnblockContact_args)
  result = UnblockContact_result.new()
  begin
    @handler.unblockContact(args.reqSeq, args.id, args.reference)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'unblockContact', seqid)
end

#process_unblockRecommendation(seqid, iprot, oprot) ⇒ Object 



2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2076

def process_unblockRecommendation(seqid, iprot, oprot)
  args = read_args(iprot, UnblockRecommendation_args)
  result = UnblockRecommendation_result.new()
  begin
    @handler.unblockRecommendation(args.reqSeq, args.id)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'unblockRecommendation', seqid)
end

#process_unregisterUserAndDevice(seqid, iprot, oprot) ⇒ Object 



2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2043

def process_unregisterUserAndDevice(seqid, iprot, oprot)
  args = read_args(iprot, UnregisterUserAndDevice_args)
  result = UnregisterUserAndDevice_result.new()
  begin
    result.success = @handler.unregisterUserAndDevice()
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'unregisterUserAndDevice', seqid)
end

#process_updateAccountMigrationPincode(seqid, iprot, oprot) ⇒ Object 



1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1798

def process_updateAccountMigrationPincode(seqid, iprot, oprot)
  args = read_args(iprot, UpdateAccountMigrationPincode_args)
  result = UpdateAccountMigrationPincode_result.new()
  begin
    @handler.updateAccountMigrationPincode(args.accountMigrationPincode)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'updateAccountMigrationPincode', seqid)
end

#process_updateAndGetNearby(seqid, iprot, oprot) ⇒ Object 



1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1593

def process_updateAndGetNearby(seqid, iprot, oprot)
  args = read_args(iprot, UpdateAndGetNearby_args)
  result = UpdateAndGetNearby_result.new()
  begin
    result.success = @handler.updateAndGetNearby(args.latitude, args.longitude, args.accuracy, args.networkStatus, args.altitudeMeters, args.velocityMetersPerSecond, args.bearingDegrees)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'updateAndGetNearby', seqid)
end

#process_updateChat(seqid, iprot, oprot) ⇒ Object 



2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2387

def process_updateChat(seqid, iprot, oprot)
  args = read_args(iprot, UpdateChat_args)
  result = UpdateChat_result.new()
  begin
    result.success = @handler.updateChat(args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'updateChat', seqid)
end

#process_updateChatRoomBGM(seqid, iprot, oprot) ⇒ Object 



1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1710

def process_updateChatRoomBGM(seqid, iprot, oprot)
  args = read_args(iprot, UpdateChatRoomBGM_args)
  result = UpdateChatRoomBGM_result.new()
  begin
    result.success = @handler.updateChatRoomBGM(args.reqSeq, args.chatRoomMid, args.chatRoomBGMInfo)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'updateChatRoomBGM', seqid)
end

#process_updateContactSetting(seqid, iprot, oprot) ⇒ Object 



1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1871

def process_updateContactSetting(seqid, iprot, oprot)
  args = read_args(iprot, UpdateContactSetting_args)
  result = UpdateContactSetting_result.new()
  begin
    @handler.updateContactSetting(args.reqSeq, args.mid, args.flag, args.value)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'updateContactSetting', seqid)
end

#process_updateExtendedProfileAttribute(seqid, iprot, oprot) ⇒ Object 



1575
1576
1577
1578
1579
1580
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1575

def process_updateExtendedProfileAttribute(seqid, iprot, oprot)
  args = read_args(iprot, UpdateExtendedProfileAttribute_args)
  result = UpdateExtendedProfileAttribute_result.new()
  @handler.updateExtendedProfileAttribute(args.reqSeq, args.attr, args.extendedProfile)
  write_result(result, oprot, 'updateExtendedProfileAttribute', seqid)
end

#process_updateProfileAttributes(seqid, iprot, oprot) ⇒ Object 



1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1721

def process_updateProfileAttributes(seqid, iprot, oprot)
  args = read_args(iprot, UpdateProfileAttributes_args)
  result = UpdateProfileAttributes_result.new()
  begin
    @handler.updateProfileAttributes(args.reqSeq, args.request)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'updateProfileAttributes', seqid)
end

#process_updateSettingsAttributes2(seqid, iprot, oprot) ⇒ Object 



2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 2398

def process_updateSettingsAttributes2(seqid, iprot, oprot)
  args = read_args(iprot, UpdateSettingsAttributes2_args)
  result = UpdateSettingsAttributes2_result.new()
  begin
    result.success = @handler.updateSettingsAttributes2(args.reqSeq, args.attributesToUpdate, args.settings)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'updateSettingsAttributes2', seqid)
end

#process_verifyAccountMigration(seqid, iprot, oprot) ⇒ Object 



1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1988

def process_verifyAccountMigration(seqid, iprot, oprot)
  args = read_args(iprot, VerifyAccountMigration_args)
  result = VerifyAccountMigration_result.new()
  begin
    @handler.verifyAccountMigration(args.migrationSessionId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'verifyAccountMigration', seqid)
end

#process_verifyIdentityCredentialWithResult(seqid, iprot, oprot) ⇒ Object 



1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
 
# File 'lib/linerb/gen-rb/talk_service.rb', line 1882

def process_verifyIdentityCredentialWithResult(seqid, iprot, oprot)
  args = read_args(iprot, VerifyIdentityCredentialWithResult_args)
  result = VerifyIdentityCredentialWithResult_result.new()
  begin
    result.success = @handler.verifyIdentityCredentialWithResult(args.identityCredential, args.migrationPincodeSessionId)
  rescue ::TalkException => e
    result.e = e
  end
  write_result(result, oprot, 'verifyIdentityCredentialWithResult', seqid)
end