Note about a Vala bug when chaining constructors which affects us

Make BackendStore.load_backends() async

It does I/O, so should be async so that it doesn't block. Consequently, it's
no longer guaranteed that all backends/personas/individuals are loaded by the
time IndividualAggegator's constructor returns.

Have each Individual use the presence message for one of its most-online personas rather than the first message found.

Cut idea for unncessary signal.

Merge remote branch 'pwith/fixes'

gcc warning fixes in tp-lowlevel.[ch]

Ensure the individual is removed if all its persona list property is emptied

This was already the case when existing personas were removed from the
individual due to their source going away. This commit fixes it for when the
persona list property is changed directly.

Use a persona's UID as an individual's alias if no personas have an alias

Make Individual.get_presence_message() return an unowned string

This prevents a completely unnecessary string copy.

Remove system m4 macros from the m4 directory

Add them to a .gitignore file instead.

Add some comments to the code

Relocate folks_tp_lowlevel_connection_open_contact_list_channel_finish() next to its _async() function

Use a hash table for tracking new incoming TpfPersonas and only add them if they're new.

Clean up Telepathy PersonaStore removal and addition. This fixes a regression where a Telepathy persona store wouldn't emit 'removed' even if its account were disabled

Use consistent naming and signatures for the Tpf.Persona property-notification-passing helper functions.

Generalize overly-specific 'using' statement

Trivial clean-up.

Support avatars (generally, and for the Telepathy backend)

Fix the location of libfolks-telepathy in its -uninstalled pkgconfig file.

Bump the version number for the major changes of the last few commits.

Add .deps files for the public libraries.

Rename the folks-telepathy files, since they're in a different namespace than the folks-backend-telepathy files

Add proper namespaces to the Telepathy backend and support libraries

Rename liblowlevel to libtp-lowlevel for clarity

Split the telepathy backend into a support library and a thin backend
wrapper (so applications can use the support library without linking against the
backend)

Factor out the Telepathy backend into a separate, loadable module.

Add tp-glib Vala bindings dependency to the .pc file and add a -uninstalled.pc file

Support writing contact group changes back to Telepathy accounts.

Don't try to process accounts which are currently being disconnected.

Set a proper internal ID for TpPersonas and throw an error if its basis TpContact has an invalid UID.

Add group notification/read support for Telepathy personas

Avoid extraneous property notifications.

Cut out debugging default value.

Forward along TpPersona presence changes through their parent Individual.

Cut outdated comment.

Support account deletion

Cut outdated comments

Actually add the presence source.

Update for the more accurate signature for Tp.Account.status_changed.

Add stub Presence interface.

Add a stub for the Capabilities interface.

Fix the way we prepare Telepathy accounts and connections (including automatically handling ones that were already open)

Update for symbol changes in the latest tp-glib bindings.

Split PersonaStore into an abstract class and the TpPersonaStore derived class.

Rename from libtelepathy-people to libfolks.

Strip off the extraneous 'tpp-' prefix to the lowlevel files.

Organize classes in the following sections in order:

  * private (enum, class, signal, plain data, property)
  * public (interface members, signal, properties), one block per interface
  * public (enum, signal, plain data, property)
  * constructor
  * constructor's dependent functions, in order of reference
  * destructor
  * destructor's dependent functions
  * public functions, followed by their dependent functions in order of ref

Additional style changes.

  * use 'var' instead of an explicit type whenever possible. It's still
    type-safe yet reduces these types of redundancy (which would be common):

        Foo foo = new Foo ();
        Foo<Bar>[] foo_bar_array = new Foo<Bar>[size];

        ------------------->

        var foo = new Foo ();
        var foo_bar_array = new Foo<Bar>[size];

  * declare variables as closely to their first use as possible. This is to make
    all the relevant code as tight as possible, to minimize scrolling of all
    types. Exceptions include: class data members, blocks of code where there
    would be more than two variable definitions in a row; in this case, add a
    blank line between the last definition and the next line of code (to avoid
    making the code unreadably-dense); Eg, do this:

    {
      var manager = AccountManager.dup ();
      unowned GLib.List<Account> accounts = manager.get_valid_accounts ();
      this.stores = new HashMap<string, PersonaStore> ();

      foreach (Account account in accounts)
        {
          var store = new PersonaStore (account);
          this.stores.set (account.get_object_path (account), store);
        }
      ...
    }

Switch the Vala source to Telepathy style, with minor clarifications:

  * properties that use the default get() and set() functions should be on a
    single line. Eg,

        public string alias { get; set; default = "(No one of consequence)"; }

  * custom one-line get() and set() functions should be on a single line. Eg,

        get { return this._personas; }

  * lambda blocks should be formatted as if they were regular blocks (with the {
    indented once on the next line, another indent for the block content,
    outdent once for the ending }). Any arguments following the lambda
    definition in a function call should be continued on the next line (this
    hasn't come up yet). Eg,

        this._personas.foreach ((persona) =>
          {
            Persona p = (Persona) persona;

            if (alias == null)
              {
                alias = p.alias;
              }
          });

Change the namespace of the telepathy-people code to Tpp, to avoid ambiguity with telepathy-glib and its Vala bindings.

Create Individuals from new Personas and notify of their creation.

Change the personas_added type to a GLib.List from an array. This way we can consistently use GLists in the C API (since they're more conventional).

Add the Alias interface

Reduce the noise of our debug output.

Signal the addition of personas to the persona store.

Create the abstract class Tp.Persona and the Tp.TpPersona wrapper of TpContacts

Retrieve the TpContacts for the discovered contact handles

Make a trivial comment change

Use debug statements instead of standard output for the various debug output

Wait until the contact list channel is ready to connect other signal handlers and get the initial set of handles

Make the build less noisy

Cut some junk code and handle some error conditions

Add a comment about the brokenness of Tp.Handle

Mark telepathy-people.vapi as generated (and thus a target for 'make clean')

Fetch the handles for the 'subscribe' contact list channel

Create a utility class to bind low-level tp-glib code without really exposing it

Create persona stores for the valid accounts and prep them

Begin filling in the classes as intended; Fetch the valid accounts and prep them

Begin building up the library, mainly in terms of build work.

Initial commit for the telepathy-people library