Retrieve the public tracks of the supported artist.

@return {@link rx.Observable} on an ArrayList of the artist's tracks.
519595
public Observable<ArrayList<SoundCloudTrack>> getArtistTracks() {
        checkState();
        if (mCacheRam.tracks.size() != 0) {
            return Observable.create(new Observable.OnSubscribe<ArrayList<SoundCloudTrack>>() {
                @Override
                public void call(Subscriber<? super ArrayList<SoundCloudTrack>> subscriber) {
                    subscriber.onNext(mCacheRam.tracks);
                    subscriber.onCompleted();
                }
            });
        } else {
            return mRetrofitService.getUserTracks(mArtistName)
                    .map(RxParser.PARSE_USER_TRACKS)
                    .map(cacheTracks());
        }
    }
925517
public static List<Track> nonEmptyTracks(final List<Track> tracks) {
		return tracks.stream()
			.map(track -> track.toBuilder()
				.listMap(Filters::nonEmptySegments)
				.build())
			.filter(Track::nonEmpty)
			.collect(toList());
	}
94521
public function getTopTracks(array $options = [])
    {
        $deferred = new Deferred();

        $options = Options::buildOptions(Options::$defaultOptions, $options, $this->tidal);

        $this->http->get(
            Options::replace(Endpoints::ARTIST_TOP_TRACKS, ['id' => $this->id]).$options
        )->then(function ($response) use ($deferred) {
            $tracks = new Collection();

            foreach ($response['items'] as $track) {
                $tracks->push(new Track(
                    $this->http,
                    $this->tidal,
                    $track
                ));
            }

            $deferred->resolve($tracks);
        }, function ($e) use ($deferred) {
            $deferred->reject($e);
        });

        return $deferred->promise();
    }
151133
def getAlbumsForArtistInCollection(artist,user=nil,extras=nil)
      method = 'getAlbumsForArtistInCollection'
      type = Album
      args = {:artist=>artist}
      args[:user] = user if user
      args[:extras] = extras if extras
      auth = !!user
      return_object type,method,args,auth
    end
1067332
public Observable<Page<ClientDiscoveryValueForSingleApiInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ClientDiscoveryValueForSingleApiInner>>, Page<ClientDiscoveryValueForSingleApiInner>>() {
                @Override
                public Page<ClientDiscoveryValueForSingleApiInner> call(ServiceResponse<Page<ClientDiscoveryValueForSingleApiInner>> response) {
                    return response.body();
                }
            });
    }
1241574
public Track[] getTracks() {
		List<Track> list = getComponentModel().tracks;
		return list == null ? null : list.toArray(new Track[]{});
	}
1324117
public Track getTrack(int trackID) throws MusixMatchException {
		Track track = new Track();
		Map<String, Object> params = new HashMap<String, Object>();

		params.put(Constants.API_KEY, apiKey);
		params.put(Constants.TRACK_ID, new String("" + trackID));

		track = getTrackResponse(Methods.TRACK_GET, params);

		return track;
	}
496234
public Observable<ServiceResponse<List<ImageList>>> getAllImageListsWithServiceResponseAsync() {
        if (this.client.baseUrl() == null) {
            throw new IllegalArgumentException("Parameter this.client.baseUrl() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{baseUrl}", this.client.baseUrl());
        return service.getAllImageLists(this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<ImageList>>>>() {
                @Override
                public Observable<ServiceResponse<List<ImageList>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<ImageList>> clientResponse = getAllImageListsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
999710
def getArtistsInCollection(user=nil,start=nil,count=nil,sort=nil,
                               query=nil,extras=nil)
      method = 'getArtistsInCollection'
      type = Artist
      args = {}
      args[:user] = user if user
      args[:start] = start if start
      args[:count] = count if count
      args[:sort] = sort if sort
      args[:query] = query if query
      args[:extras] = extras if extras
      auth = !!user
      return_object type,method,args,auth
    end
617538
public Observable<Page<LabAccountInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<LabAccountInner>>, Page<LabAccountInner>>() {
                @Override
                public Page<LabAccountInner> call(ServiceResponse<Page<LabAccountInner>> response) {
                    return response.body();
                }
            });
    }
614163
function getPlaylist(options) {
    return new Promise(function (resolve, reject) {

        if (!options.oauth_token) {
            reject(new Error('Error oauth_token is required, but is null'));
        } else {
            var uri = 'https://api.soundcloud.com/me/playlists?format=json&oauth_token=' + options.oauth_token;
            request.getAsync(uri, {timeout: 10000}).spread(function (response, body) {
                try {
                    var tracks = _.map(JSON.parse(body.toString('utf8')), function (track) {
                        return track;
                    });
                    if (DEBUG_MODE_ON) {
                        console.log('getPlaylist successful');
                    }
                    resolve(tracks);
                } catch (e) {
                    if (DEBUG_MODE_ON) {
                        console.log('Error while getPlaylist track: ', e);
                    }
                    reject(e);
                }
            }).catch(function (e) {
                if (DEBUG_MODE_ON) {
                    console.log('Error while getPlaylist track: ' + e);
                }
                reject(e);
            })
        }
    });
}
131873
def getAlbumsForArtist(artist,featuring=nil,extras=nil,start=nil,count=nil)
      method = 'getAlbumsForArtist'
      type = Album
      args = {:artist=>artist}
      args[:featuring] = featuring if featuring
      args[:extras] = extras if extras
      args[:start] = start if start
      args[:count] = count if count
      return_object type,method,args
    end
1292266
public Observable<Page<PublicIPPrefixInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<PublicIPPrefixInner>>, Page<PublicIPPrefixInner>>() {
                @Override
                public Page<PublicIPPrefixInner> call(ServiceResponse<Page<PublicIPPrefixInner>> response) {
                    return response.body();
                }
            });
    }
