public static void UpdateManifest(string fullPath) {
_document = new XmlDocument();
_document.Load(fullPath);
if (_document == null)
{
Debug.LogError("Couldn't load " + fullPath);
return;
}
_manifestNode = FindChildNode(_document, "manifest");
_namespace = _manifestNode.GetNamespaceOfPrefix("android");
_applicationNode = FindChildNode(_manifestNode, "application");
if (_applicationNode == null) {
Debug.LogError("Error parsing " + fullPath);
return;
}
SetPermission("android.permission.INTERNET");
XmlElement applicationElement = FindChildElement(_manifestNode, "application");
applicationElement.SetAttribute("name", _namespace, "com.soomla.SoomlaApp");
foreach(ISoomlaManifestTools manifestTool in ManTools) {
manifestTool.UpdateManifest();
}
_document.Save(fullPath);
}
/// <summary>
/// 添加节点属性
/// </summary>
/// <param name="xDoc">XmlDocument对象</param>
/// <param name="node">节点对象</param>
/// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
/// <param name="attributeName">新属性名称</param>
/// <param name="attributeValue">属性值</param>
public static void AddAttribute(XmlDocument xDoc, XmlNode node, string namespaceOfPrefix, string attributeName, string attributeValue)
{
string ns = namespaceOfPrefix == null ? null : node.GetNamespaceOfPrefix(namespaceOfPrefix);
XmlNode xn = xDoc.CreateNode(XmlNodeType.Attribute, attributeName, ns == "" ? null : ns);
xn.Value = attributeValue;
node.Attributes.SetNamedItem(xn);
}
private static void LoadManifest(){
_document = new XmlDocument();
_document.Load(outputFile);
if (_document == null)
{
Debug.LogError("Couldn't load " + outputFile);
return;
}
_manifestNode = FindChildNode(_document, "manifest");
_namespace = _manifestNode.GetNamespaceOfPrefix("android");
_applicationNode = FindChildNode(_manifestNode, "application");
if (_applicationNode == null) {
Debug.LogError("Error parsing " + outputFile);
return;
}
}
private static void FindTargetSchemaNode(XmlNode document, XmlNamespaceManager xmlNamespaceManager, XmlNode node, XmlNode thisSchemaNode, string rawTypeName, out XmlNode targetSchemaNode, out TypeReference typeReference)
{
string[] typeParts = rawTypeName.Split(':');
string typeName;
string typeTargetNamespace;
if (typeParts.Length == 2)
{
typeTargetNamespace = node.GetNamespaceOfPrefix(typeParts[0]);
typeName = typeParts[1];
XmlNodeList targetSchemaNodes = document.SelectNodes(".//xs:schema[@targetNamespace='" + typeTargetNamespace + "']", xmlNamespaceManager);
targetSchemaNode = targetSchemaNodes[0];
}
else if (typeParts.Length == 1)
{
typeTargetNamespace = thisSchemaNode.Attributes.GetNamedItem("targetNamespace").Value;
typeName = typeParts[0];
targetSchemaNode = thisSchemaNode;
}
else
{
throw new InvalidOperationException("Could not find target schema node for type " + rawTypeName + ".");
}
typeReference = new TypeReference(typeTargetNamespace, typeName);
}
public static string FindUnusedPrefix(XmlNode node, string prefixHint)
{
string pp = prefixHint;
if (prefixHint == null || prefixHint.Length == 0)
pp = "n";
else
{
string uri = node.GetNamespaceOfPrefix(pp);
if (uri == null || uri.Length == 0)
return pp;
}
int n = 1;
while (true)
{
string s = string.Format(pp+"{0}", n++);
string uri = node.GetNamespaceOfPrefix(s);
if (uri == null || uri.Length == 0)
return s;
}
}
public static Altova.Types.QName CastToQName(XmlNode node, MemberInfo member)
{
int i = node.InnerText.IndexOf(":");
if (i == -1)
return new Altova.Types.QName(node.GetNamespaceOfPrefix(""), node.InnerText);
string prefix = node.InnerText.Substring(0, i);
string local = node.InnerText.Substring(i + 1);
string uri = node.GetNamespaceOfPrefix(prefix);
return new Altova.Types.QName(uri, prefix, local);
}
// Namespace Axis
// Consider a list L containing only namespace nodes in the
// axis and in the node-set in lexicographic order (ascending). To begin
// processing L, if the first node is not the default namespace node (a node
// with no namespace URI and no local name), then generate a space followed
// by xmlns="" if and only if the following conditions are met:
// - the element E that owns the axis is in the node-set
// - The nearest ancestor element of E in the node-set has a default
// namespace node in the node-set (default namespace nodes always
// have non-empty values in XPath)
// The latter condition eliminates unnecessary occurrences of xmlns="" in
// the canonical form since an element only receives an xmlns="" if its
// default namespace is empty and if it has an immediate parent in the
// canonical form that has a non-empty default namespace. To finish
// processing L, simply process every namespace node in L, except omit
// namespace node with local name xml, which defines the xml prefix,
// if its string value is http://www.w3.org/XML/1998/namespace.
private void WriteNamespacesAxis (XmlNode node, bool visible)
{
// Console.WriteLine ("Debug: namespaces");
XmlDocument doc = node.OwnerDocument;
bool has_empty_namespace = false;
ArrayList list = new ArrayList ();
for (XmlNode cur = node; cur != null && cur != doc; cur = cur.ParentNode) {
foreach (XmlNode attribute in cur.Attributes) {
if (!IsNamespaceNode (attribute))
continue;
// get namespace prefix
string prefix = string.Empty;
if (attribute.Prefix == "xmlns")
prefix = attribute.LocalName;
// check if it is "xml" namespace
if (prefix == "xml" && attribute.Value == "http://www.w3.org/XML/1998/namespace")
continue;
// make sure that this is an active namespace
// for our node
string ns = node.GetNamespaceOfPrefix (prefix);
if (ns != attribute.Value)
continue;
// check that it is selected with XPath
if (!IsNodeVisible (attribute))
continue;
// check that we have not rendered it yet
bool rendered = IsNamespaceRendered (prefix, attribute.Value);
// add to the visible namespaces stack
if (visible)
visibleNamespaces.Add (attribute);
if (!rendered)
list.Add (attribute);
if (prefix == string.Empty)
has_empty_namespace = true;
}
}
// add empty namespace if needed
if (visible && !has_empty_namespace && !IsNamespaceRendered (string.Empty, string.Empty))
res.Append (" xmlns=\"\"");
list.Sort (new XmlDsigC14NTransformNamespacesComparer ());
foreach (object obj in list) {
XmlNode attribute = (obj as XmlNode);
if (attribute != null) {
res.Append (" ");
res.Append (attribute.Name);
res.Append ("=\"");
res.Append (attribute.Value);
res.Append ("\"");
}
}
// move the rendered namespaces stack
if (visible) {
prevVisibleNamespacesStart = prevVisibleNamespacesEnd;
prevVisibleNamespacesEnd = visibleNamespaces.Count;
}
}
private static bool TryFindElementWithAndroidName(
XmlNode parent,
string attrNameValue,
out XmlElement element,
string elementType = "activity")
{
string ns = parent.GetNamespaceOfPrefix("android");
var curr = parent.FirstChild;
while (curr != null)
{
var currXmlElement = curr as XmlElement;
if (currXmlElement != null &&
currXmlElement.Name == elementType &&
currXmlElement.GetAttribute("name", ns) == attrNameValue)
{
element = currXmlElement;
return true;
}
curr = curr.NextSibling;
}
element = null;
return false;
}
/// <summary>
/// 添加节点属性
/// </summary>
/// <param name="xDoc">XmlDocument对象</param>
/// <param name="node">节点对象</param>
/// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
/// <param name="attps">节点属性参数</param>
public static void AddAttribute(XmlDocument xDoc, XmlNode node, string namespaceOfPrefix, params AttributeParameter[] attps)
{
string ns = namespaceOfPrefix == null ? null : node.GetNamespaceOfPrefix(namespaceOfPrefix);
foreach (AttributeParameter attp in attps)
{
XmlNode xn = xDoc.CreateNode(XmlNodeType.Attribute, attp.Name, ns == "" ? null : ns);
xn.Value = attp.Value;
node.Attributes.SetNamedItem(xn);
}
}
void GetTypeQualifiedName (XmlNode node, string qualifiedName, out string name, out string ns)
{
int i = qualifiedName.IndexOf (':');
if (i == -1)
{
name = qualifiedName;
ns = "";
return;
}
string prefix = qualifiedName.Substring (0,i);
name = qualifiedName.Substring (i+1);
ns = node.GetNamespaceOfPrefix (prefix);
string arrayType = GetArrayType (node, name, ns);
if (arrayType != null) {
name = arrayType;
ns = "";
}
else if (ns != MetaData.SchemaNamespace) {
ns = DecodeNamespace (ns);
}
else {
ns = "";
name = GetClrFromXsd (name);
}
}
public static XmlName ParseName(XmlNode context, string name, XmlNodeType nt)
{
XmlName result = new XmlName();
XmlConvert.VerifyName(name);
int i = name.IndexOf(':');
if (i>0){
string prefix = result.Prefix = name.Substring(0,i);
result.LocalName = name.Substring(i + 1);
if (prefix == "xml") {
result.NamespaceUri = XmlUri;
} else if (prefix == "xmlns") {
result.NamespaceUri = XmlnsUri;
} else {
result.NamespaceUri = context.GetNamespaceOfPrefix(prefix);
}
} else {
result.Prefix = "";
result.LocalName = name;
if (name == "xmlns") {
result.NamespaceUri = XmlnsUri;
} else if (nt == XmlNodeType.Attribute) {
result.NamespaceUri = ""; // non-prefixed attributes are empty namespace by definition
} else {
result.NamespaceUri = context.GetNamespaceOfPrefix("");
}
}
return result;
}
/// <summary>
/// ����ָ���ڵ���ָ�����Ե�ֵ
/// </summary>
/// <param name="clsXmlNode">XML�ڵ�</param>
/// <param name="szPrefix">���Ե�ǰ</param>
/// <param name="szAttrName">������</param>
/// <param name="szAttrValue">����ֵ</param>
/// <returns>bool</returns>
public static bool SetXmlAttrValue(XmlNode clsXmlNode, string szPrefix, string szAttrName, string szAttrValue)
{
if (clsXmlNode == null)
return false;
XmlDocument clsXmlDoc = clsXmlNode.OwnerDocument;
if (clsXmlDoc == null)
return false;
if (szAttrName == null || szAttrName.Trim() == "")
return false;
if (szAttrValue == null)
szAttrValue = string.Empty;
try
{
XmlAttribute clsAttrNode = clsXmlNode.Attributes.GetNamedItem(szAttrName) as XmlAttribute;
if (clsAttrNode == null)
{
string szNamespaceUri = null;
if (szPrefix == "xmlns")
szNamespaceUri = "http://www.w3.org/2000/xmlns/";
else if (!GlobalMethods.Misc.IsEmptyString(szPrefix))
szNamespaceUri = clsXmlNode.GetNamespaceOfPrefix(szPrefix);
clsAttrNode = clsXmlDoc.CreateAttribute(szPrefix, szAttrName, szNamespaceUri);
clsXmlNode.Attributes.Append(clsAttrNode);
}
clsAttrNode.InnerText = szAttrValue;
return true;
}
catch (Exception ex)
{
LogManager.Instance.WriteLog("GlobalMethods.SetXmlAttrValue"
, new string[] { "clsXmlNode", "szPrefix", "szAttrName", "szAttrValue" }
, new object[] { clsXmlNode, szPrefix, szAttrName, szAttrValue }, "������XML�ڵ������ֵ!", ex);
return false;
}
}
