Come ottenere una miniatura di SoundCloud utilizzando l'API?

Question

Per esempio:

http://soundcloud.com/mhiqu3/sets/heretik/

Come ottenere l'URL delle miniature: http://i1.sndcdn.com/artworks-000004897289-5r6ws9-large.jpg?1767646

con l'API (o senza)?

Answer 1

È possibile utilizzare l'endpoint /tracks e leggere la proprietà artwork_url dal JSON restituito. Ulteriori dettagli: http://developers.soundcloud.com/docs/api/tracks

Answer 2

Inoltre, se si sostituisce "-large" nella stringa dell'URL con "-t300x300" o "-t500x500" si avrà accesso ai formati più grandi.

Answer 3

So che questo è piuttosto vecchio, ma sono inciampato in questa domanda alla ricerca di qualcos'altro e mi piacerebbe dare i miei due centesimi.

Queste sono tutte le possibili dimensioni (fonte API Reference):

 * t500x500:  500×500 
     * crop:   400×400 
     * t300x300:  300×300 
     * large:  100×100 (default) 
     * t67x67:  67×67 (only on artworks) 
     * badge:  47×47 
     * small:  32×32 
     * tiny:   20×20 (on artworks) 
     * tiny:   18×18 (on avatars) 
     * mini:   16×16 
     * original:  (originally uploaded image) 

Answer 4

ciò che si vuole fare è utilizzare Soundclouds API in questo modo:

SC.get(PATH, function (track, err){ 
    IMG_URL = track.artwork; 
}); 

si può vedere un esempio qui : http://runnable.com/UuiMCfATvMMkAAAS/get-a-tracks-artwork-on-soundcloud-in-javascript#

il percorso per la pista può essere ottenuto in vari modi
1. se si conosce l'ID immagine si può afferrare questo modo
var PATH = "/tracks" + id;
2. se si conosce il nome e l'utente della pista
var PATH = "https://stackoverflow.com/users/dj-faze/tracks/phase-shift-360-019-degrees"
3. È inoltre possibile ottenere l'ID con altre API Soundcloud

NOTA: assicurarsi che l'immagine della traccia che si sta tentando di ottenere sia pubblica. Se è privato, devi accedere con l'API di autorizzazione di soundcloud.

Answer 5

Ho provato a utilizzare this answer ma sfortunatamente SoundCloud non sembra garantire che esistano t500x500, original o altre dimensioni.

Così ho deciso di scrivere un'app express che reindirizzasse alla più grande immagine disponibile sul loro CDN, dato artwork_url.

https://gist.github.com/gaearon/717ed6d6c7771f95d50d

utilizza il loro schema di denominazione ed enumera formati uno per uno fino a qualche immagine restituisce lo stato 200.

Fonte:

'use strict'; 

var express = require('express'), 
    app = express(); 

require('./config/development')(app, express); 
require('./config/production')(app, express); 

var redis = require('redis'), 
    request = require('request'), 
    Promise = require('bluebird'); 

Promise.promisifyAll(redis.RedisClient.prototype); 

var redisSettings = app.set('redis'), 
    redisClient = redis.createClient(redisSettings.port, redisSettings.host, redisSettings.options); 

app.configure(function() { 
    app.use(express.bodyParser()); 
    app.use(app.router); 
}); 

function sendError(res, status, error) { 
    if (!(error instanceof Error)) { 
    error = new Error(JSON.stringify(error)); 
    } 

    return res 
    .status(status || 500) 
    .end(error && error.message || 'Internal Server Error'); 
} 

function generateCacheHeaders() { 
    var maxAge = 3600 * 24 * 365; 

    return { 
    'Cache-Control': 'public,max-age=' + maxAge, 
    'Expires': new Date(Date.now() + (maxAge * 1000)).toUTCString() 
    }; 
} 

function getCacheKey(url) { 
    return 'soundcloud-thumbnail-proxy:' + url; 
} 

app.get('/*', function (req, res) { 
    var originalUrl = req.params[0], 
     cacheKey = getCacheKey(originalUrl), 
     urls; 

    // https://developers.soundcloud.com/docs/api/reference#artwork_url 
    // This is a ridiculous naming scheme, by the way. 

    urls = [ 
    originalUrl, 
    originalUrl.replace('-large', '-t500x500'), 
    originalUrl.replace('-large', '-crop'), // 400x400 
    originalUrl.replace('-large', '-t300x300'), 
    originalUrl.replace('-large', '-large') // 100x100 
    ]; 

    return redisClient.getAsync(cacheKey).then(function (cachedUrl) { 
    if (cachedUrl) { 
     return cachedUrl; 
    } 

    return Promise.reduce(urls, function (resolvedUrl, url) { 
     if (resolvedUrl) { 
     return resolvedUrl; 
     } 

     return new Promise(function (resolve) { 
     request.head(url, function (err, response) { 
      if (!err && response.statusCode === 200) { 
      resolve(url); 
      } else { 
      resolve(null); 
      } 
     }); 
     }); 
    }, null); 
    }).then(function (url) { 
    if (!url) { 
     throw new Error('File not found'); 
    } 

    var headers = generateCacheHeaders(); 
    for (var key in headers) { 
     if (headers.hasOwnProperty(key)) { 
     res.setHeader(key, headers[key]); 
     } 
    } 

    res.redirect(url); 
    redisClient.set(cacheKey, url); 
    redisClient.expire(cacheKey, 60 * 60 * 24 * 30); 

    }).catch(function (err) { 
    sendError(res, 404, err); 
    }); 

}); 

app.get('/crossdomain.xml', function (req, res) { 
    req.setEncoding('utf8'); 
    res.writeHead(200, { 'Content-Type': 'text/xml' }); 
    res.end('<?xml version="1.0" ?><cross-domain-policy><allow-access-from domain="*" /></cross-domain-policy>'); 
}); 

redisClient.on('ready', function() { 
    app.listen(app.set('port')); 
}); 

redisClient.on('error', function() { 
    throw new Error('Could not connect to Redis'); 
}); 

module.exports = app;