STDMETHODIMP Profile::get_OfficePhone(BSTR* pVal)
{
try {
WCHAR * pResult = gSkypeQueue.RetrieveProperty(L"PROFILE", L"", L"PHONE_OFFICE");
*pVal = SysAllocString(pResult);
free(pResult);
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
STDMETHODIMP Profile::put_Birthday(DATE newVal)
{
try {
CDateTime dt = newVal;
_bstr_t bstrDate = dt.Format("%Y%m%d");
gSkypeQueue.SetProperty(L"PROFILE", L"", L"BIRTHDAY", bstrDate);
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
STDMETHODIMP Profile::put_ForwardingRules(SAFEARRAY * newVal)
{
try {
VARTYPE vt = VT_UNKNOWN;
SafeArrayGetVartype(newVal, & vt);
UINT uiDim = SafeArrayGetDim(newVal);
if((uiDim != 1) || (vt != VT_RECORD)) {
return AtlReportError(GetObjectCLSID(), L"Array of rules must be single dimension array of strings", GUID_NULL, E_INVALIDARG);
}
HRESULT hr = SafeArrayLock(newVal);
if(FAILED(hr)) {
return AtlReportError(GetObjectCLSID(), L"Unable to lock array", GUID_NULL, E_FAIL);
}
wstring wstrItems;
ForwardingRule * pItems = (ForwardingRule *) newVal->pvData;
for(ULONG l = 0; l < newVal->rgsabound[0].cElements; l++) {
WCHAR start[32], end[32];
_ltow_s(pItems[l].StartTime, start, sizeof(start)/sizeof(start[0]), 10);
_ltow_s(pItems[l].EndTime, end, sizeof(end)/sizeof(end[0]), 10);
if(l > 0) {
wstrItems += L" ";
}
wstrItems += start;
wstrItems += L",";
wstrItems += end;
wstrItems += L",";
wstrItems += pItems[l].Handle;
}
SafeArrayUnlock(newVal);
gSkypeQueue.SetProperty(L"PROFILE", L"", L"CALL_FORWARD_RULES", wstrItems.c_str());
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
// This is called when the user first loads the add-in, and on start-up
// of each subsequent Developer Studio session
STDMETHODIMP CDSAddIn::OnConnection(IApplication* pApp, VARIANT_BOOL bFirstTime,
long dwCookie, VARIANT_BOOL* OnConnection)
{
HRESULT result = S_OK;
try
{
CComPtr< IUnknown> pIUnk;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
cex_ = _Module.GetClassObject( GetObjectCLSID(), IID_IUnknown, reinterpret_cast<void**>(&pIUnk));
cex_ = CoRegisterClassObject(
GetObjectCLSID(),
pIUnk,
CLSCTX_LOCAL_SERVER,
REGCLS_MULTIPLEUSE,
&classRegistrationId_
);
pIApp_ = pApp;
m_dwCookie = dwCookie;
*OnConnection = VARIANT_TRUE;
}
catch( const std::bad_cast&)
{
*OnConnection = VARIANT_FALSE;
}
catch( const _com_error&)
{
*OnConnection = VARIANT_FALSE;
}
return result;
}
HRESULT CTCPropBagOnRegKey::_CreateLocalObject(const _bstr_t& strName,
IUnknown** ppunkObj, IErrorLog* pErrorLog, IUnknown* punkOuter)
{
// Read the CLSID of the object saved on the specified subkey
CLSID clsid;
CRegKey subkey;
_bstr_t strObjectID;
HRESULT hr = GetObjectCLSID(strName, clsid, subkey, strObjectID,
pErrorLog);
if (FAILED(hr))
return hr;
// Create the object
DWORD dwCtx = CLSCTX_ALL | CLSCTX_REMOTE_SERVER;
IPersistPropertyBagPtr pppb;
void** ppv = reinterpret_cast<void**>(&pppb);
hr = CoCreateInstance(clsid, punkOuter, dwCtx, __uuidof(pppb), ppv);
if (E_INVALIDARG == hr)
{
dwCtx &= ~CLSCTX_REMOTE_SERVER;
hr = CoCreateInstance(clsid, punkOuter, dwCtx, __uuidof(pppb), ppv);
}
if (FAILED(hr))
{
// Use local resources
MCLibRes res;
// Format a description string
_bstr_t strDesc;
strDesc.Format(IDS_FMT_FAIL_CREATE_CLSID, strObjectID);
// Log the error
USES_CONVERSION;
return LogError("CreateObject", strDesc, hr, T2COLE(strName), pErrorLog);
}
// Load the object's persistent properties
CComObjectStack<CTCPropBagOnRegKey> bag;
bag.Init(subkey, strName, this);
hr = pppb->Load(&bag, pErrorLog);
if (FAILED(hr))
return hr;
// Detach the IUnknown* and copy to the [out] parameter, don't Release it
*ppunkObj = pppb.Detach();
// Indicate success
return S_OK;
}
STDMETHODIMP Profile::get_RingtoneFileName(/*[in]*/ SkypeRingtone Tone, /*[in, out]*/ BSTR * FileName)
{
CHECK_PROTOCOL(5)
CHECK_RINGTONE(Tone)
WCHAR wstrCmd[32], wstrResponse[32];
try {
swprintf_s(wstrCmd, sizeof(wstrCmd)/sizeof(wstrCmd[0]), L"GET RINGTONE %d", Tone);
swprintf_s(wstrResponse, sizeof(wstrResponse)/sizeof(wstrResponse[0]), L"RINGTONE %d ", Tone);
WCHAR * pResponse = gSkypeQueue.ExecuteBlockingCommand(wstrCmd, wstrResponse);
*FileName = SysAllocString(pResponse);
free(pResponse);
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
STDMETHODIMP Profile::get_RingtoneStatus(/*[in]*/ SkypeRingtone Tone, /*[out, retval]*/ VARIANT_BOOL *pVal)
{
CHECK_PROTOCOL(5)
CHECK_RINGTONE(Tone)
WCHAR wstrCmd[32], wstrResponse[32];
try {
swprintf_s(wstrCmd, sizeof(wstrCmd)/sizeof(wstrCmd[0]), L"GET RINGTONE %d STATUS", Tone);
swprintf_s(wstrResponse, sizeof(wstrResponse)/sizeof(wstrResponse[0]), L"RINGTONE %d ", Tone);
WCHAR * pResponse = gSkypeQueue.ExecuteBlockingCommand(wstrCmd, wstrResponse);
*pVal = (wcsstr(pResponse, L" ON") != NULL);
free(pResponse);
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
STDMETHODIMP Profile::get_Birthday(DATE* pVal)
{
LONG yy, mm, dd;
BOOL bOk = FALSE;
try {
WCHAR * pStrBirthdate = gSkypeQueue.RetrieveProperty(L"PROFILE", L"", L"BIRTHDAY");
if(swscanf_s(pStrBirthdate, L"%04d%02d%02d", & yy, & mm, &dd) == 3) {
OleDateFromTm((WORD) yy, (WORD) mm, (WORD) dd, 0, 0, 0, * pVal);
bOk = TRUE;
}
free(pStrBirthdate);
return bOk; // 未入力の場合もエラーとしない。
//return bOk ? S_OK : AtlReportError(GetObjectCLSID(), L"Invalid birthday in user Profile", GUID_NULL, E_FAIL);
} catch(const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
STDMETHODIMP Profile::put_Sex(SkypeUserSex newVal)
{
try {
CComObject<Conversion> * objConvert;
HRESULT hr = CComObject<Conversion>::CreateInstance(& objConvert);
if(SUCCEEDED(hr)) {
BSTR bstrText;
hr = objConvert->SkypeUserSexAsText(newVal, & bstrText);
if(SUCCEEDED(hr)) {
gSkypeQueue.SetProperty(L"PROFILE", L"", L"SEX", bstrText);
SysFreeString(bstrText);
}
}
return hr;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
STDMETHODIMP Profile::put_AvatarFileName(/*[in]*/ LONG Index, /*[in]*/ BSTR FileName)
{
CHECK_PROTOCOL(5)
WCHAR wstrBuffer[32];
try {
wstring wstrCmd = L"SET AVATAR ";
wstrCmd += _ltow_s(Index, wstrBuffer, sizeof(wstrBuffer)/sizeof(wstrBuffer[0]), 10);
wstrCmd += L" ";
wstrCmd += FileName;
WCHAR * pResult = gSkypeQueue.ExecuteBlockingCommand(wstrCmd.c_str(), L"AVATAR");
free(pResult);
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
STDMETHODIMP Profile::put_RingtoneFileName(/*[in]*/ SkypeRingtone Tone, /*[in]*/ BSTR FileName)
{
CHECK_PROTOCOL(5)
CHECK_RINGTONE(Tone)
WCHAR wstrBuffer[32];
try {
wstring wstrCmd = L"SET RINGTONE ";
wstrCmd += _ltow_s(Tone, wstrBuffer, sizeof(wstrBuffer)/sizeof(wstrBuffer[0]), 10);
wstrCmd += L" ";
wstrCmd += FileName;
WCHAR * pResult = gSkypeQueue.ExecuteBlockingCommand(wstrCmd.c_str(), L"RINGTONE");
free(pResult);
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
}
/*
* Connects to the Maya command port, if not already connected.
*
* Return Value
* Returns S_OK if successful or already connected,
* or an error value otherwise.
*/
STDMETHODIMP CMELCommand::Connect(void)
{
if (m_socket != INVALID_SOCKET)
// already connected!
return S_OK;
// initialize Windows Sockets 2
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 0), &wsaData) == 0)
{
CW2A pszPortName(m_strPortName);
m_socket = ConnectToMayaCommandPortByName(pszPortName);
if (m_socket != INVALID_SOCKET)
return S_OK;
}
WSACleanup();
CAtlString strError = L"Unable to connect to command port: ";
strError += m_strPortName;
return AtlReportError(GetObjectCLSID(), strError, IID_IMELCommand);
}
STDMETHODIMP ChatMessageCollection::get_Item(VARIANT index, IChatMessage ** pRetVal)
{
if (pRetVal == NULL)
return E_POINTER;
VARIANT vIndex;
VariantInit(& vIndex);
VariantChangeType(& vIndex, & index, 0, VT_I4);
long lCtr = 0;
for(ChatMessageList::iterator it = m_itemList.begin(); it != m_itemList.end(); it++) {
if(++lCtr == vIndex.lVal) {
CComObject<ChatMessage> * ptrChatMessage;
if(SUCCEEDED(CComObject<ChatMessage>::CreateInstance(& ptrChatMessage))) {
ptrChatMessage->SetID(*it);
return ptrChatMessage->QueryInterface(pRetVal);
}
}
}
return AtlReportError(GetObjectCLSID(), "Index not within collection bounds", GUID_NULL, E_INVALIDARG);
}
// IPersist
STDMETHODIMP CMyMath::GetClassID(/*[out]*/CLSID * pClassID)
{
*pClassID = GetObjectCLSID();
return S_OK;
}
STDMETHODIMP Profile::get_ForwardingRules(SAFEARRAY ** pVal)
{
try {
WCHAR * pResult = gSkypeQueue.RetrieveProperty(L"PROFILE", L"", L"CALL_FORWARD_RULES");
size_t sz = wcslen(pResult) + 1;
WCHAR * pCopy = new WCHAR[sz];
long lTotal=0, lCtr=0;
HRESULT hr;
ForwardingRule * pItems;
for(int i = 0; i < 2; i++) {
wcscpy_s(pCopy, sz, pResult);
WCHAR *next_token = NULL;
WCHAR * pItem = wcstok_s(pCopy, L" ", &next_token);
while(pItem != NULL) {
size_t iLen = wcslen(pItem);
if(iLen > 0) {
LONG start;
LONG end;
WCHAR * name = new WCHAR[iLen];
bool bValid =
swscanf_s(pItem, L"%d,%d,%s", & start, & end, name, iLen) == 3;
if(bValid) {
if(i == 0) {
lTotal++;
} else {
pItems[lCtr].StartTime = start;
pItems[lCtr].EndTime = end;
pItems[lCtr].Handle = SysAllocString(name);
lCtr++;
}
}
delete(name);
}
pItem = wcstok_s(NULL, L" ", &next_token);
}
if(i == 0) {
SAFEARRAYBOUND sba;
sba.cElements = lTotal;
sba.lLbound = 0;
CComPtr<IRecordInfo> *ptrRecInfo;
hr = GetRecordInfoFromGuids(CAtlModule::m_libid, 1, 0, 0x409,
__uuidof(ForwardingRule), (IRecordInfo**) & ptrRecInfo);
if(FAILED(hr)) {
return AtlReportError(GetObjectCLSID(), L"Unable to retrieve structure info", GUID_NULL, E_FAIL);
}
*pVal = SafeArrayCreateEx(VT_RECORD, 1, & sba, ptrRecInfo);
if((*pVal) == NULL) {
return AtlReportError(GetObjectCLSID(), L"Unable to create array", GUID_NULL, E_FAIL);
}
hr = SafeArrayLock(*pVal);
if(FAILED(hr)) {
return AtlReportError(GetObjectCLSID(), L"Unable to lock array", GUID_NULL, E_FAIL);
}
pItems = (ForwardingRule *) (*pVal)->pvData;
} else {
hr = SafeArrayUnlock(*pVal);
if(FAILED(hr)) {
return AtlReportError(GetObjectCLSID(), L"Unable to unlock array", GUID_NULL, E_FAIL);
}
}
}
free(pResult);
return S_OK;
} catch (const WCHAR * err) {
return AtlReportError(GetObjectCLSID(), err, GUID_NULL, E_FAIL);
}
return S_OK;
}
STDMETHODIMP CImpCEDL::DownloadSelect(long lHWND,BSTR sUser)
{
HRESULT hr = S_OK;
HWND hwndParent = NULL;
CWnd *pWnd = NULL;
CStation *pStation = NULL;
CDLUpdateDlg* pDlg = NULL;
CComBSTR sTargetName = _T("");
AFX_MANAGE_STATE(AfxGetStaticModuleState())
FC_DEBUGPRINT1(_T("CEDL> DownloadSelect: thread id=0x%x\n"),::GetCurrentThreadId());
try {
if (!m_bInit) {
FC_DEBUGPRINT (_T ("CEDL> DownloadSelect: not initialized\n"));
ComThrow(GetObjectCLSID(),__uuidof(IDL),E_CE_DL_NOT_INITED);
}
pStation = m_pStationList->FindStationByIndex(0,true);
if(!pStation) {
FC_DEBUGPRINT(_T("CEDL> DownloadSelect: Station not found\n"));
ComThrow(GetObjectCLSID(),__uuidof(IDL),E_CE_DL_STATION_NOT_FOUND);
}
pWnd = new CWnd();
if(!pWnd) {
AfxThrowMemoryException();
}
hwndParent = reinterpret_cast<HWND>(lHWND);
if(!::IsWindow(hwndParent)) {
hwndParent = NULL;
}
pWnd->Attach(hwndParent);
pDlg = new CDLUpdateDlg(pWnd);
if(!pDlg) {
AfxThrowMemoryException();
}
pDlg->SetStation(pStation);
assert(m_pEvents != NULL);
pDlg->SetEventPtr(m_pEvents);
pDlg->DoModal();
}
catch(CMemoryException* e) {
hr = E_OUTOFMEMORY;
e->Delete();
}
catch(_com_error err) {
Fire_OnNewMessage(sTargetName,E_FACILITY_CEDL,err.Error(),err.Description());
hr = ComCatch(err);
}
if(pWnd) {
pWnd->Detach();
delete pWnd;
}
if(pDlg) {
delete(pDlg);
}
FC_RELEASE_PTR(pStation);
return hr;
}
STDMETHODIMP CImpCEDL::Init(BSTR sTargetName, BSTR sGenPath,BOOL bSilent)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState())
HRESULT hr = S_OK;
CString strPath,strSrc,strDest,strTarget;
CFileStatus rStatus;
PIDLEvents pEvntSink;
PICEMsg pMsgSink;
IErrorInfo* pInfo = NULL;
DWORD dwErr = 0UL;
// Enforce using of DAO36 and Jet40 by mfc42.dll
AfxGetModuleState()->m_dwVersion = 0x0601;
//EF don't call this: causes an zombie process! AfxDaoInit();
FC_DEBUGPRINT1(_T("CEDL> Init: thread id=0x%x\n"),::GetCurrentThreadId());
try {
if(!sTargetName || !sGenPath) {
ComThrow(GetObjectCLSID(),__uuidof(IDL),E_POINTER);
}
strTarget = sTargetName;
strPath = sGenPath;
strSrc = strPath + _T('\\') + strTarget;
//create own event sink - not created if already done
CreateEvntSink();
//check for the target specific gen path first
if(!CFile::GetStatus(strSrc,rStatus)) {
ComThrow(GetObjectCLSID(),__uuidof(IDL),E_CE_DL_NOGENPATH,strSrc,strTarget);
}
//create downloader directory within target specific gen path if
//not already created
strSrc = strSrc + _T('\\') + CEDL_DOMDIR;
if(!CFile::GetStatus(strSrc,rStatus)) {
//create a new dir
if(_tmkdir(strSrc)) {
//on error throw file exception with path
dwErr = GetLastError();
CFileException::ThrowOsError(dwErr,strSrc);
}
}
CStationList::CopyDatabase(strTarget,sGenPath,false);
//get the path of the current database
CStationList::GetDBPath(strDest,strTarget,sGenPath);
pEvntSink = dynamic_cast <CProxyIDLEvents<CImpCEDL>*>(this);
assert(pEvntSink);
pMsgSink = dynamic_cast <CProxy_ICEMessageEvent<CImpCEDL>*>(this);
assert(pMsgSink);
/* TODO CHECK OBSOLETE
if(m_pStationList) { //station list there - reinitialization
//station list there but represents not the same project ?
if(strGUID != m_pStationList->GetProjectGuid()) {
/* not the same project return downloader already inited.
a different project requires a call to Exit before reinit
downloader
return E_CE_DL_ALREADY_INITED;
}
/* iff any download is pending and state not CEDL_STAT_IDLE
reinitialization is not possible
if(m_pStationList->IsDownloadPending()) {
return E_CE_DL_PENDING;
}
//check wether downloader database is open.
if(!m_pStationList->IsDBOpen()) { //reopen it iff not open
m_pStationList->OpenDB();
}
if(!m_pStationList->CheckDBVersion()) {
//close db first
m_pStationList->CloseDB();
CStationList::CopyDatabase(sGenPath,true);
//reopen
m_pStationList->OpenDB();
}
}
*/
m_pStationList = new CStationList(strPath,strDest);
if(!m_pStationList) {
AfxThrowMemoryException();
}
m_pStationList->OpenDB();
if(!m_pStationList->CheckDBVersion()) {
//close db first
m_pStationList->CloseDB();
CStationList::CopyDatabase(strTarget,sGenPath,true);
//reopen
m_pStationList->OpenDB();
}
m_pStationList->BuildStationList(sTargetName,pEvntSink,pMsgSink, bSilent?true:false);
}
catch(_com_error err) {
Fire_OnNewMessage(NULL,E_FACILITY_CEDL,err.Error(),err.Description());
ComCatch(err);
hr = err.Error();
}
catch(CMemoryException* e) {
e->Delete();
hr = E_OUTOFMEMORY;
}
catch(CDaoException* e) {
hr = e->m_scode;
strDest.Empty();
if(e->m_pErrorInfo) {
strDest = e->m_pErrorInfo->m_strDescription;
}
if(strDest.IsEmpty()) {
strDest.Format(IDS_CEDL_DEFERROR,hr);
}
ComErrorInfo(GetObjectCLSID(),__uuidof(IDL),&pInfo,strDest);
_com_error err(hr,pInfo);
Fire_OnNewMessage(NULL,E_FACILITY_CEDL,err.Error(),err.Description());
e->Delete();
ComCatch(err);
}
catch(CFileException * e) {
hr = HRESULT_FROM_WIN32(e->m_lOsError);
strDest.Empty();
strSrc.Empty();
FormatMsg(strSrc.GetBuffer(_MAX_PATH),hr);
strSrc.ReleaseBuffer();
if(strSrc.IsEmpty()) {
strSrc.Format(IDS_CEDL_DEFERROR,hr);
}
strSrc.TrimRight(_T("\r\n"));
FormatMsg(strDest.GetBuffer(_MAX_PATH),E_CE_DL_FILE_ERROR,strTarget,
strSrc,e->m_strFileName);
strDest.ReleaseBuffer();
ComErrorInfo(GetObjectCLSID(),__uuidof(IDL),&pInfo,strDest);
_com_error err(hr,pInfo);
Fire_OnNewMessage(NULL,E_FACILITY_CEDL,err.Error(),err.Description());
e->Delete();
ComCatch(err);
}
if(FAILED(hr)) {
Cleanup();
m_bInit = FALSE;
return hr;
}
m_bInit = TRUE;
return hr;
}
STDMETHODIMP CDirectDynamic::GetClassID(CLSID* pClassID)
{
*pClassID = GetObjectCLSID();
return S_OK;
}
