Questão Armazenando Preferências e Dados do Aplicativo


Eu estou olhando para criar alguns aplicativos do Ubuntu, mas encontrar bons recursos são difíceis.

Eu estou usando o kit de ferramentas rapidamente, mas gostaria muito mais de uma visão. Como se costuma armazenar as preferências e configurações do aplicativo no Linux / Ubuntu?

É tão simples quanto criar um arquivo XML e salvar as informações e, em seguida, ler o arquivo no bootstrap do aplicativo?

Se alguém puder me apontar em uma direção, seria muito apreciado.

EDITAR

Isso é algo que escrevi enquanto esperava por uma resposta. Provavelmente exatamente o que as preferências fazem, mas apenas codificadas. Você pode achar útil:

import ConfigParser, os # We need to be able to store and recal settings

#first try to read the config.cfg file
config = ConfigParser.RawConfigParser()
configFile = 'data/config.cfg'

# We need to set some defaults
monState = False
tueState = False
wedState = False
thurState = False
friState = False
satState = False
sunState = False

# Creating the Config file
def createConfigFile(fileName):
    print "CREATING CONFIG" # not needed, but nice for debugging
    config.add_section('Preferences')
    config.set('Preferences', 'mon', False)
    config.set('Preferences', 'tues', False)
    config.set('Preferences', 'wed', False)
    config.set('Preferences', 'thur', False)
    config.set('Preferences', 'fri', False)
    config.set('Preferences', 'sat', False)
    config.set('Preferences', 'sun', False)
    rewriteConfigFile(filename)

# After reading the config file, we can update configs in memory. 
# But this will save it to file for when the application is started up again. 
def rewriteConfigFile(filename):    
    with open(filename, 'wb') as configfile:
        config.write(configfile)

# Reading the config file 
def readConfigFile(fileName):
    print "READING CONFIG"  # not needed, but nice for debugging
    global monState, tueState, wedState, thurState, friState, satState, sunState
    monState = config.getboolean('Preferences', 'mon')
    tueState = config.getboolean('Preferences', 'tues')
    wedState = config.getboolean('Preferences', 'wed')
    thurState = config.getboolean('Preferences', 'thur')
    friState = config.getboolean('Preferences', 'fri')
    satState = config.getboolean('Preferences', 'sat')
    sunState = config.getboolean('Preferences', 'sun')

# If the config does not exist, create it, then read it. Otherwise simply read it
if not config.read(configFile):    
    createConfigFile(configFile)
    readConfigFile(configFile)    
else:
    readConfigFile(configFile)

4
2017-11-07 10:24


origem


Dê uma olhada nessas perguntas: askubuntu.com/questions/59822/…  askubuntu.com/questions/4420/… - mivoligo


Respostas:


Os aplicativos rapidamente usam os esquemas simplificados para as preferências do aplicativo. Um esquema padrão é criado em data/glib-2.0/schemas. É um arquivo xml chamado net.launchpad.XXXX.gschema.xml onde XXXX é o nome do seu aplicativo.

Aqui está um exemplo de entrada:

<?xml version="1.0" encoding="UTF-8"?>
<schemalist gettext-domain="drawers">
  <schema id="net.launchpad.drawers" path="/net/launchpad/drawers/">
    <key name="maxicons-row" type="i">
      <range min="1" max="15"/>
      <default>5</default>
      <summary>Maximum Icons per Row</summary>
      <description>Minimum value = 1 Max=15</description>
    </key>
  </schema>
</schemalist>

As chaves podem ser inteiros (type = "i"), boolean (type = "b") ou floats (type = "d"). Use apenas letras minúsculas e - em nomes-chave.

Para acessar as configurações e vinculá-las aos widgets, você pode obtê-las da seguinte maneira (obtidas a partir do PreferencesXXXXWindow.py gerado rapidamente):

def finish_initializing(self, builder):# pylint: disable=E1002
    """Set up the preferences dialog"""
    super(PreferencesDrawersDialog, self).finish_initializing(builder)

    # Bind each preference widget to gsettings
    self.settings = Gio.Settings("net.launchpad.drawers")
    widget = self.builder.get_object('maxicons_row')
    self.settings.bind("maxicons-row", widget, "value", Gio.SettingsBindFlags.DEFAULT)

Para ler valores para variáveis ​​dentro de um programa, você pode fazer o seguinte:

from gi.repository import Gio
settings = Gio.Settings("net.launchpad.drawers")
integer=settings.get_int("intsetting")
float = settings.get_double("floatsetting")
bool = settings.get_boolean("booleansetting")

Espero que ajude.


2
2017-11-08 19:17



Obrigado Ian, que é definitivamente mais elegante, então a minha solução que acabei com. - Rudi Strydom


Se você está armazenando dados do usuário, você normalmente os salva em $ HOME / .config / $ YOURAPP / (embora o usuário possa mudar isso, então é melhor usar xdg.BaseDirectory.xdg_config_home).

Se você está usando Python, eu recomendo o ConfigParser biblioteca que facilita a leitura e gravação de dados de arquivos de configuração estruturados.


2
2017-11-08 14:48





Eu não tenho muita experiência de trabalho com o Linux. Mas o problema semelhante que enfrentei enquanto trabalhava no meu aplicativo.

No linux, todo aplicativo gera um arquivo que inclui todas as configurações. Se o seu próprio aplicativo Linux, você pode facilmente procurar o arquivo na pasta "/ etc /".

Por favor, forneça um exemplo de nome de aplicativo para mais detalhes.

Espero que isso possa ajudá-lo a encontrar o seu caminho.


0
2017-11-07 10:44



/ etc / é para configurações de todo o sistema, não configurações do usuário. - mhall119