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