C++ JSObjectPtr::InvokeAsync方法代码示例

void FileManagerAPI::exists(std::string const &url, FB::JSObjectPtr const &callback) {
	FBLOG_DEBUG("FileManagerAPI::exists", "this=" << this << "\t" << "url=" << url << "\t" << "callback=" << callback);
	FB::URI uri(url);
	if(!FileManagerAPI::isFile(uri)) {
		FBLOG_DEBUG("FileManagerAPI::exists", "Can't check Remote resource");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't check Remote resource"));
		return;
	}
	try {
		std::string pathStr = uriToFile(uri);
		if(pathStr.empty()) {
			FBLOG_DEBUG("FileManagerAPI::exists", "Invalid path");
			callback->InvokeAsync("", FB::variant_list_of(false)("Invalid path"));
			return;
		}
		boost::filesystem::path path(pathStr);
		
		FBLOG_DEBUG("FileManagerAPI::exists", "Test \"" << pathStr << "\"");
		bool b = boost::filesystem::exists(path);
		callback->InvokeAsync("", FB::variant_list_of(b)(""));
	} catch(boost::filesystem::filesystem_error &) {
		FBLOG_DEBUG("FileManagerAPI::exists", "Internal error");
		callback->InvokeAsync("", FB::variant_list_of(false)("Internal error"));
	}
}

void btlauncherAPI::gotDownloadProgram(const FB::JSObjectPtr& callback, 
									   std::wstring& program,
									   std::string& version,
									   bool success,
									   const FB::HeaderMap& headers,
									   const boost::shared_array<uint8_t>& data,
									   const size_t size) {
	TCHAR temppath[500];
	DWORD gettempresult = GetTempPath(500, temppath);
	if (! gettempresult) {
		callback->InvokeAsync("", FB::variant_list_of(false)("GetTempPath")(GetLastError()));
		return;
	}
	std::wstring syspath(temppath);
	syspath.append( program.c_str() );
	boost::uuids::random_generator gen;
	boost::uuids::uuid u = gen();
	syspath.append( _T("_") );
	std::wstring wversion;
	wversion.assign( version.begin(), version.end() );
	syspath.append( wversion );
	syspath.append( _T("_") );
	syspath.append( boost::uuids::to_wstring(u) );
	syspath.append(_T(".exe"));

	HANDLE hFile = CreateFile( syspath.c_str(), GENERIC_WRITE | GENERIC_EXECUTE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, NULL, NULL );
	if (hFile == INVALID_HANDLE_VALUE) {
		
		callback->InvokeAsync("", FB::variant_list_of(false)(GetLastError()));
		return;
	}
	PVOID ptr = (VOID*) data.get();
	DWORD written = 0;
	BOOL RESULT = WriteFile( hFile, ptr, size, &written, NULL);
	CloseHandle(hFile);
	
	if (! RESULT) {
		callback->InvokeAsync("", FB::variant_list_of("FILE")(false)(GetLastError()));
		return;
	}
	std::wstring installcommand = std::wstring(syspath);
	installcommand.append(_T(" /NOINSTALL /MINIMIZED /HIDE"));
	STARTUPINFO info;
	PROCESS_INFORMATION procinfo;
	memset(&info,0,sizeof(info));
	info.cb = sizeof(STARTUPINFO);
	 
	/* CreateProcessW can modify installcommand thus we allocate needed memory */ 
	wchar_t * pwszParam = new wchar_t[installcommand.size() + 1]; 
	const wchar_t* pchrTemp = installcommand.c_str(); 
    wcscpy_s(pwszParam, installcommand.size() + 1, pchrTemp); 

	BOOL bProc = CreateProcess(NULL, pwszParam, NULL, NULL, FALSE, 0, NULL, NULL, &info, &procinfo);
	if(bProc) {
		callback->InvokeAsync("", FB::variant_list_of("PROCESS")(true)(installcommand.c_str())(GetLastError()));
	} else {
		callback->InvokeAsync("", FB::variant_list_of("PROCESS")(false)(installcommand.c_str())(GetLastError()));
	}

}

