src/data/sources/steam/Steam.vala

   1 using Gtk;
   2 using Gee;
   3 using GameHub.Utils;
   4
   5 namespace GameHub.Data.Sources.Steam
   6 {
   7         public class Steam: GameSource
   8         {
   9                 private string api_key;
  10
  11                 public override string name { get { return "Steam"; } }
  12                 public override string icon { get { return "steam"; } }
  13                 public override string auth_description { owned get { return ".\n%s".printf(_("Your SteamID will be read from Steam configuration file")); } }
  14
  15                 public string? user_id { get; protected set; }
  16                 public string? user_name { get; protected set; }
  17
  18                 private bool? installed = null;
  19
  20                 public override bool is_installed(bool refresh)
  21                 {
  22                         if(installed != null && !refresh)
  23                         {
  24                                 return (!) installed;
  25                         }
  26
  27                         installed = Utils.is_package_installed("steam");
  28                         return (!) installed;
  29                 }
  30
  31                 public override async bool install()
  32                 {
  33                         Utils.open_uri("appstream://steam.desktop");
  34                         return true;
  35                 }
  36
  37                 public override async bool authenticate()
  38                 {
  39                         Settings.Auth.Steam.get_instance().authenticated = true;
  40
  41                         if(is_authenticated()) return true;
  42
  43                         var result = false;
  44
  45                         new Thread<void*>("steam-loginusers-thread", () => {
  46                                 var config = Parser.parse_vdf_file(FSUtils.Paths.Steam.LoginUsersVDF);
  47                                 var users = Parser.json_object(config, {"users"});
  48
  49                                 if(users == null)
  50                                 {
  51                                         result = false;
  52                                         Idle.add(authenticate.callback);
  53                                         return null;
  54                                 }
  55
  56                                 foreach(var uid in users.get_members())
  57                                 {
  58                                         user_id = uid;
  59                                         user_name = users.get_object_member(uid).get_string_member("PersonaName");
  60
  61                                         result = true;
  62                                         break;
  63                                 }
  64
  65                                 Idle.add(authenticate.callback);
  66                                 return null;
  67                         });
  68
  69                         yield;
  70                         return result;
  71                 }
  72
  73                 public override bool is_authenticated()
  74                 {
  75                         return user_id != null;
  76                 }
  77
  78                 public override bool can_authenticate_automatically()
  79                 {
  80                         return Settings.Auth.Steam.get_instance().authenticated;
  81                 }
  82
  83                 private ArrayList<Game> games = new ArrayList<Game>(Game.is_equal);
  84                 public override async ArrayList<Game> load_games(FutureResult<Game>? game_loaded = null)
  85                 {
  86                         api_key = Settings.Auth.Steam.get_instance().api_key;
  87
  88                         if(!is_authenticated() || games.size > 0)
  89                         {
  90                                 return games;
  91                         }
  92
  93                         games.clear();
  94
  95                         var cached = GamesDB.get_instance().get_games(this);
  96                         if(cached.size > 0)
  97                         {
  98                                 games = cached;
  99                                 if(game_loaded != null)
 100                                 {
 101                                         foreach(var g in cached)
 102                                         {
 103                                                 game_loaded(g);
 104                                         }
 105                                 }
 106                         }
 107                         games_count = games.size;
 108
 109                         var url = @"https://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=$(api_key)&steamid=$(user_id)&format=json&include_appinfo=1&include_played_free_games=1";
 110
 111                         var root = yield Parser.parse_remote_json_file_async(url);
 112                         var json_games = Parser.json_object(root, {"response"}).get_array_member("games");
 113
 114                         foreach(var g in json_games.get_elements())
 115                         {
 116                                 var game = new SteamGame(this, g.get_object());
 117                                 if(!games.contains(game) && yield game.is_for_linux())
 118                                 {
 119                                         games.add(game);
 120                                         if(game_loaded != null) game_loaded(game);
 121                                         GamesDB.get_instance().add_game(game);
 122                                 }
 123                                 games_count = games.size;
 124                         }
 125
 126                         return games;
 127                 }
 128
 129                 public static ArrayList<string>? folders = null;
 130                 public static ArrayList<string> LibraryFolders
 131                 {
 132                         get
 133                         {
 134                                 if(folders != null) return folders;
 135
 136                                 folders = new ArrayList<string>();
 137                                 folders.add(FSUtils.Paths.Steam.SteamApps);
 138
 139                                 var root = Parser.parse_vdf_file(FSUtils.Paths.Steam.LibraryFoldersVDF);
 140                                 var lf = Parser.json_object(root, {"LibraryFolders"});
 141
 142                                 if(lf != null)
 143                                 {
 144                                         foreach(var key in lf.get_members())
 145                                         {
 146                                                 var dir = lf.get_string_member(key) + "/steamapps";
 147                                                 if(FSUtils.file(dir).query_exists()) folders.add(dir);
 148                                         }
 149                                 }
 150
 151                                 return folders;
 152                         }
 153                 }
 154         }
 155 }