Git Product home page Git Product logo

stremio-addon-sdk's Introduction

Stremio Addon SDK ๐Ÿง™

Stremio

The ๐Ÿง™ Stremio Addon SDK ๐Ÿง™ was developed by the Stremio Team as a way of vastly simplifying Node.js addon creation for our streaming platform.

Stremio currently supports Windows, macOS, Linux, Android and iOS.

Important: We strongly recommend deploying addons to the BeamUp servers

Quick Example

This arbitrary example creates an addon that provides a stream for Big Buck Bunny and outputs a HTTP address where you can access it.

const { addonBuilder, serveHTTP, publishToCentral }  = require('stremio-addon-sdk')

const builder = new addonBuilder({
    id: 'org.myexampleaddon',
    version: '1.0.0',

    name: 'simple example',

    // Properties that determine when Stremio picks this addon
    // this means your addon will be used for streams of the type movie
    catalogs: [],
    resources: ['stream'],
    types: ['movie'],
    idPrefixes: ['tt']
})

// takes function(args)
builder.defineStreamHandler(function(args) {
    if (args.type === 'movie' && args.id === 'tt1254207') {
        // serve one stream to big buck bunny
        const stream = { url: 'http://distribution.bbb3d.renderfarming.net/video/mp4/bbb_sunflower_1080p_30fps_normal.mp4' }
        return Promise.resolve({ streams: [stream] })
    } else {
        // otherwise return no streams
        return Promise.resolve({ streams: [] })
    }
})

serveHTTP(builder.getInterface(), { port: process.env.PORT || 7000 })
//publishToCentral("https://your-domain/manifest.json") // <- invoke this if you want to publish your addon and it's accessible publically on "your-domain"

Save this as addon.js and run:

npm install stremio-addon-sdk
node ./addon.js

It will output a URL that you can use to install the addon in Stremio

Please note: addon URLs in Stremio must be loaded with HTTPS (except 127.0.0.1) and must support CORS! CORS support is handled automatically by the SDK, but if you're trying to load your addon remotely (not from 127.0.0.1), you need to support HTTPS.

Getting started with a new addon

In order to scaffold a new Stremio addon, we've made a tool called addon-bootstrap.

You can use it in the following way:

npm install -g stremio-addon-sdk # use sudo if on Linux
addon-bootstrap hello-world

You'll be asked about what resources and types you want to support, after which the addon will be created in the hello-world directory, and you'll be able to run it:

cd hello-world
npm install
npm start -- --launch

If you wish to install the addon in the Desktop version of Stremio (which you can download here), you should use npm start -- --install

Documentation

All our documentation is right here on GitHub. Take a look at our examples list for some high-level information, or dive straight into our SDK documentation for our code reference docs.

We also have an example addon that you can use as a guide to help you build your own addon.

We've made two step by step guides: one for this SDK, and one for any programming language, which you can read here.

If you don't wish to use Node.js (and therefore not use this SDK either), you can create addons in any programming language, see the addon protocol specification for more information.

It is also possible to create an addon without any programming language, see our static addon example based on the protocol specification.

SDK Features Include:

Testing

For developers looking for a quick way to test their new addons, you can either:

Deploying

In order for your addon to be used by others, it needs to be deployed online.

You can check our list of recommended hosting providers for Node.js or alternatively host it locally with localtunnel.

After you've deployed publically, in order to get your addon to show in Stremio (through the public Addon collection), you need to use publishToCentral or publish manually through the UI.

Examples & tutorials

Check out our ever growing list of examples and demo addons. This list also includes examples & tutorials on how to develop Stremio addons in PHP, Python, Ruby, C#, Rust, Java and Go. It also includes a list of video tutorials.

Rust version

There is a third-party Rust version of this SDK built on stremio-core developed by Sleeyax here.

Go version

There is a third-party Go version of this SDK developed by doingodswork here.

Advanced Usage

Read our guide for advanced usage to understand the many ways that addons can be used.

Reporting Issues

If you have any issues regarding the Stremio Addon SDK, please feel free to report them here.

Migration from v0.x

To migrate from v0.x, you need to:

  • change new addonSDK to new addonBuilder, which you can import via const addonBuilder = require('stremio-addon-sdk').addonBuilder
  • change addon.run(opts) to serveHTTP(addon.getInterface(), opts), which you can import via const serveHTTP = require('stremio-addon-sdk').serveHTTP
  • all handlers have to return a Promise (rather than take a cb)

