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() {
                  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() {
                  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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 try {
                     action.perform(StaticDataAPI.getMapInformation());
                 }
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                 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() {
                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() {
                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() {
                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() {
                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() {
                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() {
                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() {
                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() {
                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() {
                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() {
                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() {
                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 getTeamLeagues(final Action<Map<StringList<League>>> actionfinal List<StringteamIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(LeagueAPI.getTeamLeagues(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 getTeamLeagues(final Action<Map<StringList<League>>> actionfinal String... teamIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(LeagueAPI.getTeamLeagues(teamIDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the teams
IDs the IDs of the teams
See also:
Riot API Specification
    public static void getTeamsByID(final Action<Map<StringTeam>> actionfinal List<StringIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(TeamAPI.getTeamsByID(IDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the teams
IDs the IDs of the teams
See also:
Riot API Specification
    public static void getTeamsByID(final Action<Map<StringTeam>> actionfinal String... IDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(TeamAPI.getTeamsByID(IDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' teams
summonerIDs the IDs of the summoners to get teams for
See also:
Riot API Specification
    public static void getTeamsBySummoner(final Action<Map<LongList<Team>>> actionfinal List<LongsummonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(TeamAPI.getTeamsBySummoner(summonerIDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

Parameters:
action what to do with the summoners' teams
summonerIDs the IDs of the summoners to get teams for
See also:
Riot API Specification
    public static void getTeamsBySummoner(final Action<Map<LongList<Team>>> actionfinal long... summonerIDs) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    action.perform(TeamAPI.getTeamsBySummoner(summonerIDs));
                }
                catch(final APIException e) {
                    action.handle(e);
                }
            }
        }).start();
    }

    

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

    
If turned on, prints the URI of calls made to stdout

Parameters:
on whether to print the URI of calls to stdout
    public static void printCalls(final boolean on) {
        BaseRiotAPI.printCalls(on);
    }

    
Removes any set proxy
    public static void removeProxy() {
        BaseRiotAPI.removeProxy();
    }

    
Sets the API Key to use for queries

Parameters:
newAPIKey the API Key to use for queries
    public static void setAPIKey(final String newAPIKey) {
        BaseRiotAPI.setAPIKey(newAPIKey);
    }

    
Sets the server mirror to hit for queries

Parameters:
newMirror the server mirror to hit for queries
    public static void setMirror(final Region newMirror) {
        BaseRiotAPI.setMirror(newMirror);
    }

    
Sets the proxy to access the API through

Parameters:
IP the IP address of the proxy server
port the working port for the proxy server
    public static void setProxy(final String IPfinal int port) {
        BaseRiotAPI.setProxy(IPport);
    }

    
Sets multiple new rate limits for the API, removing any old ones

Parameters:
limits the rate limits to apply
    public static void setRateLimit(final Collection<RateLimitlimits) {
        BaseRiotAPI.setRateLimit(limits);
    }

    
Sets a new rate limit for the API, removing any old ones

Parameters:
callsPerEpoch the number of calls allowed in each epoch
secondsPerEpoch the number of seconds in each epoch
    public static void setRateLimit(final int callsPerEpochfinal int secondsPerEpoch) {
        BaseRiotAPI.setRateLimit(callsPerEpochsecondsPerEpoch);
    }

    
Sets a new rate limit for the API, removing any old ones

Parameters:
limit the rate limit
    public static void setRateLimit(final RateLimit limit) {
        BaseRiotAPI.setRateLimit(limit);
    }

    
Sets multiple new rate limits for the API, removing any old ones

Parameters:
limits the rate limits to apply
    public static void setRateLimit(final RateLimit... limits) {
        BaseRiotAPI.setRateLimit(limits);
    }

    
Sets the region to get information from the API for

Parameters:
newRegion the region to get information from the API for
    public static void setRegion(final Region newRegion) {
        BaseRiotAPI.setRegion(newRegion);
    }