示例#1
0
} END_TEST

START_TEST(test_call_get_ReceiveFolder) {
	uint64_t fid;
	const char *ExplicitMessageClass;

	CHECK_SUCCESS(openchangedb_get_ReceiveFolder(mem_ctx, oc_ctx, "recipient", "MessageClass",
		      &fid, &ExplicitMessageClass));

	ck_assert_int_eq(functions_called.get_ReceiveFolder, 1);
} END_TEST
示例#2
0
} END_TEST

START_TEST(test_call_replica_mapping_guid_to_replid) {
        struct GUID guid = GUID_random();
	uint16_t    replid = 0;

	CHECK_SUCCESS(openchangedb_replica_mapping_guid_to_replid(oc_ctx, "recipient",
                                                                  &guid, &replid));

	ck_assert_int_eq(functions_called.guid_to_replid, 1);
        ck_assert_int_eq(replid, 0x03);
} END_TEST
示例#3
0
} END_TEST

START_TEST(test_call_get_ReceiveFolder) {
	uint64_t fid;
	const char *ExplicitMessageClass;

	CHECK_SUCCESS(openchangedb_get_ReceiveFolder(mem_ctx, oc_ctx, "recipient", "MessageClass",
		      &fid, &ExplicitMessageClass));

	ck_assert_int_eq(functions_called.get_ReceiveFolder, 1);
	ck_assert_int_eq(fid, FOLDER_ID_EXPECTED);
	ck_assert(!strcmp(ExplicitMessageClass, DFT_MESSAGE_CLASS));
} END_TEST
示例#4
0
} END_TEST

START_TEST(test_call_replica_mapping_replid_to_guid) {
        struct GUID *guid;
        struct GUID local_guid = GUID_zero();

        guid = talloc_zero(mem_ctx, struct GUID);
	CHECK_SUCCESS(openchangedb_replica_mapping_replid_to_guid(oc_ctx, "recipient",
                                                                  0x03, guid));
        talloc_free(guid);
	ck_assert_int_eq(functions_called.replid_to_guid, 1);
	ck_assert(GUID_equal(guid, &local_guid));
} END_TEST
示例#5
0
} END_TEST