Use Cases Outside Addon SDK

The use of this SDK is not mandatory for creating Stremio Addons. You can use any programming language that supports creating a HTTP server to make Stremio Addons. Refer to our protocol specification for details and examples.

One useful scenario of not using the SDK is when you need user specific data for you addon (for example, an API Autherntication Token), you can see an example of passing user specific data in the Addon URL here. This example uses Node.js and Express to get user specific data. (Update: the Addon SDK now supports user settings)

built with love and serious coding skills by the Stremio Team

stremio-addon-sdk's People

Contributors

ayplow avatar core1024 avatar dependabot[bot] avatar dexter21767 avatar doingodswork avatar ivshti avatar jaruba avatar mhdzumair avatar nklhtv avatar paulogdm avatar shteryana avatar sleeyax avatar trtomasz avatar tymmesyde avatar vmotta8 avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

stremio-addon-sdk's Issues

Docs: step-by-step "getting started" guide

We need to create a step-by-step "getting started" guide, similar to:

https://reactjs.org/docs/getting-started.html
https://reactjs.org/docs/hello-world.html
https://www.gatsbyjs.org/docs/
https://reasonml.github.io/docs/en/what-and-why
https://doc.rust-lang.org/book/getting-started.html
https://www.ethereum.org/greeter
https://dev.twitch.tv/
https://support.plex.tv/articles/categories/channel-plugins/channel-development/

(shitcoins, but nice dev portals)
https://developers.tron.network/
https://developers.eos.io/

