1#!/usr/bin/env python3
2#
3#   Copyright 2018 Google, Inc.
4#
5#   Licensed under the Apache License, Version 2.0 (the "License");
6#   you may not use this file except in compliance with the License.
7#   You may obtain a copy of the License at
8#
9#       http://www.apache.org/licenses/LICENSE-2.0
10#
11#   Unless required by applicable law or agreed to in writing, software
12#   distributed under the License is distributed on an "AS IS" BASIS,
13#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14#   See the License for the specific language governing permissions and
15#   limitations under the License.
16
17import time
18
19from acts import asserts
20from acts import utils
21from acts_contrib.test_utils.wifi.p2p import wifi_p2p_const as p2pconsts
22import acts.utils
23
24
25def is_discovered(event, ad):
26    """Check an Android device exist in WifiP2pOnPeersAvailable event or not.
27
28    Args:
29        event: WifiP2pOnPeersAvailable which include all of p2p devices.
30        ad: The android device
31    Returns:
32        True: if an Android device exist in p2p list
33        False: if not exist
34    """
35    for device in event['data']['Peers']:
36        if device['Name'] == ad.name:
37            ad.deviceAddress = device['Address']
38            return True
39    return False
40
41
42def check_disconnect(ad, timeout=p2pconsts.DEFAULT_TIMEOUT):
43    """Check an Android device disconnect or not
44
45    Args:
46        ad: The android device
47    """
48    ad.droid.wifiP2pRequestConnectionInfo()
49    # wait disconnect event
50    ad.ed.pop_event(p2pconsts.DISCONNECTED_EVENT, timeout)
51
52
53def p2p_disconnect(ad):
54    """Invoke an Android device removeGroup to trigger p2p disconnect
55
56    Args:
57        ad: The android device
58    """
59    ad.log.debug("Disconnect")
60    ad.droid.wifiP2pRemoveGroup()
61    check_disconnect(ad)
62
63
64def p2p_connection_ping_test(ad, target_ip_address):
65    """Let an Android device to start ping target_ip_address
66
67    Args:
68        ad: The android device
69        target_ip_address: ip address which would like to ping
70    """
71    ad.log.debug("Run Ping Test, %s ping %s " % (ad.serial, target_ip_address))
72    asserts.assert_true(
73        acts.utils.adb_shell_ping(ad,
74                                  count=6,
75                                  dest_ip=target_ip_address,
76                                  timeout=20), "%s ping failed" % (ad.serial))
77
78
79def is_go(ad):
80    """Check an Android p2p role is Go or not
81
82    Args:
83        ad: The android device
84    Return:
85        True: An Android device is p2p  go
86        False: An Android device is p2p gc
87    """
88    ad.log.debug("is go check")
89    ad.droid.wifiP2pRequestConnectionInfo()
90    ad_connect_info_event = ad.ed.pop_event(
91        p2pconsts.CONNECTION_INFO_AVAILABLE_EVENT, p2pconsts.DEFAULT_TIMEOUT)
92    if ad_connect_info_event['data']['isGroupOwner']:
93        return True
94    return False
95
96
97def p2p_go_ip(ad):
98    """Get GO IP address
99
100    Args:
101        ad: The android device
102    Return:
103        GO IP address
104    """
105    ad.log.debug("p2p go ip")
106    ad.droid.wifiP2pRequestConnectionInfo()
107    ad_connect_info_event = ad.ed.pop_event(
108        p2pconsts.CONNECTION_INFO_AVAILABLE_EVENT, p2pconsts.DEFAULT_TIMEOUT)
109    ad.log.debug("p2p go ip: %s" %
110                 ad_connect_info_event['data']['groupOwnerHostAddress'])
111    return ad_connect_info_event['data']['groupOwnerHostAddress']
112
113
114def p2p_get_current_group(ad):
115    """Get current group information
116
117    Args:
118        ad: The android device
119    Return:
120        p2p group information
121    """
122    ad.log.debug("get current group")
123    ad.droid.wifiP2pRequestGroupInfo()
124    ad_group_info_event = ad.ed.pop_event(p2pconsts.GROUP_INFO_AVAILABLE_EVENT,
125                                          p2pconsts.DEFAULT_TIMEOUT)
126    ad.log.debug(
127        "p2p group: SSID:%s, password:%s, owner address: %s, interface: %s" %
128        (ad_group_info_event['data']['NetworkName'],
129         ad_group_info_event['data']['Passphrase'],
130         ad_group_info_event['data']['OwnerAddress'],
131         ad_group_info_event['data']['Interface']))
132    return ad_group_info_event['data']
133
134
135def is_ongoing_peer_ready(peerConfig, waitForPin):
136    """Check whether the peer config is ready
137
138    Args:
139        peerConfig: the ongoing config
140        waitForPin: this config needs key or not
141    Return:
142        true for ready; false otherwise.
143    """
144    if peerConfig is None:
145        return False
146    if not peerConfig['data'][WifiP2PEnums.WifiP2pConfig.DEVICEADDRESS_KEY]:
147        return False
148    if not waitForPin:
149        return True
150    if WifiP2PEnums.WpsInfo.WPS_PIN_KEY in peerConfig['data'][
151            WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY]:
152        return True
153    return False
154
155
156def wait_for_ongoing_peer_ready(ad, waitForPin, maxPollingCount):
157    """wait for the ongoing peer data ready
158
159    Args:
160        ad: The android device
161        waitForPin: this config needs key or not
162        maxPollingCount: the max polling count
163    Return:
164        the ongoing peer config
165    """
166    ad_peerConfig = None
167    ad.log.debug("%s is waiting for the ongoing peer, max polling count %s" %
168                 (ad.name, maxPollingCount))
169    while maxPollingCount > 0:
170        ad.droid.requestP2pPeerConfigure()
171        ad_peerConfig = ad.ed.pop_event(
172            p2pconsts.ONGOING_PEER_INFO_AVAILABLE_EVENT,
173            p2pconsts.DEFAULT_TIMEOUT)
174        maxPollingCount -= 1
175        if is_ongoing_peer_ready(ad_peerConfig, waitForPin):
176            break
177        ad.log.debug("%s is not ready for next step" % (ad.name))
178        time.sleep(p2pconsts.DEFAULT_POLLING_SLEEPTIME)
179    asserts.assert_true(
180        ad_peerConfig['data'][WifiP2PEnums.WifiP2pConfig.DEVICEADDRESS_KEY],
181        "DUT %s does not receive the request." % (ad.name))
182    ad.log.debug(ad_peerConfig['data'])
183    return ad_peerConfig
184
185
186#trigger p2p connect to ad2 from ad1
187def p2p_connect(ad1,
188                ad2,
189                isReconnect,
190                wpsSetup,
191                p2p_connect_type=p2pconsts.P2P_CONNECT_NEGOTIATION,
192                go_ad=None):
193    """trigger p2p connect to ad2 from ad1
194
195    Args:
196        ad1: The android device
197        ad2: The android device
198        isReconnect: boolean, if persist group is exist,
199                isReconnect is true, otherswise is false.
200        wpsSetup: which wps connection would like to use
201        p2p_connect_type: enumeration, which type this p2p connection is
202        go_ad: The group owner android device which is used for the invitation connection
203    """
204    ad1.log.info("Create p2p connection from %s to %s via wps: %s type %d" %
205                 (ad1.name, ad2.name, wpsSetup, p2p_connect_type))
206    if p2p_connect_type == p2pconsts.P2P_CONNECT_INVITATION:
207        if go_ad is None:
208            go_ad = ad1
209        find_p2p_device(ad1, ad2)
210        # GO might be another peer, so ad2 needs to find it first.
211        find_p2p_group_owner(ad2, go_ad)
212    elif p2p_connect_type == p2pconsts.P2P_CONNECT_JOIN:
213        find_p2p_group_owner(ad1, ad2)
214    else:
215        find_p2p_device(ad1, ad2)
216    time.sleep(p2pconsts.DEFAULT_SLEEPTIME)
217    wifi_p2p_config = {
218        WifiP2PEnums.WifiP2pConfig.DEVICEADDRESS_KEY: ad2.deviceAddress,
219        WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY: {
220            WifiP2PEnums.WpsInfo.WPS_SETUP_KEY: wpsSetup
221        }
222    }
223    ad1.droid.wifiP2pConnect(wifi_p2p_config)
224    ad1.ed.pop_event(p2pconsts.CONNECT_SUCCESS_EVENT,
225                     p2pconsts.DEFAULT_TIMEOUT)
226    if not isReconnect:
227        # ad1 is the initiator, it should be ready soon.
228        ad1_peerConfig = wait_for_ongoing_peer_ready(
229            ad1, wpsSetup == WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_DISPLAY, 6)
230        # auto-join tries 10 times to find groups, and
231        # one round takes 2 - 3 seconds.
232        ad2_peerConfig = wait_for_ongoing_peer_ready(
233            ad2, wpsSetup == WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_KEYPAD, 31)
234        if wpsSetup == WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_DISPLAY:
235            asserts.assert_true(
236                WifiP2PEnums.WpsInfo.WPS_PIN_KEY in ad1_peerConfig['data'][
237                    WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY],
238                "Can't get display pin value")
239            ad2_peerConfig['data'][WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY][
240                WifiP2PEnums.WpsInfo.WPS_PIN_KEY] = ad1_peerConfig['data'][
241                    WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY][
242                        WifiP2PEnums.WpsInfo.WPS_PIN_KEY]
243            ad2.droid.setP2pPeerConfigure(ad2_peerConfig['data'])
244            ad2.ed.pop_event(p2pconsts.ONGOING_PEER_SET_SUCCESS_EVENT,
245                             p2pconsts.DEFAULT_TIMEOUT)
246            ad2.droid.wifiP2pAcceptConnection()
247        elif wpsSetup == WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_KEYPAD:
248            asserts.assert_true(
249                WifiP2PEnums.WpsInfo.WPS_PIN_KEY in ad2_peerConfig['data'][
250                    WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY],
251                "Can't get keypad pin value")
252            ad1_peerConfig['data'][WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY][
253                WifiP2PEnums.WpsInfo.WPS_PIN_KEY] = ad2_peerConfig['data'][
254                    WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY][
255                        WifiP2PEnums.WpsInfo.WPS_PIN_KEY]
256            ad1.droid.setP2pPeerConfigure(ad1_peerConfig['data'])
257            ad1.ed.pop_event(p2pconsts.ONGOING_PEER_SET_SUCCESS_EVENT,
258                             p2pconsts.DEFAULT_TIMEOUT)
259            ad1.droid.wifiP2pAcceptConnection()
260            time.sleep(p2pconsts.DEFAULT_SLEEPTIME)
261            ad2.droid.wifiP2pConfirmConnection()
262        elif wpsSetup == WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_PBC:
263            ad2.droid.wifiP2pAcceptConnection()
264            if p2p_connect_type == p2pconsts.P2P_CONNECT_INVITATION:
265                time.sleep(p2pconsts.DEFAULT_SLEEPTIME)
266                go_ad.droid.wifiP2pAcceptConnection()
267
268    #wait connected event
269    if p2p_connect_type == p2pconsts.P2P_CONNECT_INVITATION:
270        go_ad.ed.pop_event(p2pconsts.CONNECTED_EVENT,
271                           p2pconsts.DEFAULT_TIMEOUT)
272    else:
273        ad1.ed.pop_event(p2pconsts.CONNECTED_EVENT, p2pconsts.DEFAULT_TIMEOUT)
274    ad2.ed.pop_event(p2pconsts.CONNECTED_EVENT, p2pconsts.DEFAULT_TIMEOUT)
275
276
277def p2p_connect_with_config(ad1, ad2, network_name, passphrase, band):
278    """trigger p2p connect to ad2 from ad1 with config
279
280    Args:
281        ad1: The android device
282        ad2: The android device
283        network_name: the network name of the desired group.
284        passphrase: the passphrase of the desired group.
285        band: the operating band of the desired group.
286    """
287    ad1.log.info("Create p2p connection from %s to %s" % (ad1.name, ad2.name))
288    find_p2p_device(ad1, ad2)
289    time.sleep(p2pconsts.DEFAULT_SLEEPTIME)
290    wifi_p2p_config = {
291        WifiP2PEnums.WifiP2pConfig.NETWORK_NAME: network_name,
292        WifiP2PEnums.WifiP2pConfig.PASSPHRASE: passphrase,
293        WifiP2PEnums.WifiP2pConfig.GROUP_BAND: band,
294        WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY: {
295            WifiP2PEnums.WpsInfo.WPS_SETUP_KEY:
296            WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_PBC
297        }
298    }
299    ad1.droid.wifiP2pConnect(wifi_p2p_config)
300    ad1.ed.pop_event(p2pconsts.CONNECT_SUCCESS_EVENT,
301                     p2pconsts.DEFAULT_TIMEOUT)
302    time.sleep(p2pconsts.DEFAULT_SLEEPTIME)
303
304    #wait connected event
305    ad1.ed.pop_event(p2pconsts.CONNECTED_EVENT, p2pconsts.DEFAULT_TIMEOUT)
306    ad2.ed.pop_event(p2pconsts.CONNECTED_EVENT, p2pconsts.DEFAULT_TIMEOUT)
307
308
309def find_p2p_device(ad1, ad2):
310    """Check an Android device ad1 can discover an Android device ad2
311
312    Args:
313        ad1: The android device
314        ad2: The android device
315    """
316    ad1.droid.wifiP2pDiscoverPeers()
317    ad2.droid.wifiP2pDiscoverPeers()
318    p2p_find_result = False
319    ad1.ed.clear_events(p2pconsts.PEER_AVAILABLE_EVENT)
320    while not p2p_find_result:
321        ad1_event = ad1.ed.pop_event(p2pconsts.PEER_AVAILABLE_EVENT,
322                                     p2pconsts.P2P_FIND_TIMEOUT)
323        ad1.log.debug(ad1_event['data'])
324        p2p_find_result = is_discovered(ad1_event, ad2)
325    asserts.assert_true(p2p_find_result,
326                        "DUT didn't discovered peer:%s device" % (ad2.name))
327
328
329def find_p2p_group_owner(ad1, ad2):
330    """Check an Android device ad1 can discover an Android device ad2 which
331       is a group owner
332
333    Args:
334        ad1: The android device
335        ad2: The android device which is a group owner
336    """
337    p2p_find_result = False
338    ad1.ed.clear_events(p2pconsts.PEER_AVAILABLE_EVENT)
339    while not p2p_find_result:
340        ad2.droid.wifiP2pStopPeerDiscovery()
341        ad1.droid.wifiP2pStopPeerDiscovery()
342        ad1.droid.wifiP2pDiscoverPeers()
343        ad1_event = ad1.ed.pop_event(p2pconsts.PEER_AVAILABLE_EVENT,
344                                     p2pconsts.P2P_FIND_TIMEOUT)
345        ad1.log.debug(ad1_event['data'])
346        for device in ad1_event['data']['Peers']:
347            if (device['Name'] == ad2.name and int(device['GroupCapability'])
348                    & p2pconsts.P2P_GROUP_CAPAB_GROUP_OWNER):
349                ad2.deviceAddress = device['Address']
350                p2p_find_result = True
351    asserts.assert_true(
352        p2p_find_result,
353        "DUT didn't discovered group owner peer:%s device" % (ad2.name))
354
355
356def createP2pLocalService(ad, serviceCategory):
357    """Based on serviceCategory to create p2p local service
358            on an Android device ad
359
360    Args:
361        ad: The android device
362        serviceCategory: p2p local service type, UPNP / IPP / AFP,
363    """
364    testData = genTestData(serviceCategory)
365    if serviceCategory == p2pconsts.P2P_LOCAL_SERVICE_UPNP:
366        ad.droid.wifiP2pCreateUpnpServiceInfo(testData[0], testData[1],
367                                              testData[2])
368    elif (serviceCategory == p2pconsts.P2P_LOCAL_SERVICE_IPP
369          or serviceCategory == p2pconsts.P2P_LOCAL_SERVICE_AFP):
370        ad.droid.wifiP2pCreateBonjourServiceInfo(testData[0], testData[1],
371                                                 testData[2])
372    ad.droid.wifiP2pAddLocalService()
373
374
375def requestServiceAndCheckResult(ad_serviceProvider, ad_serviceReceiver,
376                                 serviceType, queryString1, queryString2):
377    """Based on serviceType and query info, check service request result
378            same as expect or not on an Android device ad_serviceReceiver.
379            And remove p2p service request after result check.
380
381    Args:
382        ad_serviceProvider: The android device which provide p2p local service
383        ad_serviceReceiver: The android device which query p2p local service
384        serviceType: P2p local service type, Upnp or Bonjour
385        queryString1: Query String, NonNull
386        queryString2: Query String, used for Bonjour, Nullable
387    """
388    expectData = genExpectTestData(serviceType, queryString1, queryString2)
389    find_p2p_device(ad_serviceReceiver, ad_serviceProvider)
390    ad_serviceReceiver.droid.wifiP2pStopPeerDiscovery()
391    ad_serviceReceiver.droid.wifiP2pClearServiceRequests()
392    time.sleep(p2pconsts.DEFAULT_FUNCTION_SWITCH_TIME)
393
394    ad_serviceReceiver.droid.wifiP2pDiscoverServices()
395    serviceData = {}
396    service_id = 0
397    if (serviceType ==
398            WifiP2PEnums.WifiP2pServiceInfo.WIFI_P2P_SERVICE_TYPE_BONJOUR):
399        ad_serviceReceiver.log.info(
400            "Request bonjour service in \
401                %s with Query String %s and %s " %
402            (ad_serviceReceiver.name, queryString1, queryString2))
403        ad_serviceReceiver.log.info("expectData %s" % expectData)
404        if queryString1 != None:
405            service_id = ad_serviceReceiver.droid.wifiP2pAddDnssdServiceRequest(
406                queryString1, queryString2)
407        else:
408            service_id = ad_serviceReceiver.droid.wifiP2pAddServiceRequest(
409                serviceType)
410            ad_serviceReceiver.log.info("request bonjour service id %s" %
411                                        service_id)
412        ad_serviceReceiver.droid.wifiP2pSetDnsSdResponseListeners()
413        ad_serviceReceiver.droid.wifiP2pDiscoverServices()
414        ad_serviceReceiver.log.info("Check Service Listener")
415        time.sleep(p2pconsts.DEFAULT_SERVICE_WAITING_TIME)
416        try:
417            dnssd_events = ad_serviceReceiver.ed.pop_all(p2pconsts.DNSSD_EVENT)
418            dnssd_txrecord_events = ad_serviceReceiver.ed.pop_all(
419                p2pconsts.DNSSD_TXRECORD_EVENT)
420            dns_service = WifiP2PEnums.WifiP2pDnsSdServiceResponse()
421            for dnssd_event in dnssd_events:
422                if dnssd_event['data'][
423                        'SourceDeviceAddress'] == ad_serviceProvider.deviceAddress:
424                    dns_service.InstanceName = dnssd_event['data'][
425                        p2pconsts.DNSSD_EVENT_INSTANCENAME_KEY]
426                    dns_service.RegistrationType = dnssd_event['data'][
427                        p2pconsts.DNSSD_EVENT_REGISTRATIONTYPE_KEY]
428                    dns_service.FullDomainName = ""
429                    dns_service.TxtRecordMap = ""
430                    serviceData[dns_service.toString()] = 1
431            for dnssd_txrecord_event in dnssd_txrecord_events:
432                if dnssd_txrecord_event['data'][
433                        'SourceDeviceAddress'] == ad_serviceProvider.deviceAddress:
434                    dns_service.InstanceName = ""
435                    dns_service.RegistrationType = ""
436                    dns_service.FullDomainName = dnssd_txrecord_event['data'][
437                        p2pconsts.DNSSD_TXRECORD_EVENT_FULLDOMAINNAME_KEY]
438                    dns_service.TxtRecordMap = dnssd_txrecord_event['data'][
439                        p2pconsts.DNSSD_TXRECORD_EVENT_TXRECORDMAP_KEY]
440                    serviceData[dns_service.toString()] = 1
441            ad_serviceReceiver.log.info("serviceData %s" % serviceData)
442            if len(serviceData) == 0:
443                ad_serviceReceiver.droid.wifiP2pRemoveServiceRequest(
444                    service_id)
445                return -1
446        except queue.Empty as error:
447            ad_serviceReceiver.log.info("dnssd event is empty", )
448    elif (serviceType ==
449          WifiP2PEnums.WifiP2pServiceInfo.WIFI_P2P_SERVICE_TYPE_UPNP):
450        ad_serviceReceiver.log.info(
451            "Request upnp service in %s with Query String %s " %
452            (ad_serviceReceiver.name, queryString1))
453        ad_serviceReceiver.log.info("expectData %s" % expectData)
454        if queryString1 != None:
455            service_id = ad_serviceReceiver.droid.wifiP2pAddUpnpServiceRequest(
456                queryString1)
457        else:
458            service_id = ad_serviceReceiver.droid.wifiP2pAddServiceRequest(
459                WifiP2PEnums.WifiP2pServiceInfo.WIFI_P2P_SERVICE_TYPE_UPNP)
460        ad_serviceReceiver.droid.wifiP2pSetUpnpResponseListeners()
461        ad_serviceReceiver.droid.wifiP2pDiscoverServices()
462        ad_serviceReceiver.log.info("Check Service Listener")
463        time.sleep(p2pconsts.DEFAULT_SERVICE_WAITING_TIME)
464        try:
465            upnp_events = ad_serviceReceiver.ed.pop_all(p2pconsts.UPNP_EVENT)
466            for upnp_event in upnp_events:
467                if upnp_event['data']['Device'][
468                        'Address'] == ad_serviceProvider.deviceAddress:
469                    for service in upnp_event['data'][
470                            p2pconsts.UPNP_EVENT_SERVICELIST_KEY]:
471                        serviceData[service] = 1
472            ad_serviceReceiver.log.info("serviceData %s" % serviceData)
473            if len(serviceData) == 0:
474                ad_serviceReceiver.droid.wifiP2pRemoveServiceRequest(
475                    service_id)
476                return -1
477        except queue.Empty as error:
478            ad_serviceReceiver.log.info("p2p upnp event is empty", )
479
480    ad_serviceReceiver.log.info("Check ServiceList")
481    asserts.assert_true(checkServiceQueryResult(serviceData, expectData),
482                        "ServiceList not same as Expect")
483    # After service checked, remove the service_id
484    ad_serviceReceiver.droid.wifiP2pRemoveServiceRequest(service_id)
485    return 0
486
487
488def requestServiceAndCheckResultWithRetry(ad_serviceProvider,
489                                          ad_serviceReceiver,
490                                          serviceType,
491                                          queryString1,
492                                          queryString2,
493                                          retryCount=3):
494    """ allow failures for requestServiceAndCheckResult. Service
495        discovery might fail unexpectedly because the request packet might not be
496        recevied by the service responder due to p2p state switch.
497
498    Args:
499        ad_serviceProvider: The android device which provide p2p local service
500        ad_serviceReceiver: The android device which query p2p local service
501        serviceType: P2p local service type, Upnp or Bonjour
502        queryString1: Query String, NonNull
503        queryString2: Query String, used for Bonjour, Nullable
504        retryCount: maximum retry count, default is 3
505    """
506    ret = 0
507    while retryCount > 0:
508        ret = requestServiceAndCheckResult(ad_serviceProvider,
509                                           ad_serviceReceiver, serviceType,
510                                           queryString1, queryString2)
511        if (ret == 0):
512            break
513        retryCount -= 1
514
515    asserts.assert_equal(0, ret, "cannot find any services with retries.")
516
517
518def checkServiceQueryResult(serviceList, expectServiceList):
519    """Check serviceList same as expectServiceList or not
520
521    Args:
522        serviceList: ServiceList which get from query result
523        expectServiceList: ServiceList which hardcode in genExpectTestData
524    Return:
525        True: serviceList  same as expectServiceList
526        False:Exist discrepancy between serviceList and expectServiceList
527    """
528    tempServiceList = serviceList.copy()
529    tempExpectServiceList = expectServiceList.copy()
530    for service in serviceList.keys():
531        if service in expectServiceList:
532            del tempServiceList[service]
533            del tempExpectServiceList[service]
534    return len(tempExpectServiceList) == 0 and len(tempServiceList) == 0
535
536
537def genTestData(serviceCategory):
538    """Based on serviceCategory to generator Test Data
539
540    Args:
541        serviceCategory: P2p local service type, Upnp or Bonjour
542    Return:
543        TestData
544    """
545    testData = []
546    if serviceCategory == p2pconsts.P2P_LOCAL_SERVICE_UPNP:
547        testData.append(p2pconsts.UpnpTestData.uuid)
548        testData.append(p2pconsts.UpnpTestData.serviceType)
549        testData.append([
550            p2pconsts.UpnpTestData.AVTransport,
551            p2pconsts.UpnpTestData.ConnectionManager
552        ])
553    elif serviceCategory == p2pconsts.P2P_LOCAL_SERVICE_IPP:
554        testData.append(p2pconsts.IppTestData.ippInstanceName)
555        testData.append(p2pconsts.IppTestData.ippRegistrationType)
556        testData.append(p2pconsts.IppTestData.ipp_txtRecord)
557    elif serviceCategory == p2pconsts.P2P_LOCAL_SERVICE_AFP:
558        testData.append(p2pconsts.AfpTestData.afpInstanceName)
559        testData.append(p2pconsts.AfpTestData.afpRegistrationType)
560        testData.append(p2pconsts.AfpTestData.afp_txtRecord)
561
562    return testData
563
564
565def genExpectTestData(serviceType, queryString1, queryString2):
566    """Based on serviceCategory to generator expect serviceList
567
568    Args:
569        serviceType: P2p local service type, Upnp or Bonjour
570        queryString1: Query String, NonNull
571        queryString2: Query String, used for Bonjour, Nullable
572    Return:
573        expectServiceList
574    """
575    expectServiceList = {}
576    if (serviceType ==
577            WifiP2PEnums.WifiP2pServiceInfo.WIFI_P2P_SERVICE_TYPE_BONJOUR):
578        ipp_service = WifiP2PEnums.WifiP2pDnsSdServiceResponse()
579        afp_service = WifiP2PEnums.WifiP2pDnsSdServiceResponse()
580        if queryString1 == p2pconsts.IppTestData.ippRegistrationType:
581            if queryString2 == p2pconsts.IppTestData.ippInstanceName:
582                ipp_service.InstanceName = ""
583                ipp_service.RegistrationType = ""
584                ipp_service.FullDomainName = p2pconsts.IppTestData.ippDomainName
585                ipp_service.TxtRecordMap = p2pconsts.IppTestData.ipp_txtRecord
586                expectServiceList[ipp_service.toString()] = 1
587                return expectServiceList
588            ipp_service.InstanceName = p2pconsts.IppTestData.ippInstanceName
589            ipp_service.RegistrationType = (
590                p2pconsts.IppTestData.ippRegistrationType + ".local.")
591            ipp_service.FullDomainName = ""
592            ipp_service.TxtRecordMap = ""
593            expectServiceList[ipp_service.toString()] = 1
594            return expectServiceList
595        elif queryString1 == p2pconsts.AfpTestData.afpRegistrationType:
596            if queryString2 == p2pconsts.AfpTestData.afpInstanceName:
597                afp_service.InstanceName = ""
598                afp_service.RegistrationType = ""
599                afp_service.FullDomainName = p2pconsts.AfpTestData.afpDomainName
600                afp_service.TxtRecordMap = p2pconsts.AfpTestData.afp_txtRecord
601                expectServiceList[afp_service.toString()] = 1
602                return expectServiceList
603        ipp_service.InstanceName = p2pconsts.IppTestData.ippInstanceName
604        ipp_service.RegistrationType = (
605            p2pconsts.IppTestData.ippRegistrationType + ".local.")
606        ipp_service.FullDomainName = ""
607        ipp_service.TxtRecordMap = ""
608        expectServiceList[ipp_service.toString()] = 1
609
610        ipp_service.InstanceName = ""
611        ipp_service.RegistrationType = ""
612        ipp_service.FullDomainName = p2pconsts.IppTestData.ippDomainName
613        ipp_service.TxtRecordMap = p2pconsts.IppTestData.ipp_txtRecord
614        expectServiceList[ipp_service.toString()] = 1
615
616        afp_service.InstanceName = p2pconsts.AfpTestData.afpInstanceName
617        afp_service.RegistrationType = (
618            p2pconsts.AfpTestData.afpRegistrationType + ".local.")
619        afp_service.FullDomainName = ""
620        afp_service.TxtRecordMap = ""
621        expectServiceList[afp_service.toString()] = 1
622
623        afp_service.InstanceName = ""
624        afp_service.RegistrationType = ""
625        afp_service.FullDomainName = p2pconsts.AfpTestData.afpDomainName
626        afp_service.TxtRecordMap = p2pconsts.AfpTestData.afp_txtRecord
627        expectServiceList[afp_service.toString()] = 1
628
629        return expectServiceList
630    elif serviceType == WifiP2PEnums.WifiP2pServiceInfo.WIFI_P2P_SERVICE_TYPE_UPNP:
631        upnp_service = "uuid:" + p2pconsts.UpnpTestData.uuid + "::" + (
632            p2pconsts.UpnpTestData.rootdevice)
633        expectServiceList[upnp_service] = 1
634        if queryString1 != "upnp:rootdevice":
635            upnp_service = "uuid:" + p2pconsts.UpnpTestData.uuid + (
636                "::" + p2pconsts.UpnpTestData.AVTransport)
637            expectServiceList[upnp_service] = 1
638            upnp_service = "uuid:" + p2pconsts.UpnpTestData.uuid + (
639                "::" + p2pconsts.UpnpTestData.ConnectionManager)
640            expectServiceList[upnp_service] = 1
641            upnp_service = "uuid:" + p2pconsts.UpnpTestData.uuid + (
642                "::" + p2pconsts.UpnpTestData.serviceType)
643            expectServiceList[upnp_service] = 1
644            upnp_service = "uuid:" + p2pconsts.UpnpTestData.uuid
645            expectServiceList[upnp_service] = 1
646
647    return expectServiceList
648
649
650def p2p_create_group(ad):
651    """Create a group as Group Owner
652
653    Args:
654        ad: The android device
655    """
656    ad.droid.wifiP2pCreateGroup()
657    ad.ed.pop_event(p2pconsts.CREATE_GROUP_SUCCESS_EVENT,
658                    p2pconsts.DEFAULT_TIMEOUT)
659    time.sleep(p2pconsts.DEFAULT_SLEEPTIME)
660
661
662def p2p_create_group_with_config(ad, network_name, passphrase, band):
663    """Create a group as Group Owner
664
665    Args:
666        ad: The android device
667    """
668    wifi_p2p_config = {
669        WifiP2PEnums.WifiP2pConfig.NETWORK_NAME: network_name,
670        WifiP2PEnums.WifiP2pConfig.PASSPHRASE: passphrase,
671        WifiP2PEnums.WifiP2pConfig.GROUP_BAND: band,
672        WifiP2PEnums.WifiP2pConfig.WPSINFO_KEY: {
673            WifiP2PEnums.WpsInfo.WPS_SETUP_KEY:
674            WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_PBC
675        }
676    }
677    ad.droid.wifiP2pCreateGroupWithConfig(wifi_p2p_config)
678    ad.ed.pop_event(p2pconsts.CREATE_GROUP_SUCCESS_EVENT,
679                    p2pconsts.DEFAULT_TIMEOUT)
680    time.sleep(p2pconsts.DEFAULT_SLEEPTIME)
681
682
683def wifi_p2p_set_channels_for_current_group(ad, listening_chan,
684                                            operating_chan):
685    """Sets the listening channel and operating channel of the current group
686       created with initialize.
687
688    Args:
689        ad: The android device
690        listening_chan: Integer, the listening channel
691        operating_chan: Integer, the operating channel
692    """
693    ad.droid.wifiP2pSetChannelsForCurrentGroup(listening_chan, operating_chan)
694    ad.ed.pop_event(p2pconsts.SET_CHANNEL_SUCCESS_EVENT,
695                    p2pconsts.DEFAULT_TIMEOUT)
696
697
698class WifiP2PEnums():
699    class WifiP2pConfig():
700        DEVICEADDRESS_KEY = "deviceAddress"
701        WPSINFO_KEY = "wpsInfo"
702        GO_INTENT_KEY = "groupOwnerIntent"
703        NETID_KEY = "netId"
704        NETWORK_NAME = "networkName"
705        PASSPHRASE = "passphrase"
706        GROUP_BAND = "groupOwnerBand"
707
708    class WpsInfo():
709        WPS_SETUP_KEY = "setup"
710        BSSID_KEY = "BSSID"
711        WPS_PIN_KEY = "pin"
712        #TODO: remove it from wifi_test_utils.py
713        WIFI_WPS_INFO_PBC = 0
714        WIFI_WPS_INFO_DISPLAY = 1
715        WIFI_WPS_INFO_KEYPAD = 2
716        WIFI_WPS_INFO_LABEL = 3
717        WIFI_WPS_INFO_INVALID = 4
718
719    class WifiP2pServiceInfo():
720        #TODO: remove it from wifi_test_utils.py
721        # Macros for wifi p2p.
722        WIFI_P2P_SERVICE_TYPE_ALL = 0
723        WIFI_P2P_SERVICE_TYPE_BONJOUR = 1
724        WIFI_P2P_SERVICE_TYPE_UPNP = 2
725        WIFI_P2P_SERVICE_TYPE_VENDOR_SPECIFIC = 255
726
727    class WifiP2pDnsSdServiceResponse():
728        def __init__(self):
729            pass
730
731        InstanceName = ""
732        RegistrationType = ""
733        FullDomainName = ""
734        TxtRecordMap = {}
735
736        def toString(self):
737            return self.InstanceName + self.RegistrationType + (
738                self.FullDomainName + str(self.TxtRecordMap))
739