def get_item(self, driveid, item_driveid=None, item_id=None, path=None, find_subtitles=False, include_download_info=False):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
cache_key = self._addonid+'-drive-'+driveid+'-item_driveid-'+Utils.str(item_driveid)+'-item_id-'+Utils.str(item_id)+'-path-'+Utils.str(path)
f = self._cache.get(cache_key)
if not f :
if item_id:
f = self._provider.get('/drives/'+item_driveid+'/items/' + item_id, parameters = self._extra_parameters)
elif path == 'sharedWithMe' or path == 'recent':
return
else:
if path == '/':
path = 'root'
else:
parts = path.split('/')
if len(parts) > 1 and not parts[0]:
path = 'root:'+path+':'
f = self._provider.get('/drives/'+driveid+'/' + path, parameters = self._extra_parameters)
self._cache.set(cache_key, f, expiration=datetime.timedelta(seconds=59))
item = self._extract_item(f, include_download_info)
if find_subtitles:
subtitles = []
parent_id = Utils.get_safe_value(Utils.get_safe_value(f, 'parentReference', {}), 'id')
search_url = '/drives/'+item_driveid+'/items/' + parent_id + '/search(q=\'{'+urllib.quote(Utils.remove_extension(item['name']))+'}\')'
files = self._provider.get(search_url)
for f in files['value']:
subtitle = self._extract_item(f, include_download_info)
if subtitle['name_extension'] == 'srt' or subtitle['name_extension'] == 'sub' or subtitle['name_extension'] == 'sbv':
subtitles.append(subtitle)
if subtitles:
item['subtitles'] = subtitles
return item
def get_item(self, driveid, item_driveid=None, item_id=None, path=None, find_subtitles=False, include_download_info=False):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
cache_key = self._addonid+'-drive-'+driveid+'-item_driveid-'+Utils.str(item_driveid)+'-item_id-'+Utils.str(item_id)+'-path-'+Utils.str(path)
f = self._cache.get(cache_key)
if f:
item = self._extract_item(f, include_download_info)
else:
cache_key = self._addonid+'-drive-None-item_driveid-None-item_id-None-path-'+path
f = self._cache.get(cache_key)
if f:
item = self._extract_item(f, include_download_info)
else:
self._parameters['fields'] = self._file_fileds
if not item_id and path == '/':
item_id = 'root'
if item_id:
f = self._provider.get('/files/%s' % item_id, parameters = self._parameters)
self._cache.set(cache_key, f, expiration=datetime.timedelta(seconds=59))
item = self._extract_item(f, include_download_info)
else:
item = self.get_item_by_path(path, include_download_info)
if find_subtitles:
subtitles = []
self._parameters['q'] = 'name contains \'%s\'' % urllib.quote(Utils.remove_extension(item['name']))
files = self._provider.get('/files', parameters = self._parameters)
for f in files['files']:
subtitle = self._extract_item(f, include_download_info)
if subtitle['name_extension'] == 'srt' or subtitle['name_extension'] == 'sub' or subtitle['name_extension'] == 'sbv':
subtitles.append(subtitle)
if subtitles:
item['subtitles'] = subtitles
return item
def search(self, query, driveid, item_driveid=None, item_id=None, on_items_page_completed=None):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
self._parameters['fields'] = 'files(%s)' % self._file_fileds
query = 'fullText contains \'%s\'' % query
if item_id:
query += ' and \'%s\' in parents' % item_id
self._parameters['q'] = query
files = self._provider.get('/files', parameters = self._parameters)
if self.cancel_operation():
return
return self.process_files(driveid, files, on_items_page_completed)
def get_strm_link(driveid, item, content_type, addon_url):
item_id = Utils.str(item['id'])
item_drive_id = Utils.default(Utils.get_safe_value(item, 'drive_id'),
driveid)
content = addon_url + '?' + urllib.urlencode({
'action': 'play',
'content_type': content_type,
'item_driveid': item_drive_id,
'item_id': item_id,
'driveid': driveid
})
return Utils.str(content)
def refresh_tokens(self,
provider_name,
refresh_token,
request_params=None):
request_params = Utils.default(request_params, {})
headers = {'addon': self.get_addon_header()}
body = urllib.urlencode({
'provider': provider_name,
'refresh_token': refresh_token
})
return Request(KodiUtils.get_signin_server() + '/refresh', body,
headers, **request_params).request_json()
def get_folder_items(self,
item_driveid=None,
item_id=None,
path=None,
on_items_page_completed=None,
include_download_info=False):
item_driveid = Utils.default(item_driveid, self._driveid)
is_album = item_id and item_id[:6] == 'album-'
if is_album:
item_id = item_id[6:]
parameters = self.prepare_parameters()
if item_id:
parameters['q'] = '\'%s\' in parents' % item_id
elif path == 'sharedWithMe' or path == 'starred':
parameters['q'] = path
elif path != 'photos':
if path == '/':
parent = self._driveid if self._is_team_drive else 'root'
parameters['q'] = '\'%s\' in parents' % parent
elif not is_album:
item = self.get_item_by_path(path, include_download_info)
parameters['q'] = '\'%s\' in parents' % item['id']
parameters[
'fields'] = 'files(%s),kind,nextPageToken' % self._get_field_parameters(
)
if 'q' in parameters:
parameters['q'] += ' and not trashed'
self.configure(self._account_manager, self._driveid)
provider_method = self.get
url = '/files'
if path == 'photos':
self._photos_provider = GooglePhotos()
self._photos_provider.configure(self._account_manager,
self._driveid)
parameters = {}
provider_method = self._photos_provider.get
url = '/albums'
elif is_album:
self._photos_provider = GooglePhotos()
self._photos_provider.configure(self._account_manager,
self._driveid)
parameters = {'albumId': item_id}
provider_method = self._photos_provider.post
url = '/mediaItems:search'
files = provider_method(url, parameters=parameters)
if self.cancel_operation():
return
return self.process_files(files, parameters, on_items_page_completed,
include_download_info)
def get_subtitles(self, parent, name, item_driveid=None, include_download_info=False):
parameters = self.prepare_parameters()
item_driveid = Utils.default(item_driveid, self._driveid)
subtitles = []
parameters['fields'] = 'files(' + self._get_field_parameters() + ')'
parameters['q'] = 'name contains \'%s\'' % Utils.str(Utils.remove_extension(name)).replace("'","\\'")
parameters['pageSize'] = 1000
files = self.get('/files', parameters = parameters)
for f in files['files']:
subtitle = self._extract_item(f, include_download_info)
if subtitle['name_extension'].lower() in ('srt','idx','sub','sbv','ass','ssa','smi'):
subtitles.append(subtitle)
return subtitles
def search(self, query, item_driveid=None, item_id=None, on_items_page_completed=None):
item_driveid = Utils.default(item_driveid, self._driveid)
parameters = self.prepare_parameters()
parameters['fields'] = 'files(%s),kind,nextPageToken' % self._get_field_parameters()
query = 'fullText contains \'%s\'' % Utils.str(query)
if item_id:
query += ' and \'%s\' in parents' % item_id
parameters['q'] = query + ' and not trashed'
parameters['pageSize'] = 1000
files = self.get('/files', parameters = parameters)
if self.cancel_operation():
return
return self.process_files(files, parameters, on_items_page_completed)
def prepare_request(self, method, path, parameters=None, request_params=None, access_tokens=None, headers=None):
parameters = Utils.default(parameters, {})
access_tokens = Utils.default(access_tokens, {})
encoded_parameters = urllib.urlencode(parameters)
url = self._build_url(method, path, encoded_parameters)
request_params = self._wrap_on_exception(request_params)
if not headers:
headers = Utils.default(self._get_request_headers(), {})
content_type = Utils.get_safe_value(headers, 'content-type', '')
if content_type == 'application/json':
data = json.dumps(parameters)
else:
data = None if method == 'get' else encoded_parameters
if not access_tokens:
access_tokens = self.get_access_tokens()
self._validate_access_tokens(access_tokens, url, data, headers)
if time.time() > (access_tokens['date'] + access_tokens['expires_in'] - 600):
access_tokens.update(self.refresh_access_tokens(request_params))
self._validate_access_tokens(access_tokens, 'refresh_access_tokens', 'Unknown', 'Unknown')
self.persist_access_tokens(access_tokens)
headers['authorization'] = 'Bearer ' + access_tokens['access_token']
return Request(url, data, headers, **request_params)
def get_folder_items(self,
item_driveid=None,
item_id=None,
path=None,
on_items_page_completed=None,
include_download_info=False):
item_driveid = Utils.default(item_driveid, self._driveid)
is_album = item_id and item_id[:6] == 'album-'
if is_album:
Logger.notice(item_id)
item_id = item_id[6:]
Logger.notice(item_id)
parameters = copy.deepcopy(self._default_parameters)
if item_id:
parameters['q'] = '\'%s\' in parents' % item_id
elif path == 'sharedWithMe' or path == 'starred':
parameters['q'] = path
elif path != 'photos':
if path == '/':
parameters['q'] = '\'root\' in parents'
elif not is_album:
item = self.get_item_by_path(path, include_download_info)
parameters['q'] = '\'%s\' in parents' % item['id']
parameters['fields'] = 'files(%s),nextPageToken' % self._file_fileds
if 'q' in parameters:
parameters['q'] += ' and not trashed'
if path == 'photos':
self._photos_provider = GooglePhotos()
Logger.notice(self._get_api_url())
self._photos_provider.configure(self._account_manager,
self._driveid)
files = self._photos_provider.get('/albums')
files['is_album'] = True
elif is_album:
self._photos_provider = GooglePhotos()
self._photos_provider.configure(self._account_manager,
self._driveid)
files = self._photos_provider.post('/mediaItems:search',
parameters={'albumId': item_id})
files['is_media_items'] = True
else:
self.configure(self._account_manager, self._driveid)
files = self.get('/files', parameters=parameters)
files['is_album'] = False
if self.cancel_operation():
return
return self.process_files(files, parameters, on_items_page_completed,
include_download_info)
def get_item(self,
driveid,
item_driveid=None,
item_id=None,
path=None,
find_subtitles=False,
include_download_info=False):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
all_cache_key = self._addonid + '-drive-' + Utils.str(
driveid) + '-item_driveid-' + Utils.str(
item_driveid) + '-item_id-' + Utils.str(
item_id) + '-path-' + Utils.str(path)
f = self._cache.get(all_cache_key)
if f:
item = self._extract_item(f, include_download_info)
else:
path_cache_key = self._addonid + '-drive-None-item_driveid-None-item_id-None-path-' + Utils.str(
path)
f = self._cache.get(path_cache_key)
if f:
item = self._extract_item(f, include_download_info)
else:
self._parameters['fields'] = self._file_fileds
if not item_id and path == '/':
item_id = 'root'
if item_id:
f = self._provider.get('/files/%s' % item_id,
parameters=self._parameters)
self._cache.set(all_cache_key,
f,
expiration=datetime.timedelta(seconds=59))
item = self._extract_item(f, include_download_info)
else:
item = self.get_item_by_path(path, include_download_info)
if find_subtitles:
subtitles = []
self._parameters['fields'] = 'files(' + self._file_fileds + ')'
self._parameters['q'] = 'name contains \'%s\'' % Utils.str(
Utils.remove_extension(item['name'])).replace("'", "\\'")
files = self._provider.get('/files', parameters=self._parameters)
for f in files['files']:
subtitle = self._extract_item(f, include_download_info)
if subtitle['name_extension'] == 'srt' or subtitle[
'name_extension'] == 'sub' or subtitle[
'name_extension'] == 'sbv':
subtitles.append(subtitle)
if subtitles:
item['subtitles'] = subtitles
return item
def _refresh_slideshow(self, driveid, item_driveid, item_id, path,
change_token, wait_for_slideshow):
if wait_for_slideshow:
Logger.notice(
'Waiting up to 10 minutes until the slideshow for folder %s starts...'
% Utils.default(item_id, path))
max_waiting_time = time.time() + 10 * 60
while not self.cancel_operation(
) and not KodiUtils.get_cond_visibility(
'Slideshow.IsActive') and max_waiting_time > time.time():
if self._system_monitor.waitForAbort(2):
break
self._print_slideshow_info()
interval = self._addon.getSetting('slideshow_refresh_interval')
Logger.notice(
'Waiting up to %s minute(s) to check if it is needed to refresh the slideshow of folder %s...'
% (interval, Utils.default(item_id, path)))
target_time = time.time() + int(interval) * 60
while not self.cancel_operation() and target_time > time.time(
) and KodiUtils.get_cond_visibility('Slideshow.IsActive'):
if self._system_monitor.waitForAbort(10):
break
self._print_slideshow_info()
if not self.cancel_operation() and KodiUtils.get_cond_visibility(
'Slideshow.IsActive'):
try:
self._slideshow(driveid, item_driveid, item_id, path,
change_token)
except Exception as e:
Logger.error(
'Slideshow failed to auto refresh. Will be restarted when possible. Error: '
)
Logger.error(ExceptionUtils.full_stacktrace(e))
self._refresh_slideshow(driveid, item_driveid, item_id, path,
None, wait_for_slideshow)
else:
Logger.notice(
'Slideshow is not running anymore or abort requested.')
def search(self, query, driveid, item_driveid=None, item_id=None, on_items_page_completed=None):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
url = '/drives/'
if item_id:
url += item_driveid+'/items/' + item_id
else:
url += driveid
url += '/search(q=\''+urllib.quote(query)+'\')'
self._extra_parameters['filter'] = 'file ne null'
files = self._provider.get(url, parameters = self._extra_parameters)
if self.cancel_operation():
return
return self.process_files(driveid, files, on_items_page_completed)
def get_item(self,
driveid,
item_driveid=None,
item_id=None,
path=None,
find_subtitles=False,
include_download_info=False):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
cache_key = self._addonid + '-drive-' + driveid + '-item_driveid-' + Utils.str(
item_driveid) + '-item_id-' + Utils.str(
item_id) + '-path-' + Utils.str(path)
f = self._cache.get(cache_key)
if not f:
if item_id:
path = item_id
elif path == '/':
path = ''
self._parameters['path'] = path
f = self._provider.post('/files/get_metadata',
parameters=self._parameters,
headers=self._headers)
self._cache.set(cache_key,
f,
expiration=datetime.timedelta(seconds=59))
item = self._extract_item(f, driveid, include_download_info)
if find_subtitles:
subtitles = []
parent_path = Utils.get_parent_path(item['path_lower'])
if parent_path == '/':
parent_path = ''
self._parameters['path'] = parent_path
self._parameters['query'] = urllib.quote(
Utils.remove_extension(item['name']))
self._parameters['mode'] = 'filename'
del self._parameters['include_media_info']
files = self._provider.post('/files/search',
parameters=self._parameters,
headers=self._headers)
for f in files['matches']:
subtitle = self._extract_item(f['metadata'], driveid,
include_download_info)
if subtitle['name_extension'] == 'srt' or subtitle[
'name_extension'] == 'sub' or subtitle[
'name_extension'] == 'sbv':
subtitles.append(subtitle)
if subtitles:
item['subtitles'] = subtitles
Logger.notice(item)
return item
def get_subtitles(self, driveid, path):
item = self.get_item(driveid, path)
key = '%s%s-subtitles' % (driveid, path,)
Logger.debug('Testing subtitles from cache: %s' % key)
subtitles = self._items_cache.get(key)
if not subtitles:
provider = self._get_provider()
provider.configure(self._account_manager, driveid)
self.is_path_possible(driveid, path)
item_driveid = Utils.default(Utils.get_safe_value(item, 'drive_id'), driveid)
subtitles = provider.get_subtitles(item['parent'], item['name'], item_driveid)
Logger.debug('Saving subtitles in cache: %s' % key)
self._items_cache.set(key, item)
return subtitles
def __init__(self, *args, **kwargs):
self._common_addon = KodiUtils.get_common_addon()
self._dialog = xbmcgui.Dialog()
self.canceled = False
self._schedule_types = [
ExportScheduleDialog._startup_type, self._daily_type, 17, 11, 12,
13, 14, 15, 16
]
self._schedule_ats = []
for hour in range(0, 24):
self._schedule_ats.append('%02d:00' % hour)
self.schedule = Utils.default(kwargs["schedule"], {
'type': self._daily_type,
'at': self._schedule_ats[0]
})
def __export_folder(self, driveid, folder, export_folder, export, items_info, root_id):
folder_id = Utils.str(folder['id'])
folder_name = Utils.unicode(folder['name'])
folder_path = os.path.join(os.path.join(export_folder, folder_name), '')
if not xbmcvfs.exists(folder_path):
try:
xbmcvfs.mkdirs(folder_path)
except:
if self._system_monitor.waitForAbort(3):
return
xbmcvfs.mkdirs(folder_path)
items = self.get_provider().get_folder_items(Utils.default(Utils.get_safe_value(folder, 'drive_id'), driveid), folder['id'])
if self.cancel_operation():
return
for item in items:
if 'folder' in item:
if self._child_count_supported:
self._exporting_target += int(item['folder']['child_count'])
else:
self._exporting_target += 1
for item in items:
is_folder = 'folder' in item
item_id = Utils.str(item['id'])
item_name = Utils.unicode(item['name'])
item_name_extension = item['name_extension']
file_path = os.path.join(folder_path, item_name)
if is_folder:
ExportManager.add_item_info(items_info, item_id, item_name, os.path.join(file_path, ''), folder_id,'folder')
self.__export_folder(driveid, item, folder_path, export, items_info, root_id)
elif (('video' in item or item_name_extension in self._video_file_extensions) and export['content_type'] == 'video') or ('audio' in item and export['content_type'] == 'audio'):
item_name += ExportManager._strm_extension
file_path += ExportManager._strm_extension
if self._addon.getSetting('skip_unmodified') and KodiUtils.file_exists(file_path) and KodiUtils.file(file_path).size() == item["size"]:
continue
ExportManager.create_strm(driveid, item, file_path, export['content_type'], self._addon_url)
ExportManager.add_item_info(items_info, item_id, item_name, file_path, folder_id,'file')
elif 'nfo_export' in export and export['nfo_export'] and ('nfo' in item_name_extension or 'text/x-nfo' in item.get("mimetype")):
nfo_path = os.path.join(folder_path, Utils.unicode(item_name))
if self._addon.getSetting('skip_unmodified') and KodiUtils.file_exists(nfo_path) and KodiUtils.file(nfo_path).size() == item["size"]:
continue
ExportManager.create_nfo(item_id, export["item_driveid"], nfo_path, self.get_provider())
ExportManager.add_item_info(items_info, item_id, item_name, nfo_path, folder_id,'file')
self._export_manager.save_items_info(root_id, items_info)
self._exporting_count += 1
p = int(self._exporting_count/float(self._exporting_target)*100)
if self._exporting_percent < p:
self._exporting_percent = p
self._export_progress_dialog_bg.update(self._exporting_percent, self._addon_name + ' ' + self._common_addon.getLocalizedString(32024), file_path[len(export['destination_folder']):])
def search(self,
query,
item_driveid=None,
item_id=None,
on_items_page_completed=None):
item_driveid = Utils.default(item_driveid, self._driveid)
parameters = copy.deepcopy(self._default_parameters)
parameters['fields'] = 'files(%s)' % self._file_fileds
query = 'fullText contains \'%s\'' % Utils.str(query)
if item_id:
query += ' and \'%s\' in parents' % item_id
parameters['q'] = query + ' and not trashed'
files = self.get('/files', parameters=parameters)
if self.cancel_operation():
return
return self.process_files(files, parameters, on_items_page_completed)
def create_strm(driveid, item, file_path, content_type, addon_url):
item_id = Utils.str(item['id'])
item_drive_id = Utils.default(Utils.get_safe_value(item, 'drive_id'), driveid)
f = None
try:
f = KodiUtils.file(file_path, 'w')
content = addon_url + '?' + urllib.urlencode({'action':'play', 'content_type': content_type, 'item_driveid': item_drive_id, 'item_id': item_id, 'driveid': driveid})
if item['name_extension'] == 'strm':
content = Request(item['download_info']['url'], None).request()
f.write(content)
except:
return False
finally:
if f:
f.close()
return True
def get_item(self, item_driveid=None, item_id=None, path=None, find_subtitles=False, include_download_info=False):
parameters = self.prepare_parameters()
item_driveid = Utils.default(item_driveid, self._driveid)
parameters['fields'] = self._get_field_parameters()
if not item_id and path == '/':
item_id = 'root'
if item_id:
f = self.get('/files/%s' % item_id, parameters = parameters)
item = self._extract_item(f, include_download_info)
else:
item = self.get_item_by_path(path, include_download_info)
if find_subtitles:
subtitles = self.get_subtitles(item['parent'], item['name'], item_driveid, include_download_info)
if subtitles:
item['subtitles'] = subtitles
return item
def get_subtitles(self,
parent,
name,
item_driveid=None,
include_download_info=False):
item_driveid = Utils.default(item_driveid, self._driveid)
subtitles = []
search_url = '/drives/' + item_driveid + '/items/' + parent + '/search(q=\'' + urllib.quote(
Utils.str(Utils.remove_extension(name)).replace("'", "''")) + '\')'
files = self.get(search_url)
for f in files['value']:
subtitle = self._extract_item(f, include_download_info)
if subtitle['name_extension'].lower() in ('srt', 'idx', 'sub',
'sbv', 'ass', 'ssa',
'smi'):
subtitles.append(subtitle)
return subtitles
def search(self,
query,
driveid,
item_driveid=None,
item_id=None,
on_items_page_completed=None):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
self._parameters['fields'] = 'files(%s)' % self._file_fileds
query = 'fullText contains \'%s\'' % Utils.str(query)
if item_id:
query += ' and \'%s\' in parents' % item_id
self._parameters['q'] = query
files = self._provider.get('/files', parameters=self._parameters)
if self.cancel_operation():
return
return self.process_files(driveid, files, on_items_page_completed)
def get_bookmarks(self,
parent,
name,
item_driveid=None,
include_download_info=False):
parameters = self.prepare_parameters()
item_driveid = Utils.default(item_driveid, self._driveid)
bookmarks = []
parameters['fields'] = 'files(' + self._get_field_parameters() + ')'
parameters['q'] = 'name contains \'%s\'' % Utils.str(
Utils.remove_extension(name)).replace("'", "\\'")
files = self.get('/files', parameters=parameters)
for f in files['files']:
bookmark = self._extract_item(f, include_download_info)
if bookmark['name_extension'].lower() in ('jpg', 'png'):
bookmarks.append(bookmark)
return bookmarks
def search(self,
query,
item_driveid=None,
item_id=None,
on_items_page_completed=None):
item_driveid = Utils.default(item_driveid, self._driveid)
url = '/drives/'
if item_id:
url += item_driveid + '/items/' + item_id
else:
url += self._driveid
url += '/search(q=\'' + urllib.quote(Utils.str(query)) + '\')'
self._extra_parameters['filter'] = 'file ne null'
files = self.get(url, parameters=self._extra_parameters)
if self.cancel_operation():
return
return self.process_files(files, on_items_page_completed)
def get_folder_items(self, driveid, item_driveid=None, item_id=None, path=None, on_items_page_completed=None):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
if item_id:
files = self._provider.get('/drives/'+item_driveid+'/items/' + item_id + '/children', parameters = self._extra_parameters)
elif path == 'sharedWithMe' or path == 'recent':
files = self._provider.get('/drives/'+driveid+'/' + path)
else:
if path == '/':
path = 'root'
else:
parts = path.split('/')
if len(parts) > 1 and not parts[0]:
path = 'root:'+path+':'
files = self._provider.get('/drives/'+driveid+'/' + path + '/children', parameters = self._extra_parameters)
if self.cancel_operation():
return
return self.process_files(driveid, files, on_items_page_completed)
def get_folder_items(self, driveid, item_driveid=None, item_id=None, path=None, on_items_page_completed=None):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
self._parameters['fields'] = 'files(%s),nextPageToken' % self._file_fileds
if item_id:
self._parameters['q'] = '\'%s\' in parents' % item_id
elif path == 'sharedWithMe' or path == 'starred':
self._parameters['q'] = path
elif path == 'photos':
self._parameters['spaces'] = path
else:
if path == '/':
self._parameters['q'] = '\'root\' in parents'
else:
item = self.get_item_by_path(path)
self._parameters['q'] = '\'%s\' in parents' % item['id']
files = self._provider.get('/files', parameters = self._parameters)
if self.cancel_operation():
return
return self.process_files(driveid, files, on_items_page_completed)
def get_folder_items(self, driveid, item_driveid=None, item_id=None, path=None, on_items_page_completed=None):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
self._parameters['fields'] = 'files(%s),nextPageToken' % self._file_fileds
if item_id:
self._parameters['q'] = '\'%s\' in parents' % item_id
elif path == 'sharedWithMe' or path == 'starred':
self._parameters['q'] = path
elif path == 'photos':
self._parameters['spaces'] = path
else:
if path == '/':
self._parameters['q'] = '\'root\' in parents'
else:
item = self.get_item_by_path(path)
self._parameters['q'] = '\'%s\' in parents' % item['id']
files = self._provider.get('/files', parameters = self._parameters)
if self.cancel_operation():
return
return self.process_files(driveid, files, on_items_page_completed)
def import_bookmarks(self, driveid, item_driveid=None, item_id=None):
self._provider.configure(self._account_manager, driveid)
# self._progress_dialog.update(0, '')
# color = 'lime'
# ban = self._common_addon.getLocalizedString(32013)
item = self._provider.get_item(item_driveid=item_driveid,
item_id=item_id,
find_bookmarks=True,
include_download_info=True)
bookmarks = []
for bookmark in item['bookmarks']:
bookmarks.append(
self._get_item_play_url(
urllib.quote(Utils.str(bookmark['name'])), driveid,
Utils.default(Utils.get_safe_value(bookmark, 'drive_id'),
driveid), bookmark['id'], True))
url = bookmark['download_info']['url']
request_params = {
'on_complete':
lambda request: self.save_bookmark_image(request.response_text
),
}
request = self._provider.prepare_request('get', url)
response = request.request()
if request.response_code == 403 or request.response_code == 429:
color = 'red'
ban = self._common_addon.getLocalizedString(32033)
else:
self.save_bookmark_image(response, bookmark["name"])
item_path = 'plugin://plugin.googledrive/?item_id=%s&driveid=%s&item_driveid=%s&action=play&content_type=video' % (
item_id, driveid, item_driveid)
p = {
'mode': 'import_image',
'item_label': item["name"],
'image_name': bookmark["name"],
'item_path': item_path,
}
addon_id = 'context.item.savebookmarks'
KodiUtils.run_plugin(addon_id, p)
def write_response(self, code, message=None, content=None, headers=None):
headers = Utils.default(headers, {})
length = 0
self.send_response(code, message)
if content:
length = content.tell()
content.seek(0)
self.send_header('Content-Type', self.content_type)
self.send_header('Content-Length', length)
self.send_header('Connection', 'close')
request_id = self.headers.getheader('request-id')
if request_id:
self.send_header('request-id', request_id)
for key in headers:
self.send_header(key, headers[key])
self.end_headers()
if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
if content:
shutil.copyfileobj(content, self.wfile)
content.close()
Logger.debug('[%s] response code: %s, length: %s' % (request_id, code, length))
def get_subtitles(self):
try:
from clouddrive.common.remote.request import Request
from clouddrive.common.service.download import DownloadServiceUtil
response = Request(self.getPlayingFile() + '?subtitles',
None).request_json()
if response and 'driveid' in response and 'subtitles' in response:
driveid = response['driveid']
subtitles = response['subtitles']
for subtitle in subtitles:
url = DownloadServiceUtil.build_download_url(
driveid,
Utils.default(
Utils.get_safe_value(subtitle, 'drive_id'),
driveid), subtitle['id'],
urllib.quote(Utils.str(subtitle['name'])))
Logger.debug('subtitle: %s' % url)
self.setSubtitles(url)
except Exception as e:
Logger.error(e)
from clouddrive.common.remote.errorreport import ErrorReport
ErrorReport.handle_exception(e)
def get_folder_items(self,
driveid,
item_driveid=None,
item_id=None,
path=None,
on_items_page_completed=None):
self._provider.configure(self._account_manager, driveid)
item_driveid = Utils.default(item_driveid, driveid)
url = '/files/list_folder'
continue_url = '/list_folder/continue'
if item_id:
self._parameters['path'] = item_id
elif path == 'sharedWithMe':
continue_url = url = '/sharing/list_shared_links'
del self._parameters['include_media_info']
elif path == '/':
self._parameters['path'] = ''
files = self._provider.post(url,
parameters=self._parameters,
headers=self._headers)
if self.cancel_operation():
return
return self.process_files(driveid, files, continue_url,
on_items_page_completed)
def get_item(self, item_driveid=None, item_id=None, path=None, find_subtitles=False, include_download_info=False):
parameters = self.prepare_parameters()
item_driveid = Utils.default(item_driveid, self._driveid)
parameters['fields'] = self._get_field_parameters()
if not item_id and path == '/':
item_id = 'root'
if item_id:
f = self.get('/files/%s' % item_id, parameters = parameters)
item = self._extract_item(f, include_download_info)
else:
item = self.get_item_by_path(path, include_download_info)
if find_subtitles:
subtitles = []
parameters['fields'] = 'files(' + self._get_field_parameters() + ')'
parameters['q'] = 'name contains \'%s\'' % Utils.str(Utils.remove_extension(item['name'])).replace("'","\\'")
files = self.get('/files', parameters = parameters)
for f in files['files']:
subtitle = self._extract_item(f, include_download_info)
if subtitle['name_extension'] == 'srt' or subtitle['name_extension'] == 'sub' or subtitle['name_extension'] == 'sbv':
subtitles.append(subtitle)
if subtitles:
item['subtitles'] = subtitles
return item
def play(self, driveid, item_driveid=None, item_id=None):
self.get_provider().configure(self._account_manager, driveid)
find_subtitles = self._addon.getSetting('set_subtitle') == 'true' and self._content_type == 'video'
item = self.get_provider().get_item(item_driveid, item_id, find_subtitles=find_subtitles)
file_name = Utils.unicode(item['name'])
list_item = xbmcgui.ListItem(file_name)
succeeded = True
info = KodiUtils.get_current_library_info()
if not info:
info = KodiUtils.find_exported_video_in_library(item_id, file_name + ExportManager._strm_extension)
if info and info['id']:
Logger.debug('library info: %s' % Utils.str(info))
KodiUtils.set_home_property('dbid', Utils.str(info['id']))
KodiUtils.set_home_property('dbtype', info['type'])
KodiUtils.set_home_property('addonid', self._addonid)
details = KodiUtils.get_video_details(info['type'], info['id'])
Logger.debug('library details: %s' % Utils.str(details))
if details and 'resume' in details:
KodiUtils.set_home_property('playcount', Utils.str(details['playcount']))
resume = details['resume']
if resume['position'] > 0:
play_resume = False
if self.iskrypton:
play_resume = KodiUtils.get_addon_setting('resume_playing') == 'true'
elif KodiUtils.get_addon_setting('ask_resume') == 'true':
d = datetime(1,1,1) + timedelta(seconds=resume['position'])
t = '%02d:%02d:%02d' % (d.hour, d.minute, d.second)
Logger.debug(t)
option = self._dialog.contextmenu([KodiUtils.localize(32054, addon=self._common_addon) % t, KodiUtils.localize(12021)])
Logger.debug('selected option: %d' % option)
if option == -1:
succeeded = False
elif option == 0:
play_resume = True
if play_resume:
list_item.setProperty('resumetime', Utils.str(resume['position']))
list_item.setProperty('startoffset', Utils.str(resume['position']))
list_item.setProperty('totaltime', Utils.str(resume['total']))
else:
from clouddrive.common.service.player import KodiPlayer
KodiPlayer.cleanup()
if 'audio' in item:
list_item.setInfo('music', item['audio'])
elif 'video' in item:
list_item.addStreamInfo('video', item['video'])
list_item.select(True)
list_item.setPath(self._get_item_play_url(file_name, driveid, item_driveid, item_id))
list_item.setProperty('mimetype', Utils.get_safe_value(item, 'mimetype'))
if find_subtitles and 'subtitles' in item:
subtitles = []
for subtitle in item['subtitles']:
subtitles.append(self._get_item_play_url(urllib.quote(Utils.str(subtitle['name'])), driveid, Utils.default(Utils.get_safe_value(subtitle, 'drive_id'), driveid), subtitle['id'], True))
list_item.setSubtitles(subtitles)
if not self.cancel_operation():
xbmcplugin.setResolvedUrl(self._addon_handle, succeeded, list_item)
def _process_items(self, items, driveid):
listing = []
for item in items:
item_id = item['id']
item_name = Utils.unicode(item['name'])
item_name_extension = item['name_extension']
item_driveid = Utils.default(Utils.get_safe_value(item, 'drive_id'), driveid)
list_item = xbmcgui.ListItem(item_name)
url = None
is_folder = 'folder' in item
params = {'content_type': self._content_type, 'item_driveid': item_driveid, 'item_id': item_id, 'driveid': driveid}
if 'extra_params' in item:
params.update(item['extra_params'])
context_options = []
info = {'size': item['size'], 'date': KodiUtils.to_kodi_item_date_str(KodiUtils.to_datetime(Utils.get_safe_value(item, 'last_modified_date')))}
if is_folder:
params['action'] = '_list_folder'
url = self._addon_url + '?' + urllib.urlencode(params)
params['action'] = '_search'
cmd = 'ActivateWindow(%d,%s?%s)' % (xbmcgui.getCurrentWindowId(), self._addon_url, urllib.urlencode(params))
context_options.append((self._common_addon.getLocalizedString(32039), cmd))
if self._content_type == 'audio' or self._content_type == 'video':
params['action'] = '_open_export'
params['name'] = urllib.quote(Utils.str(item_name))
context_options.append((self._common_addon.getLocalizedString(32004), 'RunPlugin('+self._addon_url + '?' + urllib.urlencode(params)+')'))
del params['name']
elif self._content_type == 'image' and self._auto_refreshed_slideshow_supported:
params['action'] = '_slideshow'
context_options.append((self._common_addon.getLocalizedString(32032), 'RunPlugin('+self._addon_url + '?' + urllib.urlencode(params)+')'))
elif (('video' in item or item_name_extension in self._video_file_extensions) and self._content_type == 'video') or (('audio' in item or item_name_extension in self._audio_file_extensions) and self._content_type == 'audio'):
list_item.setProperty('IsPlayable', 'true')
params['action'] = 'play'
url = self._addon_url + '?' + urllib.urlencode(params)
info_type = self._content_type
if 'audio' in item:
info.update(item['audio'])
info_type = 'music'
elif 'video' in item:
list_item.addStreamInfo('video', item['video'])
list_item.setInfo(info_type, info)
if 'thumbnail' in item:
list_item.setArt({'icon': item['thumbnail'], 'thumb': item['thumbnail']})
elif ('image' in item or item_name_extension in self._image_file_extensions) and self._content_type == 'image' and item_name_extension != 'mp4':
if 'url' in item:
url = item['url']
else:
url = self._get_item_play_url(urllib.quote(Utils.str(item_name)), driveid, item_driveid, item_id)
if 'image' in item:
info.update(item['image'])
list_item.setInfo('pictures', info)
if 'thumbnail' in item and item['thumbnail']:
list_item.setArt({'icon': item['thumbnail'], 'thumb': item['thumbnail']})
if url:
context_options.extend(self.get_context_options(list_item, params, is_folder))
list_item.addContextMenuItems(context_options)
mimetype = Utils.default(Utils.get_mimetype_by_extension(item_name_extension), Utils.get_safe_value(item, 'mimetype'))
if mimetype:
list_item.setProperty('mimetype', mimetype)
listing.append((url, list_item, is_folder))
xbmcplugin.addDirectoryItems(self._addon_handle, listing, len(listing))
xbmcplugin.endOfDirectory(self._addon_handle, True)
def get_response_text_as_json(self):
return json.loads(
Utils.default(self.response_text, self._DEFAULT_RESPONSE))
def request_json(self):
return json.loads(Utils.default(self.request(),
self._DEFAULT_RESPONSE))