FileTransferAPIPtr FileManagerAPI::copy(std::string const &sourceUrl, std::string const &targetUrl, FB::JSObjectPtr const &callback) {
	FBLOG_DEBUG("FileManagerAPI::copy", "this=" << this << "\t" << "sourceUrl=" << sourceUrl << "\t" << "targetUrl=" << targetUrl << "\t" << "callback=" << callback);
	FB::URI sourceUri(sourceUrl);
	FB::URI targetUri(targetUrl);
	if(FileManagerAPI::isHttp(sourceUri) && FileManagerAPI::isHttp(targetUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't copy two Remote resources");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't copy two Remote resources"));
		return FileTransferAPIPtr();
	}
	if(FileManagerAPI::isInternal(targetUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't copy file into Internal resources");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't copy file into Internal resources"));
		return FileTransferAPIPtr();
	}
	if(FileManagerAPI::isHttp(sourceUri) && !isSameHost(sourceUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't use different host with remote resource (XSS)");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't use different host with remote resource (XSS)"));
		return FileTransferAPIPtr();
	}
	if(FileManagerAPI::isHttp(targetUri) && !isSameHost(targetUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't use different host with remote resource (XSS)");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't use different host with remote resource (XSS)"));
		return FileTransferAPIPtr();
	}
	FileTransferAPIPtr fileTransfer = getFactory()->getFileTransfer(sourceUri, targetUri, callback);
	return fileTransfer;
}

void FBTestPluginAPI::getURLCallback(const FB::JSObjectPtr& callback, bool success,
    const FB::HeaderMap& headers, const boost::shared_array<uint8_t>& data, const size_t size) {
    FB::VariantMap outHeaders;
    for (FB::HeaderMap::const_iterator it = headers.begin(); it != headers.end(); ++it) {
        if (headers.count(it->first) > 1) {
            if (outHeaders.find(it->first) != outHeaders.end()) {
                outHeaders[it->first].cast<FB::VariantList>().push_back(it->second);
            } else {
                outHeaders[it->first] = FB::VariantList(FB::variant_list_of(it->second));
            }
        } else {
            outHeaders[it->first] = it->second;
        }
    }
    if (success) {
        std::string dstr(reinterpret_cast<const char*>(data.get()), size);
        callback->InvokeAsync("", FB::variant_list_of
            (true)
            (outHeaders)
            (dstr)
            );
    } else {
        callback->InvokeAsync("", FB::variant_list_of(false));
    }
}

void ibrowserAPI::installCallback(const char *operation, plist_t status, void *user_data) {
    char *xml_doc=NULL;
    uint32_t xml_length;
    
    Callback *cb = (Callback *)user_data;
    
    FB::JSObjectPtr pcb = cb->get("pcb");
    FB::JSObjectPtr scb = cb->get("scb");
    FB::JSObjectPtr ecb = cb->get("ecb");
    
    if(pcb)
    {
        plist_to_xml(status, &xml_doc, &xml_length);
        pcb->InvokeAsync("", FB::variant_list_of(xml_doc));
        free(xml_doc);
    }
    
    plist_dict_iter it = NULL;
	char* key = NULL;
    char*   s = NULL;
	plist_t subnode = NULL;
	plist_dict_new_iter(status, &it);
	plist_dict_next_item(status, it, &key, &subnode);
	while (subnode)
	{
		if(strcmp(key, "Error") == 0)
        {
            plist_get_string_val(subnode, &s);
            if(ecb)
                ecb->InvokeAsync("", FB::variant_list_of(s));
            
        }else if(strcmp(key, "Status") == 0){
            plist_get_string_val(subnode, &s);
            if(strcmp(s, "Complete") == 0){
                if(scb)
                    scb->InvokeAsync("", FB::variant_list_of(NULL));
            }
        }
		plist_dict_next_item(status, it, &key, &subnode);
        
	}

    if(key)
        free(key);
    if(s)
        free(s);
	free(it);
    return;
}

void GCPAPI::SetRemoteDescription(const FB::variant& action,
                                  const FB::variant& sdp,
                                  const FB::JSObjectPtr& succCb,
                                  const FB::JSObjectPtr& failCb)
{
    GoCast::RtcCenter* pCtr = GoCast::RtcCenter::Instance();
    m_onsetsdpsuccessCb = succCb;
    m_onsetsdpfailureCb = failCb;
    
    if(false == pCtr->Inited())
    {
        std::string msg = m_htmlId.convert_cast<std::string>();
        msg += ": Failed to init RtcCenter singleton...";
        FBLOG_ERROR_CUSTOM("GCPAPI::SetRemoteDescription", msg);
        
        if(NULL != failCb.get())
        {
            failCb->InvokeAsync("", FB::variant_list_of("RtcCenter init failed"));
        }
        return;
    }
    
    pCtr->SetRemoteDescription(m_htmlId.convert_cast<std::string>(),
                               m_pSetRemoteSDPObserver,
                               action.convert_cast<std::string>(),
                               sdp.convert_cast<std::string>());
}

FB::variant btlauncherAPI::runProgram(const std::string& program, const FB::JSObjectPtr& callback) {
	FBLOG_INFO("runProgram()", "START");
	string exe = this->installPath;
	if (program == "SoShare")
		exe += SOSHARE_EXE_PATH;
	else if (program == "Torque")
		exe += TORQUE_EXE_PATH;
	else
		exe += BTLIVE_EXE_PATH;
		
	FBLOG_INFO("runProgram()", exe.c_str());

	struct stat st;
	if (stat(exe.c_str(), &st) == -1 || !S_ISREG(st.st_mode)) {
		FBLOG_INFO("runProgram()", "stat check problem");
		callback->InvokeAsync("", FB::variant_list_of(false)(0));
		FBLOG_INFO("runProgram()", "END");
		return 0;
	}
	
	FB::VariantList list = isRunning(program);
	if (list.empty()) {
		switch(fork()) 
		{
			case -1: {
				perror("BTLauncher Run Program Fork");
				FBLOG_INFO("runProgram()", "fork - failure");
				break;
			}
			case 0: {
				FBLOG_INFO("runProgram()", "fork - child process");
				FBLOG_INFO("runProgram()", exe.c_str());
				execlp(exe.c_str(), exe.c_str(), NULL);
				FBLOG_INFO("runProgram()", "child process exit");
				exit(1);
			}
			default: {
				break;
			}
		}
	}
	callback->InvokeAsync("", FB::variant_list_of(true)(1));
	FBLOG_INFO("runProgram()", "END");
	return 0;
}

void btlauncherAPI::gotDownloadProgram(const FB::JSObjectPtr& callback, 
									   std::string& program,
									   bool success,
									   const FB::HeaderMap& headers,
									   const boost::shared_array<uint8_t>& data,
									   const size_t size) {
	FBLOG_INFO("gotDownloadProgram()", "START");
	FBLOG_INFO("gotDownloadProgram()", program.c_str());
	

	char *tmpname = strdup("/tmp/btlauncherXXXXXX");
	mkstemp(tmpname);
	ofstream f(tmpname);
	
	if (f.fail()) {
		FBLOG_INFO("gotDownloadProgram()", "f.fail");
		callback->InvokeAsync("", FB::variant_list_of(false)(-1));
		return;
	}
	f.write((char *)data.get(), size);
	f.close();
	
	std::string url;
	if (program == "SoShare")
		url = SOSHARE_DOWNLOAD_URL;
	else if (program == "Torque")
		url = TORQUE_DOWNLOAD_URL;
	else
		url = BTLIVE_DOWNLOAD_URL;
	
	FBLOG_INFO("gotDownloadProgram()", url.c_str());
	
	const char *tarFlags = "-xf";
	if (url.find(".gz") != std::string::npos)
		tarFlags = "-xzf";
	
	pid_t tarPid;
	int status;
	switch(tarPid = fork()) 
	{
		case -1:
			FBLOG_INFO("gotDownloadProgram()", "fork failed");
			break;
		case 0:
			FBLOG_INFO("gotDownloadProgram()", "running tar");
			execl("/usr/bin/tar", "tar", tarFlags, tmpname, "-C", this->installPath.c_str(), NULL);
			break;
		default:
			FBLOG_INFO("gotDownloadProgram()", "waitpid");
			waitpid(tarPid, &status, 0);
			break;
	}
	
	runProgram(program, callback);
	FBLOG_INFO("gotDownloadProgram()", "END");
}

void btlauncherAPI::gotCheckForUpdate(const FB::JSObjectPtr& callback,
                                   bool success,
                                   const FB::HeaderMap& header,
                                   const boost::shared_array<uint8_t>& data,
                                   const size_t size) {
	FBLOG_INFO("gotCheckForUpdate()", "START");
    
	char *tmpname = strdup("/tmp/btlauncherXXXXXX.pkg");
	mkstemp(tmpname);
	ofstream f(tmpname);
	
	if (f.fail()) {
		FBLOG_INFO("gotCheckForUpdate()", "f.fail");
		callback->InvokeAsync("", FB::variant_list_of(false)(-1));
		return;
	}
	f.write((char *)data.get(), size);
	f.close();
    
    switch(fork())
    {
        case -1: {
            FBLOG_INFO("gotCheckForUpdate()", "fork - failure");
            break;
        }
        case 0: {
            FBLOG_INFO("gotCheckForUpdate()", "fork - child process");
            FBLOG_INFO("gotCheckForUpdate()", tmpname);
            execlp("installer", "installer", "-pkg", tmpname, "-target", "CurrentUserHomeDirectory", NULL);
            FBLOG_INFO("gotCheckForUpdate()", "child process exit");
            exit(1);
        }
        default: {
            FBLOG_INFO("gotCheckForUpdate()", "fork - parent process");
            break;
        }
    }
    
    callback->InvokeAsync("", FB::variant_list_of(true)(1));
	FBLOG_INFO("gotCheckForUpdate()", "END");
}

FB::variant btlauncherAPI::runProgram(const std::wstring& program, const FB::JSObjectPtr& callback) {
	if (!this->isSupported(program)) {
		return _T(NOT_SUPPORTED_MESSAGE);
	}
	
	HINSTANCE ret = (HINSTANCE)0;
	if (isRunning(program).size() == 0) {
		ret = launch_program(program);
		callback->InvokeAsync("", FB::variant_list_of(false)(ret));
	}
	return ret;
}

void FileManagerAPI::mkdir(std::string const &url, FB::JSObjectPtr const &callback) {
	FBLOG_DEBUG("FileManagerAPI::mkdir", "this=" << this << "\t" << "url=" << url << "\t" << "callback=" << callback);
	FB::URI uri(url);
	try {
		if(!FileManagerAPI::isFile(uri)) {
			FBLOG_DEBUG("FileManagerAPI::mkdir", "Can't create Remote directories");
			callback->InvokeAsync("", FB::variant_list_of(false)("Can't create Remote directories"));
			return;
		}
		if(FileManagerAPI::isInternal(uri)) {
			FBLOG_DEBUG("FileManagerAPI::mkdir", "Can't create Internal directories");
			callback->InvokeAsync("", FB::variant_list_of(false)("Can't create Internal directories"));
			return;
		}
		std::string pathStr = uriToFile(uri);
		if(pathStr.empty()) {
			FBLOG_DEBUG("FileManagerAPI::mkdir", "Invalid path");
			callback->InvokeAsync("", FB::variant_list_of(false)("Invalid path"));
			return;
		}
		boost::filesystem::path path(pathStr);
		if(boost::filesystem::exists(path)) {
			FBLOG_DEBUG("FileManagerAPI::mkdir", "The path \"" << pathStr << "\" already exists");
			callback->InvokeAsync("", FB::variant_list_of(false)("Invalid file"));
			return;
		}
		
		FBLOG_DEBUG("FileManagerAPI::mkdir", "Make directories \"" << pathStr << "\"");
		boost::filesystem::create_directories(path);
		callback->InvokeAsync("", FB::variant_list_of(true)(""));
	} catch(boost::filesystem::filesystem_error &) {
		FBLOG_DEBUG("FileManagerAPI::mkdir", "Internal error");
		callback->InvokeAsync("", FB::variant_list_of(false)("Internal error"));
	}
}

void FileManagerAPI::remove(std::string const &url, FB::JSObjectPtr const &callback) {
	FBLOG_DEBUG("FileManagerAPI::remove", "this=" << this << "\t" << "url=" << url << "\t" << "callback=" << callback);
	FB::URI uri(url);
	try {
		if(!FileManagerAPI::isFile(uri)) {
			FBLOG_DEBUG("FileManagerAPI::remove", "Can't remove Remote resource");
			callback->InvokeAsync("", FB::variant_list_of(false)("Can't remove Remote resource"));
			return;
		}
		if(FileManagerAPI::isInternal(uri)) {
			FBLOG_DEBUG("FileManagerAPI::remove", "Can't remove Internal resource");
			callback->InvokeAsync("", FB::variant_list_of(false)("Can't remove Internal resource"));
			return;
		}
		std::string pathStr = uriToFile(uri);
		if(pathStr.empty()) {
			FBLOG_DEBUG("FileManagerAPI::remove", "Invalid path");
			callback->InvokeAsync("", FB::variant_list_of(false)("Invalid path"));
			return;
		}
		boost::filesystem::path path(pathStr);
		if(!boost::filesystem::exists(path)) {
			FBLOG_DEBUG("FileManagerAPI::remove", "The path \"" << pathStr << "\" doesn't exist");
			callback->InvokeAsync("", FB::variant_list_of(false)("Invalid file"));
			return;
		}
		
		FBLOG_DEBUG("FileManagerAPI::remove", "Remove \"" << pathStr << "\"");
		boost::filesystem::remove_all(path);
		callback->InvokeAsync("", FB::variant_list_of(true)(""));
	} catch(boost::filesystem::filesystem_error &) {
		FBLOG_DEBUG("FileManagerAPI::remove", "Internal error");
		callback->InvokeAsync("", FB::variant_list_of(false)("Internal error"));
	}
}

void btlauncherAPI::gotajax(const FB::JSObjectPtr& callback, 
							bool success,
						    const FB::HeaderMap& headers,
						    const boost::shared_array<uint8_t>& data,
						    const size_t size) {
	FBLOG_INFO("gotajax()", "START");

	FB::VariantMap response;
	response["allowed"] = true;
	response["success"] = success;
	
	if(!success) {
		FBLOG_INFO("gotajax()", "unsuccessful");
		callback->InvokeAsync("", FB::variant_list_of(response));
		FBLOG_INFO("gotajax()", "END");
		return;
	}
	
	FB::VariantMap outHeaders;
	for (FB::HeaderMap::const_iterator it = headers.begin(); it != headers.end(); ++it) {
        if (headers.count(it->first) > 1) {
            if (outHeaders.find(it->first) != outHeaders.end()) {
                outHeaders[it->first].cast<FB::VariantList>().push_back(it->second);
            } else {
                outHeaders[it->first] = FB::VariantList(FB::variant_list_of(it->second));
            }
        } else {
            outHeaders[it->first] = it->second;
        }
    }
	response["headers"] = outHeaders;
	response["size"] = size;
	std::string result = std::string((const char*) data.get(), size);
	response["data"] = result;
	
	callback->InvokeAsync("", FB::variant_list_of(response));
	FBLOG_INFO("gotajax()", "END");
}

void btlauncherAPI::ajax(const std::string& url, const FB::JSObjectPtr& callback) {
	FBLOG_INFO("ajax()", "START");
	FBLOG_INFO("ajax()", url.c_str());
	if (FB::URI::fromString(url).domain != "127.0.0.1") {
		FB::VariantMap response;
		response["allowed"] = false;
		response["success"] = false;
		callback->InvokeAsync("", FB::variant_list_of(response));
		return;
	}
	FB::SimpleStreamHelper::AsyncGet(m_host, FB::URI::fromString(url), 
		boost::bind(&btlauncherAPI::gotajax, this, callback, _1, _2, _3, _4), false
		);
	FBLOG_INFO("ajax()", "END");
}

// If you override this, you probably want to call it again, since this is what calls back into the page
// to indicate that we're done.
void PluginCore::setReady()
{
    FBLOG_INFO("PluginCore", "Plugin Ready");
    // Ensure that the JSAPI object has been created, in case the browser hasn't requested it yet.
    getRootJSAPI(); 
    try {
        FB::VariantMap::iterator fnd = m_params.find("onload");
        if (fnd != m_params.end()) {
            FB::JSObjectPtr method = fnd->second.convert_cast<FB::JSObjectPtr>();
            method->InvokeAsync("", FB::variant_list_of(getRootJSAPI()));
        }
    } catch(...) {
        // Usually this would be if it isn't a JSObjectPtr or the object can't be called
    }
    onPluginReady();
}