Overall goals:

  • a separate, flashy page that begins with 2-3 commands that you can copy/paste into your terminal and immediately see results (step 1/2)
  • hosting/deploying guides that work and are easy: serverless by default, possibly even with a simple CLI command (nowsh/lambda/cloudflare workers #42, #36)
  • when you change something on the add-on, it's immediately reflected in stremio (this requires solving #38)

Full content proposal:

  1. Intro/Getting started - includes "What is Stremio", "Requirements" (basic programming knowledge, etc.) and links to the video tutorial(s)
  2. First steps/"Hello World Addon" - installing the SDK/CLI (#36), bootstrapping a Hello World addon and starting it in Stremio (need to be fixed: #38, #39), explaining resources (catalogs/streams) with links to the full per-resource docs (#4, #1); bootstrapper & addons.js pattern
  3. Adding catalogs (/catalog/), catalogs with filters: #40
  4. Adding streams (/stream/): by URL, external and BitTorrent; adding subtitles in the streams; also add an "Under the hood" section linking to https://github.com/Stremio/stremio-players/blob/master/html5-with-middlewares.md and the docs of https://github.com/Stremio/stremio/issues/524
  5. Custom metadata (/meta/)
  6. Integrating an external service by calling into an API (@jaruba any idea which API? Plex for example uses blip.tv)
  7. Deploying (hosting) your addon (nowsh, serverless #42, add IPFS in the future)
  8. Examples: https://github.com/Stremio/stremio-addon-sdk/blob/master/docs/examples/Readme.md ; some of those should illustrate the Advanced cases
  9. Advanced
    1. building crawler add-ons (scrapy-like stuff?)
    2. user-specific behavior #15
    3. search: #9
    4. subtitles
    5. reading from a DB
    6. presenting your addon better with descriptionHTML: #11 (e.g. "this is dangerous" or "click here to install the full addon", in case of user-specific addons)
    7. composability by proxying other addons #10
    8. using cinemeta

Each page should link to the relevant documentation/specification (e.g. resources, resource responses)

Ideally, those would be generated from GitHub repos and markdown, via jsdoc or another docs generator (docusaurus, gatsby, esdoc, readme.io etc). Also, something that generates a nice page from MD files (e.g. gatsby) is a different tool from the one that documents JS code (jsdoc/esdoc)

this seems like a great option: https://www.gitbook.com/
docusaurus seems more appropriate since it's self hosted and it converts docs from MD

here's the current step by step thing: https://github.com/Stremio/addon-helloworld


Alternative tutorial paths

We should have different versions of the tutorial (alternative steps 2-6 & 7):

  • NodeJS + SDK: this is the default
  • NodeJS + express
  • Python
  • Go
  • Rust

in step 1, we should link to an alternative part of steps 2-6 for each options

for step 7 (deploying), only replicating the addon will be relevant when you're not using the SDK, so we need two alternative deploy pages: with the SDK and without the SDK

also, in step 1, explain why we recommend using the SDK: "We recommend using the SDK, since it helps you validate and publish your addon"

Help center

There should be a specific help center (e.g. support email, or forum) where people can ask questions if they have issues; this help center should be linked from everywhere (guides, videos, etc.)

CLI/API: replicator

stremio-addon-sdk offer the following command:

replicate: can be used to replicate to a directory or to IPFS, or to fuzz/lint the addon
deploy: deploys to nowsh/lambda, tests if the addon is available (by running basic detectFromURL and checking a few resource paths), publishes to stremio central

the replicator being built in is fantastic, since replicating an addon is a combo of fuzzing, linting and replicating
validate/replicate can use the same code (the replicator), but configured differently
see Stremio/labs#14 ; see also CLI bootstrap issue - #36


also, we can expose it as an API

  • getScraper: getScraper(AddonImpl) => { emitter, enqueue }; can be used for publishing to IPFS AND advanced validation
  • underneath, it can work equally well with AddonClient and AddonInterface
  • inputs (most opened in stremio, cinemeta), outputs (redis, ipfs, directory)

Spec: addonSettings (http transport)

be able to specify manifest.addonSettings as an array of {name, description, type, headerName, isRequired}

That would allow every add-on to have add-on specific settings, that will be passed to it as HTTP headers in the case of the http transport (it will be supported only on the http transport)

Use cases:

  • Add-ons with authentication - e.g. put.io
  • Add-ons that require specific user preferences (e.g. "HD only")

Kind of related to: #15 - this is an implementation example of a similar thing, although the preferences are in the URL; it will be easy to extend this example to this spec

Subtitles Handler not being called?

Hi,

I am trying to create a subtitle add-on, but I am having trouble getting the call to the defined handler. I've followed the documentation and tried starting from code generated by the the addon-bootstrap, which generated the following code:

const { addonBuilder } = require("stremio-addon-sdk")

// Docs: https://github.com/Stremio/stremio-addon-sdk/blob/master/docs/api/responses/manifest.md
const manifest = {
	"id": "community.TestCoolAddon",
	"version": "0.0.1",
	"catalogs": [],
	"resources": [
		"subtitles"
	],
	"types": [
		"movie",
		"series"
	],
	"name": "Test-Cool-Addon",
	"description": "A nice first addon.",
	"idPrefixes": [
		"tt"
	]
}
const builder = new addonBuilder(manifest)

builder.defineSubtitlesHandler(({type, id}) => {
	console.log("request for subtitles: "+type+" "+id)
	// Docs: https://github.com/Stremio/stremio-addon-sdk/blob/master/docs/api/requests/defineSubtitlesHandler.md
	return Promise.resolve({ subtitles: [] })
})

module.exports = builder.getInterface()

The add-on loads without issues, but the handler defined for the subtitles is not called (I've tried the 'stream' handler, and it was called). Am I missing something?

I looked around for examples featuring subtitles, but I couldn't find any (aside from the documentation), so I'm kind of lost on this matter.

dev UX: caching, manifest updating

currently, once an addon is installed, the manifest is not auto refreshed

the dev UX of this is horrible, since they have to manually reinstall the addon to see changes
HTTP caching makes things worse, as even after reinstalling it might still be the same

we need an option like ?addonURL=...&forceRefresh or ?addonURLRefresh=... but also the equivalent of that with stremio://

this is a pretty big issue that we need to solve in time for the second addon competition

manifest.behaviorHints checker

while auto-scraping the addon (for the various publish) methods, check if any hints should be added to the manifest

e.g. if the streams serve https:// links, suggest webReady

if the streams serve magnet: links, suggest needsP2P

publishToWeb

Hello,

I use Heroku as a server and when I do

addon.publishToWeb('MONURL/manifest.json')

I get an error:

2019-01-07T12:16:54.790114+00:00 app[web.1]: addon.publishToWeb('MONURL/manifest.json')
2019-01-07T12:16:54.790116+00:00 app[web.1]: ^
2019-01-07T12:16:54.790118+00:00 app[web.1]:
2019-01-07T12:16:54.790120+00:00 app[web.1]: TypeError: addon.publishToWeb is not a function

Please help me.

docs: encourage addons.js pattern

encourage addon devs to make an addons.js file which exports the result of new addonSDK(manifest)

that way, serverless and different usages can be easily done

the way to encourage that pattern would be if we have a bootstrapper, which is also a must

Spec: Multiple Filters / Flexible Meta Details (advanced extra notation)

Proposing changes:

manifest {
    catalogs: [
        {
            filters: [
                {
                    name: 'genre',
                    values: [...]
                }, {
                    name: 'platform',
                    values: [...]
                }, {
                    name: 'year',
                    values: [...]
                }
            ],
            extraSupported: [ 'skip', 'genre', 'platform', 'year' ]
        }
     ]
}

We use select boxes for the filters on the Discovery Page instead of one vertical list.

meta {
    details: {
        year: 1997,
        genre: ['Action', 'Shooter'],
        platform: ['PC', 'Mac'],
        description: 'something'
    }
}

We generate the Detail Page based on meta.details.

If a meta.details property is also in extraSupported of the current catalogue, we link it back to the Discovery Page with the filter set.

dev UX: detect local stremio, open addon there

detect a local stremio installation and prompt the user to launch the add-on in there

that could be achieved by merely detecting the location of the stremio executable (which is consistent across platforms) and launching it

however it needs this fixed first: see #38

Spec: Manifest: better control over what is supported or what isn't

Currently, we have in the manifest: resources, types, idPrefixes and catalogs.

This is kind of limiting, because: for meta and stream resources, we always assume all listed types and all idPrefixes

We might want to create a scenario where we match /meta/{series,movie} but only /stream/series for example. Or taking this further, only /stream/*/tt* or /meta/*/local:*

The question is, how to define this spec for the manifest

One of the added difficulties is that this issue does not exist for catalogs, since we pre-define explicitly the combinations of types and ids that we support upon defining catalogs

Another question is do we want to allow different idPrefixes for different types within a resource, or we just want to allow specific { types, idPrefixes } for a resource. The latter seems more reasonable.

Monetization Options for Add-on Devs

Concept:

Two new optional parameters in the manifest:

  • donationUrl allowing add-on devs to set a URL for a donation page

  • ethAddress allowing add-on devs to set a ETH address, for a donation (or funding) DAO

Donation links should be shown at the end of playback of a video (or a playlist of videos), with a message (example: "Consider donating to the developer of this Add-on")

Subtitle not group by lang

Group subtitle by lang not work or I do something wrong.

I try to pass array of object with url and lang like this
const subsArr = [{url: url1, lang:'lang1'}, {url: url2, lang:'lang1'}]
to Promise.resolve({subtitles: subsArr }) but only one lang loaded.
Also I try to use underscore and group by _.groupBy(array, 'lang') like opensubtitle do but than nothing loaded. Is there any sample code about this ?

Open metadata at specific season/episode

An ability to open resource metadata at at specific season/episode. Currently it expects a season 1 to be present and defaults to it.
The use case (mostly for anime) would be to have catalog entries for specific seasons (currently airing season, trending based on season), and when opened you could point to a specific video entry from where to start.
I know it's just a good to have feature and maybe would only pollute the model, but I think it would be worth considering it.

Spec: consider deprecating resource shorthand

related to #14
instead of all allowing the old syntax (resources: ["something"]), always require that a resource is defined as an object

It also incorporates the types directly in it, so it doesn't really make stuff harder

it's more consistent with a data-driven approach and it will be easier to parse in statically typed languages

New API (builder), and more convenient publishing API

right now there are a few methods to publish the addon (runHTTPWithOptions, getServerlessHandler, etc.) so it gets messy

also the builder would allow you to define stuff without having to touch the manifest yourself

so it would be something like

addon.withBaseInfo({ ..base manifest... })
.defineCatalog({ type: 'movie', id: 'top' }, handler)
.defineStreams({  type: 'movie', idPrefixes: [] })

Spec: should Stream object be simplified

Only to url and shouldOpenExternal

url should begin with ytdl:// for yt, with magnet: for bittorrent, ipfs: for ipfs, and the rest is pretty easy

To make tihs work, we have to implement it in the stremio-addon-client legacy shim, and all v3 protocol add-ons delivering streams (are there any? UPDATE: yes, openbtindex)
and obviously all the clients (which will be the tough part)

Provide an alternative id for resource

It would be great to have ability to provide alternative id for resources to target multiple addons, which support different id schemes.
Current use case is for anime addons, where we could provide a anime specific id and target anime specific addons, but also provide and imdbId based id and target the usual imdbId based addons.

Publish to the new API

This is the function sig:

addonPublish { transportUrl, transportName } -> { success: 1 }

And it's described better in stremio-api README.md and in the stremio-api tests

validation of the returned results

when returning Stream or Metadata, validate those objects; this can happen using the new stremio-models and an isValid function

e.g., like in the old SDK

stremio-addons warning: stream object does not contain any stremable property

Meta Handler not being called ?

Hi, i am tryng create a addon following the docs, but the defineMetaHandler is never called.

const addon = {
    id: 'org.stremio.list',
    name: 'stremio demo',
    version: '1.0.0',
    description: 'create demos',
    resources: ['meta', 'stream', 'catalog'],
    types: ['channel'],
    catalogs: [
        {
            type: 'channel',
            id: 'yt-'
        },
    ],
    idPrefixes: ['yt-']
}
const dataset = {
    // Some examples of streams we can serve back to Stremio ; see https://github.com/Stremio/stremio-addon-sdk/blob/master/docs/api/responses/stream.md
    "dev-0051asd744": { name: "asdaweqw asd", type: "channel", infoHash: "9f86563ce2ed86bbsdfdfedd5d3e9f4e55aedd660960" }, // torrent
    "dev-news123": { name: "Big Buck Bunny", type: "channel", url: "http://clips.vorwaerts-gmbh.de/big_buck_bunny.mp4" }, // HTTP stream
    "dev-003asd1051": { name: "The Arizone Kid", type: "channel", ytId: "m3BKVSpP80s" }, // YouTube stream
    "dev-news": { name: "Fight Club", type: "channel", externalUrl: "https://www.netflix.com/watch/26004747" }, // redirects to Netflix
    "17481asd66:1:1": { name: "Pioneer One", type: "channel", infoHash: "07a9de9750158471c3302e4e95edb1107f980fa6" }, // torrent for season 1, episode 1
};

const METAHUB_URL = "https://images.metahub.space"

const generateMetaPreview = function(value, key) {
    // To provide basic meta for our movies for the catalog
    // we'll fetch the poster from Stremio's MetaHub
    // see https://github.com/Stremio/stremio-addon-sdk/blob/master/docs/api/responses/meta.md#meta-preview-object
    
    const imdbId = key.split(":")[0]
    
    return {
        id: imdbId,
        type: value.type,
        name: value.name,
        logo: METAHUB_URL+"/poster/medium/"+imdbId+"/img",
        poster: "https://raw.githubusercontent.com/tuliocll/supermariojs/master/preview.png",
        description: "igdbPlatforms || igdbMeta.summary || null",
        year: "igdbYear",
        background: "https://raw.githubusercontent.com/tuliocll/supermariojs/master/preview.png",
        genres: "igdbGenres" || null
    }
}

builder.defineCatalogHandler(function(args, cb) {
    // filter the dataset object and only take the requested type
    const metas = Object.entries(dataset)
        .filter(([_, value]) => value.type === args.type)
        .map(([key, value]) => generateMetaPreview(value, key))
    return Promise.resolve({ metas: metas })
})



builder.defineStreamHandler(function(args) {
    if (dataset[args.id]) {
        return Promise.resolve({ streams: [dataset[args.id]] });
    } else {
        return Promise.resolve({ streams: [] });
    }
})

builder.defineMetaHandler(({type, id}) => {
	console.log("request for meta: "+type+" "+id)
	// Docs: https://github.com/Stremio/stremio-addon-sdk/blob/master/docs/api/requests/defineMetaHandler.md
	return Promise.resolve({ metas: null })
})

module.exports = builder.getInterface()

const addonInterface = require("./index");
serveHTTP(addonInterface, { port: 7000 });

I am doing some wrong? thanks

Publish function, internal crawler+linter

The default .publish() (or possibly another name?) function should crawl all know resources and validate them using the https://github.com/stremio/stremio-addon-linter

This is a procedure that should also happen in development mode so that the developer can ensure the validity of their add-on while they develop

The algorithm is as follows:

  1. Checks the validity of the manifest
  2. For all catalogs in the manifest, gets the catalog and validates them
  3. For all the content in the catalogs, gets the meta and validates that
  4. For all the videos in the returned meta, gets the streams and validates that

we should think of how to proceed if the add-on provides streams only - one option is to take steps 2 and 3 from Cinemeta

It's very powerful that we can crawl and validate the add-ons in such a deterministic way, since that allows:

  • publishing/exporting to a directory, so that the add-on can be published on a static file server
  • constant validation/linting
  • publishing to IPFS/IPNS

Spec: {catalog/manifest}.behaviorHints

catalogs in the manifest (and possibly other things) should have this property called behaviorHints, which allows to tell the app how it prefers to be visualized or how it should behave

the most obvious example: if it's adult content, have adult set to true; the app will visualize it as adult, meaning it will hide it before some additional step is done

if we want it to appear only on discover or on board, have a flag for that

furthermore, this can be used for very special stuff, for example a different visualization of meta items that is used in specific cases: e.g. recommendations

it could also be used to tweak how things are handled; for example, if you return stuff with video with a stream from your search results, you might want to have a flag that commands stremio to go straight to the player, skipping the detail page

Provide an HTTP header for a stream

Is it possible to provide an http header for a stream, so that when accessing the stream the header would be attached to the request? Some of the streams require a header Referer to be attached in order to be able to access the stream.

Question: Stream Object doc

Hello !
I wanted to know how to display more information about a stream (quality for example) rather than placing it in the title like on the Zooqle add-on.
screenshot_70
It seems that the tag array doesn't show anything on the stream.

Docs: protocol: how URLs are formed

The URL that we'll access the add-on at is always derived from the URL to the manifest - this needs to be well described in the protocol documentation

e.g. if you load the add-on from https://example.com/manifest.json, resources will be looked for at https://example.com, for example https://example.com/catalog/series/top.json

Spec: Rename "genre" to a more general term, like "category"

this requires renaming in a few places:

  • properties in the MetaItem
  • extraRequired/extraSupported values
  • manifest values under a catalog

unfortunately this migth require changes in a lot of places and we still need to keep the old genre for compatibility...

so this might be difficult to pull off, unless we find somewhere to start from

remove published addon

Hi
while testing I published an addon to the community.
As I now need to move server and fix a couple of bugs, is there a way to remove the addon from the list?
I turned it off, but it still appears in the list
thanks

Spec: update property names, make them reasonable & consistent

we have the chance to change the special movie/series-related properties since the only place they're returned from is cinemeta and in all clients using the new add-on protocol use v3-cinemeta

so we have to change them in v3-cinemeta

And document them in the spec here

Finalization: after all the docs are done, go through the guides and verify everything works (including new `extra`)

stuff in the guide that we need to check

  • going through the guide and following it step by step leads to a smooth, frictionless experience

stuff in the app that we need to check

CLI: bootstrapper

stremio-addon-sdk new should bootstrap a new addon

other commands:

  • validate: checks if the addon is behaving correctly by requesting the manifest and a few simple resources
  • replicate: can be used to replicate to a directory or to IPFS, or to fuzz/lint the addon
  • deploy: deploys to nowsh/lambda, tests if the addon is available (by running basic detectFromURL and checking a few resource paths), publishes to stremio central

the replicator being built in is fantastic, since replicating an addon is a combo of fuzzing, linting and replicating
validate/replicate can use the same code (the replicator), but configured differently
see https://github.com/Stremio/labs/issues/14

The CLI should be usable both in stremio addon projects (in the directory), and for addons that are not using the SDK (e.g. implemented in Go)

Docs: Tutorial: how to make a metadata add-on with search

how to make a simple add-on with metadata (catalog, meta resources) with a search capability

The difficulty here is that it has to explain you need to supply the catalog resource but with extraRequired equal to ['search'], like in the following manifest: http://v3-cinemeta.strem.io/manifest.json

Or alternatively with extraSupported if the catalog also supplies popularity-sorted content

extraRequired may also be used for country-specific catalogs (e.g. extraRequired: ['countryCode'])

Can an addon written with addon-sdk manipulate video color etc?

I would like to write an add-on for Stremio that makes anaglyph and/or stereoscopic experience on Stremio videos possible.

I plan to do this by

  • duplicating video shown on same Stremio window one usually watch on Stremio and put them separated by an offset adjustable
  • colorize videos differently, eg. left video red, right video cyan (ideally adjustable color)
  • maybe tilt each of them around y-axis of the screen (ideally adjustable angle for each video)

Is that capability available to addon sdk?

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.