void FrameLoaderClient::dispatchDidCommitLoad()
{
/* Update the URI once first data has been received.
* This means the URI is valid and successfully identify the page that's going to be loaded.
*/
g_object_freeze_notify(G_OBJECT(m_frame));
WebKitWebFramePrivate* priv = m_frame->priv;
g_free(priv->uri);
priv->uri = g_strdup(core(m_frame)->loader()->url().prettyURL().utf8().data());
g_free(priv->title);
priv->title = NULL;
g_object_notify(G_OBJECT(m_frame), "uri");
g_object_notify(G_OBJECT(m_frame), "title");
g_signal_emit_by_name(m_frame, "load-committed");
notifyStatus(m_frame, WEBKIT_LOAD_COMMITTED);
WebKitWebView* webView = getViewFromFrame(m_frame);
if (m_frame == webkit_web_view_get_main_frame(webView)) {
g_object_freeze_notify(G_OBJECT(webView));
g_object_notify(G_OBJECT(webView), "uri");
g_object_notify(G_OBJECT(webView), "title");
g_object_thaw_notify(G_OBJECT(webView));
g_signal_emit_by_name(webView, "load-committed", m_frame);
}
g_object_thaw_notify(G_OBJECT(m_frame));
}
void FrameLoaderClient::dispatchDidFirstVisuallyNonEmptyLayout()
{
if (m_loadingErrorPage)
return;
notifyStatus(m_frame, WEBKIT_LOAD_FIRST_VISUALLY_NON_EMPTY_LAYOUT);
}
bool UnpublishSave(int saveID)
{
notifyStatus(String::Build("Unpublishing save [", saveID, "]"));
if (Client::Ref().UnpublishSave(saveID) != RequestOkay)
return false;
return true;
}
void FrameLoaderClient::dispatchDidStartProvisionalLoad()
{
if (m_loadingErrorPage)
return;
notifyStatus(m_frame, WEBKIT_LOAD_PROVISIONAL);
}
void
NetConnection_as::connect(const std::string& uri)
{
// Close any current connections. (why?) Because that's what happens.
close();
// TODO: check for other kind of invalidities here...
if ( uri.empty() )
{
_isConnected = false;
notifyStatus(CONNECT_FAILED);
return;
}
URL url(uri, getRunResources(owner()).baseURL());
if ((url.protocol() != "rtmp")
&& (url.protocol() != "rtmpt")
&& (url.protocol() != "rtmpts")
&& (url.protocol() != "https")
&& (url.protocol() != "http")) {
IF_VERBOSE_ASCODING_ERRORS(
log_aserror("NetConnection.connect(%s): invalid connection "
"protocol", url);
);
virtual bool doWork()
{
for(int i = 0; i < saves.size(); i++)
{
std::stringstream saveID;
saveID << "Unfavouring save [" << saves[i] << "] ...";
notifyStatus(saveID.str());
if(Client::Ref().FavouriteSave(saves[i], false)!=RequestOkay)
{
std::stringstream saveIDF;
saveIDF << "\boFailed to remove [" << saves[i] << "] ...";
notifyStatus(saveIDF.str());
}
notifyProgress((float(i+1)/float(saves.size())*100));
}
return true;
}
virtual bool doWork()
{
for(int i = 0; i < saves.size(); i++)
{
std::stringstream saveID;
saveID << "Hiding save [" << saves[i] << "] ...";
notifyStatus(saveID.str());
if(Client::Ref().UnpublishSave(saves[i])!=RequestOkay)
{
std::stringstream saveIDF;
saveIDF << "\boFailed to hide [" << saves[i] << "] ...";
notifyStatus(saveIDF.str());
}
notifyProgress((float(i+1)/float(saves.size())*100));
}
return true;
}
/// Called on NetConnection.connect(null).
//
/// The status notification happens immediately, isConnected becomes true.
void
NetConnection_as::connect()
{
// Close any current connections.
close();
_isConnected = true;
notifyStatus(CONNECT_SUCCESS);
}
bool Task::doWork()
{
notifyStatus("Fake progress");
for(int i = 0; i < 100; i++)
{
notifyProgress(i);
}
return true;
}
bool UnpublishSave(int saveID)
{
std::stringstream message;
message << "Unpublishing save [" << saveID << "]";
notifyStatus(message.str());
if (Client::Ref().UnpublishSave(saveID) != RequestOkay)
return false;
return true;
}
bool doWork() override
{
for (size_t i = 0; i < saves.size(); i++)
{
notifyStatus(String::Build("Deleting stamp [", saves[i].FromUtf8(), "] ..."));
Client::Ref().DeleteStamp(saves[i]);
notifyProgress((float(i+1)/float(saves.size())*100));
}
return true;
}
virtual bool doWork()
{
for(int i = 0; i < saves.size(); i++)
{
std::stringstream saveName;
saveName << "Deleting stamp [" << saves[i] << "] ...";
notifyStatus(saveName.str());
Client::Ref().DeleteStamp(saves[i]);
notifyProgress((float(i+1)/float(saves.size())*100));
}
return true;
}
void FrameLoaderClient::dispatchDidFailLoad(const ResourceError& error)
{
if (m_loadingErrorPage)
return;
notifyStatus(m_frame, WEBKIT_LOAD_FAILED);
WebKitWebView* webView = getViewFromFrame(m_frame);
GError* webError = g_error_new_literal(g_quark_from_string(error.domain().utf8().data()),
error.errorCode(),
error.localizedDescription().utf8().data());
gboolean isHandled = false;
g_signal_emit_by_name(webView, "load-error", m_frame, error.failingURL().utf8().data(), webError, &isHandled);
if (isHandled) {
g_error_free(webError);
return;
}
if (!shouldFallBack(error)) {
g_error_free(webError);
return;
}
m_loadingErrorPage = true;
String content;
gchar* fileContent = 0;
gchar* errorURI = g_filename_to_uri(DATA_DIR"/webkit-1.0/resources/error.html", NULL, NULL);
GFile* errorFile = g_file_new_for_uri(errorURI);
g_free(errorURI);
if (!errorFile)
content = makeString("<html><body>", webError->message, "</body></html>");
else {
gboolean loaded = g_file_load_contents(errorFile, 0, &fileContent, 0, 0, 0);
if (!loaded)
content = makeString("<html><body>", webError->message, "</body></html>");
else
content = String::format(fileContent, error.failingURL().utf8().data(), webError->message);
}
webkit_web_frame_load_alternate_string(m_frame, content.utf8().data(), 0, error.failingURL().utf8().data());
g_free(fileContent);
if (errorFile)
g_object_unref(errorFile);
g_error_free(webError);
}
bool doWork() override
{
for (size_t i = 0; i < saves.size(); i++)
{
notifyStatus(String::Build("Unfavouring save [", saves[i], "]"));
if (Client::Ref().FavouriteSave(saves[i], false)!=RequestOkay)
{
notifyError(String::Build("Failed to unfavourite [", saves[i], "]: " + Client::Ref().GetLastError()));
return false;
}
notifyProgress((float(i+1)/float(saves.size())*100));
}
return true;
}
bool doWork() override
{
for (size_t i = 0; i < saves.size(); i++)
{
notifyStatus(String::Build("Deleting save [", saves[i], "] ..."));
if (Client::Ref().DeleteSave(saves[i])!=RequestOkay)
{
notifyError(String::Build("Failed to delete [", saves[i], "]: ", Client::Ref().GetLastError()));
c->Refresh();
return false;
}
notifyProgress((float(i+1)/float(saves.size())*100));
}
c->Refresh();
return true;
}
virtual bool doWork()
{
for (size_t i = 0; i < saves.size(); i++)
{
std::stringstream saveID;
saveID << "Unfavouring save [" << saves[i] << "]";
notifyStatus(saveID.str());
if (Client::Ref().FavouriteSave(saves[i], false)!=RequestOkay)
{
std::stringstream saveIDF;
saveIDF << "Failed to unfavourite [" << saves[i] << "]: " + Client::Ref().GetLastError();
notifyError(saveIDF.str());
return false;
}
notifyProgress((float(i+1)/float(saves.size())*100));
}
return true;
}
virtual bool doWork()
{
for (size_t i = 0; i < saves.size(); i++)
{
std::stringstream saveID;
saveID << "Deleting save [" << saves[i] << "] ...";
notifyStatus(saveID.str());
if (Client::Ref().DeleteSave(saves[i])!=RequestOkay)
{
std::stringstream saveIDF;
saveIDF << "Failed to delete [" << saves[i] << "]: " << Client::Ref().GetLastError();
notifyError(saveIDF.str());
c->Refresh();
return false;
}
notifyProgress((float(i+1)/float(saves.size())*100));
}
c->Refresh();
return true;
}
//--------------------------------------------------
// Event handlers
void AacBqToPcmCbRenderer::onPrepare() {
SL_LOGD("AacBqToPcmCbRenderer::onPrepare()");
Mutex::Autolock _l(mBufferSourceLock);
// Initialize the PCM format info with the known parameters before the start of the decode
{
android::Mutex::Autolock autoLock(mPcmFormatLock);
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_BITSPERSAMPLE] = SL_PCMSAMPLEFORMAT_FIXED_16;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CONTAINERSIZE] = 16;
//FIXME not true on all platforms
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_ENDIANNESS] = SL_BYTEORDER_LITTLEENDIAN;
// initialization with the default values: they will be replaced by the actual values
// once the decoder has figured them out
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS] = UNKNOWN_NUMCHANNELS;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE] = UNKNOWN_SAMPLERATE;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CHANNELMASK] = SL_ANDROID_UNKNOWN_CHANNELMASK;
}
sp<MediaExtractor> extractor = new AacAdtsExtractor(mBqSource);
// only decoding a single track of data
const size_t kTrackToDecode = 0;
sp<IMediaSource> source = extractor->getTrack(kTrackToDecode);
if (source == 0) {
SL_LOGE("AacBqToPcmCbRenderer::onPrepare: error getting source from extractor");
notifyPrepared(ERROR_UNSUPPORTED);
return;
}
// the audio content is not raw PCM, so we need a decoder
source = SimpleDecodingSource::Create(source);
if (source == NULL) {
SL_LOGE("AacBqToPcmCbRenderer::onPrepare: Could not instantiate decoder.");
notifyPrepared(ERROR_UNSUPPORTED);
return;
}
sp<MetaData> meta = source->getFormat();
SL_LOGD("AacBqToPcmCbRenderer::onPrepare() after instantiating decoder");
if (source->start() != OK) {
SL_LOGE("AacBqToPcmCbRenderer::onPrepare() Failed to start source/decoder.");
notifyPrepared(MEDIA_ERROR_BASE);
return;
}
//---------------------------------
int32_t channelCount;
CHECK(meta->findInt32(kKeyChannelCount, &channelCount));
int32_t sr;
CHECK(meta->findInt32(kKeySampleRate, &sr));
// FIXME similar to AudioSfDecoder::onPrepare()
// already "good to go" (compare to AudioSfDecoder::onPrepare)
mCacheStatus = kStatusHigh;
mCacheFill = 1000;
notifyStatus();
notifyCacheFill();
{
android::Mutex::Autolock autoLock(mPcmFormatLock);
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE] = sr;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS] = channelCount;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CHANNELMASK] =
sles_channel_out_mask_from_count(channelCount);
}
SL_LOGV("AacBqToPcmCbRenderer::onPrepare() channel count=%d SR=%d",
channelCount, sr);
//---------------------------------
// The data source, and audio source (a decoder) are ready to be used
mDataSource = mBqSource;
mAudioSource = source;
mAudioSourceStarted = true;
//-------------------------------------
// signal successful completion of prepare
mStateFlags |= kFlagPrepared;
// skipping past AudioToCbRenderer and AudioSfDecoder
GenericPlayer::onPrepare();
SL_LOGD("AacBqToPcmCbRenderer::onPrepare() done, mStateFlags=0x%x", mStateFlags);
}
void FrameLoaderClient::dispatchDidFinishLoad()
{
g_signal_emit_by_name(m_frame, "load-done", true);
notifyStatus(m_frame, WEBKIT_LOAD_FINISHED);
}
void FrameLoaderClient::dispatchDidStartProvisionalLoad()
{
notifyStatus(m_frame, WEBKIT_LOAD_PROVISIONAL);
}
static void loadDone(WebKitWebFrame* frame, bool didSucceed)
{
// FIXME: load-done is deprecated. Please remove when signal's been removed.
g_signal_emit_by_name(frame, "load-done", didSucceed);
notifyStatus(frame, WEBKIT_LOAD_FINISHED);
}