867697
public Observable<List<Product>> getAllProducts() {
    return Observable.zip(getProducts(0), getProducts(1), getProducts(2), getProducts(3),
        (products0, products1, products2, products3) -> {
          List<Product> productList = new ArrayList<Product>();
          productList.addAll(products0);
          productList.addAll(products1);
          productList.addAll(products2);
          productList.addAll(products3);
          return productList;
        });
  }
740000
def listtracks(continuation_token: nil)
      oauth2_refresh_access_token if oauth2_access_token_expired?

      pb_body = MusicManager::ExportTracksRequest.new
      pb_body.client_id = uploader_id
      pb_body.export_type = MusicManager::ExportTracksRequest::TrackType::ALL
      pb_body.continuation_token = continuation_token unless continuation_token.nil?

      uri = URI('https://music.google.com/music/exportids')

      http = Net::HTTP.new(uri.host, uri.port)
      http.use_ssl = true

      req = Net::HTTP::Post.new(uri.path)
      req.body = pb_body.serialize_to_string
      req['Content-Type'] = 'application/x-google-protobuf'
      req['Authorization'] = oauth2_authentication_header
      req['X-Device-ID'] = uploader_id
      res = http.request(req)

      unless res.is_a? Net::HTTPSuccess
        fail Error, 'listtracks failed: #{res.code}'
      end

      MusicManager::ExportTracksResponse.new.parse_from_string(res.body)
    end
1276908
public Observable<List<Label>> getLabels() {
    return Observable.just(mails).flatMap(new Func1<List<Mail>, Observable<List<Label>>>() {
      @Override public Observable<List<Label>> call(List<Mail> mails) {

        delay();

        Observable error = checkExceptions();
        if (error != null) {
          return error;
        }

        List<Label> labels = new ArrayList<>(4);
        labels.add(INBOX_LABEL);
        labels.add(sentLabel);
        labels.add(spamLabel);
        labels.add(trashLabel);

        int inbox = 0;
        int spam = 0;
        int sent = 0;
        int trash = 0;

        for (Mail m : mails) {

          if (m.isRead()) {
            continue;
          }

          switch (m.getLabel()) {
            case Label.INBOX:
              inbox++;
              break;

            case Label.SENT:
              sent++;
              break;

            case Label.SPAM:
              spam++;
              break;

            case Label.TRASH:
              trash++;
              break;
          }
        }

        INBOX_LABEL.setUnreadCount(inbox);
        sentLabel.setUnreadCount(sent);
        spamLabel.setUnreadCount(spam);
        trashLabel.setUnreadCount(trash);

        return Observable.just(labels);
      }
    });
  }
98104
public Observable<ServiceResponse<UserInner>> getPublishingUserWithServiceResponseAsync() {
        if (this.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.apiVersion() is required and cannot be null.");
        }
        return service.getPublishingUser(this.apiVersion(), this.acceptLanguage(), this.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<UserInner>>>() {
                @Override
                public Observable<ServiceResponse<UserInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<UserInner> clientResponse = getPublishingUserDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }