nmkv.py

from kivy.app import App
from kivy.lang import Builder
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.popup import Popup
from kivy.uix.boxlayout import BoxLayout
from functools import partial
from subprocess import Popen, PIPE, call


Builder.load_string('''
<WifiInterface>:
    orientation: 'vertical'
    padding: '30dp'
    spacing: '20dp'
    GridLayout:
        cols: 3
        padding: 20
        spacing: 20
        size_hint: 1,.3
        Button:
            text: "Show devices"
            on_release: root.show_devices_status()
        Button:
            text: "Disconnect wifi Network"
            on_release: root.disconnect_wifi()
        TextInput:
            id: password
            write_tab: False
            hint_text: "Password to Connect Encrypted NetWork"
            disabled: True
    
    BoxLayout:
        id: label_connections
        size_hint: 1, 0.4
        orientation: 'vertical'
        Label:
            size_hint_x: 1
            size_hint_y: 0.5
            valign: 'middle'
            height: '35dp'
            text: 'clic Button Show device to show Active connection'
        
    Label:
        id: label_wifi_actif
        size_hint: (1,0.2)
        size_hint_y: None
        height: sp(10)
        text: 'Wifi enabled: ' + str(root.is_enabled())

    BoxLayout:
        orientation: 'horizontal'
        size_hint_y: 0.3
        Button:
            id: wifi_button
            size_hint_y: None
            height: sp(35)
            text: 'Enable Wifi / Start Scanning'
            on_release: root.start_wifi()

        Button:
            id: stop_wifi_button
            size_hint_y: None
            height: sp(35)
            disabled: True
            text: 'Disable Wifi'
            on_release: root.stop_wifi()

    BoxLayout:
        id: scan_layout
        orientation: 'vertical'
        Label:
            size_hint_x: 1
            size_hint_y: None
            valign: 'middle'
            height: '35dp'
            text: 'Scan Results'
''')





class WifiInterface(BoxLayout):

    param = {}
    names = {}

    
    
    @property
    def interfaces(self):
        '''
        Get all the available interfaces for WiFi.

        .. versionadded:: 1.4.0
           Tested with nmcli 1.2.6.
        '''
        if not self._is_enabled():
            self._enable()

        # fetch the devices
        proc = Popen([
            'nmcli', '--terse',
            '--fields', 'DEVICE,TYPE',
            'device'
        ], stdout=PIPE)
        lines = proc.communicate()[0].decode('utf-8').splitlines()

        # filter devices by type
        interfaces = []
        for line in lines:
            # bad escape from nmcli's side :<
            line = line.replace('\\:', '$$')
            device, dtype = line.split(':')
            if dtype != 'wifi':
                continue
            interfaces.append(device.replace('$$', ':'))

        # return wifi interfaces
        return interfaces

    @property
    def device_status(self):
        output = Popen(['nmcli', '--terse', '--fields','DEVICE,TYPE,STATE,CONNECTION','device', 'status'],
                       stdout=PIPE)
        lines = output.communicate()[0].decode('utf-8').splitlines()
        connections = []
        for line in lines:
            # bad escape from nmcli's side :<
            line = line.replace('\\:', '$$')
            device, dtype, state, connection  = line.split(':')
            ligne_connections = ( device, dtype, state, connection) # a tuple
            connections.append(ligne_connections) # remplit la liste avec chaque tuple
        return connections

    def show_devices_status(self):
        connections = self.device_status
        stack_connections = self.ids['label_connections']
        stack_connections.clear_widgets()
        content = ""
        for objet in connections:

            boxl = BoxLayout(orientation='vertical')
            label_connection = Button(
                text=str(objet),
                size_hint=(1, 1),
                height='10dp',
                halign= 'left'
            )
            button_detail = Button(
                text="Detail",
                height= '10dp',
                size_hint_x=  0.2,
                #on_release=self.detail()
            )

            boxl.add_widget(label_connection)
            #boxl.add_widget(button_detail)
            stack_connections.add_widget(boxl)

    def _start_scanning(self, interface=None):
        '''
        Start scanning for available Wi-Fi networks
        for the specified interface.

        .. versionadded:: 1.4.0
           Tested with nmcli 1.2.6.
        '''
        if not self._is_enabled():
            self.enable_wifi()
        if not interface:
            interface = self.interfaces[0]

        # force rescan for fresh data
        call(['nmcli', 'device', 'wifi', 'rescan', 'ifname', interface])

        # get properties
        fields = [
            'IN-USE','SSID', 'BSSID', 'MODE', 'CHAN', 'FREQ',
            'BARS', 'RATE', 'SIGNAL', 'SECURITY'
        ]

        # fetch all networks for interface
        output = Popen([
            'nmcli', '--terse',
            '--fields', ','.join(fields),
            'device', 'wifi', 'list', 'ifname', interface
        ], stdout=PIPE).communicate()[0].decode('utf-8')

        # parse output
        for line in output.splitlines():
            line = line.replace('\\:', '$$')
            row = {
                field: value
                for field, value in zip(fields, line.split(':'))
            }

            row['BSSID'] = row['BSSID'].replace('$$', ':')
            self.names[row['SSID']] = row

    def _get_network_info(self, name):
        '''
        Get all the network information by network's name (SSID).

        .. versionadded:: 1.4.0
           Tested with nmcli 1.2.6.
        '''
        if not self.names:
            self._start_scanning()

        ret_list = {}
        ret_list['ssid'] = self.names[name]['SSID']
        connected = self.names[name]['IN-USE']
        if connected == '*' :
            ret_list['connected'] = 'Connected'
        else:
            ret_list['connected'] = 'No'
            
        ret_list['signal'] = self.names[name]['SIGNAL']
        bars = len(self.names[name]['BARS'])
        ret_list['quality'] = '{}/100'.format(bars / 5.0 * 100)
        ret_list['frequency'] = self.names[name]['FREQ']
        ret_list['bitrates'] = self.names[name]['RATE']

        # wpa1, wpa2, wpa1 wpa2, wep, (none), perhaps something else
        security = self.names[name]['SECURITY'].lower()
        ret_list['encrypted'] = True
        if 'wpa2' and 'wpa1' in security:
            # wpa2, wpa2+wpa1
            ret_list['encryption_type'] = 'wpa2-wpa1'
        elif 'wpa1' and not 'wpa2' in security:
            ret_list['encryption_type'] = 'wpa1'
        elif 'wpa' in security:
            ret_list['encryption_type'] = 'wpa'
        elif 'wep' in security:
            ret_list['encryption_type'] = 'wep'
        elif 'none' in security:
            ret_list['encrypted'] = False
            ret_list['encryption_type'] = 'none'
        else:
            ret_list['encryption_type'] = security

        ret_list['channel'] = int(self.names[name]['CHAN'])
        ret_list['address'] = self.names[name]['BSSID']
        ret_list['mode'] = self.names[name]['MODE']

        return ret_list

    def _get_available_wifi(self):
        '''
        Return the names of all found networks.

        .. versionadded:: 1.4.0
           Tested with nmcli 1.2.6.
        '''
        if not self.names:
            self._start_scanning()
        return list(self.names.keys())

    def _create_popup(self, title, content):
        return Popup(
            title=title,
            content=Label(text=content),
            size_hint=(.8, 1),
            auto_dismiss=True
        )

    def start_wifi(self):
        wifi_button = self.ids['wifi_button']
        wifi_button.text = 'Showing Scan Results'
        wifi_button.on_release = self.show_wifi_scans
        self.start_scanning()
        stop_wifi_button = self.ids['stop_wifi_button']
        stop_wifi_button.disabled = False
        text_inpt = self.ids['password']
        text_inpt.disabled = False
        self.ids.label_wifi_actif.text = 'Wifi Enable ' + str(self.is_enabled())
        self.show_devices_status()


    def stop_wifi(self):
        stop_wifi_button = self.ids['stop_wifi_button']
        stop_wifi_button.disabled = True

        wifi_button = self.ids['wifi_button']
        wifi_button.text = 'Enable Wifi'
        wifi_button.on_release = self.start_wifi

        self.disable_wifi()
        self.ids.label_wifi_actif.text = 'Wifi Enable ' + str(self.is_enabled())
        self.ids['scan_layout'].clear_widgets()
        text_inpt = self.ids['password']
        text_inpt.disabled = False
        self.show_devices_status()

    def start_scanning(self):
        self._start_scanning()

    def clear_wifi_scans(self):
        stack = self.ids['scan_layout']
        stack.clear_widgets()

    def show_wifi_scans(self):
        stack = self.ids['scan_layout']
        stack.clear_widgets()
        wifi_scans = self.names.keys()
        for name in wifi_scans:
            content = ""
            items = self._get_network_info(name)
            if self.names[name]['IN-USE'] == '*' :
                bouton_connect = 'connected'
            else:
                bouton_connect = 'Connect'
            for key, value in items.items():
                content += "{}:    {} \n".format(key, value)

            password = self._getpassword(name)
            if password != '':
                content += 'password : ' + password

            popup = self._create_popup(name, content)
            boxl = BoxLayout(orientation='horizontal')
            button_ssid = Button(
                text=name,
                size_hint=(1, 1),
                height='40dp',
                on_release=popup.open,
            )
            button_connect = Button(
                text= bouton_connect,
                size_hint_x=.2,
                on_release=partial(self.connect, name))

            boxl.add_widget(button_ssid)
            boxl.add_widget(button_connect)
            stack.add_widget(boxl)

    def is_enabled(self):
        return self._is_enabled()

    def _is_enabled(self):
        '''
        Return the status of WiFi device.

        .. versionadded:: 1.4.0
           Tested with nmcli 1.2.6.
        '''
        output = Popen(
            ["nmcli", "radio", "wifi"],
            stdout=PIPE
        ).communicate()[0].decode('utf-8')

        if output.split()[0] == 'enabled':
            return True
        return False

    def enable_wifi(self):
        '''
        Turn WiFi device on.
        '''
        call(['nmcli', 'radio', 'wifi', 'on'])

    def disable_wifi(self):
        '''
        Turn WiFi device off.
        '''
        call(['nmcli', 'radio', 'wifi', 'off'])


    def _disconnect_wifi(self, interface=None):
        '''
        Disconnect all the networks managed by Network manager.

        .. versionadded:: 1.2.5
        '''
        if not interface:
            interface = self.interfaces[0]

        call(['nmcli', 'dev', 'disconnect', interface])

    def disconnect_wifi(self):
        self._disconnect_wifi()
        self.show_devices_status()
        self.clear_wifi_scans()


    def connect(self, network_name, instance):
        self.param['password'] = self.ids['password'].text
        self._connect(network_name, self.param)
        self.show_devices_status()
        self.clear_wifi_scans()


    def _connect(self, network, parameters, interface=None):
        '''
        Connect a specific interface to a WiFi network.

        Expects 2 parameters:
            - SSID of the network
            - parameters: dict
                - password: string or None
        '''
        self.enable_wifi()
        if not interface:
            interface = self.interfaces[0]

        password = self._getpassword(network)
        if password == '':
            password = parameters.get('password')
        command = [
            'nmcli', 'device', 'wifi', 'connect', network,
            'ifname', interface
        ]
        if password:
            command += ['password', password]
        call(command)

    def _getpassword(self,name_wifi):
        '''
        nmcli - -show - secrets - t connection show 'name of wifi network'
        '''
        #command = [ 'nmcli', '--show-secrets', '--terse', 'connection', 'show', name_wifi]
        output = Popen([ 'nmcli', '--show-secrets', '--terse', 'connection', 'show', name_wifi],
                       stdout=PIPE).communicate()[0].decode('utf-8')

        # parse output
        for line in output.splitlines():
            if '802-11-wireless-security.psk:' in line:
                security, password = line.split(':')
                return password
        return ''

    # je ne sais plus d'où cette fonction vient ( à supprimer)
    def connect_2_a_tester(self, network, parameters, interface=None):
        '''
        Expects 2 parameters:
            - name/ssid of the network.
            - parameters: dict type
                - password: string or None

        .. versionadded:: 1.2.5
        '''
        if not interface:
            interface = self.interfaces[0]

        result = None
        try:
            self.enable_wifi()
        finally:
            password = parameters['password']
            cell = self.names[network]
            result = self.Scheme.for_cell(
                interface, network, cell, password
            )
        return result

class WifiApp(App):

    def build(self):
        return WifiInterface()

    def on_pause(self):
        return True


if __name__ == "__main__":
    WifiApp().run()