Severity: Notice
Message: Trying to get property 'plaintext' of non-object
Filename: models/Crawler_model.php
Line Number: 228
Backtrace:
File: /var/www/html/KOL/voice/application/models/Crawler_model.php
Line: 228
Function: _error_handler
File: /var/www/html/KOL/voice/application/controllers/Pages.php
Line: 336
Function: get_dev_google_article
File: /var/www/html/KOL/voice/public/index.php
Line: 319
Function: require_once
Severity: Notice
Message: Trying to get property 'plaintext' of non-object
Filename: models/Crawler_model.php
Line Number: 229
Backtrace:
File: /var/www/html/KOL/voice/application/models/Crawler_model.php
Line: 229
Function: _error_handler
File: /var/www/html/KOL/voice/application/controllers/Pages.php
Line: 336
Function: get_dev_google_article
File: /var/www/html/KOL/voice/public/index.php
Line: 319
Function: require_once
Search
#在孩子長大的路上_爸媽的愛是孩子最好的禮物。不過，有時因種種因素，爸媽選擇了結束彼此的婚姻關係，孩子又該如何理解與面對這種情況呢？
我們都曾耳聞，有多少父母離異、單親，又或是身處同志家庭的孩子，在成長路上面對了多少來自外在的惡意。而面對惡意，我們需要的不是硬碰硬的「兩敗俱傷」，而是勇敢正視惡意，看見它的存在↘↘↘https://bit.ly/3DaacxA
🐳《不會改變的清單》引導孩子學習換位思考、培養同理心，同時勇敢正視自己內心的負面情緒，學會用更有智慧的方式，來面對環境或他人的不友善
🔖博客來：https://bit.ly/3m1XSJM
🔖誠品：https://bit.ly/3xNMpQ5
🔖MOMO：https://bit.ly/2Xp0FT8
#當婚姻不再_別讓大人世界影響了孩子
老公的父母親離婚時，婆婆一個人獨自撫養兩個年幼又好動的兒子。這看起來會是個很苦情的故事，但婆婆卻用「愛」與「智慧」把後面的劇本寫得圓滿。
婆婆沒有將自己跟前夫的恩怨帶到孩子的教養中，她堅決地告訴自己：#要教孩子敬愛父親；孩子不只需要母親，也需要與父親的關係。
在孩子成年之前，她從來 #不在孩子面前抱怨或指責孩子的父親，因為她知道：教孩子如何去原諒去愛，#父母必須先做好榜樣.........↘↘
📌推薦好讀>> 《 #不會改變的清單》讓孩子知道，父母的愛不會因任何形式的不同而改變。👉https://bit.ly/37UZQ6m
－－
🍒教養路上不孤單！快將<未來Family>加入"搶先看" ➡ 讓我們和您一起在教養路上並肩作戰 https://bit.ly/2VVPlxv
#長大就是慢慢知道 #在這個世界上
#惡意與不友善不會消失 #但愛也是
.
在孩子長大的路上，爸媽的愛是孩子最好的禮物。不過，有時因種種因素，爸媽選擇了結束彼此的婚姻關係，孩子又該如何理解與面對這種情況呢？又或者，在這個離婚率不低的年代，當孩子問起爸媽「什麼是離婚？」、「為什麼ＯＯ的爸爸媽媽沒有住在一起？」這些問題時，我們可以如何讓孩子知道背後的原委呢？不妨，讓孩子看小說，也陪孩子讀讀小說，一邊來理解與認識。
.
這次要與大家分享的《#不會改變的清單》，正是一本以父母離婚為主軸，同時安排了同志婚姻（多元家庭）議題作為支線的青少年小說。
.
爸媽離婚對孩子的衝擊不容小覷。在這本小說裡，主角在爸媽的安排下，規律地與一位親切的心理師碰面，讓孩子安心整理、表達自己內心的感覺（爸媽，做得好呀！）。在故事裡也提到了許多我們在臨床上會與個案分享的工具，像是：先想兩步、五分鐘的解決辦法、憂慮時間法等；這部分的劇情，也是大人、小孩認識諮商過程很好的素材。
.
乍看之下，這是一本關於父母離異、涉及多元家庭議題的兒童青少年小說。但細心閱讀後，我更發現，其實這是一本引導孩子認識社會中必然存在的「不友善與惡意」，並且慢慢陪伴讀者長出同理心的故事。
.
在這個世界上，惡意從來不會消失。我們都曾耳聞，有多少父母離異、單親，又或是身處同志家庭的孩子，在成長路上面對了多少來自外在的惡意。這些惡意如此傷人，但在小說作者巧妙的安排下，主角才慢慢理解到，其實許多惡意，正是源自「人與人的差異」、來自「我們對於這些差異的不了解」。
.
而更多時候，我們也可能是心存惡意的人，和別人並沒有不同。
.
透過這部小說，不管是大讀者或是小讀者，我們終將知道：面對惡意，我們需要的不是硬碰硬的「兩敗俱傷」，而是勇敢正視惡意，看見它的存在。並試著去看見這些不友善的底層，其實是恐懼、擔心與害怕這些情緒混搭而成的。而展現惡意其實就只是一種未經思考的反射動作而已。
.
惡意不會立刻不見（不管源於他人身上、或是自己內心裡的惡意），但我們可以學會用不同的方式面對它、理解它出現的原因，並以更溫柔、更有智慧的方式來回應它。
.
《不會改變的清單》是一個適合用來引導孩子學習換位思考、培養同理心的好故事，同時勇敢正視自己內心的負面情緒，學會用更有智慧的方式，來面對環境或他人的不友善。十分推薦爸媽與孩子一起來共讀～
.
--
.
👑心理師想跟你說8月推薦小說《不會改變的清單》👑
這邊讀起來 👉 https://reurl.cc/KAg8nj
.
🟧作者簡介
.
雷貝嘉．史德（Rebecca Stead）為美國紐伯瑞文學獎金獎得主，和書中主角碧雅有許多雷同處，她們都生長在紐約，童年經歷父母離婚。在雙親的家裡，不一樣的兩張床上，雷貝嘉從小養成了對閱讀的愛好，精確的說，她愛上了小說。長大後，她成為一名律師，因為擔心作家夢不切實際（但仍持續撰寫給成人看的故事）。某天，進行中的故事稿子被三歲兒子不慎銷毀，於是開啟她為兒童寫作的契機⋯⋯
.
🟧故事簡介
.
碧雅的爸媽決定離婚，在唯一的家庭會議上，爸爸告訴她自己是同性戀。爸媽給了她一本筆記本，裡面羅列了一份清單，上面都是不會改變的事物。從此，碧雅輪流住爸媽家，而她擁有的愛未曾減少。
.
爸即將和新男友傑西結婚，這意味著碧雅將和傑西的女兒桑妮亞成為姊妹，碧雅開心極了，因為她這輩子夢寐以求的就是擁有一個姊妹。
.
愈來愈接近爸爸們的大喜之日了，碧雅與身邊的人感受著悲傷、喜悅、驚愕、憤怒的情緒，他們將攜手前行，一同探索愛的模樣以及家人的定義。
剛好在身邊的朋友與粉絲團都見到不少相同的問題後
今天臨時拍了這支影片來跟各位分享我對於這項"抽獎新道具"的看法
至於你認為這是一個好的機制嗎？歡迎在下方留言告訴我
抽獎活動進行中！
意外得知朋友打到漆黑眼罩😏就拿來偷渡星力啦
https://www.youtube.com/watch?v=5HLXRxmyIl4
☝留言就抽『18星力卷軸』
合作聯繫請來信：leolincontact@gmail.com
★原聯絡信箱 zty5695005@gmail.com 仍會持續管理,合作過的廠商亦可來信於此★
或聯繫Whatsapp：+886912431759
(影片剪輯／手遊.PC介紹試玩／置入遊戲畫面／介紹影片）
🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡
里歐的頻道會員開啟囉！
點擊加入👉https://www.youtube.com/channel/UCLlE4endO2rIcWqUqc76xDA/join
之後的抽獎也會新增『專屬會員』的獎項🎁
不過請放心！原有獎項一樣不會少
不管是不是會員里歐一樣都相當重視相當愛的
⭐會員專屬抽獎活動⭐第三波to be continued
點擊加入👉https://www.youtube.com/channel/UCLlE4endO2rIcWqUqc76xDA/join
🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡
影片系列清單在這↓↓↓
黃金蘋果系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8iZ5tXJ95cb2zKaMSeFjhKl
皇家美髮系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8j1yhFEYOwnRpS8kqHeWCNx
時尚隨機箱系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8iMhTMPgOK12YYC3ndEBTul
方塊系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8hNKl-TPrT7Xa_ej1FmHaFQ
其他抽獎系列(滅龍.星火.潘朵拉等...)
https://www.youtube.com/playlist?list=PLKE0QdIUsM8iWFuCwYNP8d9HBiPBr9Hki
頻道淺談(youtube第一份收入等...)
https://www.youtube.com/playlist?list=PLKE0QdIUsM8hHxYlOQ7Pcb2iklPZQDGb-
灌籃高手SLAMDUNK
https://www.youtube.com/playlist?list=PLKE0QdIUsM8i7JK-m3DehOT5uvFm1qihI
一拳超人系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8i_zZnpVzsMHh_k5STFyUvN
🎉里歐的LINE官方帳號正式成立了🎉
👉點這加入https://lin.ee/ueAs8T0
我的Instagram開始經營囉！
主要會是以我個人的生活照以及限時為主
https://www.instagram.com/leolin_0122
我的FB臉書粉絲團 趕緊搜尋【Leo里歐】
https://fb.me/Leotv.youtube
贊助連結～給里歐再一抽的機會！有餘力再贊助就可以囉！
歐付寶會員編號2216296
https://payment.opay.tw/Broadcaster/Donate/87B91CDF04FC222763C0CF9CDD2CEFDA
________________________________________________________________________________________
Paypal贊助連結
https://PayPal.Me/youtubeLeoTV
只要贊助１００元或以上，記得粉專私訊你/妳的賴ID
我會親自把你加入我的非洲專屬LINE群內唷~
☆其他贊助管道也可透過粉專私訊我唷★
#新道具解析
#漆黑飾品碎片
#黃金蘋果
#新楓之谷
#Leo里歐
#메이플스토리
#Maplestory
#TMS
#楓之谷M#MapleStoryM #手遊
這應該是一部奇怪的影片
也希望遊戲變得更好🧡
(片頭好像失蹤了 下支影片就會回來了
預告一下這兩天要來偷渡朋友打到的漆黑裝！
影片不是希望大家不花錢或是不玩遊戲
任何玩遊戲的方式 想法等等
都是以自己為主 沒有人有資格也沒有干涉他人的權利
遊戲開心最重要！
上支影片抽獎活動進行中
黃金蘋果來襲！目標直指『黑翼胸章』🔥 結果怎麼都是葫蘆？！
https://www.youtube.com/watch?v=JCdGNuddTkU
趕緊訂閱！按讚！分享！ 就抽「MX-131」
合作聯繫請來信：leolincontact@gmail.com
★原聯絡信箱 zty5695005@gmail.com 仍會持續管理,合作過的廠商亦可來信於此★
或聯繫Whatsapp：+886912431759
(影片剪輯／手遊.PC介紹試玩／置入遊戲畫面／介紹影片）
🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡
里歐的頻道會員開啟囉！
點擊加入👉https://www.youtube.com/channel/UCLlE4endO2rIcWqUqc76xDA/join
之後的抽獎也會新增『專屬會員』的獎項🎁
不過請放心！原有獎項一樣不會少
不管是不是會員里歐一樣都相當重視相當愛的
⭐會員專屬抽獎活動⭐第三波to be continued
點擊加入👉https://www.youtube.com/channel/UCLlE4endO2rIcWqUqc76xDA/join
🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡
影片系列清單在這↓↓↓
黃金蘋果系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8iZ5tXJ95cb2zKaMSeFjhKl
皇家美髮系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8j1yhFEYOwnRpS8kqHeWCNx
時尚隨機箱系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8iMhTMPgOK12YYC3ndEBTul
方塊系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8hNKl-TPrT7Xa_ej1FmHaFQ
其他抽獎系列(滅龍.星火.潘朵拉等...)
https://www.youtube.com/playlist?list=PLKE0QdIUsM8iWFuCwYNP8d9HBiPBr9Hki
頻道淺談(youtube第一份收入等...)
https://www.youtube.com/playlist?list=PLKE0QdIUsM8hHxYlOQ7Pcb2iklPZQDGb-
灌籃高手SLAMDUNK
https://www.youtube.com/playlist?list=PLKE0QdIUsM8i7JK-m3DehOT5uvFm1qihI
一拳超人系列
https://www.youtube.com/playlist?list=PLKE0QdIUsM8i_zZnpVzsMHh_k5STFyUvN
🎉里歐的LINE官方帳號正式成立了🎉
👉點這加入https://lin.ee/ueAs8T0
我的Instagram開始經營囉！
主要會是以我個人的生活照以及限時為主
https://www.instagram.com/leolin_0122
我的FB臉書粉絲團 趕緊搜尋【Leo里歐】
https://fb.me/Leotv.youtube
贊助連結～給里歐再一抽的機會！有餘力再贊助就可以囉！
歐付寶會員編號2216296
https://payment.opay.tw/Broadcaster/Donate/87B91CDF04FC222763C0CF9CDD2CEFDA
________________________________________________________________________________________
Paypal贊助連結
https://PayPal.Me/youtubeLeoTV
只要贊助１００元或以上，記得粉專私訊你/妳的賴ID
我會親自把你加入我的非洲專屬LINE群內唷~
☆其他贊助管道也可透過粉專私訊我唷★
#不課金的一天
#日常閒聊
#新楓之谷
#Leo里歐
#메이플스토리
#Maplestory
#TMS
#楓之谷M#MapleStoryM #手遊
🙆 𝐚𝐧𝐧𝐚 𝐩𝐚𝐝有機布衛生棉：https://lihi1.com/0w9Fk
♻️我不是專業的環保人士，而是正在慢慢改變生活，一點一滴想要變得環保的人
♻️改變需要時間，若你覺得我不夠環保，可以留言建議提醒
🔔理性的好建議，我們都會慢慢吸收、改變。
📣 𝐈𝐧𝐬𝐭𝐚𝐠𝐫𝐚𝐦：𝐭𝐚𝐢𝐩𝐞𝐢_𝐬𝐞𝐫𝐞𝐧𝐚𝐝𝐞 ▶ 來玩：）
📣 𝐅𝐚𝐜𝐞𝐛𝐨𝐨𝐤：ㄢㄢ小日常 𝐀𝐧𝐧 𝐢𝐧 𝐓𝐚𝐢𝐩𝐞𝐢 ☻
其實一開始我對布衛生棉是很懷疑的！
畢竟，我們都不愛黏黏稠稠臭臭的經血＞＜＂
當然會想要包在衛生棉裡面趕快丟掉
怎麼會想要活回古代人一樣，用『布衛生棉』呢？
可是因為這個好奇心，我嘗試了布衛生棉。
我手邊的數量還不夠撐整個經期，
所以目前是代替經期中的第二天或第三天。
我使用的這個品牌，很多人都在用，
我是覺得很不錯，大家可以自己多多比較選擇！
我只能說～我會繼續補足其他天數的布衛生棉數量！
因為它解決了我一個很大的問題。
其實也不是很難理解，
平常月經沒來的時候，
我們就是穿著棉質內褲的，
所以如果用這種棉布製成的衛生棉，
代替塑膠衛生棉，
那以前塑膠把皮膚摩擦疼痛的問題就立刻沒了！
這就是為什麼我轉而接受+喜歡布衛生棉的原因！
然後第二個問題是臭臭的經血。
用布衛生棉的話，因為不會把私密處悶住，
所以雖然還是會有經血的氣味，但是不會有那種很噁心的悶臭！
（悶臭就是如果五個小時都沒換塑膠衛生棉，就會有的氣味）
我現在平常都有用它的小尺寸布護墊，
最大的好處是，可以保護貴貴的內褲，
內褲不會黃掉之外，又不用塑膠護墊悶住私密處。
而清洗的時候其實也就跟洗內褲一樣，沒什麼差別，
只有經期來的時候，清洗會比較麻煩一點。
我才剛開始實施布衛生棉一段時間，
就非常的驚艷了～
原來，並不是活回古代人的感覺！
等我慢慢把整個經期的數量補足，
再來分享長久使用的心得～
真的喜歡，布衛生棉～！
---------------*
♫𝙈𝙐𝙎𝙄𝘾
...
𝙋𝙪𝙧𝙚 𝙄𝙢𝙖𝙜𝙞𝙣𝙖𝙩𝙞𝙤𝙣 𝙗𝙮 𝙁𝙪𝙩𝙪𝙧𝙚 𝙅𝙖𝙢𝙚𝙨 (𝙍&𝘽 / 𝙀𝙡𝙚𝙘𝙩𝙧𝙤𝙣𝙞𝙘 𝙈𝙪𝙨𝙞𝙘 𝙈𝙖𝙠𝙚𝙧)
𝙝𝙩𝙩𝙥𝙨://𝙬𝙬𝙬.𝙞𝙣𝙨𝙩𝙖𝙜𝙧𝙖𝙢.𝙘𝙤𝙢/𝙤𝙝𝙝𝙝𝙞𝙩𝙨𝙟𝙖𝙢𝙚𝙨/
YouTube 系統和人工審查員可能會審核私人影片和播放清單，以確認廣告合適度、版權問題及防止其他濫用/騷擾行為。 功能, 不公開, 私人, 公開. 分享網址, 可, 否, 可. 新增到 ... ... <看更多>
The IFrame player API lets you embed a YouTube video player on your website and control the player using JavaScript.
Using the API's JavaScript functions, you can queue videos for playback; play, pause, or stop those videos; adjust the player volume; or retrieve information about the video being played. You can also add event listeners that will execute in response to certain player events, such as a player state change.
This guide explains how to use the IFrame API. It identifies the different types of events that the API can send and explains how to write event listeners to respond to those events. It also details the different JavaScript functions that you can call to control the video player as well as the player parameters you can use to further customize the player.
RequirementsThe user's browser must support the HTML5 postMessage feature. Most modern browsers support postMessage.
Embedded players must have a viewport that is at least 200px by 200px. If the player displays controls, it must be large enough to fully display the controls without shrinking the viewport below the minimum size. We recommend 16:9 players be at least 480 pixels wide and 270 pixels tall.
Any web page that uses the IFrame API must also implement the following JavaScript function:
onYouTubeIframeAPIReady – The API will call this function when the page has finished downloading the JavaScript for the player API, which enables you to then use the API on your page. Thus, this function might create the player objects that you want to display when the page loads.
The sample HTML page below creates an embedded player that will load a video, play it for six seconds, and then stop the playback. The numbered comments in the HTML are explained in the list below the example.
<!DOCTYPE html>
<html>
<body>
<!-- 1. The <iframe> (and video player) will replace this <div> tag. -->
<div id="player"></div> <script>
// 2. This code loads the IFrame Player API code asynchronously.
var tag = document.createElement('script'); tag.src = "https://www.youtube.com/iframe_api";
var firstScriptTag = document.getElementsByTagName('script')[0];
firstScriptTag.parentNode.insertBefore(tag, firstScriptTag); // 3. This function creates an <iframe> (and YouTube player)
// after the API code downloads.
var player;
function onYouTubeIframeAPIReady() {
player = new YT.Player('player', {
height: '390',
width: '640',
videoId: 'M7lc1UVf-VE',
playerVars: {
'playsinline': 1
},
events: {
'onReady': onPlayerReady,
'onStateChange': onPlayerStateChange
}
});
} // 4. The API will call this function when the video player is ready.
function onPlayerReady(event) {
event.target.playVideo();
} // 5. The API calls this function when the player's state changes.
// The function indicates that when playing a video (state=1),
// the player should play for six seconds and then stop.
var done = false;
function onPlayerStateChange(event) {
if (event.data == YT.PlayerState.PLAYING && !done) {
setTimeout(stopVideo, 6000);
done = true;
}
}
function stopVideo() {
player.stopVideo();
}
</script>
</body>
</html>
The following list provides more details about the sample above:
The <div> tag in this section identifies the location on the page where the IFrame API will place the video player. The constructor for the player object, which is described in the Loading a video player section, identifies the <div> tag by its id to ensure that the API places the <iframe> in the proper location. Specifically, the IFrame API will replace the <div> tag with the <iframe> tag.
As an alternative, you could also put the <iframe> element directly on the page. The Loading a video player section explains how to do so.
The code in this section loads the IFrame Player API JavaScript code. The example uses DOM modification to download the API code to ensure that the code is retrieved asynchronously. (The <script> tag's async attribute, which also enables asynchronous downloads, is not yet supported in all modern browsers as discussed in this Stack Overflow answer.
The onYouTubeIframeAPIReady function will execute as soon as the player API code downloads. This portion of the code defines a global variable, player, which refers to the video player you are embedding, and the function then constructs the video player object.
The onPlayerReady function will execute when the onReady event fires. In this example, the function indicates that when the video player is ready, it should begin to play.
The API will call the onPlayerStateChange function when the player's state changes, which may indicate that the player is playing, paused, finished, and so forth. The function indicates that when the player state is 1 (playing), the player should play for six seconds and then call the stopVideo function to stop the video.
After the API's JavaScript code loads, the API will call the onYouTubeIframeAPIReady function, at which point you can construct a YT.Player object to insert a video player on your page. The HTML excerpt below shows the onYouTubeIframeAPIReady function from the example above:
var player;
function onYouTubeIframeAPIReady() {
player = new YT.Player('player', {
height: '390',
width: '640',
videoId: 'M7lc1UVf-VE',
playerVars: {
'playsinline': 1
},
events: {
'onReady': onPlayerReady,
'onStateChange': onPlayerStateChange
}
});
}
The constructor for the video player specifies the following parameters:
The first parameter specifies either the DOM element or the id of the HTML element where the API will insert the <iframe> tag containing the player.
The IFrame API will replace the specified element with the <iframe> element containing the player. This could affect the layout of your page if the element being replaced has a different display style than the inserted <iframe> element. By default, an <iframe> displays as an inline-block element.
width (number) – The width of the video player. The default value is 640.height (number) – The height of the video player. The default value is 390.videoId (string) – The YouTube video ID that identifies the video that the player will load.playerVars (object) – The object's properties identify player parameters that can be used to customize the player.events (object) – The object's properties identify the events that the API fires and the functions (event listeners) that the API will call when those events occur. In the example, the constructor indicates that the onPlayerReady function will execute when the onReady event fires and that the onPlayerStateChange function will execute when the onStateChange event fires.As mentioned in the Getting started section, instead of writing an empty <div> element on your page, which the player API's JavaScript code will then replace with an <iframe> element, you could create the <iframe> tag yourself. The first example in the Examples section shows how to do this.
<iframe id="player" type="text/html" width="640" height="390"
src="http://www.youtube.com/embed/M7lc1UVf-VE?enablejsapi=1&origin=http://example.com"
frameborder="0"></iframe>
Note that if you do write the <iframe> tag, then when you construct the YT.Player object, you do not need to specify values for the width and height, which are specified as attributes of the <iframe> tag, or the videoId and player parameters, which are are specified in the src URL. As an extra security measure, you should also include the origin parameter to the URL, specifying the URL scheme (http:// or https://) and full domain of your host page as the parameter value. While origin is optional, including it protects against malicious third-party JavaScript being injected into your page and hijacking control of your YouTube player.
For other examples on constructing video player objects, see Examples.
OperationsTo call the player API methods, you must first get a reference to the player object you wish to control. You obtain the reference by creating a YT.Player object as discussed in the Getting started and Loading a video player sections of this document.
Queueing functions allow you to load and play a video, a playlist, or another list of videos. If you are using the object syntax described below to call these functions, then you can also queue or load a list of a user's uploaded videos.
The API supports two different syntaxes for calling the queueing functions.
The argument syntax requires function arguments to be listed in a prescribed order.
The object syntax lets you pass an object as a single parameter and to define object properties for the function arguments that you wish to set. In addition, the API may support additional functionality that the argument syntax does not support.
For example, the loadVideoById function can be called in either of the following ways. Note that the object syntax supports the endSeconds property, which the argument syntax does not support.
Argument syntax
loadVideoById("bHQqvYy5KYo", 5, "large")
Object syntax
loadVideoById({'videoId': 'bHQqvYy5KYo',
'startSeconds': 5,
'endSeconds': 60});
cueVideoByIdArgument syntax
player.cueVideoById(videoId:String,
startSeconds:Number):Void
Object syntax
player.cueVideoById({videoId:String,
startSeconds:Number,
endSeconds:Number}):Void
This function loads the specified video's thumbnail and prepares the player to play the video. The player does not request the FLV until playVideo() or seekTo() is called.
videoId parameter specifies the YouTube Video ID of the video to be played. In the YouTube Data API, a video resource's id property specifies the ID.startSeconds parameter accepts a float/integer and specifies the time from which the video should start playing when playVideo() is called. If you specify a startSeconds value and then call seekTo(), then the player plays from the time specified in the seekTo() call. When the video is cued and ready to play, the player will broadcast a video cued event (5).endSeconds parameter, which is only supported in object syntax, accepts a float/integer and specifies the time when the video should stop playing when playVideo() is called. If you specify an endSeconds value and then call seekTo(), the endSeconds value will no longer be in effect.loadVideoById
Argument syntax
player.loadVideoById(videoId:String,
startSeconds:Number):Void
Object syntax
player.loadVideoById({videoId:String,
startSeconds:Number,
endSeconds:Number}):Void
This function loads and plays the specified video.
videoId parameter specifies the YouTube Video ID of the video to be played. In the YouTube Data API, a video resource's id property specifies the ID.startSeconds parameter accepts a float/integer. If it is specified, then the video will start from the closest keyframe to the specified time.endSeconds parameter accepts a float/integer. If it is specified, then the video will stop playing at the specified time.cueVideoByUrl
Argument syntax
player.cueVideoByUrl(mediaContentUrl:String,
startSeconds:Number):Void
Object syntax
player.cueVideoByUrl({mediaContentUrl:String,
startSeconds:Number,
endSeconds:Number}):Void
This function loads the specified video's thumbnail and prepares the player to play the video. The player does not request the FLV until playVideo() or seekTo() is called.
mediaContentUrl parameter specifies a fully qualified YouTube player URL in the format http://www.youtube.com/v/VIDEO_ID?version=3.startSeconds parameter accepts a float/integer and specifies the time from which the video should start playing when playVideo() is called. If you specify startSeconds and then call seekTo(), then the player plays from the time specified in the seekTo() call. When the video is cued and ready to play, the player will broadcast a video cued event (5).endSeconds parameter, which is only supported in object syntax, accepts a float/integer and specifies the time when the video should stop playing when playVideo() is called. If you specify an endSeconds value and then call seekTo(), the endSeconds value will no longer be in effect.loadVideoByUrl
Argument syntax
player.loadVideoByUrl(mediaContentUrl:String,
startSeconds:Number):Void
Object syntax
player.loadVideoByUrl({mediaContentUrl:String,
startSeconds:Number,
endSeconds:Number}):Void
This function loads and plays the specified video.
mediaContentUrl parameter specifies a fully qualified YouTube player URL in the format http://www.youtube.com/v/VIDEO_ID?version=3.startSeconds parameter accepts a float/integer and specifies the time from which the video should start playing. If startSeconds (number can be a float) is specified, the video will start from the closest keyframe to the specified time.endSeconds parameter, which is only supported in object syntax, accepts a float/integer and specifies the time when the video should stop playing.The cuePlaylist and loadPlaylist functions allow you to load and play a playlist. If you are using object syntax to call these functions, you can also queue (or load) a list of a user's uploaded videos.
Since the functions work differently depending on whether they are called using the argument syntax or the object syntax, both calling methods are documented below.
cuePlaylistArgument syntax
player.cuePlaylist(playlist:String|Array,
index:Number,
startSeconds:Number):Void
video cued event (5).The required playlist parameter specifies an array of YouTube video IDs. In the YouTube Data API, the video resource's id property identifies that video's ID.
The optional index parameter specifies the index of the first video in the playlist that will play. The parameter uses a zero-based index, and the default parameter value is 0, so the default behavior is to load and play the first video in the playlist.
The optional startSeconds parameter accepts a float/integer and specifies the time from which the first video in the playlist should start playing when the playVideo() function is called. If you specify a startSeconds value and then call seekTo(), then the player plays from the time specified in the seekTo() call. If you cue a playlist and then call the playVideoAt() function, the player will start playing at the beginning of the specified video.
Object syntax
player.cuePlaylist({listType:String,
list:String,
index:Number,
startSeconds:Number}):Void
When the list is cued and ready to play, the player will broadcast a video cued event (5).
The optional listType property specifies the type of results feed that you are retrieving. Valid values are playlist and user_uploads. A deprecated value, search, will no longer be supported as of 15 November 2020. The default value is playlist.
The required list property contains a key that identifies the particular list of videos that YouTube should return.
If the listType property value is playlist, then the list property specifies the playlist ID or an array of video IDs. In the YouTube Data API, the playlist resource's id property identifies a playlist's ID, and the video resource's id property specifies a video ID.
If the listType property value is user_uploads, then the list property identifies the user whose uploaded videos will be returned.
If the listType property value is search, then the list property specifies the search query. Note: This functionality is deprecated and will no longer be supported as of 15 November 2020.
The optional index property specifies the index of the first video in the list that will play. The parameter uses a zero-based index, and the default parameter value is 0, so the default behavior is to load and play the first video in the list.
The optional startSeconds property accepts a float/integer and specifies the time from which the first video in the list should start playing when the playVideo() function is called. If you specify a startSeconds value and then call seekTo(), then the player plays from the time specified in the seekTo() call. If you cue a list and then call the playVideoAt() function, the player will start playing at the beginning of the specified video.
loadPlaylistArgument syntax
This function loads the specified playlist and plays it.
player.loadPlaylist(playlist:String|Array,
index:Number,
startSeconds:Number):Void
The required playlist parameter specifies an array of YouTube video IDs. In the YouTube Data API, the video resource's id property specifies a video ID.
The optional index parameter specifies the index of the first video in the playlist that will play. The parameter uses a zero-based index, and the default parameter value is 0, so the default behavior is to load and play the first video in the playlist.
The optional startSeconds parameter accepts a float/integer and specifies the time from which the first video in the playlist should start playing.
Object syntax
This function loads the specified list and plays it. The list can be a playlist or a user's uploaded videos feed. The ability to load a list of search results is deprecated and will no longer be supported as of 15 November 2020.
player.loadPlaylist({list:String,
listType:String,
index:Number,
startSeconds:Number}):Void
The optional listType property specifies the type of results feed that you are retrieving. Valid values are playlist and user_uploads. A deprecated value, search, will no longer be supported as of 15 November 2020. The default value is playlist.
The required list property contains a key that identifies the particular list of videos that YouTube should return.
If the listType property value is playlist, then the list property specifies a playlist ID or an array of video IDs. In the YouTube Data API, the playlist resource's id property specifies a playlist's ID, and the video resource's id property specifies a video ID.
If the listType property value is user_uploads, then the list property identifies the user whose uploaded videos will be returned.
If the listType property value is search, then the list property specifies the search query. Note: This functionality is deprecated and will no longer be supported as of 15 November 2020.
The optional index property specifies the index of the first video in the list that will play. The parameter uses a zero-based index, and the default parameter value is 0, so the default behavior is to load and play the first video in the list.
The optional startSeconds property accepts a float/integer and specifies the time from which the first video in the list should start playing.
player.playVideo():Voidplaying (1).player.pauseVideo():Voidpaused (2) unless the player is in the ended (0) state when the function is called, in which case the player state will not change.player.stopVideo():VoidpauseVideo function. If you want to change the video that the player is playing, you can call one of the queueing functions without calling stopVideo first.pauseVideo function, which leaves the player in the paused (2) state, the stopVideo function could put the player into any not-playing state, including ended (0), paused (2), video cued (5) or unstarted (-1).player.seekTo(seconds:Number, allowSeekAhead:Boolean):Voidplaying, video cued, etc.), the player will play the video.The seconds parameter identifies the time to which the player should advance.
The player will advance to the closest keyframe before that time unless the player has already downloaded the portion of the video to which the user is seeking.
The allowSeekAhead parameter determines whether the player will make a new request to the server if the seconds parameter specifies a time outside of the currently buffered video data.
We recommend that you set this parameter to false while the user drags the mouse along a video progress bar and then set it to true when the user releases the mouse. This approach lets a user scroll to different points of a video without requesting new video streams by scrolling past unbuffered points in the video. When the user releases the mouse button, the player advances to the desired point in the video and requests a new video stream if necessary.
Note: The 360° video playback experience has limited support on mobile devices. On unsupported devices, 360° videos appear distorted and there is no supported way to change the viewing perspective at all, including through the API, using orientation sensors, or responding to touch/drag actions on the device's screen.
player.getSphericalProperties():ObjectenableOrientationSensor property is set to true, then this function returns an object in which the fov property contains the correct value and the other properties are set to 0.yawpitchrollgetSphericalProperties function always returns 0 as the value of the roll property.fovplayer.setSphericalProperties(properties:Object):Voidproperties object. The view persists values for any other known properties not included in that object.fov property and does not affect the yaw, pitch, and roll properties for 360° video playbacks. See the enableOrientationSensor property below for more detail.properties object passed to the function contains the following properties:yawpitchrollfovenableOrientationSensorDeviceOrientationEvent. The default parameter value is true.true, an embedded player relies only on the device's movement to adjust the yaw, pitch, and roll properties for 360° video playbacks. However, the fov property can still be changed via the API, and the API is, in fact, the only way to change the fov property on a mobile device. This is the default behavior.false, then the device's movement does not affect the 360° viewing experience, and the yaw, pitch, roll, and fov properties must all be set via the API.enableOrientationSensor property value does not have any effect on the playback experience.player.nextVideo():VoidIf player.nextVideo() is called while the last video in the playlist is being watched, and the playlist is set to play continuously (loop), then the player will load and play the first video in the list.
If player.nextVideo() is called while the last video in the playlist is being watched, and the playlist is not set to play continuously, then playback will end.
player.previousVideo():VoidIf player.previousVideo() is called while the first video in the playlist is being watched, and the playlist is set to play continuously (loop), then the player will load and play the last video in the list.
If player.previousVideo() is called while the first video in the playlist is being watched, and the playlist is not set to play continuously, then the player will restart the first playlist video from the beginning.
player.playVideoAt(index:Number):VoidThe required index parameter specifies the index of the video that you want to play in the playlist. The parameter uses a zero-based index, so a value of 0 identifies the first video in the list. If you have shuffled the playlist, this function will play the video at the specified position in the shuffled playlist.
player.mute():Voidplayer.unMute():Voidplayer.isMuted():Booleantrue if the player is muted, false if not.player.setVolume(volume:Number):Void0 and 100.player.getVolume():Number0 and 100. Note that getVolume() will return the volume even if the player is muted.player.setSize(width:Number, height:Number):Object<iframe> that contains the player.player.getPlaybackRate():Number1, which indicates that the video is playing at normal speed. Playback rates may include values like 0.25, 0.5, 1, 1.5, and 2.player.setPlaybackRate(suggestedRate:Number):VoidplayVideo function is called or the user initiates playback directly through the player controls. In addition, calling functions to cue or load videos or playlists (cueVideoById, loadVideoById, etc.) will reset the playback rate to 1.onPlaybackRateChange event will fire, and your code should respond to the event rather than the fact that it called the setPlaybackRate function.getAvailablePlaybackRates method will return the possible playback rates for the currently playing video. However, if you set the suggestedRate parameter to a non-supported integer or float value, the player will round that value down to the nearest supported value in the direction of 1.player.getAvailablePlaybackRates():Array1, which indicates that the video is playing in normal speed.1).player.setLoop(loopPlaylists:Boolean):VoidThis function indicates whether the video player should continuously play a playlist or if it should stop playing after the last video in the playlist ends. The default behavior is that playlists do not loop.
This setting will persist even if you load or cue a different playlist, which means that if you load a playlist, call the setLoop function with a value of true, and then load a second playlist, the second playlist will also loop.
The required loopPlaylists parameter identifies the looping behavior.
If the parameter value is true, then the video player will continuously play playlists. After playing the last video in a playlist, the video player will go back to the beginning of the playlist and play it again.
If the parameter value is false, then playbacks will end after the video player plays the last video in a playlist.
player.setShuffle(shufflePlaylist:Boolean):VoidThis function indicates whether a playlist's videos should be shuffled so that they play back in an order different from the one that the playlist creator designated. If you shuffle a playlist after it has already started playing, the list will be reordered while the video that is playing continues to play. The next video that plays will then be selected based on the reordered list.
This setting will not persist if you load or cue a different playlist, which means that if you load a playlist, call the setShuffle function, and then load a second playlist, the second playlist will not be shuffled.
The required shufflePlaylist parameter indicates whether YouTube should shuffle the playlist.
If the parameter value is true, then YouTube will shuffle the playlist order. If you instruct the function to shuffle a playlist that has already been shuffled, YouTube will shuffle the order again.
If the parameter value is false, then YouTube will change the playlist order back to its original order.
player.getVideoLoadedFraction():Float0 and 1 that specifies the percentage of the video that the player shows as buffered. This method returns a more reliable number than the now-deprecated getVideoBytesLoaded and getVideoBytesTotal methods.player.getPlayerState():Number-1 – unstarted0 – ended1 – playing2 – paused3 – buffering5 – video cuedplayer.getCurrentTime():Numberplayer.getVideoStartBytes():Number0.) Example scenario: the user seeks ahead to a point that hasn't loaded yet, and the player makes a new request to play a segment of the video that hasn't loaded yet.player.getVideoBytesLoaded():NumbergetVideoLoadedFraction method to determine the percentage of the video that has buffered.0 and 1000 that approximates the amount of the video that has been loaded. You could calculate the fraction of the video that has been loaded by dividing the getVideoBytesLoaded value by the getVideoBytesTotal value.player.getVideoBytesTotal():NumbergetVideoLoadedFraction method to determine the percentage of the video that has buffered.1000. You could calculate the fraction of the video that has been loaded by dividing the getVideoBytesLoaded value by the getVideoBytesTotal value.player.getDuration():NumbergetDuration() will return 0 until the video's metadata is loaded, which normally happens just after the video starts playing.getDuration() function will return the elapsed time since the live video stream began. Specifically, this is the amount of time that the video has streamed without being reset or interrupted. In addition, this duration is commonly longer than the actual event time since streaming may begin before the event's start time.player.getVideoUrl():Stringplayer.getVideoEmbedCode():Stringplayer.getPlaylist():ArraysetShuffle function to shuffle the playlist order, then the getPlaylist() function's return value will reflect the shuffled order.player.getPlaylistIndex():NumberIf you have not shuffled the playlist, the return value will identify the position where the playlist creator placed the video. The return value uses a zero-based index, so a value of 0 identifies the first video in the playlist.
If you have shuffled the playlist, the return value will identify the video's order within the shuffled playlist.
player.addEventListener(event:String, listener:String):Voidevent. The Events section below identifies the different events that the player might fire. The listener is a string that specifies the function that will execute when the specified event fires.player.removeEventListener(event:String, listener:String):Voidevent. The listener is a string that identifies the function that will no longer execute when the specified event fires.player.getIframe():Object<iframe>.player.destroy():Void<iframe> containing the player.The API fires events to notify your application of changes to the embedded player. As noted in the previous section, you can subscribe to events by adding an event listener when constructing the YT.Player object, and you can also use the addEventListener function.
The API will pass an event object as the sole argument to each of those functions. The event object has the following properties:
target identifies the video player that corresponds to the event.data specifies a value relevant to the event. Note that the onReady and onAutoplayBlocked events do not specify a data property.The following list defines the events that the API fires:
onReadytarget property, which identifies the player. The function retrieves the embed code for the currently loaded video, starts to play the video, and displays the embed code in the page element that has an id value of embed-code.
function onPlayerReady(event) {
var embedCode = event.target.getVideoEmbedCode();
event.target.playVideo();
if (document.getElementById('embed-code')) {
document.getElementById('embed-code').innerHTML = embedCode;
}
}
onStateChangedata property of the event object that the API passes to your event listener function will specify an integer that corresponds to the new player state.
-1 (unstarted)
0 (ended)
1 (playing)
2 (paused)
3 (buffering)
5 (video cued).
unstarted (-1) event. When a video is cued and ready to play, the player will broadcast a video cued (5) event. In your code, you can specify the integer values or you can use one of the following namespaced variables:
YT.PlayerState.ENDED
YT.PlayerState.PLAYING
YT.PlayerState.PAUSED
YT.PlayerState.BUFFERING
YT.PlayerState.CUED
onPlaybackQualityChangedata property value of the event object that the API passes to the event listener function will be a string that identifies the new playback quality.
small
medium
large
hd720
hd1080
highres
onPlaybackRateChangesetPlaybackRate(suggestedRate) function, this event will fire if the playback rate actually changes. Your application should respond to the event and should not assume that the playback rate will automatically change when the setPlaybackRate(suggestedRate) function is called. Similarly, your code should not assume that the video playback rate will only change as a result of an explicit call to setPlaybackRate.data property value of the event object that the API passes to the event listener function will be a number that identifies the new playback rate.getAvailablePlaybackRates method returns a list of the valid playback rates for the currently cued or playing video.onErrorevent object to the event listener function. That object's data property will specify an integer that identifies the type of error that occurred.
2 – The request contains an invalid parameter value. For example, this error occurs if you specify a video ID that does not have 11 characters, or if the video ID contains invalid characters, such as exclamation points or asterisks. 5 – The requested content cannot be played in an HTML5 player or another error related to the HTML5 player has occurred. 100 – The video requested was not found. This error occurs when a video has been removed (for any reason) or has been marked as private.
101 – The owner of the requested video does not allow it to be played in embedded players.
150 – This error is the same as 101. It's just a 101 error in disguise!
onApiChange
This event is fired to indicate that the player has loaded (or unloaded) a module with exposed API methods. Your application can listen for this event and then poll the player to determine which options are exposed for the recently loaded module. Your application can then retrieve or update the existing settings for those options.
The following command retrieves an array of module names for which you can set player options:
player.getOptions();
captions module, which handles closed captioning in the player. Upon receiving an onApiChange event, your application can use the following command to determine which options can be set for the captions module:player.getOptions('captions');Retrieving an option:The table below lists the options that the API supports:
player.getOption(module, option);Setting an option
player.setOption(module, option, value);
-1, 0, 1, 2, and 3. The default size is 0, and the smallest size is -1. Setting this option to an integer below -1 will cause the smallest caption size to display, while setting this option to an integer above 3 will cause the largest caption size to display.null if you retrieve the option's value. Set the value to true to reload the closed caption data.onAutoplayBlocked
autoplay parameter
loadPlaylist function
loadVideoById function
loadVideoByUrl function
playVideo function
YT.Player objectsExample 1: Use API with existing <iframe>
In this example, an <iframe> element on the page already defines the player with which the API will be used. Note that either the player's src URL must set the enablejsapi parameter to 1 or the <iframe> element's enablejsapi attribute must be set to true.
The onPlayerReady function changes the color of the border around the player to orange when the player is ready. The onPlayerStateChange function then changes the color of the border around the player based on the current player status. For example, the color is green when the player is playing, red when paused, blue when buffering, and so forth.
This example uses the following code:
<iframe id="existing-iframe-example"
width="640" height="360"
src="https://www.youtube.com/embed/M7lc1UVf-VE?enablejsapi=1"
frameborder="0"
style="border: solid 4px #37474F"
></iframe><script type="text/javascript">
var tag = document.createElement('script');
tag.id = 'iframe-demo';
tag.src = 'https://www.youtube.com/iframe_api';
var firstScriptTag = document.getElementsByTagName('script')[0];
firstScriptTag.parentNode.insertBefore(tag, firstScriptTag); var player;
function onYouTubeIframeAPIReady() {
player = new YT.Player('existing-iframe-example', {
events: {
'onReady': onPlayerReady,
'onStateChange': onPlayerStateChange
}
});
}
function onPlayerReady(event) {
document.getElementById('existing-iframe-example').style.borderColor = '#FF6D00';
}
function changeBorderColor(playerStatus) {
var color;
if (playerStatus == -1) {
color = "#37474F"; // unstarted = gray
} else if (playerStatus == 0) {
color = "#FFFF00"; // ended = yellow
} else if (playerStatus == 1) {
color = "#33691E"; // playing = green
} else if (playerStatus == 2) {
color = "#DD2C00"; // paused = red
} else if (playerStatus == 3) {
color = "#AA00FF"; // buffering = purple
} else if (playerStatus == 5) {
color = "#FF6DOO"; // video cued = orange
}
if (color) {
document.getElementById('existing-iframe-example').style.borderColor = color;
}
}
function onPlayerStateChange(event) {
changeBorderColor(event.data);
}
</script>
Example 2: Loud playback
This example creates a 1280px by 720px video player. The event listener for the onReady event then calls the setVolume function to adjust the volume to the highest setting.
function onYouTubeIframeAPIReady() {
var player;
player = new YT.Player('player', {
width: 1280,
height: 720,
videoId: 'M7lc1UVf-VE',
events: {
'onReady': onPlayerReady,
'onStateChange': onPlayerStateChange,
'onError': onPlayerError
}
});
}function onPlayerReady(event) {
event.target.setVolume(100);
event.target.playVideo();
}
Example 3: This example sets player parameters to automatically play the video when it loads and to hide the video player's controls. It also adds event listeners for several events that the API broadcasts.
function onYouTubeIframeAPIReady() {
var player;
player = new YT.Player('player', {
videoId: 'M7lc1UVf-VE',
playerVars: { 'autoplay': 1, 'controls': 0 },
events: {
'onReady': onPlayerReady,
'onStateChange': onPlayerStateChange,
'onError': onPlayerError
}
});
}
This example uses the following code:
<style>Android WebView Media Integrity API integration
.current-values {
color: #666;
font-size: 12px;
}
</style>
<!-- The player is inserted in the following div element -->
<div id="spherical-video-player"></div><!-- Display spherical property values and enable user to update them. -->
<table style="border: 0; width: 640px;">
<tr style="background: #fff;">
<td>
<label for="yaw-property">yaw: </label>
<input type="text" id="yaw-property" style="width: 80px"><br>
<div id="yaw-current-value" class="current-values"> </div>
</td>
<td>
<label for="pitch-property">pitch: </label>
<input type="text" id="pitch-property" style="width: 80px"><br>
<div id="pitch-current-value" class="current-values"> </div>
</td>
<td>
<label for="roll-property">roll: </label>
<input type="text" id="roll-property" style="width: 80px"><br>
<div id="roll-current-value" class="current-values"> </div>
</td>
<td>
<label for="fov-property">fov: </label>
<input type="text" id="fov-property" style="width: 80px"><br>
<div id="fov-current-value" class="current-values"> </div>
</td>
<td style="vertical-align: bottom;">
<button id="spherical-properties-button">Update properties</button>
</td>
</tr>
</table><script type="text/javascript">
var tag = document.createElement('script');
tag.id = 'iframe-demo';
tag.src = 'https://www.youtube.com/iframe_api';
var firstScriptTag = document.getElementsByTagName('script')[0];
firstScriptTag.parentNode.insertBefore(tag, firstScriptTag); var PROPERTIES = ['yaw', 'pitch', 'roll', 'fov'];
var updateButton = document.getElementById('spherical-properties-button'); // Create the YouTube Player.
var ytplayer;
function onYouTubeIframeAPIReady() {
ytplayer = new YT.Player('spherical-video-player', {
height: '360',
width: '640',
videoId: 'FAtdv94yzp4',
});
} // Don't display current spherical settings because there aren't any.
function hideCurrentSettings() {
for (var p = 0; p < PROPERTIES.length; p++) {
document.getElementById(PROPERTIES[p] + '-current-value').innerHTML = '';
}
} // Retrieve current spherical property values from the API and display them.
function updateSetting() {
if (!ytplayer || !ytplayer.getSphericalProperties) {
hideCurrentSettings();
} else {
let newSettings = ytplayer.getSphericalProperties();
if (Object.keys(newSettings).length === 0) {
hideCurrentSettings();
} else {
for (var p = 0; p < PROPERTIES.length; p++) {
if (newSettings.hasOwnProperty(PROPERTIES[p])) {
currentValueNode = document.getElementById(PROPERTIES[p] +
'-current-value');
currentValueNode.innerHTML = ('current: ' +
newSettings[PROPERTIES[p]].toFixed(4));
}
}
}
}
requestAnimationFrame(updateSetting);
}
updateSetting(); // Call the API to update spherical property values.
updateButton.onclick = function() {
var sphericalProperties = {};
for (var p = 0; p < PROPERTIES.length; p++) {
var propertyInput = document.getElementById(PROPERTIES[p] + '-property');
sphericalProperties[PROPERTIES[p]] = parseFloat(propertyInput.value);
}
ytplayer.setSphericalProperties(sphericalProperties);
}
</script>
YouTube has extended the
Android WebView Media Integrity API
to enable embedded media players, including YouTube player embeds in Android applications, to
verify the embedding app's authenticity. With this change, embedding apps automatically send an
attested app ID to YouTube. The data collected through usage of this API is the app metadata (the
package name, version number, and signing certificate) and a device attestation token generated by
Google Play services.
The data is used to verify the application and device integrity. It is encrypted, not shared with
third parties, and deleted following a fixed retention period. App developers can
configure their app identity
in the WebView Media Integrity API. The configuration supports an opt-out option.
The documentation has been updated to note that YouTube has extended the
Android WebView Media Integrity API
to enable embedded media players, including YouTube player embeds in Android applications, to
verify the embedding app's authenticity. With this change, embedding apps automatically send an
attested app ID to YouTube.
The new onAutoplayBlocked event API is now available.
This event notifies your application if the browser blocks autoplay or scripted playback.
Verification of autoplay success or failure is an
established paradigm
for HTMLMediaElements, and the onAutoplayBlocked event now provides similar
functionality for the IFrame Player API.
The Getting Started and Loading a Video Player sections have been updated to include examples of using a playerVars object to customize the player.
Note: This is a deprecation announcement for the embedded player
functionality that lets you configure the player to load search results. This announcement affects
the IFrame Player API's queueing functions for lists,
cuePlaylist and
loadPlaylist.
This change will become effective on or after 15 November 2020. After that time, calls to the
cuePlaylist or loadPlaylist functions that set the listType
property to search will generate a 4xx response code, such as
404 (Not Found) or 410 (Gone). This change
also affects the list property for those functions as that property no longer
supports the ability to specify a search query.
As an alternative, you can use the YouTube Data API's
search.list method to retrieve search
results and then load selected videos in the player.
The documentation has been updated to reflect the fact that the API no longer supports functions for setting or retrieving playback quality.
As explained in this YouTube Help Center article, to give you the best viewing
experience, YouTube adjusts the quality of your video stream based on your viewing conditions.
The changes explained below have been in effect for more than one year. This update merely aligns
the documentation with current functionality:
getPlaybackQuality, setPlaybackQuality, and getAvailableQualityLevels functionssetPlaybackQuality will be no-op functions, meaning they willcueVideoById,loadVideoById, etc. -- no longer support the suggestedQuality argument.suggestedQuality field is no longer supported.suggestedQuality is specified, it will be ignored when the request is handled. It will not generate anyonPlaybackQualityChange event is still supported and might signal aThe API now supports features that allow users (or embedders) to control the viewing perspective for 360° videos:
getSphericalProperties function retrieves the current orientation for the video playback. The orientation includes the following data:setSphericalProperties function modifies the view to match the submitted property values. In addition to the orientation values described above, this function supports a Boolean field that indicates whether the IFrame embed should respond to DeviceOrientationEvents on supported mobile devices.This example demonstrates and lets you test these new features.
This update contains the following changes:
Documentation for the YouTube Flash Player API and YouTube JavaScript Player API has been removed and redirected to this document. The deprecation announcement for the Flash and JavaScript players was made on January 27, 2015. If you haven't done so already, please migrate your applications to use IFrame embeds and the IFrame Player API.
This update contains the following changes:
The newly published YouTube API Services Terms of Service ("the Updated Terms"), discussed in detail on the YouTube Engineering and Developers Blog, provides a rich set of updates to the current Terms of Service. In addition to the Updated Terms, which will go into effect as of February 10, 2017, this update includes several supporting documents to help explain the policies that developers must follow.
The full set of new documents is described in the revision history for the Updated Terms. In addition, future changes to the Updated Terms or to those supporting documents will also be explained in that revision history. You can subscribe to an RSS feed listing changes in that revision history from a link in that document.
This update contains the following changes:
The documentation has been corrected to note that the onApiChange method provides access to the captions module and not the cc module.
The Examples section has been updated to include an example that demonstrates how to use the API with an existing <iframe> element.
The clearVideo function has been deprecated and removed from the documentation. The function no longer has any effect in the YouTube player.
European Union (EU) laws require that certain disclosures must be given to and consents obtained from end users in the EU. Therefore, for end users in the European Union, you must comply with the EU User Consent Policy. We have added a notice of this requirement in our YouTube API Terms of Service.
This update contains the following changes:
The new removeEventListener function lets you remove a listener for a specified event.
This update contains the following changes:
The Requirements section has been updated to note that embedded players must have a viewport that is at least 200px by 200px. If a player displays controls, it must be large enough to fully display the controls without shrinking the viewport below the minimum size. We recommend 16:9 players be at least 480 pixels wide and 270 pixels tall.
This update contains the following changes:
The Overview now includes a video of a 2011 Google I/O presentation that discusses the iframe player.
This update contains the following changes:
The Queueing functions section has been updated to explain that you can use either argument syntax or object syntax to call all of those functions. Note that the API may support additional functionality in object syntax that the argument syntax does not support.
In addition, the descriptions and examples for each of the video queueing functions have been updated to reflect the newly added support for object syntax. (The API's playlist queueing functions already supported object syntax.)
When called using object syntax, each of the video queueing functions supports an endSeconds property, which accepts a float/integer and specifies the time when the video should stop playing when playVideo() is called.
The getVideoStartBytes method has been deprecated. The method now always returns a value of 0.
This update contains the following changes:
The example in the Loading a video player section that demonstrates how to manually create the <iframe> tag has been updated to include a closing </iframe> tag since the onYouTubeIframeAPIReady function is only called if the closing </iframe> element is present.
This update contains the following changes:
The Operations section has been expanded to list all of the supported API functions rather than linking to the JavaScript Player API Reference for that list.
The API supports several new functions and one new event that can be used to control the video playback speed:
Functions
getAvailablePlaybackRates – Retrieve the supported playback rates for the cued or playing video. Note that variable playback rates are currently only supported in the HTML5 player.
getPlaybackRate – Retrieve the playback rate for the cued or playing video.
setPlaybackRate – Set the playback rate for the cued or playing video.
Events
onPlaybackRateChange – This event fires when the video's playback rate changes.
This update contains the following changes:
The new getVideoLoadedFraction method replaces the now-deprecated getVideoBytesLoaded and getVideoBytesTotal methods. The new method returns the percentage of the video that the player shows as buffered.
The onError event may now return an error code of 5, which indicates that the requested content cannot be played in an HTML5 player or another error related to the HTML5 player has occurred.
The Requirements section has been updated to indicate that any web page using the IFrame API must also implement the onYouTubeIframeAPIReady function. Previously, the section indicated that the required function was named onYouTubePlayerAPIReady. Code samples throughout the document have also been updated to use the new name.
Note: To ensure that this change does not break existing implementations, both names will work. If, for some reason, your page has an onYouTubeIframeAPIReady function and an onYouTubePlayerAPIReady function, both functions will be called, and the onYouTubeIframeAPIReady function will be called first.
The code sample in the Getting started section has been updated to reflect that the URL for the IFrame Player API code has changed to http://www.youtube.com/iframe_api. To ensure that this change does not affect existing implementations, the old URL (http://www.youtube.com/player_api) will continue to work.
This update contains the following changes:
The Operations section now explains that the API supports the setSize() and destroy() methods. The setSize() method sets the size in pixels of the <iframe> that contains the player and the destroy() method removes the <iframe>.
This update contains the following changes:
We have removed the experimental status from the IFrame Player API.
The Loading a video player section has been updated to point out that when inserting the <iframe> element that will contain the YouTube player, the IFrame API replaces the element specified in the constructor for the YouTube player. This documentation change does not reflect a change in the API and is intended solely to clarify existing behavior.
In addition, that section now notes that the insertion of the <iframe> element could affect the layout of your page if the element being replaced has a different display style than the inserted <iframe> element. By default, an <iframe> displays as an inline-block element.
This update contains the following changes:
The Operations section has been updated to explain that the IFrame API supports a new method, getIframe(), which returns the DOM node for the IFrame embed.
This update contains the following changes:
The Requirements section has been updated to note the minimum player size.
不會改變的清單 在 #不會改變的清單 - Explore | Facebook 的必吃
這看起來會是個很苦情的故事，但婆婆卻用「愛」與「智慧」把後面的劇本寫得圓滿。 婆婆沒有將自己跟前夫的恩怨帶到孩子的教養中，她堅決地告訴自己：#要教孩子 ... ... <看更多>