Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package com.robrua.orianna.api.dto;
   
   import java.util.Collection;
   import java.util.List;
   import java.util.Map;
   
Queries the LoL REST API asynchronously

Author(s):
Rob Rua (FatalElement - NA) (robrua@alumni.cmu.edu)
  
  public class AsyncBaseRiotAPI {
    

Parameters:
action what to do with the challenger league
queueType the queue type to get the challenger league for
See also:
Riot API Specification
  
      public static void getChallenger(final Action<Leagueactionfinal QueueType queueType) {
          new Thread(new Runnable() {
              @Override
              public void run() {
                  if(action == null) {
                      LeagueAPI.getChallenger(queueType);
                  }
                  else {
                      try {
                          action.perform(LeagueAPI.getChallenger(queueType));
                      }
                      catch(final APIException e) {
                          action.handle(e);
                      }
                  }
              }
          }).start();
      }

    

Parameters:
action what to do with the champion
ID the champion's ID
See also:
Riot API Specification
  
      public static void getChampion(final Action<com.robrua.orianna.type.dto.staticdata.Championactionfinal long ID) {
          new Thread(new Runnable() {
              @Override
              public void run() {
                  if(action == null) {
                      StaticDataAPI.getChampion(ID);
                  }
                  else {
                      try {
                          action.perform(StaticDataAPI.getChampion(ID));
                      }
                      catch(final APIException e) {
                          action.handle(e);
                      }
                  }
              }
          }).start();
     }

    

Parameters:
action what to do with the list all of champions
See also:
Riot API Specification
 
     public static void getChampions(final Action<com.robrua.orianna.type.dto.staticdata.ChampionListaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getChampions();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getChampions());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the champion
ID the ID of the champion to look up
See also:
Riot API Specification
 
     public static void getChampionStatus(final Action<com.robrua.orianna.type.dto.champion.Championactionfinal long ID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     ChampionAPI.getChampionStatus(ID);
                 }
                 else {
                     try {
                         action.perform(ChampionAPI.getChampionStatus(ID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with all champions
freeToPlay whether to only return free champions
See also:
Riot API Specification
 
     public static void getChampionStatuses(final Action<com.robrua.orianna.type.dto.champion.ChampionListactionfinal boolean freeToPlay) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     ChampionAPI.getChampionStatuses(freeToPlay);
                 }
                 else {
                     try {
                         action.perform(ChampionAPI.getChampionStatuses(freeToPlay));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's current game
summonerID summoner to look up current game for
See also:
Riot API Specification
 
     public static void getCurrentGame(final Action<CurrentGameInfoactionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     CurrentGameAPI.getCurrentGame(summonerID);
                 }
                 else {
                     try {
                         action.perform(CurrentGameAPI.getCurrentGame(summonerID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the featured games
See also:
Riot API Specification
 
     public static void getFeaturedGames(final Action<FeaturedGamesaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     FeaturedGamesAPI.getFeaturedGames();
                 }
                 else {
                     try {
                         action.perform(FeaturedGamesAPI.getFeaturedGames());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the item
ID the item's ID
See also:
Riot API Specification
 
     public static void getItem(final Action<Itemactionfinal long ID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getItem(ID);
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getItem(ID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the list of all items
See also:
Riot API Specification
 
     public static void getItems(final Action<ItemListaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getItems();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getItems());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the languages
See also:
Riot API Specification
 
     public static void getLanguages(final Action<List<String>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getLanguages();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getLanguages());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the language strings
See also:
Riot API Specification
 
     public static void getLanguageStrings(final Action<LanguageStringsaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getLanguageStrings();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getLanguageStrings());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the map information
See also:
Riot API Specification
 
     public static void getMapInformation(final Action<MapDataaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getMapInformation();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getMapInformation());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the master league
queueType the queue type to get the master league for
See also:
Riot API Specification
 
     public static void getMaster(final Action<Leagueactionfinal QueueType queueType) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     LeagueAPI.getMaster(queueType);
                 }
                 else {
                     try {
                         action.perform(LeagueAPI.getMaster(queueType));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the list of all masteries
See also:
Riot API Specification
 
     public static void getMasteries(final Action<MasteryListaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getMasteries();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getMasteries());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the mastery
ID the mastery's ID
See also:
Riot API Specification
 
     public static void getMastery(final Action<Masteryactionfinal long ID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getMastery(ID);
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getMastery(ID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match
ID the ID of the match to look up
See also:
Riot API Specification
 
     public static void getMatch(final Action<MatchDetailactionfinal long ID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchAPI.getMatch(ID);
                 }
                 else {
                     try {
                         action.perform(MatchAPI.getMatch(ID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches for the summoner
summonerID the ID of the summoner to get match history for
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerID);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches after beginIndex for the summoner
summonerID the ID of the summoner to get match history for
beginIndex the game index to start from
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerIDfinal int beginIndex) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerIDbeginIndex);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerIDbeginIndex));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches after beginIndex for the summoner
summonerID the ID of the summoner to get match history for
beginIndex the game index to start from
championIDs the champions to limit games to
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerIDfinal int beginIndexfinal List<LongchampionIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerIDbeginIndexchampionIDs);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerIDbeginIndexchampionIDs));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches after beginIndex for the summoner
summonerID the ID of the summoner to get match history for
beginIndex the game index to start from
queueType the queue type to limit games to (only ranked queues)
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerIDfinal int beginIndexfinal QueueType queueType) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerIDbeginIndexqueueType);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerIDbeginIndexqueueType));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches after beginIndex for the summoner
summonerID the ID of the summoner to get match history for
beginIndex the game index to start from
queueType the queue type to limit games to (only ranked queues)
championIDs the champions to limit games to
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerIDfinal int beginIndexfinal QueueType queueType,
             final List<LongchampionIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerIDbeginIndexqueueTypechampionIDs);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerIDbeginIndexqueueTypechampionIDs));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches for the summoner
summonerID the ID of the summoner to get match history for
championIDs the champions to limit games to
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerIDfinal List<LongchampionIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerIDchampionIDs);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerIDchampionIDs));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches for the summoner
summonerID the ID of the summoner to get match history for
queueType the queue type to limit games to (only ranked queues)
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerIDfinal QueueType queueType) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerIDqueueType);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerIDqueueType));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the match history for that summoner Gets the 15 most recent matches for the summoner
summonerID the ID of the summoner to get match history for
queueType the queue type to limit games to (only ranked queues)
championIDs the champions to limit games to
See also:
Riot API Specification
 
     public static void getMatchHistory(final Action<PlayerHistoryactionfinal long summonerIDfinal QueueType queueTypefinal List<LongchampionIDs) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     MatchHistoryAPI.getMatchHistory(summonerIDqueueTypechampionIDs);
                 }
                 else {
                     try {
                         action.perform(MatchHistoryAPI.getMatchHistory(summonerIDqueueTypechampionIDs));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the ranked stats for that summoner
summonerID the ID of the summoner to get ranked stats for
See also:
Riot API Specification
 
     public static void getRankedStats(final Action<RankedStatsactionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StatsAPI.getRankedStats(summonerID);
                 }
                 else {
                     try {
                         action.perform(StatsAPI.getRankedStats(summonerID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the ranked stats for that summoner
summonerID the ID of the summoner to get ranked stats for
season the season to get stats for
See also:
Riot API Specification
 
     public static void getRankedStats(final Action<RankedStatsactionfinal long summonerIDfinal Season season) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StatsAPI.getRankedStats(summonerIDseason);
                 }
                 else {
                     try {
                         action.perform(StatsAPI.getRankedStats(summonerIDseason));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the realm
See also:
Riot API Specification
 
     public static void getRealm(final Action<Realmaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getRealm();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getRealm());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the summoner's recent games
summonerID the ID of the summoner to look up recent games for
See also:
Riot API Specification
 
     public static void getRecentGames(final Action<RecentGamesactionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     GameAPI.getRecentGames(summonerID);
                 }
                 else {
                     try {
                         action.perform(GameAPI.getRecentGames(summonerID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the rune
ID the rune's ID
See also:
Riot API Specification
 
     public static void getRune(final Action<Runeactionfinal long ID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getRune(ID);
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getRune(ID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the list of all runes
See also:
Riot API Specification
 
     public static void getRunes(final Action<RuneListaction) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StaticDataAPI.getRunes();
                 }
                 else {
                     try {
                         action.perform(StaticDataAPI.getRunes());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the shard
region the region's shard to get
See also:
Riot API Specification
 
     public static void getShard(final Action<ShardStatusactionfinal Region region) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StatusAPI.getShard(region);
                 }
                 else {
                     try {
                         action.perform(StatusAPI.getShard(region));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the list of all shards
See also:
Riot API Specification
 
     public static void getShards(final Action<List<Shard>> action) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StatusAPI.getShards();
                 }
                 else {
                     try {
                         action.perform(StatusAPI.getShards());
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the stats for that summoner
summonerID the ID of the summoner to get stats for
See also:
Riot API Specification
 
     public static void getStats(final Action<PlayerStatsSummaryListactionfinal long summonerID) {
         new Thread(new Runnable() {
             @Override
             public void run() {
                 if(action == null) {
                     StatsAPI.getStats(summonerID);
                 }
                 else {
                     try {
                         action.perform(StatsAPI.getStats(summonerID));
                     }
                     catch(final APIException e) {
                         action.handle(e);
                     }
                 }
             }
         }).start();
     }

    

Parameters:
action what to do with the stats for that summoner
summonerID the ID of the summoner to get stats for
season the season to get stats for
See also:
Riot API Specification
    public static void getStats(final Action<PlayerStatsSummaryListactionfinal long summonerIDfinal Season season) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    StatsAPI.getStats(summonerIDseason);
                }
                else {
                    try {
                        action.perform(StatsAPI.getStats(summonerIDseason));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' league entries
summonerIDs the summoners to get league entries for
See also:
Riot API Specification
    public static void getSummonerLeagueEntries(final Action<Map<LongList<League>>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    LeagueAPI.getSummonerLeagueEntries(summonerIDs);
                }
                else {
                    try {
                        action.perform(LeagueAPI.getSummonerLeagueEntries(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' league entries
summonerIDs the summoners to get league entries for
See also:
Riot API Specification
    public static void getSummonerLeagueEntries(final Action<Map<LongList<League>>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    LeagueAPI.getSummonerLeagueEntries(summonerIDs);
                }
                else {
                    try {
                        action.perform(LeagueAPI.getSummonerLeagueEntries(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' league
summonerIDs the summoners to get leagues for
See also:
Riot API Specification
    public static void getSummonerLeagues(final Action<Map<LongList<League>>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    LeagueAPI.getSummonerLeagues(summonerIDs);
                }
                else {
                    try {
                        action.perform(LeagueAPI.getSummonerLeagues(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' league
summonerIDs the summoners to get leagues for
See also:
Riot API Specification
    public static void getSummonerLeagues(final Action<Map<LongList<League>>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    LeagueAPI.getSummonerLeagues(summonerIDs);
                }
                else {
                    try {
                        action.perform(LeagueAPI.getSummonerLeagues(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners
summonerIDs the IDs of the summoners to get
See also:
Riot API Specification
    public static void getSummonersByID(final Action<Map<LongSummoner>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersByID(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersByID(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners
summonerIDs the IDs of the summoners to get
See also:
Riot API Specification
    public static void getSummonersByID(final Action<Map<LongSummoner>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersByID(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersByID(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners
summonerNames the names of the summoners to get
See also:
Riot API Specification
    public static void getSummonersByName(final Action<Map<StringSummoner>> actionfinal List<StringsummonerNames) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersByName(summonerNames);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersByName(summonerNames));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners
summonerNames the names of the summoners to get
See also:
Riot API Specification
    public static void getSummonersByName(final Action<Map<StringSummoner>> actionfinal String... summonerNames) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersByName(summonerNames);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersByName(summonerNames));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' masteries
summonerIDs the IDs of the summoners to get masteries for
See also:
Riot API Specification
    public static void getSummonersMasteries(final Action<Map<LongMasteryPages>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersMasteries(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersMasteries(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' masteries
summonerIDs the IDs of the summoners to get masteries for
See also:
Riot API Specification
    public static void getSummonersMasteries(final Action<Map<LongMasteryPages>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersMasteries(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersMasteries(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' names
summonerIDs the IDs of the summoners to get names of
See also:
Riot API Specification
    public static void getSummonersNames(final Action<Map<LongString>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersNames(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersNames(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' names
summonerIDs the IDs of the summoners to get names of
See also:
Riot API Specification
    public static void getSummonersNames(final Action<Map<LongString>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersNames(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersNames(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoner spell
ID the summoner spell's ID
See also:
Riot API Specification
    public static void getSummonerSpell(final Action<SummonerSpellactionfinal long ID) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    StaticDataAPI.getSummonerSpell(ID);
                }
                else {
                    try {
                        action.perform(StaticDataAPI.getSummonerSpell(ID));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the list of all summoner spells
See also:
Riot API Specification
    public static void getSummonerSpells(final Action<SummonerSpellListaction) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    StaticDataAPI.getSummonerSpells();
                }
                else {
                    try {
                        action.perform(StaticDataAPI.getSummonerSpells());
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' runes
summonerIDs the IDs of the summoners to get runes for
See also:
Riot API Specification
    public static void getSummonersRunes(final Action<Map<LongRunePages>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersRunes(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersRunes(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' runes
summonerIDs the IDs of the summoners to get runes for
See also:
Riot API Specification
    public static void getSummonersRunes(final Action<Map<LongRunePages>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    SummonerAPI.getSummonersRunes(summonerIDs);
                }
                else {
                    try {
                        action.perform(SummonerAPI.getSummonersRunes(summonerIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the team's leagues
teamIDs the summoners to get leagues for
See also:
Riot API Specification
    public static void getTeamLeagueEntries(final Action<Map<StringList<League>>> actionfinal List<StringteamIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    LeagueAPI.getTeamLeagueEntries(teamIDs);
                }
                else {
                    try {
                        action.perform(LeagueAPI.getTeamLeagueEntries(teamIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the team's leagues
teamIDs the summoners to get leagues for
See also:
Riot API Specification
    public static void getTeamLeagueEntries(final Action<Map<StringList<League>>> actionfinal String... teamIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(action == null) {
                    LeagueAPI.getTeamLeagueEntries(teamIDs);
                }
                else {
                    try {
                        action.perform(LeagueAPI.getTeamLeagueEntries(teamIDs));
                    }
                    catch(final APIException e) {
                        action.handle(e);
                    }
                }
            }
        }).start();