START_TEST(test_call_get_MailboxReplica) {
	uint16_t ReplID;
	struct GUID local_guid = GUID_zero();
	struct GUID ReplGUID;

	CHECK_SUCCESS(openchangedb_get_MailboxReplica(oc_ctx, "recipient", &ReplID, &ReplGUID));

	ck_assert_int_eq(functions_called.get_MailboxReplica, 1);
	ck_assert_int_eq(ReplID, 0x03);
	ck_assert(GUID_equal(&ReplGUID, &local_guid));
} END_TEST
示例#6
0
int main(int argc, char *argv[]) {

	printf("\t--------------------------------\n");
	printf("\t-    v*v    de7ec7ed    v*v    -\n");
	printf("\t-    *^* android insmod *^*    -\n");
	printf("\t--------------------------------\n");

	if(argc < 2) {
		usage(argc, argv);
		return FAILURE;
	}

	CHECK_SUCCESS(add_module(argv[1], (argc - 1), (u8_t **)&(argv[1])), "[-] unable to add the module\n");

	printf("[+] module successfully added\n");

	return SUCCESS;
}
HRESULT DXwindow::InitSDIForDevice()
{
	IAmdDxExt* pExt = NULL;
    IAmdDxExtSDI* pLocalSDI = NULL;
    HRESULT hr = S_OK;
	m_pSDI = NULL;

	HMODULE hDrvDll = GetModuleHandleW(L"atidxx32.dll");
	if ( hDrvDll == NULL )
	{
		hDrvDll = GetModuleHandleW(L"atidxx64.dll");
	}

	if (hDrvDll != NULL)
	{
		PFNAmdDxExtCreate11 pAmdDxExtCreate = reinterpret_cast<PFNAmdDxExtCreate11>(GetProcAddress(hDrvDll, "AmdDxExtCreate11"));
		if (pAmdDxExtCreate != NULL)
		{			
			hr = pAmdDxExtCreate(m_pd3dDevice, &pExt);
			CHECK_SUCCESS(hr,"pAmdDxExtCreate");
			if (pExt != NULL)
			{		
				pLocalSDI = static_cast<IAmdDxExtSDI*>((pExt)->GetExtInterface(AmdDxExtSDIID));

				if ( pLocalSDI == NULL )
				{
					MessageBoxA(NULL,"Error, you must activate DirectGMA with AMD Control Center -> AMD Firepro -> SDI/DirectGMA","DirectGMA",NULL);
					return E_FAIL;
				}
				
			}
		}
	}

	m_pSDI = pLocalSDI;

	return S_OK;
}
示例#8
0
cellular_result_t  cellular_pdp_deactivate(void* reserved)
{
    CHECK_SUCCESS(electronMDM.disconnect());
    return 0;
}
// 解析设置图形的XML
IVS_INT32 COCXDrawXMLProcess::SetGraphicsPraseXML(IA_GRAPHICS *pGraphicsArr, ULONG &ulNum, LPCTSTR pGraphicsXml, const SIZE &szGraphic, BOOL bPersent)
{
	CHECK_POINTER(pGraphicsArr, IVS_FAIL);
	CHECK_POINTER(pGraphicsXml, IVS_OPERATE_MEMORY_ERROR);

	IVS_DEBUG_TRACE("GraphicsXml: %s, GraphicWidth: %d, GraphicHeight: %d",pGraphicsXml, szGraphic.cx, szGraphic.cy);

	CXml xml;
	if (!xml.Parse(pGraphicsXml))
	{
		return IVS_FAIL;
	}

	CHECK_SUCCESS(xml.FindElem("Content"));
	CHECK_SUCCESS(xml.IntoElem());
	CHECK_SUCCESS(xml.FindElem("Graphics"));
	CHECK_SUCCESS(xml.IntoElem());

	const char *value = NULL;

	CHECK_SUCCESS(xml.FindElem("GraphicNum") && (NULL != (value = xml.GetElemValue())));
	ulNum = (ULONG)atoi(value);

	// 若设置的图形数大于图形数组长度,截断到最大画图个数
	if (ulNum > GRAPHICS_NUM_MAX)
	{
		BP_RUN_LOG_INF("COCXDrawXMLProcess::SetGraphicsPraseXML", "GraphicNum Truncated to GRAPHICS_NUM_MAX");
		ulNum = GRAPHICS_NUM_MAX;
	}

	CHECK_SUCCESS(xml.FindElem("GraphicList"));
	CHECK_SUCCESS(xml.IntoElem());

	for (ULONG i = 0; i < ulNum; i++)
	{
		// 给图形可选字段赋默认值
		memset(&pGraphicsArr[i], 0, sizeof(IA_GRAPHICS));
		pGraphicsArr[i].ulLineWidth = 3; // 默认基本线宽为3
		pGraphicsArr[i].bAllowDelete = TRUE; // 允许删除
		pGraphicsArr[i].bAllowModifySize = TRUE; // 允许修改矩形大小

		if (0 == i)
		{
			CHECK_SUCCESS(xml.FindElem("GraphicInfo"));
		} else {
			CHECK_SUCCESS(xml.NextElem());
		}
		CHECK_SUCCESS(xml.IntoElem());
		CHECK_SUCCESS(xml.FindElem("GraphicType") && (NULL != (value = xml.GetElemValue())));
		pGraphicsArr[i].ulGraphicType = (ULONG)atoi(value);

		GET_ELEMENT_ULONG(pGraphicsArr[i].ulGraphicGroup, GraphicGroup, xml);
		GET_ELEMENT_STRING(pGraphicsArr[i].GraphicGroupName, CHARACTER_NUM_MAX, GraphicGroupName, xml);

		if (xml.FindElem("GraphicBackgroundColor"))
		{
			CHECK_SUCCESS(xml.IntoElem());
			GET_ELEMENT_UCHAR(pGraphicsArr[i].BgColor.Alpha, Opacity, xml);
			GET_ELEMENT_UCHAR(pGraphicsArr[i].BgColor.Red, Red, xml);
			GET_ELEMENT_UCHAR(pGraphicsArr[i].BgColor.Green, Green, xml);
			GET_ELEMENT_UCHAR(pGraphicsArr[i].BgColor.Blue, Blue, xml);
			xml.OutOfElem();
		}

		if (xml.FindElem("GraphicLineColor"))
		{
			CHECK_SUCCESS(xml.IntoElem());
			GET_ELEMENT_UCHAR(pGraphicsArr[i].LineColor.Alpha, Opacity, xml);
			GET_ELEMENT_UCHAR(pGraphicsArr[i].LineColor.Red, Red, xml);
			GET_ELEMENT_UCHAR(pGraphicsArr[i].LineColor.Green, Green, xml);
			GET_ELEMENT_UCHAR(pGraphicsArr[i].LineColor.Blue, Blue, xml);
			xml.OutOfElem();
		}

		GET_ELEMENT_ULONG(pGraphicsArr[i].ulLineWidth, GraphicLineWidth, xml);

		CHECK_SUCCESS(xml.FindElem("PointNum") && (NULL != (value = xml.GetElemValue())));
		pGraphicsArr[i].ulPointsNum = (ULONG)atoi(value);

		CHECK_SUCCESS(xml.FindElem("PointList"));
		CHECK_SUCCESS(xml.IntoElem());

		for (ULONG j = 0; j < pGraphicsArr[i].ulPointsNum; j++)
		{
			if (0 == j)
			{
				CHECK_SUCCESS(xml.FindElem("Point"));
			} else {
				CHECK_SUCCESS(xml.NextElem());
			}
			CHECK_SUCCESS(xml.IntoElem());

			if ((0 == szGraphic.cx) || (0 == szGraphic.cy))
			{
				if (bPersent)
				{
					CHECK_SUCCESS(xml.FindElem("X") && (NULL != (value = xml.GetElemValue())));
					pGraphicsArr[i].IAPoints[j].x = (LONG)(atof(value) * FLOAT_TO_LONG_COEFF);
					CHECK_SUCCESS(xml.FindElem("Y") && (NULL != (value = xml.GetElemValue())));
					pGraphicsArr[i].IAPoints[j].y = (LONG)(atof(value) * FLOAT_TO_LONG_COEFF);
				} else {
					CHECK_SUCCESS(xml.FindElem("X") && (NULL != (value = xml.GetElemValue())));
					pGraphicsArr[i].IAPoints[j].x = (LONG)atoi(value);
					CHECK_SUCCESS(xml.FindElem("Y") && (NULL != (value = xml.GetElemValue())));
					pGraphicsArr[i].IAPoints[j].y = (LONG)atoi(value);
				}
			}
			else
			{
				CHECK_SUCCESS(xml.FindElem("X") && (NULL != (value = xml.GetElemValue())));
				pGraphicsArr[i].IAPoints[j].x = (LONG)(atof(value) * szGraphic.cx + 0.5);
				CHECK_SUCCESS(xml.FindElem("Y") && (NULL != (value = xml.GetElemValue())));
				pGraphicsArr[i].IAPoints[j].y = (LONG)(atof(value) * szGraphic.cy + 0.5);
			}

			xml.OutOfElem();
		}
		xml.OutOfElem();

		GET_ELEMENT_ULONG(pGraphicsArr[i].NamePosition, NamePosition, xml);
		GET_ELEMENT_BOOL(pGraphicsArr[i].bAllowDelete, DeleteByMouse, xml);
		GET_ELEMENT_BOOL(pGraphicsArr[i].bAllowAddNewPoint, AddNewPoint, xml);
		GET_ELEMENT_BOOL(pGraphicsArr[i].bAllowModifySize, AllowModifySize, xml);
		GET_ELEMENT_ULONG(pGraphicsArr[i].ulArrowType, ArrowType, xml);
		GET_ELEMENT_BOOL(pGraphicsArr[i].bKeepHorizon, KeepHorizon, xml);

		xml.OutOfElem();
	}
	xml.OutOfElem();
	xml.OutOfElem();

	return IVS_SUCCEED;
}
HRESULT DXwindow::InitDevice(IDXGIAdapter* adapter,D3D_DRIVER_TYPE driverType)
{
    HRESULT hr = S_OK;

    RECT rc;
    GetClientRect( m_hWnd, &rc );
    UINT width = rc.right - rc.left;
    UINT height = rc.bottom - rc.top;

    DXGI_SWAP_CHAIN_DESC sd;
    ZeroMemory( &sd, sizeof( sd ) );
    sd.BufferCount = 2;//1
    sd.BufferDesc.Width = width;
    sd.BufferDesc.Height = height;
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    sd.BufferDesc.RefreshRate.Numerator = 60;
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    sd.OutputWindow = m_hWnd;
    sd.SampleDesc.Count = 1;
    sd.SampleDesc.Quality = 0;
    sd.Windowed = TRUE;

	D3D_FEATURE_LEVEL    featureLevel = D3D_FEATURE_LEVEL_11_0;

    hr = D3D11CreateDeviceAndSwapChain( 
		adapter,
		driverType,
		NULL, 
		D3D11_CREATE_DEVICE_SINGLETHREADED, 
		NULL,
		0,
        D3D11_SDK_VERSION, 
		&sd, 
		&m_pSwapChain, 
		&m_pd3dDevice, 
		&featureLevel, 
		&m_pImmediateContext );


    if( FAILED( hr ) )
	{
        return hr;
	}

    // Create a render target view
    m_pBackBuffer = NULL;
    hr = m_pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&m_pBackBuffer );
    if( FAILED( hr ) )
        return hr;

    hr = m_pd3dDevice->CreateRenderTargetView( m_pBackBuffer, NULL, &m_pBackBuffer_RTV );

    if( FAILED( hr ) )
        return hr;

	// Create depth stencil texture
    ID3D11Texture2D* pDepthStencil = NULL;
    D3D11_TEXTURE2D_DESC descDepth;
    descDepth.Width = width;
    descDepth.Height = height;
    descDepth.MipLevels = 1;
    descDepth.ArraySize = 1;
    descDepth.Format = DXGI_FORMAT_D16_UNORM;
    descDepth.SampleDesc.Count = 1;
    descDepth.SampleDesc.Quality = 0;
    descDepth.Usage = D3D11_USAGE_DEFAULT;
    descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    descDepth.CPUAccessFlags = 0;
    descDepth.MiscFlags = 0;
    hr = m_pd3dDevice->CreateTexture2D( &descDepth, NULL, &pDepthStencil );
	CHECK_SUCCESS(hr,"pd3dDevice->CreateTexture2D");

    // Create the depth stencil view
    D3D11_DEPTH_STENCIL_VIEW_DESC descDSV;
    descDSV.Format = descDepth.Format;
    descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
    descDSV.Texture2D.MipSlice = 0;
	descDSV.Flags = 0;
    hr = m_pd3dDevice->CreateDepthStencilView( pDepthStencil, &descDSV,&m_pDSV );
	CHECK_SUCCESS(hr,"pd3dDevice->CreateDepthStencilView");
    if(pDepthStencil)
		pDepthStencil->Release();
    PASS_TEST( hr );

	m_pImmediateContext->OMSetRenderTargets( 1, &m_pBackBuffer_RTV, m_pDSV); 
	

    // Set up the viewport
    D3D11_VIEWPORT vp;
    vp.Width = (FLOAT)width;
    vp.Height = (FLOAT)height;
    vp.MinDepth = 0.0f;
    vp.MaxDepth = 1.0f;
    vp.TopLeftX = 0;
    vp.TopLeftY = 0;
    m_pImmediateContext->RSSetViewports( 1, &vp );


	D3D11_QUERY_DESC pQueryDesc;
	pQueryDesc.Query = D3D11_QUERY_EVENT;
	pQueryDesc.MiscFlags = 0;
	PASS_TEST(m_pd3dDevice->CreateQuery(&pQueryDesc, &m_pEventQuery_));


    return S_OK;
}
// 构建获取图形的XML
IVS_INT32 COCXDrawXMLProcess::GetGraphicsGetXML(const IA_GRAPHICS *pGraphicsArr, IVS_INT32 iResultCode, ULONG ulNum, CXml& xmlGraphics, const SIZE &szGraphic)
{
	CHECK_POINTER(pGraphicsArr, IVS_FAIL);
	IVS_DEBUG_TRACE("iResultCode: %d, ulNum:%d, GraphicWidth: %d, GraphicHeight: %d", iResultCode, ulNum, szGraphic.cx, szGraphic.cy);

	char val[64] = {0};

	CHECK_SUCCESS(xmlGraphics.AddDeclaration("1.0","UTF-8",""));
	CHECK_SUCCESS(xmlGraphics.AddElem("Content"));
	CHECK_SUCCESS(xmlGraphics.AddChildElem("ResultCode"));
	CHECK_SUCCESS(xmlGraphics.IntoElem());
	SET_ELEMENT_LONG(iResultCode, val, xmlGraphics);

	CHECK_SUCCESS(xmlGraphics.AddElem("Graphics"));
	CHECK_SUCCESS(xmlGraphics.AddChildElem("GraphicNum"));
	CHECK_SUCCESS(xmlGraphics.IntoElem());
	SET_ELEMENT_LONG(ulNum, val, xmlGraphics);
	if (0 == ulNum)
	{
		xmlGraphics.OutOfElem();
		xmlGraphics.OutOfElem();
		return IVS_SUCCEED;
	}

	CHECK_SUCCESS(xmlGraphics.AddElem("GraphicList"));
	for (ULONG i = 0; i < ulNum; i++)
	{
		if (i == 0)
		{
			CHECK_SUCCESS(xmlGraphics.AddChildElem("GraphicInfo"));
			CHECK_SUCCESS(xmlGraphics.IntoElem());
		}
		else
		{
			CHECK_SUCCESS(xmlGraphics.AddElem("GraphicInfo"));
		}

		CHECK_SUCCESS(xmlGraphics.AddChildElem("GraphicType"));
		CHECK_SUCCESS(xmlGraphics.IntoElem());
		SET_ELEMENT_LONG(pGraphicsArr[i].ulGraphicType, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("GraphicGroup"));
		SET_ELEMENT_LONG(pGraphicsArr[i].ulGraphicGroup, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("GraphicGroupName"));
		SET_ELEMENT_STRING(pGraphicsArr[i].GraphicGroupName, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("GraphicBackgroundColor"));
		CHECK_SUCCESS(xmlGraphics.AddChildElem("Opacity"));
		CHECK_SUCCESS(xmlGraphics.IntoElem());
		SET_ELEMENT_LONG(pGraphicsArr[i].BgColor.Alpha, val, xmlGraphics);
		CHECK_SUCCESS(xmlGraphics.AddElem("Red"));
		SET_ELEMENT_LONG(pGraphicsArr[i].BgColor.Red, val, xmlGraphics);
		CHECK_SUCCESS(xmlGraphics.AddElem("Green"));
		SET_ELEMENT_LONG(pGraphicsArr[i].BgColor.Green, val, xmlGraphics);
		CHECK_SUCCESS(xmlGraphics.AddElem("Blue"));
		SET_ELEMENT_LONG(pGraphicsArr[i].BgColor.Blue, val, xmlGraphics);
		xmlGraphics.OutOfElem();

		CHECK_SUCCESS(xmlGraphics.AddElem("GraphicLineColor"));
		CHECK_SUCCESS(xmlGraphics.AddChildElem("Opacity"));
		CHECK_SUCCESS(xmlGraphics.IntoElem());
		SET_ELEMENT_LONG(pGraphicsArr[i].LineColor.Alpha, val, xmlGraphics);
		CHECK_SUCCESS(xmlGraphics.AddElem("Red"));
		SET_ELEMENT_LONG(pGraphicsArr[i].LineColor.Red, val, xmlGraphics);
		CHECK_SUCCESS(xmlGraphics.AddElem("Green"));
		SET_ELEMENT_LONG(pGraphicsArr[i].LineColor.Green, val, xmlGraphics);
		CHECK_SUCCESS(xmlGraphics.AddElem("Blue"));
		SET_ELEMENT_LONG(pGraphicsArr[i].LineColor.Blue, val, xmlGraphics);
		xmlGraphics.OutOfElem();

		CHECK_SUCCESS(xmlGraphics.AddElem("GraphicLineWidth"));
		SET_ELEMENT_LONG(pGraphicsArr[i].ulLineWidth, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("PointNum"));
		SET_ELEMENT_LONG(pGraphicsArr[i].ulPointsNum, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("PointList"));
		for (ULONG j = 0; j < pGraphicsArr[i].ulPointsNum; j++)
		{
			if (0 == j)
			{
				CHECK_SUCCESS(xmlGraphics.AddChildElem("Point"));
				CHECK_SUCCESS(xmlGraphics.IntoElem());
			}
			else
			{
				CHECK_SUCCESS(xmlGraphics.AddElem("Point"));
			}

			CHECK_SUCCESS(xmlGraphics.AddChildElem("X"));
			CHECK_SUCCESS(xmlGraphics.IntoElem());
			if ((0 == szGraphic.cx) || (0 == szGraphic.cy))
			{			
				SET_ELEMENT_LONG(pGraphicsArr[i].IAPoints[j].x, val, xmlGraphics);
				CHECK_SUCCESS(xmlGraphics.AddElem("Y"));
				SET_ELEMENT_LONG(pGraphicsArr[i].IAPoints[j].y, val, xmlGraphics);
			}
			else
			{
				char cPointValue[10];
				memset(cPointValue, 0, sizeof(cPointValue));
				double dPointValue = (double)pGraphicsArr[i].IAPoints[j].x / szGraphic.cx;

				(void)_snprintf_s(cPointValue, sizeof(cPointValue) - 1, "%f", dPointValue);
                cPointValue[8] = '\0';
				CHECK_SUCCESS(xmlGraphics.SetElemValue(cPointValue)); 

				CHECK_SUCCESS(xmlGraphics.AddElem("Y"));
				memset(cPointValue, 0, sizeof(cPointValue));
				dPointValue = (double)pGraphicsArr[i].IAPoints[j].y / szGraphic.cy;
				(void)_snprintf_s(cPointValue, sizeof(cPointValue) - 1, "%f", dPointValue);
                cPointValue[8] = '\0';
                CHECK_SUCCESS(xmlGraphics.SetElemValue(cPointValue)); 

			}
			xmlGraphics.OutOfElem();
		}
		xmlGraphics.OutOfElem();

		CHECK_SUCCESS(xmlGraphics.AddElem("NamePosition"));
		SET_ELEMENT_LONG(pGraphicsArr[i].NamePosition, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("DeleteByMouse"));
		SET_ELEMENT_LONG(pGraphicsArr[i].bAllowDelete, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("AddNewPoint"));
		SET_ELEMENT_LONG(pGraphicsArr[i].bAllowAddNewPoint, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("AllowModifySize"));
		SET_ELEMENT_LONG(pGraphicsArr[i].bAllowModifySize, val, xmlGraphics);
	
		CHECK_SUCCESS(xmlGraphics.AddElem("ArrowType"));
		SET_ELEMENT_LONG(pGraphicsArr[i].ulArrowType, val, xmlGraphics);

		CHECK_SUCCESS(xmlGraphics.AddElem("KeepHorizon"));
		SET_ELEMENT_LONG(pGraphicsArr[i].bKeepHorizon, val, xmlGraphics);

		xmlGraphics.OutOfElem();
	}
	xmlGraphics.OutOfElem();

	xmlGraphics.OutOfElem();
	return IVS_SUCCEED;

}
// 解析画图前图形属性设置XML
IVS_INT32 COCXDrawXMLProcess::DrawGraphicsPraseXML(IA_GRAPHICS &GraphicAttribute, ULONG &ulGroupDrawMaxNum, LPCTSTR pGraphicsXml)
{
	CHECK_POINTER(pGraphicsXml, IVS_OPERATE_MEMORY_ERROR);
	IVS_DEBUG_TRACE("GroupDrawMaxNum: %lu, GraphicsXml: %s", ulGroupDrawMaxNum, pGraphicsXml);

	CXml xml;
	if (!xml.Parse(pGraphicsXml))
	{
		return IVS_FAIL;
	}

	CHECK_SUCCESS(xml.FindElem("Content"));
	CHECK_SUCCESS(xml.IntoElem());
	CHECK_SUCCESS(xml.FindElem("Graphics"));
	CHECK_SUCCESS(xml.IntoElem());

	const char *value = NULL;

	CHECK_SUCCESS(xml.FindElem("GraphicNum") && (NULL != (value = xml.GetElemValue())));
	ulGroupDrawMaxNum = (ULONG)atoi(value);

	// 若设置的图形数大于图形数组长度,截断到最大画图个数
	if (ulGroupDrawMaxNum > GRAPHICS_NUM_MAX)
	{
		BP_RUN_LOG_INF("COCXDrawXMLProcess::DrawGraphicsPraseXML", "GroupDrawMaxNum Truncated to GRAPHICS_NUM_MAX");
		ulGroupDrawMaxNum = GRAPHICS_NUM_MAX;
	}

	CHECK_SUCCESS(xml.FindElem("GraphicList"));
	CHECK_SUCCESS(xml.IntoElem());

	// 给图形可选字段赋默认值
	memset(&GraphicAttribute, 0, sizeof(IA_GRAPHICS));
	GraphicAttribute.ulLineWidth = 3; // 默认基本线宽为3
	GraphicAttribute.bAllowDelete = TRUE; // 允许删除
	GraphicAttribute.bAllowModifySize = TRUE; // 允许修改矩形大小

	CHECK_SUCCESS(xml.FindElem("GraphicInfo"));
	CHECK_SUCCESS(xml.IntoElem());
	CHECK_SUCCESS(xml.FindElem("GraphicType") && (NULL != (value = xml.GetElemValue())));
	GraphicAttribute.ulGraphicType = (ULONG)atoi(value);

	GET_ELEMENT_ULONG(GraphicAttribute.ulGraphicGroup, GraphicGroup, xml);
	GET_ELEMENT_STRING(GraphicAttribute.GraphicGroupName, CHARACTER_NUM_MAX, GraphicGroupName, xml);

	if (xml.FindElem("GraphicBackgroundColor"))
	{
		CHECK_SUCCESS(xml.IntoElem());
		GET_ELEMENT_UCHAR(GraphicAttribute.BgColor.Alpha, Opacity, xml);
		GET_ELEMENT_UCHAR(GraphicAttribute.BgColor.Red, Red, xml);
		GET_ELEMENT_UCHAR(GraphicAttribute.BgColor.Green, Green, xml);
		GET_ELEMENT_UCHAR(GraphicAttribute.BgColor.Blue, Blue, xml);
		xml.OutOfElem();
	}

	if (xml.FindElem("GraphicLineColor"))
	{
		CHECK_SUCCESS(xml.IntoElem());
		GET_ELEMENT_UCHAR(GraphicAttribute.LineColor.Alpha, Opacity, xml);
		GET_ELEMENT_UCHAR(GraphicAttribute.LineColor.Red, Red, xml);
		GET_ELEMENT_UCHAR(GraphicAttribute.LineColor.Green, Green, xml);
		GET_ELEMENT_UCHAR(GraphicAttribute.LineColor.Blue, Blue, xml);
		xml.OutOfElem();
	}

	GET_ELEMENT_ULONG(GraphicAttribute.ulLineWidth, GraphicLineWidth, xml);

	GET_ELEMENT_ULONG(GraphicAttribute.NamePosition, NamePosition, xml);
	GET_ELEMENT_BOOL(GraphicAttribute.bAllowDelete, DeleteByMouse, xml);
	GET_ELEMENT_BOOL(GraphicAttribute.bAllowAddNewPoint, AddNewPoint, xml);
	GET_ELEMENT_BOOL(GraphicAttribute.bAllowModifySize, AllowModifySize, xml);
	GET_ELEMENT_ULONG(GraphicAttribute.ulArrowType, ArrowType, xml);
	GET_ELEMENT_BOOL(GraphicAttribute.bKeepHorizon, KeepHorizon, xml);

	xml.OutOfElem();
	xml.OutOfElem();
	xml.OutOfElem();

	return IVS_SUCCEED;

}
示例#13
0
文件: Mifare.c 项目: Schoberm/nxppy
static phStatus_t LoadProfile(void)
{
    phStatus_t status = PH_ERR_SUCCESS;

    sDiscLoop.pPal1443p3aDataParams = &spalI14443p3a;
    sDiscLoop.pPal1443p3bDataParams = &spalI14443p3b;
    sDiscLoop.pPal1443p4aDataParams = &spalI14443p4a;
    sDiscLoop.pPal14443p4DataParams = &spalI14443p4;
    sDiscLoop.pHalDataParams = &sHal_Nfc_Ic.sHal;

    /*
     * These lines are added just to SIGSEG fault when non 14443-3 card is detected 
     */
    /*
     * Assign the GI for Type A 
     */
    sDiscLoop.sTypeATargetInfo.sTypeA_P2P.pGi = (uint8_t *) GI;
    sDiscLoop.sTypeATargetInfo.sTypeA_P2P.bGiLength = sizeof(GI);
    /*
     * Assign the GI for Type F 
     */
    sDiscLoop.sTypeFTargetInfo.sTypeF_P2P.pGi = (uint8_t *) GI;
    sDiscLoop.sTypeFTargetInfo.sTypeF_P2P.bGiLength = sizeof(GI);
    /*
     * Assign ATR response for Type A 
     */
    sDiscLoop.sTypeATargetInfo.sTypeA_P2P.pAtrRes = aData;
    /*
     * Assign ATR response for Type F 
     */
    sDiscLoop.sTypeFTargetInfo.sTypeF_P2P.pAtrRes = aData;
    /*
     * Assign ATS buffer for Type A 
     */
    sDiscLoop.sTypeATargetInfo.sTypeA_I3P4.pAts = aData;
    /*
     ******************************************************************************************** */

    /*
     * Passive Bailout bitmap configuration 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_BAIL_OUT, PH_OFF);
    CHECK_STATUS(status);

    /*
     * Passive poll bitmap configuration. Poll for only Type A Tags. 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_PAS_POLL_TECH_CFG, PHAC_DISCLOOP_POS_BIT_MASK_A);
    CHECK_STATUS(status);

    /*
     * Turn OFF Passive Listen. 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_PAS_LIS_TECH_CFG, PH_OFF);
    CHECK_STATUS(status);

    /*
     * Turn OFF active listen. 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_ACT_LIS_TECH_CFG, PH_OFF);
    CHECK_STATUS(status);

    /*
     * Turn OFF Active Poll 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_ACT_POLL_TECH_CFG, PH_OFF);
    CHECK_STATUS(status);

    /*
     * Disable LPCD feature. 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_ENABLE_LPCD, PH_OFF);
    CHECK_STATUS(status);

    /*
     * reset collision Pending 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_COLLISION_PENDING, PH_OFF);
    CHECK_STATUS(status);

    /*
     * whether anti-collision is supported or not. 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_ANTI_COLL, PH_ON);
    CHECK_STATUS(status);

    /*
     * Device limit for Type A 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_TYPEA_DEVICE_LIMIT, PH_ON);
    CHECK_STATUS(status);

    /*
     * Discovery loop Operation mode 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_OPE_MODE, RD_LIB_MODE_NFC);

    /*
     * Bailout on Type A detect 
     */
    status = phacDiscLoop_SetConfig(&sDiscLoop, PHAC_DISCLOOP_CONFIG_BAIL_OUT, PHAC_DISCLOOP_POS_BIT_MASK_A);
    CHECK_SUCCESS(status);

    /*
     * Return Status 
     */
    return status;
}
示例#14
0
文件: Mifare.c 项目: Schoberm/nxppy
phStatus_t NfcRdLibInit(void)
{

    phStatus_t status;

    /*
     * Initialize the Reader BAL (Bus Abstraction Layer) component 
     */
    status = phbalReg_Stub_Init(&sBalReader, sizeof(phbalReg_Stub_DataParams_t));
    CHECK_SUCCESS(status);

    /*
     * Initialize the OSAL Events. 
     */
    status = phOsal_Event_Init();
    CHECK_STATUS(status);

    // Start interrupt thread
    Set_Interrupt();

    /*
     * Set HAL type in BAL 
     */
#ifdef NXPBUILD__PHHAL_HW_PN5180
    status = phbalReg_SetConfig(&sBalReader, PHBAL_REG_CONFIG_HAL_HW_TYPE, PHBAL_REG_HAL_HW_PN5180);
#endif
#ifdef NXPBUILD__PHHAL_HW_RC523
    status = phbalReg_SetConfig(&sBalReader, PHBAL_REG_CONFIG_HAL_HW_TYPE, PHBAL_REG_HAL_HW_RC523);
#endif
#ifdef NXPBUILD__PHHAL_HW_RC663
    status = phbalReg_SetConfig(&sBalReader, PHBAL_REG_CONFIG_HAL_HW_TYPE, PHBAL_REG_HAL_HW_RC663);
#endif
    CHECK_STATUS(status);

    status = phbalReg_SetPort(&sBalReader, (uint8_t *) SPI_CONFIG);
    CHECK_STATUS(status);

    /*
     * Open BAL 
     */
    status = phbalReg_OpenPort(&sBalReader);
    CHECK_STATUS(status);

    /*
     * Initialize the Reader HAL (Hardware Abstraction Layer) component 
     */
    status = phhalHw_Nfc_IC_Init(&sHal_Nfc_Ic,
                                 sizeof(phhalHw_Nfc_Ic_DataParams_t),
                                 &sBalReader,
                                 0, bHalBufferTx, sizeof(bHalBufferTx), bHalBufferRx, sizeof(bHalBufferRx));
    CHECK_SUCCESS(status);

    /*
     * Set the parameter to use the SPI interface 
     */
    sHal_Nfc_Ic.sHal.bBalConnectionType = PHHAL_HW_BAL_CONNECTION_SPI;

    Configure_Device(&sHal_Nfc_Ic);

    /*
     * Set the generic pointer 
     */
    pHal = &sHal_Nfc_Ic.sHal;

    /*
     * Initializing specific objects for the communication with MIFARE (R) Classic cards. The MIFARE (R) Classic card
     * is compliant of ISO 14443-3 and ISO 14443-4 
     */

    /*
     * Initialize the I14443-A PAL layer 
     */
    status = phpalI14443p3a_Sw_Init(&spalI14443p3a, sizeof(phpalI14443p3a_Sw_DataParams_t), &sHal_Nfc_Ic.sHal);
    CHECK_STATUS(status);

    /*
     * Initialize the I14443-A PAL component 
     */
    status = phpalI14443p4a_Sw_Init(&spalI14443p4a, sizeof(phpalI14443p4a_Sw_DataParams_t), &sHal_Nfc_Ic.sHal);
    CHECK_STATUS(status);

    /*
     * Initialize the I14443-4 PAL component 
     */
    status = phpalI14443p4_Sw_Init(&spalI14443p4, sizeof(phpalI14443p4_Sw_DataParams_t), &sHal_Nfc_Ic.sHal);
    CHECK_STATUS(status);

    /*
     * Initialize the I14443-B PAL component 
     */
    status = phpalI14443p3b_Sw_Init(&spalI14443p3b, sizeof(phpalI14443p3b_Sw_DataParams_t), &sHal_Nfc_Ic.sHal);
    CHECK_STATUS(status);

    /*
     * Initialize the MIFARE PAL component 
     */
    status = phpalMifare_Sw_Init(&spalMifare, sizeof(phpalMifare_Sw_DataParams_t), &sHal_Nfc_Ic.sHal, NULL);
    CHECK_STATUS(status);

    /*
     * Initialize the discover component 
     */
    status = phacDiscLoop_Sw_Init(&sDiscLoop, sizeof(phacDiscLoop_Sw_DataParams_t), &sHal_Nfc_Ic.sHal);
    CHECK_SUCCESS(status);

    /*
     * Load profile for Discovery loop 
     */
    LoadProfile();

    status = phalMfc_Sw_Init(&salMfc, sizeof(phalMfc_Sw_DataParams_t), &spalMifare, NULL);
    CHECK_STATUS(status);

    /*
     * Read the version of the reader IC 
     */
#if defined NXPBUILD__PHHAL_HW_RC523
    status = phhalHw_Rc523_ReadRegister(&sHal_Nfc_Ic.sHal, PHHAL_HW_RC523_REG_VERSION, &bDataBuffer[0]);
    CHECK_SUCCESS(status);
#endif
#if defined NXPBUILD__PHHAL_HW_RC663
    status = phhalHw_Rc663_ReadRegister(&sHal_Nfc_Ic.sHal, PHHAL_HW_RC663_REG_VERSION, &bDataBuffer[0]);
    CHECK_SUCCESS(status);
#endif

    /*
     * Return Success 
     */
    return PH_ERR_SUCCESS;
}
示例#15
0
cellular_result_t  cellular_register(void* reserved)
{
    CHECK_SUCCESS(electronMDM.registerNet());
    return 0;
}
示例#16
0
cellular_result_t  cellular_off(void* reserved)
{
    CHECK_SUCCESS(electronMDM.powerOff());
    return 0;
}
示例#17
0
cellular_result_t  cellular_init(void* reserved)
{
    CHECK_SUCCESS(electronMDM.init());
    return 0;
}
示例#18
0
cellular_result_t cellular_band_available_get(MDM_BandSelect* bands, void* reserved)
{
    CHECK_SUCCESS(electronMDM.getBandAvailable(*bands));
    return 0;
}
示例#19
0
cellular_result_t cellular_band_select_set(MDM_BandSelect* bands, void* reserved)
{
    CHECK_SUCCESS(electronMDM.setBandSelect(*bands));
    return 0;
}
示例#20
0
cellular_result_t  cellular_gprs_detach(void* reserved)
{
    CHECK_SUCCESS(electronMDM.detach());
    HAL_NET_notify_disconnected();
    return 0;
}
IVS_INT32 CMediaXMLProcess::GetURLResponseData(CXml &xmlRsp, ST_MEDIA_RSP& stMediaRsp, bool& bAssociatedAudio)
{
	IVS_DEBUG_TRACE("");

	memset(&stMediaRsp, 0, sizeof(ST_MEDIA_RSP));
	const char*AttriValue = NULL;   //临时存储单个节点值
	bool bRet = false;

	CHECK_SUCCESS(xmlRsp.FindElem("Content"));
	CHECK_SUCCESS(xmlRsp.IntoElem());


	CHECK_SUCCESS(xmlRsp.FindElem("URL"));
	CHECK_SUCCESS(NULL != (AttriValue = xmlRsp.GetElemValue()));
	bRet = CToolsHelp::Memcpy(stMediaRsp.szURL, URL_LEN, AttriValue, strlen(AttriValue));
	if(!bRet)
	{
		BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Memcpy error.");
		return IVS_ALLOC_MEMORY_ERROR;
	}

	if (xmlRsp.FindElem("AssociatedAudio"))
	{
		CHECK_SUCCESS(NULL != (AttriValue = xmlRsp.GetElemValue()));
		bAssociatedAudio = (bool)atoi(AttriValue);	
	}

	CHECK_SUCCESS(xmlRsp.FindElem("RtspIP"));
	CHECK_SUCCESS(NULL != (AttriValue = xmlRsp.GetElemValue()));
	bRet = CToolsHelp::Memcpy(stMediaRsp.szRTSPIP, IVS_IP_LEN, AttriValue, strlen(AttriValue));
	if(!bRet)
	{
		BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Memcpy error.");
		return IVS_ALLOC_MEMORY_ERROR;
	}

	CHECK_SUCCESS(xmlRsp.FindElem("RtspPort"));
	CHECK_SUCCESS(NULL != (AttriValue = xmlRsp.GetElemValue()));
	bRet = CToolsHelp::Memcpy(stMediaRsp.szRTSPPORT, PORT_LEN, AttriValue, strlen(AttriValue));
	if(!bRet)
	{
		BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Memcpy error.");
		return IVS_ALLOC_MEMORY_ERROR;
	}

	//add by zwx211831, Date:20140625, 在URL中添加UserID和DomainID,以实现查询点播业务。
	//如果是旧的版本,则不变。
	if (xmlRsp.FindElem("UserId") && xmlRsp.FindElem("DomainId"))
	{
		(void)xmlRsp.FindElem("DomainId");
		CHECK_SUCCESS(NULL != (AttriValue = xmlRsp.GetElemValue()));
		std::string strDomainCode("DomainCode=");
		strDomainCode += AttriValue;
		strDomainCode += "&";
		if(!CToolsHelp::Strncat(stMediaRsp.szURL, URL_LEN, strDomainCode.c_str()))
		{
			BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Strncat error.");
			return IVS_ALLOC_MEMORY_ERROR;
		}

		(void)xmlRsp.FindElem("UserId");
		CHECK_SUCCESS(NULL != (AttriValue = xmlRsp.GetElemValue()));
		IVS_UINT32 uiUserID = 0;
		std::string strUserID("UserId=");
		GET_ELEM_VALUE_NUM_FOR_UINT("UserId", AttriValue, uiUserID, xmlRsp);
		strUserID += CToolsHelp::Int2Str(uiUserID);
		strUserID += "&";
		if(!CToolsHelp::Strncat(stMediaRsp.szURL, URL_LEN, strUserID.c_str()))
		{
			BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Strncat error.");
			return IVS_ALLOC_MEMORY_ERROR;
		}
	}

	xmlRsp.OutOfElem();

	return IVS_SUCCEED;


#if 0  //XML增加AssociatedAudio字段

	(void)xmlRsp.GetElem();    // Content
	(void)xmlRsp.IntoElem();
	(void)xmlRsp.GetElem();     // URL
	AttriValue=xmlRsp.GetElemValue(); 
	if(AttriValue == NULL)
	{
		BP_RUN_LOG_INF("Get URL Response Data", "URL is  null");
		return IVS_SDK_RET_SMU_SDK_XML_INVALD;
	}
	bool bRet = CToolsHelp::Memcpy(stMediaRsp.szURL,URL_LEN, AttriValue, strlen(AttriValue));
	if(false == bRet)
	{
		BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Memcpy error.");
		return IVS_ALLOC_MEMORY_ERROR;
	}

	(void)xmlRsp.NextElem();               // RtspIP
	(void)xmlRsp.GetElem();
	AttriValue = xmlRsp.GetElemValue();
	if(AttriValue == NULL)
	{
		BP_RUN_LOG_INF("Get URL Response Data", "RtspIP is null");
		return IVS_SDK_RET_SMU_SDK_XML_INVALD;
	}
	bRet = CToolsHelp::Memcpy(stMediaRsp.szRTSPIP,IVS_IP_LEN, AttriValue, strlen(AttriValue));
	if(false == bRet)
	{
		BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Memcpy error.");
		return IVS_ALLOC_MEMORY_ERROR;
	}

	(void)xmlRsp.NextElem();               // RtspPort
	(void)xmlRsp.GetElem();
	AttriValue = xmlRsp.GetElemValue();
	if(AttriValue == NULL)
	{
		BP_RUN_LOG_INF("Get URL Response Data", "RtspPort is null");
		return IVS_SDK_RET_SMU_SDK_XML_INVALD;
	}
	bRet = CToolsHelp::Memcpy(stMediaRsp.szRTSPPORT,PORT_LEN, AttriValue, strlen(AttriValue));
	if(false == bRet)
	{
		BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get URL Response Data", "Memcpy error.");
		return IVS_ALLOC_MEMORY_ERROR;
	}

	return IVS_SUCCEED;
#endif
}